kernel/drivers/staging/fsl-mc/bus/dpmcp.c

   1 /* Copyright 2013-2015 Freescale Semiconductor Inc.
   2  *
   3  * Redistribution and use in source and binary forms, with or without
   4  * modification, are permitted provided that the following conditions are met:
   5  * * Redistributions of source code must retain the above copyright
   6  * notice, this list of conditions and the following disclaimer.
   7  * * Redistributions in binary form must reproduce the above copyright
   8  * notice, this list of conditions and the following disclaimer in the
   9  * documentation and/or other materials provided with the distribution.
  10  * * Neither the name of the above-listed copyright holders nor the
  11  * names of any contributors may be used to endorse or promote products
  12  * derived from this software without specific prior written permission.
  13  *
  14  *
  15  * ALTERNATIVELY, this software may be distributed under the terms of the
  16  * GNU General Public License ("GPL") as published by the Free Software
  17  * Foundation, either version 2 of that License or (at your option) any
  18  * later version.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
  24  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32 #include "../include/mc-sys.h"
  33 #include "../include/mc-cmd.h"
  34 #include "dpmcp.h"
  35 #include "dpmcp-cmd.h"
  36
  37 int dpmcp_open(struct fsl_mc_io *mc_io, int dpmcp_id, uint16_t *token)
  38 {
  39         struct mc_command cmd = { 0 };
  40         int err;
  41
  42         /* prepare command */
  43         cmd.header = mc_encode_cmd_header(DPMCP_CMDID_OPEN,
  44                                           MC_CMD_PRI_LOW, 0);
  45         cmd.params[0] |= mc_enc(0, 32, dpmcp_id);
  46
  47         /* send command to mc*/
  48         err = mc_send_command(mc_io, &cmd);
  49         if (err)
  50                 return err;
  51
  52         /* retrieve response parameters */
  53         *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
  54
  55         return err;
  56 }
  57
  58 int dpmcp_close(struct fsl_mc_io *mc_io, uint16_t token)
  59 {
  60         struct mc_command cmd = { 0 };
  61
  62         /* prepare command */
  63         cmd.header = mc_encode_cmd_header(DPMCP_CMDID_CLOSE, MC_CMD_PRI_HIGH,
  64                                           token);
  65
  66         /* send command to mc*/
  67         return mc_send_command(mc_io, &cmd);
  68 }
  69
  70 int dpmcp_create(struct fsl_mc_io *mc_io,
  71                  const struct dpmcp_cfg *cfg,
  72                 uint16_t *token)
  73 {
  74         struct mc_command cmd = { 0 };
  75         int err;
  76
  77         /* prepare command */
  78         cmd.header = mc_encode_cmd_header(DPMCP_CMDID_CREATE,
  79                                           MC_CMD_PRI_LOW, 0);
  80         cmd.params[0] |= mc_enc(0, 32, cfg->portal_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.header);
  89
  90         return 0;
  91 }
  92
  93 int dpmcp_destroy(struct fsl_mc_io *mc_io, uint16_t token)
  94 {
  95         struct mc_command cmd = { 0 };
  96
  97         /* prepare command */
  98         cmd.header = mc_encode_cmd_header(DPMCP_CMDID_DESTROY,
  99                                           MC_CMD_PRI_LOW, token);
 100
 101         /* send command to mc*/
 102         return mc_send_command(mc_io, &cmd);
 103 }
 104
 105 int dpmcp_reset(struct fsl_mc_io *mc_io, uint16_t token)
 106 {
 107         struct mc_command cmd = { 0 };
 108
 109         /* prepare command */
 110         cmd.header = mc_encode_cmd_header(DPMCP_CMDID_RESET,
 111                                           MC_CMD_PRI_LOW, token);
 112
 113         /* send command to mc*/
 114         return mc_send_command(mc_io, &cmd);
 115 }
 116
 117 int dpmcp_set_irq(struct fsl_mc_io *mc_io,
 118                   uint16_t token,
 119                  uint8_t irq_index,
 120                  uint64_t irq_addr,
 121                  uint32_t irq_val,
 122                  int user_irq_id)
 123 {
 124         struct mc_command cmd = { 0 };
 125
 126         /* prepare command */
 127         cmd.header = mc_encode_cmd_header(DPMCP_CMDID_SET_IRQ,
 128                                           MC_CMD_PRI_LOW, token);
 129         cmd.params[0] |= mc_enc(0, 8, irq_index);
 130         cmd.params[0] |= mc_enc(32, 32, irq_val);
 131         cmd.params[1] |= mc_enc(0, 64, irq_addr);
 132         cmd.params[2] |= mc_enc(0, 32, user_irq_id);
 133
 134         /* send command to mc*/
 135         return mc_send_command(mc_io, &cmd);
 136 }
 137
 138 int dpmcp_get_irq(struct fsl_mc_io *mc_io,
 139                   uint16_t token,
 140                  uint8_t irq_index,
 141                  int *type,
 142                  uint64_t *irq_addr,
 143                  uint32_t *irq_val,
 144                  int *user_irq_id)
 145 {
 146         struct mc_command cmd = { 0 };
 147         int err;
 148
 149         /* prepare command */
 150         cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ,
 151                                           MC_CMD_PRI_LOW, token);
 152         cmd.params[0] |= mc_enc(32, 8, irq_index);
 153
 154         /* send command to mc*/
 155         err = mc_send_command(mc_io, &cmd);
 156         if (err)
 157                 return err;
 158
 159         /* retrieve response parameters */
 160         *irq_val = (uint32_t)mc_dec(cmd.params[0], 0, 32);
 161         *irq_addr = (uint64_t)mc_dec(cmd.params[1], 0, 64);
 162         *user_irq_id = (int)mc_dec(cmd.params[2], 0, 32);
 163         *type = (int)mc_dec(cmd.params[2], 32, 32);
 164         return 0;
 165 }
 166
 167 int dpmcp_set_irq_enable(struct fsl_mc_io *mc_io,
 168                          uint16_t token,
 169                         uint8_t irq_index,
 170                         uint8_t en)
 171 {
 172         struct mc_command cmd = { 0 };
 173
 174         /* prepare command */
 175         cmd.header = mc_encode_cmd_header(DPMCP_CMDID_SET_IRQ_ENABLE,
 176                                           MC_CMD_PRI_LOW, token);
 177         cmd.params[0] |= mc_enc(0, 8, en);
 178         cmd.params[0] |= mc_enc(32, 8, irq_index);
 179
 180         /* send command to mc*/
 181         return mc_send_command(mc_io, &cmd);
 182 }
 183
 184 int dpmcp_get_irq_enable(struct fsl_mc_io *mc_io,
 185                          uint16_t token,
 186                         uint8_t irq_index,
 187                         uint8_t *en)
 188 {
 189         struct mc_command cmd = { 0 };
 190         int err;
 191
 192         /* prepare command */
 193         cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ_ENABLE,
 194                                           MC_CMD_PRI_LOW, token);
 195         cmd.params[0] |= mc_enc(32, 8, irq_index);
 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         *en = (uint8_t)mc_dec(cmd.params[0], 0, 8);
 204         return 0;
 205 }
 206
 207 int dpmcp_set_irq_mask(struct fsl_mc_io *mc_io,
 208                        uint16_t token,
 209                       uint8_t irq_index,
 210                       uint32_t mask)
 211 {
 212         struct mc_command cmd = { 0 };
 213
 214         /* prepare command */
 215         cmd.header = mc_encode_cmd_header(DPMCP_CMDID_SET_IRQ_MASK,
 216                                           MC_CMD_PRI_LOW, token);
 217         cmd.params[0] |= mc_enc(0, 32, mask);
 218         cmd.params[0] |= mc_enc(32, 8, irq_index);
 219
 220         /* send command to mc*/
 221         return mc_send_command(mc_io, &cmd);
 222 }
 223
 224 int dpmcp_get_irq_mask(struct fsl_mc_io *mc_io,
 225                        uint16_t token,
 226                       uint8_t irq_index,
 227                       uint32_t *mask)
 228 {
 229         struct mc_command cmd = { 0 };
 230         int err;
 231
 232         /* prepare command */
 233         cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ_MASK,
 234                                           MC_CMD_PRI_LOW, token);
 235         cmd.params[0] |= mc_enc(32, 8, irq_index);
 236
 237         /* send command to mc*/
 238         err = mc_send_command(mc_io, &cmd);
 239         if (err)
 240                 return err;
 241
 242         /* retrieve response parameters */
 243         *mask = (uint32_t)mc_dec(cmd.params[0], 0, 32);
 244         return 0;
 245 }
 246
 247 int dpmcp_get_irq_status(struct fsl_mc_io *mc_io,
 248                          uint16_t token,
 249                         uint8_t irq_index,
 250                         uint32_t *status)
 251 {
 252         struct mc_command cmd = { 0 };
 253         int err;
 254
 255         /* prepare command */
 256         cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ_STATUS,
 257                                           MC_CMD_PRI_LOW, token);
 258         cmd.params[0] |= mc_enc(32, 8, irq_index);
 259
 260         /* send command to mc*/
 261         err = mc_send_command(mc_io, &cmd);
 262         if (err)
 263                 return err;
 264
 265         /* retrieve response parameters */
 266         *status = (uint32_t)mc_dec(cmd.params[0], 0, 32);
 267         return 0;
 268 }
 269
 270 int dpmcp_clear_irq_status(struct fsl_mc_io *mc_io,
 271                            uint16_t token,
 272                           uint8_t irq_index,
 273                           uint32_t status)
 274 {
 275         struct mc_command cmd = { 0 };
 276
 277         /* prepare command */
 278         cmd.header = mc_encode_cmd_header(DPMCP_CMDID_CLEAR_IRQ_STATUS,
 279                                           MC_CMD_PRI_LOW, token);
 280         cmd.params[0] |= mc_enc(0, 32, status);
 281         cmd.params[0] |= mc_enc(32, 8, irq_index);
 282
 283         /* send command to mc*/
 284         return mc_send_command(mc_io, &cmd);
 285 }
 286
 287 int dpmcp_get_attributes(struct fsl_mc_io *mc_io,
 288                          uint16_t token,
 289                         struct dpmcp_attr *attr)
 290 {
 291         struct mc_command cmd = { 0 };
 292         int err;
 293
 294         /* prepare command */
 295         cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_ATTR,
 296                                           MC_CMD_PRI_LOW, token);
 297
 298         /* send command to mc*/
 299         err = mc_send_command(mc_io, &cmd);
 300         if (err)
 301                 return err;
 302
 303         /* retrieve response parameters */
 304         attr->id = (int)mc_dec(cmd.params[0], 32, 32);
 305         attr->version.major = (uint16_t)mc_dec(cmd.params[1], 0, 16);
 306         attr->version.minor = (uint16_t)mc_dec(cmd.params[1], 16, 16);
 307         return 0;
 308 }