drivers/soc/fsl/dpio/dpio.c

   1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
   2 /*
   3  * Copyright 2013-2016 Freescale Semiconductor Inc.
   4  * Copyright 2016 NXP
   5  *
   6  */
   7 #include <linux/kernel.h>
   8 #include <linux/fsl/mc.h>
   9
  10 #include "dpio.h"
  11 #include "dpio-cmd.h"
  12
  13 /*
  14  * Data Path I/O Portal API
  15  * Contains initialization APIs and runtime control APIs for DPIO
  16  */
  17
  18 /**
  19  * dpio_open() - Open a control session for the specified object
  20  * @mc_io:      Pointer to MC portal's I/O object
  21  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  22  * @dpio_id:    DPIO unique ID
  23  * @token:      Returned token; use in subsequent API calls
  24  *
  25  * This function can be used to open a control session for an
  26  * already created object; an object may have been declared in
  27  * the DPL or by calling the dpio_create() function.
  28  * This function returns a unique authentication token,
  29  * associated with the specific object ID and the specific MC
  30  * portal; this token must be used in all subsequent commands for
  31  * this specific object.
  32  *
  33  * Return:      '0' on Success; Error code otherwise.
  34  */
  35 int dpio_open(struct fsl_mc_io *mc_io,
  36               u32 cmd_flags,
  37               int dpio_id,
  38               u16 *token)
  39 {
  40         struct fsl_mc_command cmd = { 0 };
  41         struct dpio_cmd_open *dpio_cmd;
  42         int err;
  43
  44         /* prepare command */
  45         cmd.header = mc_encode_cmd_header(DPIO_CMDID_OPEN,
  46                                           cmd_flags,
  47                                           0);
  48         dpio_cmd = (struct dpio_cmd_open *)cmd.params;
  49         dpio_cmd->dpio_id = cpu_to_le32(dpio_id);
  50
  51         err = mc_send_command(mc_io, &cmd);
  52         if (err)
  53                 return err;
  54
  55         /* retrieve response parameters */
  56         *token = mc_cmd_hdr_read_token(&cmd);
  57
  58         return 0;
  59 }
  60
  61 /**
  62  * dpio_close() - Close the control session of the object
  63  * @mc_io:      Pointer to MC portal's I/O object
  64  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  65  * @token:      Token of DPIO object
  66  *
  67  * Return:      '0' on Success; Error code otherwise.
  68  */
  69 int dpio_close(struct fsl_mc_io *mc_io,
  70                u32 cmd_flags,
  71                u16 token)
  72 {
  73         struct fsl_mc_command cmd = { 0 };
  74
  75         /* prepare command */
  76         cmd.header = mc_encode_cmd_header(DPIO_CMDID_CLOSE,
  77                                           cmd_flags,
  78                                           token);
  79
  80         return mc_send_command(mc_io, &cmd);
  81 }
  82
  83 /**
  84  * dpio_enable() - Enable the DPIO, allow I/O portal operations.
  85  * @mc_io:      Pointer to MC portal's I/O object
  86  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  87  * @token:      Token of DPIO object
  88  *
  89  * Return:      '0' on Success; Error code otherwise
  90  */
  91 int dpio_enable(struct fsl_mc_io *mc_io,
  92                 u32 cmd_flags,
  93                 u16 token)
  94 {
  95         struct fsl_mc_command cmd = { 0 };
  96
  97         /* prepare command */
  98         cmd.header = mc_encode_cmd_header(DPIO_CMDID_ENABLE,
  99                                           cmd_flags,
 100                                           token);
 101
 102         return mc_send_command(mc_io, &cmd);
 103 }
 104
 105 /**
 106  * dpio_disable() - Disable the DPIO, stop any I/O portal operation.
 107  * @mc_io:      Pointer to MC portal's I/O object
 108  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 109  * @token:      Token of DPIO object
 110  *
 111  * Return:      '0' on Success; Error code otherwise
 112  */
 113 int dpio_disable(struct fsl_mc_io *mc_io,
 114                  u32 cmd_flags,
 115                  u16 token)
 116 {
 117         struct fsl_mc_command cmd = { 0 };
 118
 119         /* prepare command */
 120         cmd.header = mc_encode_cmd_header(DPIO_CMDID_DISABLE,
 121                                           cmd_flags,
 122                                           token);
 123
 124         return mc_send_command(mc_io, &cmd);
 125 }
 126
 127 /**
 128  * dpio_get_attributes() - Retrieve DPIO attributes
 129  * @mc_io:      Pointer to MC portal's I/O object
 130  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 131  * @token:      Token of DPIO object
 132  * @attr:       Returned object's attributes
 133  *
 134  * Return:      '0' on Success; Error code otherwise
 135  */
 136 int dpio_get_attributes(struct fsl_mc_io *mc_io,
 137                         u32 cmd_flags,
 138                         u16 token,
 139                         struct dpio_attr *attr)
 140 {
 141         struct fsl_mc_command cmd = { 0 };
 142         struct dpio_rsp_get_attr *dpio_rsp;
 143         int err;
 144
 145         /* prepare command */
 146         cmd.header = mc_encode_cmd_header(DPIO_CMDID_GET_ATTR,
 147                                           cmd_flags,
 148                                           token);
 149
 150         err = mc_send_command(mc_io, &cmd);
 151         if (err)
 152                 return err;
 153
 154         /* retrieve response parameters */
 155         dpio_rsp = (struct dpio_rsp_get_attr *)cmd.params;
 156         attr->id = le32_to_cpu(dpio_rsp->id);
 157         attr->qbman_portal_id = le16_to_cpu(dpio_rsp->qbman_portal_id);
 158         attr->num_priorities = dpio_rsp->num_priorities;
 159         attr->channel_mode = dpio_rsp->channel_mode & DPIO_CHANNEL_MODE_MASK;
 160         attr->qbman_portal_ce_offset =
 161                 le64_to_cpu(dpio_rsp->qbman_portal_ce_addr);
 162         attr->qbman_portal_ci_offset =
 163                 le64_to_cpu(dpio_rsp->qbman_portal_ci_addr);
 164         attr->qbman_version = le32_to_cpu(dpio_rsp->qbman_version);
 165
 166         return 0;
 167 }
 168
 169 int dpio_set_stashing_destination(struct fsl_mc_io *mc_io,
 170                                   u32 cmd_flags,
 171                                   u16 token,
 172                                   u8 sdest)
 173 {
 174         struct fsl_mc_command cmd = { 0 };
 175         struct dpio_stashing_dest *dpio_cmd;
 176
 177         cmd.header = mc_encode_cmd_header(DPIO_CMDID_SET_STASHING_DEST,
 178                                           cmd_flags, token);
 179         dpio_cmd = (struct dpio_stashing_dest *)cmd.params;
 180         dpio_cmd->sdest = sdest;
 181
 182         return mc_send_command(mc_io, &cmd);
 183 }
 184
 185 /**
 186  * dpio_get_api_version - Get Data Path I/O API version
 187  * @mc_io:      Pointer to MC portal's DPIO object
 188  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 189  * @major_ver:  Major version of DPIO API
 190  * @minor_ver:  Minor version of DPIO API
 191  *
 192  * Return:      '0' on Success; Error code otherwise
 193  */
 194 int dpio_get_api_version(struct fsl_mc_io *mc_io,
 195                          u32 cmd_flags,
 196                          u16 *major_ver,
 197                          u16 *minor_ver)
 198 {
 199         struct fsl_mc_command cmd = { 0 };
 200         int err;
 201
 202         /* prepare command */
 203         cmd.header = mc_encode_cmd_header(DPIO_CMDID_GET_API_VERSION,
 204                                           cmd_flags, 0);
 205
 206         err = mc_send_command(mc_io, &cmd);
 207         if (err)
 208                 return err;
 209
 210         /* retrieve response parameters */
 211         mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
 212
 213         return 0;
 214 }
 215
 216 /**
 217  * dpio_reset() - Reset the DPIO, returns the object to initial state.
 218  * @mc_io:      Pointer to MC portal's I/O object
 219  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 220  * @token:      Token of DPIO object
 221  *
 222  * Return:      '0' on Success; Error code otherwise.
 223  */
 224 int dpio_reset(struct fsl_mc_io *mc_io,
 225                u32 cmd_flags,
 226                u16 token)
 227 {
 228         struct fsl_mc_command cmd = { 0 };
 229
 230         /* prepare command */
 231         cmd.header = mc_encode_cmd_header(DPIO_CMDID_RESET,
 232                                           cmd_flags,
 233                                           token);
 234
 235         /* send command to mc*/
 236         return mc_send_command(mc_io, &cmd);
 237 }