]>
Commit | Line | Data |
---|---|---|
c3452b50 AM |
1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* | |
3 | * (C) Copyright 2019 | |
4 | * Alex Marginean, NXP | |
5 | */ | |
6 | ||
7 | #include <common.h> | |
8 | #include <dm.h> | |
f7ae49fc | 9 | #include <log.h> |
336d4615 | 10 | #include <malloc.h> |
c3452b50 AM |
11 | #include <miiphy.h> |
12 | #include <dm/device-internal.h> | |
336d4615 | 13 | #include <dm/device_compat.h> |
33aad0b0 | 14 | #include <dm/of_extra.h> |
c3452b50 | 15 | #include <dm/uclass-internal.h> |
336d4615 | 16 | #include <linux/compat.h> |
c3452b50 AM |
17 | |
18 | void dm_mdio_probe_devices(void) | |
19 | { | |
20 | struct udevice *it; | |
21 | struct uclass *uc; | |
22 | ||
23 | uclass_get(UCLASS_MDIO, &uc); | |
24 | uclass_foreach_dev(it, uc) { | |
25 | device_probe(it); | |
26 | } | |
27 | } | |
28 | ||
29 | static int dm_mdio_post_bind(struct udevice *dev) | |
30 | { | |
6b3abc04 AM |
31 | const char *dt_name; |
32 | ||
33 | /* set a custom name for the MDIO device, if present in DT */ | |
f10643cf SG |
34 | if (dev_has_ofnode(dev)) { |
35 | dt_name = dev_read_string(dev, "device-name"); | |
6b3abc04 AM |
36 | if (dt_name) { |
37 | debug("renaming dev %s to %s\n", dev->name, dt_name); | |
38 | device_set_name(dev, dt_name); | |
39 | } | |
40 | } | |
41 | ||
c3452b50 AM |
42 | /* |
43 | * MDIO command doesn't like spaces in names, don't allow them to keep | |
44 | * it happy | |
45 | */ | |
46 | if (strchr(dev->name, ' ')) { | |
47 | debug("\nError: MDIO device name \"%s\" has a space!\n", | |
48 | dev->name); | |
49 | return -EINVAL; | |
50 | } | |
51 | ||
f54002d7 TH |
52 | #if CONFIG_IS_ENABLED(OF_REAL) |
53 | return dm_scan_fdt_dev(dev); | |
54 | #else | |
c3452b50 | 55 | return 0; |
f54002d7 | 56 | #endif |
c3452b50 AM |
57 | } |
58 | ||
351bfa6e MB |
59 | int dm_mdio_read(struct udevice *mdio_dev, int addr, int devad, int reg) |
60 | { | |
61 | struct mdio_ops *ops = mdio_get_ops(mdio_dev); | |
62 | ||
63 | if (!ops->read) | |
64 | return -ENOSYS; | |
65 | ||
66 | return ops->read(mdio_dev, addr, devad, reg); | |
67 | } | |
68 | ||
69 | int dm_mdio_write(struct udevice *mdio_dev, int addr, int devad, int reg, | |
70 | u16 val) | |
71 | { | |
72 | struct mdio_ops *ops = mdio_get_ops(mdio_dev); | |
73 | ||
74 | if (!ops->write) | |
75 | return -ENOSYS; | |
76 | ||
77 | return ops->write(mdio_dev, addr, devad, reg, val); | |
78 | } | |
79 | ||
80 | int dm_mdio_reset(struct udevice *mdio_dev) | |
81 | { | |
82 | struct mdio_ops *ops = mdio_get_ops(mdio_dev); | |
83 | ||
84 | if (!ops->reset) | |
85 | return 0; | |
86 | ||
87 | return ops->reset(mdio_dev); | |
88 | } | |
89 | ||
c3452b50 AM |
90 | /* |
91 | * Following read/write/reset functions are registered with legacy MII code. | |
92 | * These are called for PHY operations by upper layers and we further call the | |
93 | * DM MDIO driver functions. | |
94 | */ | |
95 | static int mdio_read(struct mii_dev *mii_bus, int addr, int devad, int reg) | |
96 | { | |
1776a24b | 97 | return dm_mdio_read(mii_bus->priv, addr, devad, reg); |
c3452b50 AM |
98 | } |
99 | ||
100 | static int mdio_write(struct mii_dev *mii_bus, int addr, int devad, int reg, | |
101 | u16 val) | |
102 | { | |
1776a24b | 103 | return dm_mdio_write(mii_bus->priv, addr, devad, reg, val); |
c3452b50 AM |
104 | } |
105 | ||
106 | static int mdio_reset(struct mii_dev *mii_bus) | |
107 | { | |
1776a24b | 108 | return dm_mdio_reset(mii_bus->priv); |
c3452b50 AM |
109 | } |
110 | ||
111 | static int dm_mdio_post_probe(struct udevice *dev) | |
112 | { | |
113 | struct mdio_perdev_priv *pdata = dev_get_uclass_priv(dev); | |
114 | ||
115 | pdata->mii_bus = mdio_alloc(); | |
116 | pdata->mii_bus->read = mdio_read; | |
117 | pdata->mii_bus->write = mdio_write; | |
118 | pdata->mii_bus->reset = mdio_reset; | |
119 | pdata->mii_bus->priv = dev; | |
bf35c312 | 120 | strlcpy(pdata->mii_bus->name, dev->name, MDIO_NAME_LEN); |
c3452b50 AM |
121 | |
122 | return mdio_register(pdata->mii_bus); | |
123 | } | |
124 | ||
125 | static int dm_mdio_pre_remove(struct udevice *dev) | |
126 | { | |
127 | struct mdio_perdev_priv *pdata = dev_get_uclass_priv(dev); | |
c3452b50 | 128 | |
1776a24b | 129 | dm_mdio_reset(dev); |
c3452b50 AM |
130 | mdio_unregister(pdata->mii_bus); |
131 | mdio_free(pdata->mii_bus); | |
132 | ||
133 | return 0; | |
134 | } | |
135 | ||
00b1bad9 MB |
136 | struct phy_device *dm_phy_find_by_ofnode(ofnode phynode) |
137 | { | |
138 | struct mdio_perdev_priv *pdata; | |
139 | struct udevice *mdiodev; | |
140 | u32 phy_addr; | |
141 | ||
142 | if (ofnode_read_u32(phynode, "reg", &phy_addr)) | |
143 | return NULL; | |
144 | ||
145 | if (uclass_get_device_by_ofnode(UCLASS_MDIO, | |
146 | ofnode_get_parent(phynode), | |
147 | &mdiodev)) | |
148 | return NULL; | |
149 | ||
150 | if (device_probe(mdiodev)) | |
151 | return NULL; | |
152 | ||
153 | pdata = dev_get_uclass_priv(mdiodev); | |
154 | ||
155 | return phy_find_by_mask(pdata->mii_bus, BIT(phy_addr)); | |
156 | } | |
157 | ||
a5d32c37 | 158 | struct phy_device *dm_mdio_phy_connect(struct udevice *mdiodev, int phyaddr, |
c3452b50 AM |
159 | struct udevice *ethdev, |
160 | phy_interface_t interface) | |
161 | { | |
a5d32c37 | 162 | struct mdio_perdev_priv *pdata = dev_get_uclass_priv(mdiodev); |
c3452b50 | 163 | |
a5d32c37 AM |
164 | if (device_probe(mdiodev)) |
165 | return NULL; | |
c3452b50 | 166 | |
a5d32c37 | 167 | return phy_connect(pdata->mii_bus, phyaddr, ethdev, interface); |
c3452b50 AM |
168 | } |
169 | ||
2f624559 AM |
170 | static struct phy_device *dm_eth_connect_phy_handle(struct udevice *ethdev, |
171 | phy_interface_t interface) | |
172 | { | |
173 | u32 phy_addr; | |
174 | struct udevice *mdiodev; | |
175 | struct phy_device *phy; | |
f27bc8af | 176 | ofnode phynode; |
2f624559 | 177 | |
b51b1a84 | 178 | if (IS_ENABLED(CONFIG_PHY_FIXED) && |
f27bc8af VO |
179 | ofnode_phy_is_fixed_link(dev_ofnode(ethdev), &phynode)) { |
180 | phy = phy_connect(NULL, 0, ethdev, interface); | |
bdf31927 RV |
181 | goto out; |
182 | } | |
183 | ||
f3dd213e MB |
184 | phynode = dev_get_phy_node(ethdev); |
185 | if (!ofnode_valid(phynode)) { | |
0851bd1e | 186 | dev_dbg(ethdev, "can't find PHY node\n"); |
2f624559 AM |
187 | return NULL; |
188 | } | |
189 | ||
190 | /* | |
191 | * reading 'reg' directly should be fine. This is a PHY node, the | |
192 | * address is always size 1 and requires no translation | |
193 | */ | |
f3dd213e | 194 | if (ofnode_read_u32(phynode, "reg", &phy_addr)) { |
2f624559 AM |
195 | dev_dbg(ethdev, "missing reg property in phy node\n"); |
196 | return NULL; | |
197 | } | |
198 | ||
199 | if (uclass_get_device_by_ofnode(UCLASS_MDIO, | |
f3dd213e | 200 | ofnode_get_parent(phynode), |
2f624559 | 201 | &mdiodev)) { |
0851bd1e | 202 | dev_dbg(ethdev, "can't find MDIO bus for node %s\n", |
f3dd213e | 203 | ofnode_get_name(ofnode_get_parent(phynode))); |
2f624559 AM |
204 | return NULL; |
205 | } | |
206 | ||
207 | phy = dm_mdio_phy_connect(mdiodev, phy_addr, ethdev, interface); | |
208 | ||
bdf31927 | 209 | out: |
2f624559 | 210 | if (phy) |
f3dd213e | 211 | phy->node = phynode; |
2f624559 AM |
212 | |
213 | return phy; | |
214 | } | |
215 | ||
216 | /* Connect to a PHY linked in eth DT node */ | |
217 | struct phy_device *dm_eth_phy_connect(struct udevice *ethdev) | |
218 | { | |
2f624559 AM |
219 | phy_interface_t interface; |
220 | struct phy_device *phy; | |
2f624559 | 221 | |
f10643cf | 222 | if (!dev_has_ofnode(ethdev)) { |
2f624559 AM |
223 | debug("%s: supplied eth dev has no DT node!\n", ethdev->name); |
224 | return NULL; | |
225 | } | |
226 | ||
123ca114 | 227 | interface = dev_read_phy_mode(ethdev); |
ffb0f6f4 MB |
228 | if (interface == PHY_INTERFACE_MODE_NA) |
229 | dev_dbg(ethdev, "can't find interface mode, default to NA\n"); | |
2f624559 AM |
230 | |
231 | phy = dm_eth_connect_phy_handle(ethdev, interface); | |
232 | ||
233 | if (!phy) | |
234 | return NULL; | |
235 | ||
236 | phy->interface = interface; | |
237 | ||
238 | return phy; | |
239 | } | |
240 | ||
c3452b50 AM |
241 | UCLASS_DRIVER(mdio) = { |
242 | .id = UCLASS_MDIO, | |
243 | .name = "mdio", | |
244 | .post_bind = dm_mdio_post_bind, | |
245 | .post_probe = dm_mdio_post_probe, | |
246 | .pre_remove = dm_mdio_pre_remove, | |
41575d8e | 247 | .per_device_auto = sizeof(struct mdio_perdev_priv), |
c3452b50 | 248 | }; |