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