drivers/net/dpaa2/mc/fsl_dpni.h

   1 /*-
   2  * This file is provided under a dual BSD/GPLv2 license. When using or
   3  * redistributing this file, you may do so under either license.
   4  *
   5  *   BSD LICENSE
   6  *
   7  * Copyright 2013-2016 Freescale Semiconductor Inc.
   8  * Copyright (c) 2016 NXP.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions are met:
  12  * * Redistributions of source code must retain the above copyright
  13  * notice, this list of conditions and the following disclaimer.
  14  * * Redistributions in binary form must reproduce the above copyright
  15  * notice, this list of conditions and the following disclaimer in the
  16  * documentation and/or other materials provided with the distribution.
  17  * * Neither the name of the above-listed copyright holders nor the
  18  * names of any contributors may be used to endorse or promote products
  19  * derived from this software without specific prior written permission.
  20  *
  21  *   GPL LICENSE SUMMARY
  22  *
  23  * ALTERNATIVELY, this software may be distributed under the terms of the
  24  * GNU General Public License ("GPL") as published by the Free Software
  25  * Foundation, either version 2 of that License or (at your option) any
  26  * later version.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  29  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  31  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
  32  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  36  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  38  * POSSIBILITY OF SUCH DAMAGE.
  39  */
  40 #ifndef __FSL_DPNI_H
  41 #define __FSL_DPNI_H
  42
  43 #include <fsl_dpkg.h>
  44
  45 struct fsl_mc_io;
  46
  47 /**
  48  * Data Path Network Interface API
  49  * Contains initialization APIs and runtime control APIs for DPNI
  50  */
  51
  52 /** General DPNI macros */
  53
  54 /**
  55  * Maximum number of traffic classes
  56  */
  57 #define DPNI_MAX_TC                             8
  58 /**
  59  * Maximum number of buffer pools per DPNI
  60  */
  61 #define DPNI_MAX_DPBP                           8
  62 /**
  63  * Maximum number of storage-profiles per DPNI
  64  */
  65 #define DPNI_MAX_SP                             2
  66
  67 /**
  68  * All traffic classes considered; see dpni_set_queue()
  69  */
  70 #define DPNI_ALL_TCS                            (uint8_t)(-1)
  71 /**
  72  * All flows within traffic class considered; see dpni_set_queue()
  73  */
  74 #define DPNI_ALL_TC_FLOWS                       (uint16_t)(-1)
  75
  76 /**
  77  * Tx traffic is always released to a buffer pool on transmit, there are no
  78  * resources allocated to have the frames confirmed back to the source after
  79  * transmission.
  80  */
  81 #define DPNI_OPT_TX_FRM_RELEASE                 0x000001
  82 /**
  83  * Disables support for MAC address filtering for addresses other than primary
  84  * MAC address. This affects both unicast and multicast. Promiscuous mode can
  85  * still be enabled/disabled for both unicast and multicast. If promiscuous mode
  86  * is disabled, only traffic matching the primary MAC address will be accepted.
  87  */
  88 #define DPNI_OPT_NO_MAC_FILTER                  0x000002
  89 /**
  90  * Allocate policers for this DPNI. They can be used to rate-limit traffic per
  91  * traffic class (TC) basis.
  92  */
  93 #define DPNI_OPT_HAS_POLICING                   0x000004
  94 /**
  95  * Congestion can be managed in several ways, allowing the buffer pool to
  96  * deplete on ingress, taildrop on each queue or use congestion groups for sets
  97  * of queues. If set, it configures a single congestion groups across all TCs.
  98  * If reset, a congestion group is allocated for each TC. Only relevant if the
  99  * DPNI has multiple traffic classes.
 100  */
 101 #define DPNI_OPT_SHARED_CONGESTION              0x000008
 102 /**
 103  * Enables TCAM for Flow Steering and QoS look-ups. If not specified, all
 104  * look-ups are exact match. Note that TCAM is not available on LS1088 and its
 105  * variants. Setting this bit on these SoCs will trigger an error.
 106  */
 107 #define DPNI_OPT_HAS_KEY_MASKING                0x000010
 108 /**
 109  * Disables the flow steering table.
 110  */
 111 #define DPNI_OPT_NO_FS                          0x000020
 112
 113 /**
 114  * dpni_open() - Open a control session for the specified object
 115  * @mc_io:      Pointer to MC portal's I/O object
 116  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 117  * @dpni_id:    DPNI unique ID
 118  * @token:      Returned token; use in subsequent API calls
 119  *
 120  * This function can be used to open a control session for an
 121  * already created object; an object may have been declared in
 122  * the DPL or by calling the dpni_create() function.
 123  * This function returns a unique authentication token,
 124  * associated with the specific object ID and the specific MC
 125  * portal; this token must be used in all subsequent commands for
 126  * this specific object.
 127  *
 128  * Return:      '0' on Success; Error code otherwise.
 129  */
 130 int dpni_open(struct fsl_mc_io  *mc_io,
 131               uint32_t          cmd_flags,
 132               int               dpni_id,
 133               uint16_t          *token);
 134
 135 /**
 136  * dpni_close() - Close the control session of the object
 137  * @mc_io:      Pointer to MC portal's I/O object
 138  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 139  * @token:      Token of DPNI object
 140  *
 141  * After this function is called, no further operations are
 142  * allowed on the object without opening a new control session.
 143  *
 144  * Return:      '0' on Success; Error code otherwise.
 145  */
 146 int dpni_close(struct fsl_mc_io *mc_io,
 147                uint32_t         cmd_flags,
 148                uint16_t         token);
 149
 150 /**
 151  * struct dpni_cfg - Structure representing DPNI configuration
 152  * @mac_addr: Primary MAC address
 153  * @adv: Advanced parameters; default is all zeros;
 154  *              use this structure to change default settings
 155  */
 156 struct dpni_cfg {
 157         /**
 158          * @options: Any combination of the following options:
 159          *              DPNI_OPT_TX_FRM_RELEASE
 160          *              DPNI_OPT_NO_MAC_FILTER
 161          *              DPNI_OPT_HAS_POLICING
 162          *              DPNI_OPT_SHARED_CONGESTION
 163          *              DPNI_OPT_HAS_KEY_MASKING
 164          *              DPNI_OPT_NO_FS
 165          * @fs_entries: Number of entries in the flow steering table.
 166          *              This table is used to select the ingress queue for
 167          *              ingress traffic, targeting a GPP core or another.
 168          *              In addition it can be used to discard traffic that
 169          *              matches the set rule. It is either an exact match table
 170          *              or a TCAM table, depending on DPNI_OPT_ HAS_KEY_MASKING
 171          *              bit in OPTIONS field. This field is ignored if
 172          *              DPNI_OPT_NO_FS bit is set in OPTIONS field. Otherwise,
 173          *              value 0 defaults to 64. Maximum supported value is 1024.
 174          *              Note that the total number of entries is limited on the
 175          *              SoC to as low as 512 entries if TCAM is used.
 176          * @vlan_filter_entries: Number of entries in the VLAN address filtering
 177          *              table. This is an exact match table used to filter
 178          *              ingress traffic based on VLAN IDs. Value 0 disables VLAN
 179          *              filtering. Maximum supported value is 16.
 180          * @mac_filter_entries: Number of entries in the MAC address filtering
 181          *              table. This is an exact match table and allows both
 182          *              unicast and multicast entries. The primary MAC address
 183          *              of the network interface is not part of this table,
 184          *              this contains only entries in addition to it. This
 185          *              field is ignored if DPNI_OPT_ NO_MAC_FILTER is set in
 186          *              OPTIONS field. Otherwise, value 0 defaults to 80.
 187          *              Maximum supported value is 80.
 188          * @num_queues: Number of Tx and Rx queues used for traffic
 189          *              distribution. This is orthogonal to QoS and is only
 190          *              used to distribute traffic to multiple GPP cores.
 191          *              This configuration affects the number of Tx queues
 192          *              (logical FQs, all associated with a single CEETM queue),
 193          *              Rx queues and Tx confirmation queues, if applicable.
 194          *              Value 0 defaults to one queue. Maximum supported value
 195          *              is 8.
 196          * @num_tcs: Number of traffic classes (TCs), reserved for the DPNI.
 197          *              TCs can have different priority levels for the purpose
 198          *              of Tx scheduling (see DPNI_SET_TX_SELECTION), different
 199          *              BPs (DPNI_ SET_POOLS), policers. There are dedicated QM
 200          *              queues for traffic classes (including class queues on
 201          *              Tx). Value 0 defaults to one TC. Maximum supported value
 202          *              is 8.
 203          * @qos_entries: Number of entries in the QoS classification table. This
 204          *              table is used to select the TC for ingress traffic. It
 205          *              is either an exact match or a TCAM table, depending on
 206          *              DPNI_OPT_ HAS_KEY_MASKING bit in OPTIONS field. This
 207          *              field is ignored if the DPNI has a single TC. Otherwise,
 208          *              a value of 0 defaults to 64. Maximum supported value
 209          *              is 64.
 210          */
 211         uint32_t options;
 212         uint16_t fs_entries;
 213         uint8_t  vlan_filter_entries;
 214         uint8_t  mac_filter_entries;
 215         uint8_t  num_queues;
 216         uint8_t  num_tcs;
 217         uint8_t  qos_entries;
 218 };
 219
 220 /**
 221  * dpni_create() - Create the DPNI object
 222  * @mc_io:      Pointer to MC portal's I/O object
 223  * @dprc_token: Parent container token; '0' for default container
 224  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 225  * @cfg:        Configuration structure
 226  * @obj_id: returned object id
 227  *
 228  * Create the DPNI object, allocate required resources and
 229  * perform required initialization.
 230  *
 231  * The object can be created either by declaring it in the
 232  * DPL file, or by calling this function.
 233  *
 234  * The function accepts an authentication token of a parent
 235  * container that this object should be assigned to. The token
 236  * can be '0' so the object will be assigned to the default container.
 237  * The newly created object can be opened with the returned
 238  * object id and using the container's associated tokens and MC portals.
 239  *
 240  * Return:      '0' on Success; Error code otherwise.
 241  */
 242 int dpni_create(struct fsl_mc_io        *mc_io,
 243                 uint16_t                dprc_token,
 244                 uint32_t                cmd_flags,
 245                 const struct dpni_cfg   *cfg,
 246                 uint32_t                *obj_id);
 247
 248 /**
 249  * dpni_destroy() - Destroy the DPNI object and release all its resources.
 250  * @mc_io:      Pointer to MC portal's I/O object
 251  * @dprc_token: Parent container token; '0' for default container
 252  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 253  * @object_id:  The object id; it must be a valid id within the container that
 254  * created this object;
 255  *
 256  * The function accepts the authentication token of the parent container that
 257  * created the object (not the one that currently owns the object). The object
 258  * is searched within parent using the provided 'object_id'.
 259  * All tokens to the object must be closed before calling destroy.
 260  *
 261  * Return:      '0' on Success; error code otherwise.
 262  */
 263 int dpni_destroy(struct fsl_mc_io       *mc_io,
 264                  uint16_t               dprc_token,
 265                  uint32_t               cmd_flags,
 266                  uint32_t               object_id);
 267
 268 /**
 269  * struct dpni_pools_cfg - Structure representing buffer pools configuration
 270  * @num_dpbp: Number of DPBPs
 271  * @pools: Array of buffer pools parameters; The number of valid entries
 272  *      must match 'num_dpbp' value
 273  */
 274 struct dpni_pools_cfg {
 275         uint8_t         num_dpbp;
 276         /**
 277          * struct pools - Buffer pools parameters
 278          * @dpbp_id: DPBP object ID
 279          * @buffer_size: Buffer size
 280          * @backup_pool: Backup pool
 281          */
 282         struct {
 283                 int             dpbp_id;
 284                 uint16_t        buffer_size;
 285                 int             backup_pool;
 286         } pools[DPNI_MAX_DPBP];
 287 };
 288
 289 /**
 290  * dpni_set_pools() - Set buffer pools configuration
 291  * @mc_io:      Pointer to MC portal's I/O object
 292  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 293  * @token:      Token of DPNI object
 294  * @cfg:        Buffer pools configuration
 295  *
 296  * mandatory for DPNI operation
 297  * warning:Allowed only when DPNI is disabled
 298  *
 299  * Return:      '0' on Success; Error code otherwise.
 300  */
 301 int dpni_set_pools(struct fsl_mc_io             *mc_io,
 302                    uint32_t                     cmd_flags,
 303                    uint16_t                     token,
 304                    const struct dpni_pools_cfg  *cfg);
 305
 306 /**
 307  * dpni_enable() - Enable the DPNI, allow sending and receiving frames.
 308  * @mc_io:      Pointer to MC portal's I/O object
 309  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 310  * @token:              Token of DPNI object
 311  *
 312  * Return:      '0' on Success; Error code otherwise.
 313  */
 314 int dpni_enable(struct fsl_mc_io        *mc_io,
 315                 uint32_t                cmd_flags,
 316                 uint16_t                token);
 317
 318 /**
 319  * dpni_disable() - Disable the DPNI, stop sending and receiving frames.
 320  * @mc_io:      Pointer to MC portal's I/O object
 321  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 322  * @token:      Token of DPNI object
 323  *
 324  * Return:      '0' on Success; Error code otherwise.
 325  */
 326 int dpni_disable(struct fsl_mc_io       *mc_io,
 327                  uint32_t               cmd_flags,
 328                  uint16_t               token);
 329
 330 /**
 331  * dpni_is_enabled() - Check if the DPNI is enabled.
 332  * @mc_io:      Pointer to MC portal's I/O object
 333  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 334  * @token:      Token of DPNI object
 335  * @en:         Returns '1' if object is enabled; '0' otherwise
 336  *
 337  * Return:      '0' on Success; Error code otherwise.
 338  */
 339 int dpni_is_enabled(struct fsl_mc_io    *mc_io,
 340                     uint32_t            cmd_flags,
 341                     uint16_t            token,
 342                     int                 *en);
 343
 344 /**
 345  * dpni_reset() - Reset the DPNI, returns the object to initial state.
 346  * @mc_io:      Pointer to MC portal's I/O object
 347  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 348  * @token:      Token of DPNI object
 349  *
 350  * Return:      '0' on Success; Error code otherwise.
 351  */
 352 int dpni_reset(struct fsl_mc_io *mc_io,
 353                uint32_t         cmd_flags,
 354                uint16_t         token);
 355
 356 /**
 357  * struct dpni_attr - Structure representing DPNI attributes
 358  * @options: Any combination of the following options:
 359  *              DPNI_OPT_TX_FRM_RELEASE
 360  *              DPNI_OPT_NO_MAC_FILTER
 361  *              DPNI_OPT_HAS_POLICING
 362  *              DPNI_OPT_SHARED_CONGESTION
 363  *              DPNI_OPT_HAS_KEY_MASKING
 364  *              DPNI_OPT_NO_FS
 365  * @num_queues: Number of Tx and Rx queues used for traffic distribution.
 366  * @num_tcs: Number of traffic classes (TCs), reserved for the DPNI.
 367  * @mac_filter_entries: Number of entries in the MAC address filtering
 368  *              table.
 369  * @vlan_filter_entries: Number of entries in the VLAN address filtering
 370  *              table.
 371  * @qos_entries: Number of entries in the QoS classification table.
 372  * @fs_entries: Number of entries in the flow steering table.
 373  * @qos_key_size: Size, in bytes, of the QoS look-up key. Defining a key larger
 374  *                      than this when adding QoS entries will result
 375  *                      in an error.
 376  * @fs_key_size: Size, in bytes, of the flow steering look-up key. Defining a
 377  *                      key larger than this when composing the hash + FS key
 378  *                      will result in an error.
 379  * @wriop_version: Version of WRIOP HW block.
 380  *                      The 3 version values are stored on 6, 5, 5 bits
 381  *                      respectively.
 382  *                      Values returned:
 383  *                      - 0x400 - WRIOP version 1.0.0, used on LS2080 and
 384  *                      variants,
 385  *                      - 0x421 - WRIOP version 1.1.1, used on LS2088 and
 386  *                      variants,
 387  *                      - 0x422 - WRIOP version 1.1.2, used on LS1088 and
 388  *                      variants.
 389  */
 390 struct dpni_attr {
 391         uint32_t options;
 392         uint8_t  num_queues;
 393         uint8_t  num_tcs;
 394         uint8_t  mac_filter_entries;
 395         uint8_t  vlan_filter_entries;
 396         uint8_t  qos_entries;
 397         uint16_t fs_entries;
 398         uint8_t  qos_key_size;
 399         uint8_t  fs_key_size;
 400         uint16_t wriop_version;
 401 };
 402
 403 /**
 404  * dpni_get_attributes() - Retrieve DPNI attributes.
 405  * @mc_io:      Pointer to MC portal's I/O object
 406  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 407  * @token:      Token of DPNI object
 408  * @attr:       Object's attributes
 409  *
 410  * Return:      '0' on Success; Error code otherwise.
 411  */
 412 int dpni_get_attributes(struct fsl_mc_io        *mc_io,
 413                         uint32_t                cmd_flags,
 414                         uint16_t                token,
 415                         struct dpni_attr        *attr);
 416
 417 /**
 418  * DPNI errors
 419  */
 420
 421 /**
 422  * Extract out of frame header error
 423  */
 424 #define DPNI_ERROR_EOFHE        0x00020000
 425 /**
 426  * Frame length error
 427  */
 428 #define DPNI_ERROR_FLE          0x00002000
 429 /**
 430  * Frame physical error
 431  */
 432 #define DPNI_ERROR_FPE          0x00001000
 433 /**
 434  * Parsing header error
 435  */
 436 #define DPNI_ERROR_PHE          0x00000020
 437 /**
 438  * Parser L3 checksum error
 439  */
 440 #define DPNI_ERROR_L3CE         0x00000004
 441 /**
 442  * Parser L3 checksum error
 443  */
 444 #define DPNI_ERROR_L4CE         0x00000001
 445
 446 /**
 447  * enum dpni_error_action - Defines DPNI behavior for errors
 448  * @DPNI_ERROR_ACTION_DISCARD: Discard the frame
 449  * @DPNI_ERROR_ACTION_CONTINUE: Continue with the normal flow
 450  * @DPNI_ERROR_ACTION_SEND_TO_ERROR_QUEUE: Send the frame to the error queue
 451  */
 452 enum dpni_error_action {
 453         DPNI_ERROR_ACTION_DISCARD = 0,
 454         DPNI_ERROR_ACTION_CONTINUE = 1,
 455         DPNI_ERROR_ACTION_SEND_TO_ERROR_QUEUE = 2
 456 };
 457
 458 /**
 459  * struct dpni_error_cfg - Structure representing DPNI errors treatment
 460  * @errors: Errors mask; use 'DPNI_ERROR__<X>
 461  * @error_action: The desired action for the errors mask
 462  * @set_frame_annotation: Set to '1' to mark the errors in frame annotation
 463  *              status (FAS); relevant only for the non-discard action
 464  */
 465 struct dpni_error_cfg {
 466         uint32_t                errors;
 467         enum dpni_error_action  error_action;
 468         int                     set_frame_annotation;
 469 };
 470
 471 /**
 472  * dpni_set_errors_behavior() - Set errors behavior
 473  * @mc_io:      Pointer to MC portal's I/O object
 474  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 475  * @token:      Token of DPNI object
 476  * @cfg:        Errors configuration
 477  *
 478  * this function may be called numerous times with different
 479  * error masks
 480  *
 481  * Return:      '0' on Success; Error code otherwise.
 482  */
 483 int dpni_set_errors_behavior(struct fsl_mc_io           *mc_io,
 484                              uint32_t                   cmd_flags,
 485                              uint16_t                   token,
 486                              struct dpni_error_cfg      *cfg);
 487
 488 /**
 489  * DPNI buffer layout modification options
 490  */
 491
 492 /**
 493  * Select to modify the time-stamp setting
 494  */
 495 #define DPNI_BUF_LAYOUT_OPT_TIMESTAMP           0x00000001
 496 /**
 497  * Select to modify the parser-result setting; not applicable for Tx
 498  */
 499 #define DPNI_BUF_LAYOUT_OPT_PARSER_RESULT       0x00000002
 500 /**
 501  * Select to modify the frame-status setting
 502  */
 503 #define DPNI_BUF_LAYOUT_OPT_FRAME_STATUS        0x00000004
 504 /**
 505  * Select to modify the private-data-size setting
 506  */
 507 #define DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE   0x00000008
 508 /**
 509  * Select to modify the data-alignment setting
 510  */
 511 #define DPNI_BUF_LAYOUT_OPT_DATA_ALIGN          0x00000010
 512 /**
 513  * Select to modify the data-head-room setting
 514  */
 515 #define DPNI_BUF_LAYOUT_OPT_DATA_HEAD_ROOM      0x00000020
 516 /**
 517  * Select to modify the data-tail-room setting
 518  */
 519 #define DPNI_BUF_LAYOUT_OPT_DATA_TAIL_ROOM      0x00000040
 520
 521 /**
 522  * struct dpni_buffer_layout - Structure representing DPNI buffer layout
 523  * @options: Flags representing the suggested modifications to the buffer
 524  *              layout; Use any combination of 'DPNI_BUF_LAYOUT_OPT_<X>' flags
 525  * @pass_timestamp: Pass timestamp value
 526  * @pass_parser_result: Pass parser results
 527  * @pass_frame_status: Pass frame status
 528  * @private_data_size: Size kept for private data (in bytes)
 529  * @data_align: Data alignment
 530  * @data_head_room: Data head room
 531  * @data_tail_room: Data tail room
 532  */
 533 struct dpni_buffer_layout {
 534         uint32_t        options;
 535         int             pass_timestamp;
 536         int             pass_parser_result;
 537         int             pass_frame_status;
 538         uint16_t        private_data_size;
 539         uint16_t        data_align;
 540         uint16_t        data_head_room;
 541         uint16_t        data_tail_room;
 542 };
 543
 544 /**
 545  * enum dpni_queue_type - Identifies a type of queue targeted by the command
 546  * @DPNI_QUEUE_RX: Rx queue
 547  * @DPNI_QUEUE_TX: Tx queue
 548  * @DPNI_QUEUE_TX_CONFIRM: Tx confirmation queue
 549  * @DPNI_QUEUE_RX_ERR: Rx error queue
 550  */enum dpni_queue_type {
 551         DPNI_QUEUE_RX,
 552         DPNI_QUEUE_TX,
 553         DPNI_QUEUE_TX_CONFIRM,
 554         DPNI_QUEUE_RX_ERR,
 555 };
 556
 557 /**
 558  * dpni_get_buffer_layout() - Retrieve buffer layout attributes.
 559  * @mc_io:      Pointer to MC portal's I/O object
 560  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 561  * @token:      Token of DPNI object
 562  * @qtype:      Type of queue to get the layout from
 563  * @layout:     Returns buffer layout attributes
 564  *
 565  * Return:      '0' on Success; Error code otherwise.
 566  */
 567 int dpni_get_buffer_layout(struct fsl_mc_io             *mc_io,
 568                            uint32_t                     cmd_flags,
 569                            uint16_t                     token,
 570                            enum dpni_queue_type         qtype,
 571                            struct dpni_buffer_layout    *layout);
 572
 573 /**
 574  * dpni_set_buffer_layout() - Set buffer layout configuration.
 575  * @mc_io:      Pointer to MC portal's I/O object
 576  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 577  * @token:      Token of DPNI object
 578  * @qtype:      Type of queue to set layout on
 579  * @layout:     Buffer layout configuration
 580  *
 581  * Return:      '0' on Success; Error code otherwise.
 582  *
 583  * @warning     Allowed only when DPNI is disabled
 584  */
 585 int dpni_set_buffer_layout(struct fsl_mc_io                *mc_io,
 586                            uint32_t                        cmd_flags,
 587                            uint16_t                        token,
 588                            enum dpni_queue_type            qtype,
 589                            const struct dpni_buffer_layout *layout);
 590
 591 /**
 592  * enum dpni_offload - Identifies a type of offload targeted by the command
 593  * @DPNI_OFF_RX_L3_CSUM: Rx L3 checksum validation
 594  * @DPNI_OFF_RX_L4_CSUM: Rx L4 checksum validation
 595  * @DPNI_OFF_TX_L3_CSUM: Tx L3 checksum generation
 596  * @DPNI_OFF_TX_L4_CSUM: Tx L4 checksum generation
 597  */
 598 enum dpni_offload {
 599         DPNI_OFF_RX_L3_CSUM,
 600         DPNI_OFF_RX_L4_CSUM,
 601         DPNI_OFF_TX_L3_CSUM,
 602         DPNI_OFF_TX_L4_CSUM,
 603 };
 604
 605 /**
 606  * dpni_set_offload() - Set DPNI offload configuration.
 607  * @mc_io:      Pointer to MC portal's I/O object
 608  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 609  * @token:      Token of DPNI object
 610  * @type:       Type of DPNI offload
 611  * @config:     Offload configuration.
 612  *                      For checksum offloads, non-zero value enables
 613  *                      the offload.
 614  *
 615  * Return:      '0' on Success; Error code otherwise.
 616  *
 617  * @warning     Allowed only when DPNI is disabled
 618  */
 619 int dpni_set_offload(struct fsl_mc_io *mc_io,
 620                      uint32_t cmd_flags,
 621                      uint16_t token,
 622                      enum dpni_offload type,
 623                      uint32_t config);
 624
 625 /**
 626  * dpni_get_offload() - Get DPNI offload configuration.
 627  * @mc_io:      Pointer to MC portal's I/O object
 628  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 629  * @token:      Token of DPNI object
 630  * @type:       Type of DPNI offload
 631  * @config:     Offload configuration.
 632  *                      For checksum offloads, a value of 1 indicates that the
 633  *                      offload is enabled.
 634  *
 635  * Return:      '0' on Success; Error code otherwise.
 636  *
 637  * @warning     Allowed only when DPNI is disabled
 638  */
 639 int dpni_get_offload(struct fsl_mc_io *mc_io,
 640                      uint32_t cmd_flags,
 641                      uint16_t token,
 642                      enum dpni_offload type,
 643                      uint32_t *config);
 644
 645 /**
 646  * dpni_get_qdid() - Get the Queuing Destination ID (QDID) that should be used
 647  *                      for enqueue operations
 648  * @mc_io:      Pointer to MC portal's I/O object
 649  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 650  * @token:      Token of DPNI object
 651  * @qtype:      Type of queue to get QDID for.  For applications lookig to
 652  *              transmit traffic this should be set to DPNI_QUEUE_TX
 653  * @qdid:       Returned virtual QDID value that should be used as an argument
 654  *                      in all enqueue operations
 655  *
 656  * Return:      '0' on Success; Error code otherwise.
 657  */
 658 int dpni_get_qdid(struct fsl_mc_io      *mc_io,
 659                   uint32_t              cmd_flags,
 660                   uint16_t              token,
 661                   enum dpni_queue_type  qtype,
 662                   uint16_t              *qdid);
 663
 664 #define DPNI_STATISTICS_CNT             7
 665
 666 union dpni_statistics {
 667         /**
 668          * struct page_0 - Page_0 statistics structure
 669          * @ingress_all_frames: Ingress frame count
 670          * @ingress_all_bytes: Ingress byte count
 671          * @ingress_multicast_frames: Ingress multicast frame count
 672          * @ingress_multicast_bytes: Ingress multicast byte count
 673          * @ingress_broadcast_frames: Ingress broadcast frame count
 674          * @ingress_broadcast_bytes: Ingress broadcast byte count
 675          */
 676         struct {
 677                 uint64_t ingress_all_frames;
 678                 uint64_t ingress_all_bytes;
 679                 uint64_t ingress_multicast_frames;
 680                 uint64_t ingress_multicast_bytes;
 681                 uint64_t ingress_broadcast_frames;
 682                 uint64_t ingress_broadcast_bytes;
 683         } page_0;
 684         /**
 685          * struct page_1 - Page_1 statistics structure
 686          * @egress_all_frames: Egress frame count
 687          * @egress_all_bytes: Egress byte count
 688          * @egress_multicast_frames: Egress multicast frame count
 689          * @egress_multicast_bytes: Egress multicast byte count
 690          * @egress_broadcast_frames: Egress broadcast frame count
 691          * @egress_broadcast_bytes: Egress broadcast byte count
 692          */
 693         struct {
 694                 uint64_t egress_all_frames;
 695                 uint64_t egress_all_bytes;
 696                 uint64_t egress_multicast_frames;
 697                 uint64_t egress_multicast_bytes;
 698                 uint64_t egress_broadcast_frames;
 699                 uint64_t egress_broadcast_bytes;
 700         } page_1;
 701         /**
 702          * struct page_2 - Page_2 statistics structure
 703          * @ingress_filtered_frames: Ingress filtered frame count
 704          * @ingress_discarded_frames: Ingress discarded frame count
 705          * @ingress_nobuffer_discards: Ingress discarded frame count due to
 706          *                                      lack of buffers
 707          * @egress_discarded_frames: Egress discarded frame count
 708          * @egress_confirmed_frames: Egress confirmed frame count
 709          */
 710         struct {
 711                 uint64_t ingress_filtered_frames;
 712                 uint64_t ingress_discarded_frames;
 713                 uint64_t ingress_nobuffer_discards;
 714                 uint64_t egress_discarded_frames;
 715                 uint64_t egress_confirmed_frames;
 716         } page_2;
 717         /**
 718          * struct raw - raw statistics structure, used to index counters
 719          */
 720         struct {
 721                 uint64_t counter[DPNI_STATISTICS_CNT];
 722         } raw;
 723 };
 724
 725 /**
 726  * Enable auto-negotiation
 727  */
 728 #define DPNI_LINK_OPT_AUTONEG           0x0000000000000001ULL
 729 /**
 730  * Enable half-duplex mode
 731  */
 732 #define DPNI_LINK_OPT_HALF_DUPLEX       0x0000000000000002ULL
 733 /**
 734  * Enable pause frames
 735  */
 736 #define DPNI_LINK_OPT_PAUSE             0x0000000000000004ULL
 737 /**
 738  * Enable a-symmetric pause frames
 739  */
 740 #define DPNI_LINK_OPT_ASYM_PAUSE        0x0000000000000008ULL
 741
 742 /**
 743  * struct dpni_link_state - Structure representing DPNI link state
 744  * @rate: Rate
 745  * @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values
 746  * @up: Link state; '0' for down, '1' for up
 747  */
 748 struct dpni_link_state {
 749         uint32_t        rate;
 750         uint64_t        options;
 751         int             up;
 752 };
 753
 754 /**
 755  * dpni_get_link_state() - Return the link state (either up or down)
 756  * @mc_io:      Pointer to MC portal's I/O object
 757  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 758  * @token:      Token of DPNI object
 759  * @state:      Returned link state;
 760  *
 761  * Return:      '0' on Success; Error code otherwise.
 762  */
 763 int dpni_get_link_state(struct fsl_mc_io        *mc_io,
 764                         uint32_t                cmd_flags,
 765                         uint16_t                token,
 766                         struct dpni_link_state  *state);
 767
 768 /**
 769  * dpni_set_max_frame_length() - Set the maximum received frame length.
 770  * @mc_io:      Pointer to MC portal's I/O object
 771  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 772  * @token:      Token of DPNI object
 773  * @max_frame_length:   Maximum received frame length (in
 774  *                              bytes); frame is discarded if its
 775  *                              length exceeds this value
 776  *
 777  * Return:      '0' on Success; Error code otherwise.
 778  */
 779 int dpni_set_max_frame_length(struct fsl_mc_io  *mc_io,
 780                               uint32_t          cmd_flags,
 781                               uint16_t          token,
 782                               uint16_t          max_frame_length);
 783
 784 /**
 785  * dpni_get_max_frame_length() - Get the maximum received frame length.
 786  * @mc_io:      Pointer to MC portal's I/O object
 787  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 788  * @token:      Token of DPNI object
 789  * @max_frame_length:   Maximum received frame length (in
 790  *                              bytes); frame is discarded if its
 791  *                              length exceeds this value
 792  *
 793  * Return:      '0' on Success; Error code otherwise.
 794  */
 795 int dpni_get_max_frame_length(struct fsl_mc_io  *mc_io,
 796                               uint32_t          cmd_flags,
 797                               uint16_t          token,
 798                               uint16_t          *max_frame_length);
 799
 800 /**
 801  * dpni_set_multicast_promisc() - Enable/disable multicast promiscuous mode
 802  * @mc_io:      Pointer to MC portal's I/O object
 803  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 804  * @token:      Token of DPNI object
 805  * @en:         Set to '1' to enable; '0' to disable
 806  *
 807  * Return:      '0' on Success; Error code otherwise.
 808  */
 809 int dpni_set_multicast_promisc(struct fsl_mc_io *mc_io,
 810                                uint32_t         cmd_flags,
 811                                uint16_t         token,
 812                                int              en);
 813
 814 /**
 815  * dpni_get_multicast_promisc() - Get multicast promiscuous mode
 816  * @mc_io:      Pointer to MC portal's I/O object
 817  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 818  * @token:      Token of DPNI object
 819  * @en:         Returns '1' if enabled; '0' otherwise
 820  *
 821  * Return:      '0' on Success; Error code otherwise.
 822  */
 823 int dpni_get_multicast_promisc(struct fsl_mc_io *mc_io,
 824                                uint32_t         cmd_flags,
 825                                uint16_t         token,
 826                                int              *en);
 827
 828 /**
 829  * dpni_set_unicast_promisc() - Enable/disable unicast promiscuous mode
 830  * @mc_io:      Pointer to MC portal's I/O object
 831  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 832  * @token:      Token of DPNI object
 833  * @en:         Set to '1' to enable; '0' to disable
 834  *
 835  * Return:      '0' on Success; Error code otherwise.
 836  */
 837 int dpni_set_unicast_promisc(struct fsl_mc_io   *mc_io,
 838                              uint32_t           cmd_flags,
 839                              uint16_t           token,
 840                              int                en);
 841
 842 /**
 843  * dpni_get_unicast_promisc() - Get unicast promiscuous mode
 844  * @mc_io:      Pointer to MC portal's I/O object
 845  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 846  * @token:      Token of DPNI object
 847  * @en:         Returns '1' if enabled; '0' otherwise
 848  *
 849  * Return:      '0' on Success; Error code otherwise.
 850  */
 851 int dpni_get_unicast_promisc(struct fsl_mc_io   *mc_io,
 852                              uint32_t           cmd_flags,
 853                              uint16_t           token,
 854                              int                *en);
 855
 856 /**
 857  * dpni_set_primary_mac_addr() - Set the primary MAC address
 858  * @mc_io:      Pointer to MC portal's I/O object
 859  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 860  * @token:      Token of DPNI object
 861  * @mac_addr:   MAC address to set as primary address
 862  *
 863  * Return:      '0' on Success; Error code otherwise.
 864  */
 865 int dpni_set_primary_mac_addr(struct fsl_mc_io  *mc_io,
 866                               uint32_t          cmd_flags,
 867                               uint16_t          token,
 868                               const uint8_t     mac_addr[6]);
 869
 870 /**
 871  * dpni_get_primary_mac_addr() - Get the primary MAC address
 872  * @mc_io:      Pointer to MC portal's I/O object
 873  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 874  * @token:      Token of DPNI object
 875  * @mac_addr:   Returned MAC address
 876  *
 877  * Return:      '0' on Success; Error code otherwise.
 878  */
 879 int dpni_get_primary_mac_addr(struct fsl_mc_io  *mc_io,
 880                               uint32_t          cmd_flags,
 881                               uint16_t          token,
 882                               uint8_t           mac_addr[6]);
 883
 884 /**
 885  * dpni_add_mac_addr() - Add MAC address filter
 886  * @mc_io:      Pointer to MC portal's I/O object
 887  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 888  * @token:      Token of DPNI object
 889  * @mac_addr:   MAC address to add
 890  *
 891  * Return:      '0' on Success; Error code otherwise.
 892  */
 893 int dpni_add_mac_addr(struct fsl_mc_io  *mc_io,
 894                       uint32_t          cmd_flags,
 895                       uint16_t          token,
 896                       const uint8_t     mac_addr[6]);
 897
 898 /**
 899  * dpni_remove_mac_addr() - Remove MAC address filter
 900  * @mc_io:      Pointer to MC portal's I/O object
 901  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 902  * @token:      Token of DPNI object
 903  * @mac_addr:   MAC address to remove
 904  *
 905  * Return:      '0' on Success; Error code otherwise.
 906  */
 907 int dpni_remove_mac_addr(struct fsl_mc_io       *mc_io,
 908                          uint32_t               cmd_flags,
 909                          uint16_t               token,
 910                          const uint8_t          mac_addr[6]);
 911
 912 /**
 913  * dpni_clear_mac_filters() - Clear all unicast and/or multicast MAC filters
 914  * @mc_io:      Pointer to MC portal's I/O object
 915  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 916  * @token:      Token of DPNI object
 917  * @unicast:    Set to '1' to clear unicast addresses
 918  * @multicast:  Set to '1' to clear multicast addresses
 919  *
 920  * The primary MAC address is not cleared by this operation.
 921  *
 922  * Return:      '0' on Success; Error code otherwise.
 923  */
 924 int dpni_clear_mac_filters(struct fsl_mc_io     *mc_io,
 925                            uint32_t             cmd_flags,
 926                            uint16_t             token,
 927                            int                  unicast,
 928                            int                  multicast);
 929
 930 /**
 931  * dpni_get_port_mac_addr() - Retrieve MAC address associated to the physical
 932  *              port the DPNI is attached to
 933  * @mc_io:      Pointer to MC portal's I/O object
 934  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 935  * @token:      Token of DPNI object
 936  * @mac_addr:   MAC address of the physical port, if any, otherwise 0
 937  *
 938  * The primary MAC address is not modified by this operation.
 939  *
 940  * Return:      '0' on Success; Error code otherwise.
 941  */
 942 int dpni_get_port_mac_addr(struct fsl_mc_io     *mc_io,
 943                            uint32_t             cmd_flags,
 944                            uint16_t             token,
 945                            uint8_t              mac_addr[6]);
 946
 947 /**
 948  * dpni_enable_vlan_filter() - Enable/disable VLAN filtering mode
 949  * @mc_io:      Pointer to MC portal's I/O object
 950  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 951  * @token:      Token of DPNI object
 952  * @en:         Set to '1' to enable; '0' to disable
 953  *
 954  * Return:      '0' on Success; Error code otherwise.
 955  */
 956 int dpni_enable_vlan_filter(struct fsl_mc_io    *mc_io,
 957                             uint32_t            cmd_flags,
 958                             uint16_t            token,
 959                             int                 en);
 960
 961 /**
 962  * dpni_add_vlan_id() - Add VLAN ID filter
 963  * @mc_io:      Pointer to MC portal's I/O object
 964  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 965  * @token:      Token of DPNI object
 966  * @vlan_id:    VLAN ID to add
 967  *
 968  * Return:      '0' on Success; Error code otherwise.
 969  */
 970 int dpni_add_vlan_id(struct fsl_mc_io   *mc_io,
 971                      uint32_t           cmd_flags,
 972                      uint16_t           token,
 973                      uint16_t           vlan_id);
 974
 975 /**
 976  * dpni_remove_vlan_id() - Remove VLAN ID filter
 977  * @mc_io:      Pointer to MC portal's I/O object
 978  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 979  * @token:      Token of DPNI object
 980  * @vlan_id:    VLAN ID to remove
 981  *
 982  * Return:      '0' on Success; Error code otherwise.
 983  */
 984 int dpni_remove_vlan_id(struct fsl_mc_io        *mc_io,
 985                         uint32_t                cmd_flags,
 986                         uint16_t                token,
 987                         uint16_t                vlan_id);
 988
 989 /**
 990  * dpni_clear_vlan_filters() - Clear all VLAN filters
 991  * @mc_io:      Pointer to MC portal's I/O object
 992  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 993  * @token:      Token of DPNI object
 994  *
 995  * Return:      '0' on Success; Error code otherwise.
 996  */
 997 int dpni_clear_vlan_filters(struct fsl_mc_io    *mc_io,
 998                             uint32_t            cmd_flags,
 999                             uint16_t            token);
