include/fsl-mc/fsl_dpni.h

   1 /*
   2  * Copyright (C) 2013-2016 Freescale Semiconductor
   3  * Copyright 2017 NXP
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7 #ifndef _FSL_DPNI_H
   8 #define _FSL_DPNI_H
   9
  10 /* DPNI Version */
  11 #define DPNI_VER_MAJOR                          7
  12 #define DPNI_VER_MINOR                          3
  13
  14 /* Command IDs */
  15 #define DPNI_CMDID_OPEN                         0x8011
  16 #define DPNI_CMDID_CLOSE                        0x8001
  17 #define DPNI_CMDID_CREATE                       0x9011
  18 #define DPNI_CMDID_DESTROY                      0x9811
  19 #define DPNI_CMDID_GET_API_VERSION              0xa011
  20
  21 #define DPNI_CMDID_ENABLE                       0x0021
  22 #define DPNI_CMDID_DISABLE                      0x0031
  23 #define DPNI_CMDID_GET_ATTR                     0x0041
  24 #define DPNI_CMDID_RESET                        0x0051
  25
  26 #define DPNI_CMDID_SET_POOLS                    0x2002
  27 #define DPNI_CMDID_SET_BUFFER_LAYOUT            0x2651
  28 #define DPNI_CMDID_GET_BUFFER_LAYOUT            0x2641
  29 #define DPNI_CMDID_SET_ERRORS_BEHAVIOR          0x20B1
  30
  31 #define DPNI_CMDID_GET_QDID                     0x2101
  32 #define DPNI_CMDID_GET_TX_DATA_OFFSET           0x2121
  33 #define DPNI_CMDID_GET_LINK_STATE               0x2151
  34 #define DPNI_CMDID_SET_LINK_CFG                 0x21A1
  35
  36 #define DPNI_CMDID_SET_PRIM_MAC                 0x2241
  37 #define DPNI_CMDID_GET_PRIM_MAC                 0x2251
  38 #define DPNI_CMDID_ADD_MAC_ADDR                 0x2261
  39 #define DPNI_CMDID_REMOVE_MAC_ADDR              0x2271
  40
  41 #define DPNI_CMDID_GET_STATISTICS               0x25D1
  42 #define DPNI_CMDID_RESET_STATISTICS             0x25E1
  43 #define DPNI_CMDID_GET_QUEUE                    0x25F1
  44 #define DPNI_CMDID_SET_QUEUE                    0x2601
  45 #define DPNI_CMDID_SET_TX_CONFIRMATION_MODE     0x2661
  46
  47 /*                cmd, param, offset, width, type, arg_name */
  48 #define DPNI_CMD_OPEN(cmd, dpni_id) \
  49         MC_CMD_OP(cmd,   0,     0,      32,     int,    dpni_id)
  50
  51 /*                cmd, param, offset, width, type, arg_name */
  52 #define DPNI_PREP_CFG(param, cfg) \
  53 do { \
  54         MC_PREP_OP(param, 0, 0,   32, uint16_t, cfg->adv.options); \
  55         MC_PREP_OP(param, 0, 32,   8, uint16_t, cfg->adv.num_queues); \
  56         MC_PREP_OP(param, 0, 40,   8, uint16_t, cfg->adv.num_tcs); \
  57         MC_PREP_OP(param, 0, 48,   8, uint16_t, cfg->adv.mac_entries); \
  58         MC_PREP_OP(param, 1, 0,   8, uint16_t, cfg->adv.vlan_entries); \
  59         MC_PREP_OP(param, 1, 16,   8, uint16_t, cfg->adv.qos_entries); \
  60         MC_PREP_OP(param, 1, 32,   16, uint16_t, cfg->adv.fs_entries); \
  61 } while (0)
  62
  63 /*                cmd, param, offset, width, type, arg_name */
  64 #define DPNI_EXT_CFG(param, cfg) \
  65 do { \
  66         MC_EXT_OP(param, 0, 0,   32, uint16_t, cfg->adv.options); \
  67         MC_EXT_OP(param, 0, 32,   8, uint16_t, cfg->adv.num_queues); \
  68         MC_EXT_OP(param, 0, 40,   8, uint16_t, cfg->adv.num_tcs); \
  69         MC_EXT_OP(param, 0, 48,   8, uint16_t, cfg->adv.mac_entries); \
  70         MC_EXT_OP(param, 1, 0,   8, uint16_t, cfg->adv.vlan_entries); \
  71         MC_EXT_OP(param, 1, 16,   8, uint16_t, cfg->adv.qos_entries); \
  72         MC_EXT_OP(param, 1, 32,   16, uint16_t, cfg->adv.fs_entries); \
  73 } while (0)
  74
  75 /*                cmd, param, offset, width, type, arg_name */
  76 #define DPNI_CMD_CREATE(cmd, cfg) \
  77 do { \
  78         MC_CMD_OP(cmd, 0, 0,    32,     uint32_t,  cfg->adv.options); \
  79         MC_CMD_OP(cmd, 0, 32,   8,      uint8_t,   cfg->adv.num_queues); \
  80         MC_CMD_OP(cmd, 0, 40,   8,      uint8_t,   cfg->adv.num_tcs); \
  81         MC_CMD_OP(cmd, 0, 48,   8,      uint8_t,   cfg->adv.mac_entries); \
  82         MC_CMD_OP(cmd, 1, 0,    8,      uint8_t,   cfg->adv.vlan_entries); \
  83         MC_CMD_OP(cmd, 1, 16,   8,      uint8_t,   cfg->adv.qos_entries); \
  84         MC_CMD_OP(cmd, 1, 32,   16,     uint8_t,   cfg->adv.fs_entries); \
  85 } while (0)
  86
  87 /*                cmd, param, offset, width, type, arg_name */
  88 #define DPNI_CMD_SET_POOLS(cmd, cfg) \
  89 do { \
  90         MC_CMD_OP(cmd, 0, 0,  8,  uint8_t,  cfg->num_dpbp); \
  91         MC_CMD_OP(cmd, 0, 8,  1,  int,      cfg->pools[0].backup_pool); \
  92         MC_CMD_OP(cmd, 0, 9,  1,  int,      cfg->pools[1].backup_pool); \
  93         MC_CMD_OP(cmd, 0, 10, 1,  int,      cfg->pools[2].backup_pool); \
  94         MC_CMD_OP(cmd, 0, 11, 1,  int,      cfg->pools[3].backup_pool); \
  95         MC_CMD_OP(cmd, 0, 12, 1,  int,      cfg->pools[4].backup_pool); \
  96         MC_CMD_OP(cmd, 0, 13, 1,  int,      cfg->pools[5].backup_pool); \
  97         MC_CMD_OP(cmd, 0, 14, 1,  int,      cfg->pools[6].backup_pool); \
  98         MC_CMD_OP(cmd, 0, 15, 1,  int,      cfg->pools[7].backup_pool); \
  99         MC_CMD_OP(cmd, 0, 32, 32, int,      cfg->pools[0].dpbp_id); \
 100         MC_CMD_OP(cmd, 4, 32, 16, uint16_t, cfg->pools[0].buffer_size);\
 101         MC_CMD_OP(cmd, 1, 0,  32, int,      cfg->pools[1].dpbp_id); \
 102         MC_CMD_OP(cmd, 4, 48, 16, uint16_t, cfg->pools[1].buffer_size);\
 103         MC_CMD_OP(cmd, 1, 32, 32, int,      cfg->pools[2].dpbp_id); \
 104         MC_CMD_OP(cmd, 5, 0,  16, uint16_t, cfg->pools[2].buffer_size);\
 105         MC_CMD_OP(cmd, 2, 0,  32, int,      cfg->pools[3].dpbp_id); \
 106         MC_CMD_OP(cmd, 5, 16, 16, uint16_t, cfg->pools[3].buffer_size);\
 107         MC_CMD_OP(cmd, 2, 32, 32, int,      cfg->pools[4].dpbp_id); \
 108         MC_CMD_OP(cmd, 5, 32, 16, uint16_t, cfg->pools[4].buffer_size);\
 109         MC_CMD_OP(cmd, 3, 0,  32, int,      cfg->pools[5].dpbp_id); \
 110         MC_CMD_OP(cmd, 5, 48, 16, uint16_t, cfg->pools[5].buffer_size);\
 111         MC_CMD_OP(cmd, 3, 32, 32, int,      cfg->pools[6].dpbp_id); \
 112         MC_CMD_OP(cmd, 6, 0,  16, uint16_t, cfg->pools[6].buffer_size);\
 113         MC_CMD_OP(cmd, 4, 0,  32, int,      cfg->pools[7].dpbp_id); \
 114         MC_CMD_OP(cmd, 6, 16, 16, uint16_t, cfg->pools[7].buffer_size);\
 115 } while (0)
 116
 117 /*                cmd, param, offset, width, type, arg_name */
 118 #define DPNI_RSP_GET_ATTR(cmd, attr) \
 119 do { \
 120         MC_RSP_OP(cmd, 0, 0,  32, int,      attr->options);\
 121         MC_RSP_OP(cmd, 0, 32,  8,  uint8_t,  attr->max_num_queues); \
 122         MC_RSP_OP(cmd, 0, 40,  8,  uint8_t,  attr->max_num_tcs); \
 123         MC_RSP_OP(cmd, 0, 48,  8,  uint8_t,  attr->max_mac_entries); \
 124         MC_RSP_OP(cmd, 1,  0,  8,  uint8_t,  attr->max_vlan_entries); \
 125         MC_RSP_OP(cmd, 1, 16,  8,  uint8_t,  attr->max_qos_entries); \
 126         MC_RSP_OP(cmd, 1, 32, 16,  uint16_t,  attr->max_fs_entries); \
 127         MC_RSP_OP(cmd, 2,  0,  8,  uint8_t,  attr->max_qos_key_size); \
 128         MC_RSP_OP(cmd, 2,  8,  8,  uint8_t,  attr->max_fs_key_size); \
 129         MC_RSP_OP(cmd, 2, 16, 16,  uint16_t,  attr->wriop_version); \
 130 } while (0)
 131
 132 /*                cmd, param, offset, width, type, arg_name */
 133 #define DPNI_CMD_SET_ERRORS_BEHAVIOR(cmd, cfg) \
 134 do { \
 135         MC_CMD_OP(cmd, 0, 0,  32, uint32_t, cfg->errors); \
 136         MC_CMD_OP(cmd, 0, 32, 4,  enum dpni_error_action, cfg->error_action); \
 137         MC_CMD_OP(cmd, 0, 36, 1,  int,      cfg->set_frame_annotation); \
 138 } while (0)
 139
 140 /*                cmd, param, offset, width, type, arg_name */
 141 #define DPNI_CMD_SET_BUFFER_LAYOUT(cmd, layout, queue) \
 142 do { \
 143         MC_CMD_OP(cmd, 0, 0,  8, enum dpni_queue_type, queue); \
 144         MC_CMD_OP(cmd, 1, 0,  16, uint16_t, layout->private_data_size); \
 145         MC_CMD_OP(cmd, 1, 16, 16, uint16_t, layout->data_align); \
 146         MC_CMD_OP(cmd, 0, 32, 16, uint16_t, layout->options); \
 147         MC_CMD_OP(cmd, 0, 48,  1,  int,     layout->pass_timestamp); \
 148         MC_CMD_OP(cmd, 0, 49,  1,  int,     layout->pass_parser_result); \
 149         MC_CMD_OP(cmd, 0, 50,  1,  int,     layout->pass_frame_status); \
 150         MC_CMD_OP(cmd, 1, 32, 16, uint16_t, layout->data_head_room); \
 151         MC_CMD_OP(cmd, 1, 48, 16, uint16_t, layout->data_tail_room); \
 152 } while (0)
 153
 154 /*                cmd, param, offset, width, type, arg_name */
 155 #define DPNI_RSP_GET_QDID(cmd, qdid) \
 156         MC_RSP_OP(cmd, 0, 0,  16, uint16_t, qdid)
 157
 158 /*                cmd, param, offset, width, type, arg_name */
 159 #define DPNI_RSP_GET_TX_DATA_OFFSET(cmd, data_offset) \
 160         MC_RSP_OP(cmd, 0, 0,  16, uint16_t, data_offset)
 161
 162 /*                cmd, param, offset, width, type, arg_name */
 163 #define DPNI_CMD_SET_LINK_CFG(cmd, cfg) \
 164 do { \
 165         MC_CMD_OP(cmd, 1, 0,  32, uint32_t, cfg->rate);\
 166         MC_CMD_OP(cmd, 2, 0,  64, uint64_t, cfg->options);\
 167 } while (0)
 168
 169 /*                cmd, param, offset, width, type, arg_name */
 170 #define DPNI_RSP_GET_LINK_STATE(cmd, state) \
 171 do { \
 172         MC_RSP_OP(cmd, 0, 32,  1, int,      state->up);\
 173         MC_RSP_OP(cmd, 1, 0,  32, uint32_t, state->rate);\
 174         MC_RSP_OP(cmd, 2, 0,  64, uint64_t, state->options);\
 175 } while (0)
 176
 177
 178
 179 /*                cmd, param, offset, width, type, arg_name */
 180 #define DPNI_CMD_SET_PRIMARY_MAC_ADDR(cmd, mac_addr) \
 181 do { \
 182         MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
 183         MC_CMD_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
 184         MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
 185         MC_CMD_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
 186         MC_CMD_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
 187         MC_CMD_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
 188 } while (0)
 189
 190 /*                cmd, param, offset, width, type, arg_name */
 191 #define DPNI_RSP_GET_PRIMARY_MAC_ADDR(cmd, mac_addr) \
 192 do { \
 193         MC_RSP_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
 194         MC_RSP_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
 195         MC_RSP_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
 196         MC_RSP_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
 197         MC_RSP_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
 198         MC_RSP_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
 199 } while (0)
 200
 201 /*                cmd, param, offset, width, type, arg_name */
 202 #define DPNI_CMD_ADD_MAC_ADDR(cmd, mac_addr) \
 203 do { \
 204         MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
 205         MC_CMD_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
 206         MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
 207         MC_CMD_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
 208         MC_CMD_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
 209         MC_CMD_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
 210 } while (0)
 211
 212 /*                cmd, param, offset, width, type, arg_name */
 213 #define DPNI_CMD_REMOVE_MAC_ADDR(cmd, mac_addr) \
 214 do { \
 215         MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
 216         MC_CMD_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
 217         MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
 218         MC_CMD_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
 219         MC_CMD_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
 220         MC_CMD_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
 221 } while (0)
 222
 223 #define DPNI_CMD_GET_QUEUE(cmd, type, tc, index) \
 224 do { \
 225         MC_CMD_OP(cmd, 0,  0,  8, enum dpni_queue_type, type); \
 226         MC_CMD_OP(cmd, 0,  8,  8, uint8_t, tc); \
 227         MC_CMD_OP(cmd, 0, 16,  8, uint8_t, index); \
 228 } while (0)
 229
 230 #define DPNI_RSP_GET_QUEUE(cmd, queue) \
 231 do { \
 232         MC_RSP_OP(cmd, 1,  0, 32, uint32_t, (queue)->destination.id); \
 233         MC_RSP_OP(cmd, 1, 56,  4, enum dpni_dest, (queue)->destination.type); \
 234         MC_RSP_OP(cmd, 1, 62,  1, char, (queue)->destination.stash_ctrl); \
 235         MC_RSP_OP(cmd, 1, 63,  1, char, (queue)->destination.hold_active); \
 236         MC_RSP_OP(cmd, 2,  0, 64, uint64_t, (queue)->flc); \
 237         MC_RSP_OP(cmd, 3,  0, 64, uint64_t, (queue)->user_context); \
 238         MC_RSP_OP(cmd, 4,  0, 32, uint32_t, (queue)->fqid); \
 239         MC_RSP_OP(cmd, 4, 32, 16, uint16_t, (queue)->qdbin); \
 240 } while (0)
 241
 242 #define DPNI_CMD_SET_QUEUE(cmd, type, tc, index, queue) \
 243 do { \
 244         MC_CMD_OP(cmd, 0,  0,  8, enum dpni_queue_type, type); \
 245         MC_CMD_OP(cmd, 0,  8,  8, uint8_t, tc); \
 246         MC_CMD_OP(cmd, 0, 16,  8, uint8_t, index); \
 247         MC_CMD_OP(cmd, 0, 24,  8, uint8_t, (queue)->options); \
 248         MC_CMD_OP(cmd, 1,  0, 32, uint32_t, (queue)->destination.id); \
 249         MC_CMD_OP(cmd, 1, 56,  4, enum dpni_dest, (queue)->destination.type); \
 250         MC_CMD_OP(cmd, 1, 62,  1, char, (queue)->destination.stash_ctrl); \
 251         MC_CMD_OP(cmd, 1, 63,  1, char, (queue)->destination.hold_active); \
 252         MC_CMD_OP(cmd, 1,  0, 32, uint32_t, (queue)->destination.id); \
 253         MC_CMD_OP(cmd, 2,  0, 64, uint64_t, (queue)->flc); \
 254         MC_CMD_OP(cmd, 3,  0, 64, uint64_t, (queue)->user_context); \
 255 } while (0)
 256
 257 /*                      cmd, param, offset, width, type, arg_name */
 258 #define DPNI_CMD_GET_STATISTICS(cmd, page) \
 259         MC_CMD_OP(cmd, 0, 0, 8, uint8_t, page)
 260
 261 /*                cmd, param, offset, width, type, arg_name */
 262 #define DPNI_RSP_GET_STATISTICS(cmd, stat) \
 263 do { \
 264         MC_RSP_OP(cmd, 0, 0, 64, uint64_t, (stat)->counter0); \
 265         MC_RSP_OP(cmd, 1, 0, 64, uint64_t, (stat)->counter1); \
 266         MC_RSP_OP(cmd, 2, 0, 64, uint64_t, (stat)->counter2); \
 267         MC_RSP_OP(cmd, 3, 0, 64, uint64_t, (stat)->counter3); \
 268         MC_RSP_OP(cmd, 4, 0, 64, uint64_t, (stat)->counter4); \
 269         MC_RSP_OP(cmd, 5, 0, 64, uint64_t, (stat)->counter5); \
 270         MC_RSP_OP(cmd, 6, 0, 64, uint64_t, (stat)->counter6); \
 271 } while (0)
 272
 273 enum net_prot {
 274         NET_PROT_NONE = 0,
 275         NET_PROT_PAYLOAD,
 276         NET_PROT_ETH,
 277         NET_PROT_VLAN,
 278         NET_PROT_IPV4,
 279         NET_PROT_IPV6,
 280         NET_PROT_IP,
 281         NET_PROT_TCP,
 282         NET_PROT_UDP,
 283         NET_PROT_UDP_LITE,
 284         NET_PROT_IPHC,
 285         NET_PROT_SCTP,
 286         NET_PROT_SCTP_CHUNK_DATA,
 287         NET_PROT_PPPOE,
 288         NET_PROT_PPP,
 289         NET_PROT_PPPMUX,
 290         NET_PROT_PPPMUX_SUBFRM,
 291         NET_PROT_L2TPV2,
 292         NET_PROT_L2TPV3_CTRL,
 293         NET_PROT_L2TPV3_SESS,
 294         NET_PROT_LLC,
 295         NET_PROT_LLC_SNAP,
 296         NET_PROT_NLPID,
 297         NET_PROT_SNAP,
 298         NET_PROT_MPLS,
 299         NET_PROT_IPSEC_AH,
 300         NET_PROT_IPSEC_ESP,
 301         NET_PROT_UDP_ENC_ESP, /* RFC 3948 */
 302         NET_PROT_MACSEC,
 303         NET_PROT_GRE,
 304         NET_PROT_MINENCAP,
 305         NET_PROT_DCCP,
 306         NET_PROT_ICMP,
 307         NET_PROT_IGMP,
 308         NET_PROT_ARP,
 309         NET_PROT_CAPWAP_DATA,
 310         NET_PROT_CAPWAP_CTRL,
 311         NET_PROT_RFC2684,
 312         NET_PROT_ICMPV6,
 313         NET_PROT_FCOE,
 314         NET_PROT_FIP,
 315         NET_PROT_ISCSI,
 316         NET_PROT_GTP,
 317         NET_PROT_USER_DEFINED_L2,
 318         NET_PROT_USER_DEFINED_L3,
 319         NET_PROT_USER_DEFINED_L4,
 320         NET_PROT_USER_DEFINED_L5,
 321         NET_PROT_USER_DEFINED_SHIM1,
 322         NET_PROT_USER_DEFINED_SHIM2,
 323
 324         NET_PROT_DUMMY_LAST
 325 };
 326
 327 /**
 328  * Data Path Network Interface API
 329  * Contains initialization APIs and runtime control APIs for DPNI
 330  */
 331
 332 struct fsl_mc_io;
 333
 334 /* General DPNI macros */
 335
 336 /* Maximum number of traffic classes */
 337 #define DPNI_MAX_TC                             8
 338 /* Maximum number of buffer pools per DPNI */
 339 #define DPNI_MAX_DPBP                           8
 340
 341 /* All traffic classes considered; see dpni_set_rx_flow() */
 342 #define DPNI_ALL_TCS                            (uint8_t)(-1)
 343 /* All flows within traffic class considered; see dpni_set_rx_flow() */
 344 #define DPNI_ALL_TC_FLOWS                       (uint16_t)(-1)
 345 /* Generate new flow ID; see dpni_set_tx_flow() */
 346 #define DPNI_NEW_FLOW_ID                        (uint16_t)(-1)
 347 /* use for common tx-conf queue; see dpni_set_tx_conf_<x>() */
 348 #define DPNI_COMMON_TX_CONF                     (uint16_t)(-1)
 349
 350 /**
 351  * dpni_open() - Open a control session for the specified object
 352  * @mc_io:      Pointer to MC portal's I/O object
 353  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 354  * @dpni_id:    DPNI unique ID
 355  * @token:      Returned token; use in subsequent API calls
 356  *
 357  * This function can be used to open a control session for an
 358  * already created object; an object may have been declared in
 359  * the DPL or by calling the dpni_create() function.
 360  * This function returns a unique authentication token,
 361  * associated with the specific object ID and the specific MC
 362  * portal; this token must be used in all subsequent commands for
 363  * this specific object.
 364  *
 365  * Return:      '0' on Success; Error code otherwise.
 366  */
 367 int dpni_open(struct fsl_mc_io  *mc_io,
 368               uint32_t          cmd_flags,
 369               int               dpni_id,
 370               uint16_t          *token);
 371
 372 /**
 373  * dpni_close() - Close the control session of the object
 374  * @mc_io:      Pointer to MC portal's I/O object
 375  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 376  * @token:      Token of DPNI object
 377  *
 378  * After this function is called, no further operations are
 379  * allowed on the object without opening a new control session.
 380  *
 381  * Return:      '0' on Success; Error code otherwise.
 382  */
 383 int dpni_close(struct fsl_mc_io *mc_io,
 384                uint32_t         cmd_flags,
 385                uint16_t         token);
 386
 387 /* DPNI configuration options */
 388
 389 /**
 390  * Allow different distribution key profiles for different traffic classes;
 391  * if not set, a single key profile is assumed
 392  */
 393 #define DPNI_OPT_ALLOW_DIST_KEY_PER_TC          0x00000001
 394
 395 /**
 396  * Disable all non-error transmit confirmation; error frames are reported
 397  * back to a common Tx error queue
 398  */
 399 #define DPNI_OPT_TX_CONF_DISABLED               0x00000002
 400
 401 /* Disable per-sender private Tx confirmation/error queue */
 402 #define DPNI_OPT_PRIVATE_TX_CONF_ERROR_DISABLED 0x00000004
 403
 404 /**
 405  * Support distribution based on hashed key;
 406  * allows statistical distribution over receive queues in a traffic class
 407  */
 408 #define DPNI_OPT_DIST_HASH                      0x00000010
 409
 410 /**
 411  * Support distribution based on flow steering;
 412  * allows explicit control of distribution over receive queues in a traffic
 413  * class
 414  */
 415 #define DPNI_OPT_DIST_FS                        0x00000020
 416
 417 /* Unicast filtering support */
 418 #define DPNI_OPT_UNICAST_FILTER                 0x00000080
 419 /* Multicast filtering support */
 420 #define DPNI_OPT_MULTICAST_FILTER               0x00000100
 421 /* VLAN filtering support */
 422 #define DPNI_OPT_VLAN_FILTER                    0x00000200
 423 /* Support IP reassembly on received packets */
 424 #define DPNI_OPT_IPR                            0x00000800
 425 /* Support IP fragmentation on transmitted packets */
 426 #define DPNI_OPT_IPF                            0x00001000
 427 /* VLAN manipulation support */
 428 #define DPNI_OPT_VLAN_MANIPULATION              0x00010000
 429 /* Support masking of QoS lookup keys */
 430 #define DPNI_OPT_QOS_MASK_SUPPORT               0x00020000
 431 /* Support masking of Flow Steering lookup keys */
 432 #define DPNI_OPT_FS_MASK_SUPPORT                0x00040000
 433
 434 /**
 435  * enum dpni_queue_type - Identifies a type of queue targeted by the command
 436  * @DPNI_QUEUE_RX: Rx queue
 437  * @DPNI_QUEUE_TX: Tx queue
 438  * @DPNI_QUEUE_TX_CONFIRM: Tx confirmation queue
 439  * @DPNI_QUEUE_RX_ERR: Rx error queue
 440  */
 441 enum dpni_queue_type {
 442         DPNI_QUEUE_RX,
 443         DPNI_QUEUE_TX,
 444         DPNI_QUEUE_TX_CONFIRM,
 445         DPNI_QUEUE_RX_ERR,
 446 };
 447
 448 struct dpni_cfg {
 449                 uint8_t mac_addr[6];
 450         struct {
 451                 uint32_t                options;
 452                 uint16_t                fs_entries;
 453                 uint8_t                 num_queues;
 454                 uint8_t                 num_tcs;
 455                 uint8_t                 mac_entries;
 456                 uint8_t                 vlan_entries;
 457                 uint8_t                 qos_entries;
 458         } adv;
 459 };
 460
 461 /**
 462  * struct dpni_extended_cfg - Structure representing extended DPNI configuration
 463  * @tc_cfg: TCs configuration
 464  * @ipr_cfg: IP reassembly configuration
 465  */
 466 struct dpni_extended_cfg {
 467         /**
 468          * struct tc_cfg - TC configuration
 469          * @max_dist: Maximum distribution size for Rx traffic class;
 470          *      supported values: 1,2,3,4,6,7,8,12,14,16,24,28,32,48,56,64,96,
 471          *      112,128,192,224,256,384,448,512,768,896,1024;
 472          *      value '0' will be treated as '1'.
 473          *      other unsupported values will be round down to the nearest
 474          *      supported value.
 475          * @max_fs_entries: Maximum FS entries for Rx traffic class;
 476          *      '0' means no support for this TC;
 477          */
 478         struct {
 479                 uint16_t        max_dist;
 480                 uint16_t        max_fs_entries;
 481         } tc_cfg[DPNI_MAX_TC];
 482         /**
 483          * struct ipr_cfg - Structure representing IP reassembly configuration
 484          * @max_reass_frm_size: Maximum size of the reassembled frame
 485          * @min_frag_size_ipv4: Minimum fragment size of IPv4 fragments
 486          * @min_frag_size_ipv6: Minimum fragment size of IPv6 fragments
 487          * @max_open_frames_ipv4: Maximum concurrent IPv4 packets in reassembly
 488          *              process
 489          * @max_open_frames_ipv6: Maximum concurrent IPv6 packets in reassembly
 490          *              process
 491          */
 492         struct {
 493                 uint16_t max_reass_frm_size;
 494                 uint16_t min_frag_size_ipv4;
 495                 uint16_t min_frag_size_ipv6;
 496                 uint16_t max_open_frames_ipv4;
 497                 uint16_t max_open_frames_ipv6;
 498         } ipr_cfg;
 499 };
 500
 501 /**
 502  * dpni_prepare_cfg() - function prepare parameters
 503  * @cfg: cfg structure
 504  * @cfg_buf: Zeroed 256 bytes of memory before mapping it to DMA
 505  *
 506  * This function has to be called before dpni_create()
 507  */
 508 int dpni_prepare_cfg(const struct dpni_cfg      *cfg,
 509                      uint8_t                    *cfg_buf);
 510 /**
 511  * dpni_create() - Create the DPNI object
 512  * @mc_io:      Pointer to MC portal's I/O object
 513  * @token:      Authentication token.
 514  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 515  * @cfg:        Configuration structure
 516  * @obj_id:     Returned obj_id; use in subsequent API calls
 517  *
 518  * Create the DPNI object, allocate required resources and
 519  * perform required initialization.
 520  *
 521  * The object can be created either by declaring it in the
 522  * DPL file, or by calling this function.
 523  *
 524  * This function returns a unique authentication token,
 525  * associated with the specific object ID and the specific MC
 526  * portal; this token must be used in all subsequent calls to
 527  * this specific object. For objects that are created using the
 528  * DPL file, call dpni_open() function to get an authentication
 529  * token first.
 530  *
 531  * Return:      '0' on Success; Error code otherwise.
 532  */
 533 int dpni_create(struct fsl_mc_io        *mc_io,
 534                 uint16_t                token,
 535                 uint32_t                cmd_flags,
 536                 const struct dpni_cfg   *cfg,
 537                 uint32_t                *obj_id);
 538
 539 /**
 540  * dpni_destroy() - Destroy the DPNI object and release all its resources.
 541  * @mc_io:      Pointer to MC portal's I/O object
 542  * @token:      Authentication token.
 543  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 544  * @obj_id:     Returned obj_id; use in subsequent API calls
 545  *
 546  * Return:      '0' on Success; error code otherwise.
 547  */
 548 int dpni_destroy(struct fsl_mc_io       *mc_io,
 549                  uint16_t               token,
 550                  uint32_t               cmd_flags,
 551                  uint32_t               obj_id);
 552
 553 /**
 554  * struct dpni_pools_cfg - Structure representing buffer pools configuration
 555  * @num_dpbp: Number of DPBPs
 556  * @pools: Array of buffer pools parameters; The number of valid entries
 557  *      must match 'num_dpbp' value
 558  */
 559 struct dpni_pools_cfg {
 560         uint8_t num_dpbp;
 561         /**
 562          * struct pools - Buffer pools parameters
 563          * @dpbp_id: DPBP object ID
 564          * @buffer_size: Buffer size
 565          * @backup_pool: Backup pool
 566          */
 567         struct {
 568                 int             dpbp_id;
 569                 uint16_t        buffer_size;
 570                 int             backup_pool;
 571         } pools[DPNI_MAX_DPBP];
 572 };
 573
 574 /**
 575  * dpni_set_pools() - Set buffer pools configuration
 576  * @mc_io:      Pointer to MC portal's I/O object
 577  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 578  * @token:      Token of DPNI object
 579  * @cfg:        Buffer pools configuration
 580  *
 581  * mandatory for DPNI operation
 582  * warning:Allowed only when DPNI is disabled
 583  *
 584  * Return:      '0' on Success; Error code otherwise.
 585  */
 586 int dpni_set_pools(struct fsl_mc_io             *mc_io,
 587                    uint32_t                     cmd_flags,
 588                    uint16_t                     token,
 589                    const struct dpni_pools_cfg  *cfg);
 590
 591 /**
 592  * dpni_enable() - Enable the DPNI, allow sending and receiving frames.
 593  * @mc_io:      Pointer to MC portal's I/O object
 594  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 595  * @token:              Token of DPNI object
 596  *
 597  * Return:      '0' on Success; Error code otherwise.
 598  */
 599 int dpni_enable(struct fsl_mc_io        *mc_io,
 600                 uint32_t                cmd_flags,
 601                 uint16_t                token);
 602
 603 /**
 604  * dpni_disable() - Disable the DPNI, stop sending and receiving frames.
 605  * @mc_io:      Pointer to MC portal's I/O object
 606  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 607  * @token:      Token of DPNI object
 608  *
 609  * Return:      '0' on Success; Error code otherwise.
 610  */
 611 int dpni_disable(struct fsl_mc_io       *mc_io,
 612                  uint32_t               cmd_flags,
 613                  uint16_t               token);
 614
 615
 616 /**
 617  * dpni_reset() - Reset the DPNI, returns the object to initial state.
 618  * @mc_io:      Pointer to MC portal's I/O object
 619  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 620  * @token:      Token of DPNI object
 621  *
 622  * Return:      '0' on Success; Error code otherwise.
 623  */
 624 int dpni_reset(struct fsl_mc_io *mc_io,
 625                uint32_t         cmd_flags,
 626                uint16_t         token);
 627
 628 /**
 629  * struct dpni_attr - Structure representing DPNI attributes
 630  * @options: Mask of available options; reflects the value as was given in
 631  *              object's creation
 632  * @max_num_queues: Number of queues available (for both Tx and Rx)
 633  * @max_num_tcs: Maximum number of traffic classes (for both Tx and Rx)
 634  * @max_mac_entries: Maximum number of traffic classes (for both Tx and Rx)
 635  * @max_unicast_filters: Maximum number of unicast filters
 636  * @max_multicast_filters: Maximum number of multicast filters
 637  * @max_vlan_entries: Maximum number of VLAN filters
 638  * @max_qos_entries: if 'max_tcs > 1', declares the maximum entries in QoS table
 639  * @max_fs_entries: declares the maximum entries in flow steering table
 640  * @max_qos_key_size: Maximum key size for the QoS look-up
 641  * @max_fs_key_size: Maximum key size for the flow steering
 642  * @wriop_version: Indicates revision of WRIOP hardware block
 643  */
 644 struct dpni_attr {
 645         uint32_t id;
 646         uint32_t options;
 647         uint8_t max_num_queues;
 648         uint8_t max_num_tcs;
 649         uint8_t max_mac_entries;
 650         uint8_t max_vlan_entries;
 651         uint8_t max_qos_entries;
 652         uint16_t max_fs_entries;
 653         uint8_t max_qos_key_size;
 654         uint8_t max_fs_key_size;
 655         uint16_t wriop_version;
 656 };
 657
 658 /**
 659  * dpni_get_attributes() - Retrieve DPNI attributes.
 660  * @mc_io:      Pointer to MC portal's I/O object
 661  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 662  * @token:      Token of DPNI object
 663  * @attr:       Object's attributes
 664  *
 665  * Return:      '0' on Success; Error code otherwise.
 666  */
 667 int dpni_get_attributes(struct fsl_mc_io        *mc_io,
 668                         uint32_t                cmd_flags,
 669                         uint16_t                token,
 670                         struct dpni_attr        *attr);
 671
 672 /**
 673  * dpni_extract_cfg() - extract the parameters
 674  * @cfg: cfg structure
 675  * @cfg_buf: 256 bytes of DMA-able memory
 676  *
 677  * This function has to be called after dpni_get_attributes()
 678  */
 679 int dpni_extract_cfg(struct dpni_cfg    *cfg,
 680                      const uint8_t      *cfg_buf);
 681
 682 /**
 683  * DPNI errors
 684  */
 685
 686 /**
 687  * Extract out of frame header error
 688  */
 689 #define DPNI_ERROR_EOFHE        0x00020000
 690 /**
 691  * Frame length error
 692  */
 693 #define DPNI_ERROR_FLE          0x00002000
 694 /**
 695  * Frame physical error
 696  */
 697 #define DPNI_ERROR_FPE          0x00001000
 698 /**
 699  * Parsing header error
 700  */
 701 #define DPNI_ERROR_PHE          0x00000020
 702 /**
 703  * Parser L3 checksum error
 704  */
 705 #define DPNI_ERROR_L3CE         0x00000004
 706 /**
 707  * Parser L3 checksum error
 708  */
 709 #define DPNI_ERROR_L4CE         0x00000001
 710
 711 /**
 712  * enum dpni_error_action - Defines DPNI behavior for errors
 713  * @DPNI_ERROR_ACTION_DISCARD: Discard the frame
 714  * @DPNI_ERROR_ACTION_CONTINUE: Continue with the normal flow
 715  * @DPNI_ERROR_ACTION_SEND_TO_ERROR_QUEUE: Send the frame to the error queue
 716  */
 717 enum dpni_error_action {
 718         DPNI_ERROR_ACTION_DISCARD = 0,
 719         DPNI_ERROR_ACTION_CONTINUE = 1,
 720         DPNI_ERROR_ACTION_SEND_TO_ERROR_QUEUE = 2
 721 };
 722
 723 /**
 724  * struct dpni_error_cfg - Structure representing DPNI errors treatment
 725  * @errors: Errors mask; use 'DPNI_ERROR__<X>
 726  * @error_action: The desired action for the errors mask
 727  * @set_frame_annotation: Set to '1' to mark the errors in frame annotation
 728  *              status (FAS); relevant only for the non-discard action
 729  */
 730 struct dpni_error_cfg {
 731         uint32_t                errors;
 732         enum dpni_error_action  error_action;
 733         int                     set_frame_annotation;
 734 };
 735
 736 /**
 737  * dpni_set_errors_behavior() - Set errors behavior
 738  * @mc_io:      Pointer to MC portal's I/O object
 739  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 740  * @token:      Token of DPNI object
 741  * @cfg:        Errors configuration
 742  *
 743  * this function may be called numerous times with different
 744  * error masks
 745  *
 746  * Return:      '0' on Success; Error code otherwise.
 747  */
 748 int dpni_set_errors_behavior(struct fsl_mc_io           *mc_io,
 749                              uint32_t                   cmd_flags,
 750                              uint16_t                   token,
 751                              struct dpni_error_cfg      *cfg);
 752
 753 /* DPNI buffer layout modification options */
 754
 755 /* Select to modify the time-stamp setting */
 756 #define DPNI_BUF_LAYOUT_OPT_TIMESTAMP           0x00000001
 757 /* Select to modify the parser-result setting; not applicable for Tx */
 758 #define DPNI_BUF_LAYOUT_OPT_PARSER_RESULT       0x00000002
 759 /* Select to modify the frame-status setting */
 760 #define DPNI_BUF_LAYOUT_OPT_FRAME_STATUS        0x00000004
 761 /* Select to modify the private-data-size setting */
 762 #define DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE   0x00000008
 763 /* Select to modify the data-alignment setting */
 764 #define DPNI_BUF_LAYOUT_OPT_DATA_ALIGN          0x00000010
 765 /* Select to modify the data-head-room setting */
 766 #define DPNI_BUF_LAYOUT_OPT_DATA_HEAD_ROOM      0x00000020
 767 /*!< Select to modify the data-tail-room setting */
 768 #define DPNI_BUF_LAYOUT_OPT_DATA_TAIL_ROOM      0x00000040
 769
 770 /**
 771  * struct dpni_buffer_layout - Structure representing DPNI buffer layout
 772  * @options: Flags representing the suggested modifications to the buffer
 773  *              layout; Use any combination of 'DPNI_BUF_LAYOUT_OPT_<X>' flags
 774  * @pass_timestamp: Pass timestamp value
 775  * @pass_parser_result: Pass parser results
 776  * @pass_frame_status: Pass frame status
 777  * @private_data_size: Size kept for private data (in bytes)
 778  * @data_align: Data alignment
 779  * @data_head_room: Data head room
 780  * @data_tail_room: Data tail room
 781  */
 782 struct dpni_buffer_layout {
 783         uint16_t options;
 784         int pass_timestamp;
 785         int pass_parser_result;
 786         int pass_frame_status;
 787         uint16_t private_data_size;
 788         uint16_t data_align;
 789         uint16_t data_head_room;
 790         uint16_t data_tail_room;
 791 };
 792
 793 /**
 794  * dpni_get_buffer_layout() - Retrieve buffer layout attributes.
 795  * @mc_io:      Pointer to MC portal's I/O object
 796  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 797  * @token:      Token of DPNI object
 798  * @layout:     Returns buffer layout attributes
 799  * @type:       DPNI queue type
 800  *
 801  * Return:      '0' on Success; Error code otherwise.
 802  */
 803 int dpni_get_buffer_layout(struct fsl_mc_io                     *mc_io,
 804                            uint32_t                             cmd_flags,
 805                            uint16_t                             token,
 806                            const struct dpni_buffer_layout      *layout,
 807                            enum dpni_queue_type                 type);
 808
 809 /**
 810  * dpni_set_buffer_layout() - Set buffer layout configuration.
 811  * @mc_io:      Pointer to MC portal's I/O object
 812  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 813  * @token:      Token of DPNI object
 814  * @layout:     Buffer layout configuration
 815  * @type:       DPNI queue type
 816  *
 817  * Return:      '0' on Success; Error code otherwise.
 818  *
 819  * @warning     Allowed only when DPNI is disabled
 820  */
 821 int dpni_set_buffer_layout(struct fsl_mc_io                     *mc_io,
 822                            uint32_t                             cmd_flags,
 823                            uint16_t                             token,
 824                            const struct dpni_buffer_layout      *layout,
 825                            enum dpni_queue_type                 type);
 826
 827 /**
 828  * dpni_get_qdid() - Get the Queuing Destination ID (QDID) that should be used
 829  *                      for enqueue operations
 830  * @mc_io:      Pointer to MC portal's I/O object
 831  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 832  * @token:      Token of DPNI object
 833  * @qdid:       Returned virtual QDID value that should be used as an argument
 834  *                      in all enqueue operations
 835  *
 836  * Return:      '0' on Success; Error code otherwise.
 837  */
 838 int dpni_get_qdid(struct fsl_mc_io      *mc_io,
 839                   uint32_t              cmd_flags,
 840                   uint16_t              token,
 841                   uint16_t              *qdid);
 842
 843 /**
 844  * dpni_get_tx_data_offset() - Get the Tx data offset (from start of buffer)
 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  * @data_offset: Tx data offset (from start of buffer)
 849  *
 850  * Return:      '0' on Success; Error code otherwise.
 851  */
 852 int dpni_get_tx_data_offset(struct fsl_mc_io    *mc_io,
 853                             uint32_t            cmd_flags,
 854                             uint16_t            token,
 855                             uint16_t            *data_offset);
 856
 857 /* Enable auto-negotiation */
 858 #define DPNI_LINK_OPT_AUTONEG           0x0000000000000001ULL
 859 /* Enable half-duplex mode */
 860 #define DPNI_LINK_OPT_HALF_DUPLEX       0x0000000000000002ULL
 861 /* Enable pause frames */
 862 #define DPNI_LINK_OPT_PAUSE             0x0000000000000004ULL
 863 /* Enable a-symmetric pause frames */
 864 #define DPNI_LINK_OPT_ASYM_PAUSE        0x0000000000000008ULL
 865
 866 /**
 867  * struct - Structure representing DPNI link configuration
 868  * @rate: Rate
 869  * @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values
 870  */
 871 struct dpni_link_cfg {
 872         uint32_t rate;
 873         uint64_t options;
 874 };
 875
 876 /**
 877  * dpni_set_link_cfg() - set the link configuration.
 878  * @mc_io:      Pointer to MC portal's I/O object
 879  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 880  * @token:      Token of DPNI object
 881  * @cfg:        Link configuration
 882  *
 883  * Return:      '0' on Success; Error code otherwise.
 884  */
 885 int dpni_set_link_cfg(struct fsl_mc_io                  *mc_io,
 886                       uint32_t                          cmd_flags,
 887                       uint16_t                          token,
 888                       const struct dpni_link_cfg        *cfg);
 889
 890 /**
 891  * struct dpni_link_state - Structure representing DPNI link state
 892  * @rate: Rate
 893  * @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values
 894  * @up: Link state; '0' for down, '1' for up
 895  */
 896 struct dpni_link_state {
 897         uint32_t rate;
 898         uint64_t options;
 899         int up;
 900 };
 901
 902 /**
 903  * dpni_get_link_state() - Return the link state (either up or down)
 904  * @mc_io:      Pointer to MC portal's I/O object
 905  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 906  * @token:      Token of DPNI object
 907  * @state:      Returned link state;
 908  *
 909  * Return:      '0' on Success; Error code otherwise.
 910  */
 911 int dpni_get_link_state(struct fsl_mc_io        *mc_io,
 912                         uint32_t                cmd_flags,
 913                         uint16_t                token,
 914                         struct dpni_link_state  *state);
 915
 916 /**
 917  * dpni_set_primary_mac_addr() - Set the primary MAC address
 918  * @mc_io:      Pointer to MC portal's I/O object
 919  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 920  * @token:      Token of DPNI object
 921  * @mac_addr:   MAC address to set as primary address
 922  *
 923  * Return:      '0' on Success; Error code otherwise.
 924  */
 925 int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
 926                               uint32_t          cmd_flags,
 927                               uint16_t          token,
 928                               const uint8_t     mac_addr[6]);
 929
 930 /**
 931  * dpni_get_primary_mac_addr() - Get the primary MAC address
 932  * @mc_io:      Pointer to MC portal's I/O object
 933  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 934  * @token:      Token of DPNI object
 935  * @mac_addr:   Returned MAC address
 936  *
 937  * Return:      '0' on Success; Error code otherwise.
 938  */
 939 int dpni_get_primary_mac_addr(struct fsl_mc_io  *mc_io,
 940                               uint32_t          cmd_flags,
 941                               uint16_t          token,
 942                               uint8_t           mac_addr[6]);
 943
 944 /**
 945  * dpni_add_mac_addr() - Add MAC address filter
 946  * @mc_io:      Pointer to MC portal's I/O object
 947  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 948  * @token:      Token of DPNI object
 949  * @mac_addr:   MAC address to add
 950  *
 951  * Return:      '0' on Success; Error code otherwise.
 952  */
 953 int dpni_add_mac_addr(struct fsl_mc_io  *mc_io,
 954                       uint32_t          cmd_flags,
 955                       uint16_t          token,
 956                       const uint8_t     mac_addr[6]);
 957
 958 /**
 959  * dpni_remove_mac_addr() - Remove MAC address filter
 960  * @mc_io:      Pointer to MC portal's I/O object
 961  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 962  * @token:      Token of DPNI object
 963  * @mac_addr:   MAC address to remove
 964  *
 965  * Return:      '0' on Success; Error code otherwise.
 966  */
 967 int dpni_remove_mac_addr(struct fsl_mc_io       *mc_io,
 968                          uint32_t               cmd_flags,
 969                          uint16_t               token,
 970                          const uint8_t          mac_addr[6]);
 971
 972 /**
 973  * enum dpni_dest - DPNI destination types
 974  * @DPNI_DEST_NONE: Unassigned destination; The queue is set in parked mode and
 975  *              does not generate FQDAN notifications; user is expected to
 976  *              dequeue from the queue based on polling or other user-defined
 977  *              method
 978  * @DPNI_DEST_DPIO: The queue is set in schedule mode and generates FQDAN
 979  *              notifications to the specified DPIO; user is expected to dequeue
 980  *              from the queue only after notification is received
 981  * @DPNI_DEST_DPCON: The queue is set in schedule mode and does not generate
 982  *              FQDAN notifications, but is connected to the specified DPCON
 983  *              object; user is expected to dequeue from the DPCON channel
 984  */
 985 enum dpni_dest {
 986         DPNI_DEST_NONE = 0,
 987         DPNI_DEST_DPIO = 1,
 988         DPNI_DEST_DPCON = 2
 989 };
 990
 991 /**
 992  * struct dpni_dest_cfg - Structure representing DPNI destination parameters
 993  * @dest_type: Destination type
 994  * @dest_id: Either DPIO ID or DPCON ID, depending on the destination type
 995  * @priority: Priority selection within the DPIO or DPCON channel; valid values
 996  *              are 0-1 or 0-7, depending on the number of priorities in that
 997  *              channel; not relevant for 'DPNI_DEST_NONE' option
 998  */
 999 struct dpni_dest_cfg {
1000         enum dpni_dest dest_type;
1001         int dest_id;
1002         uint8_t priority;
1003 };
1004
1005 /**
1006  * enum dpni_flc_type - DPNI FLC types
1007  * @DPNI_FLC_USER_DEFINED: select the FLC to be used for user defined value
1008  * @DPNI_FLC_STASH: select the FLC to be used for stash control
1009  */
1010 enum dpni_flc_type {
1011         DPNI_FLC_USER_DEFINED = 0,
1012         DPNI_FLC_STASH = 1,
1013 };
1014
1015 /**
1016  * enum dpni_stash_size - DPNI FLC stashing size
1017  * @DPNI_STASH_SIZE_0B: no stash
1018  * @DPNI_STASH_SIZE_64B: stashes 64 bytes
1019  * @DPNI_STASH_SIZE_128B: stashes 128 bytes
1020  * @DPNI_STASH_SIZE_192B: stashes 192 bytes
1021  */
1022 enum dpni_stash_size {
1023         DPNI_STASH_SIZE_0B = 0,
1024         DPNI_STASH_SIZE_64B = 1,
1025         DPNI_STASH_SIZE_128B = 2,
1026         DPNI_STASH_SIZE_192B = 3,
1027 };
1028
1029 /* DPNI FLC stash options */
1030
1031 /* stashes the whole annotation area (up to 192 bytes) */
1032 #define DPNI_FLC_STASH_FRAME_ANNOTATION 0x00000001
1033
1034 /**
1035  * struct dpni_flc_cfg - Structure representing DPNI FLC configuration
1036  * @flc_type: FLC type
1037  * @options: Mask of available options;
1038  *      use 'DPNI_FLC_STASH_<X>' values
1039  * @frame_data_size: Size of frame data to be stashed
1040  * @flow_context_size: Size of flow context to be stashed
1041  * @flow_context: 1. In case flc_type is 'DPNI_FLC_USER_DEFINED':
1042  *                      this value will be provided in the frame descriptor
1043  *                      (FD[FLC])
1044  *                2. In case flc_type is 'DPNI_FLC_STASH':
1045  *                      this value will be I/O virtual address of the
1046  *                      flow-context;
1047  *                      Must be cacheline-aligned and DMA-able memory
1048  */
1049 struct dpni_flc_cfg {
1050         enum dpni_flc_type flc_type;
1051         uint32_t options;
1052         enum dpni_stash_size frame_data_size;
1053         enum dpni_stash_size flow_context_size;
1054         uint64_t flow_context;
1055 };
1056
1057 /* DPNI queue modification options */
1058
1059 /* Select to modify the user's context associated with the queue */
1060 #define DPNI_QUEUE_OPT_USER_CTX         0x00000001
1061 /* Select to modify the queue's destination */
1062 #define DPNI_QUEUE_OPT_DEST             0x00000002
1063 /** Select to modify the flow-context parameters;
1064  * not applicable for Tx-conf/Err queues as the FD comes from the user
1065  */
1066 #define DPNI_QUEUE_OPT_FLC              0x00000004
1067 /* Select to modify the queue's order preservation */
1068 #define DPNI_QUEUE_OPT_ORDER_PRESERVATION 0x00000008
1069 /* Select to modify the queue's tail-drop threshold */
1070 #define DPNI_QUEUE_OPT_TAILDROP_THRESHOLD 0x00000010
1071
1072 /**
1073  * struct dpni_queue_cfg - Structure representing queue configuration
1074  * @options: Flags representing the suggested modifications to the queue;
1075  *              Use any combination of 'DPNI_QUEUE_OPT_<X>' flags
1076  * @user_ctx: User context value provided in the frame descriptor of each
1077  *              dequeued frame; valid only if 'DPNI_QUEUE_OPT_USER_CTX'
1078  *              is contained in 'options'
1079  * @dest_cfg: Queue destination parameters;
1080  *              valid only if 'DPNI_QUEUE_OPT_DEST' is contained in 'options'
1081  * @flc_cfg: Flow context configuration; in case the TC's distribution
1082  *              is either NONE or HASH the FLC's settings of flow#0 are used.
1083  *              in the case of FS (flow-steering) the flow's FLC settings
1084  *              are used.
1085  *              valid only if 'DPNI_QUEUE_OPT_FLC' is contained in 'options'
1086  * @order_preservation_en: enable/disable order preservation;
1087  *              valid only if 'DPNI_QUEUE_OPT_ORDER_PRESERVATION' is contained
1088  *              in 'options'
1089  * @tail_drop_threshold: set the queue's tail drop threshold in bytes;
1090  *              '0' value disable the threshold; maximum value is 0xE000000;
1091  *              valid only if 'DPNI_QUEUE_OPT_TAILDROP_THRESHOLD' is contained
1092  *              in 'options'
1093  */
1094 struct dpni_queue_cfg {
1095         uint32_t options;
1096         uint64_t user_ctx;
1097         struct dpni_dest_cfg dest_cfg;
1098         struct dpni_flc_cfg flc_cfg;
1099         int order_preservation_en;
1100         uint32_t tail_drop_threshold;
1101 };
1102
1103 /**
1104  * struct dpni_queue_attr - Structure representing queue attributes
1105  * @user_ctx: User context value provided in the frame descriptor of each
1106  *      dequeued frame
1107  * @dest_cfg: Queue destination configuration
1108  * @flc_cfg: Flow context configuration
1109  * @order_preservation_en: enable/disable order preservation
1110  * @tail_drop_threshold: queue's tail drop threshold in bytes;
1111  * @fqid: Virtual fqid value to be used for dequeue operations
1112  */
1113 struct dpni_queue_attr {
1114         uint64_t user_ctx;
1115         struct dpni_dest_cfg dest_cfg;
1116         struct dpni_flc_cfg flc_cfg;
1117         int order_preservation_en;
1118         uint32_t tail_drop_threshold;
1119         uint32_t fqid;
1120 };
1121
1122 /* DPNI Tx flow modification options */
1123
1124 /* Select to modify the settings for dedicate Tx confirmation/error */
1125 #define DPNI_TX_FLOW_OPT_TX_CONF_ERROR  0x00000001
1126 /*!< Select to modify the L3 checksum generation setting */
1127 #define DPNI_TX_FLOW_OPT_L3_CHKSUM_GEN  0x00000010
1128 /*!< Select to modify the L4 checksum generation setting */
1129 #define DPNI_TX_FLOW_OPT_L4_CHKSUM_GEN  0x00000020
1130
1131 /**
1132  * dpni_get_api_version - Retrieve DPNI Major and Minor version info.
1133  *
1134  * @mc_io:      Pointer to MC portal's I/O object
1135  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1136  * @major_ver:  DPNI major version
1137  * @minor_ver:  DPNI minor version
1138  *
1139  * Return:     '0' on Success; Error code otherwise.
1140  */
1141 int dpni_get_api_version(struct fsl_mc_io *mc_io,
1142                          u32 cmd_flags,
1143                          u16 *major_ver,
1144                          u16 *minor_ver);
1145
1146 /**
1147  * enum dpni_confirmation_mode - Defines DPNI options supported for Tx
1148  * confirmation
1149  * @DPNI_CONF_AFFINE: For each Tx queue set associated with a sender there is
1150  * an affine Tx Confirmation queue
1151  * @DPNI_CONF_SINGLE: All Tx queues are associated with a single Tx
1152  * confirmation queue
1153  * @DPNI_CONF_DISABLE: Tx frames are not confirmed.  This must be associated
1154  * with proper FD set-up to have buffers release to a Buffer Pool, otherwise
1155  * buffers will be leaked.
1156  */
1157 enum dpni_confirmation_mode {
1158         DPNI_CONF_AFFINE,
1159         DPNI_CONF_SINGLE,
1160         DPNI_CONF_DISABLE,
1161 };
1162
1163 struct dpni_tx_confirmation_mode {
1164         uint32_t pad;
1165         uint8_t confirmation_mode;
1166 };
1167
1168 /**
1169  * struct dpni_queue - Queue structure
1170  * @fqid:  FQID used for enqueueing to and/or configuration of this specific FQ
1171  * @qdbin: Queueing bin, used to enqueue using QDID, DQBIN, QPRI. Only relevant
1172  *         for Tx queues.
1173  * @flc:   FLC value for traffic dequeued from this queue.
1174  * @user_context:    User data, presented to the user along with any frames
1175  *                   from this queue. Not relevant for Tx queues.
1176  */
1177 struct dpni_queue {
1178         /**
1179         * struct destination - Destination structure
1180         * @id:   ID of the destination, only relevant if DEST_TYPE is > 0.
1181         *        Identifies either a DPIO or a DPCON object. Not relevant for Tx
1182         *        queues.
1183         * @type: May be one of the following:
1184         *         0 - No destination, queue can be manually queried, but won't
1185         *             push traffic or notifications to a DPIO;
1186         *         1 - The destination is DPIO. When traffic becomes available in
1187         *             the queue a FQDAN (FQ data available notification) will be
1188         *             generated to selected DPIO;
1189         *         2 - The destination is a DPCON. The queue is associated with a
1190         *             DPCON object for purpose of scheduling between multiple
1191         *             queues. The DPCON may be independently configured to
1192         *             generate notifications. Not relevant for Tx queues.
1193         * @hold_active: Hold active
1194         */
1195         struct {
1196                 uint32_t id;
1197                 enum dpni_dest type;
1198                 char hold_active;
1199                 char stash_ctrl;
1200         } destination;
1201         uint8_t  options;
1202         uint32_t fqid;
1203         uint16_t qdbin;
1204         uint64_t flc;
1205         uint64_t user_context;
1206 };
1207
1208 /**
1209  * dpni_set_queue() - Set queue parameters
1210  * @mc_io:      Pointer to MC portal's I/O object
1211  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1212  * @token:      Token of DPNI object
1213  * @type:       Type of queue
1214  * @tc:         Traffic class, in range 0 to NUM_TCS - 1
1215  * @index:      Selects the specific queue out of the set allocated for the same
1216  *              TC. Value must be in range 0 to NUM_QUEUES - 1
1217  * @queue:      Queue structure
1218  *
1219  * Return:     '0' on Success; Error code otherwise.
1220  */
1221 int dpni_set_queue(struct fsl_mc_io             *mc_io,
1222                    uint32_t                     cmd_flags,
1223                    uint16_t                     token,
1224                    enum dpni_queue_type         type,
1225                    uint8_t                      tc,
1226                    uint8_t                      index,
1227                    const struct dpni_queue      *queue);
1228
1229 /**
1230  * dpni_get_queue() - Get queue parameters
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  * @type:       Type of queue
1235  * @tc:         Traffic class, in range 0 to NUM_TCS - 1
1236  * @index:      Selects the specific queue out of the set allocated for the same
1237  *              TC. Value must be in range 0 to NUM_QUEUES - 1
1238  * @queue:      Queue structure
1239  *
1240  * Return:      '0' on Success; Error code otherwise.
1241  */
1242 int dpni_get_queue(struct fsl_mc_io             *mc_io,
1243                    uint32_t                     cmd_flags,
1244                    uint16_t                     token,
1245                    enum dpni_queue_type         type,
1246                    uint8_t                      tc,
1247                    uint8_t                      index,
1248                    struct dpni_queue            *queue);
1249
1250 /**
1251  * dpni_set_tx_confirmation_mode() - Set TX conf mode
1252  * @mc_io:      Pointer to MC portal's I/O object
1253  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1254  * @token:      Token of DPNI object
1255  * @mode:       DPNI confirmation mode type
1256  *
1257  * Return:      '0' on Success; Error code otherwise.
1258  */
1259 int dpni_set_tx_confirmation_mode(struct fsl_mc_io      *mc_io,
1260                                   uint32_t              cmd_flags,
1261                                   uint16_t              token,
1262                                   enum dpni_confirmation_mode mode);
1263 struct dpni_statistics {
1264         /**
1265          * Page_0 statistics structure
1266          * @ingress_all_frames: Ingress frame count
1267          * @ingress_all_bytes: Ingress byte count
1268          * @ingress_multicast_frames: Ingress multicast frame count
1269          * @ingress_multicast_bytes: Ingress multicast byte count
1270          * @ingress_broadcast_frames: Ingress broadcast frame count
1271          * @ingress_broadcast_bytes: Ingress broadcast byte count
1272          *
1273          * Page_1 statistics structure
1274          * @egress_all_frames: Egress frame count
1275          * @egress_all_bytes: Egress byte count
1276          * @egress_multicast_frames: Egress multicast frame count
1277          * @egress_multicast_bytes: Egress multicast byte count
1278          * @egress_broadcast_frames: Egress broadcast frame count
1279          * @egress_broadcast_bytes: Egress broadcast byte count
1280          *
1281          * Page_2 statistics structure
1282          * @ingress_filtered_frames: Ingress filtered frame count
1283          * @ingress_discarded_frames: Ingress discarded frame count
1284          * @ingress_nobuffer_discards: Ingress discarded frame count due to
1285          *  lack of buffers.
1286          * @egress_discarded_frames: Egress discarded frame count
1287          * @egress_confirmed_frames: Egress confirmed frame count
1288          */
1289
1290         uint64_t counter0;
1291         uint64_t counter1;
1292         uint64_t counter2;
1293         uint64_t counter3;
1294         uint64_t counter4;
1295         uint64_t counter5;
1296         uint64_t counter6;
1297 };
1298
1299 /**
1300  * dpni_get_statistics() - Get DPNI statistics
1301  * @mc_io:      Pointer to MC portal's I/O object
1302  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1303  * @token:      Token of DPNI object
1304  * @page:       Selects the statistics page to retrieve, see DPNI_GET_STATISTICS
1305  *              output. Pages are numbered 0 to 2.
1306  * @stat:       Structure containing the statistics
1307  *
1308  * Return:      '0' on Success; Error code otherwise.
1309  */
1310 int dpni_get_statistics(struct fsl_mc_io *mc_io,
1311                         uint32_t cmd_flags,
1312                         uint16_t token,
1313                         uint8_t page,
1314                         struct dpni_statistics *stat);
1315
1316 /**
1317  * dpni_reset_statistics() - Clears DPNI statistics
1318  * @mc_io:      Pointer to MC portal's I/O object
1319  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1320  * @token:      Token of DPNI object
1321  *
1322  * Return:      '0' on Success; Error code otherwise.
1323  */
1324 int dpni_reset_statistics(struct fsl_mc_io *mc_io,
1325                           uint32_t cmd_flags,
1326                           uint16_t token);
1327 #endif /* _FSL_DPNI_H */