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