1000
1001 /**
1002  * enum dpni_dist_mode - DPNI distribution mode
1003  * @DPNI_DIST_MODE_NONE: No distribution
1004  * @DPNI_DIST_MODE_HASH: Use hash distribution; only relevant if
1005  *              the 'DPNI_OPT_DIST_HASH' option was set at DPNI creation
1006  * @DPNI_DIST_MODE_FS:  Use explicit flow steering; only relevant if
1007  *       the 'DPNI_OPT_DIST_FS' option was set at DPNI creation
1008  */
1009 enum dpni_dist_mode {
1010         DPNI_DIST_MODE_NONE = 0,
1011         DPNI_DIST_MODE_HASH = 1,
1012         DPNI_DIST_MODE_FS = 2
1013 };
1014
1015 /**
1016  * enum dpni_fs_miss_action -   DPNI Flow Steering miss action
1017  * @DPNI_FS_MISS_DROP: In case of no-match, drop the frame
1018  * @DPNI_FS_MISS_EXPLICIT_FLOWID: In case of no-match, use explicit flow-id
1019  * @DPNI_FS_MISS_HASH: In case of no-match, distribute using hash
1020  */
1021 enum dpni_fs_miss_action {
1022         DPNI_FS_MISS_DROP = 0,
1023         DPNI_FS_MISS_EXPLICIT_FLOWID = 1,
1024         DPNI_FS_MISS_HASH = 2
1025 };
1026
1027 /**
1028  * struct dpni_fs_tbl_cfg - Flow Steering table configuration
1029  * @miss_action: Miss action selection
1030  * @default_flow_id: Used when 'miss_action = DPNI_FS_MISS_EXPLICIT_FLOWID'
1031  */
1032 struct dpni_fs_tbl_cfg {
1033         enum dpni_fs_miss_action        miss_action;
1034         uint16_t                        default_flow_id;
1035 };
1036
1037 /**
1038  * dpni_prepare_key_cfg() - function prepare extract parameters
1039  * @cfg: defining a full Key Generation profile (rule)
1040  * @key_cfg_buf: Zeroed 256 bytes of memory before mapping it to DMA
1041  *
1042  * This function has to be called before the following functions:
1043  *      - dpni_set_rx_tc_dist()
1044  *      - dpni_set_qos_table()
1045  */
1046 int dpni_prepare_key_cfg(const struct dpkg_profile_cfg  *cfg,
1047                          uint8_t                        *key_cfg_buf);
1048
1049 /**
1050  * struct dpni_rx_tc_dist_cfg - Rx traffic class distribution configuration
1051  * @dist_size: Set the distribution size;
1052  *      supported values: 1,2,3,4,6,7,8,12,14,16,24,28,32,48,56,64,96,
1053  *      112,128,192,224,256,384,448,512,768,896,1024
1054  * @dist_mode: Distribution mode
1055  * @key_cfg_iova: I/O virtual address of 256 bytes DMA-able memory filled with
1056  *              the extractions to be used for the distribution key by calling
1057  *              dpni_prepare_key_cfg() relevant only when
1058  *              'dist_mode != DPNI_DIST_MODE_NONE', otherwise it can be '0'
1059  * @fs_cfg: Flow Steering table configuration; only relevant if
1060  *              'dist_mode = DPNI_DIST_MODE_FS'
1061  */
1062 struct dpni_rx_tc_dist_cfg {
1063         uint16_t                dist_size;
1064         enum dpni_dist_mode     dist_mode;
1065         uint64_t                key_cfg_iova;
1066         struct dpni_fs_tbl_cfg  fs_cfg;
1067 };
1068
1069 /**
1070  * dpni_set_rx_tc_dist() - Set Rx traffic class distribution configuration
1071  * @mc_io:      Pointer to MC portal's I/O object
1072  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1073  * @token:      Token of DPNI object
1074  * @tc_id:      Traffic class selection (0-7)
1075  * @cfg:        Traffic class distribution configuration
1076  *
1077  * warning: if 'dist_mode != DPNI_DIST_MODE_NONE', call dpni_prepare_key_cfg()
1078  *                      first to prepare the key_cfg_iova parameter
1079  *
1080  * Return:      '0' on Success; error code otherwise.
1081  */
1082 int dpni_set_rx_tc_dist(struct fsl_mc_io                        *mc_io,
1083                         uint32_t                                cmd_flags,
1084                         uint16_t                                token,
1085                         uint8_t                                 tc_id,
1086                         const struct dpni_rx_tc_dist_cfg        *cfg);
1087 /**
1088  * enum dpni_congestion_unit - DPNI congestion units
1089  * @DPNI_CONGESTION_UNIT_BYTES: bytes units
1090  * @DPNI_CONGESTION_UNIT_FRAMES: frames units
1091  */
1092 enum dpni_congestion_unit {
1093         DPNI_CONGESTION_UNIT_BYTES = 0,
1094         DPNI_CONGESTION_UNIT_FRAMES
1095 };
1096
1097
1098 /**
1099  * enum dpni_dest - DPNI destination types
1100  * @DPNI_DEST_NONE: Unassigned destination; The queue is set in parked mode and
1101  *              does not generate FQDAN notifications; user is expected to
1102  *              dequeue from the queue based on polling or other user-defined
1103  *              method
1104  * @DPNI_DEST_DPIO: The queue is set in schedule mode and generates FQDAN
1105  *              notifications to the specified DPIO; user is expected to dequeue
1106  *              from the queue only after notification is received
1107  * @DPNI_DEST_DPCON: The queue is set in schedule mode and does not generate
1108  *              FQDAN notifications, but is connected to the specified DPCON
1109  *              object; user is expected to dequeue from the DPCON channel
1110  */
1111 enum dpni_dest {
1112         DPNI_DEST_NONE = 0,
1113         DPNI_DEST_DPIO = 1,
1114         DPNI_DEST_DPCON = 2
1115 };
1116
1117 /**
1118  * struct dpni_dest_cfg - Structure representing DPNI destination parameters
1119  * @dest_type: Destination type
1120  * @dest_id: Either DPIO ID or DPCON ID, depending on the destination type
1121  * @priority: Priority selection within the DPIO or DPCON channel; valid values
1122  *              are 0-1 or 0-7, depending on the number of priorities in that
1123  *              channel; not relevant for 'DPNI_DEST_NONE' option
1124  */
1125 struct dpni_dest_cfg {
1126         enum dpni_dest  dest_type;
1127         int             dest_id;
1128         uint8_t         priority;
1129 };
1130
1131 /* DPNI congestion options */
1132
1133 /**
1134  * CSCN message is written to message_iova once entering a
1135  * congestion state (see 'threshold_entry')
1136  */
1137 #define DPNI_CONG_OPT_WRITE_MEM_ON_ENTER        0x00000001
1138 /**
1139  * CSCN message is written to message_iova once exiting a
1140  * congestion state (see 'threshold_exit')
1141  */
1142 #define DPNI_CONG_OPT_WRITE_MEM_ON_EXIT         0x00000002
1143 /**
1144  * CSCN write will attempt to allocate into a cache (coherent write);
1145  * valid only if 'DPNI_CONG_OPT_WRITE_MEM_<X>' is selected
1146  */
1147 #define DPNI_CONG_OPT_COHERENT_WRITE            0x00000004
1148 /**
1149  * if 'dest_cfg.dest_type != DPNI_DEST_NONE' CSCN message is sent to
1150  * DPIO/DPCON's WQ channel once entering a congestion state
1151  * (see 'threshold_entry')
1152  */
1153 #define DPNI_CONG_OPT_NOTIFY_DEST_ON_ENTER      0x00000008
1154 /**
1155  * if 'dest_cfg.dest_type != DPNI_DEST_NONE' CSCN message is sent to
1156  * DPIO/DPCON's WQ channel once exiting a congestion state
1157  * (see 'threshold_exit')
1158  */
1159 #define DPNI_CONG_OPT_NOTIFY_DEST_ON_EXIT       0x00000010
1160 /**
1161  * if 'dest_cfg.dest_type != DPNI_DEST_NONE' when the CSCN is written to the
1162  * sw-portal's DQRR, the DQRI interrupt is asserted immediately (if enabled)
1163  */
1164 #define DPNI_CONG_OPT_INTR_COALESCING_DISABLED  0x00000020
1165
1166 /**
1167  * struct dpni_congestion_notification_cfg - congestion notification
1168  *              configuration
1169  * @units: units type
1170  * @threshold_entry: above this threshold we enter a congestion state.
1171  *      set it to '0' to disable it
1172  * @threshold_exit: below this threshold we exit the congestion state.
1173  * @message_ctx: The context that will be part of the CSCN message
1174  * @message_iova: I/O virtual address (must be in DMA-able memory),
1175  *      must be 16B aligned; valid only if 'DPNI_CONG_OPT_WRITE_MEM_<X>' is
1176  *      contained in 'options'
1177  * @dest_cfg: CSCN can be send to either DPIO or DPCON WQ channel
1178  * @notification_mode: Mask of available options; use 'DPNI_CONG_OPT_<X>' values
1179  */
1180
1181 struct dpni_congestion_notification_cfg {
1182         enum dpni_congestion_unit       units;
1183         uint32_t                        threshold_entry;
1184         uint32_t                        threshold_exit;
1185         uint64_t                        message_ctx;
1186         uint64_t                        message_iova;
1187         struct dpni_dest_cfg            dest_cfg;
1188         uint16_t                        notification_mode;
1189 };
1190
1191 /**
1192  * dpni_set_congestion_notification() - Set traffic class congestion
1193  *      notification configuration
1194  * @mc_io:      Pointer to MC portal's I/O object
1195  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1196  * @token:      Token of DPNI object
1197  * @qtype:      Type of queue - Rx, Tx and Tx confirm types are supported
1198  * @tc_id:      Traffic class selection (0-7)
1199  * @cfg:        congestion notification configuration
1200  *
1201  * Return:      '0' on Success; error code otherwise.
1202  */
1203 int dpni_set_congestion_notification(
1204                         struct fsl_mc_io                *mc_io,
1205                         uint32_t                        cmd_flags,
1206                         uint16_t                        token,
1207                         enum dpni_queue_type            qtype,
1208                         uint8_t                         tc_id,
1209                         const struct dpni_congestion_notification_cfg *cfg);
1210
1211 /**
1212  * dpni_get_congestion_notification() - Get traffic class congestion
1213  *      notification configuration
1214  * @mc_io:      Pointer to MC portal's I/O object
1215  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1216  * @token:      Token of DPNI object
1217  * @qtype:      Type of queue - Rx, Tx and Tx confirm types are supported
1218  * @tc_id:      Traffic class selection (0-7)
1219  * @cfg:        congestion notification configuration
1220  *
1221  * Return:      '0' on Success; error code otherwise.
1222  */
1223 int dpni_get_congestion_notification(struct fsl_mc_io           *mc_io,
1224                                      uint32_t                   cmd_flags,
1225                                      uint16_t                   token,
1226                                      enum dpni_queue_type       qtype,
1227                                      uint8_t                    tc_id,
1228                                 struct dpni_congestion_notification_cfg *cfg);
1229
1230
1231 /**
1232  * struct dpni_queue - Queue structure
1233  * @user_context:       User data, presented to the user along with any frames
1234  *                      from this queue. Not relevant for Tx queues.
1235  */
1236 struct dpni_queue {
1237         /**
1238          * struct destination - Destination structure
1239          * @id: ID of the destination, only relevant if DEST_TYPE is > 0.
1240          *                      Identifies either a DPIO or a DPCON object.
1241          *                      Not relevant for Tx queues.
1242          * @type:       May be one of the following:
1243          *                      0 - No destination, queue can be manually
1244          *                              queried, but will not push traffic or
1245          *                              notifications to a DPIO;
1246          *                      1 - The destination is a DPIO. When traffic
1247          *                              becomes available in the queue a FQDAN
1248          *                              (FQ data available notification) will be
1249          *                              generated to selected DPIO;
1250          *                      2 - The destination is a DPCON. The queue is
1251          *                              associated with a DPCON object for the
1252          *                              purpose of scheduling between multiple
1253          *                              queues. The DPCON may be independently
1254          *                              configured to generate notifications.
1255          *                              Not relevant for Tx queues.
1256          * @hold_active: Hold active, maintains a queue scheduled for longer
1257          *              in a DPIO during dequeue to reduce spread of traffic.
1258          *              Only relevant if queues are
1259          *              not affined to a single DPIO.
1260          */
1261         struct {
1262                 uint16_t id;
1263                 enum dpni_dest type;
1264                 char hold_active;
1265                 uint8_t priority;
1266         } destination;
1267         uint64_t user_context;
1268         /**
1269          * struct flc - FD FLow Context structure
1270          * @value:              FLC value to set
1271          * @stash_control:      Boolean, indicates whether the 6 lowest
1272          *                      significant bits are used for stash control.
1273          */
1274         struct {
1275                 uint64_t value;
1276                 char stash_control;
1277         } flc;
1278 };
1279
1280 /**
1281  * struct dpni_queue_id - Queue identification, used for enqueue commands
1282  *                              or queue control
1283  * @fqid:       FQID used for enqueueing to and/or configuration of this
1284  *                      specific FQ
1285  * @qdbin:      Queueing bin, used to enqueue using QDID, DQBIN, QPRI.
1286  *                      Only relevant for Tx queues.
1287  */
1288 struct dpni_queue_id {
1289         uint32_t fqid;
1290         uint16_t qdbin;
1291 };
1292
1293 /**
1294  * enum dpni_confirmation_mode - Defines DPNI options supported for Tx
1295  * confirmation
1296  * @DPNI_CONF_AFFINE: For each Tx queue set associated with a sender there is
1297  * an affine Tx Confirmation queue
1298  * @DPNI_CONF_SINGLE: All Tx queues are associated with a single Tx
1299  * confirmation queue
1300  * @DPNI_CONF_DISABLE: Tx frames are not confirmed.  This must be associated
1301  * with proper FD set-up to have buffers release to a Buffer Pool, otherwise
1302  * buffers will be leaked
1303  */
1304 enum dpni_confirmation_mode {
1305         DPNI_CONF_AFFINE,
1306         DPNI_CONF_SINGLE,
1307         DPNI_CONF_DISABLE,
1308 };
1309
1310 /**
1311  * dpni_set_tx_confirmation_mode() - Tx confirmation mode
1312  * @mc_io:      Pointer to MC portal's I/O object
1313  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1314  * @token:      Token of DPNI object
1315  * @mode:       Tx confirmation mode
1316  *
1317  * This function is useful only when 'DPNI_OPT_TX_CONF_DISABLED' is not
1318  * selected at DPNI creation.
1319  * Calling this function with 'mode' set to DPNI_CONF_DISABLE disables all
1320  * transmit confirmation (including the private confirmation queues), regardless
1321  * of previous settings; Note that in this case, Tx error frames are still
1322  * enqueued to the general transmit errors queue.
1323  * Calling this function with 'mode' set to DPNI_CONF_SINGLE switches all
1324  * Tx confirmations to a shared Tx conf queue.  The ID of the queue when
1325  * calling dpni_set/get_queue is -1.
1326  * Tx confirmation mode can only be changed while the DPNI is disabled.
1327  * Executing this command while the DPNI is enabled will return an error.
1328  *
1329  * Return:      '0' on Success; Error code otherwise.
1330  */
1331 int dpni_set_tx_confirmation_mode(struct fsl_mc_io              *mc_io,
1332                                   uint32_t                      cmd_flags,
1333                                   uint16_t                      token,
1334                                   enum dpni_confirmation_mode   mode);
1335
1336 /**
1337  * dpni_get_api_version() - Get Data Path Network Interface API version
1338  * @mc_io:  Pointer to MC portal's I/O object
1339  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1340  * @major_ver:  Major version of data path network interface API
1341  * @minor_ver:  Minor version of data path network interface API
1342  *
1343  * Return:  '0' on Success; Error code otherwise.
1344  */
1345 int dpni_get_api_version(struct fsl_mc_io *mc_io,
1346                          uint32_t cmd_flags,
1347                          uint16_t *major_ver,
1348                          uint16_t *minor_ver);
1349
1350 /**
1351  * Set User Context
1352  */
1353 #define DPNI_QUEUE_OPT_USER_CTX         0x00000001
1354
1355 /**
1356  * Set queue destination configuration
1357  */
1358 #define DPNI_QUEUE_OPT_DEST             0x00000002
1359
1360 /**
1361  * Set FD[FLC] configuration for traffic on this queue.  Note that FLC values
1362  * set with dpni_add_fs_entry, if any, take precedence over values per queue.
1363  */
1364 #define DPNI_QUEUE_OPT_FLC              0x00000004
1365
1366 /**
1367  * Set the queue to hold active mode.  This prevents the queue from being
1368  * rescheduled between DPIOs while it carries traffic and is active on one
1369  * DPNI.  Can help reduce reordering when servicing one queue on multiple
1370  * CPUs, but the queue is also less likely to push data to multiple CPUs
1371  * especially when congested.
1372  */
1373 #define DPNI_QUEUE_OPT_HOLD_ACTIVE      0x00000008
1374
1375 /**
1376  * dpni_set_queue() - Set queue parameters
1377  * @mc_io:              Pointer to MC portal's I/O object
1378  * @cmd_flags:          Command flags; one or more of 'MC_CMD_FLAG_'
1379  * @token:              Token of DPNI object
1380  * @qtype:              Type of queue - all queue types are supported, although
1381  *                              the command is ignored for Tx
1382  * @tc:                 Traffic class, in range 0 to NUM_TCS - 1
1383  * @index:              Selects the specific queue out of the set
1384  *                              allocated for the same TC.Value must be in
1385  *                              range 0 to NUM_QUEUES - 1
1386  * @options:            A combination of DPNI_QUEUE_OPT_ values that control
1387  *                              what configuration options are set on the queue
1388  * @queue:              Queue configuration structure
1389  *
1390  * Return:  '0' on Success; Error code otherwise.
1391  */
1392 int dpni_set_queue(struct fsl_mc_io *mc_io,
1393                    uint32_t cmd_flags,
1394                    uint16_t token,
1395                    enum dpni_queue_type qtype,
1396                    uint8_t tc,
1397                    uint8_t index,
1398                    uint8_t options,
1399                    const struct dpni_queue *queue);
1400
1401 /**
1402  * dpni_get_queue() - Get queue parameters
1403  * @mc_io:              Pointer to MC portal's I/O object
1404  * @cmd_flags:          Command flags; one or more of 'MC_CMD_FLAG_'
1405  * @token:              Token of DPNI object
1406  * @qtype:              Type of queue - all queue types are supported
1407  * @tc:                 Traffic class, in range 0 to NUM_TCS - 1
1408  * @index:              Selects the specific queue out of the set allocated
1409  *                              for the same TC. Value must be in range 0 to
1410  *                              NUM_QUEUES - 1
1411  * @queue:              Queue configuration structure
1412  * @qid:                Queue identification
1413  *
1414  * This function returns current queue configuration which can be changed by
1415  * calling dpni_set_queue, and queue identification information.
1416  * Returned qid.fqid and/or qid.qdbin values can be used to:
1417  * - enqueue traffic for Tx queues,
1418  * - perform volatile dequeue for Rx and, if applicable, Tx confirmation
1419  *   clean-up,
1420  * - retrieve queue state.
1421  *
1422  * All these operations are supported through the DPIO run-time API.
1423  *
1424  * Return:  '0' on Success; Error code otherwise.
1425  */
1426 int dpni_get_queue(struct fsl_mc_io *mc_io,
1427                    uint32_t cmd_flags,
1428                    uint16_t token,
1429                    enum dpni_queue_type qtype,
1430                    uint8_t tc,
1431                    uint8_t index,
1432                    struct dpni_queue *queue,
1433                    struct dpni_queue_id *qid);
1434
1435 /**
1436  * dpni_get_statistics() - Get DPNI statistics
1437  * @mc_io:              Pointer to MC portal's I/O object
1438  * @cmd_flags:          Command flags; one or more of 'MC_CMD_FLAG_'
1439  * @token:              Token of DPNI object
1440  * @page:               Selects the statistics page to retrieve, see
1441  *                              DPNI_GET_STATISTICS output.
1442  *                              Pages are numbered 0 to 2.
1443  * @stat:               Structure containing the statistics
1444  *
1445  * Return:  '0' on Success; Error code otherwise.
1446  */
1447 int dpni_get_statistics(struct fsl_mc_io *mc_io,
1448                         uint32_t cmd_flags,
1449                         uint16_t token,
1450                         uint8_t page,
1451                         union dpni_statistics *stat);
1452
1453 /**
1454  * dpni_reset_statistics() - Clears DPNI statistics
1455  * @mc_io:              Pointer to MC portal's I/O object
1456  * @cmd_flags:          Command flags; one or more of 'MC_CMD_FLAG_'
1457  * @token:              Token of DPNI object
1458  *
1459  * Return:  '0' on Success; Error code otherwise.
1460  */
1461 int dpni_reset_statistics(struct fsl_mc_io *mc_io,
1462                           uint32_t cmd_flags,
1463                           uint16_t token);
1464
1465 /**
1466  * enum dpni_congestion_point - Structure representing congestion point
1467  * @DPNI_CP_QUEUE:      Set taildrop per queue, identified by QUEUE_TYPE, TC and
1468  *                              QUEUE_INDEX
1469  * @DPNI_CP_GROUP:      Set taildrop per queue group. Depending on options used
1470  *                              to define the DPNI this can be either per
1471  *                              TC (default) or per interface
1472  *                              (DPNI_OPT_SHARED_CONGESTION set at DPNI create).
1473  *                              QUEUE_INDEX is ignored if this type is used.
1474  */
1475 enum dpni_congestion_point {
1476         DPNI_CP_QUEUE,
1477         DPNI_CP_GROUP,
1478 };
1479
1480 /**
1481  * struct dpni_taildrop - Structure representing the taildrop
1482  * @enable:     Indicates whether the taildrop is active or not.
1483  * @units:      Indicates the unit of THRESHOLD. Queue taildrop only
1484  *                      supports byte units, this field is ignored and
1485  *                      assumed = 0 if CONGESTION_POINT is 0.
1486  * @threshold:  Threshold value, in units identified by UNITS field. Value 0
1487  *                      cannot be used as a valid taildrop threshold,
1488  *                      THRESHOLD must be > 0 if the taildrop is
1489  *                      enabled.
1490  */
1491 struct dpni_taildrop {
1492         char enable;
1493         enum dpni_congestion_unit units;
1494         uint32_t threshold;
1495 };
1496
1497 /**
1498  * dpni_set_taildrop() - Set taildrop per queue or TC
1499  *
1500  * Setting a per-TC taildrop (cg_point = DPNI_CP_GROUP) will reset any current
1501  * congestion notification or early drop (WRED) configuration previously applied
1502  * to the same TC.
1503  *
1504  * @mc_io:      Pointer to MC portal's I/O object
1505  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1506  * @token:      Token of DPNI object
1507  * @cg_point:   Congestion point.  DPNI_CP_QUEUE is only supported in
1508  *              combination with DPNI_QUEUE_RX.
1509  * @q_type:     Queue type, can be DPNI_QUEUE_RX or DPNI_QUEUE_TX.
1510  * @tc:         Traffic class to apply this taildrop to
1511  * @q_index:    Index of the queue if the DPNI supports multiple queues for
1512  *                      traffic distribution.
1513  *                      Ignored if CONGESTION_POINT is not DPNI_CP_QUEUE.
1514  * @taildrop:   Taildrop structure
1515  *
1516  * Return:  '0' on Success; Error code otherwise.
1517  */
1518 int dpni_set_taildrop(struct fsl_mc_io *mc_io,
1519                       uint32_t cmd_flags,
1520                       uint16_t token,
1521                       enum dpni_congestion_point cg_point,
1522                       enum dpni_queue_type q_type,
1523                       uint8_t tc,
1524                       uint8_t q_index,
1525                       struct dpni_taildrop *taildrop);
1526
1527 /**
1528  * dpni_get_taildrop() - Get taildrop information
1529  * @mc_io:      Pointer to MC portal's I/O object
1530  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1531  * @token:      Token of DPNI object
1532  * @cg_point:   Congestion point
1533  * @q_type:
1534  * @tc:         Traffic class to apply this taildrop to
1535  * @q_index:    Index of the queue if the DPNI supports multiple queues for
1536  *                      traffic distribution. Ignored if CONGESTION_POINT
1537  *                      is not 0.
1538  * @taildrop:   Taildrop structure
1539  *
1540  * Return:  '0' on Success; Error code otherwise.
1541  */
1542 int dpni_get_taildrop(struct fsl_mc_io *mc_io,
1543                       uint32_t cmd_flags,
1544                       uint16_t token,
1545                       enum dpni_congestion_point cg_point,
1546                       enum dpni_queue_type q_type,
1547                       uint8_t tc,
1548                       uint8_t q_index,
1549                       struct dpni_taildrop *taildrop);
1550 #endif /* __FSL_DPNI_H */