ceph/src/spdk/dpdk/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 int dpci_get_attributes(struct fsl_mc_io *mc_io,
 269                         uint32_t cmd_flags,
 270                         uint16_t token,
 271                         struct dpci_attr *attr)
 272 {
 273         struct dpci_rsp_get_attr *rsp_params;
 274         struct mc_command cmd = { 0 };
 275         int err;
 276
 277         /* prepare command */
 278         cmd.header = mc_encode_cmd_header(DPCI_CMDID_GET_ATTR,
 279                                           cmd_flags,
 280                                           token);
 281
 282         /* send command to mc*/
 283         err = mc_send_command(mc_io, &cmd);
 284         if (err)
 285                 return err;
 286
 287         /* retrieve response parameters */
 288         rsp_params = (struct dpci_rsp_get_attr *)cmd.params;
 289         attr->id = le32_to_cpu(rsp_params->id);
 290         attr->num_of_priorities = rsp_params->num_of_priorities;
 291
 292         return 0;
 293 }
 294
 295 int dpci_set_rx_queue(struct fsl_mc_io *mc_io,
 296                       uint32_t cmd_flags,
 297                       uint16_t token,
 298                       uint8_t priority,
 299                       const struct dpci_rx_queue_cfg *cfg)
 300 {
 301         struct dpci_cmd_set_rx_queue *cmd_params;
 302         struct mc_command cmd = { 0 };
 303
 304         /* prepare command */
 305         cmd.header = mc_encode_cmd_header(DPCI_CMDID_SET_RX_QUEUE,
 306                                           cmd_flags,
 307                                           token);
 308         cmd_params = (struct dpci_cmd_set_rx_queue *)cmd.params;
 309         cmd_params->dest_id = cpu_to_le32(cfg->dest_cfg.dest_id);
 310         cmd_params->dest_priority = cfg->dest_cfg.priority;
 311         cmd_params->priority = priority;
 312         cmd_params->user_ctx = cpu_to_le64(cfg->user_ctx);
 313         cmd_params->options = cpu_to_le32(cfg->options);
 314         dpci_set_field(cmd_params->dest_type,
 315                        DEST_TYPE,
 316                        cfg->dest_cfg.dest_type);
 317
 318         /* send command to mc*/
 319         return mc_send_command(mc_io, &cmd);
 320 }
 321
 322 /**
 323  * dpci_get_rx_queue() - Retrieve Rx queue attributes.
 324  * @mc_io:      Pointer to MC portal's I/O object
 325  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 326  * @token:      Token of DPCI object
 327  * @priority:   Select the queue relative to number of
 328  *              priorities configured at DPCI creation
 329  * @attr:       Returned Rx queue attributes
 330  *
 331  * Return:      '0' on Success; Error code otherwise.
 332  */
 333 int dpci_get_rx_queue(struct fsl_mc_io *mc_io,
 334                       uint32_t cmd_flags,
 335                       uint16_t token,
 336                       uint8_t priority,
 337                       struct dpci_rx_queue_attr *attr)
 338 {
 339         struct dpci_cmd_get_queue *cmd_params;
 340         struct dpci_rsp_get_rx_queue *rsp_params;
 341         struct mc_command cmd = { 0 };
 342         int err;
 343
 344         /* prepare command */
 345         cmd.header = mc_encode_cmd_header(DPCI_CMDID_GET_RX_QUEUE,
 346                                           cmd_flags,
 347                                           token);
 348         cmd_params = (struct dpci_cmd_get_queue *)cmd.params;
 349         cmd_params->priority = priority;
 350
 351         /* send command to mc*/
 352         err = mc_send_command(mc_io, &cmd);
 353         if (err)
 354                 return err;
 355
 356         /* retrieve response parameters */
 357         rsp_params = (struct dpci_rsp_get_rx_queue *)cmd.params;
 358         attr->user_ctx = le64_to_cpu(rsp_params->user_ctx);
 359         attr->fqid = le32_to_cpu(rsp_params->fqid);
 360         attr->dest_cfg.dest_id = le32_to_cpu(rsp_params->dest_id);
 361         attr->dest_cfg.priority = rsp_params->dest_priority;
 362         attr->dest_cfg.dest_type = dpci_get_field(rsp_params->dest_type,
 363                                                   DEST_TYPE);
 364
 365         return 0;
 366 }
 367
 368 /**
 369  * dpci_get_tx_queue() - Retrieve Tx queue attributes.
 370  * @mc_io:      Pointer to MC portal's I/O object
 371  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 372  * @token:      Token of DPCI object
 373  * @priority:   Select the queue relative to number of
 374  *              priorities of the peer DPCI object
 375  * @attr:       Returned Tx queue attributes
 376  *
 377  * Return:      '0' on Success; Error code otherwise.
 378  */
 379 int dpci_get_tx_queue(struct fsl_mc_io *mc_io,
 380                       uint32_t cmd_flags,
 381                       uint16_t token,
 382                       uint8_t priority,
 383                       struct dpci_tx_queue_attr *attr)
 384 {
 385         struct dpci_cmd_get_queue *cmd_params;
 386         struct dpci_rsp_get_tx_queue *rsp_params;
 387         struct mc_command cmd = { 0 };
 388         int err;
 389
 390         /* prepare command */
 391         cmd.header = mc_encode_cmd_header(DPCI_CMDID_GET_TX_QUEUE,
 392                                           cmd_flags,
 393                                           token);
 394         cmd_params = (struct dpci_cmd_get_queue *)cmd.params;
 395         cmd_params->priority = priority;
 396
 397         /* send command to mc*/
 398         err = mc_send_command(mc_io, &cmd);
 399         if (err)
 400                 return err;
 401
 402         /* retrieve response parameters */
 403         rsp_params = (struct dpci_rsp_get_tx_queue *)cmd.params;
 404         attr->fqid = le32_to_cpu(rsp_params->fqid);
 405
 406         return 0;
 407 }
 408
 409 /**
 410  * dpci_get_api_version() - Get communication interface API version
 411  * @mc_io:      Pointer to MC portal's I/O object
 412  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 413  * @major_ver:  Major version of data path communication interface API
 414  * @minor_ver:  Minor version of data path communication interface API
 415  *
 416  * Return:  '0' on Success; Error code otherwise.
 417  */
 418 int dpci_get_api_version(struct fsl_mc_io *mc_io,
 419                          uint32_t cmd_flags,
 420                          uint16_t *major_ver,
 421                          uint16_t *minor_ver)
 422 {
 423         struct dpci_rsp_get_api_version *rsp_params;
 424         struct mc_command cmd = { 0 };
 425         int err;
 426
 427         cmd.header = mc_encode_cmd_header(DPCI_CMDID_GET_API_VERSION,
 428                                         cmd_flags,
 429                                         0);
 430
 431         err = mc_send_command(mc_io, &cmd);
 432         if (err)
 433                 return err;
 434
 435         rsp_params = (struct dpci_rsp_get_api_version *)cmd.params;
 436         *major_ver = le16_to_cpu(rsp_params->major);
 437         *minor_ver = le16_to_cpu(rsp_params->minor);
 438
 439         return 0;
 440 }