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 /**
 802  * dpni_set_unicast_promisc() - Enable/disable unicast promiscuous mode
 803  * @mc_io:      Pointer to MC portal's I/O object
 804  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 805  * @token:      Token of DPNI object
 806  * @en:         Set to '1' to enable; '0' to disable
 807  *
 808  * Return:      '0' on Success; Error code otherwise.
 809  */
 810 int dpni_set_unicast_promisc(struct fsl_mc_io   *mc_io,
 811                              uint32_t           cmd_flags,
 812                              uint16_t           token,
 813                              int                en);
 814
 815 /**
 816  * dpni_get_unicast_promisc() - Get unicast promiscuous mode
 817  * @mc_io:      Pointer to MC portal's I/O object
 818  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 819  * @token:      Token of DPNI object
 820  * @en:         Returns '1' if enabled; '0' otherwise
 821  *
 822  * Return:      '0' on Success; Error code otherwise.
 823  */
 824 int dpni_get_unicast_promisc(struct fsl_mc_io   *mc_io,
 825                              uint32_t           cmd_flags,
 826                              uint16_t           token,
 827                              int                *en);
 828
 829 /**
 830  * dpni_set_primary_mac_addr() - Set the primary MAC address
 831  * @mc_io:      Pointer to MC portal's I/O object
 832  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 833  * @token:      Token of DPNI object
 834  * @mac_addr:   MAC address to set as primary address
 835  *
 836  * Return:      '0' on Success; Error code otherwise.
 837  */
 838 int dpni_set_primary_mac_addr(struct fsl_mc_io  *mc_io,
 839                               uint32_t          cmd_flags,
 840                               uint16_t          token,
 841                               const uint8_t     mac_addr[6]);
 842
 843 /**
 844  * dpni_get_primary_mac_addr() - Get the primary MAC address
 845  * @mc_io:      Pointer to MC portal's I/O object
 846  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 847  * @token:      Token of DPNI object
 848  * @mac_addr:   Returned MAC address
 849  *
 850  * Return:      '0' on Success; Error code otherwise.
 851  */
 852 int dpni_get_primary_mac_addr(struct fsl_mc_io  *mc_io,
 853                               uint32_t          cmd_flags,
 854                               uint16_t          token,
 855                               uint8_t           mac_addr[6]);
 856
 857 /**
 858  * dpni_add_mac_addr() - Add MAC address filter
 859  * @mc_io:      Pointer to MC portal's I/O object
 860  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 861  * @token:      Token of DPNI object
 862  * @mac_addr:   MAC address to add
 863  *
 864  * Return:      '0' on Success; Error code otherwise.
 865  */
 866 int dpni_add_mac_addr(struct fsl_mc_io  *mc_io,
 867                       uint32_t          cmd_flags,
 868                       uint16_t          token,
 869                       const uint8_t     mac_addr[6]);
 870
 871 /**
 872  * dpni_remove_mac_addr() - Remove MAC address filter
 873  * @mc_io:      Pointer to MC portal's I/O object
 874  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 875  * @token:      Token of DPNI object
 876  * @mac_addr:   MAC address to remove
 877  *
 878  * Return:      '0' on Success; Error code otherwise.
 879  */
 880 int dpni_remove_mac_addr(struct fsl_mc_io       *mc_io,
 881                          uint32_t               cmd_flags,
 882                          uint16_t               token,
 883                          const uint8_t          mac_addr[6]);
 884
 885 /**
 886  * dpni_clear_mac_filters() - Clear all unicast and/or multicast MAC filters
 887  * @mc_io:      Pointer to MC portal's I/O object
 888  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 889  * @token:      Token of DPNI object
 890  * @unicast:    Set to '1' to clear unicast addresses
 891  * @multicast:  Set to '1' to clear multicast addresses
 892  *
 893  * The primary MAC address is not cleared by this operation.
 894  *
 895  * Return:      '0' on Success; Error code otherwise.
 896  */
 897 int dpni_clear_mac_filters(struct fsl_mc_io     *mc_io,
 898                            uint32_t             cmd_flags,
 899                            uint16_t             token,
 900                            int                  unicast,
 901                            int                  multicast);
 902
 903 /**
 904  * dpni_get_port_mac_addr() - Retrieve MAC address associated to the physical
 905  *              port the DPNI is attached to
 906  * @mc_io:      Pointer to MC portal's I/O object
 907  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 908  * @token:      Token of DPNI object
 909  * @mac_addr:   MAC address of the physical port, if any, otherwise 0
 910  *
 911  * The primary MAC address is not modified by this operation.
 912  *
 913  * Return:      '0' on Success; Error code otherwise.
 914  */
 915 int dpni_get_port_mac_addr(struct fsl_mc_io     *mc_io,
 916                            uint32_t             cmd_flags,
 917                            uint16_t             token,
 918                            uint8_t              mac_addr[6]);
 919
 920 /**
 921  * enum dpni_dist_mode - DPNI distribution mode
 922  * @DPNI_DIST_MODE_NONE: No distribution
 923  * @DPNI_DIST_MODE_HASH: Use hash distribution; only relevant if
 924  *              the 'DPNI_OPT_DIST_HASH' option was set at DPNI creation
 925  * @DPNI_DIST_MODE_FS:  Use explicit flow steering; only relevant if
 926  *       the 'DPNI_OPT_DIST_FS' option was set at DPNI creation
 927  */
 928 enum dpni_dist_mode {
 929         DPNI_DIST_MODE_NONE = 0,
 930         DPNI_DIST_MODE_HASH = 1,
 931         DPNI_DIST_MODE_FS = 2
 932 };
 933
 934 /**
 935  * enum dpni_fs_miss_action -   DPNI Flow Steering miss action
 936  * @DPNI_FS_MISS_DROP: In case of no-match, drop the frame
 937  * @DPNI_FS_MISS_EXPLICIT_FLOWID: In case of no-match, use explicit flow-id
 938  * @DPNI_FS_MISS_HASH: In case of no-match, distribute using hash
 939  */
 940 enum dpni_fs_miss_action {
 941         DPNI_FS_MISS_DROP = 0,
 942         DPNI_FS_MISS_EXPLICIT_FLOWID = 1,
 943         DPNI_FS_MISS_HASH = 2
 944 };
 945
 946 /**
 947  * struct dpni_fs_tbl_cfg - Flow Steering table configuration
 948  * @miss_action: Miss action selection
 949  * @default_flow_id: Used when 'miss_action = DPNI_FS_MISS_EXPLICIT_FLOWID'
 950  */
 951 struct dpni_fs_tbl_cfg {
 952         enum dpni_fs_miss_action        miss_action;
 953         uint16_t                        default_flow_id;
 954 };
 955
 956 /**
 957  * dpni_prepare_key_cfg() - function prepare extract parameters
 958  * @cfg: defining a full Key Generation profile (rule)
 959  * @key_cfg_buf: Zeroed 256 bytes of memory before mapping it to DMA
 960  *
 961  * This function has to be called before the following functions:
 962  *      - dpni_set_rx_tc_dist()
 963  *      - dpni_set_qos_table()
 964  */
 965 int dpni_prepare_key_cfg(const struct dpkg_profile_cfg  *cfg,
 966                          uint8_t                        *key_cfg_buf);
 967
 968 /**
 969  * struct dpni_rx_tc_dist_cfg - Rx traffic class distribution configuration
 970  * @dist_size: Set the distribution size;
 971  *      supported values: 1,2,3,4,6,7,8,12,14,16,24,28,32,48,56,64,96,
 972  *      112,128,192,224,256,384,448,512,768,896,1024
 973  * @dist_mode: Distribution mode
 974  * @key_cfg_iova: I/O virtual address of 256 bytes DMA-able memory filled with
 975  *              the extractions to be used for the distribution key by calling
 976  *              dpni_prepare_key_cfg() relevant only when
 977  *              'dist_mode != DPNI_DIST_MODE_NONE', otherwise it can be '0'
 978  * @fs_cfg: Flow Steering table configuration; only relevant if
 979  *              'dist_mode = DPNI_DIST_MODE_FS'
 980  */
 981 struct dpni_rx_tc_dist_cfg {
 982         uint16_t                dist_size;
 983         enum dpni_dist_mode     dist_mode;
 984         uint64_t                key_cfg_iova;
 985         struct dpni_fs_tbl_cfg  fs_cfg;
 986 };
 987
 988 /**
 989  * dpni_set_rx_tc_dist() - Set Rx traffic class distribution configuration
 990  * @mc_io:      Pointer to MC portal's I/O object
 991  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 992  * @token:      Token of DPNI object
 993  * @tc_id:      Traffic class selection (0-7)
 994  * @cfg:        Traffic class distribution configuration
 995  *
 996  * warning: if 'dist_mode != DPNI_DIST_MODE_NONE', call dpni_prepare_key_cfg()
 997  *                      first to prepare the key_cfg_iova parameter
 998  *
 999  * Return:      '0' on Success; error code otherwise.
1000  */
1001 int dpni_set_rx_tc_dist(struct fsl_mc_io                        *mc_io,
1002                         uint32_t                                cmd_flags,
1003                         uint16_t                                token,
1004                         uint8_t                                 tc_id,
1005                         const struct dpni_rx_tc_dist_cfg        *cfg);
1006 /**
1007  * enum dpni_congestion_unit - DPNI congestion units
1008  * @DPNI_CONGESTION_UNIT_BYTES: bytes units
1009  * @DPNI_CONGESTION_UNIT_FRAMES: frames units
1010  */
1011 enum dpni_congestion_unit {
1012         DPNI_CONGESTION_UNIT_BYTES = 0,
1013         DPNI_CONGESTION_UNIT_FRAMES
1014 };
1015
1016
1017 /**
1018  * enum dpni_dest - DPNI destination types
1019  * @DPNI_DEST_NONE: Unassigned destination; The queue is set in parked mode and
1020  *              does not generate FQDAN notifications; user is expected to
1021  *              dequeue from the queue based on polling or other user-defined
1022  *              method
1023  * @DPNI_DEST_DPIO: The queue is set in schedule mode and generates FQDAN
1024  *              notifications to the specified DPIO; user is expected to dequeue
1025  *              from the queue only after notification is received
1026  * @DPNI_DEST_DPCON: The queue is set in schedule mode and does not generate
1027  *              FQDAN notifications, but is connected to the specified DPCON
1028  *              object; user is expected to dequeue from the DPCON channel
1029  */
1030 enum dpni_dest {
1031         DPNI_DEST_NONE = 0,
1032         DPNI_DEST_DPIO = 1,
1033         DPNI_DEST_DPCON = 2
1034 };
1035
1036 /**
1037  * struct dpni_dest_cfg - Structure representing DPNI destination parameters
1038  * @dest_type: Destination type
1039  * @dest_id: Either DPIO ID or DPCON ID, depending on the destination type
1040  * @priority: Priority selection within the DPIO or DPCON channel; valid values
1041  *              are 0-1 or 0-7, depending on the number of priorities in that
1042  *              channel; not relevant for 'DPNI_DEST_NONE' option
1043  */
1044 struct dpni_dest_cfg {
1045         enum dpni_dest  dest_type;
1046         int             dest_id;
1047         uint8_t         priority;
1048 };
1049
1050 /* DPNI congestion options */
1051
1052 /**
1053  * CSCN message is written to message_iova once entering a
1054  * congestion state (see 'threshold_entry')
1055  */
1056 #define DPNI_CONG_OPT_WRITE_MEM_ON_ENTER        0x00000001
1057 /**
1058  * CSCN message is written to message_iova once exiting a
1059  * congestion state (see 'threshold_exit')
1060  */
1061 #define DPNI_CONG_OPT_WRITE_MEM_ON_EXIT         0x00000002
1062 /**
1063  * CSCN write will attempt to allocate into a cache (coherent write);
1064  * valid only if 'DPNI_CONG_OPT_WRITE_MEM_<X>' is selected
1065  */
1066 #define DPNI_CONG_OPT_COHERENT_WRITE            0x00000004
1067 /**
1068  * if 'dest_cfg.dest_type != DPNI_DEST_NONE' CSCN message is sent to
1069  * DPIO/DPCON's WQ channel once entering a congestion state
1070  * (see 'threshold_entry')
1071  */
1072 #define DPNI_CONG_OPT_NOTIFY_DEST_ON_ENTER      0x00000008
1073 /**
1074  * if 'dest_cfg.dest_type != DPNI_DEST_NONE' CSCN message is sent to
1075  * DPIO/DPCON's WQ channel once exiting a congestion state
1076  * (see 'threshold_exit')
1077  */
1078 #define DPNI_CONG_OPT_NOTIFY_DEST_ON_EXIT       0x00000010
1079 /**
1080  * if 'dest_cfg.dest_type != DPNI_DEST_NONE' when the CSCN is written to the
1081  * sw-portal's DQRR, the DQRI interrupt is asserted immediately (if enabled)
1082  */
1083 #define DPNI_CONG_OPT_INTR_COALESCING_DISABLED  0x00000020
1084
1085 /**
1086  * struct dpni_congestion_notification_cfg - congestion notification
1087  *              configuration
1088  * @units: units type
1089  * @threshold_entry: above this threshold we enter a congestion state.
1090  *      set it to '0' to disable it
1091  * @threshold_exit: below this threshold we exit the congestion state.
1092  * @message_ctx: The context that will be part of the CSCN message
1093  * @message_iova: I/O virtual address (must be in DMA-able memory),
1094  *      must be 16B aligned; valid only if 'DPNI_CONG_OPT_WRITE_MEM_<X>' is
1095  *      contained in 'options'
1096  * @dest_cfg: CSCN can be send to either DPIO or DPCON WQ channel
1097  * @notification_mode: Mask of available options; use 'DPNI_CONG_OPT_<X>' values
1098  */
1099
1100 struct dpni_congestion_notification_cfg {
1101         enum dpni_congestion_unit       units;
1102         uint32_t                        threshold_entry;
1103         uint32_t                        threshold_exit;
1104         uint64_t                        message_ctx;
1105         uint64_t                        message_iova;
1106         struct dpni_dest_cfg            dest_cfg;
1107         uint16_t                        notification_mode;
1108 };
1109
1110 /**
1111  * dpni_set_congestion_notification() - Set traffic class congestion
1112  *      notification configuration
1113  * @mc_io:      Pointer to MC portal's I/O object
1114  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1115  * @token:      Token of DPNI object
1116  * @qtype:      Type of queue - Rx, Tx and Tx confirm types are supported
1117  * @tc_id:      Traffic class selection (0-7)
1118  * @cfg:        congestion notification configuration
1119  *
1120  * Return:      '0' on Success; error code otherwise.
1121  */
1122 int dpni_set_congestion_notification(
1123                         struct fsl_mc_io                *mc_io,
1124                         uint32_t                        cmd_flags,
1125                         uint16_t                        token,
1126                         enum dpni_queue_type            qtype,
1127                         uint8_t                         tc_id,
1128                         const struct dpni_congestion_notification_cfg *cfg);
1129
1130 /**
1131  * dpni_get_congestion_notification() - Get traffic class congestion
1132  *      notification configuration
1133  * @mc_io:      Pointer to MC portal's I/O object
1134  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1135  * @token:      Token of DPNI object
1136  * @qtype:      Type of queue - Rx, Tx and Tx confirm types are supported
1137  * @tc_id:      Traffic class selection (0-7)
1138  * @cfg:        congestion notification configuration
1139  *
1140  * Return:      '0' on Success; error code otherwise.
1141  */
1142 int dpni_get_congestion_notification(struct fsl_mc_io           *mc_io,
1143                                      uint32_t                   cmd_flags,
1144                                      uint16_t                   token,
1145                                      enum dpni_queue_type       qtype,
1146                                      uint8_t                    tc_id,
1147                                 struct dpni_congestion_notification_cfg *cfg);
1148
1149
1150 /**
1151  * struct dpni_queue - Queue structure
1152  * @user_context:       User data, presented to the user along with any frames
1153  *                      from this queue. Not relevant for Tx queues.
1154  */
1155 struct dpni_queue {
1156         /**
1157          * struct destination - Destination structure
1158          * @id: ID of the destination, only relevant if DEST_TYPE is > 0.
1159          *                      Identifies either a DPIO or a DPCON object.
1160          *                      Not relevant for Tx queues.
1161          * @type:       May be one of the following:
1162          *                      0 - No destination, queue can be manually
1163          *                              queried, but will not push traffic or
1164          *                              notifications to a DPIO;
1165          *                      1 - The destination is a DPIO. When traffic
1166          *                              becomes available in the queue a FQDAN
1167          *                              (FQ data available notification) will be
1168          *                              generated to selected DPIO;
1169          *                      2 - The destination is a DPCON. The queue is
1170          *                              associated with a DPCON object for the
1171          *                              purpose of scheduling between multiple
1172          *                              queues. The DPCON may be independently
1173          *                              configured to generate notifications.
1174          *                              Not relevant for Tx queues.
1175          * @hold_active: Hold active, maintains a queue scheduled for longer
1176          *              in a DPIO during dequeue to reduce spread of traffic.
1177          *              Only relevant if queues are
1178          *              not affined to a single DPIO.
1179          */
1180         struct {
1181                 uint16_t id;
1182                 enum dpni_dest type;
1183                 char hold_active;
1184                 uint8_t priority;
1185         } destination;
1186         uint64_t user_context;
1187         /**
1188          * struct flc - FD FLow Context structure
1189          * @value:              FLC value to set
1190          * @stash_control:      Boolean, indicates whether the 6 lowest
1191          *                      significant bits are used for stash control.
1192          */
1193         struct {
1194                 uint64_t value;
1195                 char stash_control;
1196         } flc;
1197 };
1198
1199 /**
1200  * struct dpni_queue_id - Queue identification, used for enqueue commands
1201  *                              or queue control
1202  * @fqid:       FQID used for enqueueing to and/or configuration of this
1203  *                      specific FQ
1204  * @qdbin:      Queueing bin, used to enqueue using QDID, DQBIN, QPRI.
1205  *                      Only relevant for Tx queues.
1206  */
1207 struct dpni_queue_id {
1208         uint32_t fqid;
1209         uint16_t qdbin;
1210 };
1211
1212 /**
1213  * enum dpni_confirmation_mode - Defines DPNI options supported for Tx
1214  * confirmation
1215  * @DPNI_CONF_AFFINE: For each Tx queue set associated with a sender there is
1216  * an affine Tx Confirmation queue
1217  * @DPNI_CONF_SINGLE: All Tx queues are associated with a single Tx
1218  * confirmation queue
1219  * @DPNI_CONF_DISABLE: Tx frames are not confirmed.  This must be associated
1220  * with proper FD set-up to have buffers release to a Buffer Pool, otherwise
1221  * buffers will be leaked
1222  */
1223 enum dpni_confirmation_mode {
1224         DPNI_CONF_AFFINE,
1225         DPNI_CONF_SINGLE,
1226         DPNI_CONF_DISABLE,
1227 };
1228
1229 /**
1230  * dpni_set_tx_confirmation_mode() - Tx confirmation mode
1231  * @mc_io:      Pointer to MC portal's I/O object
1232  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1233  * @token:      Token of DPNI object
1234  * @mode:       Tx confirmation mode
1235  *
1236  * This function is useful only when 'DPNI_OPT_TX_CONF_DISABLED' is not
1237  * selected at DPNI creation.
1238  * Calling this function with 'mode' set to DPNI_CONF_DISABLE disables all
1239  * transmit confirmation (including the private confirmation queues), regardless
1240  * of previous settings; Note that in this case, Tx error frames are still
1241  * enqueued to the general transmit errors queue.
1242  * Calling this function with 'mode' set to DPNI_CONF_SINGLE switches all
1243  * Tx confirmations to a shared Tx conf queue.  The ID of the queue when
1244  * calling dpni_set/get_queue is -1.
1245  * Tx confirmation mode can only be changed while the DPNI is disabled.
1246  * Executing this command while the DPNI is enabled will return an error.
1247  *
1248  * Return:      '0' on Success; Error code otherwise.
1249  */
1250 int dpni_set_tx_confirmation_mode(struct fsl_mc_io              *mc_io,
1251                                   uint32_t                      cmd_flags,
1252                                   uint16_t                      token,
1253                                   enum dpni_confirmation_mode   mode);
1254
1255 /**
1256  * dpni_get_api_version() - Get Data Path Network Interface API version
1257  * @mc_io:  Pointer to MC portal's I/O object
1258  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1259  * @major_ver:  Major version of data path network interface API
1260  * @minor_ver:  Minor version of data path network interface API
1261  *
1262  * Return:  '0' on Success; Error code otherwise.
1263  */
1264 int dpni_get_api_version(struct fsl_mc_io *mc_io,
1265                          uint32_t cmd_flags,
1266                          uint16_t *major_ver,
1267                          uint16_t *minor_ver);
1268
1269 /**
1270  * Set User Context
1271  */
1272 #define DPNI_QUEUE_OPT_USER_CTX         0x00000001
1273
1274 /**
1275  * Set queue destination configuration
1276  */
1277 #define DPNI_QUEUE_OPT_DEST             0x00000002
1278
1279 /**
1280  * Set FD[FLC] configuration for traffic on this queue.  Note that FLC values
1281  * set with dpni_add_fs_entry, if any, take precedence over values per queue.
1282  */
1283 #define DPNI_QUEUE_OPT_FLC              0x00000004
1284
1285 /**
1286  * Set the queue to hold active mode.  This prevents the queue from being
1287  * rescheduled between DPIOs while it carries traffic and is active on one
1288  * DPNI.  Can help reduce reordering when servicing one queue on multiple
1289  * CPUs, but the queue is also less likely to push data to multiple CPUs
1290  * especially when congested.
1291  */
1292 #define DPNI_QUEUE_OPT_HOLD_ACTIVE      0x00000008
1293
1294 /**
1295  * dpni_set_queue() - Set queue parameters
1296  * @mc_io:              Pointer to MC portal's I/O object
1297  * @cmd_flags:          Command flags; one or more of 'MC_CMD_FLAG_'
1298  * @token:              Token of DPNI object
1299  * @qtype:              Type of queue - all queue types are supported, although
1300  *                              the command is ignored for Tx
1301  * @tc:                 Traffic class, in range 0 to NUM_TCS - 1
1302  * @index:              Selects the specific queue out of the set
1303  *                              allocated for the same TC.Value must be in
1304  *                              range 0 to NUM_QUEUES - 1
1305  * @options:            A combination of DPNI_QUEUE_OPT_ values that control
1306  *                              what configuration options are set on the queue
1307  * @queue:              Queue configuration structure
1308  *
1309  * Return:  '0' on Success; Error code otherwise.
1310  */
1311 int dpni_set_queue(struct fsl_mc_io *mc_io,
1312                    uint32_t cmd_flags,
1313                    uint16_t token,
1314                    enum dpni_queue_type qtype,
1315                    uint8_t tc,
1316                    uint8_t index,
1317                    uint8_t options,
1318                    const struct dpni_queue *queue);
1319
1320 /**
1321  * dpni_get_queue() - Get queue parameters
1322  * @mc_io:              Pointer to MC portal's I/O object
1323  * @cmd_flags:          Command flags; one or more of 'MC_CMD_FLAG_'
1324  * @token:              Token of DPNI object
1325  * @qtype:              Type of queue - all queue types are supported
1326  * @tc:                 Traffic class, in range 0 to NUM_TCS - 1
1327  * @index:              Selects the specific queue out of the set allocated
1328  *                              for the same TC. Value must be in range 0 to
1329  *                              NUM_QUEUES - 1
1330  * @queue:              Queue configuration structure
1331  * @qid:                Queue identification
1332  *
1333  * This function returns current queue configuration which can be changed by
1334  * calling dpni_set_queue, and queue identification information.
1335  * Returned qid.fqid and/or qid.qdbin values can be used to:
1336  * - enqueue traffic for Tx queues,
1337  * - perform volatile dequeue for Rx and, if applicable, Tx confirmation
1338  *   clean-up,
1339  * - retrieve queue state.
1340  *
1341  * All these operations are supported through the DPIO run-time API.
1342  *
1343  * Return:  '0' on Success; Error code otherwise.
1344  */
1345 int dpni_get_queue(struct fsl_mc_io *mc_io,
1346                    uint32_t cmd_flags,
1347                    uint16_t token,
1348                    enum dpni_queue_type qtype,
1349                    uint8_t tc,
1350                    uint8_t index,
1351                    struct dpni_queue *queue,
1352                    struct dpni_queue_id *qid);
1353
1354 /**
1355  * dpni_get_statistics() - Get DPNI statistics
1356  * @mc_io:              Pointer to MC portal's I/O object
1357  * @cmd_flags:          Command flags; one or more of 'MC_CMD_FLAG_'
1358  * @token:              Token of DPNI object
1359  * @page:               Selects the statistics page to retrieve, see
1360  *                              DPNI_GET_STATISTICS output.
1361  *                              Pages are numbered 0 to 2.
1362  * @stat:               Structure containing the statistics
1363  *
1364  * Return:  '0' on Success; Error code otherwise.
1365  */
1366 int dpni_get_statistics(struct fsl_mc_io *mc_io,
1367                         uint32_t cmd_flags,
1368                         uint16_t token,
1369                         uint8_t page,
1370                         union dpni_statistics *stat);
1371
1372 /**
1373  * dpni_reset_statistics() - Clears DPNI statistics
1374  * @mc_io:              Pointer to MC portal's I/O object
1375  * @cmd_flags:          Command flags; one or more of 'MC_CMD_FLAG_'
1376  * @token:              Token of DPNI object
1377  *
1378  * Return:  '0' on Success; Error code otherwise.
1379  */
1380 int dpni_reset_statistics(struct fsl_mc_io *mc_io,
1381                           uint32_t cmd_flags,
1382                           uint16_t token);
1383
1384 /**
1385  * enum dpni_congestion_point - Structure representing congestion point
1386  * @DPNI_CP_QUEUE:      Set taildrop per queue, identified by QUEUE_TYPE, TC and
1387  *                              QUEUE_INDEX
1388  * @DPNI_CP_GROUP:      Set taildrop per queue group. Depending on options used
1389  *                              to define the DPNI this can be either per
1390  *                              TC (default) or per interface
1391  *                              (DPNI_OPT_SHARED_CONGESTION set at DPNI create).
1392  *                              QUEUE_INDEX is ignored if this type is used.
1393  */
1394 enum dpni_congestion_point {
1395         DPNI_CP_QUEUE,
1396         DPNI_CP_GROUP,
1397 };
1398
1399 /**
1400  * struct dpni_taildrop - Structure representing the taildrop
1401  * @enable:     Indicates whether the taildrop is active or not.
1402  * @units:      Indicates the unit of THRESHOLD. Queue taildrop only
1403  *                      supports byte units, this field is ignored and
1404  *                      assumed = 0 if CONGESTION_POINT is 0.
1405  * @threshold:  Threshold value, in units identified by UNITS field. Value 0
1406  *                      cannot be used as a valid taildrop threshold,
1407  *                      THRESHOLD must be > 0 if the taildrop is
1408  *                      enabled.
1409  */
1410 struct dpni_taildrop {
1411         char enable;
1412         enum dpni_congestion_unit units;
1413         uint32_t threshold;
1414 };
1415
1416 /**
1417  * dpni_set_taildrop() - Set taildrop per queue or TC
1418  *
1419  * Setting a per-TC taildrop (cg_point = DPNI_CP_GROUP) will reset any current
1420  * congestion notification or early drop (WRED) configuration previously applied
1421  * to the same TC.
1422  *
1423  * @mc_io:      Pointer to MC portal's I/O object
1424  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1425  * @token:      Token of DPNI object
1426  * @cg_point:   Congestion point.  DPNI_CP_QUEUE is only supported in
1427  *              combination with DPNI_QUEUE_RX.
1428  * @q_type:     Queue type, can be DPNI_QUEUE_RX or DPNI_QUEUE_TX.
1429  * @tc:         Traffic class to apply this taildrop to
1430  * @q_index:    Index of the queue if the DPNI supports multiple queues for
1431  *                      traffic distribution.
1432  *                      Ignored if CONGESTION_POINT is not DPNI_CP_QUEUE.
1433  * @taildrop:   Taildrop structure
1434  *
1435  * Return:  '0' on Success; Error code otherwise.
1436  */
1437 int dpni_set_taildrop(struct fsl_mc_io *mc_io,
1438                       uint32_t cmd_flags,
1439                       uint16_t token,
1440                       enum dpni_congestion_point cg_point,
1441                       enum dpni_queue_type q_type,
1442                       uint8_t tc,
1443                       uint8_t q_index,
1444                       struct dpni_taildrop *taildrop);
1445
1446 /**
1447  * dpni_get_taildrop() - Get taildrop information
1448  * @mc_io:      Pointer to MC portal's I/O object
1449  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1450  * @token:      Token of DPNI object
1451  * @cg_point:   Congestion point
1452  * @q_type:
1453  * @tc:         Traffic class to apply this taildrop to
1454  * @q_index:    Index of the queue if the DPNI supports multiple queues for
1455  *                      traffic distribution. Ignored if CONGESTION_POINT
1456  *                      is not 0.
1457  * @taildrop:   Taildrop structure
1458  *
1459  * Return:  '0' on Success; Error code otherwise.
1460  */
1461 int dpni_get_taildrop(struct fsl_mc_io *mc_io,
1462                       uint32_t cmd_flags,
1463                       uint16_t token,
1464                       enum dpni_congestion_point cg_point,
1465                       enum dpni_queue_type q_type,
1466                       uint8_t tc,
1467                       uint8_t q_index,
1468                       struct dpni_taildrop *taildrop);
1469 #endif /* __FSL_DPNI_H */