Loading...
1/*
2 * drivers/net/phy/phy_device.c
3 *
4 * Framework for finding and configuring PHYs.
5 * Also contains generic PHY driver
6 *
7 * Author: Andy Fleming
8 *
9 * Copyright (c) 2004 Freescale Semiconductor, Inc.
10 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2 of the License, or (at your
14 * option) any later version.
15 *
16 */
17#include <linux/kernel.h>
18#include <linux/string.h>
19#include <linux/errno.h>
20#include <linux/unistd.h>
21#include <linux/slab.h>
22#include <linux/interrupt.h>
23#include <linux/init.h>
24#include <linux/delay.h>
25#include <linux/netdevice.h>
26#include <linux/etherdevice.h>
27#include <linux/skbuff.h>
28#include <linux/mm.h>
29#include <linux/module.h>
30#include <linux/mii.h>
31#include <linux/ethtool.h>
32#include <linux/phy.h>
33
34#include <asm/io.h>
35#include <asm/irq.h>
36#include <asm/uaccess.h>
37
38MODULE_DESCRIPTION("PHY library");
39MODULE_AUTHOR("Andy Fleming");
40MODULE_LICENSE("GPL");
41
42void phy_device_free(struct phy_device *phydev)
43{
44 kfree(phydev);
45}
46EXPORT_SYMBOL(phy_device_free);
47
48static void phy_device_release(struct device *dev)
49{
50 phy_device_free(to_phy_device(dev));
51}
52
53static struct phy_driver genphy_driver;
54extern int mdio_bus_init(void);
55extern void mdio_bus_exit(void);
56
57static LIST_HEAD(phy_fixup_list);
58static DEFINE_MUTEX(phy_fixup_lock);
59
60static int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
61 u32 flags, phy_interface_t interface);
62
63/*
64 * Creates a new phy_fixup and adds it to the list
65 * @bus_id: A string which matches phydev->dev.bus_id (or PHY_ANY_ID)
66 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
67 * It can also be PHY_ANY_UID
68 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
69 * comparison
70 * @run: The actual code to be run when a matching PHY is found
71 */
72int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
73 int (*run)(struct phy_device *))
74{
75 struct phy_fixup *fixup;
76
77 fixup = kzalloc(sizeof(struct phy_fixup), GFP_KERNEL);
78 if (!fixup)
79 return -ENOMEM;
80
81 strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
82 fixup->phy_uid = phy_uid;
83 fixup->phy_uid_mask = phy_uid_mask;
84 fixup->run = run;
85
86 mutex_lock(&phy_fixup_lock);
87 list_add_tail(&fixup->list, &phy_fixup_list);
88 mutex_unlock(&phy_fixup_lock);
89
90 return 0;
91}
92EXPORT_SYMBOL(phy_register_fixup);
93
94/* Registers a fixup to be run on any PHY with the UID in phy_uid */
95int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
96 int (*run)(struct phy_device *))
97{
98 return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
99}
100EXPORT_SYMBOL(phy_register_fixup_for_uid);
101
102/* Registers a fixup to be run on the PHY with id string bus_id */
103int phy_register_fixup_for_id(const char *bus_id,
104 int (*run)(struct phy_device *))
105{
106 return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
107}
108EXPORT_SYMBOL(phy_register_fixup_for_id);
109
110/*
111 * Returns 1 if fixup matches phydev in bus_id and phy_uid.
112 * Fixups can be set to match any in one or more fields.
113 */
114static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
115{
116 if (strcmp(fixup->bus_id, dev_name(&phydev->dev)) != 0)
117 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
118 return 0;
119
120 if ((fixup->phy_uid & fixup->phy_uid_mask) !=
121 (phydev->phy_id & fixup->phy_uid_mask))
122 if (fixup->phy_uid != PHY_ANY_UID)
123 return 0;
124
125 return 1;
126}
127
128/* Runs any matching fixups for this phydev */
129int phy_scan_fixups(struct phy_device *phydev)
130{
131 struct phy_fixup *fixup;
132
133 mutex_lock(&phy_fixup_lock);
134 list_for_each_entry(fixup, &phy_fixup_list, list) {
135 if (phy_needs_fixup(phydev, fixup)) {
136 int err;
137
138 err = fixup->run(phydev);
139
140 if (err < 0) {
141 mutex_unlock(&phy_fixup_lock);
142 return err;
143 }
144 }
145 }
146 mutex_unlock(&phy_fixup_lock);
147
148 return 0;
149}
150EXPORT_SYMBOL(phy_scan_fixups);
151
152static struct phy_device* phy_device_create(struct mii_bus *bus,
153 int addr, int phy_id)
154{
155 struct phy_device *dev;
156
157 /* We allocate the device, and initialize the
158 * default values */
159 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
160
161 if (NULL == dev)
162 return (struct phy_device*) PTR_ERR((void*)-ENOMEM);
163
164 dev->dev.release = phy_device_release;
165
166 dev->speed = 0;
167 dev->duplex = -1;
168 dev->pause = dev->asym_pause = 0;
169 dev->link = 1;
170 dev->interface = PHY_INTERFACE_MODE_GMII;
171
172 dev->autoneg = AUTONEG_ENABLE;
173
174 dev->addr = addr;
175 dev->phy_id = phy_id;
176 dev->bus = bus;
177 dev->dev.parent = bus->parent;
178 dev->dev.bus = &mdio_bus_type;
179 dev->irq = bus->irq != NULL ? bus->irq[addr] : PHY_POLL;
180 dev_set_name(&dev->dev, PHY_ID_FMT, bus->id, addr);
181
182 dev->state = PHY_DOWN;
183
184 mutex_init(&dev->lock);
185 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
186
187 /* Request the appropriate module unconditionally; don't
188 bother trying to do so only if it isn't already loaded,
189 because that gets complicated. A hotplug event would have
190 done an unconditional modprobe anyway.
191 We don't do normal hotplug because it won't work for MDIO
192 -- because it relies on the device staying around for long
193 enough for the driver to get loaded. With MDIO, the NIC
194 driver will get bored and give up as soon as it finds that
195 there's no driver _already_ loaded. */
196 request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, MDIO_ID_ARGS(phy_id));
197
198 return dev;
199}
200
201/**
202 * get_phy_id - reads the specified addr for its ID.
203 * @bus: the target MII bus
204 * @addr: PHY address on the MII bus
205 * @phy_id: where to store the ID retrieved.
206 *
207 * Description: Reads the ID registers of the PHY at @addr on the
208 * @bus, stores it in @phy_id and returns zero on success.
209 */
210int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id)
211{
212 int phy_reg;
213
214 /* Grab the bits from PHYIR1, and put them
215 * in the upper half */
216 phy_reg = bus->read(bus, addr, MII_PHYSID1);
217
218 if (phy_reg < 0)
219 return -EIO;
220
221 *phy_id = (phy_reg & 0xffff) << 16;
222
223 /* Grab the bits from PHYIR2, and put them in the lower half */
224 phy_reg = bus->read(bus, addr, MII_PHYSID2);
225
226 if (phy_reg < 0)
227 return -EIO;
228
229 *phy_id |= (phy_reg & 0xffff);
230
231 return 0;
232}
233EXPORT_SYMBOL(get_phy_id);
234
235/**
236 * get_phy_device - reads the specified PHY device and returns its @phy_device struct
237 * @bus: the target MII bus
238 * @addr: PHY address on the MII bus
239 *
240 * Description: Reads the ID registers of the PHY at @addr on the
241 * @bus, then allocates and returns the phy_device to represent it.
242 */
243struct phy_device * get_phy_device(struct mii_bus *bus, int addr)
244{
245 struct phy_device *dev = NULL;
246 u32 phy_id;
247 int r;
248
249 r = get_phy_id(bus, addr, &phy_id);
250 if (r)
251 return ERR_PTR(r);
252
253 /* If the phy_id is mostly Fs, there is no device there */
254 if ((phy_id & 0x1fffffff) == 0x1fffffff)
255 return NULL;
256
257 dev = phy_device_create(bus, addr, phy_id);
258
259 return dev;
260}
261EXPORT_SYMBOL(get_phy_device);
262
263/**
264 * phy_device_register - Register the phy device on the MDIO bus
265 * @phydev: phy_device structure to be added to the MDIO bus
266 */
267int phy_device_register(struct phy_device *phydev)
268{
269 int err;
270
271 /* Don't register a phy if one is already registered at this
272 * address */
273 if (phydev->bus->phy_map[phydev->addr])
274 return -EINVAL;
275 phydev->bus->phy_map[phydev->addr] = phydev;
276
277 /* Run all of the fixups for this PHY */
278 phy_scan_fixups(phydev);
279
280 err = device_register(&phydev->dev);
281 if (err) {
282 pr_err("phy %d failed to register\n", phydev->addr);
283 goto out;
284 }
285
286 return 0;
287
288 out:
289 phydev->bus->phy_map[phydev->addr] = NULL;
290 return err;
291}
292EXPORT_SYMBOL(phy_device_register);
293
294/**
295 * phy_find_first - finds the first PHY device on the bus
296 * @bus: the target MII bus
297 */
298struct phy_device *phy_find_first(struct mii_bus *bus)
299{
300 int addr;
301
302 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
303 if (bus->phy_map[addr])
304 return bus->phy_map[addr];
305 }
306 return NULL;
307}
308EXPORT_SYMBOL(phy_find_first);
309
310/**
311 * phy_prepare_link - prepares the PHY layer to monitor link status
312 * @phydev: target phy_device struct
313 * @handler: callback function for link status change notifications
314 *
315 * Description: Tells the PHY infrastructure to handle the
316 * gory details on monitoring link status (whether through
317 * polling or an interrupt), and to call back to the
318 * connected device driver when the link status changes.
319 * If you want to monitor your own link state, don't call
320 * this function.
321 */
322static void phy_prepare_link(struct phy_device *phydev,
323 void (*handler)(struct net_device *))
324{
325 phydev->adjust_link = handler;
326}
327
328/**
329 * phy_connect_direct - connect an ethernet device to a specific phy_device
330 * @dev: the network device to connect
331 * @phydev: the pointer to the phy device
332 * @handler: callback function for state change notifications
333 * @flags: PHY device's dev_flags
334 * @interface: PHY device's interface
335 */
336int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
337 void (*handler)(struct net_device *), u32 flags,
338 phy_interface_t interface)
339{
340 int rc;
341
342 rc = phy_attach_direct(dev, phydev, flags, interface);
343 if (rc)
344 return rc;
345
346 phy_prepare_link(phydev, handler);
347 phy_start_machine(phydev, NULL);
348 if (phydev->irq > 0)
349 phy_start_interrupts(phydev);
350
351 return 0;
352}
353EXPORT_SYMBOL(phy_connect_direct);
354
355/**
356 * phy_connect - connect an ethernet device to a PHY device
357 * @dev: the network device to connect
358 * @bus_id: the id string of the PHY device to connect
359 * @handler: callback function for state change notifications
360 * @flags: PHY device's dev_flags
361 * @interface: PHY device's interface
362 *
363 * Description: Convenience function for connecting ethernet
364 * devices to PHY devices. The default behavior is for
365 * the PHY infrastructure to handle everything, and only notify
366 * the connected driver when the link status changes. If you
367 * don't want, or can't use the provided functionality, you may
368 * choose to call only the subset of functions which provide
369 * the desired functionality.
370 */
371struct phy_device * phy_connect(struct net_device *dev, const char *bus_id,
372 void (*handler)(struct net_device *), u32 flags,
373 phy_interface_t interface)
374{
375 struct phy_device *phydev;
376 struct device *d;
377 int rc;
378
379 /* Search the list of PHY devices on the mdio bus for the
380 * PHY with the requested name */
381 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
382 if (!d) {
383 pr_err("PHY %s not found\n", bus_id);
384 return ERR_PTR(-ENODEV);
385 }
386 phydev = to_phy_device(d);
387
388 rc = phy_connect_direct(dev, phydev, handler, flags, interface);
389 if (rc)
390 return ERR_PTR(rc);
391
392 return phydev;
393}
394EXPORT_SYMBOL(phy_connect);
395
396/**
397 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY device
398 * @phydev: target phy_device struct
399 */
400void phy_disconnect(struct phy_device *phydev)
401{
402 if (phydev->irq > 0)
403 phy_stop_interrupts(phydev);
404
405 phy_stop_machine(phydev);
406
407 phydev->adjust_link = NULL;
408
409 phy_detach(phydev);
410}
411EXPORT_SYMBOL(phy_disconnect);
412
413int phy_init_hw(struct phy_device *phydev)
414{
415 int ret;
416
417 if (!phydev->drv || !phydev->drv->config_init)
418 return 0;
419
420 ret = phy_scan_fixups(phydev);
421 if (ret < 0)
422 return ret;
423
424 return phydev->drv->config_init(phydev);
425}
426
427/**
428 * phy_attach_direct - attach a network device to a given PHY device pointer
429 * @dev: network device to attach
430 * @phydev: Pointer to phy_device to attach
431 * @flags: PHY device's dev_flags
432 * @interface: PHY device's interface
433 *
434 * Description: Called by drivers to attach to a particular PHY
435 * device. The phy_device is found, and properly hooked up
436 * to the phy_driver. If no driver is attached, then the
437 * genphy_driver is used. The phy_device is given a ptr to
438 * the attaching device, and given a callback for link status
439 * change. The phy_device is returned to the attaching driver.
440 */
441static int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
442 u32 flags, phy_interface_t interface)
443{
444 struct device *d = &phydev->dev;
445 int err;
446
447 /* Assume that if there is no driver, that it doesn't
448 * exist, and we should use the genphy driver. */
449 if (NULL == d->driver) {
450 d->driver = &genphy_driver.driver;
451
452 err = d->driver->probe(d);
453 if (err >= 0)
454 err = device_bind_driver(d);
455
456 if (err)
457 return err;
458 }
459
460 if (phydev->attached_dev) {
461 dev_err(&dev->dev, "PHY already attached\n");
462 return -EBUSY;
463 }
464
465 phydev->attached_dev = dev;
466 dev->phydev = phydev;
467
468 phydev->dev_flags = flags;
469
470 phydev->interface = interface;
471
472 phydev->state = PHY_READY;
473
474 /* Do initial configuration here, now that
475 * we have certain key parameters
476 * (dev_flags and interface) */
477 err = phy_init_hw(phydev);
478 if (err)
479 phy_detach(phydev);
480
481 return err;
482}
483
484/**
485 * phy_attach - attach a network device to a particular PHY device
486 * @dev: network device to attach
487 * @bus_id: Bus ID of PHY device to attach
488 * @flags: PHY device's dev_flags
489 * @interface: PHY device's interface
490 *
491 * Description: Same as phy_attach_direct() except that a PHY bus_id
492 * string is passed instead of a pointer to a struct phy_device.
493 */
494struct phy_device *phy_attach(struct net_device *dev,
495 const char *bus_id, u32 flags, phy_interface_t interface)
496{
497 struct bus_type *bus = &mdio_bus_type;
498 struct phy_device *phydev;
499 struct device *d;
500 int rc;
501
502 /* Search the list of PHY devices on the mdio bus for the
503 * PHY with the requested name */
504 d = bus_find_device_by_name(bus, NULL, bus_id);
505 if (!d) {
506 pr_err("PHY %s not found\n", bus_id);
507 return ERR_PTR(-ENODEV);
508 }
509 phydev = to_phy_device(d);
510
511 rc = phy_attach_direct(dev, phydev, flags, interface);
512 if (rc)
513 return ERR_PTR(rc);
514
515 return phydev;
516}
517EXPORT_SYMBOL(phy_attach);
518
519/**
520 * phy_detach - detach a PHY device from its network device
521 * @phydev: target phy_device struct
522 */
523void phy_detach(struct phy_device *phydev)
524{
525 phydev->attached_dev->phydev = NULL;
526 phydev->attached_dev = NULL;
527
528 /* If the device had no specific driver before (i.e. - it
529 * was using the generic driver), we unbind the device
530 * from the generic driver so that there's a chance a
531 * real driver could be loaded */
532 if (phydev->dev.driver == &genphy_driver.driver)
533 device_release_driver(&phydev->dev);
534}
535EXPORT_SYMBOL(phy_detach);
536
537
538/* Generic PHY support and helper functions */
539
540/**
541 * genphy_config_advert - sanitize and advertise auto-negotiation parameters
542 * @phydev: target phy_device struct
543 *
544 * Description: Writes MII_ADVERTISE with the appropriate values,
545 * after sanitizing the values to make sure we only advertise
546 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
547 * hasn't changed, and > 0 if it has changed.
548 */
549static int genphy_config_advert(struct phy_device *phydev)
550{
551 u32 advertise;
552 int oldadv, adv;
553 int err, changed = 0;
554
555 /* Only allow advertising what
556 * this PHY supports */
557 phydev->advertising &= phydev->supported;
558 advertise = phydev->advertising;
559
560 /* Setup standard advertisement */
561 oldadv = adv = phy_read(phydev, MII_ADVERTISE);
562
563 if (adv < 0)
564 return adv;
565
566 adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP |
567 ADVERTISE_PAUSE_ASYM);
568 if (advertise & ADVERTISED_10baseT_Half)
569 adv |= ADVERTISE_10HALF;
570 if (advertise & ADVERTISED_10baseT_Full)
571 adv |= ADVERTISE_10FULL;
572 if (advertise & ADVERTISED_100baseT_Half)
573 adv |= ADVERTISE_100HALF;
574 if (advertise & ADVERTISED_100baseT_Full)
575 adv |= ADVERTISE_100FULL;
576 if (advertise & ADVERTISED_Pause)
577 adv |= ADVERTISE_PAUSE_CAP;
578 if (advertise & ADVERTISED_Asym_Pause)
579 adv |= ADVERTISE_PAUSE_ASYM;
580
581 if (adv != oldadv) {
582 err = phy_write(phydev, MII_ADVERTISE, adv);
583
584 if (err < 0)
585 return err;
586 changed = 1;
587 }
588
589 /* Configure gigabit if it's supported */
590 if (phydev->supported & (SUPPORTED_1000baseT_Half |
591 SUPPORTED_1000baseT_Full)) {
592 oldadv = adv = phy_read(phydev, MII_CTRL1000);
593
594 if (adv < 0)
595 return adv;
596
597 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
598 if (advertise & SUPPORTED_1000baseT_Half)
599 adv |= ADVERTISE_1000HALF;
600 if (advertise & SUPPORTED_1000baseT_Full)
601 adv |= ADVERTISE_1000FULL;
602
603 if (adv != oldadv) {
604 err = phy_write(phydev, MII_CTRL1000, adv);
605
606 if (err < 0)
607 return err;
608 changed = 1;
609 }
610 }
611
612 return changed;
613}
614
615/**
616 * genphy_setup_forced - configures/forces speed/duplex from @phydev
617 * @phydev: target phy_device struct
618 *
619 * Description: Configures MII_BMCR to force speed/duplex
620 * to the values in phydev. Assumes that the values are valid.
621 * Please see phy_sanitize_settings().
622 */
623static int genphy_setup_forced(struct phy_device *phydev)
624{
625 int err;
626 int ctl = 0;
627
628 phydev->pause = phydev->asym_pause = 0;
629
630 if (SPEED_1000 == phydev->speed)
631 ctl |= BMCR_SPEED1000;
632 else if (SPEED_100 == phydev->speed)
633 ctl |= BMCR_SPEED100;
634
635 if (DUPLEX_FULL == phydev->duplex)
636 ctl |= BMCR_FULLDPLX;
637
638 err = phy_write(phydev, MII_BMCR, ctl);
639
640 return err;
641}
642
643
644/**
645 * genphy_restart_aneg - Enable and Restart Autonegotiation
646 * @phydev: target phy_device struct
647 */
648int genphy_restart_aneg(struct phy_device *phydev)
649{
650 int ctl;
651
652 ctl = phy_read(phydev, MII_BMCR);
653
654 if (ctl < 0)
655 return ctl;
656
657 ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);
658
659 /* Don't isolate the PHY if we're negotiating */
660 ctl &= ~(BMCR_ISOLATE);
661
662 ctl = phy_write(phydev, MII_BMCR, ctl);
663
664 return ctl;
665}
666EXPORT_SYMBOL(genphy_restart_aneg);
667
668
669/**
670 * genphy_config_aneg - restart auto-negotiation or write BMCR
671 * @phydev: target phy_device struct
672 *
673 * Description: If auto-negotiation is enabled, we configure the
674 * advertising, and then restart auto-negotiation. If it is not
675 * enabled, then we write the BMCR.
676 */
677int genphy_config_aneg(struct phy_device *phydev)
678{
679 int result;
680
681 if (AUTONEG_ENABLE != phydev->autoneg)
682 return genphy_setup_forced(phydev);
683
684 result = genphy_config_advert(phydev);
685
686 if (result < 0) /* error */
687 return result;
688
689 if (result == 0) {
690 /* Advertisement hasn't changed, but maybe aneg was never on to
691 * begin with? Or maybe phy was isolated? */
692 int ctl = phy_read(phydev, MII_BMCR);
693
694 if (ctl < 0)
695 return ctl;
696
697 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
698 result = 1; /* do restart aneg */
699 }
700
701 /* Only restart aneg if we are advertising something different
702 * than we were before. */
703 if (result > 0)
704 result = genphy_restart_aneg(phydev);
705
706 return result;
707}
708EXPORT_SYMBOL(genphy_config_aneg);
709
710/**
711 * genphy_update_link - update link status in @phydev
712 * @phydev: target phy_device struct
713 *
714 * Description: Update the value in phydev->link to reflect the
715 * current link value. In order to do this, we need to read
716 * the status register twice, keeping the second value.
717 */
718int genphy_update_link(struct phy_device *phydev)
719{
720 int status;
721
722 /* Do a fake read */
723 status = phy_read(phydev, MII_BMSR);
724
725 if (status < 0)
726 return status;
727
728 /* Read link and autonegotiation status */
729 status = phy_read(phydev, MII_BMSR);
730
731 if (status < 0)
732 return status;
733
734 if ((status & BMSR_LSTATUS) == 0)
735 phydev->link = 0;
736 else
737 phydev->link = 1;
738
739 return 0;
740}
741EXPORT_SYMBOL(genphy_update_link);
742
743/**
744 * genphy_read_status - check the link status and update current link state
745 * @phydev: target phy_device struct
746 *
747 * Description: Check the link, then figure out the current state
748 * by comparing what we advertise with what the link partner
749 * advertises. Start by checking the gigabit possibilities,
750 * then move on to 10/100.
751 */
752int genphy_read_status(struct phy_device *phydev)
753{
754 int adv;
755 int err;
756 int lpa;
757 int lpagb = 0;
758
759 /* Update the link, but return if there
760 * was an error */
761 err = genphy_update_link(phydev);
762 if (err)
763 return err;
764
765 if (AUTONEG_ENABLE == phydev->autoneg) {
766 if (phydev->supported & (SUPPORTED_1000baseT_Half
767 | SUPPORTED_1000baseT_Full)) {
768 lpagb = phy_read(phydev, MII_STAT1000);
769
770 if (lpagb < 0)
771 return lpagb;
772
773 adv = phy_read(phydev, MII_CTRL1000);
774
775 if (adv < 0)
776 return adv;
777
778 lpagb &= adv << 2;
779 }
780
781 lpa = phy_read(phydev, MII_LPA);
782
783 if (lpa < 0)
784 return lpa;
785
786 adv = phy_read(phydev, MII_ADVERTISE);
787
788 if (adv < 0)
789 return adv;
790
791 lpa &= adv;
792
793 phydev->speed = SPEED_10;
794 phydev->duplex = DUPLEX_HALF;
795 phydev->pause = phydev->asym_pause = 0;
796
797 if (lpagb & (LPA_1000FULL | LPA_1000HALF)) {
798 phydev->speed = SPEED_1000;
799
800 if (lpagb & LPA_1000FULL)
801 phydev->duplex = DUPLEX_FULL;
802 } else if (lpa & (LPA_100FULL | LPA_100HALF)) {
803 phydev->speed = SPEED_100;
804
805 if (lpa & LPA_100FULL)
806 phydev->duplex = DUPLEX_FULL;
807 } else
808 if (lpa & LPA_10FULL)
809 phydev->duplex = DUPLEX_FULL;
810
811 if (phydev->duplex == DUPLEX_FULL){
812 phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
813 phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
814 }
815 } else {
816 int bmcr = phy_read(phydev, MII_BMCR);
817 if (bmcr < 0)
818 return bmcr;
819
820 if (bmcr & BMCR_FULLDPLX)
821 phydev->duplex = DUPLEX_FULL;
822 else
823 phydev->duplex = DUPLEX_HALF;
824
825 if (bmcr & BMCR_SPEED1000)
826 phydev->speed = SPEED_1000;
827 else if (bmcr & BMCR_SPEED100)
828 phydev->speed = SPEED_100;
829 else
830 phydev->speed = SPEED_10;
831
832 phydev->pause = phydev->asym_pause = 0;
833 }
834
835 return 0;
836}
837EXPORT_SYMBOL(genphy_read_status);
838
839static int genphy_config_init(struct phy_device *phydev)
840{
841 int val;
842 u32 features;
843
844 /* For now, I'll claim that the generic driver supports
845 * all possible port types */
846 features = (SUPPORTED_TP | SUPPORTED_MII
847 | SUPPORTED_AUI | SUPPORTED_FIBRE |
848 SUPPORTED_BNC);
849
850 /* Do we support autonegotiation? */
851 val = phy_read(phydev, MII_BMSR);
852
853 if (val < 0)
854 return val;
855
856 if (val & BMSR_ANEGCAPABLE)
857 features |= SUPPORTED_Autoneg;
858
859 if (val & BMSR_100FULL)
860 features |= SUPPORTED_100baseT_Full;
861 if (val & BMSR_100HALF)
862 features |= SUPPORTED_100baseT_Half;
863 if (val & BMSR_10FULL)
864 features |= SUPPORTED_10baseT_Full;
865 if (val & BMSR_10HALF)
866 features |= SUPPORTED_10baseT_Half;
867
868 if (val & BMSR_ESTATEN) {
869 val = phy_read(phydev, MII_ESTATUS);
870
871 if (val < 0)
872 return val;
873
874 if (val & ESTATUS_1000_TFULL)
875 features |= SUPPORTED_1000baseT_Full;
876 if (val & ESTATUS_1000_THALF)
877 features |= SUPPORTED_1000baseT_Half;
878 }
879
880 phydev->supported = features;
881 phydev->advertising = features;
882
883 return 0;
884}
885int genphy_suspend(struct phy_device *phydev)
886{
887 int value;
888
889 mutex_lock(&phydev->lock);
890
891 value = phy_read(phydev, MII_BMCR);
892 phy_write(phydev, MII_BMCR, (value | BMCR_PDOWN));
893
894 mutex_unlock(&phydev->lock);
895
896 return 0;
897}
898EXPORT_SYMBOL(genphy_suspend);
899
900int genphy_resume(struct phy_device *phydev)
901{
902 int value;
903
904 mutex_lock(&phydev->lock);
905
906 value = phy_read(phydev, MII_BMCR);
907 phy_write(phydev, MII_BMCR, (value & ~BMCR_PDOWN));
908
909 mutex_unlock(&phydev->lock);
910
911 return 0;
912}
913EXPORT_SYMBOL(genphy_resume);
914
915/**
916 * phy_probe - probe and init a PHY device
917 * @dev: device to probe and init
918 *
919 * Description: Take care of setting up the phy_device structure,
920 * set the state to READY (the driver's init function should
921 * set it to STARTING if needed).
922 */
923static int phy_probe(struct device *dev)
924{
925 struct phy_device *phydev;
926 struct phy_driver *phydrv;
927 struct device_driver *drv;
928 int err = 0;
929
930 phydev = to_phy_device(dev);
931
932 /* Make sure the driver is held.
933 * XXX -- Is this correct? */
934 drv = get_driver(phydev->dev.driver);
935 phydrv = to_phy_driver(drv);
936 phydev->drv = phydrv;
937
938 /* Disable the interrupt if the PHY doesn't support it */
939 if (!(phydrv->flags & PHY_HAS_INTERRUPT))
940 phydev->irq = PHY_POLL;
941
942 mutex_lock(&phydev->lock);
943
944 /* Start out supporting everything. Eventually,
945 * a controller will attach, and may modify one
946 * or both of these values */
947 phydev->supported = phydrv->features;
948 phydev->advertising = phydrv->features;
949
950 /* Set the state to READY by default */
951 phydev->state = PHY_READY;
952
953 if (phydev->drv->probe)
954 err = phydev->drv->probe(phydev);
955
956 mutex_unlock(&phydev->lock);
957
958 return err;
959
960}
961
962static int phy_remove(struct device *dev)
963{
964 struct phy_device *phydev;
965
966 phydev = to_phy_device(dev);
967
968 mutex_lock(&phydev->lock);
969 phydev->state = PHY_DOWN;
970 mutex_unlock(&phydev->lock);
971
972 if (phydev->drv->remove)
973 phydev->drv->remove(phydev);
974
975 put_driver(dev->driver);
976 phydev->drv = NULL;
977
978 return 0;
979}
980
981/**
982 * phy_driver_register - register a phy_driver with the PHY layer
983 * @new_driver: new phy_driver to register
984 */
985int phy_driver_register(struct phy_driver *new_driver)
986{
987 int retval;
988
989 new_driver->driver.name = new_driver->name;
990 new_driver->driver.bus = &mdio_bus_type;
991 new_driver->driver.probe = phy_probe;
992 new_driver->driver.remove = phy_remove;
993
994 retval = driver_register(&new_driver->driver);
995
996 if (retval) {
997 printk(KERN_ERR "%s: Error %d in registering driver\n",
998 new_driver->name, retval);
999
1000 return retval;
1001 }
1002
1003 pr_debug("%s: Registered new driver\n", new_driver->name);
1004
1005 return 0;
1006}
1007EXPORT_SYMBOL(phy_driver_register);
1008
1009void phy_driver_unregister(struct phy_driver *drv)
1010{
1011 driver_unregister(&drv->driver);
1012}
1013EXPORT_SYMBOL(phy_driver_unregister);
1014
1015static struct phy_driver genphy_driver = {
1016 .phy_id = 0xffffffff,
1017 .phy_id_mask = 0xffffffff,
1018 .name = "Generic PHY",
1019 .config_init = genphy_config_init,
1020 .features = 0,
1021 .config_aneg = genphy_config_aneg,
1022 .read_status = genphy_read_status,
1023 .suspend = genphy_suspend,
1024 .resume = genphy_resume,
1025 .driver = {.owner= THIS_MODULE, },
1026};
1027
1028static int __init phy_init(void)
1029{
1030 int rc;
1031
1032 rc = mdio_bus_init();
1033 if (rc)
1034 return rc;
1035
1036 rc = phy_driver_register(&genphy_driver);
1037 if (rc)
1038 mdio_bus_exit();
1039
1040 return rc;
1041}
1042
1043static void __exit phy_exit(void)
1044{
1045 phy_driver_unregister(&genphy_driver);
1046 mdio_bus_exit();
1047}
1048
1049subsys_initcall(phy_init);
1050module_exit(phy_exit);
1/* Framework for finding and configuring PHYs.
2 * Also contains generic PHY driver
3 *
4 * Author: Andy Fleming
5 *
6 * Copyright (c) 2004 Freescale Semiconductor, Inc.
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
14
15#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16
17#include <linux/kernel.h>
18#include <linux/string.h>
19#include <linux/errno.h>
20#include <linux/unistd.h>
21#include <linux/slab.h>
22#include <linux/interrupt.h>
23#include <linux/init.h>
24#include <linux/delay.h>
25#include <linux/netdevice.h>
26#include <linux/etherdevice.h>
27#include <linux/skbuff.h>
28#include <linux/mm.h>
29#include <linux/module.h>
30#include <linux/mii.h>
31#include <linux/ethtool.h>
32#include <linux/phy.h>
33#include <linux/mdio.h>
34#include <linux/io.h>
35#include <linux/uaccess.h>
36
37#include <asm/irq.h>
38
39MODULE_DESCRIPTION("PHY library");
40MODULE_AUTHOR("Andy Fleming");
41MODULE_LICENSE("GPL");
42
43void phy_device_free(struct phy_device *phydev)
44{
45 put_device(&phydev->dev);
46}
47EXPORT_SYMBOL(phy_device_free);
48
49static void phy_device_release(struct device *dev)
50{
51 kfree(to_phy_device(dev));
52}
53
54enum genphy_driver {
55 GENPHY_DRV_1G,
56 GENPHY_DRV_10G,
57 GENPHY_DRV_MAX
58};
59
60static struct phy_driver genphy_driver[GENPHY_DRV_MAX];
61
62static LIST_HEAD(phy_fixup_list);
63static DEFINE_MUTEX(phy_fixup_lock);
64
65/**
66 * phy_register_fixup - creates a new phy_fixup and adds it to the list
67 * @bus_id: A string which matches phydev->dev.bus_id (or PHY_ANY_ID)
68 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
69 * It can also be PHY_ANY_UID
70 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
71 * comparison
72 * @run: The actual code to be run when a matching PHY is found
73 */
74int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
75 int (*run)(struct phy_device *))
76{
77 struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL);
78
79 if (!fixup)
80 return -ENOMEM;
81
82 strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
83 fixup->phy_uid = phy_uid;
84 fixup->phy_uid_mask = phy_uid_mask;
85 fixup->run = run;
86
87 mutex_lock(&phy_fixup_lock);
88 list_add_tail(&fixup->list, &phy_fixup_list);
89 mutex_unlock(&phy_fixup_lock);
90
91 return 0;
92}
93EXPORT_SYMBOL(phy_register_fixup);
94
95/* Registers a fixup to be run on any PHY with the UID in phy_uid */
96int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
97 int (*run)(struct phy_device *))
98{
99 return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
100}
101EXPORT_SYMBOL(phy_register_fixup_for_uid);
102
103/* Registers a fixup to be run on the PHY with id string bus_id */
104int phy_register_fixup_for_id(const char *bus_id,
105 int (*run)(struct phy_device *))
106{
107 return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
108}
109EXPORT_SYMBOL(phy_register_fixup_for_id);
110
111/* Returns 1 if fixup matches phydev in bus_id and phy_uid.
112 * Fixups can be set to match any in one or more fields.
113 */
114static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
115{
116 if (strcmp(fixup->bus_id, dev_name(&phydev->dev)) != 0)
117 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
118 return 0;
119
120 if ((fixup->phy_uid & fixup->phy_uid_mask) !=
121 (phydev->phy_id & fixup->phy_uid_mask))
122 if (fixup->phy_uid != PHY_ANY_UID)
123 return 0;
124
125 return 1;
126}
127
128/* Runs any matching fixups for this phydev */
129static int phy_scan_fixups(struct phy_device *phydev)
130{
131 struct phy_fixup *fixup;
132
133 mutex_lock(&phy_fixup_lock);
134 list_for_each_entry(fixup, &phy_fixup_list, list) {
135 if (phy_needs_fixup(phydev, fixup)) {
136 int err = fixup->run(phydev);
137
138 if (err < 0) {
139 mutex_unlock(&phy_fixup_lock);
140 return err;
141 }
142 phydev->has_fixups = true;
143 }
144 }
145 mutex_unlock(&phy_fixup_lock);
146
147 return 0;
148}
149
150struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
151 bool is_c45,
152 struct phy_c45_device_ids *c45_ids)
153{
154 struct phy_device *dev;
155
156 /* We allocate the device, and initialize the default values */
157 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
158 if (NULL == dev)
159 return (struct phy_device *)PTR_ERR((void *)-ENOMEM);
160
161 dev->dev.release = phy_device_release;
162
163 dev->speed = 0;
164 dev->duplex = -1;
165 dev->pause = 0;
166 dev->asym_pause = 0;
167 dev->link = 1;
168 dev->interface = PHY_INTERFACE_MODE_GMII;
169
170 dev->autoneg = AUTONEG_ENABLE;
171
172 dev->is_c45 = is_c45;
173 dev->addr = addr;
174 dev->phy_id = phy_id;
175 if (c45_ids)
176 dev->c45_ids = *c45_ids;
177 dev->bus = bus;
178 dev->dev.parent = bus->parent;
179 dev->dev.bus = &mdio_bus_type;
180 dev->irq = bus->irq != NULL ? bus->irq[addr] : PHY_POLL;
181 dev_set_name(&dev->dev, PHY_ID_FMT, bus->id, addr);
182
183 dev->state = PHY_DOWN;
184
185 mutex_init(&dev->lock);
186 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
187 INIT_WORK(&dev->phy_queue, phy_change);
188
189 /* Request the appropriate module unconditionally; don't
190 * bother trying to do so only if it isn't already loaded,
191 * because that gets complicated. A hotplug event would have
192 * done an unconditional modprobe anyway.
193 * We don't do normal hotplug because it won't work for MDIO
194 * -- because it relies on the device staying around for long
195 * enough for the driver to get loaded. With MDIO, the NIC
196 * driver will get bored and give up as soon as it finds that
197 * there's no driver _already_ loaded.
198 */
199 request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, MDIO_ID_ARGS(phy_id));
200
201 device_initialize(&dev->dev);
202
203 return dev;
204}
205EXPORT_SYMBOL(phy_device_create);
206
207/**
208 * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.
209 * @bus: the target MII bus
210 * @addr: PHY address on the MII bus
211 * @phy_id: where to store the ID retrieved.
212 * @c45_ids: where to store the c45 ID information.
213 *
214 * If the PHY devices-in-package appears to be valid, it and the
215 * corresponding identifiers are stored in @c45_ids, zero is stored
216 * in @phy_id. Otherwise 0xffffffff is stored in @phy_id. Returns
217 * zero on success.
218 *
219 */
220static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id,
221 struct phy_c45_device_ids *c45_ids) {
222 int phy_reg;
223 int i, reg_addr;
224 const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
225
226 /* Find first non-zero Devices In package. Device
227 * zero is reserved, so don't probe it.
228 */
229 for (i = 1;
230 i < num_ids && c45_ids->devices_in_package == 0;
231 i++) {
232 reg_addr = MII_ADDR_C45 | i << 16 | 6;
233 phy_reg = mdiobus_read(bus, addr, reg_addr);
234 if (phy_reg < 0)
235 return -EIO;
236 c45_ids->devices_in_package = (phy_reg & 0xffff) << 16;
237
238 reg_addr = MII_ADDR_C45 | i << 16 | 5;
239 phy_reg = mdiobus_read(bus, addr, reg_addr);
240 if (phy_reg < 0)
241 return -EIO;
242 c45_ids->devices_in_package |= (phy_reg & 0xffff);
243
244 /* If mostly Fs, there is no device there,
245 * let's get out of here.
246 */
247 if ((c45_ids->devices_in_package & 0x1fffffff) == 0x1fffffff) {
248 *phy_id = 0xffffffff;
249 return 0;
250 }
251 }
252
253 /* Now probe Device Identifiers for each device present. */
254 for (i = 1; i < num_ids; i++) {
255 if (!(c45_ids->devices_in_package & (1 << i)))
256 continue;
257
258 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID1;
259 phy_reg = mdiobus_read(bus, addr, reg_addr);
260 if (phy_reg < 0)
261 return -EIO;
262 c45_ids->device_ids[i] = (phy_reg & 0xffff) << 16;
263
264 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID2;
265 phy_reg = mdiobus_read(bus, addr, reg_addr);
266 if (phy_reg < 0)
267 return -EIO;
268 c45_ids->device_ids[i] |= (phy_reg & 0xffff);
269 }
270 *phy_id = 0;
271 return 0;
272}
273
274/**
275 * get_phy_id - reads the specified addr for its ID.
276 * @bus: the target MII bus
277 * @addr: PHY address on the MII bus
278 * @phy_id: where to store the ID retrieved.
279 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
280 * @c45_ids: where to store the c45 ID information.
281 *
282 * Description: In the case of a 802.3-c22 PHY, reads the ID registers
283 * of the PHY at @addr on the @bus, stores it in @phy_id and returns
284 * zero on success.
285 *
286 * In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and
287 * its return value is in turn returned.
288 *
289 */
290static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id,
291 bool is_c45, struct phy_c45_device_ids *c45_ids)
292{
293 int phy_reg;
294
295 if (is_c45)
296 return get_phy_c45_ids(bus, addr, phy_id, c45_ids);
297
298 /* Grab the bits from PHYIR1, and put them in the upper half */
299 phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
300 if (phy_reg < 0)
301 return -EIO;
302
303 *phy_id = (phy_reg & 0xffff) << 16;
304
305 /* Grab the bits from PHYIR2, and put them in the lower half */
306 phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
307 if (phy_reg < 0)
308 return -EIO;
309
310 *phy_id |= (phy_reg & 0xffff);
311
312 return 0;
313}
314
315/**
316 * get_phy_device - reads the specified PHY device and returns its @phy_device
317 * struct
318 * @bus: the target MII bus
319 * @addr: PHY address on the MII bus
320 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
321 *
322 * Description: Reads the ID registers of the PHY at @addr on the
323 * @bus, then allocates and returns the phy_device to represent it.
324 */
325struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
326{
327 struct phy_c45_device_ids c45_ids = {0};
328 u32 phy_id = 0;
329 int r;
330
331 r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids);
332 if (r)
333 return ERR_PTR(r);
334
335 /* If the phy_id is mostly Fs, there is no device there */
336 if ((phy_id & 0x1fffffff) == 0x1fffffff)
337 return NULL;
338
339 return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);
340}
341EXPORT_SYMBOL(get_phy_device);
342
343/**
344 * phy_device_register - Register the phy device on the MDIO bus
345 * @phydev: phy_device structure to be added to the MDIO bus
346 */
347int phy_device_register(struct phy_device *phydev)
348{
349 int err;
350
351 /* Don't register a phy if one is already registered at this address */
352 if (phydev->bus->phy_map[phydev->addr])
353 return -EINVAL;
354 phydev->bus->phy_map[phydev->addr] = phydev;
355
356 /* Run all of the fixups for this PHY */
357 err = phy_init_hw(phydev);
358 if (err) {
359 pr_err("PHY %d failed to initialize\n", phydev->addr);
360 goto out;
361 }
362
363 err = device_add(&phydev->dev);
364 if (err) {
365 pr_err("PHY %d failed to add\n", phydev->addr);
366 goto out;
367 }
368
369 return 0;
370
371 out:
372 phydev->bus->phy_map[phydev->addr] = NULL;
373 return err;
374}
375EXPORT_SYMBOL(phy_device_register);
376
377/**
378 * phy_find_first - finds the first PHY device on the bus
379 * @bus: the target MII bus
380 */
381struct phy_device *phy_find_first(struct mii_bus *bus)
382{
383 int addr;
384
385 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
386 if (bus->phy_map[addr])
387 return bus->phy_map[addr];
388 }
389 return NULL;
390}
391EXPORT_SYMBOL(phy_find_first);
392
393/**
394 * phy_prepare_link - prepares the PHY layer to monitor link status
395 * @phydev: target phy_device struct
396 * @handler: callback function for link status change notifications
397 *
398 * Description: Tells the PHY infrastructure to handle the
399 * gory details on monitoring link status (whether through
400 * polling or an interrupt), and to call back to the
401 * connected device driver when the link status changes.
402 * If you want to monitor your own link state, don't call
403 * this function.
404 */
405static void phy_prepare_link(struct phy_device *phydev,
406 void (*handler)(struct net_device *))
407{
408 phydev->adjust_link = handler;
409}
410
411/**
412 * phy_connect_direct - connect an ethernet device to a specific phy_device
413 * @dev: the network device to connect
414 * @phydev: the pointer to the phy device
415 * @handler: callback function for state change notifications
416 * @interface: PHY device's interface
417 */
418int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
419 void (*handler)(struct net_device *),
420 phy_interface_t interface)
421{
422 int rc;
423
424 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
425 if (rc)
426 return rc;
427
428 phy_prepare_link(phydev, handler);
429 phy_start_machine(phydev);
430 if (phydev->irq > 0)
431 phy_start_interrupts(phydev);
432
433 return 0;
434}
435EXPORT_SYMBOL(phy_connect_direct);
436
437/**
438 * phy_connect - connect an ethernet device to a PHY device
439 * @dev: the network device to connect
440 * @bus_id: the id string of the PHY device to connect
441 * @handler: callback function for state change notifications
442 * @interface: PHY device's interface
443 *
444 * Description: Convenience function for connecting ethernet
445 * devices to PHY devices. The default behavior is for
446 * the PHY infrastructure to handle everything, and only notify
447 * the connected driver when the link status changes. If you
448 * don't want, or can't use the provided functionality, you may
449 * choose to call only the subset of functions which provide
450 * the desired functionality.
451 */
452struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
453 void (*handler)(struct net_device *),
454 phy_interface_t interface)
455{
456 struct phy_device *phydev;
457 struct device *d;
458 int rc;
459
460 /* Search the list of PHY devices on the mdio bus for the
461 * PHY with the requested name
462 */
463 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
464 if (!d) {
465 pr_err("PHY %s not found\n", bus_id);
466 return ERR_PTR(-ENODEV);
467 }
468 phydev = to_phy_device(d);
469
470 rc = phy_connect_direct(dev, phydev, handler, interface);
471 if (rc)
472 return ERR_PTR(rc);
473
474 return phydev;
475}
476EXPORT_SYMBOL(phy_connect);
477
478/**
479 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY
480 * device
481 * @phydev: target phy_device struct
482 */
483void phy_disconnect(struct phy_device *phydev)
484{
485 if (phydev->irq > 0)
486 phy_stop_interrupts(phydev);
487
488 phy_stop_machine(phydev);
489
490 phydev->adjust_link = NULL;
491
492 phy_detach(phydev);
493}
494EXPORT_SYMBOL(phy_disconnect);
495
496/**
497 * phy_poll_reset - Safely wait until a PHY reset has properly completed
498 * @phydev: The PHY device to poll
499 *
500 * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as
501 * published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR
502 * register must be polled until the BMCR_RESET bit clears.
503 *
504 * Furthermore, any attempts to write to PHY registers may have no effect
505 * or even generate MDIO bus errors until this is complete.
506 *
507 * Some PHYs (such as the Marvell 88E1111) don't entirely conform to the
508 * standard and do not fully reset after the BMCR_RESET bit is set, and may
509 * even *REQUIRE* a soft-reset to properly restart autonegotiation. In an
510 * effort to support such broken PHYs, this function is separate from the
511 * standard phy_init_hw() which will zero all the other bits in the BMCR
512 * and reapply all driver-specific and board-specific fixups.
513 */
514static int phy_poll_reset(struct phy_device *phydev)
515{
516 /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
517 unsigned int retries = 12;
518 int ret;
519
520 do {
521 msleep(50);
522 ret = phy_read(phydev, MII_BMCR);
523 if (ret < 0)
524 return ret;
525 } while (ret & BMCR_RESET && --retries);
526 if (ret & BMCR_RESET)
527 return -ETIMEDOUT;
528
529 /* Some chips (smsc911x) may still need up to another 1ms after the
530 * BMCR_RESET bit is cleared before they are usable.
531 */
532 msleep(1);
533 return 0;
534}
535
536int phy_init_hw(struct phy_device *phydev)
537{
538 int ret = 0;
539
540 if (!phydev->drv || !phydev->drv->config_init)
541 return 0;
542
543 if (phydev->drv->soft_reset)
544 ret = phydev->drv->soft_reset(phydev);
545 else
546 ret = genphy_soft_reset(phydev);
547
548 if (ret < 0)
549 return ret;
550
551 ret = phy_scan_fixups(phydev);
552 if (ret < 0)
553 return ret;
554
555 return phydev->drv->config_init(phydev);
556}
557EXPORT_SYMBOL(phy_init_hw);
558
559/**
560 * phy_attach_direct - attach a network device to a given PHY device pointer
561 * @dev: network device to attach
562 * @phydev: Pointer to phy_device to attach
563 * @flags: PHY device's dev_flags
564 * @interface: PHY device's interface
565 *
566 * Description: Called by drivers to attach to a particular PHY
567 * device. The phy_device is found, and properly hooked up
568 * to the phy_driver. If no driver is attached, then a
569 * generic driver is used. The phy_device is given a ptr to
570 * the attaching device, and given a callback for link status
571 * change. The phy_device is returned to the attaching driver.
572 */
573int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
574 u32 flags, phy_interface_t interface)
575{
576 struct device *d = &phydev->dev;
577 int err;
578
579 /* Assume that if there is no driver, that it doesn't
580 * exist, and we should use the genphy driver.
581 */
582 if (NULL == d->driver) {
583 if (phydev->is_c45)
584 d->driver = &genphy_driver[GENPHY_DRV_10G].driver;
585 else
586 d->driver = &genphy_driver[GENPHY_DRV_1G].driver;
587
588 err = d->driver->probe(d);
589 if (err >= 0)
590 err = device_bind_driver(d);
591
592 if (err)
593 return err;
594 }
595
596 if (phydev->attached_dev) {
597 dev_err(&dev->dev, "PHY already attached\n");
598 return -EBUSY;
599 }
600
601 phydev->attached_dev = dev;
602 dev->phydev = phydev;
603
604 phydev->dev_flags = flags;
605
606 phydev->interface = interface;
607
608 phydev->state = PHY_READY;
609
610 /* Do initial configuration here, now that
611 * we have certain key parameters
612 * (dev_flags and interface)
613 */
614 err = phy_init_hw(phydev);
615 if (err)
616 phy_detach(phydev);
617 else
618 phy_resume(phydev);
619
620 return err;
621}
622EXPORT_SYMBOL(phy_attach_direct);
623
624/**
625 * phy_attach - attach a network device to a particular PHY device
626 * @dev: network device to attach
627 * @bus_id: Bus ID of PHY device to attach
628 * @interface: PHY device's interface
629 *
630 * Description: Same as phy_attach_direct() except that a PHY bus_id
631 * string is passed instead of a pointer to a struct phy_device.
632 */
633struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
634 phy_interface_t interface)
635{
636 struct bus_type *bus = &mdio_bus_type;
637 struct phy_device *phydev;
638 struct device *d;
639 int rc;
640
641 /* Search the list of PHY devices on the mdio bus for the
642 * PHY with the requested name
643 */
644 d = bus_find_device_by_name(bus, NULL, bus_id);
645 if (!d) {
646 pr_err("PHY %s not found\n", bus_id);
647 return ERR_PTR(-ENODEV);
648 }
649 phydev = to_phy_device(d);
650
651 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
652 if (rc)
653 return ERR_PTR(rc);
654
655 return phydev;
656}
657EXPORT_SYMBOL(phy_attach);
658
659/**
660 * phy_detach - detach a PHY device from its network device
661 * @phydev: target phy_device struct
662 */
663void phy_detach(struct phy_device *phydev)
664{
665 int i;
666 phydev->attached_dev->phydev = NULL;
667 phydev->attached_dev = NULL;
668 phy_suspend(phydev);
669
670 /* If the device had no specific driver before (i.e. - it
671 * was using the generic driver), we unbind the device
672 * from the generic driver so that there's a chance a
673 * real driver could be loaded
674 */
675 for (i = 0; i < ARRAY_SIZE(genphy_driver); i++) {
676 if (phydev->dev.driver == &genphy_driver[i].driver) {
677 device_release_driver(&phydev->dev);
678 break;
679 }
680 }
681}
682EXPORT_SYMBOL(phy_detach);
683
684int phy_suspend(struct phy_device *phydev)
685{
686 struct phy_driver *phydrv = to_phy_driver(phydev->dev.driver);
687 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
688
689 /* If the device has WOL enabled, we cannot suspend the PHY */
690 phy_ethtool_get_wol(phydev, &wol);
691 if (wol.wolopts)
692 return -EBUSY;
693
694 if (phydrv->suspend)
695 return phydrv->suspend(phydev);
696 return 0;
697}
698
699int phy_resume(struct phy_device *phydev)
700{
701 struct phy_driver *phydrv = to_phy_driver(phydev->dev.driver);
702
703 if (phydrv->resume)
704 return phydrv->resume(phydev);
705 return 0;
706}
707
708/* Generic PHY support and helper functions */
709
710/**
711 * genphy_config_advert - sanitize and advertise auto-negotiation parameters
712 * @phydev: target phy_device struct
713 *
714 * Description: Writes MII_ADVERTISE with the appropriate values,
715 * after sanitizing the values to make sure we only advertise
716 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
717 * hasn't changed, and > 0 if it has changed.
718 */
719static int genphy_config_advert(struct phy_device *phydev)
720{
721 u32 advertise;
722 int oldadv, adv, bmsr;
723 int err, changed = 0;
724
725 /* Only allow advertising what this PHY supports */
726 phydev->advertising &= phydev->supported;
727 advertise = phydev->advertising;
728
729 /* Setup standard advertisement */
730 adv = phy_read(phydev, MII_ADVERTISE);
731 if (adv < 0)
732 return adv;
733
734 oldadv = adv;
735 adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP |
736 ADVERTISE_PAUSE_ASYM);
737 adv |= ethtool_adv_to_mii_adv_t(advertise);
738
739 if (adv != oldadv) {
740 err = phy_write(phydev, MII_ADVERTISE, adv);
741
742 if (err < 0)
743 return err;
744 changed = 1;
745 }
746
747 bmsr = phy_read(phydev, MII_BMSR);
748 if (bmsr < 0)
749 return bmsr;
750
751 /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
752 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
753 * logical 1.
754 */
755 if (!(bmsr & BMSR_ESTATEN))
756 return changed;
757
758 /* Configure gigabit if it's supported */
759 adv = phy_read(phydev, MII_CTRL1000);
760 if (adv < 0)
761 return adv;
762
763 oldadv = adv;
764 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
765
766 if (phydev->supported & (SUPPORTED_1000baseT_Half |
767 SUPPORTED_1000baseT_Full)) {
768 adv |= ethtool_adv_to_mii_ctrl1000_t(advertise);
769 if (adv != oldadv)
770 changed = 1;
771 }
772
773 err = phy_write(phydev, MII_CTRL1000, adv);
774 if (err < 0)
775 return err;
776
777 return changed;
778}
779
780/**
781 * genphy_setup_forced - configures/forces speed/duplex from @phydev
782 * @phydev: target phy_device struct
783 *
784 * Description: Configures MII_BMCR to force speed/duplex
785 * to the values in phydev. Assumes that the values are valid.
786 * Please see phy_sanitize_settings().
787 */
788int genphy_setup_forced(struct phy_device *phydev)
789{
790 int ctl = 0;
791
792 phydev->pause = 0;
793 phydev->asym_pause = 0;
794
795 if (SPEED_1000 == phydev->speed)
796 ctl |= BMCR_SPEED1000;
797 else if (SPEED_100 == phydev->speed)
798 ctl |= BMCR_SPEED100;
799
800 if (DUPLEX_FULL == phydev->duplex)
801 ctl |= BMCR_FULLDPLX;
802
803 return phy_write(phydev, MII_BMCR, ctl);
804}
805EXPORT_SYMBOL(genphy_setup_forced);
806
807/**
808 * genphy_restart_aneg - Enable and Restart Autonegotiation
809 * @phydev: target phy_device struct
810 */
811int genphy_restart_aneg(struct phy_device *phydev)
812{
813 int ctl = phy_read(phydev, MII_BMCR);
814
815 if (ctl < 0)
816 return ctl;
817
818 ctl |= BMCR_ANENABLE | BMCR_ANRESTART;
819
820 /* Don't isolate the PHY if we're negotiating */
821 ctl &= ~BMCR_ISOLATE;
822
823 return phy_write(phydev, MII_BMCR, ctl);
824}
825EXPORT_SYMBOL(genphy_restart_aneg);
826
827/**
828 * genphy_config_aneg - restart auto-negotiation or write BMCR
829 * @phydev: target phy_device struct
830 *
831 * Description: If auto-negotiation is enabled, we configure the
832 * advertising, and then restart auto-negotiation. If it is not
833 * enabled, then we write the BMCR.
834 */
835int genphy_config_aneg(struct phy_device *phydev)
836{
837 int result;
838
839 if (AUTONEG_ENABLE != phydev->autoneg)
840 return genphy_setup_forced(phydev);
841
842 result = genphy_config_advert(phydev);
843 if (result < 0) /* error */
844 return result;
845 if (result == 0) {
846 /* Advertisement hasn't changed, but maybe aneg was never on to
847 * begin with? Or maybe phy was isolated?
848 */
849 int ctl = phy_read(phydev, MII_BMCR);
850
851 if (ctl < 0)
852 return ctl;
853
854 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
855 result = 1; /* do restart aneg */
856 }
857
858 /* Only restart aneg if we are advertising something different
859 * than we were before.
860 */
861 if (result > 0)
862 result = genphy_restart_aneg(phydev);
863
864 return result;
865}
866EXPORT_SYMBOL(genphy_config_aneg);
867
868/**
869 * genphy_aneg_done - return auto-negotiation status
870 * @phydev: target phy_device struct
871 *
872 * Description: Reads the status register and returns 0 either if
873 * auto-negotiation is incomplete, or if there was an error.
874 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.
875 */
876int genphy_aneg_done(struct phy_device *phydev)
877{
878 int retval = phy_read(phydev, MII_BMSR);
879
880 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
881}
882EXPORT_SYMBOL(genphy_aneg_done);
883
884static int gen10g_config_aneg(struct phy_device *phydev)
885{
886 return 0;
887}
888
889/**
890 * genphy_update_link - update link status in @phydev
891 * @phydev: target phy_device struct
892 *
893 * Description: Update the value in phydev->link to reflect the
894 * current link value. In order to do this, we need to read
895 * the status register twice, keeping the second value.
896 */
897int genphy_update_link(struct phy_device *phydev)
898{
899 int status;
900
901 /* Do a fake read */
902 status = phy_read(phydev, MII_BMSR);
903 if (status < 0)
904 return status;
905
906 /* Read link and autonegotiation status */
907 status = phy_read(phydev, MII_BMSR);
908 if (status < 0)
909 return status;
910
911 if ((status & BMSR_LSTATUS) == 0)
912 phydev->link = 0;
913 else
914 phydev->link = 1;
915
916 return 0;
917}
918EXPORT_SYMBOL(genphy_update_link);
919
920/**
921 * genphy_read_status - check the link status and update current link state
922 * @phydev: target phy_device struct
923 *
924 * Description: Check the link, then figure out the current state
925 * by comparing what we advertise with what the link partner
926 * advertises. Start by checking the gigabit possibilities,
927 * then move on to 10/100.
928 */
929int genphy_read_status(struct phy_device *phydev)
930{
931 int adv;
932 int err;
933 int lpa;
934 int lpagb = 0;
935 int common_adv;
936 int common_adv_gb = 0;
937
938 /* Update the link, but return if there was an error */
939 err = genphy_update_link(phydev);
940 if (err)
941 return err;
942
943 phydev->lp_advertising = 0;
944
945 if (AUTONEG_ENABLE == phydev->autoneg) {
946 if (phydev->supported & (SUPPORTED_1000baseT_Half
947 | SUPPORTED_1000baseT_Full)) {
948 lpagb = phy_read(phydev, MII_STAT1000);
949 if (lpagb < 0)
950 return lpagb;
951
952 adv = phy_read(phydev, MII_CTRL1000);
953 if (adv < 0)
954 return adv;
955
956 phydev->lp_advertising =
957 mii_stat1000_to_ethtool_lpa_t(lpagb);
958 common_adv_gb = lpagb & adv << 2;
959 }
960
961 lpa = phy_read(phydev, MII_LPA);
962 if (lpa < 0)
963 return lpa;
964
965 phydev->lp_advertising |= mii_lpa_to_ethtool_lpa_t(lpa);
966
967 adv = phy_read(phydev, MII_ADVERTISE);
968 if (adv < 0)
969 return adv;
970
971 common_adv = lpa & adv;
972
973 phydev->speed = SPEED_10;
974 phydev->duplex = DUPLEX_HALF;
975 phydev->pause = 0;
976 phydev->asym_pause = 0;
977
978 if (common_adv_gb & (LPA_1000FULL | LPA_1000HALF)) {
979 phydev->speed = SPEED_1000;
980
981 if (common_adv_gb & LPA_1000FULL)
982 phydev->duplex = DUPLEX_FULL;
983 } else if (common_adv & (LPA_100FULL | LPA_100HALF)) {
984 phydev->speed = SPEED_100;
985
986 if (common_adv & LPA_100FULL)
987 phydev->duplex = DUPLEX_FULL;
988 } else
989 if (common_adv & LPA_10FULL)
990 phydev->duplex = DUPLEX_FULL;
991
992 if (phydev->duplex == DUPLEX_FULL) {
993 phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
994 phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
995 }
996 } else {
997 int bmcr = phy_read(phydev, MII_BMCR);
998
999 if (bmcr < 0)
1000 return bmcr;
1001
1002 if (bmcr & BMCR_FULLDPLX)
1003 phydev->duplex = DUPLEX_FULL;
1004 else
1005 phydev->duplex = DUPLEX_HALF;
1006
1007 if (bmcr & BMCR_SPEED1000)
1008 phydev->speed = SPEED_1000;
1009 else if (bmcr & BMCR_SPEED100)
1010 phydev->speed = SPEED_100;
1011 else
1012 phydev->speed = SPEED_10;
1013
1014 phydev->pause = 0;
1015 phydev->asym_pause = 0;
1016 }
1017
1018 return 0;
1019}
1020EXPORT_SYMBOL(genphy_read_status);
1021
1022static int gen10g_read_status(struct phy_device *phydev)
1023{
1024 int devad, reg;
1025 u32 mmd_mask = phydev->c45_ids.devices_in_package;
1026
1027 phydev->link = 1;
1028
1029 /* For now just lie and say it's 10G all the time */
1030 phydev->speed = SPEED_10000;
1031 phydev->duplex = DUPLEX_FULL;
1032
1033 for (devad = 0; mmd_mask; devad++, mmd_mask = mmd_mask >> 1) {
1034 if (!(mmd_mask & 1))
1035 continue;
1036
1037 /* Read twice because link state is latched and a
1038 * read moves the current state into the register
1039 */
1040 phy_read_mmd(phydev, devad, MDIO_STAT1);
1041 reg = phy_read_mmd(phydev, devad, MDIO_STAT1);
1042 if (reg < 0 || !(reg & MDIO_STAT1_LSTATUS))
1043 phydev->link = 0;
1044 }
1045
1046 return 0;
1047}
1048
1049/**
1050 * genphy_soft_reset - software reset the PHY via BMCR_RESET bit
1051 * @phydev: target phy_device struct
1052 *
1053 * Description: Perform a software PHY reset using the standard
1054 * BMCR_RESET bit and poll for the reset bit to be cleared.
1055 *
1056 * Returns: 0 on success, < 0 on failure
1057 */
1058int genphy_soft_reset(struct phy_device *phydev)
1059{
1060 int ret;
1061
1062 ret = phy_write(phydev, MII_BMCR, BMCR_RESET);
1063 if (ret < 0)
1064 return ret;
1065
1066 return phy_poll_reset(phydev);
1067}
1068EXPORT_SYMBOL(genphy_soft_reset);
1069
1070static int genphy_config_init(struct phy_device *phydev)
1071{
1072 int val;
1073 u32 features;
1074
1075 /* For now, I'll claim that the generic driver supports
1076 * all possible port types
1077 */
1078 features = (SUPPORTED_TP | SUPPORTED_MII
1079 | SUPPORTED_AUI | SUPPORTED_FIBRE |
1080 SUPPORTED_BNC);
1081
1082 /* Do we support autonegotiation? */
1083 val = phy_read(phydev, MII_BMSR);
1084 if (val < 0)
1085 return val;
1086
1087 if (val & BMSR_ANEGCAPABLE)
1088 features |= SUPPORTED_Autoneg;
1089
1090 if (val & BMSR_100FULL)
1091 features |= SUPPORTED_100baseT_Full;
1092 if (val & BMSR_100HALF)
1093 features |= SUPPORTED_100baseT_Half;
1094 if (val & BMSR_10FULL)
1095 features |= SUPPORTED_10baseT_Full;
1096 if (val & BMSR_10HALF)
1097 features |= SUPPORTED_10baseT_Half;
1098
1099 if (val & BMSR_ESTATEN) {
1100 val = phy_read(phydev, MII_ESTATUS);
1101 if (val < 0)
1102 return val;
1103
1104 if (val & ESTATUS_1000_TFULL)
1105 features |= SUPPORTED_1000baseT_Full;
1106 if (val & ESTATUS_1000_THALF)
1107 features |= SUPPORTED_1000baseT_Half;
1108 }
1109
1110 phydev->supported = features;
1111 phydev->advertising = features;
1112
1113 return 0;
1114}
1115
1116static int gen10g_soft_reset(struct phy_device *phydev)
1117{
1118 /* Do nothing for now */
1119 return 0;
1120}
1121
1122static int gen10g_config_init(struct phy_device *phydev)
1123{
1124 /* Temporarily just say we support everything */
1125 phydev->supported = SUPPORTED_10000baseT_Full;
1126 phydev->advertising = SUPPORTED_10000baseT_Full;
1127
1128 return 0;
1129}
1130
1131int genphy_suspend(struct phy_device *phydev)
1132{
1133 int value;
1134
1135 mutex_lock(&phydev->lock);
1136
1137 value = phy_read(phydev, MII_BMCR);
1138 phy_write(phydev, MII_BMCR, value | BMCR_PDOWN);
1139
1140 mutex_unlock(&phydev->lock);
1141
1142 return 0;
1143}
1144EXPORT_SYMBOL(genphy_suspend);
1145
1146static int gen10g_suspend(struct phy_device *phydev)
1147{
1148 return 0;
1149}
1150
1151int genphy_resume(struct phy_device *phydev)
1152{
1153 int value;
1154
1155 mutex_lock(&phydev->lock);
1156
1157 value = phy_read(phydev, MII_BMCR);
1158 phy_write(phydev, MII_BMCR, value & ~BMCR_PDOWN);
1159
1160 mutex_unlock(&phydev->lock);
1161
1162 return 0;
1163}
1164EXPORT_SYMBOL(genphy_resume);
1165
1166static int gen10g_resume(struct phy_device *phydev)
1167{
1168 return 0;
1169}
1170
1171/**
1172 * phy_probe - probe and init a PHY device
1173 * @dev: device to probe and init
1174 *
1175 * Description: Take care of setting up the phy_device structure,
1176 * set the state to READY (the driver's init function should
1177 * set it to STARTING if needed).
1178 */
1179static int phy_probe(struct device *dev)
1180{
1181 struct phy_device *phydev = to_phy_device(dev);
1182 struct device_driver *drv = phydev->dev.driver;
1183 struct phy_driver *phydrv = to_phy_driver(drv);
1184 int err = 0;
1185
1186 phydev->drv = phydrv;
1187
1188 /* Disable the interrupt if the PHY doesn't support it
1189 * but the interrupt is still a valid one
1190 */
1191 if (!(phydrv->flags & PHY_HAS_INTERRUPT) &&
1192 phy_interrupt_is_valid(phydev))
1193 phydev->irq = PHY_POLL;
1194
1195 if (phydrv->flags & PHY_IS_INTERNAL)
1196 phydev->is_internal = true;
1197
1198 mutex_lock(&phydev->lock);
1199
1200 /* Start out supporting everything. Eventually,
1201 * a controller will attach, and may modify one
1202 * or both of these values
1203 */
1204 phydev->supported = phydrv->features;
1205 phydev->advertising = phydrv->features;
1206
1207 /* Set the state to READY by default */
1208 phydev->state = PHY_READY;
1209
1210 if (phydev->drv->probe)
1211 err = phydev->drv->probe(phydev);
1212
1213 mutex_unlock(&phydev->lock);
1214
1215 return err;
1216}
1217
1218static int phy_remove(struct device *dev)
1219{
1220 struct phy_device *phydev = to_phy_device(dev);
1221
1222 mutex_lock(&phydev->lock);
1223 phydev->state = PHY_DOWN;
1224 mutex_unlock(&phydev->lock);
1225
1226 if (phydev->drv->remove)
1227 phydev->drv->remove(phydev);
1228 phydev->drv = NULL;
1229
1230 return 0;
1231}
1232
1233/**
1234 * phy_driver_register - register a phy_driver with the PHY layer
1235 * @new_driver: new phy_driver to register
1236 */
1237int phy_driver_register(struct phy_driver *new_driver)
1238{
1239 int retval;
1240
1241 new_driver->driver.name = new_driver->name;
1242 new_driver->driver.bus = &mdio_bus_type;
1243 new_driver->driver.probe = phy_probe;
1244 new_driver->driver.remove = phy_remove;
1245
1246 retval = driver_register(&new_driver->driver);
1247 if (retval) {
1248 pr_err("%s: Error %d in registering driver\n",
1249 new_driver->name, retval);
1250
1251 return retval;
1252 }
1253
1254 pr_debug("%s: Registered new driver\n", new_driver->name);
1255
1256 return 0;
1257}
1258EXPORT_SYMBOL(phy_driver_register);
1259
1260int phy_drivers_register(struct phy_driver *new_driver, int n)
1261{
1262 int i, ret = 0;
1263
1264 for (i = 0; i < n; i++) {
1265 ret = phy_driver_register(new_driver + i);
1266 if (ret) {
1267 while (i-- > 0)
1268 phy_driver_unregister(new_driver + i);
1269 break;
1270 }
1271 }
1272 return ret;
1273}
1274EXPORT_SYMBOL(phy_drivers_register);
1275
1276void phy_driver_unregister(struct phy_driver *drv)
1277{
1278 driver_unregister(&drv->driver);
1279}
1280EXPORT_SYMBOL(phy_driver_unregister);
1281
1282void phy_drivers_unregister(struct phy_driver *drv, int n)
1283{
1284 int i;
1285
1286 for (i = 0; i < n; i++)
1287 phy_driver_unregister(drv + i);
1288}
1289EXPORT_SYMBOL(phy_drivers_unregister);
1290
1291static struct phy_driver genphy_driver[] = {
1292{
1293 .phy_id = 0xffffffff,
1294 .phy_id_mask = 0xffffffff,
1295 .name = "Generic PHY",
1296 .soft_reset = genphy_soft_reset,
1297 .config_init = genphy_config_init,
1298 .features = 0,
1299 .config_aneg = genphy_config_aneg,
1300 .aneg_done = genphy_aneg_done,
1301 .read_status = genphy_read_status,
1302 .suspend = genphy_suspend,
1303 .resume = genphy_resume,
1304 .driver = { .owner = THIS_MODULE, },
1305}, {
1306 .phy_id = 0xffffffff,
1307 .phy_id_mask = 0xffffffff,
1308 .name = "Generic 10G PHY",
1309 .soft_reset = gen10g_soft_reset,
1310 .config_init = gen10g_config_init,
1311 .features = 0,
1312 .config_aneg = gen10g_config_aneg,
1313 .read_status = gen10g_read_status,
1314 .suspend = gen10g_suspend,
1315 .resume = gen10g_resume,
1316 .driver = {.owner = THIS_MODULE, },
1317} };
1318
1319static int __init phy_init(void)
1320{
1321 int rc;
1322
1323 rc = mdio_bus_init();
1324 if (rc)
1325 return rc;
1326
1327 rc = phy_drivers_register(genphy_driver,
1328 ARRAY_SIZE(genphy_driver));
1329 if (rc)
1330 mdio_bus_exit();
1331
1332 return rc;
1333}
1334
1335static void __exit phy_exit(void)
1336{
1337 phy_drivers_unregister(genphy_driver,
1338 ARRAY_SIZE(genphy_driver));
1339 mdio_bus_exit();
1340}
1341
1342subsys_initcall(phy_init);
1343module_exit(phy_exit);