1 /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0) 2 * 3 * Copyright 2013-2016 Freescale Semiconductor Inc. 4 * Copyright 2018-2021 NXP 5 * 6 */ 7 #ifndef __FSL_DPDMUX_H 8 #define __FSL_DPDMUX_H 9 10 #include <fsl_net.h> 11 12 struct fsl_mc_io; 13 14 /** @addtogroup dpdmux Data Path Demux API 15 * Contains API for handling DPDMUX topology and functionality 16 * @{ 17 */ 18 19 int dpdmux_open(struct fsl_mc_io *mc_io, 20 uint32_t cmd_flags, 21 int dpdmux_id, 22 uint16_t *token); 23 24 int dpdmux_close(struct fsl_mc_io *mc_io, 25 uint32_t cmd_flags, 26 uint16_t token); 27 28 /** 29 * DPDMUX general options 30 */ 31 32 /** 33 * Enable bridging between internal interfaces 34 */ 35 #define DPDMUX_OPT_BRIDGE_EN 0x0000000000000002ULL 36 37 /** 38 * Mask support for classification 39 */ 40 #define DPDMUX_OPT_CLS_MASK_SUPPORT 0x0000000000000020ULL 41 42 /** 43 * Automatic max frame length - maximum frame length for dpdmux interface will 44 * be changed automatically by connected dpni objects. 45 */ 46 #define DPDMUX_OPT_AUTO_MAX_FRAME_LEN 0x0000000000000040ULL 47 48 #define DPDMUX_IRQ_INDEX_IF 0x0000 49 #define DPDMUX_IRQ_INDEX 0x0001 50 51 /** 52 * IRQ event - Indicates that the link state changed 53 */ 54 #define DPDMUX_IRQ_EVENT_LINK_CHANGED 0x0001 55 56 /** 57 * enum dpdmux_manip - DPDMUX manipulation operations 58 * @DPDMUX_MANIP_NONE: No manipulation on frames 59 * @DPDMUX_MANIP_ADD_REMOVE_S_VLAN: Add S-VLAN on egress, remove it on ingress 60 */ 61 enum dpdmux_manip { 62 DPDMUX_MANIP_NONE = 0x0, 63 DPDMUX_MANIP_ADD_REMOVE_S_VLAN = 0x1 64 }; 65 66 /** 67 * enum dpdmux_method - DPDMUX method options 68 * @DPDMUX_METHOD_NONE: no DPDMUX method 69 * @DPDMUX_METHOD_C_VLAN_MAC: DPDMUX based on C-VLAN and MAC address 70 * @DPDMUX_METHOD_MAC: DPDMUX based on MAC address 71 * @DPDMUX_METHOD_C_VLAN: DPDMUX based on C-VLAN 72 * @DPDMUX_METHOD_S_VLAN: DPDMUX based on S-VLAN 73 */ 74 enum dpdmux_method { 75 DPDMUX_METHOD_NONE = 0x0, 76 DPDMUX_METHOD_C_VLAN_MAC = 0x1, 77 DPDMUX_METHOD_MAC = 0x2, 78 DPDMUX_METHOD_C_VLAN = 0x3, 79 DPDMUX_METHOD_S_VLAN = 0x4, 80 DPDMUX_METHOD_CUSTOM = 0x5, 81 }; 82 83 /** 84 * struct dpdmux_cfg - DPDMUX configuration parameters 85 * @method: Defines the operation method for the DPDMUX address table 86 * @manip: Required manipulation operation 87 * @num_ifs: Number of interfaces (excluding the uplink interface) 88 * @default_if: Default interface number (different from uplink, 89 maximum value num_ifs) 90 * @adv: Advanced parameters; default is all zeros; 91 * use this structure to change default settings 92 * @adv.options: DPDMUX options - combination of 'DPDMUX_OPT_<X>' flags. 93 * @adv.max_dmat_entries: Maximum entries in DPDMUX address table 94 * 0 - indicates default: 64 entries per interface. 95 * @adv.max_mc_groups: Number of multicast groups in DPDMUX table 96 * 0 - indicates default: 32 multicast groups. 97 * @adv.max_vlan_ids: Maximum vlan ids allowed in the system - 98 * relevant only case of working in mac+vlan method. 99 * 0 - indicates default 16 vlan ids. 100 * @adv.mem_size: Size of the memory used for internal buffers expressed as 101 * number of 256byte buffers. 102 */ 103 struct dpdmux_cfg { 104 enum dpdmux_method method; 105 enum dpdmux_manip manip; 106 uint16_t num_ifs; 107 uint16_t default_if; 108 struct { 109 uint64_t options; 110 uint16_t max_dmat_entries; 111 uint16_t max_mc_groups; 112 uint16_t max_vlan_ids; 113 uint16_t mem_size; 114 } adv; 115 }; 116 117 int dpdmux_create(struct fsl_mc_io *mc_io, 118 uint16_t dprc_token, 119 uint32_t cmd_flags, 120 const struct dpdmux_cfg *cfg, 121 uint32_t *obj_id); 122 123 int dpdmux_destroy(struct fsl_mc_io *mc_io, 124 uint16_t dprc_token, 125 uint32_t cmd_flags, 126 uint32_t object_id); 127 128 int dpdmux_enable(struct fsl_mc_io *mc_io, 129 uint32_t cmd_flags, 130 uint16_t token); 131 132 int dpdmux_disable(struct fsl_mc_io *mc_io, 133 uint32_t cmd_flags, 134 uint16_t token); 135 136 int dpdmux_is_enabled(struct fsl_mc_io *mc_io, 137 uint32_t cmd_flags, 138 uint16_t token, 139 int *en); 140 141 int dpdmux_reset(struct fsl_mc_io *mc_io, 142 uint32_t cmd_flags, 143 uint16_t token); 144 145 /** 146 *Setting 1 DPDMUX_RESET will not reset default interface 147 */ 148 #define DPDMUX_SKIP_DEFAULT_INTERFACE 0x01 149 /** 150 *Setting 1 DPDMUX_RESET will not reset unicast rules 151 */ 152 #define DPDMUX_SKIP_UNICAST_RULES 0x02 153 /** 154 *Setting 1 DPDMUX_RESET will not reset multicast rules 155 */ 156 #define DPDMUX_SKIP_MULTICAST_RULES 0x04 157 158 int dpdmux_set_resetable(struct fsl_mc_io *mc_io, 159 uint32_t cmd_flags, 160 uint16_t token, 161 uint8_t skip_reset_flags); 162 163 int dpdmux_get_resetable(struct fsl_mc_io *mc_io, 164 uint32_t cmd_flags, 165 uint16_t token, 166 uint8_t *skip_reset_flags); 167 168 /** 169 * struct dpdmux_attr - Structure representing DPDMUX attributes 170 * @id: DPDMUX object ID 171 * @options: Configuration options (bitmap) 172 * @method: DPDMUX address table method 173 * @manip: DPDMUX manipulation type 174 * @num_ifs: Number of interfaces (excluding the uplink interface) 175 * @mem_size: DPDMUX frame storage memory size 176 * @default_if: Default interface number (different from uplink, 177 maximum value num_ifs) 178 */ 179 struct dpdmux_attr { 180 int id; 181 uint64_t options; 182 enum dpdmux_method method; 183 enum dpdmux_manip manip; 184 uint16_t num_ifs; 185 uint16_t mem_size; 186 uint16_t default_if; 187 }; 188 189 int dpdmux_get_attributes(struct fsl_mc_io *mc_io, 190 uint32_t cmd_flags, 191 uint16_t token, 192 struct dpdmux_attr *attr); 193 194 int dpdmux_set_max_frame_length(struct fsl_mc_io *mc_io, 195 uint32_t cmd_flags, 196 uint16_t token, 197 uint16_t max_frame_length); 198 199 /** 200 * enum dpdmux_counter_type - Counter types 201 * @DPDMUX_CNT_ING_FRAME: Counts ingress frames 202 * @DPDMUX_CNT_ING_BYTE: Counts ingress bytes 203 * @DPDMUX_CNT_ING_FLTR_FRAME: Counts filtered ingress frames 204 * @DPDMUX_CNT_ING_FRAME_DISCARD: Counts discarded ingress frames 205 * @DPDMUX_CNT_ING_MCAST_FRAME: Counts ingress multicast frames 206 * @DPDMUX_CNT_ING_MCAST_BYTE: Counts ingress multicast bytes 207 * @DPDMUX_CNT_ING_BCAST_FRAME: Counts ingress broadcast frames 208 * @DPDMUX_CNT_ING_BCAST_BYTES: Counts ingress broadcast bytes 209 * @DPDMUX_CNT_EGR_FRAME: Counts egress frames 210 * @DPDMUX_CNT_EGR_BYTE: Counts egress bytes 211 * @DPDMUX_CNT_EGR_FRAME_DISCARD: Counts discarded egress frames 212 * @DPDMUX_CNT_ING_NO_BUFFER_DISCARD: Counts ingress no buffer discard frames 213 */ 214 enum dpdmux_counter_type { 215 DPDMUX_CNT_ING_FRAME = 0x0, 216 DPDMUX_CNT_ING_BYTE = 0x1, 217 DPDMUX_CNT_ING_FLTR_FRAME = 0x2, 218 DPDMUX_CNT_ING_FRAME_DISCARD = 0x3, 219 DPDMUX_CNT_ING_MCAST_FRAME = 0x4, 220 DPDMUX_CNT_ING_MCAST_BYTE = 0x5, 221 DPDMUX_CNT_ING_BCAST_FRAME = 0x6, 222 DPDMUX_CNT_ING_BCAST_BYTES = 0x7, 223 DPDMUX_CNT_EGR_FRAME = 0x8, 224 DPDMUX_CNT_EGR_BYTE = 0x9, 225 DPDMUX_CNT_EGR_FRAME_DISCARD = 0xa, 226 DPDMUX_CNT_ING_NO_BUFFER_DISCARD = 0xb, 227 }; 228 229 /** 230 * enum dpdmux_accepted_frames_type - DPDMUX frame types 231 * @DPDMUX_ADMIT_ALL: The device accepts VLAN tagged, untagged and 232 * priority-tagged frames 233 * @DPDMUX_ADMIT_ONLY_VLAN_TAGGED: The device discards untagged frames or 234 * priority-tagged frames that are received on this 235 * interface 236 * @DPDMUX_ADMIT_ONLY_UNTAGGED: Untagged frames or priority-tagged frames 237 * received on this interface are accepted 238 */ 239 enum dpdmux_accepted_frames_type { 240 DPDMUX_ADMIT_ALL = 0, 241 DPDMUX_ADMIT_ONLY_VLAN_TAGGED = 1, 242 DPDMUX_ADMIT_ONLY_UNTAGGED = 2 243 }; 244 245 /** 246 * enum dpdmux_action - DPDMUX action for un-accepted frames 247 * @DPDMUX_ACTION_DROP: Drop un-accepted frames 248 * @DPDMUX_ACTION_REDIRECT_TO_CTRL: Redirect un-accepted frames to the 249 * control interface 250 */ 251 enum dpdmux_action { 252 DPDMUX_ACTION_DROP = 0, 253 DPDMUX_ACTION_REDIRECT_TO_CTRL = 1 254 }; 255 256 /** 257 * struct dpdmux_accepted_frames - Frame types configuration 258 * @type: Defines ingress accepted frames 259 * @unaccept_act: Defines action on frames not accepted 260 */ 261 struct dpdmux_accepted_frames { 262 enum dpdmux_accepted_frames_type type; 263 enum dpdmux_action unaccept_act; 264 }; 265 266 int dpdmux_if_set_accepted_frames(struct fsl_mc_io *mc_io, 267 uint32_t cmd_flags, 268 uint16_t token, 269 uint16_t if_id, 270 const struct dpdmux_accepted_frames *cfg); 271 272 /** 273 * struct dpdmux_if_attr - Structure representing frame types configuration 274 * @rate: Configured interface rate (in bits per second) 275 * @enabled: Indicates if interface is enabled 276 * @accept_frame_type: Indicates type of accepted frames for the interface 277 */ 278 struct dpdmux_if_attr { 279 uint32_t rate; 280 int enabled; 281 int is_default; 282 enum dpdmux_accepted_frames_type accept_frame_type; 283 }; 284 285 int dpdmux_if_get_attributes(struct fsl_mc_io *mc_io, 286 uint32_t cmd_flags, 287 uint16_t token, 288 uint16_t if_id, 289 struct dpdmux_if_attr *attr); 290 291 int dpdmux_if_enable(struct fsl_mc_io *mc_io, 292 uint32_t cmd_flags, 293 uint16_t token, 294 uint16_t if_id); 295 296 int dpdmux_if_disable(struct fsl_mc_io *mc_io, 297 uint32_t cmd_flags, 298 uint16_t token, 299 uint16_t if_id); 300 301 /** 302 * struct dpdmux_l2_rule - Structure representing L2 rule 303 * @mac_addr: MAC address 304 * @vlan_id: VLAN ID 305 */ 306 struct dpdmux_l2_rule { 307 uint8_t mac_addr[6]; 308 uint16_t vlan_id; 309 }; 310 311 int dpdmux_if_remove_l2_rule(struct fsl_mc_io *mc_io, 312 uint32_t cmd_flags, 313 uint16_t token, 314 uint16_t if_id, 315 const struct dpdmux_l2_rule *rule); 316 317 int dpdmux_if_add_l2_rule(struct fsl_mc_io *mc_io, 318 uint32_t cmd_flags, 319 uint16_t token, 320 uint16_t if_id, 321 const struct dpdmux_l2_rule *rule); 322 323 int dpdmux_if_get_counter(struct fsl_mc_io *mc_io, 324 uint32_t cmd_flags, 325 uint16_t token, 326 uint16_t if_id, 327 enum dpdmux_counter_type counter_type, 328 uint64_t *counter); 329 330 int dpdmux_ul_reset_counters(struct fsl_mc_io *mc_io, 331 uint32_t cmd_flags, 332 uint16_t token); 333 334 /** 335 * Enable auto-negotiation 336 */ 337 #define DPDMUX_LINK_OPT_AUTONEG 0x0000000000000001ULL 338 /** 339 * Enable half-duplex mode 340 */ 341 #define DPDMUX_LINK_OPT_HALF_DUPLEX 0x0000000000000002ULL 342 /** 343 * Enable pause frames 344 */ 345 #define DPDMUX_LINK_OPT_PAUSE 0x0000000000000004ULL 346 /** 347 * Enable a-symmetric pause frames 348 */ 349 #define DPDMUX_LINK_OPT_ASYM_PAUSE 0x0000000000000008ULL 350 351 /** 352 * struct dpdmux_link_cfg - Structure representing DPDMUX link configuration 353 * @rate: Rate 354 * @options: Mask of available options; use 'DPDMUX_LINK_OPT_<X>' values 355 */ 356 struct dpdmux_link_cfg { 357 uint32_t rate; 358 uint64_t options; 359 uint64_t advertising; 360 }; 361 362 int dpdmux_if_set_link_cfg(struct fsl_mc_io *mc_io, 363 uint32_t cmd_flags, 364 uint16_t token, 365 uint16_t if_id, 366 struct dpdmux_link_cfg *cfg); 367 /** 368 * struct dpdmux_link_state - Structure representing DPDMUX link state 369 * @rate: Rate 370 * @options: Mask of available options; use 'DPDMUX_LINK_OPT_<X>' values 371 * @up: 0 - down, 1 - up 372 * @state_valid: Ignore/Update the state of the link 373 * @supported: Speeds capability of the phy (bitmap) 374 * @advertising: Speeds that are advertised for autoneg (bitmap) 375 */ 376 struct dpdmux_link_state { 377 uint32_t rate; 378 uint64_t options; 379 int up; 380 int state_valid; 381 uint64_t supported; 382 uint64_t advertising; 383 }; 384 385 int dpdmux_if_get_link_state(struct fsl_mc_io *mc_io, 386 uint32_t cmd_flags, 387 uint16_t token, 388 uint16_t if_id, 389 struct dpdmux_link_state *state); 390 391 int dpdmux_if_set_default(struct fsl_mc_io *mc_io, 392 uint32_t cmd_flags, 393 uint16_t token, 394 uint16_t if_id); 395 396 int dpdmux_if_get_default(struct fsl_mc_io *mc_io, 397 uint32_t cmd_flags, 398 uint16_t token, 399 uint16_t *if_id); 400 401 int dpdmux_set_custom_key(struct fsl_mc_io *mc_io, 402 uint32_t cmd_flags, 403 uint16_t token, 404 uint64_t key_cfg_iova); 405 406 /** 407 * struct dpdmux_rule_cfg - Custom classification rule. 408 * 409 * @key_iova: DMA address of buffer storing the look-up value 410 * @mask_iova: DMA address of the mask used for TCAM classification. This 411 * parameter is used only if dpdmux was created using option 412 * DPDMUX_OPT_CLS_MASK_SUPPORT. 413 * @key_size: size, in bytes, of the look-up value. This must match the size 414 * of the look-up key defined using dpdmux_set_custom_key, otherwise the 415 * entry will never be hit 416 * @entry_index: rule index into the table. This parameter is used only when 417 * dpdmux object was created using option DPDMUX_OPT_CLS_MASK_SUPPORT. In 418 * this case the rule is masking and the current frame may be a hit for 419 * multiple rules. This parameter determines the order in which the rules 420 * will be checked (smaller entry_index first). 421 */ 422 struct dpdmux_rule_cfg { 423 uint64_t key_iova; 424 uint64_t mask_iova; 425 uint8_t key_size; 426 uint16_t entry_index; 427 }; 428 429 /** 430 * struct dpdmux_cls_action - Action to execute for frames matching the 431 * classification entry 432 * 433 * @dest_if: Interface to forward the frames to. Port numbering is similar to 434 * the one used to connect interfaces: 435 * - 0 is the uplink port, 436 * - all others are downlink ports. 437 */ 438 struct dpdmux_cls_action { 439 uint16_t dest_if; 440 }; 441 442 int dpdmux_add_custom_cls_entry(struct fsl_mc_io *mc_io, 443 uint32_t cmd_flags, 444 uint16_t token, 445 struct dpdmux_rule_cfg *rule, 446 struct dpdmux_cls_action *action); 447 448 int dpdmux_remove_custom_cls_entry(struct fsl_mc_io *mc_io, 449 uint32_t cmd_flags, 450 uint16_t token, 451 struct dpdmux_rule_cfg *rule); 452 453 int dpdmux_get_api_version(struct fsl_mc_io *mc_io, 454 uint32_t cmd_flags, 455 uint16_t *major_ver, 456 uint16_t *minor_ver); 457 458 /** 459 * Discard bit. This bit must be used together with other bits in 460 * DPDMUX_ERROR_ACTION_CONTINUE to disable discarding of frames containing 461 * errors 462 */ 463 #define DPDMUX_ERROR_DISC 0x80000000 464 /** 465 * MACSEC is enabled 466 */ 467 #define DPDMUX_ERROR_MS 0x40000000 468 /** 469 * PTP event frame 470 */ 471 #define DPDMUX_ERROR_PTP 0x08000000 472 /** 473 * This is a multicast frame 474 */ 475 #define DPDMUX_ERROR_MC 0x04000000 476 /** 477 * This is a broadcast frame 478 */ 479 #define DPDMUX_ERROR_BC 0x02000000 480 /** 481 * Invalid Key composition or key size error 482 */ 483 #define DPDMUX_ERROR_KSE 0x00040000 484 /** 485 * Extract out of frame header 486 */ 487 #define DPDMUX_ERROR_EOFHE 0x00020000 488 /** 489 * Maximum number of chained lookups is reached 490 */ 491 #define DPDMUX_ERROR_MNLE 0x00010000 492 /** 493 * Invalid table ID 494 */ 495 #define DPDMUX_ERROR_TIDE 0x00008000 496 /** 497 * Policer initialization entry error 498 */ 499 #define DPDMUX_ERROR_PIEE 0x00004000 500 /** 501 * Frame length error 502 */ 503 #define DPDMUX_ERROR_FLE 0x00002000 504 /** 505 * Frame physical error 506 */ 507 #define DPDMUX_ERROR_FPE 0x00001000 508 /** 509 * Cycle limit is exceeded and frame parsing is forced to terminate early 510 */ 511 #define DPDMUX_ERROR_PTE 0x00000080 512 /** 513 * Invalid softparse instruction is encountered 514 */ 515 #define DPDMUX_ERROR_ISP 0x00000040 516 /** 517 * Parsing header error 518 */ 519 #define DPDMUX_ERROR_PHE 0x00000020 520 /* 521 * Block limit is exceeded. Maximum data that can be read and parsed is 256 522 * bytes. 523 * Parser will set this bit if it needs more that this limit to parse. 524 */ 525 #define DPDMUX_ERROR_BLE 0x00000010 526 /** 527 * L3 checksum validation 528 */ 529 #define DPDMUX__ERROR_L3CV 0x00000008 530 /** 531 * L3 checksum error 532 */ 533 #define DPDMUX__ERROR_L3CE 0x00000004 534 /** 535 * L4 checksum validation 536 */ 537 #define DPDMUX__ERROR_L4CV 0x00000002 538 /** 539 * L4 checksum error 540 */ 541 #define DPDMUX__ERROR_L4CE 0x00000001 542 543 enum dpdmux_error_action { 544 DPDMUX_ERROR_ACTION_DISCARD = 0, 545 DPDMUX_ERROR_ACTION_CONTINUE = 1 546 }; 547 548 /** 549 * Configure how dpdmux interface behaves on errors 550 * @errors - or'ed combination of DPDMUX_ERROR_* 551 * @action - set to DPDMUX_ERROR_ACTION_DISCARD or DPDMUX_ERROR_ACTION_CONTINUE 552 */ 553 struct dpdmux_error_cfg { 554 uint32_t errors; 555 enum dpdmux_error_action error_action; 556 }; 557 558 int dpdmux_if_set_errors_behavior(struct fsl_mc_io *mc_io, uint32_t cmd_flags, 559 uint16_t token, uint16_t if_id, struct dpdmux_error_cfg *cfg); 560 561 #endif /* __FSL_DPDMUX_H */ 562