Commit | Line | Data |
---|---|---|
11b0bacd | 1 | /* |
a79d8e93 | 2 | * Fixed MDIO bus (MDIO bus emulation with fixed PHYs) |
11b0bacd | 3 | * |
a79d8e93 VB |
4 | * Author: Vitaly Bordug <vbordug@ru.mvista.com> |
5 | * Anton Vorontsov <avorontsov@ru.mvista.com> | |
11b0bacd | 6 | * |
a79d8e93 | 7 | * Copyright (c) 2006-2007 MontaVista Software, Inc. |
11b0bacd VB |
8 | * |
9 | * This program is free software; you can redistribute it and/or modify it | |
10 | * under the terms of the GNU General Public License as published by the | |
11 | * Free Software Foundation; either version 2 of the License, or (at your | |
12 | * option) any later version. | |
11b0bacd | 13 | */ |
a79d8e93 | 14 | |
11b0bacd | 15 | #include <linux/kernel.h> |
11b0bacd | 16 | #include <linux/module.h> |
a79d8e93 VB |
17 | #include <linux/platform_device.h> |
18 | #include <linux/list.h> | |
11b0bacd | 19 | #include <linux/mii.h> |
11b0bacd | 20 | #include <linux/phy.h> |
7c32f470 | 21 | #include <linux/phy_fixed.h> |
57401d5e | 22 | #include <linux/err.h> |
5a0e3ad6 | 23 | #include <linux/slab.h> |
a7595121 | 24 | #include <linux/of.h> |
11b0bacd | 25 | |
a79d8e93 | 26 | #define MII_REGS_NUM 29 |
11b0bacd | 27 | |
a79d8e93 VB |
28 | struct fixed_mdio_bus { |
29 | int irqs[PHY_MAX_ADDR]; | |
298cf9be | 30 | struct mii_bus *mii_bus; |
a79d8e93 VB |
31 | struct list_head phys; |
32 | }; | |
11b0bacd | 33 | |
a79d8e93 | 34 | struct fixed_phy { |
9b744942 | 35 | int addr; |
a79d8e93 VB |
36 | u16 regs[MII_REGS_NUM]; |
37 | struct phy_device *phydev; | |
38 | struct fixed_phy_status status; | |
39 | int (*link_update)(struct net_device *, struct fixed_phy_status *); | |
40 | struct list_head node; | |
41 | }; | |
7c32f470 | 42 | |
a79d8e93 VB |
43 | static struct platform_device *pdev; |
44 | static struct fixed_mdio_bus platform_fmb = { | |
45 | .phys = LIST_HEAD_INIT(platform_fmb.phys), | |
46 | }; | |
7c32f470 | 47 | |
a79d8e93 | 48 | static int fixed_phy_update_regs(struct fixed_phy *fp) |
11b0bacd | 49 | { |
a79d8e93 | 50 | u16 bmsr = BMSR_ANEGCAPABLE; |
11b0bacd | 51 | u16 bmcr = 0; |
a79d8e93 VB |
52 | u16 lpagb = 0; |
53 | u16 lpa = 0; | |
11b0bacd | 54 | |
a79d8e93 | 55 | if (fp->status.duplex) { |
11b0bacd VB |
56 | bmcr |= BMCR_FULLDPLX; |
57 | ||
a79d8e93 VB |
58 | switch (fp->status.speed) { |
59 | case 1000: | |
60 | bmsr |= BMSR_ESTATEN; | |
61 | bmcr |= BMCR_SPEED1000; | |
62 | lpagb |= LPA_1000FULL; | |
63 | break; | |
11b0bacd VB |
64 | case 100: |
65 | bmsr |= BMSR_100FULL; | |
66 | bmcr |= BMCR_SPEED100; | |
a79d8e93 | 67 | lpa |= LPA_100FULL; |
7c32f470 | 68 | break; |
11b0bacd VB |
69 | case 10: |
70 | bmsr |= BMSR_10FULL; | |
a79d8e93 | 71 | lpa |= LPA_10FULL; |
7c32f470 | 72 | break; |
a79d8e93 | 73 | default: |
8d242488 | 74 | pr_warn("fixed phy: unknown speed\n"); |
a79d8e93 | 75 | return -EINVAL; |
11b0bacd VB |
76 | } |
77 | } else { | |
a79d8e93 VB |
78 | switch (fp->status.speed) { |
79 | case 1000: | |
80 | bmsr |= BMSR_ESTATEN; | |
81 | bmcr |= BMCR_SPEED1000; | |
82 | lpagb |= LPA_1000HALF; | |
83 | break; | |
11b0bacd VB |
84 | case 100: |
85 | bmsr |= BMSR_100HALF; | |
86 | bmcr |= BMCR_SPEED100; | |
a79d8e93 | 87 | lpa |= LPA_100HALF; |
7c32f470 | 88 | break; |
11b0bacd | 89 | case 10: |
a79d8e93 VB |
90 | bmsr |= BMSR_10HALF; |
91 | lpa |= LPA_10HALF; | |
7c32f470 | 92 | break; |
a79d8e93 | 93 | default: |
8d242488 | 94 | pr_warn("fixed phy: unknown speed\n"); |
a79d8e93 | 95 | return -EINVAL; |
11b0bacd VB |
96 | } |
97 | } | |
98 | ||
a79d8e93 VB |
99 | if (fp->status.link) |
100 | bmsr |= BMSR_LSTATUS | BMSR_ANEGCOMPLETE; | |
101 | ||
102 | if (fp->status.pause) | |
103 | lpa |= LPA_PAUSE_CAP; | |
104 | ||
105 | if (fp->status.asym_pause) | |
106 | lpa |= LPA_PAUSE_ASYM; | |
107 | ||
9b744942 TP |
108 | fp->regs[MII_PHYSID1] = 0; |
109 | fp->regs[MII_PHYSID2] = 0; | |
a79d8e93 VB |
110 | |
111 | fp->regs[MII_BMSR] = bmsr; | |
112 | fp->regs[MII_BMCR] = bmcr; | |
113 | fp->regs[MII_LPA] = lpa; | |
114 | fp->regs[MII_STAT1000] = lpagb; | |
11b0bacd VB |
115 | |
116 | return 0; | |
117 | } | |
118 | ||
9b744942 | 119 | static int fixed_mdio_read(struct mii_bus *bus, int phy_addr, int reg_num) |
11b0bacd | 120 | { |
ec2a5652 | 121 | struct fixed_mdio_bus *fmb = bus->priv; |
a79d8e93 VB |
122 | struct fixed_phy *fp; |
123 | ||
124 | if (reg_num >= MII_REGS_NUM) | |
125 | return -1; | |
126 | ||
a2dbba76 FF |
127 | /* We do not support emulating Clause 45 over Clause 22 register reads |
128 | * return an error instead of bogus data. | |
129 | */ | |
130 | switch (reg_num) { | |
131 | case MII_MMD_CTRL: | |
132 | case MII_MMD_DATA: | |
133 | return -1; | |
134 | default: | |
135 | break; | |
136 | } | |
137 | ||
a79d8e93 | 138 | list_for_each_entry(fp, &fmb->phys, node) { |
9b744942 | 139 | if (fp->addr == phy_addr) { |
a79d8e93 VB |
140 | /* Issue callback if user registered it. */ |
141 | if (fp->link_update) { | |
142 | fp->link_update(fp->phydev->attached_dev, | |
143 | &fp->status); | |
144 | fixed_phy_update_regs(fp); | |
11b0bacd | 145 | } |
a79d8e93 | 146 | return fp->regs[reg_num]; |
7c32f470 | 147 | } |
a79d8e93 | 148 | } |
11b0bacd | 149 | |
a79d8e93 | 150 | return 0xFFFF; |
11b0bacd VB |
151 | } |
152 | ||
9b744942 | 153 | static int fixed_mdio_write(struct mii_bus *bus, int phy_addr, int reg_num, |
a79d8e93 | 154 | u16 val) |
11b0bacd | 155 | { |
11b0bacd VB |
156 | return 0; |
157 | } | |
158 | ||
a79d8e93 VB |
159 | /* |
160 | * If something weird is required to be done with link/speed, | |
161 | * network driver is able to assign a function to implement this. | |
162 | * May be useful for PHY's that need to be software-driven. | |
163 | */ | |
164 | int fixed_phy_set_link_update(struct phy_device *phydev, | |
165 | int (*link_update)(struct net_device *, | |
166 | struct fixed_phy_status *)) | |
11b0bacd | 167 | { |
a79d8e93 VB |
168 | struct fixed_mdio_bus *fmb = &platform_fmb; |
169 | struct fixed_phy *fp; | |
11b0bacd | 170 | |
799d4444 | 171 | if (!phydev || !phydev->bus) |
a79d8e93 | 172 | return -EINVAL; |
11b0bacd | 173 | |
a79d8e93 | 174 | list_for_each_entry(fp, &fmb->phys, node) { |
9b744942 | 175 | if (fp->addr == phydev->addr) { |
a79d8e93 VB |
176 | fp->link_update = link_update; |
177 | fp->phydev = phydev; | |
178 | return 0; | |
179 | } | |
180 | } | |
11b0bacd | 181 | |
a79d8e93 | 182 | return -ENOENT; |
7c32f470 | 183 | } |
a79d8e93 | 184 | EXPORT_SYMBOL_GPL(fixed_phy_set_link_update); |
7c32f470 | 185 | |
a3bebdce SS |
186 | int fixed_phy_update_state(struct phy_device *phydev, |
187 | const struct fixed_phy_status *status, | |
188 | const struct fixed_phy_status *changed) | |
189 | { | |
190 | struct fixed_mdio_bus *fmb = &platform_fmb; | |
191 | struct fixed_phy *fp; | |
192 | ||
193 | if (!phydev || !phydev->bus) | |
194 | return -EINVAL; | |
195 | ||
196 | list_for_each_entry(fp, &fmb->phys, node) { | |
197 | if (fp->addr == phydev->addr) { | |
198 | #define _UPD(x) if (changed->x) \ | |
199 | fp->status.x = status->x | |
200 | _UPD(link); | |
201 | _UPD(speed); | |
202 | _UPD(duplex); | |
203 | _UPD(pause); | |
204 | _UPD(asym_pause); | |
205 | #undef _UPD | |
206 | fixed_phy_update_regs(fp); | |
207 | return 0; | |
208 | } | |
209 | } | |
210 | ||
211 | return -ENOENT; | |
212 | } | |
213 | EXPORT_SYMBOL(fixed_phy_update_state); | |
214 | ||
9b744942 | 215 | int fixed_phy_add(unsigned int irq, int phy_addr, |
a79d8e93 | 216 | struct fixed_phy_status *status) |
11b0bacd | 217 | { |
a79d8e93 VB |
218 | int ret; |
219 | struct fixed_mdio_bus *fmb = &platform_fmb; | |
220 | struct fixed_phy *fp; | |
11b0bacd | 221 | |
a79d8e93 VB |
222 | fp = kzalloc(sizeof(*fp), GFP_KERNEL); |
223 | if (!fp) | |
224 | return -ENOMEM; | |
11b0bacd | 225 | |
a79d8e93 | 226 | memset(fp->regs, 0xFF, sizeof(fp->regs[0]) * MII_REGS_NUM); |
11b0bacd | 227 | |
9b744942 | 228 | fmb->irqs[phy_addr] = irq; |
11b0bacd | 229 | |
9b744942 | 230 | fp->addr = phy_addr; |
a79d8e93 | 231 | fp->status = *status; |
7c32f470 | 232 | |
a79d8e93 VB |
233 | ret = fixed_phy_update_regs(fp); |
234 | if (ret) | |
235 | goto err_regs; | |
11b0bacd | 236 | |
a79d8e93 | 237 | list_add_tail(&fp->node, &fmb->phys); |
7c32f470 | 238 | |
a79d8e93 | 239 | return 0; |
11b0bacd | 240 | |
a79d8e93 VB |
241 | err_regs: |
242 | kfree(fp); | |
243 | return ret; | |
244 | } | |
245 | EXPORT_SYMBOL_GPL(fixed_phy_add); | |
11b0bacd | 246 | |
a7595121 TP |
247 | void fixed_phy_del(int phy_addr) |
248 | { | |
249 | struct fixed_mdio_bus *fmb = &platform_fmb; | |
250 | struct fixed_phy *fp, *tmp; | |
251 | ||
252 | list_for_each_entry_safe(fp, tmp, &fmb->phys, node) { | |
253 | if (fp->addr == phy_addr) { | |
254 | list_del(&fp->node); | |
255 | kfree(fp); | |
256 | return; | |
257 | } | |
258 | } | |
259 | } | |
260 | EXPORT_SYMBOL_GPL(fixed_phy_del); | |
261 | ||
262 | static int phy_fixed_addr; | |
263 | static DEFINE_SPINLOCK(phy_fixed_addr_lock); | |
264 | ||
fd2ef0ba PG |
265 | struct phy_device *fixed_phy_register(unsigned int irq, |
266 | struct fixed_phy_status *status, | |
267 | struct device_node *np) | |
a7595121 TP |
268 | { |
269 | struct fixed_mdio_bus *fmb = &platform_fmb; | |
270 | struct phy_device *phy; | |
271 | int phy_addr; | |
272 | int ret; | |
273 | ||
274 | /* Get the next available PHY address, up to PHY_MAX_ADDR */ | |
275 | spin_lock(&phy_fixed_addr_lock); | |
276 | if (phy_fixed_addr == PHY_MAX_ADDR) { | |
277 | spin_unlock(&phy_fixed_addr_lock); | |
fd2ef0ba | 278 | return ERR_PTR(-ENOSPC); |
a7595121 TP |
279 | } |
280 | phy_addr = phy_fixed_addr++; | |
281 | spin_unlock(&phy_fixed_addr_lock); | |
282 | ||
283 | ret = fixed_phy_add(PHY_POLL, phy_addr, status); | |
284 | if (ret < 0) | |
fd2ef0ba | 285 | return ERR_PTR(ret); |
a7595121 TP |
286 | |
287 | phy = get_phy_device(fmb->mii_bus, phy_addr, false); | |
288 | if (!phy || IS_ERR(phy)) { | |
289 | fixed_phy_del(phy_addr); | |
fd2ef0ba | 290 | return ERR_PTR(-EINVAL); |
a7595121 TP |
291 | } |
292 | ||
293 | of_node_get(np); | |
294 | phy->dev.of_node = np; | |
295 | ||
296 | ret = phy_device_register(phy); | |
297 | if (ret) { | |
298 | phy_device_free(phy); | |
299 | of_node_put(np); | |
300 | fixed_phy_del(phy_addr); | |
fd2ef0ba | 301 | return ERR_PTR(ret); |
a7595121 TP |
302 | } |
303 | ||
fd2ef0ba | 304 | return phy; |
a7595121 | 305 | } |
37e9a690 | 306 | EXPORT_SYMBOL_GPL(fixed_phy_register); |
a7595121 | 307 | |
a79d8e93 VB |
308 | static int __init fixed_mdio_bus_init(void) |
309 | { | |
310 | struct fixed_mdio_bus *fmb = &platform_fmb; | |
311 | int ret; | |
11b0bacd | 312 | |
a79d8e93 | 313 | pdev = platform_device_register_simple("Fixed MDIO bus", 0, NULL, 0); |
57401d5e DC |
314 | if (IS_ERR(pdev)) { |
315 | ret = PTR_ERR(pdev); | |
a79d8e93 VB |
316 | goto err_pdev; |
317 | } | |
11b0bacd | 318 | |
298cf9be LB |
319 | fmb->mii_bus = mdiobus_alloc(); |
320 | if (fmb->mii_bus == NULL) { | |
321 | ret = -ENOMEM; | |
322 | goto err_mdiobus_reg; | |
323 | } | |
11b0bacd | 324 | |
9e6c643b | 325 | snprintf(fmb->mii_bus->id, MII_BUS_ID_SIZE, "fixed-0"); |
298cf9be | 326 | fmb->mii_bus->name = "Fixed MDIO Bus"; |
ec2a5652 | 327 | fmb->mii_bus->priv = fmb; |
298cf9be LB |
328 | fmb->mii_bus->parent = &pdev->dev; |
329 | fmb->mii_bus->read = &fixed_mdio_read; | |
330 | fmb->mii_bus->write = &fixed_mdio_write; | |
331 | fmb->mii_bus->irq = fmb->irqs; | |
332 | ||
333 | ret = mdiobus_register(fmb->mii_bus); | |
a79d8e93 | 334 | if (ret) |
298cf9be | 335 | goto err_mdiobus_alloc; |
11b0bacd | 336 | |
a79d8e93 | 337 | return 0; |
11b0bacd | 338 | |
298cf9be LB |
339 | err_mdiobus_alloc: |
340 | mdiobus_free(fmb->mii_bus); | |
a79d8e93 VB |
341 | err_mdiobus_reg: |
342 | platform_device_unregister(pdev); | |
343 | err_pdev: | |
344 | return ret; | |
345 | } | |
346 | module_init(fixed_mdio_bus_init); | |
11b0bacd | 347 | |
a79d8e93 VB |
348 | static void __exit fixed_mdio_bus_exit(void) |
349 | { | |
350 | struct fixed_mdio_bus *fmb = &platform_fmb; | |
651be3a2 | 351 | struct fixed_phy *fp, *tmp; |
11b0bacd | 352 | |
298cf9be LB |
353 | mdiobus_unregister(fmb->mii_bus); |
354 | mdiobus_free(fmb->mii_bus); | |
a79d8e93 | 355 | platform_device_unregister(pdev); |
11b0bacd | 356 | |
651be3a2 | 357 | list_for_each_entry_safe(fp, tmp, &fmb->phys, node) { |
a79d8e93 VB |
358 | list_del(&fp->node); |
359 | kfree(fp); | |
7c32f470 | 360 | } |
11b0bacd | 361 | } |
a79d8e93 | 362 | module_exit(fixed_mdio_bus_exit); |
11b0bacd | 363 | |
a79d8e93 | 364 | MODULE_DESCRIPTION("Fixed MDIO bus (MDIO bus emulation with fixed PHYs)"); |
11b0bacd VB |
365 | MODULE_AUTHOR("Vitaly Bordug"); |
366 | MODULE_LICENSE("GPL"); |