1 /*
2 * Copyright (c) 2021 IP-Logix Inc.
3 * Copyright 2023 NXP
4 *
5 * SPDX-License-Identifier: Apache-2.0
6 */
7
8 #include <zephyr/shell/shell.h>
9 #include <stdlib.h>
10 #include <zephyr/drivers/mdio.h>
11 #include <string.h>
12 #include <zephyr/sys/util.h>
13 #include <zephyr/devicetree.h>
14
15 #include <zephyr/logging/log.h>
16 LOG_MODULE_REGISTER(mdio_shell, CONFIG_LOG_DEFAULT_LEVEL);
17
18 #if DT_HAS_COMPAT_STATUS_OKAY(atmel_sam_mdio)
19 #define DT_DRV_COMPAT atmel_sam_mdio
20 #elif DT_HAS_COMPAT_STATUS_OKAY(espressif_esp32_mdio)
21 #define DT_DRV_COMPAT espressif_esp32_mdio
22 #elif DT_HAS_COMPAT_STATUS_OKAY(nxp_imx_netc_emdio)
23 #define DT_DRV_COMPAT nxp_imx_netc_emdio
24 #elif DT_HAS_COMPAT_STATUS_OKAY(nxp_s32_netc_emdio)
25 #define DT_DRV_COMPAT nxp_s32_netc_emdio
26 #elif DT_HAS_COMPAT_STATUS_OKAY(nxp_s32_gmac_mdio)
27 #define DT_DRV_COMPAT nxp_s32_gmac_mdio
28 #elif DT_HAS_COMPAT_STATUS_OKAY(adi_adin2111_mdio)
29 #define DT_DRV_COMPAT adi_adin2111_mdio
30 #elif DT_HAS_COMPAT_STATUS_OKAY(smsc_lan91c111_mdio)
31 #define DT_DRV_COMPAT smsc_lan91c111_mdio
32 #elif DT_HAS_COMPAT_STATUS_OKAY(zephyr_mdio_gpio)
33 #define DT_DRV_COMPAT zephyr_mdio_gpio
34 #elif DT_HAS_COMPAT_STATUS_OKAY(nxp_enet_mdio)
35 #define DT_DRV_COMPAT nxp_enet_mdio
36 #elif DT_HAS_COMPAT_STATUS_OKAY(infineon_xmc4xxx_mdio)
37 #define DT_DRV_COMPAT infineon_xmc4xxx_mdio
38 #elif DT_HAS_COMPAT_STATUS_OKAY(nxp_enet_qos_mdio)
39 #define DT_DRV_COMPAT nxp_enet_qos_mdio
40 #elif DT_HAS_COMPAT_STATUS_OKAY(litex_liteeth_mdio)
41 #define DT_DRV_COMPAT litex_liteeth_mdio
42 #elif DT_HAS_COMPAT_STATUS_OKAY(st_stm32_mdio)
43 #define DT_DRV_COMPAT st_stm32_mdio
44 #elif DT_HAS_COMPAT_STATUS_OKAY(snps_dwcxgmac_mdio)
45 #define DT_DRV_COMPAT snps_dwcxgmac_mdio
46 #elif DT_HAS_COMPAT_STATUS_OKAY(sensry_sy1xx_mdio)
47 #define DT_DRV_COMPAT sensry_sy1xx_mdio
48 #else
49 #error "No known devicetree compatible match for MDIO shell"
50 #endif
51
52 #define MDIO_NODE_ID DT_COMPAT_GET_ANY_STATUS_OKAY(DT_DRV_COMPAT)
53
54 /*
55 * Scan the entire 5-bit address space of the MDIO bus
56 *
57 * scan [<reg_addr>]
58 */
cmd_mdio_scan(const struct shell * sh,size_t argc,char ** argv)59 static int cmd_mdio_scan(const struct shell *sh, size_t argc, char **argv)
60 {
61 const struct device *dev;
62 int cnt;
63 uint16_t data;
64 uint16_t reg_addr;
65
66 dev = DEVICE_DT_GET(MDIO_NODE_ID);
67 if (!device_is_ready(dev)) {
68 shell_error(sh, "MDIO: Device driver %s is not ready.", dev->name);
69
70 return -ENODEV;
71 }
72
73 if (argc >= 2) {
74 reg_addr = strtol(argv[1], NULL, 16);
75 } else {
76 reg_addr = 0;
77 }
78
79 shell_print(sh,
80 "Scanning bus for devices. Reading register 0x%x",
81 reg_addr);
82 cnt = 0;
83
84 mdio_bus_enable(dev);
85
86 for (int i = 0; i < 32; i++) {
87 data = 0;
88 if (mdio_read(dev, i, reg_addr, &data) >= 0 &&
89 data != UINT16_MAX) {
90 cnt++;
91 shell_print(sh, "Found MDIO device @ 0x%x", i);
92 }
93 }
94
95 mdio_bus_disable(dev);
96
97 shell_print(sh, "%u devices found on %s", cnt, dev->name);
98
99 return 0;
100 }
101
102 /* mdio write <port_addr> <reg_addr> <data> */
cmd_mdio_write(const struct shell * sh,size_t argc,char ** argv)103 static int cmd_mdio_write(const struct shell *sh, size_t argc, char **argv)
104 {
105 const struct device *dev;
106 uint16_t data;
107 uint16_t reg_addr;
108 uint16_t port_addr;
109
110 dev = DEVICE_DT_GET(MDIO_NODE_ID);
111 if (!device_is_ready(dev)) {
112 shell_error(sh, "MDIO: Device driver %s is not ready.", dev->name);
113
114 return -ENODEV;
115 }
116
117 port_addr = strtol(argv[1], NULL, 16);
118 reg_addr = strtol(argv[2], NULL, 16);
119 data = strtol(argv[3], NULL, 16);
120
121 mdio_bus_enable(dev);
122
123 if (mdio_write(dev, port_addr, reg_addr, data) < 0) {
124 shell_error(sh, "Failed to write to device: %s", dev->name);
125 mdio_bus_disable(dev);
126
127 return -EIO;
128 }
129
130 mdio_bus_disable(dev);
131
132 return 0;
133 }
134
135 /* mdio read <port_addr> <reg_addr> */
cmd_mdio_read(const struct shell * sh,size_t argc,char ** argv)136 static int cmd_mdio_read(const struct shell *sh, size_t argc, char **argv)
137 {
138 const struct device *dev;
139 uint16_t data;
140 uint16_t reg_addr;
141 uint16_t port_addr;
142
143 dev = DEVICE_DT_GET(MDIO_NODE_ID);
144 if (!device_is_ready(dev)) {
145 shell_error(sh, "MDIO: Device driver %s is not ready.", dev->name);
146
147 return -ENODEV;
148 }
149
150 port_addr = strtol(argv[1], NULL, 16);
151 reg_addr = strtol(argv[2], NULL, 16);
152
153 mdio_bus_enable(dev);
154
155 if (mdio_read(dev, port_addr, reg_addr, &data) < 0) {
156 shell_error(sh, "Failed to read from device: %s", dev->name);
157 mdio_bus_disable(dev);
158
159 return -EIO;
160 }
161
162 mdio_bus_disable(dev);
163
164 shell_print(sh, "%x[%x]: 0x%x", port_addr, reg_addr, data);
165
166 return 0;
167 }
168
169 /* mdio write_c45 <port_addr> <dev_addr> <reg_addr> <value> */
cmd_mdio_write_45(const struct shell * sh,size_t argc,char ** argv)170 static int cmd_mdio_write_45(const struct shell *sh, size_t argc, char **argv)
171 {
172 const struct device *dev;
173 uint16_t data;
174 uint16_t reg_addr;
175 uint8_t dev_addr;
176 uint8_t port_addr;
177
178 dev = DEVICE_DT_GET(MDIO_NODE_ID);
179 if (!device_is_ready(dev)) {
180 shell_error(sh, "MDIO: Device driver %s is not ready.", dev->name);
181
182 return -ENODEV;
183 }
184
185 port_addr = strtol(argv[1], NULL, 16);
186 dev_addr = strtol(argv[2], NULL, 16);
187 reg_addr = strtol(argv[3], NULL, 16);
188 data = strtol(argv[4], NULL, 16);
189
190 mdio_bus_enable(dev);
191
192 if (mdio_write_c45(dev, port_addr, dev_addr, reg_addr, data) < 0) {
193 shell_error(sh, "Failed to write to device: %s", dev->name);
194 mdio_bus_disable(dev);
195
196 return -EIO;
197 }
198
199 mdio_bus_disable(dev);
200
201 return 0;
202 }
203
204 /* mdio read_c45 <port_addr> <dev_addr> <reg_addr> */
cmd_mdio_read_c45(const struct shell * sh,size_t argc,char ** argv)205 static int cmd_mdio_read_c45(const struct shell *sh, size_t argc, char **argv)
206 {
207 const struct device *dev;
208 uint16_t data;
209 uint16_t reg_addr;
210 uint8_t dev_addr;
211 uint8_t port_addr;
212
213 dev = DEVICE_DT_GET(MDIO_NODE_ID);
214 if (!device_is_ready(dev)) {
215 shell_error(sh, "MDIO: Device driver %s is not ready.", dev->name);
216
217 return -ENODEV;
218 }
219
220 port_addr = strtol(argv[1], NULL, 16);
221 dev_addr = strtol(argv[2], NULL, 16);
222 reg_addr = strtol(argv[3], NULL, 16);
223
224 mdio_bus_enable(dev);
225
226 if (mdio_read_c45(dev, port_addr, dev_addr, reg_addr, &data) < 0) {
227 shell_error(sh, "Failed to read from device: %s", dev->name);
228 mdio_bus_disable(dev);
229
230 return -EIO;
231 }
232
233 mdio_bus_disable(dev);
234
235 shell_print(sh, "%x[%x:%x]: 0x%x", port_addr, dev_addr, reg_addr, data);
236
237 return 0;
238 }
239
240 SHELL_STATIC_SUBCMD_SET_CREATE(sub_mdio_cmds,
241 SHELL_CMD_ARG(scan, NULL,
242 "Scan MDIO bus for devices: scan [<reg_addr>]",
243 cmd_mdio_scan, 0, 1),
244 SHELL_CMD_ARG(read, NULL,
245 "Read from MDIO device: read <phy_addr> <reg_addr>",
246 cmd_mdio_read, 3, 0),
247 SHELL_CMD_ARG(write, NULL,
248 "Write to MDIO device: write <phy_addr> <reg_addr> <value>",
249 cmd_mdio_write, 4, 0),
250 SHELL_CMD_ARG(read_c45, NULL,
251 "Read from MDIO Clause 45 device: "
252 "read_c45 <port_addr> <dev_addr> <reg_addr>",
253 cmd_mdio_read_c45, 4, 0),
254 SHELL_CMD_ARG(write_c45, NULL,
255 "Write to MDIO Clause 45 device: "
256 "write_c45 <port_addr> <dev_addr> <reg_addr> <value>",
257 cmd_mdio_write_45, 5, 0),
258 SHELL_SUBCMD_SET_END /* Array terminated. */
259 );
260
261 SHELL_CMD_REGISTER(mdio, &sub_mdio_cmds, "MDIO commands", NULL);
262
