target/linux/layerscape/patches-5.4/806-dma-0001-dmaengine-fsl-dpaa2-qdma-Add-the-DPDMAI-Data-Path-DM.patch

   1 From e8a617bd4aa67cc57b7ff8b9a1b2ca0acd4712ac Mon Sep 17 00:00:00 2001
   2 From: Peng Ma <peng.ma@nxp.com>
   3 Date: Mon, 4 Mar 2019 15:39:14 +0800
   4 Subject: [PATCH] dmaengine: fsl-dpaa2-qdma: Add the DPDMAI(Data Path DMA
   5  Interface) support
   6
   7 The MC(Management Complex) exports the DPDMAI(Data Path DMA Interface)
   8 object as an interface to operate the DPAA2(Data Path Acceleration
   9 Architecture 2) qDMA Engine. The DPDMAI enables sending frame-based
  10 requests to qDMA and receiving back confirmation response on transaction
  11 completion, utilizing the DPAA2 QBMan(Queue Manager and Buffer Manager
  12 hardware) infrastructure. DPDMAI object provides up to two priorities for
  13 processing qDMA requests.
  14 The following list summarizes the DPDMAI main features and capabilities:
  15         1. Supports up to two scheduling priorities for processing
  16         service requests.
  17         - Each DPDMAI transmit queue is mapped to one of two service
  18         priorities, allowing further prioritization in hardware between
  19         requests from different DPDMAI objects.
  20         2. Supports up to two receive queues for incoming transaction
  21         completion confirmations.
  22         - Each DPDMAI receive queue is mapped to one of two receive
  23         priorities, allowing further prioritization between other
  24         interfaces when associating the DPDMAI receive queues to DPIO
  25         or DPCON(Data Path Concentrator) objects.
  26         3. Supports different scheduling options for processing received
  27         packets:
  28         - Queues can be configured either in 'parked' mode (default),
  29         or attached to a DPIO object, or attached to DPCON object.
  30         4. Allows interaction with one or more DPIO objects for
  31         dequeueing/enqueueing frame descriptors(FD) and for
  32         acquiring/releasing buffers.
  33         5. Supports enable, disable, and reset operations.
  34
  35 Add dpdmai to support some platforms with dpaa2 qdma engine.
  36
  37 Signed-off-by: Peng Ma <peng.ma@nxp.com>
  38 ---
  39  drivers/dma/fsl-dpaa2-qdma/dpdmai.c | 366 ++++++++++++++++++++++++++++++++++++
  40  drivers/dma/fsl-dpaa2-qdma/dpdmai.h | 177 +++++++++++++++++
  41  2 files changed, 543 insertions(+)
  42  create mode 100644 drivers/dma/fsl-dpaa2-qdma/dpdmai.c
  43  create mode 100644 drivers/dma/fsl-dpaa2-qdma/dpdmai.h
  44
  45 --- /dev/null
  46 +++ b/drivers/dma/fsl-dpaa2-qdma/dpdmai.c
  47 @@ -0,0 +1,366 @@
  48 +// SPDX-License-Identifier: GPL-2.0
  49 +// Copyright 2019 NXP
  50 +
  51 +#include <linux/types.h>
  52 +#include <linux/io.h>
  53 +#include <linux/fsl/mc.h>
  54 +#include "dpdmai.h"
  55 +
  56 +struct dpdmai_rsp_get_attributes {
  57 +       __le32 id;
  58 +       u8 num_of_priorities;
  59 +       u8 pad0[3];
  60 +       __le16 major;
  61 +       __le16 minor;
  62 +};
  63 +
  64 +struct dpdmai_cmd_queue {
  65 +       __le32 dest_id;
  66 +       u8 priority;
  67 +       u8 queue;
  68 +       u8 dest_type;
  69 +       u8 pad;
  70 +       __le64 user_ctx;
  71 +       union {
  72 +               __le32 options;
  73 +               __le32 fqid;
  74 +       };
  75 +};
  76 +
  77 +struct dpdmai_rsp_get_tx_queue {
  78 +       __le64 pad;
  79 +       __le32 fqid;
  80 +};
  81 +
  82 +#define MC_CMD_OP(_cmd, _param, _offset, _width, _type, _arg) \
  83 +       ((_cmd).params[_param] |= mc_enc((_offset), (_width), _arg))
  84 +
  85 +/* cmd, param, offset, width, type, arg_name */
  86 +#define DPDMAI_CMD_CREATE(_cmd, _cfg) \
  87 +do { \
  88 +       typeof(_cmd) (cmd) = (_cmd); \
  89 +       typeof(_cfg) (cfg) = (_cfg); \
  90 +       MC_CMD_OP(cmd, 0, 8,  8,  u8,  (cfg)->priorities[0]);\
  91 +       MC_CMD_OP(cmd, 0, 16, 8,  u8,  (cfg)->priorities[1]);\
  92 +} while (0)
  93 +
  94 +static inline u64 mc_enc(int lsoffset, int width, u64 val)
  95 +{
  96 +       return (val & MAKE_UMASK64(width)) << lsoffset;
  97 +}
  98 +
  99 +/**
 100 + * dpdmai_open() - Open a control session for the specified object
 101 + * @mc_io:     Pointer to MC portal's I/O object
 102 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
 103 + * @dpdmai_id: DPDMAI unique ID
 104 + * @token:     Returned token; use in subsequent API calls
 105 + *
 106 + * This function can be used to open a control session for an
 107 + * already created object; an object may have been declared in
 108 + * the DPL or by calling the dpdmai_create() function.
 109 + * This function returns a unique authentication token,
 110 + * associated with the specific object ID and the specific MC
 111 + * portal; this token must be used in all subsequent commands for
 112 + * this specific object.
 113 + *
 114 + * Return:     '0' on Success; Error code otherwise.
 115 + */
 116 +int dpdmai_open(struct fsl_mc_io *mc_io, u32 cmd_flags,
 117 +               int dpdmai_id, u16 *token)
 118 +{
 119 +       struct fsl_mc_command cmd = { 0 };
 120 +       __le64 *cmd_dpdmai_id;
 121 +       int err;
 122 +
 123 +       /* prepare command */
 124 +       cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_OPEN,
 125 +                                         cmd_flags, 0);
 126 +
 127 +       cmd_dpdmai_id = cmd.params;
 128 +       *cmd_dpdmai_id = cpu_to_le32(dpdmai_id);
 129 +
 130 +       /* send command to mc*/
 131 +       err = mc_send_command(mc_io, &cmd);
 132 +       if (err)
 133 +               return err;
 134 +
 135 +       /* retrieve response parameters */
 136 +       *token = mc_cmd_hdr_read_token(&cmd);
 137 +
 138 +       return 0;
 139 +}
 140 +
 141 +/**
 142 + * dpdmai_close() - Close the control session of the object
 143 + * @mc_io:     Pointer to MC portal's I/O object
 144 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
 145 + * @token:     Token of DPDMAI object
 146 + *
 147 + * After this function is called, no further operations are
 148 + * allowed on the object without opening a new control session.
 149 + *
 150 + * Return:     '0' on Success; Error code otherwise.
 151 + */
 152 +int dpdmai_close(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
 153 +{
 154 +       struct fsl_mc_command cmd = { 0 };
 155 +
 156 +       /* prepare command */
 157 +       cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_CLOSE,
 158 +                                         cmd_flags, token);
 159 +
 160 +       /* send command to mc*/
 161 +       return mc_send_command(mc_io, &cmd);
 162 +}
 163 +
 164 +/**
 165 + * dpdmai_create() - Create the DPDMAI object
 166 + * @mc_io:     Pointer to MC portal's I/O object
 167 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
 168 + * @cfg:       Configuration structure
 169 + * @token:     Returned token; use in subsequent API calls
 170 + *
 171 + * Create the DPDMAI object, allocate required resources and
 172 + * perform required initialization.
 173 + *
 174 + * The object can be created either by declaring it in the
 175 + * DPL file, or by calling this function.
 176 + *
 177 + * This function returns a unique authentication token,
 178 + * associated with the specific object ID and the specific MC
 179 + * portal; this token must be used in all subsequent calls to
 180 + * this specific object. For objects that are created using the
 181 + * DPL file, call dpdmai_open() function to get an authentication
 182 + * token first.
 183 + *
 184 + * Return:     '0' on Success; Error code otherwise.
 185 + */
 186 +int dpdmai_create(struct fsl_mc_io *mc_io, u32 cmd_flags,
 187 +                 const struct dpdmai_cfg *cfg, u16 *token)
 188 +{
 189 +       struct fsl_mc_command cmd = { 0 };
 190 +       int err;
 191 +
 192 +       /* prepare command */
 193 +       cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_CREATE,
 194 +                                         cmd_flags, 0);
 195 +       DPDMAI_CMD_CREATE(cmd, cfg);
 196 +
 197 +       /* send command to mc*/
 198 +       err = mc_send_command(mc_io, &cmd);
 199 +       if (err)
 200 +               return err;
 201 +
 202 +       /* retrieve response parameters */
 203 +       *token = mc_cmd_hdr_read_token(&cmd);
 204 +
 205 +       return 0;
 206 +}
 207 +
 208 +/**
 209 + * dpdmai_enable() - Enable the DPDMAI, allow sending and receiving frames.
 210 + * @mc_io:     Pointer to MC portal's I/O object
 211 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
 212 + * @token:     Token of DPDMAI object
 213 + *
 214 + * Return:     '0' on Success; Error code otherwise.
 215 + */
 216 +int dpdmai_enable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
 217 +{
 218 +       struct fsl_mc_command cmd = { 0 };
 219 +
 220 +       /* prepare command */
 221 +       cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_ENABLE,
 222 +                                         cmd_flags, token);
 223 +
 224 +       /* send command to mc*/
 225 +       return mc_send_command(mc_io, &cmd);
 226 +}
 227 +
 228 +/**
 229 + * dpdmai_disable() - Disable the DPDMAI, stop sending and receiving frames.
 230 + * @mc_io:     Pointer to MC portal's I/O object
 231 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
 232 + * @token:     Token of DPDMAI object
 233 + *
 234 + * Return:     '0' on Success; Error code otherwise.
 235 + */
 236 +int dpdmai_disable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
 237 +{
 238 +       struct fsl_mc_command cmd = { 0 };
 239 +
 240 +       /* prepare command */
 241 +       cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_DISABLE,
 242 +                                         cmd_flags, token);
 243 +
 244 +       /* send command to mc*/
 245 +       return mc_send_command(mc_io, &cmd);
 246 +}
 247 +
 248 +/**
 249 + * dpdmai_reset() - Reset the DPDMAI, returns the object to initial state.
 250 + * @mc_io:     Pointer to MC portal's I/O object
 251 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
 252 + * @token:     Token of DPDMAI object
 253 + *
 254 + * Return:     '0' on Success; Error code otherwise.
 255 + */
 256 +int dpdmai_reset(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
 257 +{
 258 +       struct fsl_mc_command cmd = { 0 };
 259 +
 260 +       /* prepare command */
 261 +       cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_RESET,
 262 +                                         cmd_flags, token);
 263 +
 264 +       /* send command to mc*/
 265 +       return mc_send_command(mc_io, &cmd);
 266 +}
 267 +
 268 +/**
 269 + * dpdmai_get_attributes() - Retrieve DPDMAI 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 DPDMAI object
 273 + * @attr:      Returned object's attributes
 274 + *
 275 + * Return:     '0' on Success; Error code otherwise.
 276 + */
 277 +int dpdmai_get_attributes(struct fsl_mc_io *mc_io, u32 cmd_flags,
 278 +                         u16 token, struct dpdmai_attr *attr)
 279 +{
 280 +       struct dpdmai_rsp_get_attributes *rsp_params;
 281 +       struct fsl_mc_command cmd = { 0 };
 282 +       int err;
 283 +
 284 +       /* prepare command */
 285 +       cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_ATTR,
 286 +                                         cmd_flags, token);
 287 +
 288 +       /* send command to mc*/
 289 +       err = mc_send_command(mc_io, &cmd);
 290 +       if (err)
 291 +               return err;
 292 +
 293 +       /* retrieve response parameters */
 294 +       rsp_params = (struct dpdmai_rsp_get_attributes *)cmd.params;
 295 +       attr->id = le32_to_cpu(rsp_params->id);
 296 +       attr->version.major = le16_to_cpu(rsp_params->major);
 297 +       attr->version.minor = le16_to_cpu(rsp_params->minor);
 298 +       attr->num_of_priorities = rsp_params->num_of_priorities;
 299 +
 300 +       return 0;
 301 +}
 302 +
 303 +/**
 304 + * dpdmai_set_rx_queue() - Set Rx queue configuration
 305 + * @mc_io:     Pointer to MC portal's I/O object
 306 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
 307 + * @token:     Token of DPDMAI object
 308 + * @priority:  Select the queue relative to number of
 309 + *             priorities configured at DPDMAI creation
 310 + * @cfg:       Rx queue configuration
 311 + *
 312 + * Return:     '0' on Success; Error code otherwise.
 313 + */
 314 +int dpdmai_set_rx_queue(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
 315 +                       u8 priority, const struct dpdmai_rx_queue_cfg *cfg)
 316 +{
 317 +       struct dpdmai_cmd_queue *cmd_params;
 318 +       struct fsl_mc_command cmd = { 0 };
 319 +
 320 +       /* prepare command */
 321 +       cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_SET_RX_QUEUE,
 322 +                                         cmd_flags, token);
 323 +
 324 +       cmd_params = (struct dpdmai_cmd_queue *)cmd.params;
 325 +       cmd_params->dest_id = cpu_to_le32(cfg->dest_cfg.dest_id);
 326 +       cmd_params->priority = cfg->dest_cfg.priority;
 327 +       cmd_params->queue = priority;
 328 +       cmd_params->dest_type = cfg->dest_cfg.dest_type;
 329 +       cmd_params->user_ctx = cpu_to_le64(cfg->user_ctx);
 330 +       cmd_params->options = cpu_to_le32(cfg->options);
 331 +
 332 +       /* send command to mc*/
 333 +       return mc_send_command(mc_io, &cmd);
 334 +}
 335 +
 336 +/**
 337 + * dpdmai_get_rx_queue() - Retrieve Rx 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 + * @attr:      Returned Rx queue attributes
 344 + *
 345 + * Return:     '0' on Success; Error code otherwise.
 346 + */
 347 +int dpdmai_get_rx_queue(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
 348 +                       u8 priority, struct dpdmai_rx_queue_attr *attr)
 349 +{
 350 +       struct dpdmai_cmd_queue *cmd_params;
 351 +       struct fsl_mc_command cmd = { 0 };
 352 +       int err;
 353 +
 354 +       /* prepare command */
 355 +       cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_RX_QUEUE,
 356 +                                         cmd_flags, token);
 357 +
 358 +       cmd_params = (struct dpdmai_cmd_queue *)cmd.params;
 359 +       cmd_params->queue = priority;
 360 +
 361 +       /* send command to mc*/
 362 +       err = mc_send_command(mc_io, &cmd);
 363 +       if (err)
 364 +               return err;
 365 +
 366 +       /* retrieve response parameters */
 367 +       attr->dest_cfg.dest_id = le32_to_cpu(cmd_params->dest_id);
 368 +       attr->dest_cfg.priority = cmd_params->priority;
 369 +       attr->dest_cfg.dest_type = cmd_params->dest_type;
 370 +       attr->user_ctx = le64_to_cpu(cmd_params->user_ctx);
 371 +       attr->fqid = le32_to_cpu(cmd_params->fqid);
 372 +
 373 +       return 0;
 374 +}
 375 +
 376 +/**
 377 + * dpdmai_get_tx_queue() - Retrieve Tx queue attributes.
 378 + * @mc_io:     Pointer to MC portal's I/O object
 379 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
 380 + * @token:     Token of DPDMAI object
 381 + * @priority:  Select the queue relative to number of
 382 + *                     priorities configured at DPDMAI creation
 383 + * @fqid:      Returned Tx queue
 384 + *
 385 + * Return:     '0' on Success; Error code otherwise.
 386 + */
 387 +int dpdmai_get_tx_queue(struct fsl_mc_io *mc_io, u32 cmd_flags,
 388 +                       u16 token, u8 priority, u32 *fqid)
 389 +{
 390 +       struct dpdmai_rsp_get_tx_queue *rsp_params;
 391 +       struct dpdmai_cmd_queue *cmd_params;
 392 +       struct fsl_mc_command cmd = { 0 };
 393 +       int err;
 394 +
 395 +       /* prepare command */
 396 +       cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_TX_QUEUE,
 397 +                                         cmd_flags, token);
 398 +
 399 +       cmd_params = (struct dpdmai_cmd_queue *)cmd.params;
 400 +       cmd_params->queue = priority;
 401 +
 402 +       /* send command to mc*/
 403 +       err = mc_send_command(mc_io, &cmd);
 404 +       if (err)
 405 +               return err;
 406 +
 407 +       /* retrieve response parameters */
 408 +
 409 +       rsp_params = (struct dpdmai_rsp_get_tx_queue *)cmd.params;
 410 +       *fqid = le32_to_cpu(rsp_params->fqid);
 411 +
 412 +       return 0;
 413 +}
 414 --- /dev/null
 415 +++ b/drivers/dma/fsl-dpaa2-qdma/dpdmai.h
 416 @@ -0,0 +1,177 @@
 417 +/* SPDX-License-Identifier: GPL-2.0 */
 418 +/* Copyright 2019 NXP */
 419 +
 420 +#ifndef __FSL_DPDMAI_H
 421 +#define __FSL_DPDMAI_H
 422 +
 423 +/* DPDMAI Version */
 424 +#define DPDMAI_VER_MAJOR       2
 425 +#define DPDMAI_VER_MINOR       2
 426 +
 427 +#define DPDMAI_CMD_BASE_VERSION        0
 428 +#define DPDMAI_CMD_ID_OFFSET   4
 429 +
 430 +#define DPDMAI_CMDID_FORMAT(x) (((x) << DPDMAI_CMD_ID_OFFSET) | \
 431 +                               DPDMAI_CMD_BASE_VERSION)
 432 +
 433 +/* Command IDs */
 434 +#define DPDMAI_CMDID_CLOSE             DPDMAI_CMDID_FORMAT(0x800)
 435 +#define DPDMAI_CMDID_OPEN               DPDMAI_CMDID_FORMAT(0x80E)
 436 +#define DPDMAI_CMDID_CREATE             DPDMAI_CMDID_FORMAT(0x90E)
 437 +
 438 +#define DPDMAI_CMDID_ENABLE             DPDMAI_CMDID_FORMAT(0x002)
 439 +#define DPDMAI_CMDID_DISABLE            DPDMAI_CMDID_FORMAT(0x003)
 440 +#define DPDMAI_CMDID_GET_ATTR           DPDMAI_CMDID_FORMAT(0x004)
 441 +#define DPDMAI_CMDID_RESET              DPDMAI_CMDID_FORMAT(0x005)
 442 +#define DPDMAI_CMDID_IS_ENABLED         DPDMAI_CMDID_FORMAT(0x006)
 443 +
 444 +#define DPDMAI_CMDID_SET_IRQ            DPDMAI_CMDID_FORMAT(0x010)
 445 +#define DPDMAI_CMDID_GET_IRQ            DPDMAI_CMDID_FORMAT(0x011)
 446 +#define DPDMAI_CMDID_SET_IRQ_ENABLE     DPDMAI_CMDID_FORMAT(0x012)
 447 +#define DPDMAI_CMDID_GET_IRQ_ENABLE     DPDMAI_CMDID_FORMAT(0x013)
 448 +#define DPDMAI_CMDID_SET_IRQ_MASK       DPDMAI_CMDID_FORMAT(0x014)
 449 +#define DPDMAI_CMDID_GET_IRQ_MASK       DPDMAI_CMDID_FORMAT(0x015)
 450 +#define DPDMAI_CMDID_GET_IRQ_STATUS     DPDMAI_CMDID_FORMAT(0x016)
 451 +#define DPDMAI_CMDID_CLEAR_IRQ_STATUS  DPDMAI_CMDID_FORMAT(0x017)
 452 +
 453 +#define DPDMAI_CMDID_SET_RX_QUEUE      DPDMAI_CMDID_FORMAT(0x1A0)
 454 +#define DPDMAI_CMDID_GET_RX_QUEUE       DPDMAI_CMDID_FORMAT(0x1A1)
 455 +#define DPDMAI_CMDID_GET_TX_QUEUE       DPDMAI_CMDID_FORMAT(0x1A2)
 456 +
 457 +#define MC_CMD_HDR_TOKEN_O 32  /* Token field offset */
 458 +#define MC_CMD_HDR_TOKEN_S 16  /* Token field size */
 459 +
 460 +#define MAKE_UMASK64(_width) \
 461 +       ((u64)((_width) < 64 ? ((u64)1 << (_width)) - 1 : (u64)-1))
 462 +
 463 +/* Data Path DMA Interface API
 464 + * Contains initialization APIs and runtime control APIs for DPDMAI
 465 + */
 466 +
 467 +/**
 468 + * Maximum number of Tx/Rx priorities per DPDMAI object
 469 + */
 470 +#define DPDMAI_PRIO_NUM                2
 471 +
 472 +/* DPDMAI queue modification options */
 473 +
 474 +/**
 475 + * Select to modify the user's context associated with the queue
 476 + */
 477 +#define DPDMAI_QUEUE_OPT_USER_CTX      0x1
 478 +
 479 +/**
 480 + * Select to modify the queue's destination
 481 + */
 482 +#define DPDMAI_QUEUE_OPT_DEST          0x2
 483 +
 484 +/**
 485 + * struct dpdmai_cfg - Structure representing DPDMAI configuration
 486 + * @priorities: Priorities for the DMA hardware processing; valid priorities are
 487 + *     configured with values 1-8; the entry following last valid entry
 488 + *     should be configured with 0
 489 + */
 490 +struct dpdmai_cfg {
 491 +       u8 priorities[DPDMAI_PRIO_NUM];
 492 +};
 493 +
 494 +/**
 495 + * struct dpdmai_attr - Structure representing DPDMAI attributes
 496 + * @id: DPDMAI object ID
 497 + * @version: DPDMAI version
 498 + * @num_of_priorities: number of priorities
 499 + */
 500 +struct dpdmai_attr {
 501 +       int     id;
 502 +       /**
 503 +        * struct version - DPDMAI version
 504 +        * @major: DPDMAI major version
 505 +        * @minor: DPDMAI minor version
 506 +        */
 507 +       struct {
 508 +               u16 major;
 509 +               u16 minor;
 510 +       } version;
 511 +       u8 num_of_priorities;
 512 +};
 513 +
 514 +/**
 515 + * enum dpdmai_dest - DPDMAI destination types
 516 + * @DPDMAI_DEST_NONE: Unassigned destination; The queue is set in parked mode
 517 + *     and does not generate FQDAN notifications; user is expected to dequeue
 518 + *     from the queue based on polling or other user-defined method
 519 + * @DPDMAI_DEST_DPIO: The queue is set in schedule mode and generates FQDAN
 520 + *     notifications to the specified DPIO; user is expected to dequeue
 521 + *     from the queue only after notification is received
 522 + * @DPDMAI_DEST_DPCON: The queue is set in schedule mode and does not generate
 523 + *     FQDAN notifications, but is connected to the specified DPCON object;
 524 + *     user is expected to dequeue from the DPCON channel
 525 + */
 526 +enum dpdmai_dest {
 527 +       DPDMAI_DEST_NONE = 0,
 528 +       DPDMAI_DEST_DPIO = 1,
 529 +       DPDMAI_DEST_DPCON = 2
 530 +};
 531 +
 532 +/**
 533 + * struct dpdmai_dest_cfg - Structure representing DPDMAI destination parameters
 534 + * @dest_type: Destination type
 535 + * @dest_id: Either DPIO ID or DPCON ID, depending on the destination type
 536 + * @priority: Priority selection within the DPIO or DPCON channel; valid values
 537 + *     are 0-1 or 0-7, depending on the number of priorities in that
 538 + *     channel; not relevant for 'DPDMAI_DEST_NONE' option
 539 + */
 540 +struct dpdmai_dest_cfg {
 541 +       enum dpdmai_dest dest_type;
 542 +       int dest_id;
 543 +       u8 priority;
 544 +};
 545 +
 546 +/**
 547 + * struct dpdmai_rx_queue_cfg - DPDMAI RX queue configuration
 548 + * @options: Flags representing the suggested modifications to the queue;
 549 + *     Use any combination of 'DPDMAI_QUEUE_OPT_<X>' flags
 550 + * @user_ctx: User context value provided in the frame descriptor of each
 551 + *     dequeued frame;
 552 + *     valid only if 'DPDMAI_QUEUE_OPT_USER_CTX' is contained in 'options'
 553 + * @dest_cfg: Queue destination parameters;
 554 + *     valid only if 'DPDMAI_QUEUE_OPT_DEST' is contained in 'options'
 555 + */
 556 +struct dpdmai_rx_queue_cfg {
 557 +       struct dpdmai_dest_cfg dest_cfg;
 558 +       u32 options;
 559 +       u64 user_ctx;
 560 +
 561 +};
 562 +
 563 +/**
 564 + * struct dpdmai_rx_queue_attr - Structure representing attributes of Rx queues
 565 + * @user_ctx:  User context value provided in the frame descriptor of each
 566 + *      dequeued frame
 567 + * @dest_cfg: Queue destination configuration
 568 + * @fqid: Virtual FQID value to be used for dequeue operations
 569 + */
 570 +struct dpdmai_rx_queue_attr {
 571 +       struct dpdmai_dest_cfg  dest_cfg;
 572 +       u64 user_ctx;
 573 +       u32 fqid;
 574 +};
 575 +
 576 +int dpdmai_open(struct fsl_mc_io *mc_io, u32 cmd_flags,
 577 +               int dpdmai_id, u16 *token);
 578 +int dpdmai_close(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token);
 579 +int dpdmai_create(struct fsl_mc_io *mc_io, u32 cmd_flags,
 580 +                 const struct dpdmai_cfg *cfg, u16 *token);
 581 +int dpdmai_enable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token);
 582 +int dpdmai_disable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token);
 583 +int dpdmai_reset(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token);
 584 +int dpdmai_get_attributes(struct fsl_mc_io *mc_io, u32 cmd_flags,
 585 +                         u16 token, struct dpdmai_attr *attr);
 586 +int dpdmai_set_rx_queue(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
 587 +                       u8 priority, const struct dpdmai_rx_queue_cfg *cfg);
 588 +int dpdmai_get_rx_queue(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
 589 +                       u8 priority, struct dpdmai_rx_queue_attr *attr);
 590 +int dpdmai_get_tx_queue(struct fsl_mc_io *mc_io, u32 cmd_flags,
 591 +                       u16 token, u8 priority, u32 *fqid);
 592 +
 593 +#endif /* __FSL_DPDMAI_H */