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 4 11 #define DPNI_VER_MINOR 0 12 13 /* Command IDs */ 14 #define DPNI_CMDID_OPEN 0x801 15 #define DPNI_CMDID_CLOSE 0x800 16 17 #define DPNI_CMDID_ENABLE 0x002 18 #define DPNI_CMDID_DISABLE 0x003 19 #define DPNI_CMDID_GET_ATTR 0x004 20 #define DPNI_CMDID_RESET 0x005 21 22 #define DPNI_CMDID_SET_POOLS 0x200 23 #define DPNI_CMDID_GET_RX_BUFFER_LAYOUT 0x201 24 #define DPNI_CMDID_SET_RX_BUFFER_LAYOUT 0x202 25 #define DPNI_CMDID_GET_TX_BUFFER_LAYOUT 0x203 26 #define DPNI_CMDID_SET_TX_BUFFER_LAYOUT 0x204 27 #define DPNI_CMDID_SET_TX_CONF_BUFFER_LAYOUT 0x205 28 #define DPNI_CMDID_GET_TX_CONF_BUFFER_LAYOUT 0x206 29 30 #define DPNI_CMDID_GET_QDID 0x210 31 #define DPNI_CMDID_GET_TX_DATA_OFFSET 0x212 32 #define DPNI_CMDID_GET_COUNTER 0x213 33 #define DPNI_CMDID_SET_COUNTER 0x214 34 #define DPNI_CMDID_GET_LINK_STATE 0x215 35 #define DPNI_CMDID_SET_LINK_CFG 0x21A 36 37 #define DPNI_CMDID_SET_PRIM_MAC 0x224 38 #define DPNI_CMDID_GET_PRIM_MAC 0x225 39 #define DPNI_CMDID_ADD_MAC_ADDR 0x226 40 #define DPNI_CMDID_REMOVE_MAC_ADDR 0x227 41 42 #define DPNI_CMDID_SET_TX_FLOW 0x236 43 #define DPNI_CMDID_GET_TX_FLOW 0x237 44 #define DPNI_CMDID_SET_RX_FLOW 0x238 45 #define DPNI_CMDID_GET_RX_FLOW 0x239 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 52 /* cmd, param, offset, width, type, arg_name */ 53 #define DPNI_CMD_SET_POOLS(cmd, cfg) \ 54 do { \ 55 MC_CMD_OP(cmd, 0, 0, 8, uint8_t, cfg->num_dpbp); \ 56 MC_CMD_OP(cmd, 0, 32, 32, int, cfg->pools[0].dpbp_id); \ 57 MC_CMD_OP(cmd, 4, 32, 16, uint16_t, cfg->pools[0].buffer_size);\ 58 MC_CMD_OP(cmd, 1, 0, 32, int, cfg->pools[1].dpbp_id); \ 59 MC_CMD_OP(cmd, 4, 48, 16, uint16_t, cfg->pools[1].buffer_size);\ 60 MC_CMD_OP(cmd, 1, 32, 32, int, cfg->pools[2].dpbp_id); \ 61 MC_CMD_OP(cmd, 5, 0, 16, uint16_t, cfg->pools[2].buffer_size);\ 62 MC_CMD_OP(cmd, 2, 0, 32, int, cfg->pools[3].dpbp_id); \ 63 MC_CMD_OP(cmd, 5, 16, 16, uint16_t, cfg->pools[3].buffer_size);\ 64 MC_CMD_OP(cmd, 2, 32, 32, int, cfg->pools[4].dpbp_id); \ 65 MC_CMD_OP(cmd, 5, 32, 16, uint16_t, cfg->pools[4].buffer_size);\ 66 MC_CMD_OP(cmd, 3, 0, 32, int, cfg->pools[5].dpbp_id); \ 67 MC_CMD_OP(cmd, 5, 48, 16, uint16_t, cfg->pools[5].buffer_size);\ 68 MC_CMD_OP(cmd, 3, 32, 32, int, cfg->pools[6].dpbp_id); \ 69 MC_CMD_OP(cmd, 6, 0, 16, uint16_t, cfg->pools[6].buffer_size);\ 70 MC_CMD_OP(cmd, 4, 0, 32, int, cfg->pools[7].dpbp_id); \ 71 MC_CMD_OP(cmd, 6, 16, 16, uint16_t, cfg->pools[7].buffer_size);\ 72 } while (0) 73 74 /* cmd, param, offset, width, type, arg_name */ 75 #define DPNI_RSP_GET_ATTR(cmd, attr) \ 76 do { \ 77 MC_RSP_OP(cmd, 0, 0, 32, int, attr->id);\ 78 MC_RSP_OP(cmd, 0, 32, 8, uint8_t, attr->max_tcs); \ 79 MC_RSP_OP(cmd, 0, 40, 8, uint8_t, attr->max_senders); \ 80 MC_RSP_OP(cmd, 0, 48, 8, enum net_prot, attr->start_hdr); \ 81 MC_RSP_OP(cmd, 1, 0, 64, uint64_t, attr->options); \ 82 MC_RSP_OP(cmd, 2, 0, 8, uint8_t, attr->max_unicast_filters); \ 83 MC_RSP_OP(cmd, 2, 8, 8, uint8_t, attr->max_multicast_filters);\ 84 MC_RSP_OP(cmd, 2, 16, 8, uint8_t, attr->max_vlan_filters); \ 85 MC_RSP_OP(cmd, 2, 24, 8, uint8_t, attr->max_qos_entries); \ 86 MC_RSP_OP(cmd, 2, 32, 8, uint8_t, attr->max_qos_key_size); \ 87 MC_RSP_OP(cmd, 2, 40, 8, uint8_t, attr->max_dist_key_size); \ 88 MC_RSP_OP(cmd, 3, 0, 8, uint8_t, attr->max_dist_per_tc[0]); \ 89 MC_RSP_OP(cmd, 3, 8, 8, uint8_t, attr->max_dist_per_tc[1]); \ 90 MC_RSP_OP(cmd, 3, 16, 8, uint8_t, attr->max_dist_per_tc[2]); \ 91 MC_RSP_OP(cmd, 3, 24, 8, uint8_t, attr->max_dist_per_tc[3]); \ 92 MC_RSP_OP(cmd, 3, 32, 8, uint8_t, attr->max_dist_per_tc[4]); \ 93 MC_RSP_OP(cmd, 3, 40, 8, uint8_t, attr->max_dist_per_tc[5]); \ 94 MC_RSP_OP(cmd, 3, 48, 8, uint8_t, attr->max_dist_per_tc[6]); \ 95 MC_RSP_OP(cmd, 3, 56, 8, uint8_t, attr->max_dist_per_tc[7]); \ 96 MC_RSP_OP(cmd, 4, 0, 16, uint16_t, \ 97 attr->ipr_cfg.max_reass_frm_size); \ 98 MC_RSP_OP(cmd, 4, 16, 16, uint16_t, \ 99 attr->ipr_cfg.min_frag_size_ipv4); \ 100 MC_RSP_OP(cmd, 4, 32, 16, uint16_t, \ 101 attr->ipr_cfg.min_frag_size_ipv6); \ 102 MC_RSP_OP(cmd, 5, 0, 16, uint16_t, \ 103 attr->ipr_cfg.max_open_frames_ipv4); \ 104 MC_RSP_OP(cmd, 5, 16, 16, uint16_t, \ 105 attr->ipr_cfg.max_open_frames_ipv6); \ 106 MC_RSP_OP(cmd, 5, 32, 16, uint16_t, attr->version.major);\ 107 MC_RSP_OP(cmd, 5, 48, 16, uint16_t, attr->version.minor);\ 108 } while (0) 109 110 /* cmd, param, offset, width, type, arg_name */ 111 #define DPNI_RSP_GET_RX_BUFFER_LAYOUT(cmd, layout) \ 112 do { \ 113 MC_RSP_OP(cmd, 0, 0, 16, uint16_t, layout->private_data_size); \ 114 MC_RSP_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \ 115 MC_RSP_OP(cmd, 1, 0, 1, int, layout->pass_timestamp); \ 116 MC_RSP_OP(cmd, 1, 1, 1, int, layout->pass_parser_result); \ 117 MC_RSP_OP(cmd, 1, 2, 1, int, layout->pass_frame_status); \ 118 MC_RSP_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \ 119 MC_RSP_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \ 120 } while (0) 121 122 /* cmd, param, offset, width, type, arg_name */ 123 #define DPNI_CMD_SET_RX_BUFFER_LAYOUT(cmd, layout) \ 124 do { \ 125 MC_CMD_OP(cmd, 0, 0, 16, uint16_t, layout->private_data_size); \ 126 MC_CMD_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \ 127 MC_CMD_OP(cmd, 0, 32, 32, uint32_t, layout->options); \ 128 MC_CMD_OP(cmd, 1, 0, 1, int, layout->pass_timestamp); \ 129 MC_CMD_OP(cmd, 1, 1, 1, int, layout->pass_parser_result); \ 130 MC_CMD_OP(cmd, 1, 2, 1, int, layout->pass_frame_status); \ 131 MC_CMD_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \ 132 MC_CMD_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \ 133 } while (0) 134 135 /* cmd, param, offset, width, type, arg_name */ 136 #define DPNI_RSP_GET_TX_BUFFER_LAYOUT(cmd, layout) \ 137 do { \ 138 MC_RSP_OP(cmd, 0, 0, 16, uint16_t, layout->private_data_size); \ 139 MC_RSP_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \ 140 MC_RSP_OP(cmd, 1, 0, 1, int, layout->pass_timestamp); \ 141 MC_RSP_OP(cmd, 1, 1, 1, int, layout->pass_parser_result); \ 142 MC_RSP_OP(cmd, 1, 2, 1, int, layout->pass_frame_status); \ 143 MC_RSP_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \ 144 MC_RSP_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \ 145 } while (0) 146 147 /* cmd, param, offset, width, type, arg_name */ 148 #define DPNI_CMD_SET_TX_BUFFER_LAYOUT(cmd, layout) \ 149 do { \ 150 MC_CMD_OP(cmd, 0, 0, 16, uint16_t, layout->private_data_size); \ 151 MC_CMD_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \ 152 MC_CMD_OP(cmd, 0, 32, 32, uint32_t, layout->options); \ 153 MC_CMD_OP(cmd, 1, 0, 1, int, layout->pass_timestamp); \ 154 MC_CMD_OP(cmd, 1, 1, 1, int, layout->pass_parser_result); \ 155 MC_CMD_OP(cmd, 1, 2, 1, int, layout->pass_frame_status); \ 156 MC_CMD_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \ 157 MC_CMD_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \ 158 } while (0) 159 160 /* cmd, param, offset, width, type, arg_name */ 161 #define DPNI_RSP_GET_TX_CONF_BUFFER_LAYOUT(cmd, layout) \ 162 do { \ 163 MC_RSP_OP(cmd, 0, 0, 16, uint16_t, layout->private_data_size); \ 164 MC_RSP_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \ 165 MC_RSP_OP(cmd, 1, 0, 1, int, layout->pass_timestamp); \ 166 MC_RSP_OP(cmd, 1, 1, 1, int, layout->pass_parser_result); \ 167 MC_RSP_OP(cmd, 1, 2, 1, int, layout->pass_frame_status); \ 168 MC_RSP_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \ 169 MC_RSP_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \ 170 } while (0) 171 172 /* cmd, param, offset, width, type, arg_name */ 173 #define DPNI_CMD_SET_TX_CONF_BUFFER_LAYOUT(cmd, layout) \ 174 do { \ 175 MC_CMD_OP(cmd, 0, 0, 16, uint16_t, layout->private_data_size); \ 176 MC_CMD_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \ 177 MC_CMD_OP(cmd, 0, 32, 32, uint32_t, layout->options); \ 178 MC_CMD_OP(cmd, 1, 0, 1, int, layout->pass_timestamp); \ 179 MC_CMD_OP(cmd, 1, 1, 1, int, layout->pass_parser_result); \ 180 MC_CMD_OP(cmd, 1, 2, 1, int, layout->pass_frame_status); \ 181 MC_CMD_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \ 182 MC_CMD_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \ 183 } while (0) 184 185 /* cmd, param, offset, width, type, arg_name */ 186 #define DPNI_RSP_GET_QDID(cmd, qdid) \ 187 MC_RSP_OP(cmd, 0, 0, 16, uint16_t, qdid) 188 189 /* cmd, param, offset, width, type, arg_name */ 190 #define DPNI_RSP_GET_TX_DATA_OFFSET(cmd, data_offset) \ 191 MC_RSP_OP(cmd, 0, 0, 16, uint16_t, data_offset) 192 193 /* cmd, param, offset, width, type, arg_name */ 194 #define DPNI_CMD_GET_COUNTER(cmd, counter) \ 195 MC_CMD_OP(cmd, 0, 0, 16, enum dpni_counter, counter) 196 197 /* cmd, param, offset, width, type, arg_name */ 198 #define DPNI_RSP_GET_COUNTER(cmd, value) \ 199 MC_RSP_OP(cmd, 1, 0, 64, uint64_t, value) 200 201 /* cmd, param, offset, width, type, arg_name */ 202 #define DPNI_CMD_SET_COUNTER(cmd, counter, value) \ 203 do { \ 204 MC_CMD_OP(cmd, 0, 0, 16, enum dpni_counter, counter); \ 205 MC_CMD_OP(cmd, 1, 0, 64, uint64_t, value); \ 206 } while (0) 207 208 /* cmd, param, offset, width, type, arg_name */ 209 #define DPNI_CMD_SET_LINK_CFG(cmd, cfg) \ 210 do { \ 211 MC_CMD_OP(cmd, 1, 0, 64, uint64_t, cfg->rate);\ 212 MC_CMD_OP(cmd, 2, 0, 64, uint64_t, cfg->options);\ 213 } while (0) 214 215 /* cmd, param, offset, width, type, arg_name */ 216 #define DPNI_RSP_GET_LINK_STATE(cmd, state) \ 217 do { \ 218 MC_RSP_OP(cmd, 0, 32, 1, int, state->up);\ 219 MC_RSP_OP(cmd, 1, 0, 64, uint64_t, state->rate);\ 220 MC_RSP_OP(cmd, 2, 0, 64, uint64_t, state->options);\ 221 } while (0) 222 223 224 225 /* cmd, param, offset, width, type, arg_name */ 226 #define DPNI_CMD_SET_PRIMARY_MAC_ADDR(cmd, mac_addr) \ 227 do { \ 228 MC_CMD_OP(cmd, 0, 16, 8, uint8_t, mac_addr[5]); \ 229 MC_CMD_OP(cmd, 0, 24, 8, uint8_t, mac_addr[4]); \ 230 MC_CMD_OP(cmd, 0, 32, 8, uint8_t, mac_addr[3]); \ 231 MC_CMD_OP(cmd, 0, 40, 8, uint8_t, mac_addr[2]); \ 232 MC_CMD_OP(cmd, 0, 48, 8, uint8_t, mac_addr[1]); \ 233 MC_CMD_OP(cmd, 0, 56, 8, uint8_t, mac_addr[0]); \ 234 } while (0) 235 236 /* cmd, param, offset, width, type, arg_name */ 237 #define DPNI_RSP_GET_PRIMARY_MAC_ADDR(cmd, mac_addr) \ 238 do { \ 239 MC_RSP_OP(cmd, 0, 16, 8, uint8_t, mac_addr[5]); \ 240 MC_RSP_OP(cmd, 0, 24, 8, uint8_t, mac_addr[4]); \ 241 MC_RSP_OP(cmd, 0, 32, 8, uint8_t, mac_addr[3]); \ 242 MC_RSP_OP(cmd, 0, 40, 8, uint8_t, mac_addr[2]); \ 243 MC_RSP_OP(cmd, 0, 48, 8, uint8_t, mac_addr[1]); \ 244 MC_RSP_OP(cmd, 0, 56, 8, uint8_t, mac_addr[0]); \ 245 } while (0) 246 247 /* cmd, param, offset, width, type, arg_name */ 248 #define DPNI_CMD_ADD_MAC_ADDR(cmd, mac_addr) \ 249 do { \ 250 MC_CMD_OP(cmd, 0, 16, 8, uint8_t, mac_addr[5]); \ 251 MC_CMD_OP(cmd, 0, 24, 8, uint8_t, mac_addr[4]); \ 252 MC_CMD_OP(cmd, 0, 32, 8, uint8_t, mac_addr[3]); \ 253 MC_CMD_OP(cmd, 0, 40, 8, uint8_t, mac_addr[2]); \ 254 MC_CMD_OP(cmd, 0, 48, 8, uint8_t, mac_addr[1]); \ 255 MC_CMD_OP(cmd, 0, 56, 8, uint8_t, mac_addr[0]); \ 256 } while (0) 257 258 /* cmd, param, offset, width, type, arg_name */ 259 #define DPNI_CMD_REMOVE_MAC_ADDR(cmd, mac_addr) \ 260 do { \ 261 MC_CMD_OP(cmd, 0, 16, 8, uint8_t, mac_addr[5]); \ 262 MC_CMD_OP(cmd, 0, 24, 8, uint8_t, mac_addr[4]); \ 263 MC_CMD_OP(cmd, 0, 32, 8, uint8_t, mac_addr[3]); \ 264 MC_CMD_OP(cmd, 0, 40, 8, uint8_t, mac_addr[2]); \ 265 MC_CMD_OP(cmd, 0, 48, 8, uint8_t, mac_addr[1]); \ 266 MC_CMD_OP(cmd, 0, 56, 8, uint8_t, mac_addr[0]); \ 267 } while (0) 268 269 /* cmd, param, offset, width, type, arg_name */ 270 #define DPNI_CMD_SET_TX_FLOW(cmd, flow_id, cfg) \ 271 do { \ 272 MC_CMD_OP(cmd, 0, 0, 32, int, \ 273 cfg->conf_err_cfg.queue_cfg.dest_cfg.dest_id);\ 274 MC_CMD_OP(cmd, 0, 32, 8, uint8_t, \ 275 cfg->conf_err_cfg.queue_cfg.dest_cfg.priority);\ 276 MC_CMD_OP(cmd, 0, 40, 2, enum dpni_dest, \ 277 cfg->conf_err_cfg.queue_cfg.dest_cfg.dest_type);\ 278 MC_CMD_OP(cmd, 0, 42, 1, int, cfg->conf_err_cfg.errors_only);\ 279 MC_CMD_OP(cmd, 0, 43, 1, int, cfg->l3_chksum_gen);\ 280 MC_CMD_OP(cmd, 0, 44, 1, int, cfg->l4_chksum_gen);\ 281 MC_CMD_OP(cmd, 0, 45, 1, int, \ 282 cfg->conf_err_cfg.use_default_queue);\ 283 MC_CMD_OP(cmd, 0, 48, 16, uint16_t, flow_id);\ 284 MC_CMD_OP(cmd, 1, 0, 64, uint64_t, \ 285 cfg->conf_err_cfg.queue_cfg.user_ctx);\ 286 MC_CMD_OP(cmd, 2, 0, 32, uint32_t, cfg->options);\ 287 MC_CMD_OP(cmd, 2, 32, 32, uint32_t, \ 288 cfg->conf_err_cfg.queue_cfg.options);\ 289 } while (0) 290 291 /* cmd, param, offset, width, type, arg_name */ 292 #define DPNI_RSP_SET_TX_FLOW(cmd, flow_id) \ 293 MC_RSP_OP(cmd, 0, 48, 16, uint16_t, flow_id) 294 295 /* cmd, param, offset, width, type, arg_name */ 296 #define DPNI_CMD_GET_TX_FLOW(cmd, flow_id) \ 297 MC_CMD_OP(cmd, 0, 48, 16, uint16_t, flow_id) 298 299 /* cmd, param, offset, width, type, arg_name */ 300 #define DPNI_RSP_GET_TX_FLOW(cmd, attr) \ 301 do { \ 302 MC_RSP_OP(cmd, 0, 0, 32, int, \ 303 attr->conf_err_attr.queue_attr.dest_cfg.dest_id);\ 304 MC_RSP_OP(cmd, 0, 32, 8, uint8_t, \ 305 attr->conf_err_attr.queue_attr.dest_cfg.priority);\ 306 MC_RSP_OP(cmd, 0, 40, 2, enum dpni_dest, \ 307 attr->conf_err_attr.queue_attr.dest_cfg.dest_type);\ 308 MC_RSP_OP(cmd, 0, 42, 1, int, attr->conf_err_attr.errors_only);\ 309 MC_RSP_OP(cmd, 0, 43, 1, int, attr->l3_chksum_gen);\ 310 MC_RSP_OP(cmd, 0, 44, 1, int, attr->l4_chksum_gen);\ 311 MC_RSP_OP(cmd, 0, 45, 1, int, \ 312 attr->conf_err_attr.use_default_queue);\ 313 MC_RSP_OP(cmd, 1, 0, 64, uint64_t, \ 314 attr->conf_err_attr.queue_attr.user_ctx);\ 315 MC_RSP_OP(cmd, 2, 32, 32, uint32_t, \ 316 attr->conf_err_attr.queue_attr.fqid);\ 317 } while (0) 318 319 /* cmd, param, offset, width, type, arg_name */ 320 #define DPNI_CMD_SET_RX_FLOW(cmd, tc_id, flow_id, cfg) \ 321 do { \ 322 MC_CMD_OP(cmd, 0, 0, 32, int, cfg->dest_cfg.dest_id); \ 323 MC_CMD_OP(cmd, 0, 32, 8, uint8_t, cfg->dest_cfg.priority);\ 324 MC_CMD_OP(cmd, 0, 40, 2, enum dpni_dest, cfg->dest_cfg.dest_type);\ 325 MC_CMD_OP(cmd, 0, 48, 16, uint16_t, flow_id); \ 326 MC_CMD_OP(cmd, 1, 0, 64, uint64_t, cfg->user_ctx); \ 327 MC_CMD_OP(cmd, 2, 16, 8, uint8_t, tc_id); \ 328 MC_CMD_OP(cmd, 2, 32, 32, uint32_t, cfg->options); \ 329 } while (0) 330 331 /* cmd, param, offset, width, type, arg_name */ 332 #define DPNI_CMD_GET_RX_FLOW(cmd, tc_id, flow_id) \ 333 do { \ 334 MC_CMD_OP(cmd, 0, 16, 8, uint8_t, tc_id); \ 335 MC_CMD_OP(cmd, 0, 48, 16, uint16_t, flow_id); \ 336 } while (0) 337 338 /* cmd, param, offset, width, type, arg_name */ 339 #define DPNI_RSP_GET_RX_FLOW(cmd, attr) \ 340 do { \ 341 MC_RSP_OP(cmd, 0, 0, 32, int, attr->dest_cfg.dest_id); \ 342 MC_RSP_OP(cmd, 0, 32, 8, uint8_t, attr->dest_cfg.priority);\ 343 MC_RSP_OP(cmd, 0, 40, 2, enum dpni_dest, attr->dest_cfg.dest_type); \ 344 MC_RSP_OP(cmd, 1, 0, 64, uint64_t, attr->user_ctx); \ 345 MC_RSP_OP(cmd, 2, 32, 32, uint32_t, attr->fqid); \ 346 } while (0) 347 348 enum net_prot { 349 NET_PROT_NONE = 0, 350 NET_PROT_PAYLOAD, 351 NET_PROT_ETH, 352 NET_PROT_VLAN, 353 NET_PROT_IPV4, 354 NET_PROT_IPV6, 355 NET_PROT_IP, 356 NET_PROT_TCP, 357 NET_PROT_UDP, 358 NET_PROT_UDP_LITE, 359 NET_PROT_IPHC, 360 NET_PROT_SCTP, 361 NET_PROT_SCTP_CHUNK_DATA, 362 NET_PROT_PPPOE, 363 NET_PROT_PPP, 364 NET_PROT_PPPMUX, 365 NET_PROT_PPPMUX_SUBFRM, 366 NET_PROT_L2TPV2, 367 NET_PROT_L2TPV3_CTRL, 368 NET_PROT_L2TPV3_SESS, 369 NET_PROT_LLC, 370 NET_PROT_LLC_SNAP, 371 NET_PROT_NLPID, 372 NET_PROT_SNAP, 373 NET_PROT_MPLS, 374 NET_PROT_IPSEC_AH, 375 NET_PROT_IPSEC_ESP, 376 NET_PROT_UDP_ENC_ESP, /* RFC 3948 */ 377 NET_PROT_MACSEC, 378 NET_PROT_GRE, 379 NET_PROT_MINENCAP, 380 NET_PROT_DCCP, 381 NET_PROT_ICMP, 382 NET_PROT_IGMP, 383 NET_PROT_ARP, 384 NET_PROT_CAPWAP_DATA, 385 NET_PROT_CAPWAP_CTRL, 386 NET_PROT_RFC2684, 387 NET_PROT_ICMPV6, 388 NET_PROT_FCOE, 389 NET_PROT_FIP, 390 NET_PROT_ISCSI, 391 NET_PROT_GTP, 392 NET_PROT_USER_DEFINED_L2, 393 NET_PROT_USER_DEFINED_L3, 394 NET_PROT_USER_DEFINED_L4, 395 NET_PROT_USER_DEFINED_L5, 396 NET_PROT_USER_DEFINED_SHIM1, 397 NET_PROT_USER_DEFINED_SHIM2, 398 399 NET_PROT_DUMMY_LAST 400 }; 401 402 /* Data Path Network Interface API 403 * Contains initialization APIs and runtime control APIs for DPNI 404 */ 405 406 struct fsl_mc_io; 407 408 /* General DPNI macros */ 409 410 /* Maximum number of traffic classes */ 411 #define DPNI_MAX_TC 8 412 /* Maximum number of buffer pools per DPNI */ 413 #define DPNI_MAX_DPBP 8 414 415 /* All traffic classes considered; see dpni_set_rx_flow() */ 416 #define DPNI_ALL_TCS (uint8_t)(-1) 417 /* All flows within traffic class considered; see dpni_set_rx_flow() */ 418 #define DPNI_ALL_TC_FLOWS (uint16_t)(-1) 419 /* Generate new flow ID; see dpni_set_tx_flow() */ 420 #define DPNI_NEW_FLOW_ID (uint16_t)(-1) 421 422 /** 423 * dpni_open() - Open a control session for the specified object 424 * @mc_io: Pointer to MC portal's I/O object 425 * @dpni_id: DPNI unique ID 426 * @token: Returned token; use in subsequent API calls 427 * 428 * This function can be used to open a control session for an 429 * already created object; an object may have been declared in 430 * the DPL or by calling the dpni_create() function. 431 * This function returns a unique authentication token, 432 * associated with the specific object ID and the specific MC 433 * portal; this token must be used in all subsequent commands for 434 * this specific object. 435 * 436 * Return: '0' on Success; Error code otherwise. 437 */ 438 int dpni_open(struct fsl_mc_io *mc_io, int dpni_id, uint16_t *token); 439 440 /** 441 * dpni_close() - Close the control session of the object 442 * @mc_io: Pointer to MC portal's I/O object 443 * @token: Token of DPNI object 444 * 445 * After this function is called, no further operations are 446 * allowed on the object without opening a new control session. 447 * 448 * Return: '0' on Success; Error code otherwise. 449 */ 450 int dpni_close(struct fsl_mc_io *mc_io, uint16_t token); 451 452 /** 453 * struct dpni_ipr_cfg - Structure representing IP reassembly configuration 454 * @max_reass_frm_size: Maximum size of the reassembled frame 455 * @min_frag_size_ipv4: Minimum fragment size of IPv4 fragments 456 * @min_frag_size_ipv6: Minimum fragment size of IPv6 fragments 457 * @max_open_frames_ipv4: Maximum concurrent IPv4 packets in reassembly process 458 * @max_open_frames_ipv6: Maximum concurrent IPv6 packets in reassembly process 459 */ 460 struct dpni_ipr_cfg { 461 uint16_t max_reass_frm_size; 462 uint16_t min_frag_size_ipv4; 463 uint16_t min_frag_size_ipv6; 464 uint16_t max_open_frames_ipv4; 465 uint16_t max_open_frames_ipv6; 466 }; 467 468 /** 469 * struct dpni_pools_cfg - Structure representing buffer pools configuration 470 * @num_dpbp: Number of DPBPs 471 * @pools: Array of buffer pools parameters; The number of valid entries 472 * must match 'num_dpbp' value 473 */ 474 struct dpni_pools_cfg { 475 uint8_t num_dpbp; 476 /** 477 * struct pools - Buffer pools parameters 478 * @dpbp_id: DPBP object ID 479 * @buffer_size: Buffer size 480 */ 481 struct { 482 int dpbp_id; 483 uint16_t buffer_size; 484 } pools[DPNI_MAX_DPBP]; 485 }; 486 487 /** 488 * dpni_set_pools() - Set buffer pools configuration 489 * @mc_io: Pointer to MC portal's I/O object 490 * @token: Token of DPNI object 491 * @cfg: Buffer pools configuration 492 * 493 * mandatory for DPNI operation 494 * warning:Allowed only when DPNI is disabled 495 * 496 * Return: '0' on Success; Error code otherwise. 497 */ 498 int dpni_set_pools(struct fsl_mc_io *mc_io, 499 uint16_t token, 500 const struct dpni_pools_cfg *cfg); 501 502 /** 503 * dpni_enable() - Enable the DPNI, allow sending and receiving frames. 504 * @mc_io: Pointer to MC portal's I/O object 505 * @token: Token of DPNI object 506 * 507 * Return: '0' on Success; Error code otherwise. 508 */ 509 int dpni_enable(struct fsl_mc_io *mc_io, uint16_t token); 510 511 /** 512 * dpni_disable() - Disable the DPNI, stop sending and receiving frames. 513 * @mc_io: Pointer to MC portal's I/O object 514 * @token: Token of DPNI object 515 * 516 * Return: '0' on Success; Error code otherwise. 517 */ 518 int dpni_disable(struct fsl_mc_io *mc_io, uint16_t token); 519 520 521 /** 522 * @dpni_reset() - Reset the DPNI, returns the object to initial state. 523 * @mc_io: Pointer to MC portal's I/O object 524 * @token: Token of DPNI object 525 * 526 * Return: '0' on Success; Error code otherwise. 527 */ 528 int dpni_reset(struct fsl_mc_io *mc_io, uint16_t token); 529 530 /** 531 * struct dpni_attr - Structure representing DPNI attributes 532 * @id: DPNI object ID 533 * @version: DPNI version 534 * @start_hdr: Indicates the packet starting header for parsing 535 * @options: Mask of available options; reflects the value as was given in 536 * object's creation 537 * @max_senders: Maximum number of different senders; used as the number 538 * of dedicated Tx flows; 539 * @max_tcs: Maximum number of traffic classes (for both Tx and Rx) 540 * @max_dist_per_tc: Maximum distribution size per Rx traffic class; 541 * Set to the required value minus 1 542 * @max_unicast_filters: Maximum number of unicast filters 543 * @max_multicast_filters: Maximum number of multicast filters 544 * @max_vlan_filters: Maximum number of VLAN filters 545 * @max_qos_entries: if 'max_tcs > 1', declares the maximum entries in QoS table 546 * @max_qos_key_size: Maximum key size for the QoS look-up 547 * @max_dist_key_size: Maximum key size for the distribution look-up 548 * @ipr_cfg: IP reassembly configuration 549 */ 550 struct dpni_attr { 551 int id; 552 /** 553 * struct version - DPNI version 554 * @major: DPNI major version 555 * @minor: DPNI minor version 556 */ 557 struct { 558 uint16_t major; 559 uint16_t minor; 560 } version; 561 enum net_prot start_hdr; 562 uint64_t options; 563 uint8_t max_senders; 564 uint8_t max_tcs; 565 uint8_t max_dist_per_tc[DPNI_MAX_TC]; 566 uint8_t max_unicast_filters; 567 uint8_t max_multicast_filters; 568 uint8_t max_vlan_filters; 569 uint8_t max_qos_entries; 570 uint8_t max_qos_key_size; 571 uint8_t max_dist_key_size; 572 struct dpni_ipr_cfg ipr_cfg; 573 }; 574 /** 575 * dpni_get_attributes() - Retrieve DPNI attributes. 576 * @mc_io: Pointer to MC portal's I/O objec 577 * @token: Token of DPNI object 578 * @attr: Returned object's attributes 579 * 580 * Return: '0' on Success; Error code otherwise. 581 */ 582 int dpni_get_attributes(struct fsl_mc_io *mc_io, 583 uint16_t token, 584 struct dpni_attr *attr); 585 586 /* DPNI buffer layout modification options */ 587 588 /* Select to modify the time-stamp setting */ 589 #define DPNI_BUF_LAYOUT_OPT_TIMESTAMP 0x00000001 590 /* Select to modify the parser-result setting; not applicable for Tx */ 591 #define DPNI_BUF_LAYOUT_OPT_PARSER_RESULT 0x00000002 592 /* Select to modify the frame-status setting */ 593 #define DPNI_BUF_LAYOUT_OPT_FRAME_STATUS 0x00000004 594 /* Select to modify the private-data-size setting */ 595 #define DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE 0x00000008 596 /* Select to modify the data-alignment setting */ 597 #define DPNI_BUF_LAYOUT_OPT_DATA_ALIGN 0x00000010 598 /* Select to modify the data-head-room setting */ 599 #define DPNI_BUF_LAYOUT_OPT_DATA_HEAD_ROOM 0x00000020 600 /*!< Select to modify the data-tail-room setting */ 601 #define DPNI_BUF_LAYOUT_OPT_DATA_TAIL_ROOM 0x00000040 602 603 /** 604 * struct dpni_buffer_layout - Structure representing DPNI buffer layout 605 * @options: Flags representing the suggested modifications to the buffer 606 * layout; Use any combination of 'DPNI_BUF_LAYOUT_OPT_<X>' flags 607 * @pass_timestamp: Pass timestamp value 608 * @pass_parser_result: Pass parser results 609 * @pass_frame_status: Pass frame status 610 * @private_data_size: Size kept for private data (in bytes) 611 * @data_align: Data alignment 612 * @data_head_room: Data head room 613 * @data_tail_room: Data tail room 614 */ 615 struct dpni_buffer_layout { 616 uint32_t options; 617 int pass_timestamp; 618 int pass_parser_result; 619 int pass_frame_status; 620 uint16_t private_data_size; 621 uint16_t data_align; 622 uint16_t data_head_room; 623 uint16_t data_tail_room; 624 }; 625 626 /** 627 * dpni_get_rx_buffer_layout() - Retrieve Rx buffer layout attributes. 628 * @mc_io: Pointer to MC portal's I/O object 629 * @token: Token of DPNI object 630 * @layout: Returns buffer layout attributes 631 * 632 * Return: '0' on Success; Error code otherwise. 633 */ 634 int dpni_get_rx_buffer_layout(struct fsl_mc_io *mc_io, 635 uint16_t token, 636 struct dpni_buffer_layout *layout); 637 /** 638 * dpni_set_rx_buffer_layout() - Set Rx buffer layout configuration. 639 * @mc_io: Pointer to MC portal's I/O object 640 * @token: Token of DPNI object 641 * @layout: Buffer layout configuration 642 * 643 * Return: '0' on Success; Error code otherwise. 644 * 645 * @warning Allowed only when DPNI is disabled 646 */ 647 int dpni_set_rx_buffer_layout(struct fsl_mc_io *mc_io, 648 uint16_t token, 649 const struct dpni_buffer_layout *layout); 650 651 /** 652 * dpni_get_tx_buffer_layout() - Retrieve Tx buffer layout attributes. 653 * @mc_io: Pointer to MC portal's I/O object 654 * @token: Token of DPNI object 655 * @layout: Returns buffer layout attributes 656 * 657 * Return: '0' on Success; Error code otherwise. 658 */ 659 int dpni_get_tx_buffer_layout(struct fsl_mc_io *mc_io, 660 uint16_t token, 661 struct dpni_buffer_layout *layout); 662 663 /** 664 * @brief Set Tx buffer layout configuration. 665 * 666 * @param[in] mc_io Pointer to MC portal's I/O object 667 * @param[in] token Token of DPNI object 668 * @param[in] layout Buffer layout configuration 669 * 670 * @returns '0' on Success; Error code otherwise. 671 * 672 * @warning Allowed only when DPNI is disabled 673 */ 674 int dpni_set_tx_buffer_layout(struct fsl_mc_io *mc_io, 675 uint16_t token, 676 const struct dpni_buffer_layout *layout); 677 /** 678 * dpni_get_tx_conf_buffer_layout() - Retrieve Tx confirmation buffer layout 679 * attributes. 680 * @mc_io: Pointer to MC portal's I/O object 681 * @token: Token of DPNI object 682 * @layout: Returns buffer layout attributes 683 * 684 * Return: '0' on Success; Error code otherwise. 685 */ 686 int dpni_get_tx_conf_buffer_layout(struct fsl_mc_io *mc_io, 687 uint16_t token, 688 struct dpni_buffer_layout *layout); 689 /** 690 * dpni_set_tx_conf_buffer_layout() - Set Tx confirmation buffer layout 691 * configuration. 692 * @mc_io: Pointer to MC portal's I/O object 693 * @token: Token of DPNI object 694 * @layout: Buffer layout configuration 695 * 696 * Return: '0' on Success; Error code otherwise. 697 * 698 * @warning Allowed only when DPNI is disabled 699 */ 700 int dpni_set_tx_conf_buffer_layout(struct fsl_mc_io *mc_io, 701 uint16_t token, 702 const struct dpni_buffer_layout *layout); 703 /** 704 * dpni_get_spid() - Get the AIOP storage profile ID associated with the DPNI 705 * @mc_io: Pointer to MC portal's I/O object 706 * @token: Token of DPNI object 707 * @spid: Returned aiop storage-profile ID 708 * 709 * Return: '0' on Success; Error code otherwise. 710 * 711 * @warning Only relevant for DPNI that belongs to AIOP container. 712 */ 713 int dpni_get_qdid(struct fsl_mc_io *mc_io, uint16_t token, uint16_t *qdid); 714 715 /** 716 * dpni_get_tx_data_offset() - Get the Tx data offset (from start of buffer) 717 * @mc_io: Pointer to MC portal's I/O object 718 * @token: Token of DPNI object 719 * @data_offset: Tx data offset (from start of buffer) 720 * 721 * Return: '0' on Success; Error code otherwise. 722 */ 723 int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io, 724 uint16_t token, 725 uint16_t *data_offset); 726 727 /** 728 * enum dpni_counter - DPNI counter types 729 * @DPNI_CNT_ING_FRAME: Counts ingress frames 730 * @DPNI_CNT_ING_BYTE: Counts ingress bytes 731 * @DPNI_CNT_ING_FRAME_DROP: Counts ingress frames dropped due to explicit 732 * 'drop' setting 733 * @DPNI_CNT_ING_FRAME_DISCARD: Counts ingress frames discarded due to errors 734 * @DPNI_CNT_ING_MCAST_FRAME: Counts ingress multicast frames 735 * @DPNI_CNT_ING_MCAST_BYTE: Counts ingress multicast bytes 736 * @DPNI_CNT_ING_BCAST_FRAME: Counts ingress broadcast frames 737 * @DPNI_CNT_ING_BCAST_BYTES: Counts ingress broadcast bytes 738 * @DPNI_CNT_EGR_FRAME: Counts egress frames 739 * @DPNI_CNT_EGR_BYTE: Counts egress bytes 740 * @DPNI_CNT_EGR_FRAME_DISCARD: Counts egress frames discarded due to errors 741 */ 742 enum dpni_counter { 743 DPNI_CNT_ING_FRAME = 0x0, 744 DPNI_CNT_ING_BYTE = 0x1, 745 DPNI_CNT_ING_FRAME_DROP = 0x2, 746 DPNI_CNT_ING_FRAME_DISCARD = 0x3, 747 DPNI_CNT_ING_MCAST_FRAME = 0x4, 748 DPNI_CNT_ING_MCAST_BYTE = 0x5, 749 DPNI_CNT_ING_BCAST_FRAME = 0x6, 750 DPNI_CNT_ING_BCAST_BYTES = 0x7, 751 DPNI_CNT_EGR_FRAME = 0x8, 752 DPNI_CNT_EGR_BYTE = 0x9, 753 DPNI_CNT_EGR_FRAME_DISCARD = 0xa 754 }; 755 756 /** 757 * dpni_get_counter() - Read a specific DPNI counter 758 * @mc_io: Pointer to MC portal's I/O object 759 * @token: Token of DPNI object 760 * @counter: The requested counter 761 * @value: Returned counter's current value 762 * 763 * Return: '0' on Success; Error code otherwise. 764 */ 765 int dpni_get_counter(struct fsl_mc_io *mc_io, 766 uint16_t token, 767 enum dpni_counter counter, 768 uint64_t *value); 769 770 /** 771 * dpni_set_counter() - Set (or clear) a specific DPNI counter 772 * @mc_io: Pointer to MC portal's I/O object 773 * @token: Token of DPNI object 774 * @counter: The requested counter 775 * @value: New counter value; typically pass '0' for resetting 776 * the counter. 777 * 778 * Return: '0' on Success; Error code otherwise. 779 */ 780 int dpni_set_counter(struct fsl_mc_io *mc_io, 781 uint16_t token, 782 enum dpni_counter counter, 783 uint64_t value); 784 /** 785 * struct - Structure representing DPNI link configuration 786 * @rate: Rate 787 * @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values 788 */ 789 struct dpni_link_cfg { 790 uint64_t rate; 791 uint64_t options; 792 }; 793 794 /** 795 * dpni_set_link_cfg() - set the link configuration. 796 * @mc_io: Pointer to MC portal's I/O object 797 * @token: Token of DPNI object 798 * @cfg: Link configuration 799 * 800 * Return: '0' on Success; Error code otherwise. 801 */ 802 int dpni_set_link_cfg(struct fsl_mc_io *mc_io, 803 uint16_t token, 804 struct dpni_link_cfg *cfg); 805 806 /** 807 * struct dpni_link_state - Structure representing DPNI link state 808 * @rate: Rate 809 * @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values 810 * @up: Link state; '0' for down, '1' for up 811 */ 812 struct dpni_link_state { 813 uint64_t rate; 814 uint64_t options; 815 int up; 816 }; 817 818 /** 819 * dpni_get_link_state() - Return the link state (either up or down) 820 * @mc_io: Pointer to MC portal's I/O object 821 * @token: Token of DPNI object 822 * @state: Returned link state; 823 * 824 * Return: '0' on Success; Error code otherwise. 825 */ 826 int dpni_get_link_state(struct fsl_mc_io *mc_io, 827 uint16_t token, 828 struct dpni_link_state *state); 829 830 /** 831 * dpni_set_primary_mac_addr() - Set the primary MAC address 832 * @mc_io: Pointer to MC portal's I/O object 833 * @token: Token of DPNI object 834 * @mac_addr: MAC address to set as primary address 835 * 836 * Return: '0' on Success; Error code otherwise. 837 */ 838 int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io, 839 uint16_t token, 840 const uint8_t mac_addr[6]); 841 /** 842 * dpni_get_primary_mac_addr() - Get the primary MAC address 843 * @mc_io: Pointer to MC portal's I/O object 844 * @token: Token of DPNI object 845 * @mac_addr: Returned MAC address 846 * 847 * Return: '0' on Success; Error code otherwise. 848 */ 849 int dpni_get_primary_mac_addr(struct fsl_mc_io *mc_io, 850 uint16_t token, 851 uint8_t mac_addr[6]); 852 /** 853 * dpni_add_mac_addr() - Add MAC address filter 854 * @mc_io: Pointer to MC portal's I/O object 855 * @token: Token of DPNI object 856 * @mac_addr: MAC address to add 857 * 858 * Return: '0' on Success; Error code otherwise. 859 */ 860 int dpni_add_mac_addr(struct fsl_mc_io *mc_io, 861 uint16_t token, 862 const uint8_t mac_addr[6]); 863 864 /** 865 * dpni_remove_mac_addr() - Remove MAC address filter 866 * @mc_io: Pointer to MC portal's I/O object 867 * @token: Token of DPNI object 868 * @mac_addr: MAC address to remove 869 * 870 * Return: '0' on Success; Error code otherwise. 871 */ 872 int dpni_remove_mac_addr(struct fsl_mc_io *mc_io, 873 uint16_t token, 874 const uint8_t mac_addr[6]); 875 876 /** 877 * enum dpni_dest - DPNI destination types 878 * DPNI_DEST_NONE: Unassigned destination; The queue is set in parked mode and 879 * does not generate FQDAN notifications; user is expected to 880 * dequeue from the queue based on polling or other user-defined 881 * method 882 * @DPNI_DEST_DPIO: The queue is set in schedule mode and generates FQDAN 883 * notifications to the specified DPIO; user is expected to dequeue 884 * from the queue only after notification is received 885 * @DPNI_DEST_DPCON: The queue is set in schedule mode and does not generate 886 * FQDAN notifications, but is connected to the specified DPCON 887 * object; user is expected to dequeue from the DPCON channel 888 */ 889 enum dpni_dest { 890 DPNI_DEST_NONE = 0, 891 DPNI_DEST_DPIO = 1, 892 DPNI_DEST_DPCON = 2 893 }; 894 895 /** 896 * struct dpni_dest_cfg - Structure representing DPNI destination parameters 897 * @dest_type: Destination type 898 * @dest_id: Either DPIO ID or DPCON ID, depending on the destination type 899 * @priority: Priority selection within the DPIO or DPCON channel; valid values 900 * are 0-1 or 0-7, depending on the number of priorities in that 901 * channel; not relevant for 'DPNI_DEST_NONE' option 902 */ 903 struct dpni_dest_cfg { 904 enum dpni_dest dest_type; 905 int dest_id; 906 uint8_t priority; 907 }; 908 909 /* DPNI queue modification options */ 910 911 /* Select to modify the user's context associated with the queue */ 912 #define DPNI_QUEUE_OPT_USER_CTX 0x00000001 913 /* Select to modify the queue's destination */ 914 #define DPNI_QUEUE_OPT_DEST 0x00000002 915 916 /** 917 * struct dpni_queue_cfg - Structure representing queue configuration 918 * @options: Flags representing the suggested modifications to the queue; 919 * Use any combination of 'DPNI_QUEUE_OPT_<X>' flags 920 * @user_ctx: User context value provided in the frame descriptor of each 921 * dequeued frame; valid only if 'DPNI_QUEUE_OPT_USER_CTX' 922 * is contained in 'options' 923 * @dest_cfg: Queue destination parameters; 924 * valid only if 'DPNI_QUEUE_OPT_DEST' is contained in 'options' 925 */ 926 struct dpni_queue_cfg { 927 uint32_t options; 928 uint64_t user_ctx; 929 struct dpni_dest_cfg dest_cfg; 930 }; 931 932 /** 933 * struct dpni_queue_attr - Structure representing queue attributes 934 * @user_ctx: User context value provided in the frame descriptor of each 935 * dequeued frame 936 * @dest_cfg: Queue destination configuration 937 * @fqid: Virtual fqid value to be used for dequeue operations 938 */ 939 struct dpni_queue_attr { 940 uint64_t user_ctx; 941 struct dpni_dest_cfg dest_cfg; 942 uint32_t fqid; 943 }; 944 945 /* DPNI Tx flow modification options */ 946 947 /* Select to modify the settings for dedicate Tx confirmation/error */ 948 #define DPNI_TX_FLOW_OPT_TX_CONF_ERROR 0x00000001 949 /*!< Select to modify the Tx confirmation and/or error setting */ 950 #define DPNI_TX_FLOW_OPT_ONLY_TX_ERROR 0x00000002 951 /*!< Select to modify the queue configuration */ 952 #define DPNI_TX_FLOW_OPT_QUEUE 0x00000004 953 /*!< Select to modify the L3 checksum generation setting */ 954 #define DPNI_TX_FLOW_OPT_L3_CHKSUM_GEN 0x00000010 955 /*!< Select to modify the L4 checksum generation setting */ 956 #define DPNI_TX_FLOW_OPT_L4_CHKSUM_GEN 0x00000020 957 958 /** 959 * struct dpni_tx_flow_cfg - Structure representing Tx flow configuration 960 * @options: Flags representing the suggested modifications to the Tx flow; 961 * Use any combination 'DPNI_TX_FLOW_OPT_<X>' flags 962 * @conf_err_cfg: Tx confirmation and error configuration; these settings are 963 * ignored if 'DPNI_OPT_PRIVATE_TX_CONF_ERROR_DISABLED' was set at 964 * DPNI creation 965 * @l3_chksum_gen: Set to '1' to enable L3 checksum generation; '0' to disable; 966 * valid only if 'DPNI_TX_FLOW_OPT_L3_CHKSUM_GEN' is contained in 967 * 'options' 968 * @l4_chksum_gen: Set to '1' to enable L4 checksum generation; '0' to disable; 969 * valid only if 'DPNI_TX_FLOW_OPT_L4_CHKSUM_GEN' is contained in 970 * 'options' 971 */ 972 struct dpni_tx_flow_cfg { 973 uint32_t options; 974 /** 975 * struct cnf_err_cfg - Tx confirmation and error configuration 976 * @use_default_queue: Set to '1' to use the common (default) Tx 977 * confirmation and error queue; Set to '0' to use the 978 * private Tx confirmation and error queue; valid only if 979 * 'DPNI_TX_FLOW_OPT_TX_CONF_ERROR' is contained in 980 * 'options' 981 * @errors_only: Set to '1' to report back only error frames; 982 * Set to '0' to confirm transmission/error for all 983 * transmitted frames; 984 * valid only if 'DPNI_TX_FLOW_OPT_ONLY_TX_ERROR' is 985 * contained in 'options' and 'use_default_queue = 0'; 986 * @queue_cfg: Queue configuration; valid only if 987 * 'DPNI_TX_FLOW_OPT_QUEUE' is contained in 'options' 988 */ 989 struct { 990 int use_default_queue; 991 int errors_only; 992 struct dpni_queue_cfg queue_cfg; 993 } conf_err_cfg; 994 int l3_chksum_gen; 995 int l4_chksum_gen; 996 }; 997 998 /** 999 * dpni_set_tx_flow() - Set Tx flow configuration 1000 * @mc_io: Pointer to MC portal's I/O object 1001 * @token: Token of DPNI object 1002 * @flow_id: Provides (or returns) the sender's flow ID; 1003 * for each new sender set (*flow_id) to 1004 * 'DPNI_NEW_FLOW_ID' to generate a new flow_id; 1005 * this ID should be used as the QDBIN argument 1006 * in enqueue operations 1007 * @cfg: Tx flow configuration 1008 * 1009 * Return: '0' on Success; Error code otherwise. 1010 */ 1011 int dpni_set_tx_flow(struct fsl_mc_io *mc_io, 1012 uint16_t token, 1013 uint16_t *flow_id, 1014 const struct dpni_tx_flow_cfg *cfg); 1015 1016 /** 1017 * struct dpni_tx_flow_attr - Structure representing Tx flow attributes 1018 * @conf_err_attr: Tx confirmation and error attributes 1019 * @l3_chksum_gen: '1' if L3 checksum generation is enabled; '0' if disabled 1020 * @l4_chksum_gen: '1' if L4 checksum generation is enabled; '0' if disabled 1021 */ 1022 struct dpni_tx_flow_attr { 1023 /** 1024 * struct conf_err_attr - Tx confirmation and error attributes 1025 * @use_default_queue: '1' if using common (default) Tx confirmation and 1026 * error queue; 1027 * '0' if using private Tx confirmation and error 1028 * queue 1029 * @errors_only: '1' if only error frames are reported back; '0' if all 1030 * transmitted frames are confirmed 1031 * @queue_attr: Queue attributes 1032 */ 1033 struct { 1034 int use_default_queue; 1035 int errors_only; 1036 struct dpni_queue_attr queue_attr; 1037 } conf_err_attr; 1038 int l3_chksum_gen; 1039 int l4_chksum_gen; 1040 }; 1041 1042 /** 1043 * dpni_get_tx_flow() - Get Tx flow attributes 1044 * @mc_io: Pointer to MC portal's I/O object 1045 * @token: Token of DPNI object 1046 * @flow_id: The sender's flow ID, as returned by the 1047 * dpni_set_tx_flow() function 1048 * @attr: Returned Tx flow attributes 1049 * 1050 * Return: '0' on Success; Error code otherwise. 1051 */ 1052 int dpni_get_tx_flow(struct fsl_mc_io *mc_io, 1053 uint16_t token, 1054 uint16_t flow_id, 1055 struct dpni_tx_flow_attr *attr); 1056 1057 /** 1058 * dpni_set_rx_flow() - Set Rx flow configuration 1059 * @mc_io: Pointer to MC portal's I/O object 1060 * @token: Token of DPNI object 1061 * @tc_id: Traffic class selection (0-7); 1062 * use 'DPNI_ALL_TCS' to set all TCs and all flows 1063 * @flow_id Rx flow id within the traffic class; use 1064 * 'DPNI_ALL_TC_FLOWS' to set all flows within 1065 * this tc_id; ignored if tc_id is set to 1066 * 'DPNI_ALL_TCS'; 1067 * @cfg: Rx flow configuration 1068 * 1069 * Return: '0' on Success; Error code otherwise. 1070 */ 1071 int dpni_set_rx_flow(struct fsl_mc_io *mc_io, 1072 uint16_t token, 1073 uint8_t tc_id, 1074 uint16_t flow_id, 1075 const struct dpni_queue_cfg *cfg); 1076 1077 /** 1078 * dpni_get_rx_flow() - Get Rx flow attributes 1079 * @mc_io: Pointer to MC portal's I/O object 1080 * @token: Token of DPNI object 1081 * @tc_id: Traffic class selection (0-7) 1082 * @flow_id: Rx flow id within the traffic class 1083 * @attr: Returned Rx flow attributes 1084 * 1085 * Return: '0' on Success; Error code otherwise. 1086 */ 1087 int dpni_get_rx_flow(struct fsl_mc_io *mc_io, 1088 uint16_t token, 1089 uint8_t tc_id, 1090 uint16_t flow_id, 1091 struct dpni_queue_attr *attr); 1092 1093 #endif /* _FSL_DPNI_H */ 1094