2
* drivers/net/phy/phy_device.c
4
* Framework for finding and configuring PHYs.
5
* Also contains generic PHY driver
9
* Copyright (c) 2004 Freescale Semiconductor, Inc.
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.
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>
29
#include <linux/module.h>
30
#include <linux/mii.h>
31
#include <linux/ethtool.h>
32
#include <linux/phy.h>
36
#include <asm/uaccess.h>
38
MODULE_DESCRIPTION("PHY library");
39
MODULE_AUTHOR("Andy Fleming");
40
MODULE_LICENSE("GPL");
42
void phy_device_free(struct phy_device *phydev)
46
EXPORT_SYMBOL(phy_device_free);
48
static void phy_device_release(struct device *dev)
50
phy_device_free(to_phy_device(dev));
53
static struct phy_driver genphy_driver;
54
extern int mdio_bus_init(void);
55
extern void mdio_bus_exit(void);
57
static LIST_HEAD(phy_fixup_list);
58
static DEFINE_MUTEX(phy_fixup_lock);
60
static int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
61
u32 flags, phy_interface_t interface);
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
70
* @run: The actual code to be run when a matching PHY is found
72
int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
73
int (*run)(struct phy_device *))
75
struct phy_fixup *fixup;
77
fixup = kzalloc(sizeof(struct phy_fixup), GFP_KERNEL);
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;
86
mutex_lock(&phy_fixup_lock);
87
list_add_tail(&fixup->list, &phy_fixup_list);
88
mutex_unlock(&phy_fixup_lock);
92
EXPORT_SYMBOL(phy_register_fixup);
94
/* Registers a fixup to be run on any PHY with the UID in phy_uid */
95
int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
96
int (*run)(struct phy_device *))
98
return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
100
EXPORT_SYMBOL(phy_register_fixup_for_uid);
102
/* Registers a fixup to be run on the PHY with id string bus_id */
103
int phy_register_fixup_for_id(const char *bus_id,
104
int (*run)(struct phy_device *))
106
return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
108
EXPORT_SYMBOL(phy_register_fixup_for_id);
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.
114
static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
116
if (strcmp(fixup->bus_id, dev_name(&phydev->dev)) != 0)
117
if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
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)
128
/* Runs any matching fixups for this phydev */
129
int phy_scan_fixups(struct phy_device *phydev)
131
struct phy_fixup *fixup;
133
mutex_lock(&phy_fixup_lock);
134
list_for_each_entry(fixup, &phy_fixup_list, list) {
135
if (phy_needs_fixup(phydev, fixup)) {
138
err = fixup->run(phydev);
141
mutex_unlock(&phy_fixup_lock);
146
mutex_unlock(&phy_fixup_lock);
150
EXPORT_SYMBOL(phy_scan_fixups);
152
static struct phy_device* phy_device_create(struct mii_bus *bus,
153
int addr, int phy_id)
155
struct phy_device *dev;
157
/* We allocate the device, and initialize the
159
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
162
return (struct phy_device*) PTR_ERR((void*)-ENOMEM);
164
dev->dev.release = phy_device_release;
168
dev->pause = dev->asym_pause = 0;
170
dev->interface = PHY_INTERFACE_MODE_GMII;
172
dev->autoneg = AUTONEG_ENABLE;
175
dev->phy_id = phy_id;
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);
182
dev->state = PHY_DOWN;
184
mutex_init(&dev->lock);
185
INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
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));
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.
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.
210
int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id)
214
/* Grab the bits from PHYIR1, and put them
215
* in the upper half */
216
phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
221
*phy_id = (phy_reg & 0xffff) << 16;
223
/* Grab the bits from PHYIR2, and put them in the lower half */
224
phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
229
*phy_id |= (phy_reg & 0xffff);
233
EXPORT_SYMBOL(get_phy_id);
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
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.
243
struct phy_device * get_phy_device(struct mii_bus *bus, int addr)
245
struct phy_device *dev = NULL;
249
r = get_phy_id(bus, addr, &phy_id);
253
/* If the phy_id is mostly Fs, there is no device there */
254
if ((phy_id & 0x1fffffff) == 0x1fffffff)
257
dev = phy_device_create(bus, addr, phy_id);
261
EXPORT_SYMBOL(get_phy_device);
264
* phy_device_register - Register the phy device on the MDIO bus
265
* @phydev: phy_device structure to be added to the MDIO bus
267
int phy_device_register(struct phy_device *phydev)
271
/* Don't register a phy if one is already registered at this
273
if (phydev->bus->phy_map[phydev->addr])
275
phydev->bus->phy_map[phydev->addr] = phydev;
277
/* Run all of the fixups for this PHY */
278
phy_scan_fixups(phydev);
280
err = device_register(&phydev->dev);
282
pr_err("phy %d failed to register\n", phydev->addr);
289
phydev->bus->phy_map[phydev->addr] = NULL;
292
EXPORT_SYMBOL(phy_device_register);
295
* phy_find_first - finds the first PHY device on the bus
296
* @bus: the target MII bus
298
struct phy_device *phy_find_first(struct mii_bus *bus)
302
for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
303
if (bus->phy_map[addr])
304
return bus->phy_map[addr];
308
EXPORT_SYMBOL(phy_find_first);
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
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
322
static void phy_prepare_link(struct phy_device *phydev,
323
void (*handler)(struct net_device *))
325
phydev->adjust_link = handler;
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
336
int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
337
void (*handler)(struct net_device *), u32 flags,
338
phy_interface_t interface)
342
rc = phy_attach_direct(dev, phydev, flags, interface);
346
phy_prepare_link(phydev, handler);
347
phy_start_machine(phydev, NULL);
349
phy_start_interrupts(phydev);
353
EXPORT_SYMBOL(phy_connect_direct);
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
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.
371
struct 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)
375
struct phy_device *phydev;
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);
383
pr_err("PHY %s not found\n", bus_id);
384
return ERR_PTR(-ENODEV);
386
phydev = to_phy_device(d);
388
rc = phy_connect_direct(dev, phydev, handler, flags, interface);
394
EXPORT_SYMBOL(phy_connect);
397
* phy_disconnect - disable interrupts, stop state machine, and detach a PHY device
398
* @phydev: target phy_device struct
400
void phy_disconnect(struct phy_device *phydev)
403
phy_stop_interrupts(phydev);
405
phy_stop_machine(phydev);
407
phydev->adjust_link = NULL;
411
EXPORT_SYMBOL(phy_disconnect);
413
int phy_init_hw(struct phy_device *phydev)
417
if (!phydev->drv || !phydev->drv->config_init)
420
ret = phy_scan_fixups(phydev);
424
return phydev->drv->config_init(phydev);
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
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.
441
static int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
442
u32 flags, phy_interface_t interface)
444
struct device *d = &phydev->dev;
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;
452
err = d->driver->probe(d);
454
err = device_bind_driver(d);
460
if (phydev->attached_dev) {
461
dev_err(&dev->dev, "PHY already attached\n");
465
phydev->attached_dev = dev;
466
dev->phydev = phydev;
468
phydev->dev_flags = flags;
470
phydev->interface = interface;
472
phydev->state = PHY_READY;
474
/* Do initial configuration here, now that
475
* we have certain key parameters
476
* (dev_flags and interface) */
477
err = phy_init_hw(phydev);
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
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.
494
struct phy_device *phy_attach(struct net_device *dev,
495
const char *bus_id, u32 flags, phy_interface_t interface)
497
struct bus_type *bus = &mdio_bus_type;
498
struct phy_device *phydev;
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);
506
pr_err("PHY %s not found\n", bus_id);
507
return ERR_PTR(-ENODEV);
509
phydev = to_phy_device(d);
511
rc = phy_attach_direct(dev, phydev, flags, interface);
517
EXPORT_SYMBOL(phy_attach);
520
* phy_detach - detach a PHY device from its network device
521
* @phydev: target phy_device struct
523
void phy_detach(struct phy_device *phydev)
525
phydev->attached_dev->phydev = NULL;
526
phydev->attached_dev = NULL;
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);
535
EXPORT_SYMBOL(phy_detach);
538
/* Generic PHY support and helper functions */
541
* genphy_config_advert - sanitize and advertise auto-negotiation parameters
542
* @phydev: target phy_device struct
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.
549
static int genphy_config_advert(struct phy_device *phydev)
553
int err, changed = 0;
555
/* Only allow advertising what
556
* this PHY supports */
557
phydev->advertising &= phydev->supported;
558
advertise = phydev->advertising;
560
/* Setup standard advertisement */
561
oldadv = adv = phy_read(phydev, MII_ADVERTISE);
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;
582
err = phy_write(phydev, MII_ADVERTISE, adv);
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);
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;
604
err = phy_write(phydev, MII_CTRL1000, adv);
616
* genphy_setup_forced - configures/forces speed/duplex from @phydev
617
* @phydev: target phy_device struct
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().
623
static int genphy_setup_forced(struct phy_device *phydev)
628
phydev->pause = phydev->asym_pause = 0;
630
if (SPEED_1000 == phydev->speed)
631
ctl |= BMCR_SPEED1000;
632
else if (SPEED_100 == phydev->speed)
633
ctl |= BMCR_SPEED100;
635
if (DUPLEX_FULL == phydev->duplex)
636
ctl |= BMCR_FULLDPLX;
638
err = phy_write(phydev, MII_BMCR, ctl);
645
* genphy_restart_aneg - Enable and Restart Autonegotiation
646
* @phydev: target phy_device struct
648
int genphy_restart_aneg(struct phy_device *phydev)
652
ctl = phy_read(phydev, MII_BMCR);
657
ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);
659
/* Don't isolate the PHY if we're negotiating */
660
ctl &= ~(BMCR_ISOLATE);
662
ctl = phy_write(phydev, MII_BMCR, ctl);
666
EXPORT_SYMBOL(genphy_restart_aneg);
670
* genphy_config_aneg - restart auto-negotiation or write BMCR
671
* @phydev: target phy_device struct
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.
677
int genphy_config_aneg(struct phy_device *phydev)
681
if (AUTONEG_ENABLE != phydev->autoneg)
682
return genphy_setup_forced(phydev);
684
result = genphy_config_advert(phydev);
686
if (result < 0) /* error */
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);
697
if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
698
result = 1; /* do restart aneg */
701
/* Only restart aneg if we are advertising something different
702
* than we were before. */
704
result = genphy_restart_aneg(phydev);
708
EXPORT_SYMBOL(genphy_config_aneg);
711
* genphy_update_link - update link status in @phydev
712
* @phydev: target phy_device struct
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.
718
int genphy_update_link(struct phy_device *phydev)
723
status = phy_read(phydev, MII_BMSR);
728
/* Read link and autonegotiation status */
729
status = phy_read(phydev, MII_BMSR);
734
if ((status & BMSR_LSTATUS) == 0)
741
EXPORT_SYMBOL(genphy_update_link);
744
* genphy_read_status - check the link status and update current link state
745
* @phydev: target phy_device struct
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.
752
int genphy_read_status(struct phy_device *phydev)
759
/* Update the link, but return if there
761
err = genphy_update_link(phydev);
765
if (AUTONEG_ENABLE == phydev->autoneg) {
766
if (phydev->supported & (SUPPORTED_1000baseT_Half
767
| SUPPORTED_1000baseT_Full)) {
768
lpagb = phy_read(phydev, MII_STAT1000);
773
adv = phy_read(phydev, MII_CTRL1000);
781
lpa = phy_read(phydev, MII_LPA);
786
adv = phy_read(phydev, MII_ADVERTISE);
793
phydev->speed = SPEED_10;
794
phydev->duplex = DUPLEX_HALF;
795
phydev->pause = phydev->asym_pause = 0;
797
if (lpagb & (LPA_1000FULL | LPA_1000HALF)) {
798
phydev->speed = SPEED_1000;
800
if (lpagb & LPA_1000FULL)
801
phydev->duplex = DUPLEX_FULL;
802
} else if (lpa & (LPA_100FULL | LPA_100HALF)) {
803
phydev->speed = SPEED_100;
805
if (lpa & LPA_100FULL)
806
phydev->duplex = DUPLEX_FULL;
808
if (lpa & LPA_10FULL)
809
phydev->duplex = DUPLEX_FULL;
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;
816
int bmcr = phy_read(phydev, MII_BMCR);
820
if (bmcr & BMCR_FULLDPLX)
821
phydev->duplex = DUPLEX_FULL;
823
phydev->duplex = DUPLEX_HALF;
825
if (bmcr & BMCR_SPEED1000)
826
phydev->speed = SPEED_1000;
827
else if (bmcr & BMCR_SPEED100)
828
phydev->speed = SPEED_100;
830
phydev->speed = SPEED_10;
832
phydev->pause = phydev->asym_pause = 0;
837
EXPORT_SYMBOL(genphy_read_status);
839
static int genphy_config_init(struct phy_device *phydev)
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 |
850
/* Do we support autonegotiation? */
851
val = phy_read(phydev, MII_BMSR);
856
if (val & BMSR_ANEGCAPABLE)
857
features |= SUPPORTED_Autoneg;
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;
868
if (val & BMSR_ESTATEN) {
869
val = phy_read(phydev, MII_ESTATUS);
874
if (val & ESTATUS_1000_TFULL)
875
features |= SUPPORTED_1000baseT_Full;
876
if (val & ESTATUS_1000_THALF)
877
features |= SUPPORTED_1000baseT_Half;
880
phydev->supported = features;
881
phydev->advertising = features;
885
int genphy_suspend(struct phy_device *phydev)
889
mutex_lock(&phydev->lock);
891
value = phy_read(phydev, MII_BMCR);
892
phy_write(phydev, MII_BMCR, (value | BMCR_PDOWN));
894
mutex_unlock(&phydev->lock);
898
EXPORT_SYMBOL(genphy_suspend);
900
int genphy_resume(struct phy_device *phydev)
904
mutex_lock(&phydev->lock);
906
value = phy_read(phydev, MII_BMCR);
907
phy_write(phydev, MII_BMCR, (value & ~BMCR_PDOWN));
909
mutex_unlock(&phydev->lock);
913
EXPORT_SYMBOL(genphy_resume);
916
* phy_probe - probe and init a PHY device
917
* @dev: device to probe and init
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).
923
static int phy_probe(struct device *dev)
925
struct phy_device *phydev;
926
struct phy_driver *phydrv;
927
struct device_driver *drv;
930
phydev = to_phy_device(dev);
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;
938
/* Disable the interrupt if the PHY doesn't support it */
939
if (!(phydrv->flags & PHY_HAS_INTERRUPT))
940
phydev->irq = PHY_POLL;
942
mutex_lock(&phydev->lock);
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;
950
/* Set the state to READY by default */
951
phydev->state = PHY_READY;
953
if (phydev->drv->probe)
954
err = phydev->drv->probe(phydev);
956
mutex_unlock(&phydev->lock);
962
static int phy_remove(struct device *dev)
964
struct phy_device *phydev;
966
phydev = to_phy_device(dev);
968
mutex_lock(&phydev->lock);
969
phydev->state = PHY_DOWN;
970
mutex_unlock(&phydev->lock);
972
if (phydev->drv->remove)
973
phydev->drv->remove(phydev);
975
put_driver(dev->driver);
982
* phy_driver_register - register a phy_driver with the PHY layer
983
* @new_driver: new phy_driver to register
985
int phy_driver_register(struct phy_driver *new_driver)
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;
994
retval = driver_register(&new_driver->driver);
997
printk(KERN_ERR "%s: Error %d in registering driver\n",
998
new_driver->name, retval);
1003
pr_debug("%s: Registered new driver\n", new_driver->name);
1007
EXPORT_SYMBOL(phy_driver_register);
1009
void phy_driver_unregister(struct phy_driver *drv)
1011
driver_unregister(&drv->driver);
1013
EXPORT_SYMBOL(phy_driver_unregister);
1015
static struct phy_driver genphy_driver = {
1016
.phy_id = 0xffffffff,
1017
.phy_id_mask = 0xffffffff,
1018
.name = "Generic PHY",
1019
.config_init = genphy_config_init,
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, },
1028
static int __init phy_init(void)
1032
rc = mdio_bus_init();
1036
rc = phy_driver_register(&genphy_driver);
1043
static void __exit phy_exit(void)
1045
phy_driver_unregister(&genphy_driver);
1049
subsys_initcall(phy_init);
1050
module_exit(phy_exit);