LXR linux/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
  10struct dpdmai_rsp_get_attributes {
  11        __le32 id;
  12        u8 num_of_priorities;
  13        u8 pad0[3];
  14        __le16 major;
  15        __le16 minor;
  16};
  17
  18struct 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
  31struct 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) \
  41do { \
  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
  46static 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 */
  68int 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}
  92EXPORT_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 */
 105int 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}
 116EXPORT_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 */
 140int 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_destroy() - Destroy the DPDMAI object and release all its resources.
 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 */
 170int dpdmai_destroy(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_DESTROY,
 176                                          cmd_flags, token);
 177
 178        /* send command to mc*/
 179        return mc_send_command(mc_io, &cmd);
 180}
 181EXPORT_SYMBOL_GPL(dpdmai_destroy);
 182
 183/**
 184 * dpdmai_enable() - Enable the DPDMAI, allow 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 */
 191int dpdmai_enable(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_ENABLE,
 197                                          cmd_flags, token);
 198
 199        /* send command to mc*/
 200        return mc_send_command(mc_io, &cmd);
 201}
 202EXPORT_SYMBOL_GPL(dpdmai_enable);
 203
 204/**
 205 * dpdmai_disable() - Disable the DPDMAI, stop sending and receiving frames.
 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 */
 212int dpdmai_disable(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_DISABLE,
 218                                          cmd_flags, token);
 219
 220        /* send command to mc*/
 221        return mc_send_command(mc_io, &cmd);
 222}
 223EXPORT_SYMBOL_GPL(dpdmai_disable);
 224
 225/**
 226 * dpdmai_reset() - Reset the DPDMAI, returns the object to initial state.
 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 *
 231 * Return:      '0' on Success; Error code otherwise.
 232 */
 233int dpdmai_reset(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
 234{
 235        struct fsl_mc_command cmd = { 0 };
 236
 237        /* prepare command */
 238        cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_RESET,
 239                                          cmd_flags, token);
 240
 241        /* send command to mc*/
 242        return mc_send_command(mc_io, &cmd);
 243}
 244EXPORT_SYMBOL_GPL(dpdmai_reset);
 245
 246/**
 247 * dpdmai_get_attributes() - Retrieve DPDMAI attributes.
 248 * @mc_io:      Pointer to MC portal's I/O object
 249 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 250 * @token:      Token of DPDMAI object
 251 * @attr:       Returned object's attributes
 252 *
 253 * Return:      '0' on Success; Error code otherwise.
 254 */
 255int dpdmai_get_attributes(struct fsl_mc_io *mc_io, u32 cmd_flags,
 256                          u16 token, struct dpdmai_attr *attr)
 257{
 258        struct dpdmai_rsp_get_attributes *rsp_params;
 259        struct fsl_mc_command cmd = { 0 };
 260        int err;
 261
 262        /* prepare command */
 263        cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_ATTR,
 264                                          cmd_flags, token);
 265
 266        /* send command to mc*/
 267        err = mc_send_command(mc_io, &cmd);
 268        if (err)
 269                return err;
 270
 271        /* retrieve response parameters */
 272        rsp_params = (struct dpdmai_rsp_get_attributes *)cmd.params;
 273        attr->id = le32_to_cpu(rsp_params->id);
 274        attr->version.major = le16_to_cpu(rsp_params->major);
 275        attr->version.minor = le16_to_cpu(rsp_params->minor);
 276        attr->num_of_priorities = rsp_params->num_of_priorities;
 277
 278        return 0;
 279}
 280EXPORT_SYMBOL_GPL(dpdmai_get_attributes);
 281
 282/**
 283 * dpdmai_set_rx_queue() - Set Rx queue configuration
 284 * @mc_io:      Pointer to MC portal's I/O object
 285 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 286 * @token:      Token of DPDMAI object
 287 * @priority:   Select the queue relative to number of
 288 *              priorities configured at DPDMAI creation
 289 * @cfg:        Rx queue configuration
 290 *
 291 * Return:      '0' on Success; Error code otherwise.
 292 */
 293int dpdmai_set_rx_queue(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
 294                        u8 priority, const struct dpdmai_rx_queue_cfg *cfg)
 295{
 296        struct dpdmai_cmd_queue *cmd_params;
 297        struct fsl_mc_command cmd = { 0 };
 298
 299        /* prepare command */
 300        cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_SET_RX_QUEUE,
 301                                          cmd_flags, token);
 302
 303        cmd_params = (struct dpdmai_cmd_queue *)cmd.params;
 304        cmd_params->dest_id = cpu_to_le32(cfg->dest_cfg.dest_id);
 305        cmd_params->priority = cfg->dest_cfg.priority;
 306        cmd_params->queue = priority;
 307        cmd_params->dest_type = cfg->dest_cfg.dest_type;
 308        cmd_params->user_ctx = cpu_to_le64(cfg->user_ctx);
 309        cmd_params->options = cpu_to_le32(cfg->options);
 310
 311        /* send command to mc*/
 312        return mc_send_command(mc_io, &cmd);
 313}
 314EXPORT_SYMBOL_GPL(dpdmai_set_rx_queue);
 315
 316/**
 317 * dpdmai_get_rx_queue() - Retrieve Rx queue attributes.
 318 * @mc_io:      Pointer to MC portal's I/O object
 319 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 320 * @token:      Token of DPDMAI object
 321 * @priority:   Select the queue relative to number of
 322 *                              priorities configured at DPDMAI creation
 323 * @attr:       Returned Rx queue attributes
 324 *
 325 * Return:      '0' on Success; Error code otherwise.
 326 */
 327int dpdmai_get_rx_queue(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
 328                        u8 priority, struct dpdmai_rx_queue_attr *attr)
 329{
 330        struct dpdmai_cmd_queue *cmd_params;
 331        struct fsl_mc_command cmd = { 0 };
 332        int err;
 333
 334        /* prepare command */
 335        cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_RX_QUEUE,
 336                                          cmd_flags, token);
 337
 338        cmd_params = (struct dpdmai_cmd_queue *)cmd.params;
 339        cmd_params->queue = priority;
 340
 341        /* send command to mc*/
 342        err = mc_send_command(mc_io, &cmd);
 343        if (err)
 344                return err;
 345
 346        /* retrieve response parameters */
 347        attr->dest_cfg.dest_id = le32_to_cpu(cmd_params->dest_id);
 348        attr->dest_cfg.priority = cmd_params->priority;
 349        attr->dest_cfg.dest_type = cmd_params->dest_type;
 350        attr->user_ctx = le64_to_cpu(cmd_params->user_ctx);
 351        attr->fqid = le32_to_cpu(cmd_params->fqid);
 352
 353        return 0;
 354}
 355EXPORT_SYMBOL_GPL(dpdmai_get_rx_queue);
 356
 357/**
 358 * dpdmai_get_tx_queue() - Retrieve Tx queue attributes.
 359 * @mc_io:      Pointer to MC portal's I/O object
 360 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 361 * @token:      Token of DPDMAI object
 362 * @priority:   Select the queue relative to number of
 363 *                      priorities configured at DPDMAI creation
 364 * @fqid:       Returned Tx queue
 365 *
 366 * Return:      '0' on Success; Error code otherwise.
 367 */
 368int dpdmai_get_tx_queue(struct fsl_mc_io *mc_io, u32 cmd_flags,
 369                        u16 token, u8 priority, u32 *fqid)
 370{
 371        struct dpdmai_rsp_get_tx_queue *rsp_params;
 372        struct dpdmai_cmd_queue *cmd_params;
 373        struct fsl_mc_command cmd = { 0 };
 374        int err;
 375
 376        /* prepare command */
 377        cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_TX_QUEUE,
 378                                          cmd_flags, token);
 379
 380        cmd_params = (struct dpdmai_cmd_queue *)cmd.params;
 381        cmd_params->queue = priority;
 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
 390        rsp_params = (struct dpdmai_rsp_get_tx_queue *)cmd.params;
 391        *fqid = le32_to_cpu(rsp_params->fqid);
 392
 393        return 0;
 394}
 395EXPORT_SYMBOL_GPL(dpdmai_get_tx_queue);
 396
 397MODULE_LICENSE("GPL v2");
 398