drivers/dma/fsl-dpaa2-qdma/dpdmai.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright 2019 NXP
   3
   4 #include <linux/module.h>
   5 #include <linux/types.h>
   6 #include <linux/io.h>
   7 #include <linux/fsl/mc.h>
   8 #include "dpdmai.h"
   9
  10 struct dpdmai_rsp_get_attributes {
  11         __le32 id;
  12         u8 num_of_priorities;
  13         u8 pad0[3];
  14         __le16 major;
  15         __le16 minor;
  16 };
  17
  18 struct dpdmai_cmd_queue {
  19         __le32 dest_id;
  20         u8 priority;
  21         u8 queue;
  22         u8 dest_type;
  23         u8 pad;
  24         __le64 user_ctx;
  25         union {
  26                 __le32 options;
  27                 __le32 fqid;
  28         };
  29 };
  30
  31 struct dpdmai_rsp_get_tx_queue {
  32         __le64 pad;
  33         __le32 fqid;
  34 };
  35
  36 #define MC_CMD_OP(_cmd, _param, _offset, _width, _type, _arg) \
  37         ((_cmd).params[_param] |= mc_enc((_offset), (_width), _arg))
  38
  39 /* cmd, param, offset, width, type, arg_name */
  40 #define DPDMAI_CMD_CREATE(cmd, cfg) \
  41 do { \
  42         MC_CMD_OP(cmd, 0, 8,  8,  u8,  (cfg)->priorities[0]);\
  43         MC_CMD_OP(cmd, 0, 16, 8,  u8,  (cfg)->priorities[1]);\
  44 } while (0)
  45
  46 static inline u64 mc_enc(int lsoffset, int width, u64 val)
  47 {
  48         return (val & MAKE_UMASK64(width)) << lsoffset;
  49 }
  50
  51 /**
  52  * dpdmai_open() - Open a control session for the specified object
  53  * @mc_io:      Pointer to MC portal's I/O object
  54  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  55  * @dpdmai_id:  DPDMAI unique ID
  56  * @token:      Returned token; use in subsequent API calls
  57  *
  58  * This function can be used to open a control session for an
  59  * already created object; an object may have been declared in
  60  * the DPL or by calling the dpdmai_create() function.
  61  * This function returns a unique authentication token,
  62  * associated with the specific object ID and the specific MC
  63  * portal; this token must be used in all subsequent commands for
  64  * this specific object.
  65  *
  66  * Return:      '0' on Success; Error code otherwise.
  67  */
  68 int dpdmai_open(struct fsl_mc_io *mc_io, u32 cmd_flags,
  69                 int dpdmai_id, u16 *token)
  70 {
  71         struct fsl_mc_command cmd = { 0 };
  72         __le64 *cmd_dpdmai_id;
  73         int err;
  74
  75         /* prepare command */
  76         cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_OPEN,
  77                                           cmd_flags, 0);
  78
  79         cmd_dpdmai_id = cmd.params;
  80         *cmd_dpdmai_id = cpu_to_le32(dpdmai_id);
  81
  82         /* send command to mc*/
  83         err = mc_send_command(mc_io, &cmd);
  84         if (err)
  85                 return err;
  86
  87         /* retrieve response parameters */
  88         *token = mc_cmd_hdr_read_token(&cmd);
  89
  90         return 0;
  91 }
  92 EXPORT_SYMBOL_GPL(dpdmai_open);
  93
  94 /**
  95  * dpdmai_close() - Close the control session of the object
  96  * @mc_io:      Pointer to MC portal's I/O object
  97  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  98  * @token:      Token of DPDMAI object
  99  *
 100  * After this function is called, no further operations are
 101  * allowed on the object without opening a new control session.
 102  *
 103  * Return:      '0' on Success; Error code otherwise.
 104  */
 105 int dpdmai_close(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
 106 {
 107         struct fsl_mc_command cmd = { 0 };
 108
 109         /* prepare command */
 110         cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_CLOSE,
 111                                           cmd_flags, token);
 112
 113         /* send command to mc*/
 114         return mc_send_command(mc_io, &cmd);
 115 }
 116 EXPORT_SYMBOL_GPL(dpdmai_close);
 117
 118 /**
 119  * dpdmai_create() - Create the DPDMAI object
 120  * @mc_io:      Pointer to MC portal's I/O object
 121  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 122  * @cfg:        Configuration structure
 123  * @token:      Returned token; use in subsequent API calls
 124  *
 125  * Create the DPDMAI object, allocate required resources and
 126  * perform required initialization.
 127  *
 128  * The object can be created either by declaring it in the
 129  * DPL file, or by calling this function.
 130  *
 131  * This function returns a unique authentication token,
 132  * associated with the specific object ID and the specific MC
 133  * portal; this token must be used in all subsequent calls to
 134  * this specific object. For objects that are created using the
 135  * DPL file, call dpdmai_open() function to get an authentication
 136  * token first.
 137  *
 138  * Return:      '0' on Success; Error code otherwise.
 139  */
 140 int dpdmai_create(struct fsl_mc_io *mc_io, u32 cmd_flags,
 141                   const struct dpdmai_cfg *cfg, u16 *token)
 142 {
 143         struct fsl_mc_command cmd = { 0 };
 144         int err;
 145
 146         /* prepare command */
 147         cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_CREATE,
 148                                           cmd_flags, 0);
 149         DPDMAI_CMD_CREATE(cmd, cfg);
 150
 151         /* send command to mc*/
 152         err = mc_send_command(mc_io, &cmd);
 153         if (err)
 154                 return err;
 155
 156         /* retrieve response parameters */
 157         *token = mc_cmd_hdr_read_token(&cmd);
 158
 159         return 0;
 160 }
 161
 162 /**
 163  * dpdmai_enable() - Enable the DPDMAI, allow sending and receiving frames.
 164  * @mc_io:      Pointer to MC portal's I/O object
 165  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 166  * @token:      Token of DPDMAI object
 167  *
 168  * Return:      '0' on Success; Error code otherwise.
 169  */
 170 int dpdmai_enable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
 171 {
 172         struct fsl_mc_command cmd = { 0 };
 173
 174         /* prepare command */
 175         cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_ENABLE,
 176                                           cmd_flags, token);
 177
 178         /* send command to mc*/
 179         return mc_send_command(mc_io, &cmd);
 180 }
 181 EXPORT_SYMBOL_GPL(dpdmai_enable);
 182
 183 /**
 184  * dpdmai_disable() - Disable the DPDMAI, stop sending and receiving frames.
 185  * @mc_io:      Pointer to MC portal's I/O object
 186  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 187  * @token:      Token of DPDMAI object
 188  *
 189  * Return:      '0' on Success; Error code otherwise.
 190  */
 191 int dpdmai_disable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
 192 {
 193         struct fsl_mc_command cmd = { 0 };
 194
 195         /* prepare command */
 196         cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_DISABLE,
 197                                           cmd_flags, token);
 198
 199         /* send command to mc*/
 200         return mc_send_command(mc_io, &cmd);
 201 }
 202 EXPORT_SYMBOL_GPL(dpdmai_disable);
 203
 204 /**
 205  * dpdmai_reset() - Reset the DPDMAI, returns the object to initial state.
 206  * @mc_io:      Pointer to MC portal's I/O object
 207  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 208  * @token:      Token of DPDMAI object
 209  *
 210  * Return:      '0' on Success; Error code otherwise.
 211  */
 212 int dpdmai_reset(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
 213 {
 214         struct fsl_mc_command cmd = { 0 };
 215
 216         /* prepare command */
 217         cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_RESET,
 218                                           cmd_flags, token);
 219
 220         /* send command to mc*/
 221         return mc_send_command(mc_io, &cmd);
 222 }
 223 EXPORT_SYMBOL_GPL(dpdmai_reset);
 224
 225 /**
 226  * dpdmai_get_attributes() - Retrieve DPDMAI attributes.
 227  * @mc_io:      Pointer to MC portal's I/O object
 228  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 229  * @token:      Token of DPDMAI object
 230  * @attr:       Returned object's attributes
 231  *
 232  * Return:      '0' on Success; Error code otherwise.
 233  */
 234 int dpdmai_get_attributes(struct fsl_mc_io *mc_io, u32 cmd_flags,
 235                           u16 token, struct dpdmai_attr *attr)
 236 {
 237         struct dpdmai_rsp_get_attributes *rsp_params;
 238         struct fsl_mc_command cmd = { 0 };
 239         int err;
 240
 241         /* prepare command */
 242         cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_ATTR,
 243                                           cmd_flags, token);
 244
 245         /* send command to mc*/
 246         err = mc_send_command(mc_io, &cmd);
 247         if (err)
 248                 return err;
 249
 250         /* retrieve response parameters */
 251         rsp_params = (struct dpdmai_rsp_get_attributes *)cmd.params;
 252         attr->id = le32_to_cpu(rsp_params->id);
 253         attr->version.major = le16_to_cpu(rsp_params->major);
 254         attr->version.minor = le16_to_cpu(rsp_params->minor);
 255         attr->num_of_priorities = rsp_params->num_of_priorities;
 256
 257         return 0;
 258 }
 259 EXPORT_SYMBOL_GPL(dpdmai_get_attributes);
 260
 261 /**
 262  * dpdmai_set_rx_queue() - Set Rx queue configuration
 263  * @mc_io:      Pointer to MC portal's I/O object
 264  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 265  * @token:      Token of DPDMAI object
 266  * @priority:   Select the queue relative to number of
 267  *              priorities configured at DPDMAI creation
 268  * @cfg:        Rx queue configuration
 269  *
 270  * Return:      '0' on Success; Error code otherwise.
 271  */
 272 int dpdmai_set_rx_queue(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
 273                         u8 priority, const struct dpdmai_rx_queue_cfg *cfg)
 274 {
 275         struct dpdmai_cmd_queue *cmd_params;
 276         struct fsl_mc_command cmd = { 0 };
 277
 278         /* prepare command */
 279         cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_SET_RX_QUEUE,
 280                                           cmd_flags, token);
 281
 282         cmd_params = (struct dpdmai_cmd_queue *)cmd.params;
 283         cmd_params->dest_id = cpu_to_le32(cfg->dest_cfg.dest_id);
 284         cmd_params->priority = cfg->dest_cfg.priority;
 285         cmd_params->queue = priority;
 286         cmd_params->dest_type = cfg->dest_cfg.dest_type;
 287         cmd_params->user_ctx = cpu_to_le64(cfg->user_ctx);
 288         cmd_params->options = cpu_to_le32(cfg->options);
 289
 290         /* send command to mc*/
 291         return mc_send_command(mc_io, &cmd);
 292 }
 293 EXPORT_SYMBOL_GPL(dpdmai_set_rx_queue);
 294
 295 /**
 296  * dpdmai_get_rx_queue() - Retrieve Rx queue attributes.
 297  * @mc_io:      Pointer to MC portal's I/O object
 298  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 299  * @token:      Token of DPDMAI object
 300  * @priority:   Select the queue relative to number of
 301  *                              priorities configured at DPDMAI creation
 302  * @attr:       Returned Rx queue attributes
 303  *
 304  * Return:      '0' on Success; Error code otherwise.
 305  */
 306 int dpdmai_get_rx_queue(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
 307                         u8 priority, struct dpdmai_rx_queue_attr *attr)
 308 {
 309         struct dpdmai_cmd_queue *cmd_params;
 310         struct fsl_mc_command cmd = { 0 };
 311         int err;
 312
 313         /* prepare command */
 314         cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_RX_QUEUE,
 315                                           cmd_flags, token);
 316
 317         cmd_params = (struct dpdmai_cmd_queue *)cmd.params;
 318         cmd_params->queue = priority;
 319
 320         /* send command to mc*/
 321         err = mc_send_command(mc_io, &cmd);
 322         if (err)
 323                 return err;
 324
 325         /* retrieve response parameters */
 326         attr->dest_cfg.dest_id = le32_to_cpu(cmd_params->dest_id);
 327         attr->dest_cfg.priority = cmd_params->priority;
 328         attr->dest_cfg.dest_type = cmd_params->dest_type;
 329         attr->user_ctx = le64_to_cpu(cmd_params->user_ctx);
 330         attr->fqid = le32_to_cpu(cmd_params->fqid);
 331
 332         return 0;
 333 }
 334 EXPORT_SYMBOL_GPL(dpdmai_get_rx_queue);
 335
 336 /**
 337  * dpdmai_get_tx_queue() - Retrieve Tx queue attributes.
 338  * @mc_io:      Pointer to MC portal's I/O object
 339  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 340  * @token:      Token of DPDMAI object
 341  * @priority:   Select the queue relative to number of
 342  *                      priorities configured at DPDMAI creation
 343  * @fqid:       Returned Tx queue
 344  *
 345  * Return:      '0' on Success; Error code otherwise.
 346  */
 347 int dpdmai_get_tx_queue(struct fsl_mc_io *mc_io, u32 cmd_flags,
 348                         u16 token, u8 priority, u32 *fqid)
 349 {
 350         struct dpdmai_rsp_get_tx_queue *rsp_params;
 351         struct dpdmai_cmd_queue *cmd_params;
 352         struct fsl_mc_command cmd = { 0 };
 353         int err;
 354
 355         /* prepare command */
 356         cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_TX_QUEUE,
 357                                           cmd_flags, token);
 358
 359         cmd_params = (struct dpdmai_cmd_queue *)cmd.params;
 360         cmd_params->queue = priority;
 361
 362         /* send command to mc*/
 363         err = mc_send_command(mc_io, &cmd);
 364         if (err)
 365                 return err;
 366
 367         /* retrieve response parameters */
 368
 369         rsp_params = (struct dpdmai_rsp_get_tx_queue *)cmd.params;
 370         *fqid = le32_to_cpu(rsp_params->fqid);
 371
 372         return 0;
 373 }
 374 EXPORT_SYMBOL_GPL(dpdmai_get_tx_queue);
 375
 376 MODULE_LICENSE("GPL v2");