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/phy_led_triggers.h>
34#include <linux/mdio.h>
35#include <linux/io.h>
36#include <linux/uaccess.h>
37#include <linux/of.h>
38
39#include <asm/irq.h>
40
41MODULE_DESCRIPTION("PHY library");
42MODULE_AUTHOR("Andy Fleming");
43MODULE_LICENSE("GPL");
44
45void phy_device_free(struct phy_device *phydev)
46{
47 put_device(&phydev->mdio.dev);
48}
49EXPORT_SYMBOL(phy_device_free);
50
51static void phy_mdio_device_free(struct mdio_device *mdiodev)
52{
53 struct phy_device *phydev;
54
55 phydev = container_of(mdiodev, struct phy_device, mdio);
56 phy_device_free(phydev);
57}
58
59static void phy_device_release(struct device *dev)
60{
61 kfree(to_phy_device(dev));
62}
63
64static void phy_mdio_device_remove(struct mdio_device *mdiodev)
65{
66 struct phy_device *phydev;
67
68 phydev = container_of(mdiodev, struct phy_device, mdio);
69 phy_device_remove(phydev);
70}
71
72static struct phy_driver genphy_driver;
73extern struct phy_driver genphy_10g_driver;
74
75static LIST_HEAD(phy_fixup_list);
76static DEFINE_MUTEX(phy_fixup_lock);
77
78#ifdef CONFIG_PM
79static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
80{
81 struct device_driver *drv = phydev->mdio.dev.driver;
82 struct phy_driver *phydrv = to_phy_driver(drv);
83 struct net_device *netdev = phydev->attached_dev;
84
85 if (!drv || !phydrv->suspend)
86 return false;
87
88 /* PHY not attached? May suspend if the PHY has not already been
89 * suspended as part of a prior call to phy_disconnect() ->
90 * phy_detach() -> phy_suspend() because the parent netdev might be the
91 * MDIO bus driver and clock gated at this point.
92 */
93 if (!netdev)
94 return !phydev->suspended;
95
96 /* Don't suspend PHY if the attached netdev parent may wakeup.
97 * The parent may point to a PCI device, as in tg3 driver.
98 */
99 if (netdev->dev.parent && device_may_wakeup(netdev->dev.parent))
100 return false;
101
102 /* Also don't suspend PHY if the netdev itself may wakeup. This
103 * is the case for devices w/o underlaying pwr. mgmt. aware bus,
104 * e.g. SoC devices.
105 */
106 if (device_may_wakeup(&netdev->dev))
107 return false;
108
109 return true;
110}
111
112static int mdio_bus_phy_suspend(struct device *dev)
113{
114 struct phy_device *phydev = to_phy_device(dev);
115
116 /* We must stop the state machine manually, otherwise it stops out of
117 * control, possibly with the phydev->lock held. Upon resume, netdev
118 * may call phy routines that try to grab the same lock, and that may
119 * lead to a deadlock.
120 */
121 if (phydev->attached_dev && phydev->adjust_link)
122 phy_stop_machine(phydev);
123
124 if (!mdio_bus_phy_may_suspend(phydev))
125 return 0;
126
127 return phy_suspend(phydev);
128}
129
130static int mdio_bus_phy_resume(struct device *dev)
131{
132 struct phy_device *phydev = to_phy_device(dev);
133 int ret;
134
135 if (!mdio_bus_phy_may_suspend(phydev))
136 goto no_resume;
137
138 ret = phy_resume(phydev);
139 if (ret < 0)
140 return ret;
141
142no_resume:
143 if (phydev->attached_dev && phydev->adjust_link)
144 phy_start_machine(phydev);
145
146 return 0;
147}
148
149static int mdio_bus_phy_restore(struct device *dev)
150{
151 struct phy_device *phydev = to_phy_device(dev);
152 struct net_device *netdev = phydev->attached_dev;
153 int ret;
154
155 if (!netdev)
156 return 0;
157
158 ret = phy_init_hw(phydev);
159 if (ret < 0)
160 return ret;
161
162 /* The PHY needs to renegotiate. */
163 phydev->link = 0;
164 phydev->state = PHY_UP;
165
166 phy_start_machine(phydev);
167
168 return 0;
169}
170
171static const struct dev_pm_ops mdio_bus_phy_pm_ops = {
172 .suspend = mdio_bus_phy_suspend,
173 .resume = mdio_bus_phy_resume,
174 .freeze = mdio_bus_phy_suspend,
175 .thaw = mdio_bus_phy_resume,
176 .restore = mdio_bus_phy_restore,
177};
178
179#define MDIO_BUS_PHY_PM_OPS (&mdio_bus_phy_pm_ops)
180
181#else
182
183#define MDIO_BUS_PHY_PM_OPS NULL
184
185#endif /* CONFIG_PM */
186
187/**
188 * phy_register_fixup - creates a new phy_fixup and adds it to the list
189 * @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID)
190 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
191 * It can also be PHY_ANY_UID
192 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
193 * comparison
194 * @run: The actual code to be run when a matching PHY is found
195 */
196int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
197 int (*run)(struct phy_device *))
198{
199 struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL);
200
201 if (!fixup)
202 return -ENOMEM;
203
204 strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
205 fixup->phy_uid = phy_uid;
206 fixup->phy_uid_mask = phy_uid_mask;
207 fixup->run = run;
208
209 mutex_lock(&phy_fixup_lock);
210 list_add_tail(&fixup->list, &phy_fixup_list);
211 mutex_unlock(&phy_fixup_lock);
212
213 return 0;
214}
215EXPORT_SYMBOL(phy_register_fixup);
216
217/* Registers a fixup to be run on any PHY with the UID in phy_uid */
218int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
219 int (*run)(struct phy_device *))
220{
221 return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
222}
223EXPORT_SYMBOL(phy_register_fixup_for_uid);
224
225/* Registers a fixup to be run on the PHY with id string bus_id */
226int phy_register_fixup_for_id(const char *bus_id,
227 int (*run)(struct phy_device *))
228{
229 return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
230}
231EXPORT_SYMBOL(phy_register_fixup_for_id);
232
233/**
234 * phy_unregister_fixup - remove a phy_fixup from the list
235 * @bus_id: A string matches fixup->bus_id (or PHY_ANY_ID) in phy_fixup_list
236 * @phy_uid: A phy id matches fixup->phy_id (or PHY_ANY_UID) in phy_fixup_list
237 * @phy_uid_mask: Applied to phy_uid and fixup->phy_uid before comparison
238 */
239int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask)
240{
241 struct list_head *pos, *n;
242 struct phy_fixup *fixup;
243 int ret;
244
245 ret = -ENODEV;
246
247 mutex_lock(&phy_fixup_lock);
248 list_for_each_safe(pos, n, &phy_fixup_list) {
249 fixup = list_entry(pos, struct phy_fixup, list);
250
251 if ((!strcmp(fixup->bus_id, bus_id)) &&
252 ((fixup->phy_uid & phy_uid_mask) ==
253 (phy_uid & phy_uid_mask))) {
254 list_del(&fixup->list);
255 kfree(fixup);
256 ret = 0;
257 break;
258 }
259 }
260 mutex_unlock(&phy_fixup_lock);
261
262 return ret;
263}
264EXPORT_SYMBOL(phy_unregister_fixup);
265
266/* Unregisters a fixup of any PHY with the UID in phy_uid */
267int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask)
268{
269 return phy_unregister_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask);
270}
271EXPORT_SYMBOL(phy_unregister_fixup_for_uid);
272
273/* Unregisters a fixup of the PHY with id string bus_id */
274int phy_unregister_fixup_for_id(const char *bus_id)
275{
276 return phy_unregister_fixup(bus_id, PHY_ANY_UID, 0xffffffff);
277}
278EXPORT_SYMBOL(phy_unregister_fixup_for_id);
279
280/* Returns 1 if fixup matches phydev in bus_id and phy_uid.
281 * Fixups can be set to match any in one or more fields.
282 */
283static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
284{
285 if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0)
286 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
287 return 0;
288
289 if ((fixup->phy_uid & fixup->phy_uid_mask) !=
290 (phydev->phy_id & fixup->phy_uid_mask))
291 if (fixup->phy_uid != PHY_ANY_UID)
292 return 0;
293
294 return 1;
295}
296
297/* Runs any matching fixups for this phydev */
298static int phy_scan_fixups(struct phy_device *phydev)
299{
300 struct phy_fixup *fixup;
301
302 mutex_lock(&phy_fixup_lock);
303 list_for_each_entry(fixup, &phy_fixup_list, list) {
304 if (phy_needs_fixup(phydev, fixup)) {
305 int err = fixup->run(phydev);
306
307 if (err < 0) {
308 mutex_unlock(&phy_fixup_lock);
309 return err;
310 }
311 phydev->has_fixups = true;
312 }
313 }
314 mutex_unlock(&phy_fixup_lock);
315
316 return 0;
317}
318
319static int phy_bus_match(struct device *dev, struct device_driver *drv)
320{
321 struct phy_device *phydev = to_phy_device(dev);
322 struct phy_driver *phydrv = to_phy_driver(drv);
323 const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
324 int i;
325
326 if (!(phydrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY))
327 return 0;
328
329 if (phydrv->match_phy_device)
330 return phydrv->match_phy_device(phydev);
331
332 if (phydev->is_c45) {
333 for (i = 1; i < num_ids; i++) {
334 if (!(phydev->c45_ids.devices_in_package & (1 << i)))
335 continue;
336
337 if ((phydrv->phy_id & phydrv->phy_id_mask) ==
338 (phydev->c45_ids.device_ids[i] &
339 phydrv->phy_id_mask))
340 return 1;
341 }
342 return 0;
343 } else {
344 return (phydrv->phy_id & phydrv->phy_id_mask) ==
345 (phydev->phy_id & phydrv->phy_id_mask);
346 }
347}
348
349struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
350 bool is_c45,
351 struct phy_c45_device_ids *c45_ids)
352{
353 struct phy_device *dev;
354 struct mdio_device *mdiodev;
355
356 /* We allocate the device, and initialize the default values */
357 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
358 if (!dev)
359 return ERR_PTR(-ENOMEM);
360
361 mdiodev = &dev->mdio;
362 mdiodev->dev.release = phy_device_release;
363 mdiodev->dev.parent = &bus->dev;
364 mdiodev->dev.bus = &mdio_bus_type;
365 mdiodev->bus = bus;
366 mdiodev->pm_ops = MDIO_BUS_PHY_PM_OPS;
367 mdiodev->bus_match = phy_bus_match;
368 mdiodev->addr = addr;
369 mdiodev->flags = MDIO_DEVICE_FLAG_PHY;
370 mdiodev->device_free = phy_mdio_device_free;
371 mdiodev->device_remove = phy_mdio_device_remove;
372
373 dev->speed = 0;
374 dev->duplex = -1;
375 dev->pause = 0;
376 dev->asym_pause = 0;
377 dev->link = 0;
378 dev->interface = PHY_INTERFACE_MODE_GMII;
379
380 dev->autoneg = AUTONEG_ENABLE;
381
382 dev->is_c45 = is_c45;
383 dev->phy_id = phy_id;
384 if (c45_ids)
385 dev->c45_ids = *c45_ids;
386 dev->irq = bus->irq[addr];
387 dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);
388
389 dev->state = PHY_DOWN;
390
391 mutex_init(&dev->lock);
392 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
393 INIT_WORK(&dev->phy_queue, phy_change_work);
394
395 /* Request the appropriate module unconditionally; don't
396 * bother trying to do so only if it isn't already loaded,
397 * because that gets complicated. A hotplug event would have
398 * done an unconditional modprobe anyway.
399 * We don't do normal hotplug because it won't work for MDIO
400 * -- because it relies on the device staying around for long
401 * enough for the driver to get loaded. With MDIO, the NIC
402 * driver will get bored and give up as soon as it finds that
403 * there's no driver _already_ loaded.
404 */
405 request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, MDIO_ID_ARGS(phy_id));
406
407 device_initialize(&mdiodev->dev);
408
409 return dev;
410}
411EXPORT_SYMBOL(phy_device_create);
412
413/* get_phy_c45_devs_in_pkg - reads a MMD's devices in package registers.
414 * @bus: the target MII bus
415 * @addr: PHY address on the MII bus
416 * @dev_addr: MMD address in the PHY.
417 * @devices_in_package: where to store the devices in package information.
418 *
419 * Description: reads devices in package registers of a MMD at @dev_addr
420 * from PHY at @addr on @bus.
421 *
422 * Returns: 0 on success, -EIO on failure.
423 */
424static int get_phy_c45_devs_in_pkg(struct mii_bus *bus, int addr, int dev_addr,
425 u32 *devices_in_package)
426{
427 int phy_reg, reg_addr;
428
429 reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS2;
430 phy_reg = mdiobus_read(bus, addr, reg_addr);
431 if (phy_reg < 0)
432 return -EIO;
433 *devices_in_package = (phy_reg & 0xffff) << 16;
434
435 reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS1;
436 phy_reg = mdiobus_read(bus, addr, reg_addr);
437 if (phy_reg < 0)
438 return -EIO;
439 *devices_in_package |= (phy_reg & 0xffff);
440
441 return 0;
442}
443
444/**
445 * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.
446 * @bus: the target MII bus
447 * @addr: PHY address on the MII bus
448 * @phy_id: where to store the ID retrieved.
449 * @c45_ids: where to store the c45 ID information.
450 *
451 * If the PHY devices-in-package appears to be valid, it and the
452 * corresponding identifiers are stored in @c45_ids, zero is stored
453 * in @phy_id. Otherwise 0xffffffff is stored in @phy_id. Returns
454 * zero on success.
455 *
456 */
457static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id,
458 struct phy_c45_device_ids *c45_ids) {
459 int phy_reg;
460 int i, reg_addr;
461 const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
462 u32 *devs = &c45_ids->devices_in_package;
463
464 /* Find first non-zero Devices In package. Device zero is reserved
465 * for 802.3 c45 complied PHYs, so don't probe it at first.
466 */
467 for (i = 1; i < num_ids && *devs == 0; i++) {
468 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, i, devs);
469 if (phy_reg < 0)
470 return -EIO;
471
472 if ((*devs & 0x1fffffff) == 0x1fffffff) {
473 /* If mostly Fs, there is no device there,
474 * then let's continue to probe more, as some
475 * 10G PHYs have zero Devices In package,
476 * e.g. Cortina CS4315/CS4340 PHY.
477 */
478 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, 0, devs);
479 if (phy_reg < 0)
480 return -EIO;
481 /* no device there, let's get out of here */
482 if ((*devs & 0x1fffffff) == 0x1fffffff) {
483 *phy_id = 0xffffffff;
484 return 0;
485 } else {
486 break;
487 }
488 }
489 }
490
491 /* Now probe Device Identifiers for each device present. */
492 for (i = 1; i < num_ids; i++) {
493 if (!(c45_ids->devices_in_package & (1 << i)))
494 continue;
495
496 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID1;
497 phy_reg = mdiobus_read(bus, addr, reg_addr);
498 if (phy_reg < 0)
499 return -EIO;
500 c45_ids->device_ids[i] = (phy_reg & 0xffff) << 16;
501
502 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID2;
503 phy_reg = mdiobus_read(bus, addr, reg_addr);
504 if (phy_reg < 0)
505 return -EIO;
506 c45_ids->device_ids[i] |= (phy_reg & 0xffff);
507 }
508 *phy_id = 0;
509 return 0;
510}
511
512/**
513 * get_phy_id - reads the specified addr for its ID.
514 * @bus: the target MII bus
515 * @addr: PHY address on the MII bus
516 * @phy_id: where to store the ID retrieved.
517 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
518 * @c45_ids: where to store the c45 ID information.
519 *
520 * Description: In the case of a 802.3-c22 PHY, reads the ID registers
521 * of the PHY at @addr on the @bus, stores it in @phy_id and returns
522 * zero on success.
523 *
524 * In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and
525 * its return value is in turn returned.
526 *
527 */
528static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id,
529 bool is_c45, struct phy_c45_device_ids *c45_ids)
530{
531 int phy_reg;
532
533 if (is_c45)
534 return get_phy_c45_ids(bus, addr, phy_id, c45_ids);
535
536 /* Grab the bits from PHYIR1, and put them in the upper half */
537 phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
538 if (phy_reg < 0) {
539 /* if there is no device, return without an error so scanning
540 * the bus works properly
541 */
542 if (phy_reg == -EIO || phy_reg == -ENODEV) {
543 *phy_id = 0xffffffff;
544 return 0;
545 }
546
547 return -EIO;
548 }
549
550 *phy_id = (phy_reg & 0xffff) << 16;
551
552 /* Grab the bits from PHYIR2, and put them in the lower half */
553 phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
554 if (phy_reg < 0)
555 return -EIO;
556
557 *phy_id |= (phy_reg & 0xffff);
558
559 return 0;
560}
561
562/**
563 * get_phy_device - reads the specified PHY device and returns its @phy_device
564 * struct
565 * @bus: the target MII bus
566 * @addr: PHY address on the MII bus
567 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
568 *
569 * Description: Reads the ID registers of the PHY at @addr on the
570 * @bus, then allocates and returns the phy_device to represent it.
571 */
572struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
573{
574 struct phy_c45_device_ids c45_ids = {0};
575 u32 phy_id = 0;
576 int r;
577
578 r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids);
579 if (r)
580 return ERR_PTR(r);
581
582 /* If the phy_id is mostly Fs, there is no device there */
583 if ((phy_id & 0x1fffffff) == 0x1fffffff)
584 return ERR_PTR(-ENODEV);
585
586 return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);
587}
588EXPORT_SYMBOL(get_phy_device);
589
590static ssize_t
591phy_id_show(struct device *dev, struct device_attribute *attr, char *buf)
592{
593 struct phy_device *phydev = to_phy_device(dev);
594
595 return sprintf(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);
596}
597static DEVICE_ATTR_RO(phy_id);
598
599static ssize_t
600phy_interface_show(struct device *dev, struct device_attribute *attr, char *buf)
601{
602 struct phy_device *phydev = to_phy_device(dev);
603 const char *mode = NULL;
604
605 if (phy_is_internal(phydev))
606 mode = "internal";
607 else
608 mode = phy_modes(phydev->interface);
609
610 return sprintf(buf, "%s\n", mode);
611}
612static DEVICE_ATTR_RO(phy_interface);
613
614static ssize_t
615phy_has_fixups_show(struct device *dev, struct device_attribute *attr,
616 char *buf)
617{
618 struct phy_device *phydev = to_phy_device(dev);
619
620 return sprintf(buf, "%d\n", phydev->has_fixups);
621}
622static DEVICE_ATTR_RO(phy_has_fixups);
623
624static struct attribute *phy_dev_attrs[] = {
625 &dev_attr_phy_id.attr,
626 &dev_attr_phy_interface.attr,
627 &dev_attr_phy_has_fixups.attr,
628 NULL,
629};
630ATTRIBUTE_GROUPS(phy_dev);
631
632/**
633 * phy_device_register - Register the phy device on the MDIO bus
634 * @phydev: phy_device structure to be added to the MDIO bus
635 */
636int phy_device_register(struct phy_device *phydev)
637{
638 int err;
639
640 err = mdiobus_register_device(&phydev->mdio);
641 if (err)
642 return err;
643
644 /* Deassert the reset signal */
645 phy_device_reset(phydev, 0);
646
647 /* Run all of the fixups for this PHY */
648 err = phy_scan_fixups(phydev);
649 if (err) {
650 pr_err("PHY %d failed to initialize\n", phydev->mdio.addr);
651 goto out;
652 }
653
654 phydev->mdio.dev.groups = phy_dev_groups;
655
656 err = device_add(&phydev->mdio.dev);
657 if (err) {
658 pr_err("PHY %d failed to add\n", phydev->mdio.addr);
659 goto out;
660 }
661
662 return 0;
663
664 out:
665 /* Assert the reset signal */
666 phy_device_reset(phydev, 1);
667
668 mdiobus_unregister_device(&phydev->mdio);
669 return err;
670}
671EXPORT_SYMBOL(phy_device_register);
672
673/**
674 * phy_device_remove - Remove a previously registered phy device from the MDIO bus
675 * @phydev: phy_device structure to remove
676 *
677 * This doesn't free the phy_device itself, it merely reverses the effects
678 * of phy_device_register(). Use phy_device_free() to free the device
679 * after calling this function.
680 */
681void phy_device_remove(struct phy_device *phydev)
682{
683 device_del(&phydev->mdio.dev);
684
685 /* Assert the reset signal */
686 phy_device_reset(phydev, 1);
687
688 mdiobus_unregister_device(&phydev->mdio);
689}
690EXPORT_SYMBOL(phy_device_remove);
691
692/**
693 * phy_find_first - finds the first PHY device on the bus
694 * @bus: the target MII bus
695 */
696struct phy_device *phy_find_first(struct mii_bus *bus)
697{
698 struct phy_device *phydev;
699 int addr;
700
701 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
702 phydev = mdiobus_get_phy(bus, addr);
703 if (phydev)
704 return phydev;
705 }
706 return NULL;
707}
708EXPORT_SYMBOL(phy_find_first);
709
710static void phy_link_change(struct phy_device *phydev, bool up, bool do_carrier)
711{
712 struct net_device *netdev = phydev->attached_dev;
713
714 if (do_carrier) {
715 if (up)
716 netif_carrier_on(netdev);
717 else
718 netif_carrier_off(netdev);
719 }
720 phydev->adjust_link(netdev);
721}
722
723/**
724 * phy_prepare_link - prepares the PHY layer to monitor link status
725 * @phydev: target phy_device struct
726 * @handler: callback function for link status change notifications
727 *
728 * Description: Tells the PHY infrastructure to handle the
729 * gory details on monitoring link status (whether through
730 * polling or an interrupt), and to call back to the
731 * connected device driver when the link status changes.
732 * If you want to monitor your own link state, don't call
733 * this function.
734 */
735static void phy_prepare_link(struct phy_device *phydev,
736 void (*handler)(struct net_device *))
737{
738 phydev->adjust_link = handler;
739}
740
741/**
742 * phy_connect_direct - connect an ethernet device to a specific phy_device
743 * @dev: the network device to connect
744 * @phydev: the pointer to the phy device
745 * @handler: callback function for state change notifications
746 * @interface: PHY device's interface
747 */
748int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
749 void (*handler)(struct net_device *),
750 phy_interface_t interface)
751{
752 int rc;
753
754 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
755 if (rc)
756 return rc;
757
758 phy_prepare_link(phydev, handler);
759 phy_start_machine(phydev);
760 if (phydev->irq > 0)
761 phy_start_interrupts(phydev);
762
763 return 0;
764}
765EXPORT_SYMBOL(phy_connect_direct);
766
767/**
768 * phy_connect - connect an ethernet device to a PHY device
769 * @dev: the network device to connect
770 * @bus_id: the id string of the PHY device to connect
771 * @handler: callback function for state change notifications
772 * @interface: PHY device's interface
773 *
774 * Description: Convenience function for connecting ethernet
775 * devices to PHY devices. The default behavior is for
776 * the PHY infrastructure to handle everything, and only notify
777 * the connected driver when the link status changes. If you
778 * don't want, or can't use the provided functionality, you may
779 * choose to call only the subset of functions which provide
780 * the desired functionality.
781 */
782struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
783 void (*handler)(struct net_device *),
784 phy_interface_t interface)
785{
786 struct phy_device *phydev;
787 struct device *d;
788 int rc;
789
790 /* Search the list of PHY devices on the mdio bus for the
791 * PHY with the requested name
792 */
793 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
794 if (!d) {
795 pr_err("PHY %s not found\n", bus_id);
796 return ERR_PTR(-ENODEV);
797 }
798 phydev = to_phy_device(d);
799
800 rc = phy_connect_direct(dev, phydev, handler, interface);
801 put_device(d);
802 if (rc)
803 return ERR_PTR(rc);
804
805 return phydev;
806}
807EXPORT_SYMBOL(phy_connect);
808
809/**
810 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY
811 * device
812 * @phydev: target phy_device struct
813 */
814void phy_disconnect(struct phy_device *phydev)
815{
816 if (phydev->irq > 0)
817 phy_stop_interrupts(phydev);
818
819 phy_stop_machine(phydev);
820
821 phydev->adjust_link = NULL;
822
823 phy_detach(phydev);
824}
825EXPORT_SYMBOL(phy_disconnect);
826
827/**
828 * phy_poll_reset - Safely wait until a PHY reset has properly completed
829 * @phydev: The PHY device to poll
830 *
831 * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as
832 * published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR
833 * register must be polled until the BMCR_RESET bit clears.
834 *
835 * Furthermore, any attempts to write to PHY registers may have no effect
836 * or even generate MDIO bus errors until this is complete.
837 *
838 * Some PHYs (such as the Marvell 88E1111) don't entirely conform to the
839 * standard and do not fully reset after the BMCR_RESET bit is set, and may
840 * even *REQUIRE* a soft-reset to properly restart autonegotiation. In an
841 * effort to support such broken PHYs, this function is separate from the
842 * standard phy_init_hw() which will zero all the other bits in the BMCR
843 * and reapply all driver-specific and board-specific fixups.
844 */
845static int phy_poll_reset(struct phy_device *phydev)
846{
847 /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
848 unsigned int retries = 12;
849 int ret;
850
851 do {
852 msleep(50);
853 ret = phy_read(phydev, MII_BMCR);
854 if (ret < 0)
855 return ret;
856 } while (ret & BMCR_RESET && --retries);
857 if (ret & BMCR_RESET)
858 return -ETIMEDOUT;
859
860 /* Some chips (smsc911x) may still need up to another 1ms after the
861 * BMCR_RESET bit is cleared before they are usable.
862 */
863 msleep(1);
864 return 0;
865}
866
867int phy_init_hw(struct phy_device *phydev)
868{
869 int ret = 0;
870
871 /* Deassert the reset signal */
872 phy_device_reset(phydev, 0);
873
874 if (!phydev->drv || !phydev->drv->config_init)
875 return 0;
876
877 if (phydev->drv->soft_reset)
878 ret = phydev->drv->soft_reset(phydev);
879 else
880 ret = genphy_soft_reset(phydev);
881
882 if (ret < 0)
883 return ret;
884
885 ret = phy_scan_fixups(phydev);
886 if (ret < 0)
887 return ret;
888
889 return phydev->drv->config_init(phydev);
890}
891EXPORT_SYMBOL(phy_init_hw);
892
893void phy_attached_info(struct phy_device *phydev)
894{
895 phy_attached_print(phydev, NULL);
896}
897EXPORT_SYMBOL(phy_attached_info);
898
899#define ATTACHED_FMT "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%s)"
900void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
901{
902 const char *drv_name = phydev->drv ? phydev->drv->name : "unbound";
903 char *irq_str;
904 char irq_num[8];
905
906 switch(phydev->irq) {
907 case PHY_POLL:
908 irq_str = "POLL";
909 break;
910 case PHY_IGNORE_INTERRUPT:
911 irq_str = "IGNORE";
912 break;
913 default:
914 snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq);
915 irq_str = irq_num;
916 break;
917 }
918
919
920 if (!fmt) {
921 dev_info(&phydev->mdio.dev, ATTACHED_FMT "\n",
922 drv_name, phydev_name(phydev),
923 irq_str);
924 } else {
925 va_list ap;
926
927 dev_info(&phydev->mdio.dev, ATTACHED_FMT,
928 drv_name, phydev_name(phydev),
929 irq_str);
930
931 va_start(ap, fmt);
932 vprintk(fmt, ap);
933 va_end(ap);
934 }
935}
936EXPORT_SYMBOL(phy_attached_print);
937
938/**
939 * phy_attach_direct - attach a network device to a given PHY device pointer
940 * @dev: network device to attach
941 * @phydev: Pointer to phy_device to attach
942 * @flags: PHY device's dev_flags
943 * @interface: PHY device's interface
944 *
945 * Description: Called by drivers to attach to a particular PHY
946 * device. The phy_device is found, and properly hooked up
947 * to the phy_driver. If no driver is attached, then a
948 * generic driver is used. The phy_device is given a ptr to
949 * the attaching device, and given a callback for link status
950 * change. The phy_device is returned to the attaching driver.
951 * This function takes a reference on the phy device.
952 */
953int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
954 u32 flags, phy_interface_t interface)
955{
956 struct module *ndev_owner = dev->dev.parent->driver->owner;
957 struct mii_bus *bus = phydev->mdio.bus;
958 struct device *d = &phydev->mdio.dev;
959 bool using_genphy = false;
960 int err;
961
962 /* For Ethernet device drivers that register their own MDIO bus, we
963 * will have bus->owner match ndev_mod, so we do not want to increment
964 * our own module->refcnt here, otherwise we would not be able to
965 * unload later on.
966 */
967 if (ndev_owner != bus->owner && !try_module_get(bus->owner)) {
968 dev_err(&dev->dev, "failed to get the bus module\n");
969 return -EIO;
970 }
971
972 get_device(d);
973
974 /* Assume that if there is no driver, that it doesn't
975 * exist, and we should use the genphy driver.
976 */
977 if (!d->driver) {
978 if (phydev->is_c45)
979 d->driver = &genphy_10g_driver.mdiodrv.driver;
980 else
981 d->driver = &genphy_driver.mdiodrv.driver;
982
983 using_genphy = true;
984 }
985
986 if (!try_module_get(d->driver->owner)) {
987 dev_err(&dev->dev, "failed to get the device driver module\n");
988 err = -EIO;
989 goto error_put_device;
990 }
991
992 if (using_genphy) {
993 err = d->driver->probe(d);
994 if (err >= 0)
995 err = device_bind_driver(d);
996
997 if (err)
998 goto error_module_put;
999 }
1000
1001 if (phydev->attached_dev) {
1002 dev_err(&dev->dev, "PHY already attached\n");
1003 err = -EBUSY;
1004 goto error;
1005 }
1006
1007 phydev->phy_link_change = phy_link_change;
1008 phydev->attached_dev = dev;
1009 dev->phydev = phydev;
1010
1011 /* Some Ethernet drivers try to connect to a PHY device before
1012 * calling register_netdevice() -> netdev_register_kobject() and
1013 * does the dev->dev.kobj initialization. Here we only check for
1014 * success which indicates that the network device kobject is
1015 * ready. Once we do that we still need to keep track of whether
1016 * links were successfully set up or not for phy_detach() to
1017 * remove them accordingly.
1018 */
1019 phydev->sysfs_links = false;
1020
1021 err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,
1022 "attached_dev");
1023 if (!err) {
1024 err = sysfs_create_link_nowarn(&dev->dev.kobj,
1025 &phydev->mdio.dev.kobj,
1026 "phydev");
1027 if (err) {
1028 dev_err(&dev->dev, "could not add device link to %s err %d\n",
1029 kobject_name(&phydev->mdio.dev.kobj),
1030 err);
1031 /* non-fatal - some net drivers can use one netdevice
1032 * with more then one phy
1033 */
1034 }
1035
1036 phydev->sysfs_links = true;
1037 }
1038
1039 phydev->dev_flags = flags;
1040
1041 phydev->interface = interface;
1042
1043 phydev->state = PHY_READY;
1044
1045 /* Initial carrier state is off as the phy is about to be
1046 * (re)initialized.
1047 */
1048 netif_carrier_off(phydev->attached_dev);
1049
1050 /* Do initial configuration here, now that
1051 * we have certain key parameters
1052 * (dev_flags and interface)
1053 */
1054 err = phy_init_hw(phydev);
1055 if (err)
1056 goto error;
1057
1058 phy_resume(phydev);
1059 phy_led_triggers_register(phydev);
1060
1061 return err;
1062
1063error:
1064 /* phy_detach() does all of the cleanup below */
1065 phy_detach(phydev);
1066 return err;
1067
1068error_module_put:
1069 module_put(d->driver->owner);
1070error_put_device:
1071 put_device(d);
1072 if (ndev_owner != bus->owner)
1073 module_put(bus->owner);
1074 return err;
1075}
1076EXPORT_SYMBOL(phy_attach_direct);
1077
1078/**
1079 * phy_attach - attach a network device to a particular PHY device
1080 * @dev: network device to attach
1081 * @bus_id: Bus ID of PHY device to attach
1082 * @interface: PHY device's interface
1083 *
1084 * Description: Same as phy_attach_direct() except that a PHY bus_id
1085 * string is passed instead of a pointer to a struct phy_device.
1086 */
1087struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
1088 phy_interface_t interface)
1089{
1090 struct bus_type *bus = &mdio_bus_type;
1091 struct phy_device *phydev;
1092 struct device *d;
1093 int rc;
1094
1095 /* Search the list of PHY devices on the mdio bus for the
1096 * PHY with the requested name
1097 */
1098 d = bus_find_device_by_name(bus, NULL, bus_id);
1099 if (!d) {
1100 pr_err("PHY %s not found\n", bus_id);
1101 return ERR_PTR(-ENODEV);
1102 }
1103 phydev = to_phy_device(d);
1104
1105 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1106 put_device(d);
1107 if (rc)
1108 return ERR_PTR(rc);
1109
1110 return phydev;
1111}
1112EXPORT_SYMBOL(phy_attach);
1113
1114/**
1115 * phy_detach - detach a PHY device from its network device
1116 * @phydev: target phy_device struct
1117 *
1118 * This detaches the phy device from its network device and the phy
1119 * driver, and drops the reference count taken in phy_attach_direct().
1120 */
1121void phy_detach(struct phy_device *phydev)
1122{
1123 struct net_device *dev = phydev->attached_dev;
1124 struct module *ndev_owner = dev->dev.parent->driver->owner;
1125 struct mii_bus *bus;
1126
1127 if (phydev->sysfs_links) {
1128 sysfs_remove_link(&dev->dev.kobj, "phydev");
1129 sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev");
1130 }
1131 phydev->attached_dev->phydev = NULL;
1132 phydev->attached_dev = NULL;
1133 phy_suspend(phydev);
1134 phydev->phylink = NULL;
1135
1136 phy_led_triggers_unregister(phydev);
1137
1138 module_put(phydev->mdio.dev.driver->owner);
1139
1140 /* If the device had no specific driver before (i.e. - it
1141 * was using the generic driver), we unbind the device
1142 * from the generic driver so that there's a chance a
1143 * real driver could be loaded
1144 */
1145 if (phydev->mdio.dev.driver == &genphy_10g_driver.mdiodrv.driver ||
1146 phydev->mdio.dev.driver == &genphy_driver.mdiodrv.driver)
1147 device_release_driver(&phydev->mdio.dev);
1148
1149 /*
1150 * The phydev might go away on the put_device() below, so avoid
1151 * a use-after-free bug by reading the underlying bus first.
1152 */
1153 bus = phydev->mdio.bus;
1154
1155 put_device(&phydev->mdio.dev);
1156 if (ndev_owner != bus->owner)
1157 module_put(bus->owner);
1158
1159 /* Assert the reset signal */
1160 phy_device_reset(phydev, 1);
1161}
1162EXPORT_SYMBOL(phy_detach);
1163
1164int phy_suspend(struct phy_device *phydev)
1165{
1166 struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1167 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
1168 int ret = 0;
1169
1170 /* If the device has WOL enabled, we cannot suspend the PHY */
1171 phy_ethtool_get_wol(phydev, &wol);
1172 if (wol.wolopts)
1173 return -EBUSY;
1174
1175 if (phydev->drv && phydrv->suspend)
1176 ret = phydrv->suspend(phydev);
1177
1178 if (ret)
1179 return ret;
1180
1181 phydev->suspended = true;
1182
1183 return ret;
1184}
1185EXPORT_SYMBOL(phy_suspend);
1186
1187int __phy_resume(struct phy_device *phydev)
1188{
1189 struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1190 int ret = 0;
1191
1192 WARN_ON(!mutex_is_locked(&phydev->lock));
1193
1194 if (phydev->drv && phydrv->resume)
1195 ret = phydrv->resume(phydev);
1196
1197 if (ret)
1198 return ret;
1199
1200 phydev->suspended = false;
1201
1202 return ret;
1203}
1204EXPORT_SYMBOL(__phy_resume);
1205
1206int phy_resume(struct phy_device *phydev)
1207{
1208 int ret;
1209
1210 mutex_lock(&phydev->lock);
1211 ret = __phy_resume(phydev);
1212 mutex_unlock(&phydev->lock);
1213
1214 return ret;
1215}
1216EXPORT_SYMBOL(phy_resume);
1217
1218int phy_loopback(struct phy_device *phydev, bool enable)
1219{
1220 struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1221 int ret = 0;
1222
1223 mutex_lock(&phydev->lock);
1224
1225 if (enable && phydev->loopback_enabled) {
1226 ret = -EBUSY;
1227 goto out;
1228 }
1229
1230 if (!enable && !phydev->loopback_enabled) {
1231 ret = -EINVAL;
1232 goto out;
1233 }
1234
1235 if (phydev->drv && phydrv->set_loopback)
1236 ret = phydrv->set_loopback(phydev, enable);
1237 else
1238 ret = -EOPNOTSUPP;
1239
1240 if (ret)
1241 goto out;
1242
1243 phydev->loopback_enabled = enable;
1244
1245out:
1246 mutex_unlock(&phydev->lock);
1247 return ret;
1248}
1249EXPORT_SYMBOL(phy_loopback);
1250
1251/**
1252 * phy_reset_after_clk_enable - perform a PHY reset if needed
1253 * @phydev: target phy_device struct
1254 *
1255 * Description: Some PHYs are known to need a reset after their refclk was
1256 * enabled. This function evaluates the flags and perform the reset if it's
1257 * needed. Returns < 0 on error, 0 if the phy wasn't reset and 1 if the phy
1258 * was reset.
1259 */
1260int phy_reset_after_clk_enable(struct phy_device *phydev)
1261{
1262 if (!phydev || !phydev->drv)
1263 return -ENODEV;
1264
1265 if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) {
1266 phy_device_reset(phydev, 1);
1267 phy_device_reset(phydev, 0);
1268 return 1;
1269 }
1270
1271 return 0;
1272}
1273EXPORT_SYMBOL(phy_reset_after_clk_enable);
1274
1275/* Generic PHY support and helper functions */
1276
1277/**
1278 * genphy_config_advert - sanitize and advertise auto-negotiation parameters
1279 * @phydev: target phy_device struct
1280 *
1281 * Description: Writes MII_ADVERTISE with the appropriate values,
1282 * after sanitizing the values to make sure we only advertise
1283 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
1284 * hasn't changed, and > 0 if it has changed.
1285 */
1286static int genphy_config_advert(struct phy_device *phydev)
1287{
1288 u32 advertise;
1289 int oldadv, adv, bmsr;
1290 int err, changed = 0;
1291
1292 /* Only allow advertising what this PHY supports */
1293 phydev->advertising &= phydev->supported;
1294 advertise = phydev->advertising;
1295
1296 /* Setup standard advertisement */
1297 adv = phy_read(phydev, MII_ADVERTISE);
1298 if (adv < 0)
1299 return adv;
1300
1301 oldadv = adv;
1302 adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP |
1303 ADVERTISE_PAUSE_ASYM);
1304 adv |= ethtool_adv_to_mii_adv_t(advertise);
1305
1306 if (adv != oldadv) {
1307 err = phy_write(phydev, MII_ADVERTISE, adv);
1308
1309 if (err < 0)
1310 return err;
1311 changed = 1;
1312 }
1313
1314 bmsr = phy_read(phydev, MII_BMSR);
1315 if (bmsr < 0)
1316 return bmsr;
1317
1318 /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
1319 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
1320 * logical 1.
1321 */
1322 if (!(bmsr & BMSR_ESTATEN))
1323 return changed;
1324
1325 /* Configure gigabit if it's supported */
1326 adv = phy_read(phydev, MII_CTRL1000);
1327 if (adv < 0)
1328 return adv;
1329
1330 oldadv = adv;
1331 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
1332
1333 if (phydev->supported & (SUPPORTED_1000baseT_Half |
1334 SUPPORTED_1000baseT_Full)) {
1335 adv |= ethtool_adv_to_mii_ctrl1000_t(advertise);
1336 }
1337
1338 if (adv != oldadv)
1339 changed = 1;
1340
1341 err = phy_write(phydev, MII_CTRL1000, adv);
1342 if (err < 0)
1343 return err;
1344
1345 return changed;
1346}
1347
1348/**
1349 * genphy_config_eee_advert - disable unwanted eee mode advertisement
1350 * @phydev: target phy_device struct
1351 *
1352 * Description: Writes MDIO_AN_EEE_ADV after disabling unsupported energy
1353 * efficent ethernet modes. Returns 0 if the PHY's advertisement hasn't
1354 * changed, and 1 if it has changed.
1355 */
1356static int genphy_config_eee_advert(struct phy_device *phydev)
1357{
1358 int broken = phydev->eee_broken_modes;
1359 int old_adv, adv;
1360
1361 /* Nothing to disable */
1362 if (!broken)
1363 return 0;
1364
1365 /* If the following call fails, we assume that EEE is not
1366 * supported by the phy. If we read 0, EEE is not advertised
1367 * In both case, we don't need to continue
1368 */
1369 adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1370 if (adv <= 0)
1371 return 0;
1372
1373 old_adv = adv;
1374 adv &= ~broken;
1375
1376 /* Advertising remains unchanged with the broken mask */
1377 if (old_adv == adv)
1378 return 0;
1379
1380 phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, adv);
1381
1382 return 1;
1383}
1384
1385/**
1386 * genphy_setup_forced - configures/forces speed/duplex from @phydev
1387 * @phydev: target phy_device struct
1388 *
1389 * Description: Configures MII_BMCR to force speed/duplex
1390 * to the values in phydev. Assumes that the values are valid.
1391 * Please see phy_sanitize_settings().
1392 */
1393int genphy_setup_forced(struct phy_device *phydev)
1394{
1395 u16 ctl = 0;
1396
1397 phydev->pause = 0;
1398 phydev->asym_pause = 0;
1399
1400 if (SPEED_1000 == phydev->speed)
1401 ctl |= BMCR_SPEED1000;
1402 else if (SPEED_100 == phydev->speed)
1403 ctl |= BMCR_SPEED100;
1404
1405 if (DUPLEX_FULL == phydev->duplex)
1406 ctl |= BMCR_FULLDPLX;
1407
1408 return phy_modify(phydev, MII_BMCR,
1409 ~(BMCR_LOOPBACK | BMCR_ISOLATE | BMCR_PDOWN), ctl);
1410}
1411EXPORT_SYMBOL(genphy_setup_forced);
1412
1413/**
1414 * genphy_restart_aneg - Enable and Restart Autonegotiation
1415 * @phydev: target phy_device struct
1416 */
1417int genphy_restart_aneg(struct phy_device *phydev)
1418{
1419 /* Don't isolate the PHY if we're negotiating */
1420 return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
1421 BMCR_ANENABLE | BMCR_ANRESTART);
1422}
1423EXPORT_SYMBOL(genphy_restart_aneg);
1424
1425/**
1426 * genphy_config_aneg - restart auto-negotiation or write BMCR
1427 * @phydev: target phy_device struct
1428 *
1429 * Description: If auto-negotiation is enabled, we configure the
1430 * advertising, and then restart auto-negotiation. If it is not
1431 * enabled, then we write the BMCR.
1432 */
1433int genphy_config_aneg(struct phy_device *phydev)
1434{
1435 int err, changed;
1436
1437 changed = genphy_config_eee_advert(phydev);
1438
1439 if (AUTONEG_ENABLE != phydev->autoneg)
1440 return genphy_setup_forced(phydev);
1441
1442 err = genphy_config_advert(phydev);
1443 if (err < 0) /* error */
1444 return err;
1445
1446 changed |= err;
1447
1448 if (changed == 0) {
1449 /* Advertisement hasn't changed, but maybe aneg was never on to
1450 * begin with? Or maybe phy was isolated?
1451 */
1452 int ctl = phy_read(phydev, MII_BMCR);
1453
1454 if (ctl < 0)
1455 return ctl;
1456
1457 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
1458 changed = 1; /* do restart aneg */
1459 }
1460
1461 /* Only restart aneg if we are advertising something different
1462 * than we were before.
1463 */
1464 if (changed > 0)
1465 return genphy_restart_aneg(phydev);
1466
1467 return 0;
1468}
1469EXPORT_SYMBOL(genphy_config_aneg);
1470
1471/**
1472 * genphy_aneg_done - return auto-negotiation status
1473 * @phydev: target phy_device struct
1474 *
1475 * Description: Reads the status register and returns 0 either if
1476 * auto-negotiation is incomplete, or if there was an error.
1477 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.
1478 */
1479int genphy_aneg_done(struct phy_device *phydev)
1480{
1481 int retval = phy_read(phydev, MII_BMSR);
1482
1483 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
1484}
1485EXPORT_SYMBOL(genphy_aneg_done);
1486
1487/**
1488 * genphy_update_link - update link status in @phydev
1489 * @phydev: target phy_device struct
1490 *
1491 * Description: Update the value in phydev->link to reflect the
1492 * current link value. In order to do this, we need to read
1493 * the status register twice, keeping the second value.
1494 */
1495int genphy_update_link(struct phy_device *phydev)
1496{
1497 int status;
1498
1499 /* Do a fake read */
1500 status = phy_read(phydev, MII_BMSR);
1501 if (status < 0)
1502 return status;
1503
1504 /* Read link and autonegotiation status */
1505 status = phy_read(phydev, MII_BMSR);
1506 if (status < 0)
1507 return status;
1508
1509 if ((status & BMSR_LSTATUS) == 0)
1510 phydev->link = 0;
1511 else
1512 phydev->link = 1;
1513
1514 return 0;
1515}
1516EXPORT_SYMBOL(genphy_update_link);
1517
1518/**
1519 * genphy_read_status - check the link status and update current link state
1520 * @phydev: target phy_device struct
1521 *
1522 * Description: Check the link, then figure out the current state
1523 * by comparing what we advertise with what the link partner
1524 * advertises. Start by checking the gigabit possibilities,
1525 * then move on to 10/100.
1526 */
1527int genphy_read_status(struct phy_device *phydev)
1528{
1529 int adv;
1530 int err;
1531 int lpa;
1532 int lpagb = 0;
1533 int common_adv;
1534 int common_adv_gb = 0;
1535
1536 /* Update the link, but return if there was an error */
1537 err = genphy_update_link(phydev);
1538 if (err)
1539 return err;
1540
1541 phydev->lp_advertising = 0;
1542
1543 if (AUTONEG_ENABLE == phydev->autoneg) {
1544 if (phydev->supported & (SUPPORTED_1000baseT_Half
1545 | SUPPORTED_1000baseT_Full)) {
1546 lpagb = phy_read(phydev, MII_STAT1000);
1547 if (lpagb < 0)
1548 return lpagb;
1549
1550 adv = phy_read(phydev, MII_CTRL1000);
1551 if (adv < 0)
1552 return adv;
1553
1554 phydev->lp_advertising =
1555 mii_stat1000_to_ethtool_lpa_t(lpagb);
1556 common_adv_gb = lpagb & adv << 2;
1557 }
1558
1559 lpa = phy_read(phydev, MII_LPA);
1560 if (lpa < 0)
1561 return lpa;
1562
1563 phydev->lp_advertising |= mii_lpa_to_ethtool_lpa_t(lpa);
1564
1565 adv = phy_read(phydev, MII_ADVERTISE);
1566 if (adv < 0)
1567 return adv;
1568
1569 common_adv = lpa & adv;
1570
1571 phydev->speed = SPEED_10;
1572 phydev->duplex = DUPLEX_HALF;
1573 phydev->pause = 0;
1574 phydev->asym_pause = 0;
1575
1576 if (common_adv_gb & (LPA_1000FULL | LPA_1000HALF)) {
1577 phydev->speed = SPEED_1000;
1578
1579 if (common_adv_gb & LPA_1000FULL)
1580 phydev->duplex = DUPLEX_FULL;
1581 } else if (common_adv & (LPA_100FULL | LPA_100HALF)) {
1582 phydev->speed = SPEED_100;
1583
1584 if (common_adv & LPA_100FULL)
1585 phydev->duplex = DUPLEX_FULL;
1586 } else
1587 if (common_adv & LPA_10FULL)
1588 phydev->duplex = DUPLEX_FULL;
1589
1590 if (phydev->duplex == DUPLEX_FULL) {
1591 phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
1592 phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
1593 }
1594 } else {
1595 int bmcr = phy_read(phydev, MII_BMCR);
1596
1597 if (bmcr < 0)
1598 return bmcr;
1599
1600 if (bmcr & BMCR_FULLDPLX)
1601 phydev->duplex = DUPLEX_FULL;
1602 else
1603 phydev->duplex = DUPLEX_HALF;
1604
1605 if (bmcr & BMCR_SPEED1000)
1606 phydev->speed = SPEED_1000;
1607 else if (bmcr & BMCR_SPEED100)
1608 phydev->speed = SPEED_100;
1609 else
1610 phydev->speed = SPEED_10;
1611
1612 phydev->pause = 0;
1613 phydev->asym_pause = 0;
1614 }
1615
1616 return 0;
1617}
1618EXPORT_SYMBOL(genphy_read_status);
1619
1620/**
1621 * genphy_soft_reset - software reset the PHY via BMCR_RESET bit
1622 * @phydev: target phy_device struct
1623 *
1624 * Description: Perform a software PHY reset using the standard
1625 * BMCR_RESET bit and poll for the reset bit to be cleared.
1626 *
1627 * Returns: 0 on success, < 0 on failure
1628 */
1629int genphy_soft_reset(struct phy_device *phydev)
1630{
1631 int ret;
1632
1633 ret = phy_write(phydev, MII_BMCR, BMCR_RESET);
1634 if (ret < 0)
1635 return ret;
1636
1637 return phy_poll_reset(phydev);
1638}
1639EXPORT_SYMBOL(genphy_soft_reset);
1640
1641int genphy_config_init(struct phy_device *phydev)
1642{
1643 int val;
1644 u32 features;
1645
1646 features = (SUPPORTED_TP | SUPPORTED_MII
1647 | SUPPORTED_AUI | SUPPORTED_FIBRE |
1648 SUPPORTED_BNC | SUPPORTED_Pause | SUPPORTED_Asym_Pause);
1649
1650 /* Do we support autonegotiation? */
1651 val = phy_read(phydev, MII_BMSR);
1652 if (val < 0)
1653 return val;
1654
1655 if (val & BMSR_ANEGCAPABLE)
1656 features |= SUPPORTED_Autoneg;
1657
1658 if (val & BMSR_100FULL)
1659 features |= SUPPORTED_100baseT_Full;
1660 if (val & BMSR_100HALF)
1661 features |= SUPPORTED_100baseT_Half;
1662 if (val & BMSR_10FULL)
1663 features |= SUPPORTED_10baseT_Full;
1664 if (val & BMSR_10HALF)
1665 features |= SUPPORTED_10baseT_Half;
1666
1667 if (val & BMSR_ESTATEN) {
1668 val = phy_read(phydev, MII_ESTATUS);
1669 if (val < 0)
1670 return val;
1671
1672 if (val & ESTATUS_1000_TFULL)
1673 features |= SUPPORTED_1000baseT_Full;
1674 if (val & ESTATUS_1000_THALF)
1675 features |= SUPPORTED_1000baseT_Half;
1676 }
1677
1678 phydev->supported &= features;
1679 phydev->advertising &= features;
1680
1681 return 0;
1682}
1683EXPORT_SYMBOL(genphy_config_init);
1684
1685/* This is used for the phy device which doesn't support the MMD extended
1686 * register access, but it does have side effect when we are trying to access
1687 * the MMD register via indirect method.
1688 */
1689int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad, u16 regnum)
1690{
1691 return -EOPNOTSUPP;
1692}
1693EXPORT_SYMBOL(genphy_read_mmd_unsupported);
1694
1695int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum,
1696 u16 regnum, u16 val)
1697{
1698 return -EOPNOTSUPP;
1699}
1700EXPORT_SYMBOL(genphy_write_mmd_unsupported);
1701
1702int genphy_suspend(struct phy_device *phydev)
1703{
1704 return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);
1705}
1706EXPORT_SYMBOL(genphy_suspend);
1707
1708int genphy_resume(struct phy_device *phydev)
1709{
1710 return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN);
1711}
1712EXPORT_SYMBOL(genphy_resume);
1713
1714int genphy_loopback(struct phy_device *phydev, bool enable)
1715{
1716 return phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK,
1717 enable ? BMCR_LOOPBACK : 0);
1718}
1719EXPORT_SYMBOL(genphy_loopback);
1720
1721static int __set_phy_supported(struct phy_device *phydev, u32 max_speed)
1722{
1723 /* The default values for phydev->supported are provided by the PHY
1724 * driver "features" member, we want to reset to sane defaults first
1725 * before supporting higher speeds.
1726 */
1727 phydev->supported &= PHY_DEFAULT_FEATURES;
1728
1729 switch (max_speed) {
1730 default:
1731 return -ENOTSUPP;
1732 case SPEED_1000:
1733 phydev->supported |= PHY_1000BT_FEATURES;
1734 /* fall through */
1735 case SPEED_100:
1736 phydev->supported |= PHY_100BT_FEATURES;
1737 /* fall through */
1738 case SPEED_10:
1739 phydev->supported |= PHY_10BT_FEATURES;
1740 }
1741
1742 return 0;
1743}
1744
1745int phy_set_max_speed(struct phy_device *phydev, u32 max_speed)
1746{
1747 int err;
1748
1749 err = __set_phy_supported(phydev, max_speed);
1750 if (err)
1751 return err;
1752
1753 phydev->advertising = phydev->supported;
1754
1755 return 0;
1756}
1757EXPORT_SYMBOL(phy_set_max_speed);
1758
1759static void of_set_phy_supported(struct phy_device *phydev)
1760{
1761 struct device_node *node = phydev->mdio.dev.of_node;
1762 u32 max_speed;
1763
1764 if (!IS_ENABLED(CONFIG_OF_MDIO))
1765 return;
1766
1767 if (!node)
1768 return;
1769
1770 if (!of_property_read_u32(node, "max-speed", &max_speed))
1771 __set_phy_supported(phydev, max_speed);
1772}
1773
1774static void of_set_phy_eee_broken(struct phy_device *phydev)
1775{
1776 struct device_node *node = phydev->mdio.dev.of_node;
1777 u32 broken = 0;
1778
1779 if (!IS_ENABLED(CONFIG_OF_MDIO))
1780 return;
1781
1782 if (!node)
1783 return;
1784
1785 if (of_property_read_bool(node, "eee-broken-100tx"))
1786 broken |= MDIO_EEE_100TX;
1787 if (of_property_read_bool(node, "eee-broken-1000t"))
1788 broken |= MDIO_EEE_1000T;
1789 if (of_property_read_bool(node, "eee-broken-10gt"))
1790 broken |= MDIO_EEE_10GT;
1791 if (of_property_read_bool(node, "eee-broken-1000kx"))
1792 broken |= MDIO_EEE_1000KX;
1793 if (of_property_read_bool(node, "eee-broken-10gkx4"))
1794 broken |= MDIO_EEE_10GKX4;
1795 if (of_property_read_bool(node, "eee-broken-10gkr"))
1796 broken |= MDIO_EEE_10GKR;
1797
1798 phydev->eee_broken_modes = broken;
1799}
1800
1801/**
1802 * phy_probe - probe and init a PHY device
1803 * @dev: device to probe and init
1804 *
1805 * Description: Take care of setting up the phy_device structure,
1806 * set the state to READY (the driver's init function should
1807 * set it to STARTING if needed).
1808 */
1809static int phy_probe(struct device *dev)
1810{
1811 struct phy_device *phydev = to_phy_device(dev);
1812 struct device_driver *drv = phydev->mdio.dev.driver;
1813 struct phy_driver *phydrv = to_phy_driver(drv);
1814 int err = 0;
1815
1816 phydev->drv = phydrv;
1817
1818 /* Disable the interrupt if the PHY doesn't support it
1819 * but the interrupt is still a valid one
1820 */
1821 if (!(phydrv->flags & PHY_HAS_INTERRUPT) &&
1822 phy_interrupt_is_valid(phydev))
1823 phydev->irq = PHY_POLL;
1824
1825 if (phydrv->flags & PHY_IS_INTERNAL)
1826 phydev->is_internal = true;
1827
1828 mutex_lock(&phydev->lock);
1829
1830 /* Start out supporting everything. Eventually,
1831 * a controller will attach, and may modify one
1832 * or both of these values
1833 */
1834 phydev->supported = phydrv->features;
1835 of_set_phy_supported(phydev);
1836 phydev->advertising = phydev->supported;
1837
1838 /* Get the EEE modes we want to prohibit. We will ask
1839 * the PHY stop advertising these mode later on
1840 */
1841 of_set_phy_eee_broken(phydev);
1842
1843 /* The Pause Frame bits indicate that the PHY can support passing
1844 * pause frames. During autonegotiation, the PHYs will determine if
1845 * they should allow pause frames to pass. The MAC driver should then
1846 * use that result to determine whether to enable flow control via
1847 * pause frames.
1848 *
1849 * Normally, PHY drivers should not set the Pause bits, and instead
1850 * allow phylib to do that. However, there may be some situations
1851 * (e.g. hardware erratum) where the driver wants to set only one
1852 * of these bits.
1853 */
1854 if (phydrv->features & (SUPPORTED_Pause | SUPPORTED_Asym_Pause)) {
1855 phydev->supported &= ~(SUPPORTED_Pause | SUPPORTED_Asym_Pause);
1856 phydev->supported |= phydrv->features &
1857 (SUPPORTED_Pause | SUPPORTED_Asym_Pause);
1858 } else {
1859 phydev->supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
1860 }
1861
1862 /* Set the state to READY by default */
1863 phydev->state = PHY_READY;
1864
1865 if (phydev->drv->probe) {
1866 /* Deassert the reset signal */
1867 phy_device_reset(phydev, 0);
1868
1869 err = phydev->drv->probe(phydev);
1870 if (err) {
1871 /* Assert the reset signal */
1872 phy_device_reset(phydev, 1);
1873 }
1874 }
1875
1876 mutex_unlock(&phydev->lock);
1877
1878 return err;
1879}
1880
1881static int phy_remove(struct device *dev)
1882{
1883 struct phy_device *phydev = to_phy_device(dev);
1884
1885 cancel_delayed_work_sync(&phydev->state_queue);
1886
1887 mutex_lock(&phydev->lock);
1888 phydev->state = PHY_DOWN;
1889 mutex_unlock(&phydev->lock);
1890
1891 if (phydev->drv && phydev->drv->remove) {
1892 phydev->drv->remove(phydev);
1893
1894 /* Assert the reset signal */
1895 phy_device_reset(phydev, 1);
1896 }
1897 phydev->drv = NULL;
1898
1899 return 0;
1900}
1901
1902/**
1903 * phy_driver_register - register a phy_driver with the PHY layer
1904 * @new_driver: new phy_driver to register
1905 * @owner: module owning this PHY
1906 */
1907int phy_driver_register(struct phy_driver *new_driver, struct module *owner)
1908{
1909 int retval;
1910
1911 new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY;
1912 new_driver->mdiodrv.driver.name = new_driver->name;
1913 new_driver->mdiodrv.driver.bus = &mdio_bus_type;
1914 new_driver->mdiodrv.driver.probe = phy_probe;
1915 new_driver->mdiodrv.driver.remove = phy_remove;
1916 new_driver->mdiodrv.driver.owner = owner;
1917
1918 retval = driver_register(&new_driver->mdiodrv.driver);
1919 if (retval) {
1920 pr_err("%s: Error %d in registering driver\n",
1921 new_driver->name, retval);
1922
1923 return retval;
1924 }
1925
1926 pr_debug("%s: Registered new driver\n", new_driver->name);
1927
1928 return 0;
1929}
1930EXPORT_SYMBOL(phy_driver_register);
1931
1932int phy_drivers_register(struct phy_driver *new_driver, int n,
1933 struct module *owner)
1934{
1935 int i, ret = 0;
1936
1937 for (i = 0; i < n; i++) {
1938 ret = phy_driver_register(new_driver + i, owner);
1939 if (ret) {
1940 while (i-- > 0)
1941 phy_driver_unregister(new_driver + i);
1942 break;
1943 }
1944 }
1945 return ret;
1946}
1947EXPORT_SYMBOL(phy_drivers_register);
1948
1949void phy_driver_unregister(struct phy_driver *drv)
1950{
1951 driver_unregister(&drv->mdiodrv.driver);
1952}
1953EXPORT_SYMBOL(phy_driver_unregister);
1954
1955void phy_drivers_unregister(struct phy_driver *drv, int n)
1956{
1957 int i;
1958
1959 for (i = 0; i < n; i++)
1960 phy_driver_unregister(drv + i);
1961}
1962EXPORT_SYMBOL(phy_drivers_unregister);
1963
1964static struct phy_driver genphy_driver = {
1965 .phy_id = 0xffffffff,
1966 .phy_id_mask = 0xffffffff,
1967 .name = "Generic PHY",
1968 .soft_reset = genphy_no_soft_reset,
1969 .config_init = genphy_config_init,
1970 .features = PHY_GBIT_FEATURES | SUPPORTED_MII |
1971 SUPPORTED_AUI | SUPPORTED_FIBRE |
1972 SUPPORTED_BNC,
1973 .aneg_done = genphy_aneg_done,
1974 .suspend = genphy_suspend,
1975 .resume = genphy_resume,
1976 .set_loopback = genphy_loopback,
1977};
1978
1979static int __init phy_init(void)
1980{
1981 int rc;
1982
1983 rc = mdio_bus_init();
1984 if (rc)
1985 return rc;
1986
1987 rc = phy_driver_register(&genphy_10g_driver, THIS_MODULE);
1988 if (rc)
1989 goto err_10g;
1990
1991 rc = phy_driver_register(&genphy_driver, THIS_MODULE);
1992 if (rc) {
1993 phy_driver_unregister(&genphy_10g_driver);
1994err_10g:
1995 mdio_bus_exit();
1996 }
1997
1998 return rc;
1999}
2000
2001static void __exit phy_exit(void)
2002{
2003 phy_driver_unregister(&genphy_10g_driver);
2004 phy_driver_unregister(&genphy_driver);
2005 mdio_bus_exit();
2006}
2007
2008subsys_initcall(phy_init);
2009module_exit(phy_exit);