drivers/bus/fslmc/mc/dpci.c

   1 /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
   2  *
   3  * Copyright 2013-2016 Freescale Semiconductor Inc.
   4  *
   5  */
   6 #include <fsl_mc_sys.h>
   7 #include <fsl_mc_cmd.h>
   8 #include <fsl_dpci.h>
   9 #include <fsl_dpci_cmd.h>
  10
  11 /**
  12  * dpci_open() - Open a control session for the specified object
  13  * @mc_io:      Pointer to MC portal's I/O object
  14  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  15  * @dpci_id:    DPCI unique ID
  16  * @token:      Returned token; use in subsequent API calls
  17  *
  18  * This function can be used to open a control session for an
  19  * already created object; an object may have been declared in
  20  * the DPL or by calling the dpci_create() function.
  21  * This function returns a unique authentication token,
  22  * associated with the specific object ID and the specific MC
  23  * portal; this token must be used in all subsequent commands for
  24  * this specific object.
  25  *
  26  * Return:      '0' on Success; Error code otherwise.
  27  */
  28 int dpci_open(struct fsl_mc_io *mc_io,
  29               uint32_t cmd_flags,
  30               int dpci_id,
  31               uint16_t *token)
  32 {
  33         struct dpci_cmd_open *cmd_params;
  34         struct mc_command cmd = { 0 };
  35         int err;
  36
  37         /* prepare command */
  38         cmd.header = mc_encode_cmd_header(DPCI_CMDID_OPEN,
  39                                           cmd_flags,
  40                                           0);
  41         cmd_params = (struct dpci_cmd_open *)cmd.params;
  42         cmd_params->dpci_id = cpu_to_le32(dpci_id);
  43
  44         /* send command to mc*/
  45         err = mc_send_command(mc_io, &cmd);
  46         if (err)
  47                 return err;
  48
  49         /* retrieve response parameters */
  50         *token = mc_cmd_hdr_read_token(&cmd);
  51
  52         return 0;
  53 }
  54
  55 /**
  56  * dpci_close() - Close the control session of the object
  57  * @mc_io:      Pointer to MC portal's I/O object
  58  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  59  * @token:      Token of DPCI object
  60  *
  61  * After this function is called, no further operations are
  62  * allowed on the object without opening a new control session.
  63  *
  64  * Return:      '0' on Success; Error code otherwise.
  65  */
  66 int dpci_close(struct fsl_mc_io *mc_io,
  67                uint32_t cmd_flags,
  68                uint16_t token)
  69 {
  70         struct mc_command cmd = { 0 };
  71
  72         /* prepare command */
  73         cmd.header = mc_encode_cmd_header(DPCI_CMDID_CLOSE,
  74                                           cmd_flags,
  75                                           token);
  76
  77         /* send command to mc*/
  78         return mc_send_command(mc_io, &cmd);
  79 }
  80
  81 /**
  82  * dpci_create() - Create the DPCI object.
  83  * @mc_io:      Pointer to MC portal's I/O object
  84  * @dprc_token: Parent container token; '0' for default container
  85  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  86  * @cfg:        Configuration structure
  87  * @obj_id:     Returned object id
  88  *
  89  * Create the DPCI object, allocate required resources and perform required
  90  * initialization.
  91  *
  92  * The object can be created either by declaring it in the
  93  * DPL file, or by calling this function.
  94  *
  95  * The function accepts an authentication token of a parent
  96  * container that this object should be assigned to. The token
  97  * can be '0' so the object will be assigned to the default container.
  98  * The newly created object can be opened with the returned
  99  * object id and using the container's associated tokens and MC portals.
 100  *
 101  * Return:      '0' on Success; Error code otherwise.
 102  */
 103 int dpci_create(struct fsl_mc_io *mc_io,
 104                 uint16_t dprc_token,
 105                 uint32_t cmd_flags,
 106                 const struct dpci_cfg *cfg,
 107                 uint32_t *obj_id)
 108 {
 109         struct dpci_cmd_create *cmd_params;
 110         struct mc_command cmd = { 0 };
 111         int err;
 112
 113         /* prepare command */
 114         cmd.header = mc_encode_cmd_header(DPCI_CMDID_CREATE,
 115                                           cmd_flags,
 116                                           dprc_token);
 117         cmd_params = (struct dpci_cmd_create *)cmd.params;
 118         cmd_params->num_of_priorities = cfg->num_of_priorities;
 119
 120         /* send command to mc*/
 121         err = mc_send_command(mc_io, &cmd);
 122         if (err)
 123                 return err;
 124
 125         /* retrieve response parameters */
 126         *obj_id = mc_cmd_read_object_id(&cmd);
 127
 128         return 0;
 129 }
 130
 131 /**
 132  * dpci_destroy() - Destroy the DPCI object and release all its resources.
 133  * @mc_io:      Pointer to MC portal's I/O object
 134  * @dprc_token: Parent container token; '0' for default container
 135  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 136  * @object_id:  The object id; it must be a valid id within the container that
 137  * created this object;
 138  *
 139  * The function accepts the authentication token of the parent container that
 140  * created the object (not the one that currently owns the object). The object
 141  * is searched within parent using the provided 'object_id'.
 142  * All tokens to the object must be closed before calling destroy.
 143  *
 144  * Return:      '0' on Success; error code otherwise.
 145  */
 146 int dpci_destroy(struct fsl_mc_io *mc_io,
 147                  uint16_t dprc_token,
 148                  uint32_t cmd_flags,
 149                  uint32_t object_id)
 150 {
 151         struct dpci_cmd_destroy *cmd_params;
 152         struct mc_command cmd = { 0 };
 153
 154         /* prepare command */
 155         cmd.header = mc_encode_cmd_header(DPCI_CMDID_DESTROY,
 156                                           cmd_flags,
 157                                           dprc_token);
 158         cmd_params = (struct dpci_cmd_destroy *)cmd.params;
 159         cmd_params->dpci_id = cpu_to_le32(object_id);
 160
 161         /* send command to mc*/
 162         return mc_send_command(mc_io, &cmd);
 163 }
 164
 165 /**
 166  * dpci_enable() - Enable the DPCI, allow sending and receiving frames.
 167  * @mc_io:      Pointer to MC portal's I/O object
 168  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 169  * @token:      Token of DPCI object
 170  *
 171  * Return:      '0' on Success; Error code otherwise.
 172  */
 173 int dpci_enable(struct fsl_mc_io *mc_io,
 174                 uint32_t cmd_flags,
 175                 uint16_t token)
 176 {
 177         struct mc_command cmd = { 0 };
 178
 179         /* prepare command */
 180         cmd.header = mc_encode_cmd_header(DPCI_CMDID_ENABLE,
 181                                           cmd_flags,
 182                                           token);
 183
 184         /* send command to mc*/
 185         return mc_send_command(mc_io, &cmd);
 186 }
 187
 188 /**
 189  * dpci_disable() - Disable the DPCI, stop sending and receiving frames.
 190  * @mc_io:      Pointer to MC portal's I/O object
 191  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 192  * @token:      Token of DPCI object
 193  *
 194  * Return:      '0' on Success; Error code otherwise.
 195  */
 196 int dpci_disable(struct fsl_mc_io *mc_io,
 197                  uint32_t cmd_flags,
 198                  uint16_t token)
 199 {
 200         struct mc_command cmd = { 0 };
 201
 202         /* prepare command */
 203         cmd.header = mc_encode_cmd_header(DPCI_CMDID_DISABLE,
 204                                           cmd_flags,
 205                                           token);
 206
 207         /* send command to mc*/
 208         return mc_send_command(mc_io, &cmd);
 209 }
 210
 211 /**
 212  * dpci_is_enabled() - Check if the DPCI is enabled.
 213  * @mc_io:      Pointer to MC portal's I/O object
 214  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 215  * @token:      Token of DPCI object
 216  * @en:         Returns '1' if object is enabled; '0' otherwise
 217  *
 218  * Return:      '0' on Success; Error code otherwise.
 219  */
 220 int dpci_is_enabled(struct fsl_mc_io *mc_io,
 221                     uint32_t cmd_flags,
 222                     uint16_t token,
 223                     int *en)
 224 {
 225         struct dpci_rsp_is_enabled *rsp_params;
 226         struct mc_command cmd = { 0 };
 227         int err;
 228
 229         /* prepare command */
 230         cmd.header = mc_encode_cmd_header(DPCI_CMDID_IS_ENABLED, cmd_flags,
 231                                           token);
 232
 233         /* send command to mc*/
 234         err = mc_send_command(mc_io, &cmd);
 235         if (err)
 236                 return err;
 237
 238         /* retrieve response parameters */
 239         rsp_params = (struct dpci_rsp_is_enabled *)cmd.params;
 240         *en = dpci_get_field(rsp_params->en, ENABLE);
 241
 242         return 0;
 243 }
 244
 245 /**
 246  * dpci_reset() - Reset the DPCI, returns the object to initial state.
 247  * @mc_io:      Pointer to MC portal's I/O object
 248  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 249  * @token:      Token of DPCI object
 250  *
 251  * Return:      '0' on Success; Error code otherwise.
 252  */
 253 int dpci_reset(struct fsl_mc_io *mc_io,
 254                uint32_t cmd_flags,
 255                uint16_t token)
 256 {
 257         struct mc_command cmd = { 0 };
 258
 259         /* prepare command */
 260         cmd.header = mc_encode_cmd_header(DPCI_CMDID_RESET,
 261                                           cmd_flags,
 262                                           token);
 263
 264         /* send command to mc*/
 265         return mc_send_command(mc_io, &cmd);
 266 }
 267
 268 /**
 269  * dpci_get_attributes() - Retrieve DPCI attributes.
 270  * @mc_io:      Pointer to MC portal's I/O object
 271  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 272  * @token:      Token of DPCI object
 273  * @attr:       Returned object's attributes
 274  *
 275  * Return:      '0' on Success; Error code otherwise.
 276  */
 277 int dpci_get_attributes(struct fsl_mc_io *mc_io,
 278                         uint32_t cmd_flags,
 279                         uint16_t token,
 280                         struct dpci_attr *attr)
 281 {
 282         struct dpci_rsp_get_attr *rsp_params;
 283         struct mc_command cmd = { 0 };
 284         int err;
 285
 286         /* prepare command */
 287         cmd.header = mc_encode_cmd_header(DPCI_CMDID_GET_ATTR,
 288                                           cmd_flags,
 289                                           token);
 290
 291         /* send command to mc*/
 292         err = mc_send_command(mc_io, &cmd);
 293         if (err)
 294                 return err;
 295
 296         /* retrieve response parameters */
 297         rsp_params = (struct dpci_rsp_get_attr *)cmd.params;
 298         attr->id = le32_to_cpu(rsp_params->id);
 299         attr->num_of_priorities = rsp_params->num_of_priorities;
 300
 301         return 0;
 302 }
 303
 304 /**
 305  * dpci_set_rx_queue() - Set Rx queue configuration
 306  * @mc_io:      Pointer to MC portal's I/O object
 307  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 308  * @token:      Token of DPCI object
 309  * @priority:   Select the queue relative to number of
 310  *                      priorities configured at DPCI creation; use
 311  *                      DPCI_ALL_QUEUES to configure all Rx queues
 312  *                      identically.
 313  * @cfg:        Rx queue configuration
 314  *
 315  * Return:      '0' on Success; Error code otherwise.
 316  */
 317 int dpci_set_rx_queue(struct fsl_mc_io *mc_io,
 318                       uint32_t cmd_flags,
 319                       uint16_t token,
 320                       uint8_t priority,
 321                       const struct dpci_rx_queue_cfg *cfg)
 322 {
 323         struct dpci_cmd_set_rx_queue *cmd_params;
 324         struct mc_command cmd = { 0 };
 325
 326         /* prepare command */
 327         cmd.header = mc_encode_cmd_header(DPCI_CMDID_SET_RX_QUEUE,
 328                                           cmd_flags,
 329                                           token);
 330         cmd_params = (struct dpci_cmd_set_rx_queue *)cmd.params;
 331         cmd_params->dest_id = cpu_to_le32(cfg->dest_cfg.dest_id);
 332         cmd_params->dest_priority = cfg->dest_cfg.priority;
 333         cmd_params->priority = priority;
 334         cmd_params->user_ctx = cpu_to_le64(cfg->user_ctx);
 335         cmd_params->options = cpu_to_le32(cfg->options);
 336         dpci_set_field(cmd_params->dest_type,
 337                        DEST_TYPE,
 338                        cfg->dest_cfg.dest_type);
 339         dpci_set_field(cmd_params->dest_type,
 340                        ORDER_PRESERVATION,
 341                        cfg->order_preservation_en);
 342
 343         /* send command to mc*/
 344         return mc_send_command(mc_io, &cmd);
 345 }
 346
 347 /**
 348  * dpci_get_rx_queue() - Retrieve Rx queue attributes.
 349  * @mc_io:      Pointer to MC portal's I/O object
 350  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 351  * @token:      Token of DPCI object
 352  * @priority:   Select the queue relative to number of
 353  *              priorities configured at DPCI creation
 354  * @attr:       Returned Rx queue attributes
 355  *
 356  * Return:      '0' on Success; Error code otherwise.
 357  */
 358 int dpci_get_rx_queue(struct fsl_mc_io *mc_io,
 359                       uint32_t cmd_flags,
 360                       uint16_t token,
 361                       uint8_t priority,
 362                       struct dpci_rx_queue_attr *attr)
 363 {
 364         struct dpci_cmd_get_queue *cmd_params;
 365         struct dpci_rsp_get_rx_queue *rsp_params;
 366         struct mc_command cmd = { 0 };
 367         int err;
 368
 369         /* prepare command */
 370         cmd.header = mc_encode_cmd_header(DPCI_CMDID_GET_RX_QUEUE,
 371                                           cmd_flags,
 372                                           token);
 373         cmd_params = (struct dpci_cmd_get_queue *)cmd.params;
 374         cmd_params->priority = priority;
 375
 376         /* send command to mc*/
 377         err = mc_send_command(mc_io, &cmd);
 378         if (err)
 379                 return err;
 380
 381         /* retrieve response parameters */
 382         rsp_params = (struct dpci_rsp_get_rx_queue *)cmd.params;
 383         attr->user_ctx = le64_to_cpu(rsp_params->user_ctx);
 384         attr->fqid = le32_to_cpu(rsp_params->fqid);
 385         attr->dest_cfg.dest_id = le32_to_cpu(rsp_params->dest_id);
 386         attr->dest_cfg.priority = rsp_params->dest_priority;
 387         attr->dest_cfg.dest_type = dpci_get_field(rsp_params->dest_type,
 388                                                   DEST_TYPE);
 389
 390         return 0;
 391 }
 392
 393 /**
 394  * dpci_get_tx_queue() - Retrieve Tx queue attributes.
 395  * @mc_io:      Pointer to MC portal's I/O object
 396  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 397  * @token:      Token of DPCI object
 398  * @priority:   Select the queue relative to number of
 399  *              priorities of the peer DPCI object
 400  * @attr:       Returned Tx queue attributes
 401  *
 402  * Return:      '0' on Success; Error code otherwise.
 403  */
 404 int dpci_get_tx_queue(struct fsl_mc_io *mc_io,
 405                       uint32_t cmd_flags,
 406                       uint16_t token,
 407                       uint8_t priority,
 408                       struct dpci_tx_queue_attr *attr)
 409 {
 410         struct dpci_cmd_get_queue *cmd_params;
 411         struct dpci_rsp_get_tx_queue *rsp_params;
 412         struct mc_command cmd = { 0 };
 413         int err;
 414
 415         /* prepare command */
 416         cmd.header = mc_encode_cmd_header(DPCI_CMDID_GET_TX_QUEUE,
 417                                           cmd_flags,
 418                                           token);
 419         cmd_params = (struct dpci_cmd_get_queue *)cmd.params;
 420         cmd_params->priority = priority;
 421
 422         /* send command to mc*/
 423         err = mc_send_command(mc_io, &cmd);
 424         if (err)
 425                 return err;
 426
 427         /* retrieve response parameters */
 428         rsp_params = (struct dpci_rsp_get_tx_queue *)cmd.params;
 429         attr->fqid = le32_to_cpu(rsp_params->fqid);
 430
 431         return 0;
 432 }
 433
 434 /**
 435  * dpci_get_api_version() - Get communication interface API version
 436  * @mc_io:      Pointer to MC portal's I/O object
 437  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 438  * @major_ver:  Major version of data path communication interface API
 439  * @minor_ver:  Minor version of data path communication interface API
 440  *
 441  * Return:  '0' on Success; Error code otherwise.
 442  */
 443 int dpci_get_api_version(struct fsl_mc_io *mc_io,
 444                          uint32_t cmd_flags,
 445                          uint16_t *major_ver,
 446                          uint16_t *minor_ver)
 447 {
 448         struct dpci_rsp_get_api_version *rsp_params;
 449         struct mc_command cmd = { 0 };
 450         int err;
 451
 452         cmd.header = mc_encode_cmd_header(DPCI_CMDID_GET_API_VERSION,
 453                                         cmd_flags,
 454                                         0);
 455
 456         err = mc_send_command(mc_io, &cmd);
 457         if (err)
 458                 return err;
 459
 460         rsp_params = (struct dpci_rsp_get_api_version *)cmd.params;
 461         *major_ver = le16_to_cpu(rsp_params->major);
 462         *minor_ver = le16_to_cpu(rsp_params->minor);
 463
 464         return 0;
 465 }
 466
 467 /**
 468  * dpci_set_opr() - Set Order Restoration configuration.
 469  * @mc_io:      Pointer to MC portal's I/O object
 470  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 471  * @token:      Token of DPCI object
 472  * @index:      The queue index
 473  * @options:    Configuration mode options
 474  *              can be OPR_OPT_CREATE or OPR_OPT_RETIRE
 475  * @cfg:        Configuration options for the OPR
 476  *
 477  * Return:      '0' on Success; Error code otherwise.
 478  */
 479 int dpci_set_opr(struct fsl_mc_io *mc_io,
 480                  uint32_t cmd_flags,
 481                  uint16_t token,
 482                  uint8_t index,
 483                  uint8_t options,
 484                  struct opr_cfg *cfg)
 485 {
 486         struct dpci_cmd_set_opr *cmd_params;
 487         struct mc_command cmd = { 0 };
 488
 489         /* prepare command */
 490         cmd.header = mc_encode_cmd_header(DPCI_CMDID_SET_OPR,
 491                                           cmd_flags,
 492                                           token);
 493         cmd_params = (struct dpci_cmd_set_opr *)cmd.params;
 494         cmd_params->index = index;
 495         cmd_params->options = options;
 496         cmd_params->oloe = cfg->oloe;
 497         cmd_params->oeane = cfg->oeane;
 498         cmd_params->olws = cfg->olws;
 499         cmd_params->oa = cfg->oa;
 500         cmd_params->oprrws = cfg->oprrws;
 501
 502         /* send command to mc*/
 503         return mc_send_command(mc_io, &cmd);
 504 }
 505
 506 /**
 507  * dpci_get_opr() - Retrieve Order Restoration config and query.
 508  * @mc_io:      Pointer to MC portal's I/O object
 509  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 510  * @token:      Token of DPCI object
 511  * @index:      The queue index
 512  * @cfg:        Returned OPR configuration
 513  * @qry:        Returned OPR query
 514  *
 515  * Return:      '0' on Success; Error code otherwise.
 516  */
 517 int dpci_get_opr(struct fsl_mc_io *mc_io,
 518                  uint32_t cmd_flags,
 519                  uint16_t token,
 520                  uint8_t index,
 521                  struct opr_cfg *cfg,
 522                  struct opr_qry *qry)
 523 {
 524         struct dpci_rsp_get_opr *rsp_params;
 525         struct dpci_cmd_get_opr *cmd_params;
 526         struct mc_command cmd = { 0 };
 527         int err;
 528
 529         /* prepare command */
 530         cmd.header = mc_encode_cmd_header(DPCI_CMDID_GET_OPR,
 531                                           cmd_flags,
 532                                           token);
 533         cmd_params = (struct dpci_cmd_get_opr *)cmd.params;
 534         cmd_params->index = index;
 535
 536         /* send command to mc*/
 537         err = mc_send_command(mc_io, &cmd);
 538         if (err)
 539                 return err;
 540
 541         /* retrieve response parameters */
 542         rsp_params = (struct dpci_rsp_get_opr *)cmd.params;
 543         cfg->oloe = rsp_params->oloe;
 544         cfg->oeane = rsp_params->oeane;
 545         cfg->olws = rsp_params->olws;
 546         cfg->oa = rsp_params->oa;
 547         cfg->oprrws = rsp_params->oprrws;
 548         qry->rip = dpci_get_field(rsp_params->flags, RIP);
 549         qry->enable = dpci_get_field(rsp_params->flags, OPR_ENABLE);
 550         qry->nesn = le16_to_cpu(rsp_params->nesn);
 551         qry->ndsn = le16_to_cpu(rsp_params->ndsn);
 552         qry->ea_tseq = le16_to_cpu(rsp_params->ea_tseq);
 553         qry->tseq_nlis = dpci_get_field(rsp_params->tseq_nlis, TSEQ_NLIS);
 554         qry->ea_hseq = le16_to_cpu(rsp_params->ea_hseq);
 555         qry->hseq_nlis = dpci_get_field(rsp_params->hseq_nlis, HSEQ_NLIS);
 556         qry->ea_hptr = le16_to_cpu(rsp_params->ea_hptr);
 557         qry->ea_tptr = le16_to_cpu(rsp_params->ea_tptr);
 558         qry->opr_vid = le16_to_cpu(rsp_params->opr_vid);
 559         qry->opr_id = le16_to_cpu(rsp_params->opr_id);
 560
 561         return 0;
 562 }