drivers/net/dpaa2/mc/fsl_dpdmux.h

   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         uint16_t max_dmat_entries;
 188         uint16_t max_mc_groups;
 189         uint16_t max_vlan_ids;
 190 };
 191
 192 int dpdmux_get_attributes(struct fsl_mc_io *mc_io,
 193                           uint32_t cmd_flags,
 194                           uint16_t token,
 195                           struct dpdmux_attr *attr);
 196
 197 int dpdmux_set_max_frame_length(struct fsl_mc_io *mc_io,
 198                                 uint32_t cmd_flags,
 199                                 uint16_t token,
 200                                 uint16_t max_frame_length);
 201
 202 int dpdmux_get_max_frame_length(struct fsl_mc_io *mc_io,
 203                                 uint32_t cmd_flags,
 204                                 uint16_t token,
 205                                 uint16_t if_id,
 206                                 uint16_t *max_frame_length);
 207
 208 /**
 209  * enum dpdmux_counter_type - Counter types
 210  * @DPDMUX_CNT_ING_FRAME: Counts ingress frames
 211  * @DPDMUX_CNT_ING_BYTE: Counts ingress bytes
 212  * @DPDMUX_CNT_ING_FLTR_FRAME: Counts filtered ingress frames
 213  * @DPDMUX_CNT_ING_FRAME_DISCARD: Counts discarded ingress frames
 214  * @DPDMUX_CNT_ING_MCAST_FRAME: Counts ingress multicast frames
 215  * @DPDMUX_CNT_ING_MCAST_BYTE: Counts ingress multicast bytes
 216  * @DPDMUX_CNT_ING_BCAST_FRAME: Counts ingress broadcast frames
 217  * @DPDMUX_CNT_ING_BCAST_BYTES: Counts ingress broadcast bytes
 218  * @DPDMUX_CNT_EGR_FRAME: Counts egress frames
 219  * @DPDMUX_CNT_EGR_BYTE: Counts egress bytes
 220  * @DPDMUX_CNT_EGR_FRAME_DISCARD: Counts discarded egress frames
 221  * @DPDMUX_CNT_ING_NO_BUFFER_DISCARD: Counts ingress no buffer discard frames
 222  */
 223 enum dpdmux_counter_type {
 224         DPDMUX_CNT_ING_FRAME = 0x0,
 225         DPDMUX_CNT_ING_BYTE = 0x1,
 226         DPDMUX_CNT_ING_FLTR_FRAME = 0x2,
 227         DPDMUX_CNT_ING_FRAME_DISCARD = 0x3,
 228         DPDMUX_CNT_ING_MCAST_FRAME = 0x4,
 229         DPDMUX_CNT_ING_MCAST_BYTE = 0x5,
 230         DPDMUX_CNT_ING_BCAST_FRAME = 0x6,
 231         DPDMUX_CNT_ING_BCAST_BYTES = 0x7,
 232         DPDMUX_CNT_EGR_FRAME = 0x8,
 233         DPDMUX_CNT_EGR_BYTE = 0x9,
 234         DPDMUX_CNT_EGR_FRAME_DISCARD = 0xa,
 235         DPDMUX_CNT_ING_NO_BUFFER_DISCARD = 0xb,
 236 };
 237
 238 /**
 239  * enum dpdmux_accepted_frames_type - DPDMUX frame types
 240  * @DPDMUX_ADMIT_ALL: The device accepts VLAN tagged, untagged and
 241  *                      priority-tagged frames
 242  * @DPDMUX_ADMIT_ONLY_VLAN_TAGGED: The device discards untagged frames or
 243  *                              priority-tagged frames that are received on this
 244  *                              interface
 245  * @DPDMUX_ADMIT_ONLY_UNTAGGED: Untagged frames or priority-tagged frames
 246  *                              received on this interface are accepted
 247  */
 248 enum dpdmux_accepted_frames_type {
 249         DPDMUX_ADMIT_ALL = 0,
 250         DPDMUX_ADMIT_ONLY_VLAN_TAGGED = 1,
 251         DPDMUX_ADMIT_ONLY_UNTAGGED = 2
 252 };
 253
 254 /**
 255  * enum dpdmux_action - DPDMUX action for un-accepted frames
 256  * @DPDMUX_ACTION_DROP: Drop un-accepted frames
 257  * @DPDMUX_ACTION_REDIRECT_TO_CTRL: Redirect un-accepted frames to the
 258  *                                      control interface
 259  */
 260 enum dpdmux_action {
 261         DPDMUX_ACTION_DROP = 0,
 262         DPDMUX_ACTION_REDIRECT_TO_CTRL = 1
 263 };
 264
 265 /**
 266  * struct dpdmux_accepted_frames - Frame types configuration
 267  * @type: Defines ingress accepted frames
 268  * @unaccept_act: Defines action on frames not accepted
 269  */
 270 struct dpdmux_accepted_frames {
 271         enum dpdmux_accepted_frames_type type;
 272         enum dpdmux_action unaccept_act;
 273 };
 274
 275 int dpdmux_if_set_accepted_frames(struct fsl_mc_io *mc_io,
 276                                   uint32_t cmd_flags,
 277                                   uint16_t token,
 278                                   uint16_t if_id,
 279                                   const struct dpdmux_accepted_frames *cfg);
 280
 281 /**
 282  * struct dpdmux_if_attr - Structure representing frame types configuration
 283  * @rate: Configured interface rate (in bits per second)
 284  * @enabled: Indicates if interface is enabled
 285  * @accept_frame_type: Indicates type of accepted frames for the interface
 286  */
 287 struct dpdmux_if_attr {
 288         uint32_t rate;
 289         int enabled;
 290         int is_default;
 291         enum dpdmux_accepted_frames_type accept_frame_type;
 292 };
 293
 294 int dpdmux_if_get_attributes(struct fsl_mc_io *mc_io,
 295                              uint32_t cmd_flags,
 296                              uint16_t token,
 297                              uint16_t if_id,
 298                              struct dpdmux_if_attr *attr);
 299
 300 int dpdmux_if_enable(struct fsl_mc_io *mc_io,
 301                      uint32_t cmd_flags,
 302                      uint16_t token,
 303                      uint16_t if_id);
 304
 305 int dpdmux_if_disable(struct fsl_mc_io *mc_io,
 306                       uint32_t cmd_flags,
 307                       uint16_t token,
 308                       uint16_t if_id);
 309
 310 /**
 311  * struct dpdmux_l2_rule - Structure representing L2 rule
 312  * @mac_addr: MAC address
 313  * @vlan_id: VLAN ID
 314  */
 315 struct dpdmux_l2_rule {
 316         uint8_t mac_addr[6];
 317         uint16_t vlan_id;
 318 };
 319
 320 int dpdmux_if_remove_l2_rule(struct fsl_mc_io *mc_io,
 321                              uint32_t cmd_flags,
 322                              uint16_t token,
 323                              uint16_t if_id,
 324                              const struct dpdmux_l2_rule *rule);
 325
 326 int dpdmux_if_add_l2_rule(struct fsl_mc_io *mc_io,
 327                           uint32_t cmd_flags,
 328                           uint16_t token,
 329                           uint16_t if_id,
 330                           const struct dpdmux_l2_rule *rule);
 331
 332 int dpdmux_if_get_counter(struct fsl_mc_io *mc_io,
 333                           uint32_t cmd_flags,
 334                           uint16_t token,
 335                           uint16_t if_id,
 336                           enum dpdmux_counter_type counter_type,
 337                           uint64_t *counter);
 338
 339 int dpdmux_ul_reset_counters(struct fsl_mc_io *mc_io,
 340                              uint32_t cmd_flags,
 341                              uint16_t token);
 342
 343 /**
 344  * Enable auto-negotiation
 345  */
 346 #define DPDMUX_LINK_OPT_AUTONEG         0x0000000000000001ULL
 347 /**
 348  * Enable half-duplex mode
 349  */
 350 #define DPDMUX_LINK_OPT_HALF_DUPLEX     0x0000000000000002ULL
 351 /**
 352  * Enable pause frames
 353  */
 354 #define DPDMUX_LINK_OPT_PAUSE           0x0000000000000004ULL
 355 /**
 356  * Enable a-symmetric pause frames
 357  */
 358 #define DPDMUX_LINK_OPT_ASYM_PAUSE      0x0000000000000008ULL
 359
 360 /**
 361  * struct dpdmux_link_cfg - Structure representing DPDMUX link configuration
 362  * @rate: Rate
 363  * @options: Mask of available options; use 'DPDMUX_LINK_OPT_<X>' values
 364  */
 365 struct dpdmux_link_cfg {
 366         uint32_t rate;
 367         uint64_t options;
 368         uint64_t advertising;
 369 };
 370
 371 int dpdmux_if_set_link_cfg(struct fsl_mc_io *mc_io,
 372                            uint32_t cmd_flags,
 373                            uint16_t token,
 374                            uint16_t if_id,
 375                            struct dpdmux_link_cfg *cfg);
 376 /**
 377  * struct dpdmux_link_state - Structure representing DPDMUX link state
 378  * @rate: Rate
 379  * @options: Mask of available options; use 'DPDMUX_LINK_OPT_<X>' values
 380  * @up: 0 - down, 1 - up
 381  * @state_valid: Ignore/Update the state of the link
 382  * @supported: Speeds capability of the phy (bitmap)
 383  * @advertising: Speeds that are advertised for autoneg (bitmap)
 384  */
 385 struct dpdmux_link_state {
 386         uint32_t rate;
 387         uint64_t options;
 388         int      up;
 389         int      state_valid;
 390         uint64_t supported;
 391         uint64_t advertising;
 392 };
 393
 394 int dpdmux_if_get_link_state(struct fsl_mc_io *mc_io,
 395                              uint32_t cmd_flags,
 396                              uint16_t token,
 397                              uint16_t if_id,
 398                              struct dpdmux_link_state *state);
 399
 400 int dpdmux_if_set_default(struct fsl_mc_io *mc_io,
 401                 uint32_t cmd_flags,
 402                 uint16_t token,
 403                 uint16_t if_id);
 404
 405 int dpdmux_if_get_default(struct fsl_mc_io *mc_io,
 406                 uint32_t cmd_flags,
 407                 uint16_t token,
 408                 uint16_t *if_id);
 409
 410 int dpdmux_set_custom_key(struct fsl_mc_io *mc_io,
 411                         uint32_t cmd_flags,
 412                         uint16_t token,
 413                         uint64_t key_cfg_iova);
 414
 415 /**
 416  * struct dpdmux_rule_cfg - Custom classification rule.
 417  *
 418  * @key_iova: DMA address of buffer storing the look-up value
 419  * @mask_iova: DMA address of the mask used for TCAM classification. This
 420  *  parameter is used only if dpdmux was created using option
 421  *  DPDMUX_OPT_CLS_MASK_SUPPORT.
 422  * @key_size: size, in bytes, of the look-up value. This must match the size
 423  *      of the look-up key defined using dpdmux_set_custom_key, otherwise the
 424  *      entry will never be hit
 425  * @entry_index: rule index into the table. This parameter is used only when
 426  *  dpdmux object was created using option DPDMUX_OPT_CLS_MASK_SUPPORT. In
 427  *  this case the rule is masking and the current frame may be a hit for
 428  *  multiple rules. This parameter determines the order in which the rules
 429  *  will be checked (smaller entry_index first).
 430  */
 431 struct dpdmux_rule_cfg {
 432         uint64_t key_iova;
 433         uint64_t mask_iova;
 434         uint8_t key_size;
 435         uint16_t entry_index;
 436 };
 437
 438 /**
 439  * struct dpdmux_cls_action - Action to execute for frames matching the
 440  *      classification entry
 441  *
 442  * @dest_if: Interface to forward the frames to. Port numbering is similar to
 443  *      the one used to connect interfaces:
 444  *      - 0 is the uplink port,
 445  *      - all others are downlink ports.
 446  */
 447 struct dpdmux_cls_action {
 448         uint16_t dest_if;
 449 };
 450
 451 int dpdmux_add_custom_cls_entry(struct fsl_mc_io *mc_io,
 452                 uint32_t cmd_flags,
 453                 uint16_t token,
 454                 struct dpdmux_rule_cfg *rule,
 455                 struct dpdmux_cls_action *action);
 456
 457 int dpdmux_remove_custom_cls_entry(struct fsl_mc_io *mc_io,
 458                 uint32_t cmd_flags,
 459                 uint16_t token,
 460                 struct dpdmux_rule_cfg *rule);
 461
 462 int dpdmux_get_api_version(struct fsl_mc_io *mc_io,
 463                            uint32_t cmd_flags,
 464                            uint16_t *major_ver,
 465                            uint16_t *minor_ver);
 466
 467 /**
 468  * Discard bit. This bit must be used together with other bits in
 469  * DPDMUX_ERROR_ACTION_CONTINUE to disable discarding of frames containing
 470  * errors
 471  */
 472 #define DPDMUX_ERROR_DISC               0x80000000
 473 /**
 474  * MACSEC is enabled
 475  */
 476 #define DPDMUX_ERROR_MS                 0x40000000
 477 /**
 478  * PTP event frame
 479  */
 480 #define DPDMUX_ERROR_PTP                        0x08000000
 481 /**
 482  * This is a multicast frame
 483  */
 484 #define DPDMUX_ERROR_MC                 0x04000000
 485 /**
 486  * This is a broadcast frame
 487  */
 488 #define DPDMUX_ERROR_BC                 0x02000000
 489 /**
 490  * Invalid Key composition or key size error
 491  */
 492 #define DPDMUX_ERROR_KSE                        0x00040000
 493 /**
 494  * Extract out of frame header
 495  */
 496 #define DPDMUX_ERROR_EOFHE              0x00020000
 497 /**
 498  * Maximum number of chained lookups is reached
 499  */
 500 #define DPDMUX_ERROR_MNLE                       0x00010000
 501 /**
 502  * Invalid table ID
 503  */
 504 #define DPDMUX_ERROR_TIDE                       0x00008000
 505 /**
 506  * Policer initialization entry error
 507  */
 508 #define DPDMUX_ERROR_PIEE                       0x00004000
 509 /**
 510  * Frame length error
 511  */
 512 #define DPDMUX_ERROR_FLE                        0x00002000
 513 /**
 514  * Frame physical error
 515  */
 516 #define DPDMUX_ERROR_FPE                        0x00001000
 517 /**
 518  * Cycle limit is exceeded and frame parsing is forced to terminate early
 519  */
 520 #define DPDMUX_ERROR_PTE                        0x00000080
 521 /**
 522  * Invalid softparse instruction is encountered
 523  */
 524 #define DPDMUX_ERROR_ISP                        0x00000040
 525 /**
 526  * Parsing header error
 527  */
 528 #define DPDMUX_ERROR_PHE                        0x00000020
 529 /*
 530  * Block limit is exceeded. Maximum data that can be read and parsed is 256
 531  * bytes.
 532  * Parser will set this bit if it needs more that this limit to parse.
 533  */
 534 #define DPDMUX_ERROR_BLE                        0x00000010
 535 /**
 536  * L3 checksum validation
 537  */
 538 #define DPDMUX__ERROR_L3CV                      0x00000008
 539 /**
 540  * L3 checksum error
 541  */
 542 #define DPDMUX__ERROR_L3CE                      0x00000004
 543 /**
 544  * L4 checksum validation
 545  */
 546 #define DPDMUX__ERROR_L4CV                      0x00000002
 547 /**
 548  * L4 checksum error
 549  */
 550 #define DPDMUX__ERROR_L4CE                      0x00000001
 551
 552 enum dpdmux_error_action {
 553         DPDMUX_ERROR_ACTION_DISCARD = 0,
 554         DPDMUX_ERROR_ACTION_CONTINUE = 1
 555 };
 556
 557 /**
 558  * Configure how dpdmux interface behaves on errors
 559  * @errors - or'ed combination of DPDMUX_ERROR_*
 560  * @action - set to DPDMUX_ERROR_ACTION_DISCARD or DPDMUX_ERROR_ACTION_CONTINUE
 561  */
 562 struct dpdmux_error_cfg {
 563         uint32_t errors;
 564         enum dpdmux_error_action error_action;
 565 };
 566
 567 int dpdmux_if_set_errors_behavior(struct fsl_mc_io *mc_io, uint32_t cmd_flags,
 568                 uint16_t token, uint16_t if_id, struct dpdmux_error_cfg *cfg);
 569
 570 #endif /* __FSL_DPDMUX_H */