drivers/crypto/dpaa2_sec/mc/dpseci.c

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