git.sur5r.net Git - u-boot/blob - drivers/net/fsl-mc/dprc.c

   1 /*
   2  * Freescale Layerscape MC I/O wrapper
   3  *
   4  * Copyright (C) 2013-2015 Freescale Semiconductor, Inc.
   5  * Author: German Rivera <German.Rivera@freescale.com>
   6  *
   7  * SPDX-License-Identifier:     GPL-2.0+
   8  */
   9
  10 #include <fsl-mc/fsl_mc_sys.h>
  11 #include <fsl-mc/fsl_mc_cmd.h>
  12 #include <fsl-mc/fsl_dprc.h>
  13
  14 int dprc_get_container_id(struct fsl_mc_io *mc_io, int *container_id)
  15 {
  16         struct mc_command cmd = { 0 };
  17         int err;
  18
  19         /* prepare command */
  20         cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONT_ID,
  21                                           MC_CMD_PRI_LOW, 0);
  22
  23         /* send command to mc*/
  24         err = mc_send_command(mc_io, &cmd);
  25         if (err)
  26                 return err;
  27
  28         /* retrieve response parameters */
  29         DPRC_RSP_GET_CONTAINER_ID(cmd, *container_id);
  30
  31         return 0;
  32 }
  33
  34 int dprc_open(struct fsl_mc_io *mc_io, int container_id, uint16_t *token)
  35 {
  36         struct mc_command cmd = { 0 };
  37         int err;
  38
  39         /* prepare command */
  40         cmd.header = mc_encode_cmd_header(DPRC_CMDID_OPEN, MC_CMD_PRI_LOW,
  41                                           0);
  42         DPRC_CMD_OPEN(cmd, container_id);
  43
  44         /* send command to mc*/
  45         err = mc_send_command(mc_io, &cmd);
  46         if (err)
  47                 return err;
  48
  49         /* retrieve response parameters */
  50         *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
  51
  52         return 0;
  53 }
  54
  55 int dprc_close(struct fsl_mc_io *mc_io, uint16_t token)
  56 {
  57         struct mc_command cmd = { 0 };
  58
  59         /* prepare command */
  60         cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLOSE, MC_CMD_PRI_HIGH,
  61                                           token);
  62
  63         /* send command to mc*/
  64         return mc_send_command(mc_io, &cmd);
  65 }
  66
  67 int dprc_reset_container(struct fsl_mc_io *mc_io,
  68                          uint16_t token,
  69                          int child_container_id)
  70 {
  71         struct mc_command cmd = { 0 };
  72
  73         /* prepare command */
  74         cmd.header = mc_encode_cmd_header(DPRC_CMDID_RESET_CONT,
  75                                           MC_CMD_PRI_LOW, token);
  76         DPRC_CMD_RESET_CONTAINER(cmd, child_container_id);
  77
  78         /* send command to mc*/
  79         return mc_send_command(mc_io, &cmd);
  80 }
  81
  82 int dprc_get_attributes(struct fsl_mc_io *mc_io,
  83                         uint16_t token,
  84                         struct dprc_attributes *attr)
  85 {
  86         struct mc_command cmd = { 0 };
  87         int err;
  88
  89         /* prepare command */
  90         cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_ATTR,
  91                                           MC_CMD_PRI_LOW,
  92                                           token);
  93
  94         /* send command to mc*/
  95         err = mc_send_command(mc_io, &cmd);
  96         if (err)
  97                 return err;
  98
  99         /* retrieve response parameters */
 100         DPRC_RSP_GET_ATTRIBUTES(cmd, attr);
 101
 102         return 0;
 103 }
 104
 105 int dprc_get_obj_count(struct fsl_mc_io *mc_io, uint16_t token, int *obj_count)
 106 {
 107         struct mc_command cmd = { 0 };
 108         int err;
 109
 110         /* prepare command */
 111         cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_COUNT,
 112                                           MC_CMD_PRI_LOW, token);
 113
 114         /* send command to mc*/
 115         err = mc_send_command(mc_io, &cmd);
 116         if (err)
 117                 return err;
 118
 119         /* retrieve response parameters */
 120         DPRC_RSP_GET_OBJ_COUNT(cmd, *obj_count);
 121
 122         return 0;
 123 }
 124
 125 int dprc_get_obj(struct fsl_mc_io *mc_io,
 126                  uint16_t token,
 127                  int obj_index,
 128                  struct dprc_obj_desc *obj_desc)
 129 {
 130         struct mc_command cmd = { 0 };
 131         int err;
 132
 133         /* prepare command */
 134         cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ,
 135                                           MC_CMD_PRI_LOW,
 136                                           token);
 137         DPRC_CMD_GET_OBJ(cmd, obj_index);
 138
 139         /* send command to mc*/
 140         err = mc_send_command(mc_io, &cmd);
 141         if (err)
 142                 return err;
 143
 144         /* retrieve response parameters */
 145         DPRC_RSP_GET_OBJ(cmd, obj_desc);
 146
 147         return 0;
 148 }
 149
 150 int dprc_get_res_count(struct fsl_mc_io *mc_io,
 151                        uint16_t token,
 152                        char *type,
 153                        int *res_count)
 154 {
 155         struct mc_command cmd = { 0 };
 156         int err;
 157
 158         *res_count = 0;
 159
 160         /* prepare command */
 161         cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_COUNT,
 162                                           MC_CMD_PRI_LOW, token);
 163         DPRC_CMD_GET_RES_COUNT(cmd, type);
 164
 165         /* send command to mc*/
 166         err = mc_send_command(mc_io, &cmd);
 167         if (err)
 168                 return err;
 169
 170         /* retrieve response parameters */
 171         DPRC_RSP_GET_RES_COUNT(cmd, *res_count);
 172
 173         return 0;
 174 }
 175
 176 int dprc_get_res_ids(struct fsl_mc_io *mc_io,
 177                      uint16_t token,
 178                      char *type,
 179                      struct dprc_res_ids_range_desc *range_desc)
 180 {
 181         struct mc_command cmd = { 0 };
 182         int err;
 183
 184         /* prepare command */
 185         cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_IDS,
 186                                           MC_CMD_PRI_LOW, token);
 187         DPRC_CMD_GET_RES_IDS(cmd, range_desc, type);
 188
 189         /* send command to mc*/
 190         err = mc_send_command(mc_io, &cmd);
 191         if (err)
 192                 return err;
 193
 194         /* retrieve response parameters */
 195         DPRC_RSP_GET_RES_IDS(cmd, range_desc);
 196
 197         return 0;
 198 }
 199
 200 int dprc_get_obj_region(struct fsl_mc_io *mc_io,
 201                         uint16_t token,
 202                         char *obj_type,
 203                         int obj_id,
 204                         uint8_t region_index,
 205                         struct dprc_region_desc *region_desc)
 206 {
 207         struct mc_command cmd = { 0 };
 208         int err;
 209
 210         /* prepare command */
 211         cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG,
 212                                           MC_CMD_PRI_LOW, token);
 213         DPRC_CMD_GET_OBJ_REGION(cmd, obj_type, obj_id, region_index);
 214
 215         /* send command to mc*/
 216         err = mc_send_command(mc_io, &cmd);
 217         if (err)
 218                 return err;
 219
 220         /* retrieve response parameters */
 221         DPRC_RSP_GET_OBJ_REGION(cmd, region_desc);
 222
 223         return 0;
 224 }
 225
 226 int dprc_connect(struct fsl_mc_io *mc_io,
 227                  uint16_t token,
 228                  const struct dprc_endpoint *endpoint1,
 229                  const struct dprc_endpoint *endpoint2)
 230 {
 231         struct mc_command cmd = { 0 };
 232
 233         /* prepare command */
 234         cmd.header = mc_encode_cmd_header(DPRC_CMDID_CONNECT,
 235                                           MC_CMD_PRI_LOW,
 236                                           token);
 237         DPRC_CMD_CONNECT(cmd, endpoint1, endpoint2);
 238
 239         /* send command to mc*/
 240         return mc_send_command(mc_io, &cmd);
 241 }
 242
 243 int dprc_disconnect(struct fsl_mc_io *mc_io,
 244                     uint16_t token,
 245                     const struct dprc_endpoint *endpoint)
 246 {
 247         struct mc_command cmd = { 0 };
 248
 249         /* prepare command */
 250         cmd.header = mc_encode_cmd_header(DPRC_CMDID_DISCONNECT,
 251                                           MC_CMD_PRI_LOW,
 252                                           token);
 253         DPRC_CMD_DISCONNECT(cmd, endpoint);
 254
 255         /* send command to mc*/
 256         return mc_send_command(mc_io, &cmd);
 257 }
 258
 259 int dprc_get_connection(struct fsl_mc_io *mc_io,
 260                         uint16_t token,
 261                                         const struct dprc_endpoint *endpoint1,
 262                                         struct dprc_endpoint *endpoint2,
 263                                         int *state)
 264 {
 265         struct mc_command cmd = { 0 };
 266         int err;
 267
 268         /* prepare command */
 269         cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONNECTION,
 270                                           MC_CMD_PRI_LOW,
 271                                           token);
 272         DPRC_CMD_GET_CONNECTION(cmd, endpoint1);
 273
 274         /* send command to mc*/
 275         err = mc_send_command(mc_io, &cmd);
 276         if (err)
 277                 return err;
 278
 279         /* retrieve response parameters */
 280         DPRC_RSP_GET_CONNECTION(cmd, endpoint2, *state);
 281
 282         return 0;
 283 }