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