drivers/staging/fsl-dpaa2/ethernet/dpni.h

   1 /* SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) */
   2 /* Copyright 2013-2016 Freescale Semiconductor Inc.
   3  * Copyright 2016 NXP
   4  */
   5 #ifndef __FSL_DPNI_H
   6 #define __FSL_DPNI_H
   7
   8 #include "dpkg.h"
   9
  10 struct fsl_mc_io;
  11
  12 /**
  13  * Data Path Network Interface API
  14  * Contains initialization APIs and runtime control APIs for DPNI
  15  */
  16
  17 /** General DPNI macros */
  18
  19 /**
  20  * Maximum number of traffic classes
  21  */
  22 #define DPNI_MAX_TC                             8
  23 /**
  24  * Maximum number of buffer pools per DPNI
  25  */
  26 #define DPNI_MAX_DPBP                           8
  27
  28 /**
  29  * All traffic classes considered; see dpni_set_queue()
  30  */
  31 #define DPNI_ALL_TCS                            (u8)(-1)
  32 /**
  33  * All flows within traffic class considered; see dpni_set_queue()
  34  */
  35 #define DPNI_ALL_TC_FLOWS                       (u16)(-1)
  36 /**
  37  * Generate new flow ID; see dpni_set_queue()
  38  */
  39 #define DPNI_NEW_FLOW_ID                        (u16)(-1)
  40
  41 /**
  42  * Tx traffic is always released to a buffer pool on transmit, there are no
  43  * resources allocated to have the frames confirmed back to the source after
  44  * transmission.
  45  */
  46 #define DPNI_OPT_TX_FRM_RELEASE                 0x000001
  47 /**
  48  * Disables support for MAC address filtering for addresses other than primary
  49  * MAC address. This affects both unicast and multicast. Promiscuous mode can
  50  * still be enabled/disabled for both unicast and multicast. If promiscuous mode
  51  * is disabled, only traffic matching the primary MAC address will be accepted.
  52  */
  53 #define DPNI_OPT_NO_MAC_FILTER                  0x000002
  54 /**
  55  * Allocate policers for this DPNI. They can be used to rate-limit traffic per
  56  * traffic class (TC) basis.
  57  */
  58 #define DPNI_OPT_HAS_POLICING                   0x000004
  59 /**
  60  * Congestion can be managed in several ways, allowing the buffer pool to
  61  * deplete on ingress, taildrop on each queue or use congestion groups for sets
  62  * of queues. If set, it configures a single congestion groups across all TCs.
  63  * If reset, a congestion group is allocated for each TC. Only relevant if the
  64  * DPNI has multiple traffic classes.
  65  */
  66 #define DPNI_OPT_SHARED_CONGESTION              0x000008
  67 /**
  68  * Enables TCAM for Flow Steering and QoS look-ups. If not specified, all
  69  * look-ups are exact match. Note that TCAM is not available on LS1088 and its
  70  * variants. Setting this bit on these SoCs will trigger an error.
  71  */
  72 #define DPNI_OPT_HAS_KEY_MASKING                0x000010
  73 /**
  74  * Disables the flow steering table.
  75  */
  76 #define DPNI_OPT_NO_FS                          0x000020
  77
  78 int dpni_open(struct fsl_mc_io  *mc_io,
  79               u32               cmd_flags,
  80               int               dpni_id,
  81               u16               *token);
  82
  83 int dpni_close(struct fsl_mc_io *mc_io,
  84                u32              cmd_flags,
  85                u16              token);
  86
  87 /**
  88  * struct dpni_pools_cfg - Structure representing buffer pools configuration
  89  * @num_dpbp: Number of DPBPs
  90  * @pools: Array of buffer pools parameters; The number of valid entries
  91  *      must match 'num_dpbp' value
  92  * @pools.dpbp_id: DPBP object ID
  93  * @pools.buffer_size: Buffer size
  94  * @pools.backup_pool: Backup pool
  95  */
  96 struct dpni_pools_cfg {
  97         u8              num_dpbp;
  98         struct {
  99                 int     dpbp_id;
 100                 u16     buffer_size;
 101                 int     backup_pool;
 102         } pools[DPNI_MAX_DPBP];
 103 };
 104
 105 int dpni_set_pools(struct fsl_mc_io             *mc_io,
 106                    u32                          cmd_flags,
 107                    u16                          token,
 108                    const struct dpni_pools_cfg  *cfg);
 109
 110 int dpni_enable(struct fsl_mc_io        *mc_io,
 111                 u32                     cmd_flags,
 112                 u16                     token);
 113
 114 int dpni_disable(struct fsl_mc_io       *mc_io,
 115                  u32                    cmd_flags,
 116                  u16                    token);
 117
 118 int dpni_is_enabled(struct fsl_mc_io    *mc_io,
 119                     u32                 cmd_flags,
 120                     u16                 token,
 121                     int                 *en);
 122
 123 int dpni_reset(struct fsl_mc_io *mc_io,
 124                u32              cmd_flags,
 125                u16              token);
 126
 127 /**
 128  * DPNI IRQ Index and Events
 129  */
 130
 131 /**
 132  * IRQ index
 133  */
 134 #define DPNI_IRQ_INDEX                          0
 135 /**
 136  * IRQ event - indicates a change in link state
 137  */
 138 #define DPNI_IRQ_EVENT_LINK_CHANGED             0x00000001
 139
 140 int dpni_set_irq_enable(struct fsl_mc_io        *mc_io,
 141                         u32                     cmd_flags,
 142                         u16                     token,
 143                         u8                      irq_index,
 144                         u8                      en);
 145
 146 int dpni_get_irq_enable(struct fsl_mc_io        *mc_io,
 147                         u32                     cmd_flags,
 148                         u16                     token,
 149                         u8                      irq_index,
 150                         u8                      *en);
 151
 152 int dpni_set_irq_mask(struct fsl_mc_io  *mc_io,
 153                       u32               cmd_flags,
 154                       u16               token,
 155                       u8                irq_index,
 156                       u32               mask);
 157
 158 int dpni_get_irq_mask(struct fsl_mc_io  *mc_io,
 159                       u32               cmd_flags,
 160                       u16               token,
 161                       u8                irq_index,
 162                       u32               *mask);
 163
 164 int dpni_get_irq_status(struct fsl_mc_io        *mc_io,
 165                         u32                     cmd_flags,
 166                         u16                     token,
 167                         u8                      irq_index,
 168                         u32                     *status);
 169
 170 int dpni_clear_irq_status(struct fsl_mc_io      *mc_io,
 171                           u32                   cmd_flags,
 172                           u16                   token,
 173                           u8                    irq_index,
 174                           u32                   status);
 175
 176 /**
 177  * struct dpni_attr - Structure representing DPNI attributes
 178  * @options: Any combination of the following options:
 179  *              DPNI_OPT_TX_FRM_RELEASE
 180  *              DPNI_OPT_NO_MAC_FILTER
 181  *              DPNI_OPT_HAS_POLICING
 182  *              DPNI_OPT_SHARED_CONGESTION
 183  *              DPNI_OPT_HAS_KEY_MASKING
 184  *              DPNI_OPT_NO_FS
 185  * @num_queues: Number of Tx and Rx queues used for traffic distribution.
 186  * @num_tcs: Number of traffic classes (TCs), reserved for the DPNI.
 187  * @mac_filter_entries: Number of entries in the MAC address filtering table.
 188  * @vlan_filter_entries: Number of entries in the VLAN address filtering table.
 189  * @qos_entries: Number of entries in the QoS classification table.
 190  * @fs_entries: Number of entries in the flow steering table.
 191  * @qos_key_size: Size, in bytes, of the QoS look-up key. Defining a key larger
 192  *              than this when adding QoS entries will result in an error.
 193  * @fs_key_size: Size, in bytes, of the flow steering look-up key. Defining a
 194  *              key larger than this when composing the hash + FS key will
 195  *              result in an error.
 196  * @wriop_version: Version of WRIOP HW block. The 3 version values are stored
 197  *              on 6, 5, 5 bits respectively.
 198  */
 199 struct dpni_attr {
 200         u32 options;
 201         u8 num_queues;
 202         u8 num_tcs;
 203         u8 mac_filter_entries;
 204         u8 vlan_filter_entries;
 205         u8 qos_entries;
 206         u16 fs_entries;
 207         u8 qos_key_size;
 208         u8 fs_key_size;
 209         u16 wriop_version;
 210 };
 211
 212 int dpni_get_attributes(struct fsl_mc_io        *mc_io,
 213                         u32                     cmd_flags,
 214                         u16                     token,
 215                         struct dpni_attr        *attr);
 216
 217 /**
 218  * DPNI errors
 219  */
 220
 221 /**
 222  * Extract out of frame header error
 223  */
 224 #define DPNI_ERROR_EOFHE        0x00020000
 225 /**
 226  * Frame length error
 227  */
 228 #define DPNI_ERROR_FLE          0x00002000
 229 /**
 230  * Frame physical error
 231  */
 232 #define DPNI_ERROR_FPE          0x00001000
 233 /**
 234  * Parsing header error
 235  */
 236 #define DPNI_ERROR_PHE          0x00000020
 237 /**
 238  * Parser L3 checksum error
 239  */
 240 #define DPNI_ERROR_L3CE         0x00000004
 241 /**
 242  * Parser L3 checksum error
 243  */
 244 #define DPNI_ERROR_L4CE         0x00000001
 245
 246 /**
 247  * enum dpni_error_action - Defines DPNI behavior for errors
 248  * @DPNI_ERROR_ACTION_DISCARD: Discard the frame
 249  * @DPNI_ERROR_ACTION_CONTINUE: Continue with the normal flow
 250  * @DPNI_ERROR_ACTION_SEND_TO_ERROR_QUEUE: Send the frame to the error queue
 251  */
 252 enum dpni_error_action {
 253         DPNI_ERROR_ACTION_DISCARD = 0,
 254         DPNI_ERROR_ACTION_CONTINUE = 1,
 255         DPNI_ERROR_ACTION_SEND_TO_ERROR_QUEUE = 2
 256 };
 257
 258 /**
 259  * struct dpni_error_cfg - Structure representing DPNI errors treatment
 260  * @errors: Errors mask; use 'DPNI_ERROR__<X>
 261  * @error_action: The desired action for the errors mask
 262  * @set_frame_annotation: Set to '1' to mark the errors in frame annotation
 263  *              status (FAS); relevant only for the non-discard action
 264  */
 265 struct dpni_error_cfg {
 266         u32                     errors;
 267         enum dpni_error_action  error_action;
 268         int                     set_frame_annotation;
 269 };
 270
 271 int dpni_set_errors_behavior(struct fsl_mc_io           *mc_io,
 272                              u32                        cmd_flags,
 273                              u16                        token,
 274                              struct dpni_error_cfg      *cfg);
 275
 276 /**
 277  * DPNI buffer layout modification options
 278  */
 279
 280 /**
 281  * Select to modify the time-stamp setting
 282  */
 283 #define DPNI_BUF_LAYOUT_OPT_TIMESTAMP           0x00000001
 284 /**
 285  * Select to modify the parser-result setting; not applicable for Tx
 286  */
 287 #define DPNI_BUF_LAYOUT_OPT_PARSER_RESULT       0x00000002
 288 /**
 289  * Select to modify the frame-status setting
 290  */
 291 #define DPNI_BUF_LAYOUT_OPT_FRAME_STATUS        0x00000004
 292 /**
 293  * Select to modify the private-data-size setting
 294  */
 295 #define DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE   0x00000008
 296 /**
 297  * Select to modify the data-alignment setting
 298  */
 299 #define DPNI_BUF_LAYOUT_OPT_DATA_ALIGN          0x00000010
 300 /**
 301  * Select to modify the data-head-room setting
 302  */
 303 #define DPNI_BUF_LAYOUT_OPT_DATA_HEAD_ROOM      0x00000020
 304 /**
 305  * Select to modify the data-tail-room setting
 306  */
 307 #define DPNI_BUF_LAYOUT_OPT_DATA_TAIL_ROOM      0x00000040
 308
 309 /**
 310  * struct dpni_buffer_layout - Structure representing DPNI buffer layout
 311  * @options: Flags representing the suggested modifications to the buffer
 312  *              layout; Use any combination of 'DPNI_BUF_LAYOUT_OPT_<X>' flags
 313  * @pass_timestamp: Pass timestamp value
 314  * @pass_parser_result: Pass parser results
 315  * @pass_frame_status: Pass frame status
 316  * @private_data_size: Size kept for private data (in bytes)
 317  * @data_align: Data alignment
 318  * @data_head_room: Data head room
 319  * @data_tail_room: Data tail room
 320  */
 321 struct dpni_buffer_layout {
 322         u32     options;
 323         int     pass_timestamp;
 324         int     pass_parser_result;
 325         int     pass_frame_status;
 326         u16     private_data_size;
 327         u16     data_align;
 328         u16     data_head_room;
 329         u16     data_tail_room;
 330 };
 331
 332 /**
 333  * enum dpni_queue_type - Identifies a type of queue targeted by the command
 334  * @DPNI_QUEUE_RX: Rx queue
 335  * @DPNI_QUEUE_TX: Tx queue
 336  * @DPNI_QUEUE_TX_CONFIRM: Tx confirmation queue
 337  * @DPNI_QUEUE_RX_ERR: Rx error queue
 338  */enum dpni_queue_type {
 339         DPNI_QUEUE_RX,
 340         DPNI_QUEUE_TX,
 341         DPNI_QUEUE_TX_CONFIRM,
 342         DPNI_QUEUE_RX_ERR,
 343 };
 344
 345 int dpni_get_buffer_layout(struct fsl_mc_io             *mc_io,
 346                            u32                          cmd_flags,
 347                            u16                          token,
 348                            enum dpni_queue_type         qtype,
 349                            struct dpni_buffer_layout    *layout);
 350
 351 int dpni_set_buffer_layout(struct fsl_mc_io                *mc_io,
 352                            u32                             cmd_flags,
 353                            u16                             token,
 354                            enum dpni_queue_type            qtype,
 355                            const struct dpni_buffer_layout *layout);
 356
 357 /**
 358  * enum dpni_offload - Identifies a type of offload targeted by the command
 359  * @DPNI_OFF_RX_L3_CSUM: Rx L3 checksum validation
 360  * @DPNI_OFF_RX_L4_CSUM: Rx L4 checksum validation
 361  * @DPNI_OFF_TX_L3_CSUM: Tx L3 checksum generation
 362  * @DPNI_OFF_TX_L4_CSUM: Tx L4 checksum generation
 363  */
 364 enum dpni_offload {
 365         DPNI_OFF_RX_L3_CSUM,
 366         DPNI_OFF_RX_L4_CSUM,
 367         DPNI_OFF_TX_L3_CSUM,
 368         DPNI_OFF_TX_L4_CSUM,
 369 };
 370
 371 int dpni_set_offload(struct fsl_mc_io   *mc_io,
 372                      u32                cmd_flags,
 373                      u16                token,
 374                      enum dpni_offload  type,
 375                      u32                config);
 376
 377 int dpni_get_offload(struct fsl_mc_io   *mc_io,
 378                      u32                cmd_flags,
 379                      u16                token,
 380                      enum dpni_offload  type,
 381                      u32                *config);
 382
 383 int dpni_get_qdid(struct fsl_mc_io      *mc_io,
 384                   u32                   cmd_flags,
 385                   u16                   token,
 386                   enum dpni_queue_type  qtype,
 387                   u16                   *qdid);
 388
 389 int dpni_get_tx_data_offset(struct fsl_mc_io    *mc_io,
 390                             u32                 cmd_flags,
 391                             u16                 token,
 392                             u16                 *data_offset);
 393
 394 #define DPNI_STATISTICS_CNT             7
 395
 396 /**
 397  * union dpni_statistics - Union describing the DPNI statistics
 398  * @page_0: Page_0 statistics structure
 399  * @page_0.ingress_all_frames: Ingress frame count
 400  * @page_0.ingress_all_bytes: Ingress byte count
 401  * @page_0.ingress_multicast_frames: Ingress multicast frame count
 402  * @page_0.ingress_multicast_bytes: Ingress multicast byte count
 403  * @page_0.ingress_broadcast_frames: Ingress broadcast frame count
 404  * @page_0.ingress_broadcast_bytes: Ingress broadcast byte count
 405  * @page_1: Page_1 statistics structure
 406  * @page_1.egress_all_frames: Egress frame count
 407  * @page_1.egress_all_bytes: Egress byte count
 408  * @page_1.egress_multicast_frames: Egress multicast frame count
 409  * @page_1.egress_multicast_bytes: Egress multicast byte count
 410  * @page_1.egress_broadcast_frames: Egress broadcast frame count
 411  * @page_1.egress_broadcast_bytes: Egress broadcast byte count
 412  * @page_2: Page_2 statistics structure
 413  * @page_2.ingress_filtered_frames: Ingress filtered frame count
 414  * @page_2.ingress_discarded_frames: Ingress discarded frame count
 415  * @page_2.ingress_nobuffer_discards: Ingress discarded frame count due to
 416  *      lack of buffers
 417  * @page_2.egress_discarded_frames: Egress discarded frame count
 418  * @page_2.egress_confirmed_frames: Egress confirmed frame count
 419  * @raw: raw statistics structure, used to index counters
 420  */
 421 union dpni_statistics {
 422         struct {
 423                 u64 ingress_all_frames;
 424                 u64 ingress_all_bytes;
 425                 u64 ingress_multicast_frames;
 426                 u64 ingress_multicast_bytes;
 427                 u64 ingress_broadcast_frames;
 428                 u64 ingress_broadcast_bytes;
 429         } page_0;
 430         struct {
 431                 u64 egress_all_frames;
 432                 u64 egress_all_bytes;
 433                 u64 egress_multicast_frames;
 434                 u64 egress_multicast_bytes;
 435                 u64 egress_broadcast_frames;
 436                 u64 egress_broadcast_bytes;
 437         } page_1;
 438         struct {
 439                 u64 ingress_filtered_frames;
 440                 u64 ingress_discarded_frames;
 441                 u64 ingress_nobuffer_discards;
 442                 u64 egress_discarded_frames;
 443                 u64 egress_confirmed_frames;
 444         } page_2;
 445         struct {
 446                 u64 counter[DPNI_STATISTICS_CNT];
 447         } raw;
 448 };
 449
 450 int dpni_get_statistics(struct fsl_mc_io        *mc_io,
 451                         u32                     cmd_flags,
 452                         u16                     token,
 453                         u8                      page,
 454                         union dpni_statistics   *stat);
 455
 456 /**
 457  * Enable auto-negotiation
 458  */
 459 #define DPNI_LINK_OPT_AUTONEG           0x0000000000000001ULL
 460 /**
 461  * Enable half-duplex mode
 462  */
 463 #define DPNI_LINK_OPT_HALF_DUPLEX       0x0000000000000002ULL
 464 /**
 465  * Enable pause frames
 466  */
 467 #define DPNI_LINK_OPT_PAUSE             0x0000000000000004ULL
 468 /**
 469  * Enable a-symmetric pause frames
 470  */
 471 #define DPNI_LINK_OPT_ASYM_PAUSE        0x0000000000000008ULL
 472
 473 /**
 474  * struct - Structure representing DPNI link configuration
 475  * @rate: Rate
 476  * @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values
 477  */
 478 struct dpni_link_cfg {
 479         u32 rate;
 480         u64 options;
 481 };
 482
 483 int dpni_set_link_cfg(struct fsl_mc_io                  *mc_io,
 484                       u32                               cmd_flags,
 485                       u16                               token,
 486                       const struct dpni_link_cfg        *cfg);
 487
 488 /**
 489  * struct dpni_link_state - Structure representing DPNI link state
 490  * @rate: Rate
 491  * @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values
 492  * @up: Link state; '0' for down, '1' for up
 493  */
 494 struct dpni_link_state {
 495         u32     rate;
 496         u64     options;
 497         int     up;
 498 };
 499
 500 int dpni_get_link_state(struct fsl_mc_io        *mc_io,
 501                         u32                     cmd_flags,
 502                         u16                     token,
 503                         struct dpni_link_state  *state);
 504
 505 int dpni_set_max_frame_length(struct fsl_mc_io  *mc_io,
 506                               u32               cmd_flags,
 507                               u16               token,
 508                               u16               max_frame_length);
 509
 510 int dpni_get_max_frame_length(struct fsl_mc_io  *mc_io,
 511                               u32               cmd_flags,
 512                               u16               token,
 513                               u16               *max_frame_length);
 514
 515 int dpni_set_multicast_promisc(struct fsl_mc_io *mc_io,
 516                                u32              cmd_flags,
 517                                u16              token,
 518                                int              en);
 519
 520 int dpni_get_multicast_promisc(struct fsl_mc_io *mc_io,
 521                                u32              cmd_flags,
 522                                u16              token,
 523                                int              *en);
 524
 525 int dpni_set_unicast_promisc(struct fsl_mc_io   *mc_io,
 526                              u32                cmd_flags,
 527                              u16                token,
 528                              int                en);
 529
 530 int dpni_get_unicast_promisc(struct fsl_mc_io   *mc_io,
 531                              u32                cmd_flags,
 532                              u16                token,
 533                              int                *en);
 534
 535 int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
 536                               u32               cmd_flags,
 537                               u16               token,
 538                               const u8          mac_addr[6]);
 539
 540 int dpni_get_primary_mac_addr(struct fsl_mc_io  *mc_io,
 541                               u32               cmd_flags,
 542                               u16               token,
 543                               u8                mac_addr[6]);
 544
 545 int dpni_get_port_mac_addr(struct fsl_mc_io     *mc_io,
 546                            u32                  cm_flags,
 547                            u16                  token,
 548                            u8                   mac_addr[6]);
 549
 550 int dpni_add_mac_addr(struct fsl_mc_io  *mc_io,
 551                       u32               cmd_flags,
 552                       u16               token,
 553                       const u8          mac_addr[6]);
 554
 555 int dpni_remove_mac_addr(struct fsl_mc_io       *mc_io,
 556                          u32                    cmd_flags,
 557                          u16                    token,
 558                          const u8               mac_addr[6]);
 559
 560 int dpni_clear_mac_filters(struct fsl_mc_io     *mc_io,
 561                            u32                  cmd_flags,
 562                            u16                  token,
 563                            int                  unicast,
 564                            int                  multicast);
 565
 566 /**
 567  * enum dpni_dist_mode - DPNI distribution mode
 568  * @DPNI_DIST_MODE_NONE: No distribution
 569  * @DPNI_DIST_MODE_HASH: Use hash distribution; only relevant if
 570  *              the 'DPNI_OPT_DIST_HASH' option was set at DPNI creation
 571  * @DPNI_DIST_MODE_FS:  Use explicit flow steering; only relevant if
 572  *       the 'DPNI_OPT_DIST_FS' option was set at DPNI creation
 573  */
 574 enum dpni_dist_mode {
 575         DPNI_DIST_MODE_NONE = 0,
 576         DPNI_DIST_MODE_HASH = 1,
 577         DPNI_DIST_MODE_FS = 2
 578 };
 579
 580 /**
 581  * enum dpni_fs_miss_action -   DPNI Flow Steering miss action
 582  * @DPNI_FS_MISS_DROP: In case of no-match, drop the frame
 583  * @DPNI_FS_MISS_EXPLICIT_FLOWID: In case of no-match, use explicit flow-id
 584  * @DPNI_FS_MISS_HASH: In case of no-match, distribute using hash
 585  */
 586 enum dpni_fs_miss_action {
 587         DPNI_FS_MISS_DROP = 0,
 588         DPNI_FS_MISS_EXPLICIT_FLOWID = 1,
 589         DPNI_FS_MISS_HASH = 2
 590 };
 591
 592 /**
 593  * struct dpni_fs_tbl_cfg - Flow Steering table configuration
 594  * @miss_action: Miss action selection
 595  * @default_flow_id: Used when 'miss_action = DPNI_FS_MISS_EXPLICIT_FLOWID'
 596  */
 597 struct dpni_fs_tbl_cfg {
 598         enum dpni_fs_miss_action        miss_action;
 599         u16                             default_flow_id;
 600 };
 601
 602 int dpni_prepare_key_cfg(const struct dpkg_profile_cfg *cfg,
 603                          u8 *key_cfg_buf);
 604
 605 /**
 606  * struct dpni_rx_tc_dist_cfg - Rx traffic class distribution configuration
 607  * @dist_size: Set the distribution size;
 608  *      supported values: 1,2,3,4,6,7,8,12,14,16,24,28,32,48,56,64,96,
 609  *      112,128,192,224,256,384,448,512,768,896,1024
 610  * @dist_mode: Distribution mode
 611  * @key_cfg_iova: I/O virtual address of 256 bytes DMA-able memory filled with
 612  *              the extractions to be used for the distribution key by calling
 613  *              dpni_prepare_key_cfg() relevant only when
 614  *              'dist_mode != DPNI_DIST_MODE_NONE', otherwise it can be '0'
 615  * @fs_cfg: Flow Steering table configuration; only relevant if
 616  *              'dist_mode = DPNI_DIST_MODE_FS'
 617  */
 618 struct dpni_rx_tc_dist_cfg {
 619         u16                     dist_size;
 620         enum dpni_dist_mode     dist_mode;
 621         u64                     key_cfg_iova;
 622         struct dpni_fs_tbl_cfg  fs_cfg;
 623 };
 624
 625 int dpni_set_rx_tc_dist(struct fsl_mc_io                        *mc_io,
 626                         u32                                     cmd_flags,
 627                         u16                                     token,
 628                         u8                                      tc_id,
 629                         const struct dpni_rx_tc_dist_cfg        *cfg);
 630
 631 /**
 632  * enum dpni_dest - DPNI destination types
 633  * @DPNI_DEST_NONE: Unassigned destination; The queue is set in parked mode and
 634  *              does not generate FQDAN notifications; user is expected to
 635  *              dequeue from the queue based on polling or other user-defined
 636  *              method
 637  * @DPNI_DEST_DPIO: The queue is set in schedule mode and generates FQDAN
 638  *              notifications to the specified DPIO; user is expected to dequeue
 639  *              from the queue only after notification is received
 640  * @DPNI_DEST_DPCON: The queue is set in schedule mode and does not generate
 641  *              FQDAN notifications, but is connected to the specified DPCON
 642  *              object; user is expected to dequeue from the DPCON channel
 643  */
 644 enum dpni_dest {
 645         DPNI_DEST_NONE = 0,
 646         DPNI_DEST_DPIO = 1,
 647         DPNI_DEST_DPCON = 2
 648 };
 649
 650 /**
 651  * struct dpni_queue - Queue structure
 652  * @destination - Destination structure
 653  * @destination.id: ID of the destination, only relevant if DEST_TYPE is > 0.
 654  *      Identifies either a DPIO or a DPCON object.
 655  *      Not relevant for Tx queues.
 656  * @destination.type:   May be one of the following:
 657  *      0 - No destination, queue can be manually
 658  *              queried, but will not push traffic or
 659  *              notifications to a DPIO;
 660  *      1 - The destination is a DPIO. When traffic
 661  *              becomes available in the queue a FQDAN
 662  *              (FQ data available notification) will be
 663  *              generated to selected DPIO;
 664  *      2 - The destination is a DPCON. The queue is
 665  *              associated with a DPCON object for the
 666  *              purpose of scheduling between multiple
 667  *              queues. The DPCON may be independently
 668  *              configured to generate notifications.
 669  *              Not relevant for Tx queues.
 670  * @destination.hold_active: Hold active, maintains a queue scheduled for longer
 671  *      in a DPIO during dequeue to reduce spread of traffic.
 672  *      Only relevant if queues are
 673  *      not affined to a single DPIO.
 674  * @user_context: User data, presented to the user along with any frames
 675  *      from this queue. Not relevant for Tx queues.
 676  * @flc: FD FLow Context structure
 677  * @flc.value: Default FLC value for traffic dequeued from
 678  *      this queue.  Please check description of FD
 679  *      structure for more information.
 680  *      Note that FLC values set using dpni_add_fs_entry,
 681  *      if any, take precedence over values per queue.
 682  * @flc.stash_control: Boolean, indicates whether the 6 lowest
 683  *      - significant bits are used for stash control.
 684  *      significant bits are used for stash control.  If set, the 6
 685  *      least significant bits in value are interpreted as follows:
 686  *      - bits 0-1: indicates the number of 64 byte units of context
 687  *      that are stashed.  FLC value is interpreted as a memory address
 688  *      in this case, excluding the 6 LS bits.
 689  *      - bits 2-3: indicates the number of 64 byte units of frame
 690  *      annotation to be stashed.  Annotation is placed at FD[ADDR].
 691  *      - bits 4-5: indicates the number of 64 byte units of frame
 692  *      data to be stashed.  Frame data is placed at FD[ADDR] +
 693  *      FD[OFFSET].
 694  *      For more details check the Frame Descriptor section in the
 695  *      hardware documentation.
 696  */
 697 struct dpni_queue {
 698         struct {
 699                 u16 id;
 700                 enum dpni_dest type;
 701                 char hold_active;
 702                 u8 priority;
 703         } destination;
 704         u64 user_context;
 705         struct {
 706                 u64 value;
 707                 char stash_control;
 708         } flc;
 709 };
 710
 711 /**
 712  * struct dpni_queue_id - Queue identification, used for enqueue commands
 713  *                      or queue control
 714  * @fqid: FQID used for enqueueing to and/or configuration of this specific FQ
 715  * @qdbin: Queueing bin, used to enqueue using QDID, DQBIN, QPRI. Only relevant
 716  *              for Tx queues.
 717  */
 718 struct dpni_queue_id {
 719         u32 fqid;
 720         u16 qdbin;
 721 };
 722
 723 /**
 724  * Set User Context
 725  */
 726 #define DPNI_QUEUE_OPT_USER_CTX         0x00000001
 727 #define DPNI_QUEUE_OPT_DEST             0x00000002
 728 #define DPNI_QUEUE_OPT_FLC              0x00000004
 729 #define DPNI_QUEUE_OPT_HOLD_ACTIVE      0x00000008
 730
 731 int dpni_set_queue(struct fsl_mc_io     *mc_io,
 732                    u32                  cmd_flags,
 733                    u16                  token,
 734                    enum dpni_queue_type qtype,
 735                    u8                   tc,
 736                    u8                   index,
 737                    u8                   options,
 738                    const struct dpni_queue *queue);
 739
 740 int dpni_get_queue(struct fsl_mc_io     *mc_io,
 741                    u32                  cmd_flags,
 742                    u16                  token,
 743                    enum dpni_queue_type qtype,
 744                    u8                   tc,
 745                    u8                   index,
 746                    struct dpni_queue    *queue,
 747                    struct dpni_queue_id *qid);
 748
 749 /**
 750  * enum dpni_congestion_unit - DPNI congestion units
 751  * @DPNI_CONGESTION_UNIT_BYTES: bytes units
 752  * @DPNI_CONGESTION_UNIT_FRAMES: frames units
 753  */
 754 enum dpni_congestion_unit {
 755         DPNI_CONGESTION_UNIT_BYTES = 0,
 756         DPNI_CONGESTION_UNIT_FRAMES
 757 };
 758
 759 /**
 760  * enum dpni_congestion_point - Structure representing congestion point
 761  * @DPNI_CP_QUEUE: Set taildrop per queue, identified by QUEUE_TYPE, TC and
 762  *              QUEUE_INDEX
 763  * @DPNI_CP_GROUP: Set taildrop per queue group. Depending on options used to
 764  *              define the DPNI this can be either per TC (default) or per
 765  *              interface (DPNI_OPT_SHARED_CONGESTION set at DPNI create).
 766  *              QUEUE_INDEX is ignored if this type is used.
 767  */
 768 enum dpni_congestion_point {
 769         DPNI_CP_QUEUE,
 770         DPNI_CP_GROUP,
 771 };
 772
 773 /**
 774  * struct dpni_taildrop - Structure representing the taildrop
 775  * @enable:     Indicates whether the taildrop is active or not.
 776  * @units:      Indicates the unit of THRESHOLD. Queue taildrop only supports
 777  *              byte units, this field is ignored and assumed = 0 if
 778  *              CONGESTION_POINT is 0.
 779  * @threshold:  Threshold value, in units identified by UNITS field. Value 0
 780  *              cannot be used as a valid taildrop threshold, THRESHOLD must
 781  *              be > 0 if the taildrop is enabled.
 782  */
 783 struct dpni_taildrop {
 784         char enable;
 785         enum dpni_congestion_unit units;
 786         u32 threshold;
 787 };
 788
 789 int dpni_set_taildrop(struct fsl_mc_io *mc_io,
 790                       u32 cmd_flags,
 791                       u16 token,
 792                       enum dpni_congestion_point cg_point,
 793                       enum dpni_queue_type q_type,
 794                       u8 tc,
 795                       u8 q_index,
 796                       struct dpni_taildrop *taildrop);
 797
 798 int dpni_get_taildrop(struct fsl_mc_io *mc_io,
 799                       u32 cmd_flags,
 800                       u16 token,
 801                       enum dpni_congestion_point cg_point,
 802                       enum dpni_queue_type q_type,
 803                       u8 tc,
 804                       u8 q_index,
 805                       struct dpni_taildrop *taildrop);
 806
 807 /**
 808  * struct dpni_rule_cfg - Rule configuration for table lookup
 809  * @key_iova: I/O virtual address of the key (must be in DMA-able memory)
 810  * @mask_iova: I/O virtual address of the mask (must be in DMA-able memory)
 811  * @key_size: key and mask size (in bytes)
 812  */
 813 struct dpni_rule_cfg {
 814         u64     key_iova;
 815         u64     mask_iova;
 816         u8      key_size;
 817 };
 818
 819 int dpni_get_api_version(struct fsl_mc_io *mc_io,
 820                          u32 cmd_flags,
 821                          u16 *major_ver,
 822                          u16 *minor_ver);
 823
 824 #endif /* __FSL_DPNI_H */