drivers/crypto/dpaa2_sec/mc/dpseci.c

   1 /*-
   2  * This file is provided under a dual BSD/GPLv2 license. When using or
   3  * redistributing this file, you may do so under either license.
   4  *
   5  *   BSD LICENSE
   6  *
   7  * Copyright 2013-2016 Freescale Semiconductor Inc.
   8  * Copyright 2016 NXP.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions are met:
  12  * * Redistributions of source code must retain the above copyright
  13  * notice, this list of conditions and the following disclaimer.
  14  * * Redistributions in binary form must reproduce the above copyright
  15  * notice, this list of conditions and the following disclaimer in the
  16  * documentation and/or other materials provided with the distribution.
  17  * * Neither the name of the above-listed copyright holders nor the
  18  * names of any contributors may be used to endorse or promote products
  19  * derived from this software without specific prior written permission.
  20  *
  21  *   GPL LICENSE SUMMARY
  22  *
  23  * ALTERNATIVELY, this software may be distributed under the terms of the
  24  * GNU General Public License ("GPL") as published by the Free Software
  25  * Foundation, either version 2 of that License or (at your option) any
  26  * later version.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  29  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  31  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
  32  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  36  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  38  * POSSIBILITY OF SUCH DAMAGE.
  39  */
  40 #include <fsl_mc_sys.h>
  41 #include <fsl_mc_cmd.h>
  42 #include <fsl_dpseci.h>
  43 #include <fsl_dpseci_cmd.h>
  44
  45 /**
  46  * dpseci_open() - Open a control session for the specified object
  47  * @mc_io:      Pointer to MC portal's I/O object
  48  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  49  * @dpseci_id:  DPSECI unique ID
  50  * @token:      Returned token; use in subsequent API calls
  51  *
  52  * This function can be used to open a control session for an
  53  * already created object; an object may have been declared in
  54  * the DPL or by calling the dpseci_create() function.
  55  * This function returns a unique authentication token,
  56  * associated with the specific object ID and the specific MC
  57  * portal; this token must be used in all subsequent commands for
  58  * this specific object.
  59  *
  60  * Return:      '0' on Success; Error code otherwise.
  61  */
  62 int dpseci_open(struct fsl_mc_io *mc_io,
  63                 uint32_t cmd_flags,
  64                 int dpseci_id,
  65                 uint16_t *token)
  66 {
  67         struct dpseci_cmd_open *cmd_params;
  68         struct mc_command cmd = { 0 };
  69         int err;
  70
  71         /* prepare command */
  72         cmd.header = mc_encode_cmd_header(DPSECI_CMDID_OPEN,
  73                                           cmd_flags,
  74                                           0);
  75         cmd_params = (struct dpseci_cmd_open *)cmd.params;
  76         cmd_params->dpseci_id = cpu_to_le32(dpseci_id);
  77
  78         /* send command to mc*/
  79         err = mc_send_command(mc_io, &cmd);
  80         if (err)
  81                 return err;
  82
  83         /* retrieve response parameters */
  84         *token = mc_cmd_hdr_read_token(&cmd);
  85
  86         return 0;
  87 }
  88
  89 /**
  90  * dpseci_close() - Close the control session of the object
  91  * @mc_io:      Pointer to MC portal's I/O object
  92  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  93  * @token:      Token of DPSECI object
  94  *
  95  * After this function is called, no further operations are
  96  * allowed on the object without opening a new control session.
  97  *
  98  * Return:      '0' on Success; Error code otherwise.
  99  */
 100 int dpseci_close(struct fsl_mc_io *mc_io,
 101                  uint32_t cmd_flags,
 102                  uint16_t token)
 103 {
 104         struct mc_command cmd = { 0 };
 105
 106         /* prepare command */
 107         cmd.header = mc_encode_cmd_header(DPSECI_CMDID_CLOSE,
 108                                           cmd_flags,
 109                                           token);
 110
 111         /* send command to mc*/
 112         return mc_send_command(mc_io, &cmd);
 113 }
 114
 115 /**
 116  * dpseci_create() - Create the DPSECI object
 117  * @mc_io:      Pointer to MC portal's I/O object
 118  * @dprc_token: Parent container token; '0' for default container
 119  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 120  * @cfg:        Configuration structure
 121  * @obj_id:     Returned object id
 122  *
 123  * Create the DPSECI object, allocate required resources and
 124  * perform required initialization.
 125  *
 126  * The object can be created either by declaring it in the
 127  * DPL file, or by calling this function.
 128  *
 129  * The function accepts an authentication token of a parent
 130  * container that this object should be assigned to. The token
 131  * can be '0' so the object will be assigned to the default container.
 132  * The newly created object can be opened with the returned
 133  * object id and using the container's associated tokens and MC portals.
 134  *
 135  * Return:      '0' on Success; Error code otherwise.
 136  */
 137 int dpseci_create(struct fsl_mc_io *mc_io,
 138                   uint16_t dprc_token,
 139                   uint32_t cmd_flags,
 140                   const struct dpseci_cfg *cfg,
 141                   uint32_t *obj_id)
 142 {
 143         struct dpseci_cmd_create *cmd_params;
 144         struct mc_command cmd = { 0 };
 145         int err, i;
 146
 147         /* prepare command */
 148         cmd.header = mc_encode_cmd_header(DPSECI_CMDID_CREATE,
 149                                           cmd_flags,
 150                                           dprc_token);
 151         cmd_params = (struct dpseci_cmd_create *)cmd.params;
 152         for (i = 0; i < DPSECI_PRIO_NUM; i++)
 153                 cmd_params->priorities[i] = cfg->priorities[i];
 154         cmd_params->num_tx_queues = cfg->num_tx_queues;
 155         cmd_params->num_rx_queues = cfg->num_rx_queues;
 156         cmd_params->options = cfg->options;
 157
 158         /* send command to mc*/
 159         err = mc_send_command(mc_io, &cmd);
 160         if (err)
 161                 return err;
 162
 163         /* retrieve response parameters */
 164         *obj_id = mc_cmd_read_object_id(&cmd);
 165
 166         return 0;
 167 }
 168
 169 /**
 170  * dpseci_destroy() - Destroy the DPSECI object and release all its resources.
 171  * @mc_io:      Pointer to MC portal's I/O object
 172  * @dprc_token: Parent container token; '0' for default container
 173  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 174  * @object_id:  The object id; it must be a valid id within the container that
 175  * created this object;
 176  *
 177  * The function accepts the authentication token of the parent container that
 178  * created the object (not the one that currently owns the object). The object
 179  * is searched within parent using the provided 'object_id'.
 180  * All tokens to the object must be closed before calling destroy.
 181  *
 182  * Return:      '0' on Success; error code otherwise.
 183  */
 184 int dpseci_destroy(struct fsl_mc_io *mc_io,
 185                    uint16_t dprc_token,
 186                    uint32_t cmd_flags,
 187                    uint32_t object_id)
 188 {
 189         struct dpseci_cmd_destroy *cmd_params;
 190         struct mc_command cmd = { 0 };
 191
 192         /* prepare command */
 193         cmd.header = mc_encode_cmd_header(DPSECI_CMDID_DESTROY,
 194                                           cmd_flags,
 195                                           dprc_token);
 196         cmd_params = (struct dpseci_cmd_destroy *)cmd.params;
 197         cmd_params->dpseci_id = cpu_to_le32(object_id);
 198
 199         /* send command to mc*/
 200         return mc_send_command(mc_io, &cmd);
 201 }
 202
 203 /**
 204  * dpseci_enable() - Enable the DPSECI, allow sending and receiving frames.
 205  * @mc_io:      Pointer to MC portal's I/O object
 206  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 207  * @token:      Token of DPSECI object
 208  *
 209  * Return:      '0' on Success; Error code otherwise.
 210  */
 211 int dpseci_enable(struct fsl_mc_io *mc_io,
 212                   uint32_t cmd_flags,
 213                   uint16_t token)
 214 {
 215         struct mc_command cmd = { 0 };
 216
 217         /* prepare command */
 218         cmd.header = mc_encode_cmd_header(DPSECI_CMDID_ENABLE,
 219                                           cmd_flags,
 220                                           token);
 221
 222         /* send command to mc*/
 223         return mc_send_command(mc_io, &cmd);
 224 }
 225
 226 /**
 227  * dpseci_disable() - Disable the DPSECI, stop sending and receiving frames.
 228  * @mc_io:      Pointer to MC portal's I/O object
 229  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 230  * @token:      Token of DPSECI object
 231  *
 232  * Return:      '0' on Success; Error code otherwise.
 233  */
 234 int dpseci_disable(struct fsl_mc_io *mc_io,
 235                    uint32_t cmd_flags,
 236                    uint16_t token)
 237 {
 238         struct mc_command cmd = { 0 };
 239
 240         /* prepare command */
 241         cmd.header = mc_encode_cmd_header(DPSECI_CMDID_DISABLE,
 242                                           cmd_flags,
 243                                           token);
 244
 245         /* send command to mc*/
 246         return mc_send_command(mc_io, &cmd);
 247 }
 248
 249 /**
 250  * dpseci_is_enabled() - Check if the DPSECI is enabled.
 251  * @mc_io:      Pointer to MC portal's I/O object
 252  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 253  * @token:      Token of DPSECI object
 254  * @en:         Returns '1' if object is enabled; '0' otherwise
 255  *
 256  * Return:      '0' on Success; Error code otherwise.
 257  */
 258 int dpseci_is_enabled(struct fsl_mc_io *mc_io,
 259                       uint32_t cmd_flags,
 260                       uint16_t token,
 261                       int *en)
 262 {
 263         struct dpseci_rsp_is_enabled *rsp_params;
 264         struct mc_command cmd = { 0 };
 265         int err;
 266
 267         /* prepare command */
 268         cmd.header = mc_encode_cmd_header(DPSECI_CMDID_IS_ENABLED,
 269                                           cmd_flags,
 270                                           token);
 271
 272         /* send command to mc*/
 273         err = mc_send_command(mc_io, &cmd);
 274         if (err)
 275                 return err;
 276
 277         /* retrieve response parameters */
 278         rsp_params = (struct dpseci_rsp_is_enabled *)cmd.params;
 279         *en = dpseci_get_field(rsp_params->en, ENABLE);
 280
 281         return 0;
 282 }
 283
 284 /**
 285  * dpseci_reset() - Reset the DPSECI, returns the object to initial state.
 286  * @mc_io:      Pointer to MC portal's I/O object
 287  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 288  * @token:      Token of DPSECI object
 289  *
 290  * Return:      '0' on Success; Error code otherwise.
 291  */
 292 int dpseci_reset(struct fsl_mc_io *mc_io,
 293                  uint32_t cmd_flags,
 294                  uint16_t token)
 295 {
 296         struct mc_command cmd = { 0 };
 297
 298         /* prepare command */
 299         cmd.header = mc_encode_cmd_header(DPSECI_CMDID_RESET,
 300                                           cmd_flags,
 301                                           token);
 302
 303         /* send command to mc*/
 304         return mc_send_command(mc_io, &cmd);
 305 }
 306
 307 /**
 308  * dpseci_get_attributes() - Retrieve DPSECI attributes.
 309  * @mc_io:      Pointer to MC portal's I/O object
 310  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 311  * @token:      Token of DPSECI object
 312  * @attr:       Returned object's attributes
 313  *
 314  * Return:      '0' on Success; Error code otherwise.
 315  */
 316 int dpseci_get_attributes(struct fsl_mc_io *mc_io,
 317                           uint32_t cmd_flags,
 318                           uint16_t token,
 319                           struct dpseci_attr *attr)
 320 {
 321         struct dpseci_rsp_get_attr *rsp_params;
 322         struct mc_command cmd = { 0 };
 323         int err;
 324
 325         /* prepare command */
 326         cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_ATTR,
 327                                           cmd_flags,
 328                                           token);
 329
 330         /* send command to mc*/
 331         err = mc_send_command(mc_io, &cmd);
 332         if (err)
 333                 return err;
 334
 335         /* retrieve response parameters */
 336         rsp_params = (struct dpseci_rsp_get_attr *)cmd.params;
 337         attr->id = le32_to_cpu(rsp_params->id);
 338         attr->options = rsp_params->options;
 339         attr->num_tx_queues = rsp_params->num_tx_queues;
 340         attr->num_rx_queues = rsp_params->num_rx_queues;
 341
 342         return 0;
 343 }
 344
 345 /**
 346  * dpseci_set_rx_queue() - Set Rx queue configuration
 347  * @mc_io:      Pointer to MC portal's I/O object
 348  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 349  * @token:      Token of DPSECI object
 350  * @queue:      Select the queue relative to number of
 351  *              priorities configured at DPSECI creation; use
 352  *              DPSECI_ALL_QUEUES to configure all Rx queues identically.
 353  * @cfg:        Rx queue configuration
 354  *
 355  * Return:      '0' on Success; Error code otherwise.
 356  */
 357 int dpseci_set_rx_queue(struct fsl_mc_io *mc_io,
 358                         uint32_t cmd_flags,
 359                         uint16_t token,
 360                         uint8_t queue,
 361                         const struct dpseci_rx_queue_cfg *cfg)
 362 {
 363         struct dpseci_cmd_set_rx_queue *cmd_params;
 364         struct mc_command cmd = { 0 };
 365
 366         /* prepare command */
 367         cmd.header = mc_encode_cmd_header(DPSECI_CMDID_SET_RX_QUEUE,
 368                                           cmd_flags,
 369                                           token);
 370         cmd_params = (struct dpseci_cmd_set_rx_queue *)cmd.params;
 371         cmd_params->dest_id = cpu_to_le32(cfg->dest_cfg.dest_id);
 372         cmd_params->dest_priority = cfg->dest_cfg.priority;
 373         cmd_params->queue = queue;
 374         cmd_params->user_ctx = cpu_to_le64(cfg->user_ctx);
 375         cmd_params->options = cpu_to_le32(cfg->options);
 376         dpseci_set_field(cmd_params->dest_type,
 377                          DEST_TYPE,
 378                          cfg->dest_cfg.dest_type);
 379         dpseci_set_field(cmd_params->order_preservation_en,
 380                          ORDER_PRESERVATION,
 381                          cfg->order_preservation_en);
 382
 383         /* send command to mc*/
 384         return mc_send_command(mc_io, &cmd);
 385 }
 386
 387 /**
 388  * dpseci_get_rx_queue() - Retrieve Rx queue attributes.
 389  * @mc_io:      Pointer to MC portal's I/O object
 390  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 391  * @token:      Token of DPSECI object
 392  * @queue:      Select the queue relative to number of
 393  *                              priorities configured at DPSECI creation
 394  * @attr:       Returned Rx queue attributes
 395  *
 396  * Return:      '0' on Success; Error code otherwise.
 397  */
 398 int dpseci_get_rx_queue(struct fsl_mc_io *mc_io,
 399                         uint32_t cmd_flags,
 400                         uint16_t token,
 401                         uint8_t queue,
 402                         struct dpseci_rx_queue_attr *attr)
 403 {
 404         struct dpseci_rsp_get_rx_queue *rsp_params;
 405         struct dpseci_cmd_get_queue *cmd_params;
 406         struct mc_command cmd = { 0 };
 407         int err;
 408
 409         /* prepare command */
 410         cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_RX_QUEUE,
 411                                           cmd_flags,
 412                                           token);
 413         cmd_params = (struct dpseci_cmd_get_queue *)cmd.params;
 414         cmd_params->queue = queue;
 415
 416         /* send command to mc*/
 417         err = mc_send_command(mc_io, &cmd);
 418         if (err)
 419                 return err;
 420
 421         /* retrieve response parameters */
 422         rsp_params = (struct dpseci_rsp_get_rx_queue *)cmd.params;
 423         attr->user_ctx = le64_to_cpu(rsp_params->user_ctx);
 424         attr->fqid = le32_to_cpu(rsp_params->fqid);
 425         attr->dest_cfg.dest_id = le32_to_cpu(rsp_params->dest_id);
 426         attr->dest_cfg.priority = rsp_params->dest_priority;
 427         attr->dest_cfg.dest_type =
 428                 dpseci_get_field(rsp_params->dest_type,
 429                                  DEST_TYPE);
 430         attr->order_preservation_en =
 431                 dpseci_get_field(rsp_params->order_preservation_en,
 432                                  ORDER_PRESERVATION);
 433
 434         return 0;
 435 }
 436
 437 /**
 438  * dpseci_get_tx_queue() - Retrieve Tx queue attributes.
 439  * @mc_io:      Pointer to MC portal's I/O object
 440  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 441  * @token:      Token of DPSECI object
 442  * @queue:      Select the queue relative to number of
 443  *              priorities configured at DPSECI creation
 444  * @attr:       Returned Tx queue attributes
 445  *
 446  * Return:      '0' on Success; Error code otherwise.
 447  */
 448 int dpseci_get_tx_queue(struct fsl_mc_io *mc_io,
 449                         uint32_t cmd_flags,
 450                         uint16_t token,
 451                         uint8_t queue,
 452                         struct dpseci_tx_queue_attr *attr)
 453 {
 454         struct dpseci_rsp_get_tx_queue *rsp_params;
 455         struct dpseci_cmd_get_queue *cmd_params;
 456         struct mc_command cmd = { 0 };
 457         int err;
 458
 459         /* prepare command */
 460         cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_TX_QUEUE,
 461                                           cmd_flags,
 462                                           token);
 463         cmd_params = (struct dpseci_cmd_get_queue *)cmd.params;
 464         cmd_params->queue = queue;
 465
 466         /* send command to mc*/
 467         err = mc_send_command(mc_io, &cmd);
 468         if (err)
 469                 return err;
 470
 471         /* retrieve response parameters */
 472         rsp_params = (struct dpseci_rsp_get_tx_queue *)cmd.params;
 473         attr->fqid = le32_to_cpu(rsp_params->fqid);
 474         attr->priority = rsp_params->priority;
 475
 476         return 0;
 477 }
 478
 479 /**
 480  * dpseci_get_sec_attr() - Retrieve SEC accelerator attributes.
 481  * @mc_io:      Pointer to MC portal's I/O object
 482  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 483  * @token:      Token of DPSECI object
 484  * @attr:       Returned SEC attributes
 485  *
 486  * Return:      '0' on Success; Error code otherwise.
 487  */
 488 int dpseci_get_sec_attr(struct fsl_mc_io *mc_io,
 489                         uint32_t cmd_flags,
 490                         uint16_t token,
 491                         struct dpseci_sec_attr *attr)
 492 {
 493         struct dpseci_rsp_get_sec_attr *rsp_params;
 494         struct mc_command cmd = { 0 };
 495         int err;
 496
 497         /* prepare command */
 498         cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_SEC_ATTR,
 499                                           cmd_flags,
 500                                           token);
 501
 502         /* send command to mc*/
 503         err = mc_send_command(mc_io, &cmd);
 504         if (err)
 505                 return err;
 506
 507         /* retrieve response parameters */
 508         rsp_params = (struct dpseci_rsp_get_sec_attr *)cmd.params;
 509         attr->ip_id = le16_to_cpu(rsp_params->ip_id);
 510         attr->major_rev = rsp_params->major_rev;
 511         attr->minor_rev = rsp_params->minor_rev;
 512         attr->era = rsp_params->era;
 513         attr->deco_num = rsp_params->deco_num;
 514         attr->zuc_auth_acc_num = rsp_params->zuc_auth_acc_num;
 515         attr->zuc_enc_acc_num = rsp_params->zuc_enc_acc_num;
 516         attr->snow_f8_acc_num = rsp_params->snow_f8_acc_num;
 517         attr->snow_f9_acc_num = rsp_params->snow_f9_acc_num;
 518         attr->crc_acc_num = rsp_params->crc_acc_num;
 519         attr->pk_acc_num = rsp_params->pk_acc_num;
 520         attr->kasumi_acc_num = rsp_params->kasumi_acc_num;
 521         attr->rng_acc_num = rsp_params->rng_acc_num;
 522         attr->md_acc_num = rsp_params->md_acc_num;
 523         attr->arc4_acc_num = rsp_params->arc4_acc_num;
 524         attr->des_acc_num = rsp_params->des_acc_num;
 525         attr->aes_acc_num = rsp_params->aes_acc_num;
 526
 527         return 0;
 528 }
 529
 530 /**
 531  * dpseci_get_sec_counters() - Retrieve SEC accelerator counters.
 532  * @mc_io:      Pointer to MC portal's I/O object
 533  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 534  * @token:      Token of DPSECI object
 535  * @counters:   Returned SEC counters
 536  *
 537  * Return:      '0' on Success; Error code otherwise.
 538  */
 539 int dpseci_get_sec_counters(struct fsl_mc_io *mc_io,
 540                             uint32_t cmd_flags,
 541                             uint16_t token,
 542                             struct dpseci_sec_counters *counters)
 543 {
 544         struct dpseci_rsp_get_sec_counters *rsp_params;
 545         struct mc_command cmd = { 0 };
 546         int err;
 547
 548         /* prepare command */
 549         cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_SEC_COUNTERS,
 550                                           cmd_flags,
 551                                           token);
 552
 553         /* send command to mc*/
 554         err = mc_send_command(mc_io, &cmd);
 555         if (err)
 556                 return err;
 557
 558         /* retrieve response parameters */
 559         rsp_params = (struct dpseci_rsp_get_sec_counters *)cmd.params;
 560         counters->dequeued_requests =
 561                                 le64_to_cpu(rsp_params->dequeued_requests);
 562         counters->ob_enc_requests = le64_to_cpu(rsp_params->ob_enc_requests);
 563         counters->ib_dec_requests = le64_to_cpu(rsp_params->ib_dec_requests);
 564         counters->ob_enc_bytes = le64_to_cpu(rsp_params->ob_enc_bytes);
 565         counters->ob_prot_bytes = le64_to_cpu(rsp_params->ob_prot_bytes);
 566         counters->ib_dec_bytes = le64_to_cpu(rsp_params->ib_dec_bytes);
 567         counters->ib_valid_bytes = le64_to_cpu(rsp_params->ib_valid_bytes);
 568
 569         return 0;
 570 }
 571
 572 /**
 573  * dpseci_get_api_version() - Get Data Path SEC Interface API version
 574  * @mc_io:  Pointer to MC portal's I/O object
 575  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 576  * @major_ver:  Major version of data path sec API
 577  * @minor_ver:  Minor version of data path sec API
 578  *
 579  * Return:  '0' on Success; Error code otherwise.
 580  */
 581 int dpseci_get_api_version(struct fsl_mc_io *mc_io,
 582                            uint32_t cmd_flags,
 583                            uint16_t *major_ver,
 584                            uint16_t *minor_ver)
 585 {
 586         struct dpseci_rsp_get_api_version *rsp_params;
 587         struct mc_command cmd = { 0 };
 588         int err;
 589
 590         cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_API_VERSION,
 591                                         cmd_flags,
 592                                         0);
 593
 594         err = mc_send_command(mc_io, &cmd);
 595         if (err)
 596                 return err;
 597
 598         rsp_params = (struct dpseci_rsp_get_api_version *)cmd.params;
 599         *major_ver = le16_to_cpu(rsp_params->major);
 600         *minor_ver = le16_to_cpu(rsp_params->minor);
 601
 602         return 0;
 603 }
 604
 605 int dpseci_set_congestion_notification(
 606                         struct fsl_mc_io *mc_io,
 607                         uint32_t cmd_flags,
 608                         uint16_t token,
 609                         const struct dpseci_congestion_notification_cfg *cfg)
 610 {
 611         struct dpseci_cmd_set_congestion_notification *cmd_params;
 612         struct mc_command cmd = { 0 };
 613
 614         /* prepare command */
 615         cmd.header = mc_encode_cmd_header(
 616                         DPSECI_CMDID_SET_CONGESTION_NOTIFICATION,
 617                         cmd_flags,
 618                         token);
 619
 620         cmd_params =
 621                 (struct dpseci_cmd_set_congestion_notification *)cmd.params;
 622         cmd_params->dest_id = cfg->dest_cfg.dest_id;
 623         cmd_params->dest_priority = cfg->dest_cfg.priority;
 624         cmd_params->message_ctx = cfg->message_ctx;
 625         cmd_params->message_iova = cfg->message_iova;
 626         cmd_params->notification_mode = cfg->notification_mode;
 627         cmd_params->threshold_entry = cfg->threshold_entry;
 628         cmd_params->threshold_exit = cfg->threshold_exit;
 629         dpseci_set_field(cmd_params->type_units,
 630                          DEST_TYPE,
 631                          cfg->dest_cfg.dest_type);
 632         dpseci_set_field(cmd_params->type_units,
 633                          CG_UNITS,
 634                          cfg->units);
 635
 636         /* send command to mc*/
 637         return mc_send_command(mc_io, &cmd);
 638 }
 639
 640 int dpseci_get_congestion_notification(
 641                                 struct fsl_mc_io *mc_io,
 642                                 uint32_t cmd_flags,
 643                                 uint16_t token,
 644                                 struct dpseci_congestion_notification_cfg *cfg)
 645 {
 646         struct dpseci_cmd_set_congestion_notification *rsp_params;
 647         struct mc_command cmd = { 0 };
 648         int err;
 649
 650         /* prepare command */
 651         cmd.header = mc_encode_cmd_header(
 652                         DPSECI_CMDID_GET_CONGESTION_NOTIFICATION,
 653                         cmd_flags,
 654                         token);
 655
 656         /* send command to mc*/
 657         err = mc_send_command(mc_io, &cmd);
 658         if (err)
 659                 return err;
 660
 661         rsp_params =
 662                 (struct dpseci_cmd_set_congestion_notification *)cmd.params;
 663
 664         cfg->dest_cfg.dest_id = le32_to_cpu(rsp_params->dest_id);
 665         cfg->dest_cfg.priority = rsp_params->dest_priority;
 666         cfg->notification_mode = le16_to_cpu(rsp_params->notification_mode);
 667         cfg->message_ctx = le64_to_cpu(rsp_params->message_ctx);
 668         cfg->message_iova = le64_to_cpu(rsp_params->message_iova);
 669         cfg->threshold_entry = le32_to_cpu(rsp_params->threshold_entry);
 670         cfg->threshold_exit = le32_to_cpu(rsp_params->threshold_exit);
 671         cfg->units = dpseci_get_field(rsp_params->type_units, CG_UNITS);
 672         cfg->dest_cfg.dest_type = dpseci_get_field(rsp_params->type_units,
 673                                                 DEST_TYPE);
 674
 675         return 0;
 676 }