include/fsl-mc/fsl_dpni.h

   1 /*
   2  * Copyright (C) 2013-2015 Freescale Semiconductor
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6 #ifndef _FSL_DPNI_H
   7 #define _FSL_DPNI_H
   8
   9 /* DPNI Version */
  10 #define DPNI_VER_MAJOR                          5
  11 #define DPNI_VER_MINOR                          1
  12
  13 /* Command IDs */
  14 #define DPNI_CMDID_OPEN                         0x801
  15 #define DPNI_CMDID_CLOSE                        0x800
  16 #define DPNI_CMDID_CREATE                       0x901
  17 #define DPNI_CMDID_DESTROY                      0x900
  18
  19 #define DPNI_CMDID_ENABLE                       0x002
  20 #define DPNI_CMDID_DISABLE                      0x003
  21 #define DPNI_CMDID_GET_ATTR                     0x004
  22 #define DPNI_CMDID_RESET                        0x005
  23
  24 #define DPNI_CMDID_SET_POOLS                    0x200
  25 #define DPNI_CMDID_GET_RX_BUFFER_LAYOUT         0x201
  26 #define DPNI_CMDID_SET_RX_BUFFER_LAYOUT         0x202
  27 #define DPNI_CMDID_GET_TX_BUFFER_LAYOUT         0x203
  28 #define DPNI_CMDID_SET_TX_BUFFER_LAYOUT         0x204
  29 #define DPNI_CMDID_SET_TX_CONF_BUFFER_LAYOUT    0x205
  30 #define DPNI_CMDID_GET_TX_CONF_BUFFER_LAYOUT    0x206
  31
  32 #define DPNI_CMDID_GET_QDID                     0x210
  33 #define DPNI_CMDID_GET_TX_DATA_OFFSET           0x212
  34 #define DPNI_CMDID_GET_COUNTER                  0x213
  35 #define DPNI_CMDID_SET_COUNTER                  0x214
  36 #define DPNI_CMDID_GET_LINK_STATE               0x215
  37 #define DPNI_CMDID_SET_LINK_CFG         0x21A
  38
  39 #define DPNI_CMDID_SET_PRIM_MAC                 0x224
  40 #define DPNI_CMDID_GET_PRIM_MAC                 0x225
  41 #define DPNI_CMDID_ADD_MAC_ADDR                 0x226
  42 #define DPNI_CMDID_REMOVE_MAC_ADDR              0x227
  43
  44 #define DPNI_CMDID_SET_TX_FLOW                  0x236
  45 #define DPNI_CMDID_GET_TX_FLOW                  0x237
  46 #define DPNI_CMDID_SET_RX_FLOW                  0x238
  47 #define DPNI_CMDID_GET_RX_FLOW                  0x239
  48
  49 /*                cmd, param, offset, width, type, arg_name */
  50 #define DPNI_CMD_OPEN(cmd, dpni_id) \
  51         MC_CMD_OP(cmd,   0,     0,      32,     int,    dpni_id)
  52
  53 /*                cmd, param, offset, width, type, arg_name */
  54 #define DPNI_CMD_CREATE(cmd, cfg) \
  55 do { \
  56         MC_CMD_OP(cmd, 0, 0,    8,  uint8_t,  cfg->adv.max_tcs); \
  57         MC_CMD_OP(cmd, 0, 8,    8,  uint8_t,  cfg->adv.max_senders); \
  58         MC_CMD_OP(cmd, 0, 16,   8,  uint8_t,  cfg->mac_addr[5]); \
  59         MC_CMD_OP(cmd, 0, 24,   8,  uint8_t,  cfg->mac_addr[4]); \
  60         MC_CMD_OP(cmd, 0, 32,   8,  uint8_t,  cfg->mac_addr[3]); \
  61         MC_CMD_OP(cmd, 0, 40,   8,  uint8_t,  cfg->mac_addr[2]); \
  62         MC_CMD_OP(cmd, 0, 48,   8,  uint8_t,  cfg->mac_addr[1]); \
  63         MC_CMD_OP(cmd, 0, 56,   8,  uint8_t,  cfg->mac_addr[0]); \
  64         MC_CMD_OP(cmd, 1, 0,    32, uint32_t, cfg->adv.options); \
  65         MC_CMD_OP(cmd, 2, 0,    8,  uint8_t,  cfg->adv.max_unicast_filters); \
  66         MC_CMD_OP(cmd, 2, 8,    8,  uint8_t,  cfg->adv.max_multicast_filters); \
  67         MC_CMD_OP(cmd, 2, 16,   8,  uint8_t,  cfg->adv.max_vlan_filters); \
  68         MC_CMD_OP(cmd, 2, 24,   8,  uint8_t,  cfg->adv.max_qos_entries); \
  69         MC_CMD_OP(cmd, 2, 32,   8,  uint8_t,  cfg->adv.max_qos_key_size); \
  70         MC_CMD_OP(cmd, 2, 48,   8,  uint8_t,  cfg->adv.max_dist_key_size); \
  71         MC_CMD_OP(cmd, 2, 56,   8,  enum net_prot, cfg->adv.start_hdr); \
  72         MC_CMD_OP(cmd, 3, 0,    8,  uint8_t,  cfg->adv.max_dist_per_tc[0]); \
  73         MC_CMD_OP(cmd, 3, 8,    8,  uint8_t,  cfg->adv.max_dist_per_tc[1]); \
  74         MC_CMD_OP(cmd, 3, 16,   8,  uint8_t,  cfg->adv.max_dist_per_tc[2]); \
  75         MC_CMD_OP(cmd, 3, 24,   8,  uint8_t,  cfg->adv.max_dist_per_tc[3]); \
  76         MC_CMD_OP(cmd, 3, 32,   8,  uint8_t,  cfg->adv.max_dist_per_tc[4]); \
  77         MC_CMD_OP(cmd, 3, 40,   8,  uint8_t,  cfg->adv.max_dist_per_tc[5]); \
  78         MC_CMD_OP(cmd, 3, 48,   8,  uint8_t,  cfg->adv.max_dist_per_tc[6]); \
  79         MC_CMD_OP(cmd, 3, 56,   8,  uint8_t,  cfg->adv.max_dist_per_tc[7]); \
  80         MC_CMD_OP(cmd, 4, 0,    16, uint16_t, \
  81                                     cfg->adv.ipr_cfg.max_reass_frm_size); \
  82         MC_CMD_OP(cmd, 4, 16,   16, uint16_t, \
  83                                     cfg->adv.ipr_cfg.min_frag_size_ipv4); \
  84         MC_CMD_OP(cmd, 4, 32,   16, uint16_t, \
  85                                     cfg->adv.ipr_cfg.min_frag_size_ipv6); \
  86         MC_CMD_OP(cmd, 4, 48,   8,  uint8_t, cfg->adv.max_policers); \
  87         MC_CMD_OP(cmd, 4, 56,   8,  uint8_t, cfg->adv.max_congestion_ctrl); \
  88         MC_CMD_OP(cmd, 5, 0,    16, uint16_t, \
  89                                   cfg->adv.ipr_cfg.max_open_frames_ipv4); \
  90         MC_CMD_OP(cmd, 5, 16,   16, uint16_t, \
  91                                   cfg->adv.ipr_cfg.max_open_frames_ipv6); \
  92 } while (0)
  93
  94 /*                cmd, param, offset, width, type, arg_name */
  95 #define DPNI_CMD_SET_POOLS(cmd, cfg) \
  96 do { \
  97         MC_CMD_OP(cmd, 0, 0,  8,  uint8_t,  cfg->num_dpbp); \
  98         MC_CMD_OP(cmd, 0, 32, 32, int,      cfg->pools[0].dpbp_id); \
  99         MC_CMD_OP(cmd, 4, 32, 16, uint16_t, cfg->pools[0].buffer_size);\
 100         MC_CMD_OP(cmd, 1, 0,  32, int,      cfg->pools[1].dpbp_id); \
 101         MC_CMD_OP(cmd, 4, 48, 16, uint16_t, cfg->pools[1].buffer_size);\
 102         MC_CMD_OP(cmd, 1, 32, 32, int,      cfg->pools[2].dpbp_id); \
 103         MC_CMD_OP(cmd, 5, 0,  16, uint16_t, cfg->pools[2].buffer_size);\
 104         MC_CMD_OP(cmd, 2, 0,  32, int,      cfg->pools[3].dpbp_id); \
 105         MC_CMD_OP(cmd, 5, 16, 16, uint16_t, cfg->pools[3].buffer_size);\
 106         MC_CMD_OP(cmd, 2, 32, 32, int,      cfg->pools[4].dpbp_id); \
 107         MC_CMD_OP(cmd, 5, 32, 16, uint16_t, cfg->pools[4].buffer_size);\
 108         MC_CMD_OP(cmd, 3, 0,  32, int,      cfg->pools[5].dpbp_id); \
 109         MC_CMD_OP(cmd, 5, 48, 16, uint16_t, cfg->pools[5].buffer_size);\
 110         MC_CMD_OP(cmd, 3, 32, 32, int,      cfg->pools[6].dpbp_id); \
 111         MC_CMD_OP(cmd, 6, 0,  16, uint16_t, cfg->pools[6].buffer_size);\
 112         MC_CMD_OP(cmd, 4, 0,  32, int,      cfg->pools[7].dpbp_id); \
 113         MC_CMD_OP(cmd, 6, 16, 16, uint16_t, cfg->pools[7].buffer_size);\
 114 } while (0)
 115
 116 /*                cmd, param, offset, width, type, arg_name */
 117 #define DPNI_RSP_GET_ATTR(cmd, attr) \
 118 do { \
 119         MC_RSP_OP(cmd, 0, 0,  32, int,      attr->id);\
 120         MC_RSP_OP(cmd, 0, 32, 8,  uint8_t,  attr->max_tcs); \
 121         MC_RSP_OP(cmd, 0, 40, 8,  uint8_t,  attr->max_senders); \
 122         MC_RSP_OP(cmd, 0, 48, 8,  enum net_prot, attr->start_hdr); \
 123         MC_RSP_OP(cmd, 1, 0,  32, uint32_t, attr->options); \
 124         MC_RSP_OP(cmd, 2, 0,  8,  uint8_t,  attr->max_unicast_filters); \
 125         MC_RSP_OP(cmd, 2, 8,  8,  uint8_t,  attr->max_multicast_filters);\
 126         MC_RSP_OP(cmd, 2, 16, 8,  uint8_t,  attr->max_vlan_filters); \
 127         MC_RSP_OP(cmd, 2, 24, 8,  uint8_t,  attr->max_qos_entries); \
 128         MC_RSP_OP(cmd, 2, 32, 8,  uint8_t,  attr->max_qos_key_size); \
 129         MC_RSP_OP(cmd, 2, 40, 8,  uint8_t,  attr->max_dist_key_size); \
 130         MC_RSP_OP(cmd, 3, 0,  8,  uint8_t,  attr->max_dist_per_tc[0]); \
 131         MC_RSP_OP(cmd, 3, 8,  8,  uint8_t,  attr->max_dist_per_tc[1]); \
 132         MC_RSP_OP(cmd, 3, 16, 8,  uint8_t,  attr->max_dist_per_tc[2]); \
 133         MC_RSP_OP(cmd, 3, 24, 8,  uint8_t,  attr->max_dist_per_tc[3]); \
 134         MC_RSP_OP(cmd, 3, 32, 8,  uint8_t,  attr->max_dist_per_tc[4]); \
 135         MC_RSP_OP(cmd, 3, 40, 8,  uint8_t,  attr->max_dist_per_tc[5]); \
 136         MC_RSP_OP(cmd, 3, 48, 8,  uint8_t,  attr->max_dist_per_tc[6]); \
 137         MC_RSP_OP(cmd, 3, 56, 8,  uint8_t,  attr->max_dist_per_tc[7]); \
 138         MC_RSP_OP(cmd, 4, 0,    16, uint16_t, \
 139                                     attr->ipr_cfg.max_reass_frm_size); \
 140         MC_RSP_OP(cmd, 4, 16,   16, uint16_t, \
 141                                     attr->ipr_cfg.min_frag_size_ipv4); \
 142         MC_RSP_OP(cmd, 4, 32,   16, uint16_t, \
 143                                     attr->ipr_cfg.min_frag_size_ipv6);\
 144         MC_RSP_OP(cmd, 4, 48,   8,  uint8_t, attr->max_policers); \
 145         MC_RSP_OP(cmd, 4, 56,   8,  uint8_t, attr->max_congestion_ctrl); \
 146         MC_RSP_OP(cmd, 5, 0,    16, uint16_t, \
 147                                   attr->ipr_cfg.max_open_frames_ipv4); \
 148         MC_RSP_OP(cmd, 5, 16,   16, uint16_t, \
 149                                   attr->ipr_cfg.max_open_frames_ipv6); \
 150         MC_RSP_OP(cmd, 5, 32, 16, uint16_t, attr->version.major);\
 151         MC_RSP_OP(cmd, 5, 48, 16, uint16_t, attr->version.minor);\
 152 } while (0)
 153
 154 /*                cmd, param, offset, width, type, arg_name */
 155 #define DPNI_RSP_GET_RX_BUFFER_LAYOUT(cmd, layout) \
 156 do { \
 157         MC_RSP_OP(cmd, 0, 0,  16, uint16_t, layout->private_data_size); \
 158         MC_RSP_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \
 159         MC_RSP_OP(cmd, 1, 0,  1,  int,      layout->pass_timestamp); \
 160         MC_RSP_OP(cmd, 1, 1,  1,  int,      layout->pass_parser_result); \
 161         MC_RSP_OP(cmd, 1, 2,  1,  int,      layout->pass_frame_status); \
 162         MC_RSP_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \
 163         MC_RSP_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \
 164 } while (0)
 165
 166 /*                cmd, param, offset, width, type, arg_name */
 167 #define DPNI_CMD_SET_RX_BUFFER_LAYOUT(cmd, layout) \
 168 do { \
 169         MC_CMD_OP(cmd, 0, 0,  16, uint16_t, layout->private_data_size); \
 170         MC_CMD_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \
 171         MC_CMD_OP(cmd, 0, 32, 32, uint32_t, layout->options); \
 172         MC_CMD_OP(cmd, 1, 0,  1,  int,      layout->pass_timestamp); \
 173         MC_CMD_OP(cmd, 1, 1,  1,  int,      layout->pass_parser_result); \
 174         MC_CMD_OP(cmd, 1, 2,  1,  int,      layout->pass_frame_status); \
 175         MC_CMD_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \
 176         MC_CMD_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \
 177 } while (0)
 178
 179 /*                cmd, param, offset, width, type, arg_name */
 180 #define DPNI_RSP_GET_TX_BUFFER_LAYOUT(cmd, layout) \
 181 do { \
 182         MC_RSP_OP(cmd, 0, 0,  16, uint16_t, layout->private_data_size); \
 183         MC_RSP_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \
 184         MC_RSP_OP(cmd, 1, 0,  1,  int,      layout->pass_timestamp); \
 185         MC_RSP_OP(cmd, 1, 1,  1,  int,      layout->pass_parser_result); \
 186         MC_RSP_OP(cmd, 1, 2,  1,  int,      layout->pass_frame_status); \
 187         MC_RSP_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \
 188         MC_RSP_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \
 189 } while (0)
 190
 191 /*                cmd, param, offset, width, type, arg_name */
 192 #define DPNI_CMD_SET_TX_BUFFER_LAYOUT(cmd, layout) \
 193 do { \
 194         MC_CMD_OP(cmd, 0, 0,  16, uint16_t, layout->private_data_size); \
 195         MC_CMD_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \
 196         MC_CMD_OP(cmd, 0, 32, 32, uint32_t, layout->options); \
 197         MC_CMD_OP(cmd, 1, 0,  1,  int,      layout->pass_timestamp); \
 198         MC_CMD_OP(cmd, 1, 1,  1,  int,      layout->pass_parser_result); \
 199         MC_CMD_OP(cmd, 1, 2,  1,  int,      layout->pass_frame_status); \
 200         MC_CMD_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \
 201         MC_CMD_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \
 202 } while (0)
 203
 204 /*                cmd, param, offset, width, type, arg_name */
 205 #define DPNI_RSP_GET_TX_CONF_BUFFER_LAYOUT(cmd, layout) \
 206 do { \
 207         MC_RSP_OP(cmd, 0, 0,  16, uint16_t, layout->private_data_size); \
 208         MC_RSP_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \
 209         MC_RSP_OP(cmd, 1, 0,  1,  int,      layout->pass_timestamp); \
 210         MC_RSP_OP(cmd, 1, 1,  1,  int,      layout->pass_parser_result); \
 211         MC_RSP_OP(cmd, 1, 2,  1,  int,      layout->pass_frame_status); \
 212         MC_RSP_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \
 213         MC_RSP_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \
 214 } while (0)
 215
 216 /*                cmd, param, offset, width, type, arg_name */
 217 #define DPNI_CMD_SET_TX_CONF_BUFFER_LAYOUT(cmd, layout) \
 218 do { \
 219         MC_CMD_OP(cmd, 0, 0,  16, uint16_t, layout->private_data_size); \
 220         MC_CMD_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \
 221         MC_CMD_OP(cmd, 0, 32, 32, uint32_t, layout->options); \
 222         MC_CMD_OP(cmd, 1, 0,  1,  int,      layout->pass_timestamp); \
 223         MC_CMD_OP(cmd, 1, 1,  1,  int,      layout->pass_parser_result); \
 224         MC_CMD_OP(cmd, 1, 2,  1,  int,      layout->pass_frame_status); \
 225         MC_CMD_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \
 226         MC_CMD_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \
 227 } while (0)
 228
 229 /*                cmd, param, offset, width, type, arg_name */
 230 #define DPNI_RSP_GET_QDID(cmd, qdid) \
 231         MC_RSP_OP(cmd, 0, 0,  16, uint16_t, qdid)
 232
 233 /*                cmd, param, offset, width, type, arg_name */
 234 #define DPNI_RSP_GET_TX_DATA_OFFSET(cmd, data_offset) \
 235         MC_RSP_OP(cmd, 0, 0,  16, uint16_t, data_offset)
 236
 237 /*                cmd, param, offset, width, type, arg_name */
 238 #define DPNI_CMD_GET_COUNTER(cmd, counter) \
 239         MC_CMD_OP(cmd, 0, 0,  16, enum dpni_counter, counter)
 240
 241 /*                cmd, param, offset, width, type, arg_name */
 242 #define DPNI_RSP_GET_COUNTER(cmd, value) \
 243         MC_RSP_OP(cmd, 1, 0,  64, uint64_t, value)
 244
 245 /*                cmd, param, offset, width, type, arg_name */
 246 #define DPNI_CMD_SET_COUNTER(cmd, counter, value) \
 247 do { \
 248         MC_CMD_OP(cmd, 0, 0,  16, enum dpni_counter, counter); \
 249         MC_CMD_OP(cmd, 1, 0,  64, uint64_t, value); \
 250 } while (0)
 251
 252 /*                cmd, param, offset, width, type, arg_name */
 253 #define DPNI_CMD_SET_LINK_CFG(cmd, cfg) \
 254 do { \
 255         MC_CMD_OP(cmd, 1, 0,  32, uint32_t, cfg->rate);\
 256         MC_CMD_OP(cmd, 2, 0,  64, uint64_t, cfg->options);\
 257 } while (0)
 258
 259 /*                cmd, param, offset, width, type, arg_name */
 260 #define DPNI_RSP_GET_LINK_STATE(cmd, state) \
 261 do { \
 262         MC_RSP_OP(cmd, 0, 32,  1, int,      state->up);\
 263         MC_RSP_OP(cmd, 1, 0,  32, uint32_t, state->rate);\
 264         MC_RSP_OP(cmd, 2, 0,  64, uint64_t, state->options);\
 265 } while (0)
 266
 267
 268
 269 /*                cmd, param, offset, width, type, arg_name */
 270 #define DPNI_CMD_SET_PRIMARY_MAC_ADDR(cmd, mac_addr) \
 271 do { \
 272         MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
 273         MC_CMD_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
 274         MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
 275         MC_CMD_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
 276         MC_CMD_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
 277         MC_CMD_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
 278 } while (0)
 279
 280 /*                cmd, param, offset, width, type, arg_name */
 281 #define DPNI_RSP_GET_PRIMARY_MAC_ADDR(cmd, mac_addr) \
 282 do { \
 283         MC_RSP_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
 284         MC_RSP_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
 285         MC_RSP_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
 286         MC_RSP_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
 287         MC_RSP_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
 288         MC_RSP_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
 289 } while (0)
 290
 291 /*                cmd, param, offset, width, type, arg_name */
 292 #define DPNI_CMD_ADD_MAC_ADDR(cmd, mac_addr) \
 293 do { \
 294         MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
 295         MC_CMD_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
 296         MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
 297         MC_CMD_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
 298         MC_CMD_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
 299         MC_CMD_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
 300 } while (0)
 301
 302 /*                cmd, param, offset, width, type, arg_name */
 303 #define DPNI_CMD_REMOVE_MAC_ADDR(cmd, mac_addr) \
 304 do { \
 305         MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
 306         MC_CMD_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
 307         MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
 308         MC_CMD_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
 309         MC_CMD_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
 310         MC_CMD_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
 311 } while (0)
 312
 313 /*                cmd, param, offset, width, type, arg_name */
 314 #define DPNI_CMD_SET_TX_FLOW(cmd, flow_id, cfg) \
 315 do { \
 316         MC_CMD_OP(cmd, 0, 0,  32, int,     \
 317                            cfg->conf_err_cfg.queue_cfg.dest_cfg.dest_id);\
 318         MC_CMD_OP(cmd, 0, 32, 8,  uint8_t, \
 319                            cfg->conf_err_cfg.queue_cfg.dest_cfg.priority);\
 320         MC_CMD_OP(cmd, 0, 40, 2,  enum dpni_dest, \
 321                            cfg->conf_err_cfg.queue_cfg.dest_cfg.dest_type);\
 322         MC_CMD_OP(cmd, 0, 42, 1,  int,      cfg->conf_err_cfg.errors_only);\
 323         MC_CMD_OP(cmd, 0, 43, 1,  int,      cfg->l3_chksum_gen);\
 324         MC_CMD_OP(cmd, 0, 44, 1,  int,      cfg->l4_chksum_gen);\
 325         MC_CMD_OP(cmd, 0, 45, 1,  int,      \
 326                            cfg->conf_err_cfg.use_default_queue);\
 327         MC_CMD_OP(cmd, 0, 48, 16, uint16_t, flow_id);\
 328         MC_CMD_OP(cmd, 1, 0,  64, uint64_t, \
 329                            cfg->conf_err_cfg.queue_cfg.user_ctx);\
 330         MC_CMD_OP(cmd, 2, 0,  32, uint32_t, cfg->options);\
 331         MC_CMD_OP(cmd, 2, 32,  32, uint32_t, \
 332                            cfg->conf_err_cfg.queue_cfg.options);\
 333 } while (0)
 334
 335 /*                cmd, param, offset, width, type, arg_name */
 336 #define DPNI_RSP_SET_TX_FLOW(cmd, flow_id) \
 337         MC_RSP_OP(cmd, 0, 48, 16, uint16_t, flow_id)
 338
 339 /*                cmd, param, offset, width, type, arg_name */
 340 #define DPNI_CMD_GET_TX_FLOW(cmd, flow_id) \
 341         MC_CMD_OP(cmd, 0, 48, 16, uint16_t, flow_id)
 342
 343 /*                cmd, param, offset, width, type, arg_name */
 344 #define DPNI_RSP_GET_TX_FLOW(cmd, attr) \
 345 do { \
 346         MC_RSP_OP(cmd, 0, 0,  32, int,      \
 347                         attr->conf_err_attr.queue_attr.dest_cfg.dest_id);\
 348         MC_RSP_OP(cmd, 0, 32, 8,  uint8_t,  \
 349                         attr->conf_err_attr.queue_attr.dest_cfg.priority);\
 350         MC_RSP_OP(cmd, 0, 40, 2,  enum dpni_dest, \
 351                         attr->conf_err_attr.queue_attr.dest_cfg.dest_type);\
 352         MC_RSP_OP(cmd, 0, 42, 1,  int,      attr->conf_err_attr.errors_only);\
 353         MC_RSP_OP(cmd, 0, 43, 1,  int,      attr->l3_chksum_gen);\
 354         MC_RSP_OP(cmd, 0, 44, 1,  int,      attr->l4_chksum_gen);\
 355         MC_RSP_OP(cmd, 0, 45, 1,  int,      \
 356                         attr->conf_err_attr.use_default_queue);\
 357         MC_RSP_OP(cmd, 1, 0,  64, uint64_t, \
 358                         attr->conf_err_attr.queue_attr.user_ctx);\
 359         MC_RSP_OP(cmd, 2, 32, 32, uint32_t, \
 360                         attr->conf_err_attr.queue_attr.fqid);\
 361 } while (0)
 362
 363 /*                cmd, param, offset, width, type, arg_name */
 364 #define DPNI_CMD_SET_RX_FLOW(cmd, tc_id, flow_id, cfg) \
 365 do { \
 366         MC_CMD_OP(cmd, 0, 0,  32, int,      cfg->dest_cfg.dest_id); \
 367         MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  cfg->dest_cfg.priority);\
 368         MC_CMD_OP(cmd, 0, 40, 2,  enum dpni_dest, cfg->dest_cfg.dest_type);\
 369         MC_CMD_OP(cmd, 0, 42, 1,  int,      cfg->order_preservation_en);\
 370         MC_CMD_OP(cmd, 0, 48, 16, uint16_t, flow_id); \
 371         MC_CMD_OP(cmd, 1, 0,  64, uint64_t, cfg->user_ctx); \
 372         MC_CMD_OP(cmd, 2, 16, 8,  uint8_t,  tc_id); \
 373         MC_CMD_OP(cmd, 2, 32,  32, uint32_t, cfg->options); \
 374         MC_CMD_OP(cmd, 3, 0,  4,  enum dpni_flc_type, cfg->flc_cfg.flc_type); \
 375         MC_CMD_OP(cmd, 3, 4,  4,  enum dpni_stash_size, \
 376                 cfg->flc_cfg.frame_data_size);\
 377         MC_CMD_OP(cmd, 3, 8,  4,  enum dpni_stash_size, \
 378                 cfg->flc_cfg.flow_context_size);\
 379         MC_CMD_OP(cmd, 3, 32, 32, uint32_t, cfg->flc_cfg.options);\
 380         MC_CMD_OP(cmd, 4, 0,  64, uint64_t, cfg->flc_cfg.flow_context);\
 381 } while (0)
 382
 383 /*                cmd, param, offset, width, type, arg_name */
 384 #define DPNI_CMD_GET_RX_FLOW(cmd, tc_id, flow_id) \
 385 do { \
 386         MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  tc_id); \
 387         MC_CMD_OP(cmd, 0, 48, 16, uint16_t, flow_id); \
 388 } while (0)
 389
 390 /*                cmd, param, offset, width, type, arg_name */
 391 #define DPNI_RSP_GET_RX_FLOW(cmd, attr) \
 392 do { \
 393         MC_RSP_OP(cmd, 0, 0,  32, int,      attr->dest_cfg.dest_id); \
 394         MC_RSP_OP(cmd, 0, 32, 8,  uint8_t,  attr->dest_cfg.priority);\
 395         MC_RSP_OP(cmd, 0, 40, 2,  enum dpni_dest, attr->dest_cfg.dest_type); \
 396         MC_CMD_OP(cmd, 0, 42, 1,  int,      attr->order_preservation_en);\
 397         MC_RSP_OP(cmd, 1, 0,  64, uint64_t, attr->user_ctx); \
 398         MC_RSP_OP(cmd, 2, 32, 32, uint32_t, attr->fqid); \
 399         MC_RSP_OP(cmd, 3, 0,  4,  enum dpni_flc_type, attr->flc_cfg.flc_type); \
 400         MC_RSP_OP(cmd, 3, 4,  4,  enum dpni_stash_size, \
 401                 attr->flc_cfg.frame_data_size);\
 402         MC_RSP_OP(cmd, 3, 8,  4,  enum dpni_stash_size, \
 403                 attr->flc_cfg.flow_context_size);\
 404         MC_RSP_OP(cmd, 3, 32, 32, uint32_t, attr->flc_cfg.options);\
 405         MC_RSP_OP(cmd, 4, 0,  64, uint64_t, attr->flc_cfg.flow_context);\
 406 } while (0)
 407
 408 enum net_prot {
 409         NET_PROT_NONE = 0,
 410         NET_PROT_PAYLOAD,
 411         NET_PROT_ETH,
 412         NET_PROT_VLAN,
 413         NET_PROT_IPV4,
 414         NET_PROT_IPV6,
 415         NET_PROT_IP,
 416         NET_PROT_TCP,
 417         NET_PROT_UDP,
 418         NET_PROT_UDP_LITE,
 419         NET_PROT_IPHC,
 420         NET_PROT_SCTP,
 421         NET_PROT_SCTP_CHUNK_DATA,
 422         NET_PROT_PPPOE,
 423         NET_PROT_PPP,
 424         NET_PROT_PPPMUX,
 425         NET_PROT_PPPMUX_SUBFRM,
 426         NET_PROT_L2TPV2,
 427         NET_PROT_L2TPV3_CTRL,
 428         NET_PROT_L2TPV3_SESS,
 429         NET_PROT_LLC,
 430         NET_PROT_LLC_SNAP,
 431         NET_PROT_NLPID,
 432         NET_PROT_SNAP,
 433         NET_PROT_MPLS,
 434         NET_PROT_IPSEC_AH,
 435         NET_PROT_IPSEC_ESP,
 436         NET_PROT_UDP_ENC_ESP, /* RFC 3948 */
 437         NET_PROT_MACSEC,
 438         NET_PROT_GRE,
 439         NET_PROT_MINENCAP,
 440         NET_PROT_DCCP,
 441         NET_PROT_ICMP,
 442         NET_PROT_IGMP,
 443         NET_PROT_ARP,
 444         NET_PROT_CAPWAP_DATA,
 445         NET_PROT_CAPWAP_CTRL,
 446         NET_PROT_RFC2684,
 447         NET_PROT_ICMPV6,
 448         NET_PROT_FCOE,
 449         NET_PROT_FIP,
 450         NET_PROT_ISCSI,
 451         NET_PROT_GTP,
 452         NET_PROT_USER_DEFINED_L2,
 453         NET_PROT_USER_DEFINED_L3,
 454         NET_PROT_USER_DEFINED_L4,
 455         NET_PROT_USER_DEFINED_L5,
 456         NET_PROT_USER_DEFINED_SHIM1,
 457         NET_PROT_USER_DEFINED_SHIM2,
 458
 459         NET_PROT_DUMMY_LAST
 460 };
 461
 462 /**
 463  * Data Path Network Interface API
 464  * Contains initialization APIs and runtime control APIs for DPNI
 465  */
 466
 467 struct fsl_mc_io;
 468
 469 /* General DPNI macros */
 470
 471 /* Maximum number of traffic classes */
 472 #define DPNI_MAX_TC                             8
 473 /* Maximum number of buffer pools per DPNI */
 474 #define DPNI_MAX_DPBP                           8
 475
 476 /* All traffic classes considered; see dpni_set_rx_flow() */
 477 #define DPNI_ALL_TCS                            (uint8_t)(-1)
 478 /* All flows within traffic class considered; see dpni_set_rx_flow() */
 479 #define DPNI_ALL_TC_FLOWS                       (uint16_t)(-1)
 480 /* Generate new flow ID; see dpni_set_tx_flow() */
 481 #define DPNI_NEW_FLOW_ID                        (uint16_t)(-1)
 482
 483 /**
 484  * dpni_open() - Open a control session for the specified object
 485  * @mc_io:      Pointer to MC portal's I/O object
 486  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 487  * @dpni_id:    DPNI unique ID
 488  * @token:      Returned token; use in subsequent API calls
 489  *
 490  * This function can be used to open a control session for an
 491  * already created object; an object may have been declared in
 492  * the DPL or by calling the dpni_create() function.
 493  * This function returns a unique authentication token,
 494  * associated with the specific object ID and the specific MC
 495  * portal; this token must be used in all subsequent commands for
 496  * this specific object.
 497  *
 498  * Return:      '0' on Success; Error code otherwise.
 499  */
 500 int dpni_open(struct fsl_mc_io  *mc_io,
 501               uint32_t          cmd_flags,
 502               int               dpni_id,
 503               uint16_t          *token);
 504
 505 /**
 506  * dpni_close() - Close the control session of the object
 507  * @mc_io:      Pointer to MC portal's I/O object
 508  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 509  * @token:      Token of DPNI object
 510  *
 511  * After this function is called, no further operations are
 512  * allowed on the object without opening a new control session.
 513  *
 514  * Return:      '0' on Success; Error code otherwise.
 515  */
 516 int dpni_close(struct fsl_mc_io *mc_io,
 517                uint32_t         cmd_flags,
 518                uint16_t         token);
 519
 520 /* DPNI configuration options */
 521
 522 /**
 523  * Allow different distribution key profiles for different traffic classes;
 524  * if not set, a single key profile is assumed
 525  */
 526 #define DPNI_OPT_ALLOW_DIST_KEY_PER_TC          0x00000001
 527
 528 /**
 529  * Disable all non-error transmit confirmation; error frames are reported
 530  * back to a common Tx error queue
 531  */
 532 #define DPNI_OPT_TX_CONF_DISABLED               0x00000002
 533
 534 /* Disable per-sender private Tx confirmation/error queue */
 535 #define DPNI_OPT_PRIVATE_TX_CONF_ERROR_DISABLED 0x00000004
 536
 537 /**
 538  * Support distribution based on hashed key;
 539  * allows statistical distribution over receive queues in a traffic class
 540  */
 541 #define DPNI_OPT_DIST_HASH                      0x00000010
 542
 543 /**
 544  * Support distribution based on flow steering;
 545  * allows explicit control of distribution over receive queues in a traffic
 546  * class
 547  */
 548 #define DPNI_OPT_DIST_FS                        0x00000020
 549
 550 /* Unicast filtering support */
 551 #define DPNI_OPT_UNICAST_FILTER                 0x00000080
 552 /* Multicast filtering support */
 553 #define DPNI_OPT_MULTICAST_FILTER               0x00000100
 554 /* VLAN filtering support */
 555 #define DPNI_OPT_VLAN_FILTER                    0x00000200
 556 /* Support IP reassembly on received packets */
 557 #define DPNI_OPT_IPR                            0x00000800
 558 /* Support IP fragmentation on transmitted packets */
 559 #define DPNI_OPT_IPF                            0x00001000
 560 /* VLAN manipulation support */
 561 #define DPNI_OPT_VLAN_MANIPULATION              0x00010000
 562 /* Support masking of QoS lookup keys */
 563 #define DPNI_OPT_QOS_MASK_SUPPORT               0x00020000
 564 /* Support masking of Flow Steering lookup keys */
 565 #define DPNI_OPT_FS_MASK_SUPPORT                0x00040000
 566
 567 /**
 568  * struct dpni_ipr_cfg - Structure representing IP reassembly configuration
 569  * @max_reass_frm_size: Maximum size of the reassembled frame
 570  * @min_frag_size_ipv4: Minimum fragment size of IPv4 fragments
 571  * @min_frag_size_ipv6: Minimum fragment size of IPv6 fragments
 572  * @max_open_frames_ipv4: Maximum concurrent IPv4 packets in reassembly process
 573  * @max_open_frames_ipv6: Maximum concurrent IPv6 packets in reassembly process
 574  */
 575 struct dpni_ipr_cfg {
 576         uint16_t max_reass_frm_size;
 577         uint16_t min_frag_size_ipv4;
 578         uint16_t min_frag_size_ipv6;
 579         uint16_t max_open_frames_ipv4;
 580         uint16_t max_open_frames_ipv6;
 581 };
 582
 583 /**
 584  * struct dpni_cfg - Structure representing DPNI configuration
 585  * @mac_addr: Primary MAC address
 586  * @adv: Advanced parameters; default is all zeros;
 587  *              use this structure to change default settings
 588  */
 589 struct dpni_cfg {
 590         uint8_t mac_addr[6];
 591         /**
 592          * struct adv - Advanced parameters
 593          * @options: Mask of available options; use 'DPNI_OPT_<X>' values
 594          * @start_hdr: Selects the packet starting header for parsing;
 595          *              'NET_PROT_NONE' is treated as default: 'NET_PROT_ETH'
 596          * @max_senders: Maximum number of different senders; used as the number
 597          *              of dedicated Tx flows; Non-power-of-2 values are rounded
 598          *              up to the next power-of-2 value as hardware demands it;
 599          *              '0' will be treated as '1'
 600          * @max_tcs: Maximum number of traffic classes (for both Tx and Rx);
 601          *              '0' will e treated as '1'
 602          * @max_dist_per_tc: Maximum distribution size per Rx traffic class;
 603          *                      Must be set to the required value minus 1;
 604          *                      i.e. 0->1, 1->2, ... ,255->256;
 605          *                      Non-power-of-2 values are rounded up to the next
 606          *                      power-of-2 value as hardware demands it
 607          * @max_unicast_filters: Maximum number of unicast filters;
 608          *                      '0' is treated  as '16'
 609          * @max_multicast_filters: Maximum number of multicast filters;
 610          *                      '0' is treated as '64'
 611          * @max_qos_entries: if 'max_tcs > 1', declares the maximum entries in
 612          *                      the QoS table; '0' is treated as '64'
 613          * @max_qos_key_size: Maximum key size for the QoS look-up;
 614          *                      '0' is treated as '24' which is enough for IPv4
 615          *                      5-tuple
 616          * @max_dist_key_size: Maximum key size for the distribution;
 617          *              '0' is treated as '24' which is enough for IPv4 5-tuple
 618          * @max_policers: Maximum number of policers;
 619          *              should be between '0' and max_tcs
 620          * @max_congestion_ctrl: Maximum number of congestion control groups
 621          *              (CGs); covers early drop and congestion notification
 622          *              requirements for traffic classes;
 623          *              should be between '0' and max_tcs
 624          * @ipr_cfg: IP reassembly configuration
 625          */
 626         struct {
 627                 uint32_t                options;
 628                 enum net_prot           start_hdr;
 629                 uint8_t         max_senders;
 630                 uint8_t         max_tcs;
 631                 uint8_t                 max_dist_per_tc[DPNI_MAX_TC];
 632                 uint8_t         max_unicast_filters;
 633                 uint8_t         max_multicast_filters;
 634                 uint8_t                 max_vlan_filters;
 635                 uint8_t         max_qos_entries;
 636                 uint8_t         max_qos_key_size;
 637                 uint8_t         max_dist_key_size;
 638                 uint8_t         max_policers;
 639                 uint8_t         max_congestion_ctrl;
 640                 struct dpni_ipr_cfg     ipr_cfg;
 641         } adv;
 642 };
 643
 644 /**
 645  * dpni_create() - Create the DPNI object
 646  * @mc_io:      Pointer to MC portal's I/O object
 647  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 648  * @cfg:        Configuration structure
 649  * @token:      Returned token; use in subsequent API calls
 650  *
 651  * Create the DPNI object, allocate required resources and
 652  * perform required initialization.
 653  *
 654  * The object can be created either by declaring it in the
 655  * DPL file, or by calling this function.
 656  *
 657  * This function returns a unique authentication token,
 658  * associated with the specific object ID and the specific MC
 659  * portal; this token must be used in all subsequent calls to
 660  * this specific object. For objects that are created using the
 661  * DPL file, call dpni_open() function to get an authentication
 662  * token first.
 663  *
 664  * Return:      '0' on Success; Error code otherwise.
 665  */
 666 int dpni_create(struct fsl_mc_io        *mc_io,
 667                 uint32_t                cmd_flags,
 668                 const struct dpni_cfg   *cfg,
 669                 uint16_t                *token);
 670
 671 /**
 672  * dpni_destroy() - Destroy the DPNI object and release all its resources.
 673  * @mc_io:      Pointer to MC portal's I/O object
 674  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 675  * @token:      Token of DPNI object
 676  *
 677  * Return:      '0' on Success; error code otherwise.
 678  */
 679 int dpni_destroy(struct fsl_mc_io       *mc_io,
 680                  uint32_t               cmd_flags,
 681                  uint16_t               token);
 682
 683 /**
 684  * struct dpni_pools_cfg - Structure representing buffer pools configuration
 685  * @num_dpbp: Number of DPBPs
 686  * @pools: Array of buffer pools parameters; The number of valid entries
 687  *      must match 'num_dpbp' value
 688  */
 689 struct dpni_pools_cfg {
 690         uint8_t num_dpbp;
 691         /**
 692          * struct pools - Buffer pools parameters
 693          * @dpbp_id: DPBP object ID
 694          * @buffer_size: Buffer size
 695          * @backup_pool: Backup pool
 696          */
 697         struct {
 698                 int             dpbp_id;
 699                 uint16_t        buffer_size;
 700                 int             backup_pool;
 701         } pools[DPNI_MAX_DPBP];
 702 };
 703
 704 /**
 705  * dpni_set_pools() - Set buffer pools configuration
 706  * @mc_io:      Pointer to MC portal's I/O object
 707  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 708  * @token:      Token of DPNI object
 709  * @cfg:        Buffer pools configuration
 710  *
 711  * mandatory for DPNI operation
 712  * warning:Allowed only when DPNI is disabled
 713  *
 714  * Return:      '0' on Success; Error code otherwise.
 715  */
 716 int dpni_set_pools(struct fsl_mc_io             *mc_io,
 717                    uint32_t                     cmd_flags,
 718                    uint16_t                     token,
 719                    const struct dpni_pools_cfg  *cfg);
 720
 721 /**
 722  * dpni_enable() - Enable the DPNI, allow sending and receiving frames.
 723  * @mc_io:      Pointer to MC portal's I/O object
 724  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 725  * @token:              Token of DPNI object
 726  *
 727  * Return:      '0' on Success; Error code otherwise.
 728  */
 729 int dpni_enable(struct fsl_mc_io        *mc_io,
 730                 uint32_t                cmd_flags,
 731                 uint16_t                token);
 732
 733 /**
 734  * dpni_disable() - Disable the DPNI, stop sending and receiving frames.
 735  * @mc_io:      Pointer to MC portal's I/O object
 736  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 737  * @token:      Token of DPNI object
 738  *
 739  * Return:      '0' on Success; Error code otherwise.
 740  */
 741 int dpni_disable(struct fsl_mc_io       *mc_io,
 742                  uint32_t               cmd_flags,
 743                  uint16_t               token);
 744
 745
 746 /**
 747  * dpni_reset() - Reset the DPNI, returns the object to initial state.
 748  * @mc_io:      Pointer to MC portal's I/O object
 749  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 750  * @token:      Token of DPNI object
 751  *
 752  * Return:      '0' on Success; Error code otherwise.
 753  */
 754 int dpni_reset(struct fsl_mc_io *mc_io,
 755                uint32_t         cmd_flags,
 756                uint16_t         token);
 757
 758 /**
 759  * struct dpni_attr - Structure representing DPNI attributes
 760  * @id: DPNI object ID
 761  * @version: DPNI version
 762  * @start_hdr: Indicates the packet starting header for parsing
 763  * @options: Mask of available options; reflects the value as was given in
 764  *              object's creation
 765  * @max_senders: Maximum number of different senders; used as the number
 766  *              of dedicated Tx flows;
 767  * @max_tcs: Maximum number of traffic classes (for both Tx and Rx)
 768  * @max_dist_per_tc: Maximum distribution size per Rx traffic class;
 769  *                      Set to the required value minus 1
 770  * @max_unicast_filters: Maximum number of unicast filters
 771  * @max_multicast_filters: Maximum number of multicast filters
 772  * @max_vlan_filters: Maximum number of VLAN filters
 773  * @max_qos_entries: if 'max_tcs > 1', declares the maximum entries in QoS table
 774  * @max_qos_key_size: Maximum key size for the QoS look-up
 775  * @max_dist_key_size: Maximum key size for the distribution look-up
 776  * @max_policers: Maximum number of policers;
 777  * @max_congestion_ctrl: Maximum number of congestion control groups (CGs);
 778  * @ipr_cfg: IP reassembly configuration
 779  */
 780 struct dpni_attr {
 781         int id;
 782         /**
 783          * struct version - DPNI version
 784          * @major: DPNI major version
 785          * @minor: DPNI minor version
 786          */
 787         struct {
 788                 uint16_t major;
 789                 uint16_t minor;
 790         } version;
 791         enum net_prot start_hdr;
 792         uint32_t options;
 793         uint8_t max_senders;
 794         uint8_t max_tcs;
 795         uint8_t max_dist_per_tc[DPNI_MAX_TC];
 796         uint8_t max_unicast_filters;
 797         uint8_t max_multicast_filters;
 798         uint8_t max_vlan_filters;
 799         uint8_t max_qos_entries;
 800         uint8_t max_qos_key_size;
 801         uint8_t max_dist_key_size;
 802         uint8_t max_policers;
 803         uint8_t max_congestion_ctrl;
 804         struct dpni_ipr_cfg ipr_cfg;
 805 };
 806
 807 /**
 808  * dpni_get_attributes() - Retrieve DPNI attributes.
 809  * @mc_io:      Pointer to MC portal's I/O object
 810  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 811  * @token:      Token of DPNI object
 812  * @attr:       Returned object's attributes
 813  *
 814  * Return:      '0' on Success; Error code otherwise.
 815  */
 816 int dpni_get_attributes(struct fsl_mc_io        *mc_io,
 817                         uint32_t                cmd_flags,
 818                         uint16_t                token,
 819                         struct dpni_attr        *attr);
 820
 821 /* DPNI buffer layout modification options */
 822
 823 /* Select to modify the time-stamp setting */
 824 #define DPNI_BUF_LAYOUT_OPT_TIMESTAMP           0x00000001
 825 /* Select to modify the parser-result setting; not applicable for Tx */
 826 #define DPNI_BUF_LAYOUT_OPT_PARSER_RESULT       0x00000002
 827 /* Select to modify the frame-status setting */
 828 #define DPNI_BUF_LAYOUT_OPT_FRAME_STATUS        0x00000004
 829 /* Select to modify the private-data-size setting */
 830 #define DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE   0x00000008
 831 /* Select to modify the data-alignment setting */
 832 #define DPNI_BUF_LAYOUT_OPT_DATA_ALIGN          0x00000010
 833 /* Select to modify the data-head-room setting */
 834 #define DPNI_BUF_LAYOUT_OPT_DATA_HEAD_ROOM      0x00000020
 835 /*!< Select to modify the data-tail-room setting */
 836 #define DPNI_BUF_LAYOUT_OPT_DATA_TAIL_ROOM      0x00000040
 837
 838 /**
 839  * struct dpni_buffer_layout - Structure representing DPNI buffer layout
 840  * @options: Flags representing the suggested modifications to the buffer
 841  *              layout; Use any combination of 'DPNI_BUF_LAYOUT_OPT_<X>' flags
 842  * @pass_timestamp: Pass timestamp value
 843  * @pass_parser_result: Pass parser results
 844  * @pass_frame_status: Pass frame status
 845  * @private_data_size: Size kept for private data (in bytes)
 846  * @data_align: Data alignment
 847  * @data_head_room: Data head room
 848  * @data_tail_room: Data tail room
 849  */
 850 struct dpni_buffer_layout {
 851         uint32_t options;
 852         int pass_timestamp;
 853         int pass_parser_result;
 854         int pass_frame_status;
 855         uint16_t private_data_size;
 856         uint16_t data_align;
 857         uint16_t data_head_room;
 858         uint16_t data_tail_room;
 859 };
 860
 861 /**
 862  * dpni_get_rx_buffer_layout() - Retrieve Rx buffer layout attributes.
 863  * @mc_io:      Pointer to MC portal's I/O object
 864  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 865  * @token:      Token of DPNI object
 866  * @layout:     Returns buffer layout attributes
 867  *
 868  * Return:      '0' on Success; Error code otherwise.
 869  */
 870 int dpni_get_rx_buffer_layout(struct fsl_mc_io          *mc_io,
 871                               uint32_t                  cmd_flags,
 872                               uint16_t                  token,
 873                               struct dpni_buffer_layout *layout);
 874
 875 /**
 876  * dpni_set_rx_buffer_layout() - Set Rx buffer layout configuration.
 877  * @mc_io:      Pointer to MC portal's I/O object
 878  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 879  * @token:      Token of DPNI object
 880  * @layout:     Buffer layout configuration
 881  *
 882  * Return:      '0' on Success; Error code otherwise.
 883  *
 884  * @warning     Allowed only when DPNI is disabled
 885  */
 886 int dpni_set_rx_buffer_layout(struct fsl_mc_io                  *mc_io,
 887                               uint32_t                          cmd_flags,
 888                               uint16_t                          token,
 889                               const struct dpni_buffer_layout   *layout);
 890
 891 /**
 892  * dpni_get_tx_buffer_layout() - Retrieve Tx buffer layout attributes.
 893  * @mc_io:      Pointer to MC portal's I/O object
 894  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 895  * @token:      Token of DPNI object
 896  * @layout:     Returns buffer layout attributes
 897  *
 898  * Return:      '0' on Success; Error code otherwise.
 899  */
 900 int dpni_get_tx_buffer_layout(struct fsl_mc_io          *mc_io,
 901                               uint32_t                  cmd_flags,
 902                               uint16_t                  token,
 903                               struct dpni_buffer_layout *layout);
 904
 905 /**
 906  * dpni_set_tx_buffer_layout() - Set Tx buffer layout configuration.
 907  * @mc_io:      Pointer to MC portal's I/O object
 908  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 909  * @token:      Token of DPNI object
 910  * @layout:     Buffer layout configuration
 911  *
 912  * Return:      '0' on Success; Error code otherwise.
 913  *
 914  * @warning     Allowed only when DPNI is disabled
 915  */
 916 int dpni_set_tx_buffer_layout(struct fsl_mc_io                  *mc_io,
 917                               uint32_t                          cmd_flags,
 918                               uint16_t                          token,
 919                               const struct dpni_buffer_layout   *layout);
 920
 921 /**
 922  * dpni_get_tx_conf_buffer_layout() - Retrieve Tx confirmation buffer layout
 923  *                              attributes.
 924  * @mc_io:      Pointer to MC portal's I/O object
 925  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 926  * @token:      Token of DPNI object
 927  * @layout:     Returns buffer layout attributes
 928  *
 929  * Return:      '0' on Success; Error code otherwise.
 930  */
 931 int dpni_get_tx_conf_buffer_layout(struct fsl_mc_io             *mc_io,
 932                                    uint32_t                     cmd_flags,
 933                                    uint16_t                     token,
 934                                    struct dpni_buffer_layout    *layout);
 935
 936 /**
 937  * dpni_set_tx_conf_buffer_layout() - Set Tx confirmation buffer layout
 938  *                                      configuration.
 939  * @mc_io:      Pointer to MC portal's I/O object
 940  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 941  * @token:      Token of DPNI object
 942  * @layout:     Buffer layout configuration
 943  *
 944  * Return:      '0' on Success; Error code otherwise.
 945  *
 946  * @warning     Allowed only when DPNI is disabled
 947  */
 948 int dpni_set_tx_conf_buffer_layout(struct fsl_mc_io                *mc_io,
 949                                    uint32_t                        cmd_flags,
 950                                    uint16_t                        token,
 951                                    const struct dpni_buffer_layout *layout);
 952
 953 /**
 954  * dpni_get_qdid() - Get the Queuing Destination ID (QDID) that should be used
 955  *                      for enqueue operations
 956  * @mc_io:      Pointer to MC portal's I/O object
 957  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 958  * @token:      Token of DPNI object
 959  * @qdid:       Returned virtual QDID value that should be used as an argument
 960  *                      in all enqueue operations
 961  *
 962  * Return:      '0' on Success; Error code otherwise.
 963  */
 964 int dpni_get_qdid(struct fsl_mc_io      *mc_io,
 965                   uint32_t              cmd_flags,
 966                   uint16_t              token,
 967                   uint16_t              *qdid);
 968
 969 /**
 970  * dpni_get_tx_data_offset() - Get the Tx data offset (from start of buffer)
 971  * @mc_io:      Pointer to MC portal's I/O object
 972  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 973  * @token:      Token of DPNI object
 974  * @data_offset: Tx data offset (from start of buffer)
 975  *
 976  * Return:      '0' on Success; Error code otherwise.
 977  */
 978 int dpni_get_tx_data_offset(struct fsl_mc_io    *mc_io,
 979                             uint32_t            cmd_flags,
 980                             uint16_t            token,
 981                             uint16_t            *data_offset);
 982
 983 /**
 984  * enum dpni_counter - DPNI counter types
 985  * @DPNI_CNT_ING_FRAME: Counts ingress frames
 986  * @DPNI_CNT_ING_BYTE: Counts ingress bytes
 987  * @DPNI_CNT_ING_FRAME_DROP: Counts ingress frames dropped due to explicit
 988  *              'drop' setting
 989  * @DPNI_CNT_ING_FRAME_DISCARD: Counts ingress frames discarded due to errors
 990  * @DPNI_CNT_ING_MCAST_FRAME: Counts ingress multicast frames
 991  * @DPNI_CNT_ING_MCAST_BYTE: Counts ingress multicast bytes
 992  * @DPNI_CNT_ING_BCAST_FRAME: Counts ingress broadcast frames
 993  * @DPNI_CNT_ING_BCAST_BYTES: Counts ingress broadcast bytes
 994  * @DPNI_CNT_EGR_FRAME: Counts egress frames
 995  * @DPNI_CNT_EGR_BYTE: Counts egress bytes
 996  * @DPNI_CNT_EGR_FRAME_DISCARD: Counts egress frames discarded due to errors
 997  */
 998 enum dpni_counter {
 999         DPNI_CNT_ING_FRAME = 0x0,
1000         DPNI_CNT_ING_BYTE = 0x1,
1001         DPNI_CNT_ING_FRAME_DROP = 0x2,
1002         DPNI_CNT_ING_FRAME_DISCARD = 0x3,
1003         DPNI_CNT_ING_MCAST_FRAME = 0x4,
1004         DPNI_CNT_ING_MCAST_BYTE = 0x5,
1005         DPNI_CNT_ING_BCAST_FRAME = 0x6,
1006         DPNI_CNT_ING_BCAST_BYTES = 0x7,
1007         DPNI_CNT_EGR_FRAME = 0x8,
1008         DPNI_CNT_EGR_BYTE = 0x9,
1009         DPNI_CNT_EGR_FRAME_DISCARD = 0xa
1010 };
1011
1012 /**
1013  * dpni_get_counter() - Read a specific DPNI counter
1014  * @mc_io:      Pointer to MC portal's I/O object
1015  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1016  * @token:      Token of DPNI object
1017  * @counter:    The requested counter
1018  * @value:      Returned counter's current value
1019  *
1020  * Return:      '0' on Success; Error code otherwise.
1021  */
1022 int dpni_get_counter(struct fsl_mc_io   *mc_io,
1023                      uint32_t           cmd_flags,
1024                      uint16_t           token,
1025                      enum dpni_counter  counter,
1026                      uint64_t           *value);
1027
1028 /**
1029  * dpni_set_counter() - Set (or clear) a specific DPNI counter
1030  * @mc_io:      Pointer to MC portal's I/O object
1031  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1032  * @token:      Token of DPNI object
1033  * @counter:    The requested counter
1034  * @value:      New counter value; typically pass '0' for resetting
1035  *                      the counter.
1036  *
1037  * Return:      '0' on Success; Error code otherwise.
1038  */
1039 int dpni_set_counter(struct fsl_mc_io   *mc_io,
1040                      uint32_t           cmd_flags,
1041                      uint16_t           token,
1042                      enum dpni_counter  counter,
1043                      uint64_t           value);
1044
1045 /* Enable auto-negotiation */
1046 #define DPNI_LINK_OPT_AUTONEG           0x0000000000000001ULL
1047 /* Enable half-duplex mode */
1048 #define DPNI_LINK_OPT_HALF_DUPLEX       0x0000000000000002ULL
1049 /* Enable pause frames */
1050 #define DPNI_LINK_OPT_PAUSE             0x0000000000000004ULL
1051 /* Enable a-symmetric pause frames */
1052 #define DPNI_LINK_OPT_ASYM_PAUSE        0x0000000000000008ULL
1053
1054 /**
1055  * struct - Structure representing DPNI link configuration
1056  * @rate: Rate
1057  * @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values
1058  */
1059 struct dpni_link_cfg {
1060         uint32_t rate;
1061         uint64_t options;
1062 };
1063
1064 /**
1065  * dpni_set_link_cfg() - set the link configuration.
1066  * @mc_io:      Pointer to MC portal's I/O object
1067  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1068  * @token:      Token of DPNI object
1069  * @cfg:        Link configuration
1070  *
1071  * Return:      '0' on Success; Error code otherwise.
1072  */
1073 int dpni_set_link_cfg(struct fsl_mc_io                  *mc_io,
1074                       uint32_t                          cmd_flags,
1075                       uint16_t                          token,
1076                       const struct dpni_link_cfg        *cfg);
1077
1078 /**
1079  * struct dpni_link_state - Structure representing DPNI link state
1080  * @rate: Rate
1081  * @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values
1082  * @up: Link state; '0' for down, '1' for up
1083  */
1084 struct dpni_link_state {
1085         uint32_t rate;
1086         uint64_t options;
1087         int up;
1088 };
1089
1090 /**
1091  * dpni_get_link_state() - Return the link state (either up or down)
1092  * @mc_io:      Pointer to MC portal's I/O object
1093  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1094  * @token:      Token of DPNI object
1095  * @state:      Returned link state;
1096  *
1097  * Return:      '0' on Success; Error code otherwise.
1098  */
1099 int dpni_get_link_state(struct fsl_mc_io        *mc_io,
1100                         uint32_t                cmd_flags,
1101                         uint16_t                token,
1102                         struct dpni_link_state  *state);
1103
1104 /**
1105  * dpni_set_primary_mac_addr() - Set the primary MAC address
1106  * @mc_io:      Pointer to MC portal's I/O object
1107  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1108  * @token:      Token of DPNI object
1109  * @mac_addr:   MAC address to set as primary address
1110  *
1111  * Return:      '0' on Success; Error code otherwise.
1112  */
1113 int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
1114                               uint32_t          cmd_flags,
1115                               uint16_t          token,
1116                               const uint8_t     mac_addr[6]);
1117
1118 /**
1119  * dpni_get_primary_mac_addr() - Get the primary MAC address
1120  * @mc_io:      Pointer to MC portal's I/O object
1121  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1122  * @token:      Token of DPNI object
1123  * @mac_addr:   Returned MAC address
1124  *
1125  * Return:      '0' on Success; Error code otherwise.
1126  */
1127 int dpni_get_primary_mac_addr(struct fsl_mc_io  *mc_io,
1128                               uint32_t          cmd_flags,
1129                               uint16_t          token,
1130                               uint8_t           mac_addr[6]);
1131
1132 /**
1133  * dpni_add_mac_addr() - Add MAC address filter
1134  * @mc_io:      Pointer to MC portal's I/O object
1135  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1136  * @token:      Token of DPNI object
1137  * @mac_addr:   MAC address to add
1138  *
1139  * Return:      '0' on Success; Error code otherwise.
1140  */
1141 int dpni_add_mac_addr(struct fsl_mc_io  *mc_io,
1142                       uint32_t          cmd_flags,
1143                       uint16_t          token,
1144                       const uint8_t     mac_addr[6]);
1145
1146 /**
1147  * dpni_remove_mac_addr() - Remove MAC address filter
1148  * @mc_io:      Pointer to MC portal's I/O object
1149  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1150  * @token:      Token of DPNI object
1151  * @mac_addr:   MAC address to remove
1152  *
1153  * Return:      '0' on Success; Error code otherwise.
1154  */
1155 int dpni_remove_mac_addr(struct fsl_mc_io       *mc_io,
1156                          uint32_t               cmd_flags,
1157                          uint16_t               token,
1158                          const uint8_t          mac_addr[6]);
1159
1160 /**
1161  * enum dpni_dest - DPNI destination types
1162  * @DPNI_DEST_NONE: Unassigned destination; The queue is set in parked mode and
1163  *              does not generate FQDAN notifications; user is expected to
1164  *              dequeue from the queue based on polling or other user-defined
1165  *              method
1166  * @DPNI_DEST_DPIO: The queue is set in schedule mode and generates FQDAN
1167  *              notifications to the specified DPIO; user is expected to dequeue
1168  *              from the queue only after notification is received
1169  * @DPNI_DEST_DPCON: The queue is set in schedule mode and does not generate
1170  *              FQDAN notifications, but is connected to the specified DPCON
1171  *              object; user is expected to dequeue from the DPCON channel
1172  */
1173 enum dpni_dest {
1174         DPNI_DEST_NONE = 0,
1175         DPNI_DEST_DPIO = 1,
1176         DPNI_DEST_DPCON = 2
1177 };
1178
1179 /**
1180  * struct dpni_dest_cfg - Structure representing DPNI destination parameters
1181  * @dest_type: Destination type
1182  * @dest_id: Either DPIO ID or DPCON ID, depending on the destination type
1183  * @priority: Priority selection within the DPIO or DPCON channel; valid values
1184  *              are 0-1 or 0-7, depending on the number of priorities in that
1185  *              channel; not relevant for 'DPNI_DEST_NONE' option
1186  */
1187 struct dpni_dest_cfg {
1188         enum dpni_dest dest_type;
1189         int dest_id;
1190         uint8_t priority;
1191 };
1192
1193 /**
1194  * enum dpni_flc_type - DPNI FLC types
1195  * @DPNI_FLC_USER_DEFINED: select the FLC to be used for user defined value
1196  * @DPNI_FLC_STASH: select the FLC to be used for stash control
1197  */
1198 enum dpni_flc_type {
1199         DPNI_FLC_USER_DEFINED = 0,
1200         DPNI_FLC_STASH = 1,
1201 };
1202
1203 /**
1204  * enum dpni_stash_size - DPNI FLC stashing size
1205  * @DPNI_STASH_SIZE_0B: no stash
1206  * @DPNI_STASH_SIZE_64B: stashes 64 bytes
1207  * @DPNI_STASH_SIZE_128B: stashes 128 bytes
1208  * @DPNI_STASH_SIZE_192B: stashes 192 bytes
1209  */
1210 enum dpni_stash_size {
1211         DPNI_STASH_SIZE_0B = 0,
1212         DPNI_STASH_SIZE_64B = 1,
1213         DPNI_STASH_SIZE_128B = 2,
1214         DPNI_STASH_SIZE_192B = 3,
1215 };
1216
1217 /* DPNI FLC stash options */
1218
1219 /* stashes the whole annotation area (up to 192 bytes) */
1220 #define DPNI_FLC_STASH_FRAME_ANNOTATION 0x00000001
1221
1222 /**
1223  * struct dpni_flc_cfg - Structure representing DPNI FLC configuration
1224  * @flc_type: FLC type
1225  * @options: Mask of available options;
1226  *      use 'DPNI_FLC_STASH_<X>' values
1227  * @frame_data_size: Size of frame data to be stashed
1228  * @flow_context_size: Size of flow context to be stashed
1229  * @flow_context: 1. In case flc_type is 'DPNI_FLC_USER_DEFINED':
1230  *                      this value will be provided in the frame descriptor
1231  *                      (FD[FLC])
1232  *                2. In case flc_type is 'DPNI_FLC_STASH':
1233  *                      this value will be I/O virtual address of the
1234  *                      flow-context;
1235  *                      Must be cacheline-aligned and DMA-able memory
1236  */
1237 struct dpni_flc_cfg {
1238         enum dpni_flc_type flc_type;
1239         uint32_t options;
1240         enum dpni_stash_size frame_data_size;
1241         enum dpni_stash_size flow_context_size;
1242         uint64_t flow_context;
1243 };
1244
1245 /* DPNI queue modification options */
1246
1247 /* Select to modify the user's context associated with the queue */
1248 #define DPNI_QUEUE_OPT_USER_CTX         0x00000001
1249 /* Select to modify the queue's destination */
1250 #define DPNI_QUEUE_OPT_DEST             0x00000002
1251 /** Select to modify the flow-context parameters;
1252  * not applicable for Tx-conf/Err queues as the FD comes from the user
1253  */
1254 #define DPNI_QUEUE_OPT_FLC              0x00000004
1255 /* Select to modify the queue's order preservation */
1256 #define DPNI_QUEUE_OPT_ORDER_PRESERVATION 0x00000008
1257
1258 /**
1259  * struct dpni_queue_cfg - Structure representing queue configuration
1260  * @options: Flags representing the suggested modifications to the queue;
1261  *              Use any combination of 'DPNI_QUEUE_OPT_<X>' flags
1262  * @user_ctx: User context value provided in the frame descriptor of each
1263  *              dequeued frame; valid only if 'DPNI_QUEUE_OPT_USER_CTX'
1264  *              is contained in 'options'
1265  * @dest_cfg: Queue destination parameters;
1266  *              valid only if 'DPNI_QUEUE_OPT_DEST' is contained in 'options'
1267  * @flc_cfg: Flow context configuration; in case the TC's distribution
1268  *              is either NONE or HASH the FLC's settings of flow#0 are used.
1269  *              in the case of FS (flow-steering) the flow's FLC settings
1270  *              are used.
1271  *              valid only if 'DPNI_QUEUE_OPT_FLC' is contained in 'options'
1272  * @order_preservation_en: enable/disable order preservation;
1273  *              valid only if 'DPNI_QUEUE_OPT_ORDER_PRESERVATION' is contained
1274  *              in 'options'
1275  */
1276 struct dpni_queue_cfg {
1277         uint32_t options;
1278         uint64_t user_ctx;
1279         struct dpni_dest_cfg dest_cfg;
1280         struct dpni_flc_cfg flc_cfg;
1281         int order_preservation_en;
1282 };
1283
1284 /**
1285  * struct dpni_queue_attr - Structure representing queue attributes
1286  * @user_ctx: User context value provided in the frame descriptor of each
1287  *      dequeued frame
1288  * @dest_cfg: Queue destination configuration
1289  * @flc_cfg: Flow context configuration
1290  * @order_preservation_en: enable/disable order preservation
1291  * @fqid: Virtual fqid value to be used for dequeue operations
1292  */
1293 struct dpni_queue_attr {
1294         uint64_t user_ctx;
1295         struct dpni_dest_cfg dest_cfg;
1296         struct dpni_flc_cfg flc_cfg;
1297         int order_preservation_en;
1298         uint32_t fqid;
1299 };
1300
1301 /* DPNI Tx flow modification options */
1302
1303 /* Select to modify the settings for dedicate Tx confirmation/error */
1304 #define DPNI_TX_FLOW_OPT_TX_CONF_ERROR  0x00000001
1305 /*!< Select to modify the Tx confirmation and/or error setting */
1306 #define DPNI_TX_FLOW_OPT_ONLY_TX_ERROR  0x00000002
1307 /*!< Select to modify the queue configuration */
1308 #define DPNI_TX_FLOW_OPT_QUEUE          0x00000004
1309 /*!< Select to modify the L3 checksum generation setting */
1310 #define DPNI_TX_FLOW_OPT_L3_CHKSUM_GEN  0x00000010
1311 /*!< Select to modify the L4 checksum generation setting */
1312 #define DPNI_TX_FLOW_OPT_L4_CHKSUM_GEN  0x00000020
1313
1314 /**
1315  * struct dpni_tx_flow_cfg - Structure representing Tx flow configuration
1316  * @options: Flags representing the suggested modifications to the Tx flow;
1317  *              Use any combination 'DPNI_TX_FLOW_OPT_<X>' flags
1318  * @conf_err_cfg: Tx confirmation and error configuration; these settings are
1319  *              ignored if 'DPNI_OPT_PRIVATE_TX_CONF_ERROR_DISABLED' was set at
1320  *              DPNI creation
1321  * @l3_chksum_gen: Set to '1' to enable L3 checksum generation; '0' to disable;
1322  *              valid only if 'DPNI_TX_FLOW_OPT_L3_CHKSUM_GEN' is contained in
1323  *              'options'
1324  * @l4_chksum_gen: Set to '1' to enable L4 checksum generation; '0' to disable;
1325  *              valid only if 'DPNI_TX_FLOW_OPT_L4_CHKSUM_GEN' is contained in
1326  *              'options'
1327  */
1328 struct dpni_tx_flow_cfg {
1329         uint32_t options;
1330         /**
1331          * struct cnf_err_cfg - Tx confirmation and error configuration
1332          * @use_default_queue: Set to '1' to use the common (default) Tx
1333          *              confirmation and error queue; Set to '0' to use the
1334          *              private Tx confirmation and error queue; valid only if
1335          *              'DPNI_TX_FLOW_OPT_TX_CONF_ERROR' is contained in
1336          *              'options'
1337          * @errors_only: Set to '1' to report back only error frames;
1338          *              Set to '0' to confirm transmission/error for all
1339          *              transmitted frames;
1340          *              valid only if 'DPNI_TX_FLOW_OPT_ONLY_TX_ERROR' is
1341          *              contained in 'options' and 'use_default_queue = 0';
1342          * @queue_cfg: Queue configuration; valid only if
1343          *              'DPNI_TX_FLOW_OPT_QUEUE' is contained in 'options'
1344          */
1345         struct {
1346                 int use_default_queue;
1347                 int errors_only;
1348                 struct dpni_queue_cfg queue_cfg;
1349         } conf_err_cfg;
1350         int l3_chksum_gen;
1351         int l4_chksum_gen;
1352 };
1353
1354 /**
1355  * dpni_set_tx_flow() - Set Tx flow configuration
1356  * @mc_io:      Pointer to MC portal's I/O object
1357  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1358  * @token:      Token of DPNI object
1359  * @flow_id:    Provides (or returns) the sender's flow ID;
1360  *                              for each new sender set (*flow_id) to
1361  *                              'DPNI_NEW_FLOW_ID' to generate a new flow_id;
1362  *                              this ID should be used as the QDBIN argument
1363  *                              in enqueue operations
1364  * @cfg:        Tx flow configuration
1365  *
1366  * Return:      '0' on Success; Error code otherwise.
1367  */
1368 int dpni_set_tx_flow(struct fsl_mc_io                   *mc_io,
1369                      uint32_t                           cmd_flags,
1370                      uint16_t                           token,
1371                      uint16_t                           *flow_id,
1372                      const struct dpni_tx_flow_cfg      *cfg);
1373
1374 /**
1375  * struct dpni_tx_flow_attr - Structure representing Tx flow attributes
1376  * @conf_err_attr: Tx confirmation and error attributes
1377  * @l3_chksum_gen: '1' if L3 checksum generation is enabled; '0' if disabled
1378  * @l4_chksum_gen: '1' if L4 checksum generation is enabled; '0' if disabled
1379  */
1380 struct dpni_tx_flow_attr {
1381         /**
1382          * struct conf_err_attr - Tx confirmation and error attributes
1383          * @use_default_queue: '1' if using common (default) Tx confirmation and
1384          *                      error queue;
1385          *                      '0' if using private Tx confirmation and error
1386          *                      queue
1387          * @errors_only: '1' if only error frames are reported back; '0' if all
1388          *              transmitted frames are confirmed
1389          * @queue_attr: Queue attributes
1390          */
1391         struct {
1392                 int use_default_queue;
1393                 int errors_only;
1394                 struct dpni_queue_attr queue_attr;
1395         } conf_err_attr;
1396         int l3_chksum_gen;
1397         int l4_chksum_gen;
1398 };
1399
1400 /**
1401  * dpni_get_tx_flow() - Get Tx flow attributes
1402  * @mc_io:      Pointer to MC portal's I/O object
1403  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1404  * @token:      Token of DPNI object
1405  * @flow_id:    The sender's flow ID, as returned by the
1406  *                      dpni_set_tx_flow() function
1407  * @attr:       Returned Tx flow attributes
1408  *
1409  * Return:      '0' on Success; Error code otherwise.
1410  */
1411 int dpni_get_tx_flow(struct fsl_mc_io           *mc_io,
1412                      uint32_t                   cmd_flags,
1413                      uint16_t                   token,
1414                      uint16_t                   flow_id,
1415                      struct dpni_tx_flow_attr   *attr);
1416
1417 /**
1418  * dpni_set_rx_flow() - Set Rx flow configuration
1419  * @mc_io:      Pointer to MC portal's I/O object
1420  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1421  * @token:      Token of DPNI object
1422  * @tc_id:      Traffic class selection (0-7);
1423  *                      use 'DPNI_ALL_TCS' to set all TCs and all flows
1424  * @flow_id:    Rx flow id within the traffic class; use
1425  *                      'DPNI_ALL_TC_FLOWS' to set all flows within
1426  *                      this tc_id; ignored if tc_id is set to
1427  *                      'DPNI_ALL_TCS';
1428  * @cfg:        Rx flow configuration
1429  *
1430  * Return:      '0' on Success; Error code otherwise.
1431  */
1432 int dpni_set_rx_flow(struct fsl_mc_io                   *mc_io,
1433                      uint32_t                           cmd_flags,
1434                      uint16_t                           token,
1435                      uint8_t                            tc_id,
1436                      uint16_t                           flow_id,
1437                      const struct dpni_queue_cfg        *cfg);
1438
1439 /**
1440  * dpni_get_rx_flow() - Get Rx flow attributes
1441  * @mc_io:      Pointer to MC portal's I/O object
1442  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1443  * @token:      Token of DPNI object
1444  * @tc_id:      Traffic class selection (0-7)
1445  * @flow_id:    Rx flow id within the traffic class
1446  * @attr:       Returned Rx flow attributes
1447  *
1448  * Return:      '0' on Success; Error code otherwise.
1449  */
1450 int dpni_get_rx_flow(struct fsl_mc_io           *mc_io,
1451                      uint32_t                   cmd_flags,
1452                      uint16_t                   token,
1453                      uint8_t                    tc_id,
1454                      uint16_t                   flow_id,
1455                      struct dpni_queue_attr     *attr);
1456
1457 #endif /* _FSL_DPNI_H */