1 /* 2 * Freescale Layerscape MC I/O wrapper 3 * 4 * Copyright (C) 2015 Freescale Semiconductor, Inc. 5 * Author: Prabhakar Kushwaha <prabhakar@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_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 uint32_t cmd_flags, 55 const struct dpmac_cfg *cfg, 56 uint16_t *token) 57 { 58 struct mc_command cmd = { 0 }; 59 int err; 60 61 /* prepare command */ 62 cmd.header = mc_encode_cmd_header(DPMAC_CMDID_CREATE, 63 cmd_flags, 64 0); 65 DPMAC_CMD_CREATE(cmd, cfg); 66 67 /* send command to mc*/ 68 err = mc_send_command(mc_io, &cmd); 69 if (err) 70 return err; 71 72 /* retrieve response parameters */ 73 *token = MC_CMD_HDR_READ_TOKEN(cmd.header); 74 75 return 0; 76 } 77 78 int dpmac_destroy(struct fsl_mc_io *mc_io, 79 uint32_t cmd_flags, 80 uint16_t token) 81 { 82 struct mc_command cmd = { 0 }; 83 84 /* prepare command */ 85 cmd.header = mc_encode_cmd_header(DPMAC_CMDID_DESTROY, 86 cmd_flags, 87 token); 88 89 /* send command to mc*/ 90 return mc_send_command(mc_io, &cmd); 91 } 92 93 int dpmac_get_attributes(struct fsl_mc_io *mc_io, 94 uint32_t cmd_flags, 95 uint16_t token, 96 struct dpmac_attr *attr) 97 { 98 struct mc_command cmd = { 0 }; 99 int err; 100 101 /* prepare command */ 102 cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_ATTR, 103 cmd_flags, 104 token); 105 106 /* send command to mc*/ 107 err = mc_send_command(mc_io, &cmd); 108 if (err) 109 return err; 110 111 /* retrieve response parameters */ 112 DPMAC_RSP_GET_ATTRIBUTES(cmd, attr); 113 114 return 0; 115 } 116 117 int dpmac_mdio_read(struct fsl_mc_io *mc_io, 118 uint32_t cmd_flags, 119 uint16_t token, 120 struct dpmac_mdio_cfg *cfg) 121 { 122 struct mc_command cmd = { 0 }; 123 int err; 124 125 /* prepare command */ 126 cmd.header = mc_encode_cmd_header(DPMAC_CMDID_MDIO_READ, 127 cmd_flags, 128 token); 129 DPMAC_CMD_MDIO_READ(cmd, cfg); 130 131 /* send command to mc*/ 132 err = mc_send_command(mc_io, &cmd); 133 if (err) 134 return err; 135 136 /* retrieve response parameters */ 137 DPMAC_RSP_MDIO_READ(cmd, cfg->data); 138 139 return 0; 140 } 141 142 int dpmac_mdio_write(struct fsl_mc_io *mc_io, 143 uint32_t cmd_flags, 144 uint16_t token, 145 struct dpmac_mdio_cfg *cfg) 146 { 147 struct mc_command cmd = { 0 }; 148 149 /* prepare command */ 150 cmd.header = mc_encode_cmd_header(DPMAC_CMDID_MDIO_WRITE, 151 cmd_flags, 152 token); 153 DPMAC_CMD_MDIO_WRITE(cmd, cfg); 154 155 /* send command to mc*/ 156 return mc_send_command(mc_io, &cmd); 157 } 158 159 int dpmac_get_link_cfg(struct fsl_mc_io *mc_io, 160 uint32_t cmd_flags, 161 uint16_t token, 162 struct dpmac_link_cfg *cfg) 163 { 164 struct mc_command cmd = { 0 }; 165 int err = 0; 166 167 /* prepare command */ 168 cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_LINK_CFG, 169 cmd_flags, 170 token); 171 172 /* send command to mc*/ 173 err = mc_send_command(mc_io, &cmd); 174 if (err) 175 return err; 176 177 DPMAC_RSP_GET_LINK_CFG(cmd, cfg); 178 179 return 0; 180 } 181 182 int dpmac_set_link_state(struct fsl_mc_io *mc_io, 183 uint32_t cmd_flags, 184 uint16_t token, 185 struct dpmac_link_state *link_state) 186 { 187 struct mc_command cmd = { 0 }; 188 189 /* prepare command */ 190 cmd.header = mc_encode_cmd_header(DPMAC_CMDID_SET_LINK_STATE, 191 cmd_flags, 192 token); 193 DPMAC_CMD_SET_LINK_STATE(cmd, link_state); 194 195 /* send command to mc*/ 196 return mc_send_command(mc_io, &cmd); 197 } 198 199 int dpmac_get_counter(struct fsl_mc_io *mc_io, 200 uint32_t cmd_flags, 201 uint16_t token, 202 enum dpmac_counter type, 203 uint64_t *counter) 204 { 205 struct mc_command cmd = { 0 }; 206 int err = 0; 207 208 /* prepare command */ 209 cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_COUNTER, 210 cmd_flags, 211 token); 212 DPMAC_CMD_GET_COUNTER(cmd, type); 213 214 /* send command to mc*/ 215 err = mc_send_command(mc_io, &cmd); 216 if (err) 217 return err; 218 219 DPMAC_RSP_GET_COUNTER(cmd, *counter); 220 221 return 0; 222 } 223