drivers/net/dpaa2/mc/dpdmux.c

   1 /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
   2  *
   3  * Copyright 2013-2016 Freescale Semiconductor Inc.
   4  * Copyright 2018-2019 NXP
   5  *
   6  */
   7 #include <fsl_mc_sys.h>
   8 #include <fsl_mc_cmd.h>
   9 #include <fsl_dpdmux.h>
  10 #include <fsl_dpdmux_cmd.h>
  11
  12 /** @addtogroup dpdmux
  13  * @{
  14  */
  15
  16 /**
  17  * dpdmux_open() - Open a control session for the specified object
  18  * @mc_io:      Pointer to MC portal's I/O object
  19  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  20  * @dpdmux_id:          DPDMUX unique ID
  21  * @token:              Returned token; use in subsequent API calls
  22  *
  23  * This function can be used to open a control session for an
  24  * already created object; an object may have been declared in
  25  * the DPL or by calling the dpdmux_create() function.
  26  * This function returns a unique authentication token,
  27  * associated with the specific object ID and the specific MC
  28  * portal; this token must be used in all subsequent commands for
  29  * this specific object.
  30  *
  31  * Return:      '0' on Success; Error code otherwise.
  32  */
  33 int dpdmux_open(struct fsl_mc_io *mc_io,
  34                 uint32_t cmd_flags,
  35                 int dpdmux_id,
  36                 uint16_t *token)
  37 {
  38         struct mc_command cmd = { 0 };
  39         struct dpdmux_cmd_open *cmd_params;
  40         int err;
  41
  42         /* prepare command */
  43         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_OPEN,
  44                                           cmd_flags,
  45                                           0);
  46         cmd_params = (struct dpdmux_cmd_open *)cmd.params;
  47         cmd_params->dpdmux_id = cpu_to_le32(dpdmux_id);
  48
  49         /* send command to mc*/
  50         err = mc_send_command(mc_io, &cmd);
  51         if (err)
  52                 return err;
  53
  54         /* retrieve response parameters */
  55         *token = mc_cmd_hdr_read_token(&cmd);
  56
  57         return 0;
  58 }
  59
  60 /**
  61  * dpdmux_close() - Close the control session of the object
  62  * @mc_io:      Pointer to MC portal's I/O object
  63  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  64  * @token:              Token of DPDMUX object
  65  *
  66  * After this function is called, no further operations are
  67  * allowed on the object without opening a new control session.
  68  *
  69  * Return:      '0' on Success; Error code otherwise.
  70  */
  71 int dpdmux_close(struct fsl_mc_io *mc_io,
  72                  uint32_t cmd_flags,
  73                  uint16_t token)
  74 {
  75         struct mc_command cmd = { 0 };
  76
  77         /* prepare command */
  78         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_CLOSE,
  79                                           cmd_flags,
  80                                           token);
  81
  82         /* send command to mc*/
  83         return mc_send_command(mc_io, &cmd);
  84 }
  85
  86 /**
  87  * dpdmux_create() - Create the DPDMUX object
  88  * @mc_io:      Pointer to MC portal's I/O object
  89  * @dprc_token: Parent container token; '0' for default container
  90  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  91  * @cfg:        Configuration structure
  92  * @obj_id: returned object id
  93  *
  94  * Create the DPDMUX object, allocate required resources and
  95  * perform required initialization.
  96  *
  97  * The object can be created either by declaring it in the
  98  * DPL file, or by calling this function.
  99  *
 100  * The function accepts an authentication token of a parent
 101  * container that this object should be assigned to. The token
 102  * can be '0' so the object will be assigned to the default container.
 103  * The newly created object can be opened with the returned
 104  * object id and using the container's associated tokens and MC portals.
 105  *
 106  * Return:      '0' on Success; Error code otherwise.
 107  */
 108 int dpdmux_create(struct fsl_mc_io *mc_io,
 109                   uint16_t dprc_token,
 110                   uint32_t cmd_flags,
 111                   const struct dpdmux_cfg       *cfg,
 112                   uint32_t *obj_id)
 113 {
 114         struct mc_command cmd = { 0 };
 115         struct dpdmux_cmd_create *cmd_params;
 116         int err;
 117
 118         /* prepare command */
 119         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_CREATE,
 120                                           cmd_flags,
 121                                           dprc_token);
 122         cmd_params = (struct dpdmux_cmd_create *)cmd.params;
 123         cmd_params->method = cfg->method;
 124         cmd_params->manip = cfg->manip;
 125         cmd_params->num_ifs = cpu_to_le16(cfg->num_ifs);
 126         cmd_params->adv_max_dmat_entries =
 127                         cpu_to_le16(cfg->adv.max_dmat_entries);
 128         cmd_params->adv_max_mc_groups = cpu_to_le16(cfg->adv.max_mc_groups);
 129         cmd_params->adv_max_vlan_ids = cpu_to_le16(cfg->adv.max_vlan_ids);
 130         cmd_params->options = cpu_to_le64(cfg->adv.options);
 131
 132         /* send command to mc*/
 133         err = mc_send_command(mc_io, &cmd);
 134         if (err)
 135                 return err;
 136
 137         /* retrieve response parameters */
 138         *obj_id = mc_cmd_read_object_id(&cmd);
 139
 140         return 0;
 141 }
 142
 143 /**
 144  * dpdmux_destroy() - Destroy the DPDMUX object and release all its resources.
 145  * @mc_io:      Pointer to MC portal's I/O object
 146  * @dprc_token: Parent container token; '0' for default container
 147  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 148  * @object_id:  The object id; it must be a valid id within the container that
 149  * created this object;
 150  *
 151  * The function accepts the authentication token of the parent container that
 152  * created the object (not the one that currently owns the object). The object
 153  * is searched within parent using the provided 'object_id'.
 154  * All tokens to the object must be closed before calling destroy.
 155  *
 156  * Return:      '0' on Success; error code otherwise.
 157  */
 158 int dpdmux_destroy(struct fsl_mc_io *mc_io,
 159                    uint16_t dprc_token,
 160                    uint32_t cmd_flags,
 161                    uint32_t object_id)
 162 {
 163         struct mc_command cmd = { 0 };
 164         struct dpdmux_cmd_destroy *cmd_params;
 165
 166         /* prepare command */
 167         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_DESTROY,
 168                                           cmd_flags,
 169                                           dprc_token);
 170         cmd_params = (struct dpdmux_cmd_destroy *)cmd.params;
 171         cmd_params->dpdmux_id = cpu_to_le32(object_id);
 172
 173         /* send command to mc*/
 174         return mc_send_command(mc_io, &cmd);
 175 }
 176
 177 /**
 178  * dpdmux_enable() - Enable DPDMUX functionality
 179  * @mc_io:      Pointer to MC portal's I/O object
 180  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 181  * @token:      Token of DPDMUX object
 182  *
 183  * Return:      '0' on Success; Error code otherwise.
 184  */
 185 int dpdmux_enable(struct fsl_mc_io *mc_io,
 186                   uint32_t cmd_flags,
 187                   uint16_t token)
 188 {
 189         struct mc_command cmd = { 0 };
 190
 191         /* prepare command */
 192         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_ENABLE,
 193                                           cmd_flags,
 194                                           token);
 195
 196         /* send command to mc*/
 197         return mc_send_command(mc_io, &cmd);
 198 }
 199
 200 /**
 201  * dpdmux_disable() - Disable DPDMUX functionality
 202  * @mc_io:      Pointer to MC portal's I/O object
 203  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 204  * @token:      Token of DPDMUX object
 205  *
 206  * Return:      '0' on Success; Error code otherwise.
 207  */
 208 int dpdmux_disable(struct fsl_mc_io *mc_io,
 209                    uint32_t cmd_flags,
 210                    uint16_t token)
 211 {
 212         struct mc_command cmd = { 0 };
 213
 214         /* prepare command */
 215         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_DISABLE,
 216                                           cmd_flags,
 217                                           token);
 218
 219         /* send command to mc*/
 220         return mc_send_command(mc_io, &cmd);
 221 }
 222
 223 /**
 224  * dpdmux_is_enabled() - Check if the DPDMUX is enabled.
 225  * @mc_io:      Pointer to MC portal's I/O object
 226  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 227  * @token:      Token of DPDMUX object
 228  * @en:         Returns '1' if object is enabled; '0' otherwise
 229  *
 230  * Return:      '0' on Success; Error code otherwise.
 231  */
 232 int dpdmux_is_enabled(struct fsl_mc_io *mc_io,
 233                       uint32_t cmd_flags,
 234                       uint16_t token,
 235                       int *en)
 236 {
 237         struct mc_command cmd = { 0 };
 238         struct dpdmux_rsp_is_enabled *rsp_params;
 239         int err;
 240
 241         /* prepare command */
 242         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IS_ENABLED,
 243                                           cmd_flags,
 244                                           token);
 245
 246         /* send command to mc*/
 247         err = mc_send_command(mc_io, &cmd);
 248         if (err)
 249                 return err;
 250
 251         /* retrieve response parameters */
 252         rsp_params = (struct dpdmux_rsp_is_enabled *)cmd.params;
 253         *en = dpdmux_get_field(rsp_params->en, ENABLE);
 254
 255         return 0;
 256 }
 257
 258 /**
 259  * dpdmux_reset() - Reset the DPDMUX, returns the object to initial state.
 260  * @mc_io:      Pointer to MC portal's I/O object
 261  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 262  * @token:      Token of DPDMUX object
 263  *
 264  * Return:      '0' on Success; Error code otherwise.
 265  */
 266 int dpdmux_reset(struct fsl_mc_io *mc_io,
 267                  uint32_t cmd_flags,
 268                  uint16_t token)
 269 {
 270         struct mc_command cmd = { 0 };
 271
 272         /* prepare command */
 273         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_RESET,
 274                                           cmd_flags,
 275                                           token);
 276
 277         /* send command to mc*/
 278         return mc_send_command(mc_io, &cmd);
 279 }
 280
 281 /**
 282  * dpdmux_get_attributes() - Retrieve DPDMUX attributes
 283  * @mc_io:      Pointer to MC portal's I/O object
 284  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 285  * @token:      Token of DPDMUX object
 286  * @attr:       Returned object's attributes
 287  *
 288  * Return:      '0' on Success; Error code otherwise.
 289  */
 290 int dpdmux_get_attributes(struct fsl_mc_io *mc_io,
 291                           uint32_t cmd_flags,
 292                           uint16_t token,
 293                           struct dpdmux_attr *attr)
 294 {
 295         struct mc_command cmd = { 0 };
 296         struct dpdmux_rsp_get_attr *rsp_params;
 297         int err;
 298
 299         /* prepare command */
 300         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_GET_ATTR,
 301                                           cmd_flags,
 302                                           token);
 303
 304         /* send command to mc*/
 305         err = mc_send_command(mc_io, &cmd);
 306         if (err)
 307                 return err;
 308
 309         /* retrieve response parameters */
 310         rsp_params = (struct dpdmux_rsp_get_attr *)cmd.params;
 311         attr->id = le32_to_cpu(rsp_params->id);
 312         attr->options = le64_to_cpu(rsp_params->options);
 313         attr->method = rsp_params->method;
 314         attr->manip = rsp_params->manip;
 315         attr->num_ifs = le16_to_cpu(rsp_params->num_ifs);
 316         attr->mem_size = le16_to_cpu(rsp_params->mem_size);
 317
 318         return 0;
 319 }
 320
 321 /**
 322  * dpdmux_if_enable() - Enable Interface
 323  * @mc_io:      Pointer to MC portal's I/O object
 324  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 325  * @token:      Token of DPDMUX object
 326  * @if_id:      Interface Identifier
 327  *
 328  * Return:      Completion status. '0' on Success; Error code otherwise.
 329  */
 330 int dpdmux_if_enable(struct fsl_mc_io *mc_io,
 331                      uint32_t cmd_flags,
 332                      uint16_t token,
 333                      uint16_t if_id)
 334 {
 335         struct dpdmux_cmd_if *cmd_params;
 336         struct mc_command cmd = { 0 };
 337
 338         /* prepare command */
 339         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_ENABLE,
 340                                           cmd_flags,
 341                                           token);
 342         cmd_params = (struct dpdmux_cmd_if *)cmd.params;
 343         cmd_params->if_id = cpu_to_le16(if_id);
 344
 345         /* send command to mc*/
 346         return mc_send_command(mc_io, &cmd);
 347 }
 348
 349 /**
 350  * dpdmux_if_disable() - Disable Interface
 351  * @mc_io:      Pointer to MC portal's I/O object
 352  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 353  * @token:      Token of DPDMUX object
 354  * @if_id:      Interface Identifier
 355  *
 356  * Return:      Completion status. '0' on Success; Error code otherwise.
 357  */
 358 int dpdmux_if_disable(struct fsl_mc_io *mc_io,
 359                       uint32_t cmd_flags,
 360                       uint16_t token,
 361                       uint16_t if_id)
 362 {
 363         struct dpdmux_cmd_if *cmd_params;
 364         struct mc_command cmd = { 0 };
 365
 366         /* prepare command */
 367         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_DISABLE,
 368                                           cmd_flags,
 369                                           token);
 370         cmd_params = (struct dpdmux_cmd_if *)cmd.params;
 371         cmd_params->if_id = cpu_to_le16(if_id);
 372
 373         /* send command to mc*/
 374         return mc_send_command(mc_io, &cmd);
 375 }
 376
 377 /**
 378  * dpdmux_set_max_frame_length() - Set the maximum frame length in DPDMUX
 379  * @mc_io:      Pointer to MC portal's I/O object
 380  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 381  * @token:              Token of DPDMUX object
 382  * @max_frame_length:   The required maximum frame length
 383  *
 384  * Update the maximum frame length on all DMUX interfaces.
 385  * In case of VEPA, the maximum frame length on all dmux interfaces
 386  * will be updated with the minimum value of the mfls of the connected
 387  * dpnis and the actual value of dmux mfl.
 388  *
 389  * Return:      '0' on Success; Error code otherwise.
 390  */
 391 int dpdmux_set_max_frame_length(struct fsl_mc_io *mc_io,
 392                                 uint32_t cmd_flags,
 393                                 uint16_t token,
 394                                 uint16_t max_frame_length)
 395 {
 396         struct mc_command cmd = { 0 };
 397         struct dpdmux_cmd_set_max_frame_length *cmd_params;
 398
 399         /* prepare command */
 400         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_SET_MAX_FRAME_LENGTH,
 401                                           cmd_flags,
 402                                           token);
 403         cmd_params = (struct dpdmux_cmd_set_max_frame_length *)cmd.params;
 404         cmd_params->max_frame_length = cpu_to_le16(max_frame_length);
 405
 406         /* send command to mc*/
 407         return mc_send_command(mc_io, &cmd);
 408 }
 409
 410 /**
 411  * dpdmux_ul_reset_counters() - Function resets the uplink counter
 412  * @mc_io:      Pointer to MC portal's I/O object
 413  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 414  * @token:      Token of DPDMUX object
 415  *
 416  * Return:      '0' on Success; Error code otherwise.
 417  */
 418 int dpdmux_ul_reset_counters(struct fsl_mc_io *mc_io,
 419                              uint32_t cmd_flags,
 420                              uint16_t token)
 421 {
 422         struct mc_command cmd = { 0 };
 423
 424         /* prepare command */
 425         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_UL_RESET_COUNTERS,
 426                                           cmd_flags,
 427                                           token);
 428
 429         /* send command to mc*/
 430         return mc_send_command(mc_io, &cmd);
 431 }
 432
 433 /**
 434  * dpdmux_if_set_accepted_frames() - Set the accepted frame types
 435  * @mc_io:      Pointer to MC portal's I/O object
 436  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 437  * @token:      Token of DPDMUX object
 438  * @if_id:      Interface ID (0 for uplink, or 1-num_ifs);
 439  * @cfg:        Frame types configuration
 440  *
 441  * if 'DPDMUX_ADMIT_ONLY_VLAN_TAGGED' is set - untagged frames or
 442  * priority-tagged frames are discarded.
 443  * if 'DPDMUX_ADMIT_ONLY_UNTAGGED' is set - untagged frames or
 444  * priority-tagged frames are accepted.
 445  * if 'DPDMUX_ADMIT_ALL' is set (default mode) - all VLAN tagged,
 446  * untagged and priority-tagged frame are accepted;
 447  *
 448  * Return:      '0' on Success; Error code otherwise.
 449  */
 450 int dpdmux_if_set_accepted_frames(struct fsl_mc_io *mc_io,
 451                                   uint32_t cmd_flags,
 452                                   uint16_t token,
 453                                   uint16_t if_id,
 454                                   const struct dpdmux_accepted_frames *cfg)
 455 {
 456         struct mc_command cmd = { 0 };
 457         struct dpdmux_cmd_if_set_accepted_frames *cmd_params;
 458
 459         /* prepare command */
 460         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_SET_ACCEPTED_FRAMES,
 461                                           cmd_flags,
 462                                           token);
 463         cmd_params = (struct dpdmux_cmd_if_set_accepted_frames *)cmd.params;
 464         cmd_params->if_id = cpu_to_le16(if_id);
 465         dpdmux_set_field(cmd_params->frames_options,
 466                          ACCEPTED_FRAMES_TYPE,
 467                          cfg->type);
 468         dpdmux_set_field(cmd_params->frames_options,
 469                          UNACCEPTED_FRAMES_ACTION,
 470                          cfg->unaccept_act);
 471
 472         /* send command to mc*/
 473         return mc_send_command(mc_io, &cmd);
 474 }
 475
 476 /**
 477  * dpdmux_if_get_attributes() - Obtain DPDMUX interface attributes
 478  * @mc_io:      Pointer to MC portal's I/O object
 479  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 480  * @token:      Token of DPDMUX object
 481  * @if_id:      Interface ID (0 for uplink, or 1-num_ifs);
 482  * @attr:       Interface attributes
 483  *
 484  * Return:      '0' on Success; Error code otherwise.
 485  */
 486 int dpdmux_if_get_attributes(struct fsl_mc_io *mc_io,
 487                              uint32_t cmd_flags,
 488                              uint16_t token,
 489                              uint16_t if_id,
 490                              struct dpdmux_if_attr *attr)
 491 {
 492         struct mc_command cmd = { 0 };
 493         struct dpdmux_cmd_if *cmd_params;
 494         struct dpdmux_rsp_if_get_attr *rsp_params;
 495         int err;
 496
 497         /* prepare command */
 498         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_GET_ATTR,
 499                                           cmd_flags,
 500                                           token);
 501         cmd_params = (struct dpdmux_cmd_if *)cmd.params;
 502         cmd_params->if_id = cpu_to_le16(if_id);
 503
 504         /* send command to mc*/
 505         err = mc_send_command(mc_io, &cmd);
 506         if (err)
 507                 return err;
 508
 509         /* retrieve response parameters */
 510         rsp_params = (struct dpdmux_rsp_if_get_attr *)cmd.params;
 511         attr->rate = le32_to_cpu(rsp_params->rate);
 512         attr->enabled = dpdmux_get_field(rsp_params->enabled, ENABLE);
 513         attr->is_default = dpdmux_get_field(rsp_params->enabled, IS_DEFAULT);
 514         attr->accept_frame_type = dpdmux_get_field(
 515                                   rsp_params->accepted_frames_type,
 516                                   ACCEPTED_FRAMES_TYPE);
 517
 518         return 0;
 519 }
 520
 521 /**
 522  * dpdmux_if_remove_l2_rule() - Remove L2 rule from DPDMUX table
 523  * @mc_io:      Pointer to MC portal's I/O object
 524  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 525  * @token:      Token of DPDMUX object
 526  * @if_id:      Destination interface ID
 527  * @rule:       L2 rule
 528  *
 529  * Function removes a L2 rule from DPDMUX table
 530  * or adds an interface to an existing multicast address
 531  *
 532  * Return:      '0' on Success; Error code otherwise.
 533  */
 534 int dpdmux_if_remove_l2_rule(struct fsl_mc_io *mc_io,
 535                              uint32_t cmd_flags,
 536                              uint16_t token,
 537                              uint16_t if_id,
 538                              const struct dpdmux_l2_rule *rule)
 539 {
 540         struct mc_command cmd = { 0 };
 541         struct dpdmux_cmd_if_l2_rule *cmd_params;
 542
 543         /* prepare command */
 544         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_REMOVE_L2_RULE,
 545                                           cmd_flags,
 546                                           token);
 547         cmd_params = (struct dpdmux_cmd_if_l2_rule *)cmd.params;
 548         cmd_params->if_id = cpu_to_le16(if_id);
 549         cmd_params->vlan_id = cpu_to_le16(rule->vlan_id);
 550         cmd_params->mac_addr5 = rule->mac_addr[5];
 551         cmd_params->mac_addr4 = rule->mac_addr[4];
 552         cmd_params->mac_addr3 = rule->mac_addr[3];
 553         cmd_params->mac_addr2 = rule->mac_addr[2];
 554         cmd_params->mac_addr1 = rule->mac_addr[1];
 555         cmd_params->mac_addr0 = rule->mac_addr[0];
 556
 557         /* send command to mc*/
 558         return mc_send_command(mc_io, &cmd);
 559 }
 560
 561 /**
 562  * dpdmux_if_add_l2_rule() - Add L2 rule into DPDMUX table
 563  * @mc_io:      Pointer to MC portal's I/O object
 564  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 565  * @token:      Token of DPDMUX object
 566  * @if_id:      Destination interface ID
 567  * @rule:       L2 rule
 568  *
 569  * Function adds a L2 rule into DPDMUX table
 570  * or adds an interface to an existing multicast address
 571  *
 572  * Return:      '0' on Success; Error code otherwise.
 573  */
 574 int dpdmux_if_add_l2_rule(struct fsl_mc_io *mc_io,
 575                           uint32_t cmd_flags,
 576                           uint16_t token,
 577                           uint16_t if_id,
 578                           const struct dpdmux_l2_rule *rule)
 579 {
 580         struct mc_command cmd = { 0 };
 581         struct dpdmux_cmd_if_l2_rule *cmd_params;
 582
 583         /* prepare command */
 584         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_ADD_L2_RULE,
 585                                           cmd_flags,
 586                                           token);
 587         cmd_params = (struct dpdmux_cmd_if_l2_rule *)cmd.params;
 588         cmd_params->if_id = cpu_to_le16(if_id);
 589         cmd_params->vlan_id = cpu_to_le16(rule->vlan_id);
 590         cmd_params->mac_addr5 = rule->mac_addr[5];
 591         cmd_params->mac_addr4 = rule->mac_addr[4];
 592         cmd_params->mac_addr3 = rule->mac_addr[3];
 593         cmd_params->mac_addr2 = rule->mac_addr[2];
 594         cmd_params->mac_addr1 = rule->mac_addr[1];
 595         cmd_params->mac_addr0 = rule->mac_addr[0];
 596
 597         /* send command to mc*/
 598         return mc_send_command(mc_io, &cmd);
 599 }
 600
 601 /**
 602  * dpdmux_if_get_counter() - Functions obtains specific counter of an interface
 603  * @mc_io: Pointer to MC portal's I/O object
 604  * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
 605  * @token: Token of DPDMUX object
 606  * @if_id:  Interface Id
 607  * @counter_type: counter type
 608  * @counter: Returned specific counter information
 609  *
 610  * Return:      '0' on Success; Error code otherwise.
 611  */
 612 int dpdmux_if_get_counter(struct fsl_mc_io *mc_io,
 613                           uint32_t cmd_flags,
 614                           uint16_t token,
 615                           uint16_t if_id,
 616                           enum dpdmux_counter_type counter_type,
 617                           uint64_t *counter)
 618 {
 619         struct mc_command cmd = { 0 };
 620         struct dpdmux_cmd_if_get_counter *cmd_params;
 621         struct dpdmux_rsp_if_get_counter *rsp_params;
 622         int err;
 623
 624         /* prepare command */
 625         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_GET_COUNTER,
 626                                           cmd_flags,
 627                                           token);
 628         cmd_params = (struct dpdmux_cmd_if_get_counter *)cmd.params;
 629         cmd_params->if_id = cpu_to_le16(if_id);
 630         cmd_params->counter_type = counter_type;
 631
 632         /* send command to mc*/
 633         err = mc_send_command(mc_io, &cmd);
 634         if (err)
 635                 return err;
 636
 637         /* retrieve response parameters */
 638         rsp_params = (struct dpdmux_rsp_if_get_counter *)cmd.params;
 639         *counter = le64_to_cpu(rsp_params->counter);
 640
 641         return 0;
 642 }
 643
 644 /**
 645  * dpdmux_if_set_link_cfg() - set the link configuration.
 646  * @mc_io:      Pointer to MC portal's I/O object
 647  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 648  * @token: Token of DPSW object
 649  * @if_id: interface id
 650  * @cfg: Link configuration
 651  *
 652  * Return:      '0' on Success; Error code otherwise.
 653  */
 654 int dpdmux_if_set_link_cfg(struct fsl_mc_io *mc_io,
 655                            uint32_t cmd_flags,
 656                            uint16_t token,
 657                            uint16_t if_id,
 658                            struct dpdmux_link_cfg *cfg)
 659 {
 660         struct mc_command cmd = { 0 };
 661         struct dpdmux_cmd_if_set_link_cfg *cmd_params;
 662
 663         /* prepare command */
 664         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_SET_LINK_CFG,
 665                                           cmd_flags,
 666                                           token);
 667         cmd_params = (struct dpdmux_cmd_if_set_link_cfg *)cmd.params;
 668         cmd_params->if_id = cpu_to_le16(if_id);
 669         cmd_params->rate = cpu_to_le32(cfg->rate);
 670         cmd_params->options = cpu_to_le64(cfg->options);
 671         cmd_params->advertising = cpu_to_le64(cfg->advertising);
 672
 673         /* send command to mc*/
 674         return mc_send_command(mc_io, &cmd);
 675 }
 676
 677 /**
 678  * dpdmux_if_get_link_state - Return the link state
 679  * @mc_io:      Pointer to MC portal's I/O object
 680  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 681  * @token: Token of DPSW object
 682  * @if_id: interface id
 683  * @state: link state
 684  *
 685  * @returns     '0' on Success; Error code otherwise.
 686  */
 687 int dpdmux_if_get_link_state(struct fsl_mc_io *mc_io,
 688                              uint32_t cmd_flags,
 689                              uint16_t token,
 690                              uint16_t if_id,
 691                              struct dpdmux_link_state *state)
 692 {
 693         struct mc_command cmd = { 0 };
 694         struct dpdmux_cmd_if_get_link_state *cmd_params;
 695         struct dpdmux_rsp_if_get_link_state *rsp_params;
 696         int err;
 697
 698         /* prepare command */
 699         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_GET_LINK_STATE,
 700                                           cmd_flags,
 701                                           token);
 702         cmd_params = (struct dpdmux_cmd_if_get_link_state *)cmd.params;
 703         cmd_params->if_id = cpu_to_le16(if_id);
 704
 705         /* send command to mc*/
 706         err = mc_send_command(mc_io, &cmd);
 707         if (err)
 708                 return err;
 709
 710         /* retrieve response parameters */
 711         rsp_params = (struct dpdmux_rsp_if_get_link_state *)cmd.params;
 712         state->rate = le32_to_cpu(rsp_params->rate);
 713         state->options = le64_to_cpu(rsp_params->options);
 714         state->up = dpdmux_get_field(rsp_params->up, UP);
 715         state->state_valid = dpdmux_get_field(rsp_params->up, STATE_VALID);
 716         state->supported = le64_to_cpu(rsp_params->supported);
 717         state->advertising = le64_to_cpu(rsp_params->advertising);
 718
 719         return 0;
 720 }
 721
 722 /**
 723  * dpdmux_if_set_default - Set default interface
 724  * @mc_io:      Pointer to MC portal's I/O object
 725  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 726  * @token: Token of DPSW object
 727  * @if_id: interface id
 728  *
 729  * @returns     '0' on Success; Error code otherwise.
 730  */
 731 int dpdmux_if_set_default(struct fsl_mc_io *mc_io,
 732                 uint32_t cmd_flags,
 733                 uint16_t token,
 734                 uint16_t if_id)
 735 {
 736         struct dpdmux_cmd_if *cmd_params;
 737         struct mc_command cmd = { 0 };
 738
 739         /* prepare command */
 740         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_SET_DEFAULT,
 741                                           cmd_flags,
 742                                           token);
 743         cmd_params = (struct dpdmux_cmd_if *)cmd.params;
 744         cmd_params->if_id = cpu_to_le16(if_id);
 745
 746         /* send command to mc*/
 747         return mc_send_command(mc_io, &cmd);
 748 }
 749
 750 /**
 751  * dpdmux_if_get_default - Get default interface
 752  * @mc_io:      Pointer to MC portal's I/O object
 753  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 754  * @token: Token of DPSW object
 755  * @if_id: interface id
 756  *
 757  * @returns     '0' on Success; Error code otherwise.
 758  */
 759 int dpdmux_if_get_default(struct fsl_mc_io *mc_io,
 760                 uint32_t cmd_flags,
 761                 uint16_t token,
 762                 uint16_t *if_id)
 763 {
 764         struct dpdmux_cmd_if *rsp_params;
 765         struct mc_command cmd = { 0 };
 766         int err;
 767
 768         /* prepare command */
 769         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_IF_GET_DEFAULT,
 770                                           cmd_flags,
 771                                           token);
 772
 773         /* send command to mc*/
 774         err = mc_send_command(mc_io, &cmd);
 775         if (err)
 776                 return err;
 777
 778         /* retrieve response parameters */
 779         rsp_params = (struct dpdmux_cmd_if *)cmd.params;
 780         *if_id = le16_to_cpu(rsp_params->if_id);
 781
 782         return 0;
 783 }
 784
 785 /**
 786  * dpdmux_set_custom_key - Set a custom classification key.
 787  *
 788  * This API is only available for DPDMUX instance created with
 789  * DPDMUX_METHOD_CUSTOM.  This API must be called before populating the
 790  * classification table using dpdmux_add_custom_cls_entry.
 791  *
 792  * Calls to dpdmux_set_custom_key remove all existing classification entries
 793  * that may have been added previously using dpdmux_add_custom_cls_entry.
 794  *
 795  * @mc_io:              Pointer to MC portal's I/O object
 796  * @cmd_flags:          Command flags; one or more of 'MC_CMD_FLAG_'
 797  * @token:              Token of DPSW object
 798  * @if_id:              Interface id
 799  * @key_cfg_iova:       DMA address of a configuration structure set up using
 800  *                      dpkg_prepare_key_cfg. Maximum key size is 24 bytes
 801  *
 802  * @returns     '0' on Success; Error code otherwise.
 803  */
 804 int dpdmux_set_custom_key(struct fsl_mc_io *mc_io,
 805                         uint32_t cmd_flags,
 806                         uint16_t token,
 807                         uint64_t key_cfg_iova)
 808 {
 809         struct dpdmux_set_custom_key *cmd_params;
 810         struct mc_command cmd = { 0 };
 811
 812         /* prepare command */
 813         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_SET_CUSTOM_KEY,
 814                                           cmd_flags,
 815                                           token);
 816         cmd_params = (struct dpdmux_set_custom_key *)cmd.params;
 817         cmd_params->key_cfg_iova = cpu_to_le64(key_cfg_iova);
 818
 819         /* send command to mc*/
 820         return mc_send_command(mc_io, &cmd);
 821 }
 822
 823 /**
 824  * dpdmux_add_custom_cls_entry - Adds a custom classification entry.
 825  *
 826  * This API is only available for DPDMUX instances created with
 827  * DPDMUX_METHOD_CUSTOM.  Before calling this function a classification key
 828  * composition rule must be set up using dpdmux_set_custom_key.
 829  *
 830  * @mc_io:      Pointer to MC portal's I/O object
 831  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 832  * @token: Token of DPSW object
 833  * @rule: Classification rule to insert.  Rules cannot be duplicated, if a
 834  *      matching rule already exists, the action will be replaced.
 835  * @action: Action to perform for matching traffic.
 836  *
 837  * @returns     '0' on Success; Error code otherwise.
 838  */
 839 int dpdmux_add_custom_cls_entry(struct fsl_mc_io *mc_io,
 840                 uint32_t cmd_flags,
 841                 uint16_t token,
 842                 struct dpdmux_rule_cfg *rule,
 843                 struct dpdmux_cls_action *action)
 844 {
 845         struct dpdmux_cmd_add_custom_cls_entry *cmd_params;
 846         struct mc_command cmd = { 0 };
 847
 848         /* prepare command */
 849         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_ADD_CUSTOM_CLS_ENTRY,
 850                                           cmd_flags,
 851                                           token);
 852
 853         cmd_params = (struct dpdmux_cmd_add_custom_cls_entry *)cmd.params;
 854         cmd_params->key_size = rule->key_size;
 855         cmd_params->dest_if = cpu_to_le16(action->dest_if);
 856         cmd_params->key_iova = cpu_to_le64(rule->key_iova);
 857         cmd_params->mask_iova = cpu_to_le64(rule->mask_iova);
 858
 859         /* send command to mc*/
 860         return mc_send_command(mc_io, &cmd);
 861 }
 862
 863 /**
 864  * dpdmux_remove_custom_cls_entry - Removes a custom classification entry.
 865  *
 866  * This API is only available for DPDMUX instances created with
 867  * DPDMUX_METHOD_CUSTOM.  The API can be used to remove classification
 868  * entries previously inserted using dpdmux_add_custom_cls_entry.
 869  *
 870  * @mc_io:      Pointer to MC portal's I/O object
 871  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 872  * @token: Token of DPSW object
 873  * @rule: Classification rule to remove
 874  *
 875  * @returns     '0' on Success; Error code otherwise.
 876  */
 877 int dpdmux_remove_custom_cls_entry(struct fsl_mc_io *mc_io,
 878                 uint32_t cmd_flags,
 879                 uint16_t token,
 880                 struct dpdmux_rule_cfg *rule)
 881 {
 882         struct dpdmux_cmd_remove_custom_cls_entry *cmd_params;
 883         struct mc_command cmd = { 0 };
 884
 885         /* prepare command */
 886         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_REMOVE_CUSTOM_CLS_ENTRY,
 887                                           cmd_flags,
 888                                           token);
 889         cmd_params = (struct dpdmux_cmd_remove_custom_cls_entry *)cmd.params;
 890         cmd_params->key_size = rule->key_size;
 891         cmd_params->key_iova = cpu_to_le64(rule->key_iova);
 892         cmd_params->mask_iova = cpu_to_le64(rule->mask_iova);
 893
 894         /* send command to mc*/
 895         return mc_send_command(mc_io, &cmd);
 896 }
 897
 898 /**
 899  * dpdmux_get_api_version() - Get Data Path Demux API version
 900  * @mc_io:  Pointer to MC portal's I/O object
 901  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 902  * @major_ver:  Major version of data path demux API
 903  * @minor_ver:  Minor version of data path demux API
 904  *
 905  * Return:  '0' on Success; Error code otherwise.
 906  */
 907 int dpdmux_get_api_version(struct fsl_mc_io *mc_io,
 908                            uint32_t cmd_flags,
 909                            uint16_t *major_ver,
 910                            uint16_t *minor_ver)
 911 {
 912         struct mc_command cmd = { 0 };
 913         struct dpdmux_rsp_get_api_version *rsp_params;
 914         int err;
 915
 916         cmd.header = mc_encode_cmd_header(DPDMUX_CMDID_GET_API_VERSION,
 917                                         cmd_flags,
 918                                         0);
 919
 920         err = mc_send_command(mc_io, &cmd);
 921         if (err)
 922                 return err;
 923
 924         rsp_params = (struct dpdmux_rsp_get_api_version *)cmd.params;
 925         *major_ver = le16_to_cpu(rsp_params->major);
 926         *minor_ver = le16_to_cpu(rsp_params->minor);
 927
 928         return 0;
 929 }