drivers/net/fsl-mc/dpmac.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Freescale Layerscape MC I/O wrapper
   4  *
   5  * Copyright 2015-2016 Freescale Semiconductor, Inc.
   6  * Copyright 2017 NXP
   7  * Author: Prabhakar Kushwaha <prabhakar@freescale.com>
   8  */
   9
  10 #include <fsl-mc/fsl_mc_sys.h>
  11 #include <fsl-mc/fsl_mc_cmd.h>
  12 #include <fsl-mc/fsl_dpmac.h>
  13
  14 int dpmac_open(struct fsl_mc_io *mc_io,
  15                uint32_t cmd_flags,
  16                int dpmac_id,
  17                uint16_t *token)
  18 {
  19         struct mc_command cmd = { 0 };
  20         int err;
  21
  22         /* prepare command */
  23         cmd.header = mc_encode_cmd_header(DPMAC_CMDID_OPEN,
  24                                           cmd_flags,
  25                                           0);
  26         DPMAC_CMD_OPEN(cmd, dpmac_id);
  27
  28         /* send command to mc*/
  29         err = mc_send_command(mc_io, &cmd);
  30         if (err)
  31                 return err;
  32
  33         /* retrieve response parameters */
  34         *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
  35
  36         return err;
  37 }
  38
  39 int dpmac_close(struct fsl_mc_io *mc_io,
  40                 uint32_t cmd_flags,
  41                 uint16_t token)
  42 {
  43         struct mc_command cmd = { 0 };
  44
  45         /* prepare command */
  46         cmd.header = mc_encode_cmd_header(DPMAC_CMDID_CLOSE, cmd_flags,
  47                                           token);
  48
  49         /* send command to mc*/
  50         return mc_send_command(mc_io, &cmd);
  51 }
  52
  53 int dpmac_create(struct fsl_mc_io *mc_io,
  54                  uint16_t dprc_token,
  55                  uint32_t cmd_flags,
  56                  const struct dpmac_cfg *cfg,
  57                  uint32_t *obj_id)
  58 {
  59         struct mc_command cmd = { 0 };
  60         int err;
  61
  62         /* prepare command */
  63         cmd.header = mc_encode_cmd_header(DPMAC_CMDID_CREATE,
  64                                           cmd_flags,
  65                                           dprc_token);
  66         DPMAC_CMD_CREATE(cmd, cfg);
  67
  68         /* send command to mc*/
  69         err = mc_send_command(mc_io, &cmd);
  70         if (err)
  71                 return err;
  72
  73         /* retrieve response parameters */
  74         MC_CMD_READ_OBJ_ID(cmd, *obj_id);
  75
  76         return 0;
  77 }
  78
  79 int dpmac_destroy(struct fsl_mc_io *mc_io,
  80                   uint16_t dprc_token,
  81                   uint32_t cmd_flags,
  82                   uint32_t obj_id)
  83 {
  84         struct mc_command cmd = { 0 };
  85
  86         /* prepare command */
  87         cmd.header = mc_encode_cmd_header(DPMAC_CMDID_DESTROY,
  88                                           cmd_flags,
  89                                           dprc_token);
  90
  91         /* set object id to destroy */
  92         CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, obj_id);
  93
  94         /* send command to mc*/
  95         return mc_send_command(mc_io, &cmd);
  96 }
  97
  98 int dpmac_get_attributes(struct fsl_mc_io *mc_io,
  99                          uint32_t cmd_flags,
 100                          uint16_t token,
 101                          struct dpmac_attr *attr)
 102 {
 103         struct mc_command cmd = { 0 };
 104         int err;
 105
 106         /* prepare command */
 107         cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_ATTR,
 108                                           cmd_flags,
 109                                           token);
 110
 111         /* send command to mc*/
 112         err = mc_send_command(mc_io, &cmd);
 113         if (err)
 114                 return err;
 115
 116         /* retrieve response parameters */
 117         DPMAC_RSP_GET_ATTRIBUTES(cmd, attr);
 118
 119         return 0;
 120 }
 121
 122 int dpmac_mdio_read(struct fsl_mc_io *mc_io,
 123                     uint32_t cmd_flags,
 124                     uint16_t token,
 125                     struct dpmac_mdio_cfg *cfg)
 126 {
 127         struct mc_command cmd = { 0 };
 128         int err;
 129
 130         /* prepare command */
 131         cmd.header = mc_encode_cmd_header(DPMAC_CMDID_MDIO_READ,
 132                                           cmd_flags,
 133                                           token);
 134         DPMAC_CMD_MDIO_READ(cmd, cfg);
 135
 136         /* send command to mc*/
 137         err = mc_send_command(mc_io, &cmd);
 138         if (err)
 139                 return err;
 140
 141         /* retrieve response parameters */
 142         DPMAC_RSP_MDIO_READ(cmd, cfg->data);
 143
 144         return 0;
 145 }
 146
 147 int dpmac_mdio_write(struct fsl_mc_io *mc_io,
 148                      uint32_t cmd_flags,
 149                      uint16_t token,
 150                      struct dpmac_mdio_cfg *cfg)
 151 {
 152         struct mc_command cmd = { 0 };
 153
 154         /* prepare command */
 155         cmd.header = mc_encode_cmd_header(DPMAC_CMDID_MDIO_WRITE,
 156                                           cmd_flags,
 157                                           token);
 158         DPMAC_CMD_MDIO_WRITE(cmd, cfg);
 159
 160         /* send command to mc*/
 161         return mc_send_command(mc_io, &cmd);
 162 }
 163
 164 int dpmac_get_link_cfg(struct fsl_mc_io *mc_io,
 165                        uint32_t cmd_flags,
 166                        uint16_t token,
 167                        struct dpmac_link_cfg *cfg)
 168 {
 169         struct mc_command cmd = { 0 };
 170         int err = 0;
 171
 172         /* prepare command */
 173         cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_LINK_CFG,
 174                                           cmd_flags,
 175                                           token);
 176
 177         /* send command to mc*/
 178         err = mc_send_command(mc_io, &cmd);
 179         if (err)
 180                 return err;
 181
 182         DPMAC_RSP_GET_LINK_CFG(cmd, cfg);
 183
 184         return 0;
 185 }
 186
 187 int dpmac_set_link_state(struct fsl_mc_io *mc_io,
 188                          uint32_t cmd_flags,
 189                          uint16_t token,
 190                          struct dpmac_link_state *link_state)
 191 {
 192         struct mc_command cmd = { 0 };
 193
 194         /* prepare command */
 195         cmd.header = mc_encode_cmd_header(DPMAC_CMDID_SET_LINK_STATE,
 196                                           cmd_flags,
 197                                           token);
 198         DPMAC_CMD_SET_LINK_STATE(cmd, link_state);
 199
 200         /* send command to mc*/
 201         return mc_send_command(mc_io, &cmd);
 202 }
 203
 204 int dpmac_get_counter(struct fsl_mc_io *mc_io,
 205                       uint32_t cmd_flags,
 206                       uint16_t token,
 207                       enum dpmac_counter type,
 208                       uint64_t *counter)
 209 {
 210         struct mc_command cmd = { 0 };
 211         int err = 0;
 212
 213         /* prepare command */
 214         cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_COUNTER,
 215                                           cmd_flags,
 216                                           token);
 217         DPMAC_CMD_GET_COUNTER(cmd, type);
 218
 219         /* send command to mc*/
 220         err = mc_send_command(mc_io, &cmd);
 221         if (err)
 222                 return err;
 223
 224         DPMAC_RSP_GET_COUNTER(cmd, *counter);
 225
 226         return 0;
 227 }
 228
 229 int dpmac_get_api_version(struct fsl_mc_io *mc_io,
 230                          u32 cmd_flags,
 231                          u16 *major_ver,
 232                          u16 *minor_ver)
 233 {
 234         struct mc_command cmd = { 0 };
 235         int err;
 236
 237         /* prepare command */
 238         cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_API_VERSION,
 239                                           cmd_flags, 0);
 240
 241         /* send command to mc */
 242         err = mc_send_command(mc_io, &cmd);
 243         if (err)
 244                 return err;
 245
 246         /* retrieve response parameters */
 247         mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
 248
 249         return 0;
 250 }