LXR uboot/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
  14int dprc_get_container_id(struct fsl_mc_io *mc_io,
  15                          uint32_t cmd_flags,
  16                          int *container_id)
  17{
  18        struct mc_command cmd = { 0 };
  19        int err;
  20
  21        /* prepare command */
  22        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONT_ID,
  23                                          cmd_flags,
  24                                          0);
  25
  26        /* send command to mc*/
  27        err = mc_send_command(mc_io, &cmd);
  28        if (err)
  29                return err;
  30
  31        /* retrieve response parameters */
  32        DPRC_RSP_GET_CONTAINER_ID(cmd, *container_id);
  33
  34        return 0;
  35}
  36
  37int dprc_open(struct fsl_mc_io *mc_io,
  38              uint32_t cmd_flags,
  39              int container_id,
  40              uint16_t *token)
  41{
  42        struct mc_command cmd = { 0 };
  43        int err;
  44
  45        /* prepare command */
  46        cmd.header = mc_encode_cmd_header(DPRC_CMDID_OPEN, cmd_flags,
  47                                          0);
  48        DPRC_CMD_OPEN(cmd, container_id);
  49
  50        /* send command to mc*/
  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.header);
  57
  58        return 0;
  59}
  60
  61int dprc_close(struct fsl_mc_io *mc_io,
  62               uint32_t cmd_flags,
  63               uint16_t token)
  64{
  65        struct mc_command cmd = { 0 };
  66
  67        /* prepare command */
  68        cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLOSE, cmd_flags,
  69                                          token);
  70
  71        /* send command to mc*/
  72        return mc_send_command(mc_io, &cmd);
  73}
  74
  75int dprc_create_container(struct fsl_mc_io *mc_io,
  76                          uint32_t cmd_flags,
  77                          uint16_t token,
  78                          struct dprc_cfg *cfg,
  79                          int *child_container_id,
  80                          uint64_t *child_portal_paddr)
  81{
  82        struct mc_command cmd = { 0 };
  83        int err;
  84
  85        /* prepare command */
  86        DPRC_CMD_CREATE_CONTAINER(cmd, cfg);
  87
  88        cmd.header = mc_encode_cmd_header(DPRC_CMDID_CREATE_CONT,
  89                                          cmd_flags,
  90                                          token);
  91
  92        /* send command to mc*/
  93        err = mc_send_command(mc_io, &cmd);
  94        if (err)
  95                return err;
  96
  97        /* retrieve response parameters */
  98        DPRC_RSP_CREATE_CONTAINER(cmd, *child_container_id,
  99                                  *child_portal_paddr);
 100
 101        return 0;
 102}
 103
 104int dprc_destroy_container(struct fsl_mc_io *mc_io,
 105                           uint32_t cmd_flags,
 106                           uint16_t token,
 107                           int child_container_id)
 108{
 109        struct mc_command cmd = { 0 };
 110
 111        /* prepare command */
 112        cmd.header = mc_encode_cmd_header(DPRC_CMDID_DESTROY_CONT,
 113                                          cmd_flags,
 114                                          token);
 115        DPRC_CMD_DESTROY_CONTAINER(cmd, child_container_id);
 116
 117        /* send command to mc*/
 118        return mc_send_command(mc_io, &cmd);
 119}
 120
 121int dprc_reset_container(struct fsl_mc_io *mc_io,
 122                         uint32_t cmd_flags,
 123                         uint16_t token,
 124                         int child_container_id)
 125{
 126        struct mc_command cmd = { 0 };
 127
 128        /* prepare command */
 129        cmd.header = mc_encode_cmd_header(DPRC_CMDID_RESET_CONT,
 130                                          cmd_flags,
 131                                          token);
 132        DPRC_CMD_RESET_CONTAINER(cmd, child_container_id);
 133
 134        /* send command to mc*/
 135        return mc_send_command(mc_io, &cmd);
 136}
 137
 138int dprc_get_attributes(struct fsl_mc_io *mc_io,
 139                        uint32_t cmd_flags,
 140                        uint16_t token,
 141                        struct dprc_attributes *attr)
 142{
 143        struct mc_command cmd = { 0 };
 144        int err;
 145
 146        /* prepare command */
 147        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_ATTR,
 148                                          cmd_flags,
 149                                          token);
 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        DPRC_RSP_GET_ATTRIBUTES(cmd, attr);
 158
 159        return 0;
 160}
 161
 162int dprc_get_obj_count(struct fsl_mc_io *mc_io,
 163                       uint32_t cmd_flags,
 164                       uint16_t token,
 165                       int *obj_count)
 166{
 167        struct mc_command cmd = { 0 };
 168        int err;
 169
 170        /* prepare command */
 171        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_COUNT,
 172                                          cmd_flags,
 173                                          token);
 174
 175        /* send command to mc*/
 176        err = mc_send_command(mc_io, &cmd);
 177        if (err)
 178                return err;
 179
 180        /* retrieve response parameters */
 181        DPRC_RSP_GET_OBJ_COUNT(cmd, *obj_count);
 182
 183        return 0;
 184}
 185
 186int dprc_get_obj(struct fsl_mc_io *mc_io,
 187                 uint32_t cmd_flags,
 188                 uint16_t token,
 189                 int obj_index,
 190                 struct dprc_obj_desc *obj_desc)
 191{
 192        struct mc_command cmd = { 0 };
 193        int err;
 194
 195        /* prepare command */
 196        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ,
 197                                          cmd_flags,
 198                                          token);
 199        DPRC_CMD_GET_OBJ(cmd, obj_index);
 200
 201        /* send command to mc*/
 202        err = mc_send_command(mc_io, &cmd);
 203        if (err)
 204                return err;
 205
 206        /* retrieve response parameters */
 207        DPRC_RSP_GET_OBJ(cmd, obj_desc);
 208
 209        return 0;
 210}
 211
 212int dprc_get_res_count(struct fsl_mc_io *mc_io,
 213                       uint32_t cmd_flags,
 214                       uint16_t token,
 215                       char *type,
 216                       int *res_count)
 217{
 218        struct mc_command cmd = { 0 };
 219        int err;
 220
 221        *res_count = 0;
 222
 223        /* prepare command */
 224        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_COUNT,
 225                                          cmd_flags,
 226                                          token);
 227        DPRC_CMD_GET_RES_COUNT(cmd, type);
 228
 229        /* send command to mc*/
 230        err = mc_send_command(mc_io, &cmd);
 231        if (err)
 232                return err;
 233
 234        /* retrieve response parameters */
 235        DPRC_RSP_GET_RES_COUNT(cmd, *res_count);
 236
 237        return 0;
 238}
 239
 240int dprc_get_res_ids(struct fsl_mc_io *mc_io,
 241                     uint32_t cmd_flags,
 242                     uint16_t token,
 243                     char *type,
 244                     struct dprc_res_ids_range_desc *range_desc)
 245{
 246        struct mc_command cmd = { 0 };
 247        int err;
 248
 249        /* prepare command */
 250        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_IDS,
 251                                          cmd_flags,
 252                                          token);
 253        DPRC_CMD_GET_RES_IDS(cmd, range_desc, type);
 254
 255        /* send command to mc*/
 256        err = mc_send_command(mc_io, &cmd);
 257        if (err)
 258                return err;
 259
 260        /* retrieve response parameters */
 261        DPRC_RSP_GET_RES_IDS(cmd, range_desc);
 262
 263        return 0;
 264}
 265
 266int dprc_get_obj_region(struct fsl_mc_io *mc_io,
 267                        uint32_t cmd_flags,
 268                        uint16_t token,
 269                        char *obj_type,
 270                        int obj_id,
 271                        uint8_t region_index,
 272                        struct dprc_region_desc *region_desc)
 273{
 274        struct mc_command cmd = { 0 };
 275        int err;
 276
 277        /* prepare command */
 278        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG,
 279                                          cmd_flags,
 280                                          token);
 281        DPRC_CMD_GET_OBJ_REGION(cmd, obj_type, obj_id, region_index);
 282
 283        /* send command to mc*/
 284        err = mc_send_command(mc_io, &cmd);
 285        if (err)
 286                return err;
 287
 288        /* retrieve response parameters */
 289        DPRC_RSP_GET_OBJ_REGION(cmd, region_desc);
 290
 291        return 0;
 292}
 293
 294int dprc_connect(struct fsl_mc_io *mc_io,
 295                 uint32_t cmd_flags,
 296                 uint16_t token,
 297                 const struct dprc_endpoint *endpoint1,
 298                 const struct dprc_endpoint *endpoint2,
 299                 const struct dprc_connection_cfg *cfg)
 300{
 301        struct mc_command cmd = { 0 };
 302
 303        /* prepare command */
 304        cmd.header = mc_encode_cmd_header(DPRC_CMDID_CONNECT,
 305                                          cmd_flags,
 306                                          token);
 307        DPRC_CMD_CONNECT(cmd, endpoint1, endpoint2, cfg);
 308
 309        /* send command to mc*/
 310        return mc_send_command(mc_io, &cmd);
 311}
 312
 313int dprc_disconnect(struct fsl_mc_io *mc_io,
 314                    uint32_t cmd_flags,
 315                    uint16_t token,
 316                    const struct dprc_endpoint *endpoint)
 317{
 318        struct mc_command cmd = { 0 };
 319
 320        /* prepare command */
 321        cmd.header = mc_encode_cmd_header(DPRC_CMDID_DISCONNECT,
 322                                          cmd_flags,
 323                                          token);
 324        DPRC_CMD_DISCONNECT(cmd, endpoint);
 325
 326        /* send command to mc*/
 327        return mc_send_command(mc_io, &cmd);
 328}
 329
 330int dprc_get_connection(struct fsl_mc_io *mc_io,
 331                        uint32_t cmd_flags,
 332                        uint16_t token,
 333                        const struct dprc_endpoint *endpoint1,
 334                        struct dprc_endpoint *endpoint2,
 335                        int *state)
 336{
 337        struct mc_command cmd = { 0 };
 338        int err;
 339
 340        /* prepare command */
 341        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONNECTION,
 342                                          cmd_flags,
 343                                          token);
 344        DPRC_CMD_GET_CONNECTION(cmd, endpoint1);
 345
 346        /* send command to mc*/
 347        err = mc_send_command(mc_io, &cmd);
 348        if (err)
 349                return err;
 350
 351        /* retrieve response parameters */
 352        DPRC_RSP_GET_CONNECTION(cmd, endpoint2, *state);
 353
 354        return 0;
 355}
 356