1 /*
2 * drivers/net/phy/phy.c
3 *
4 * Framework for configuring and reading PHY devices
5 * Based on code in sungem_phy.c and gianfar_phy.c
6 *
7 * Author: Andy Fleming
8 *
9 * Copyright (c) 2004 Freescale Semiconductor, Inc.
10 * Copyright (c) 2006, 2007 Maciej W. Rozycki
11 *
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2 of the License, or (at your
15 * option) any later version.
16 *
17 */
18 #include <linux/kernel.h>
19 #include <linux/string.h>
20 #include <linux/errno.h>
21 #include <linux/unistd.h>
22 #include <linux/slab.h>
23 #include <linux/interrupt.h>
24 #include <linux/init.h>
25 #include <linux/delay.h>
26 #include <linux/netdevice.h>
27 #include <linux/etherdevice.h>
28 #include <linux/skbuff.h>
29 #include <linux/mm.h>
30 #include <linux/module.h>
31 #include <linux/mii.h>
32 #include <linux/ethtool.h>
33 #include <linux/phy.h>
34 #include <linux/timer.h>
35 #include <linux/workqueue.h>
36
37 #include <asm/atomic.h>
38 #include <asm/io.h>
39 #include <asm/irq.h>
40 #include <asm/uaccess.h>
41
42 /**
43 * phy_print_status - Convenience function to print out the current phy status
44 * @phydev: the phy_device struct
45 */
phy_print_status(struct phy_device * phydev)46 void phy_print_status(struct phy_device *phydev)
47 {
48 pr_info("PHY: %s - Link is %s", dev_name(&phydev->dev),
49 phydev->link ? "Up" : "Down");
50 if (phydev->link)
51 printk(" - %d/%s", phydev->speed,
52 DUPLEX_FULL == phydev->duplex ?
53 "Full" : "Half");
54
55 printk("\n");
56 }
57 EXPORT_SYMBOL(phy_print_status);
58
59
60 /**
61 * phy_clear_interrupt - Ack the phy device's interrupt
62 * @phydev: the phy_device struct
63 *
64 * If the @phydev driver has an ack_interrupt function, call it to
65 * ack and clear the phy device's interrupt.
66 *
67 * Returns 0 on success on < 0 on error.
68 */
phy_clear_interrupt(struct phy_device * phydev)69 int phy_clear_interrupt(struct phy_device *phydev)
70 {
71 int err = 0;
72
73 if (phydev->drv->ack_interrupt)
74 err = phydev->drv->ack_interrupt(phydev);
75
76 return err;
77 }
78
79 /**
80 * phy_config_interrupt - configure the PHY device for the requested interrupts
81 * @phydev: the phy_device struct
82 * @interrupts: interrupt flags to configure for this @phydev
83 *
84 * Returns 0 on success on < 0 on error.
85 */
phy_config_interrupt(struct phy_device * phydev,u32 interrupts)86 int phy_config_interrupt(struct phy_device *phydev, u32 interrupts)
87 {
88 int err = 0;
89
90 phydev->interrupts = interrupts;
91 if (phydev->drv->config_intr)
92 err = phydev->drv->config_intr(phydev);
93
94 return err;
95 }
96
97
98 /**
99 * phy_aneg_done - return auto-negotiation status
100 * @phydev: target phy_device struct
101 *
102 * Description: Reads the status register and returns 0 either if
103 * auto-negotiation is incomplete, or if there was an error.
104 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.
105 */
phy_aneg_done(struct phy_device * phydev)106 static inline int phy_aneg_done(struct phy_device *phydev)
107 {
108 int retval;
109
110 retval = phy_read(phydev, MII_BMSR);
111
112 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
113 }
114
115 /* A structure for mapping a particular speed and duplex
116 * combination to a particular SUPPORTED and ADVERTISED value */
117 struct phy_setting {
118 int speed;
119 int duplex;
120 u32 setting;
121 };
122
123 /* A mapping of all SUPPORTED settings to speed/duplex */
124 static const struct phy_setting settings[] = {
125 {
126 .speed = 10000,
127 .duplex = DUPLEX_FULL,
128 .setting = SUPPORTED_10000baseT_Full,
129 },
130 {
131 .speed = SPEED_1000,
132 .duplex = DUPLEX_FULL,
133 .setting = SUPPORTED_1000baseT_Full,
134 },
135 {
136 .speed = SPEED_1000,
137 .duplex = DUPLEX_HALF,
138 .setting = SUPPORTED_1000baseT_Half,
139 },
140 {
141 .speed = SPEED_100,
142 .duplex = DUPLEX_FULL,
143 .setting = SUPPORTED_100baseT_Full,
144 },
145 {
146 .speed = SPEED_100,
147 .duplex = DUPLEX_HALF,
148 .setting = SUPPORTED_100baseT_Half,
149 },
150 {
151 .speed = SPEED_10,
152 .duplex = DUPLEX_FULL,
153 .setting = SUPPORTED_10baseT_Full,
154 },
155 {
156 .speed = SPEED_10,
157 .duplex = DUPLEX_HALF,
158 .setting = SUPPORTED_10baseT_Half,
159 },
160 };
161
162 #define MAX_NUM_SETTINGS ARRAY_SIZE(settings)
163
164 /**
165 * phy_find_setting - find a PHY settings array entry that matches speed & duplex
166 * @speed: speed to match
167 * @duplex: duplex to match
168 *
169 * Description: Searches the settings array for the setting which
170 * matches the desired speed and duplex, and returns the index
171 * of that setting. Returns the index of the last setting if
172 * none of the others match.
173 */
phy_find_setting(int speed,int duplex)174 static inline int phy_find_setting(int speed, int duplex)
175 {
176 int idx = 0;
177
178 while (idx < ARRAY_SIZE(settings) &&
179 (settings[idx].speed != speed ||
180 settings[idx].duplex != duplex))
181 idx++;
182
183 return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1;
184 }
185
186 /**
187 * phy_find_valid - find a PHY setting that matches the requested features mask
188 * @idx: The first index in settings[] to search
189 * @features: A mask of the valid settings
190 *
191 * Description: Returns the index of the first valid setting less
192 * than or equal to the one pointed to by idx, as determined by
193 * the mask in features. Returns the index of the last setting
194 * if nothing else matches.
195 */
phy_find_valid(int idx,u32 features)196 static inline int phy_find_valid(int idx, u32 features)
197 {
198 while (idx < MAX_NUM_SETTINGS && !(settings[idx].setting & features))
199 idx++;
200
201 return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1;
202 }
203
204 /**
205 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
206 * @phydev: the target phy_device struct
207 *
208 * Description: Make sure the PHY is set to supported speeds and
209 * duplexes. Drop down by one in this order: 1000/FULL,
210 * 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
211 */
phy_sanitize_settings(struct phy_device * phydev)212 void phy_sanitize_settings(struct phy_device *phydev)
213 {
214 u32 features = phydev->supported;
215 int idx;
216
217 /* Sanitize settings based on PHY capabilities */
218 if ((features & SUPPORTED_Autoneg) == 0)
219 phydev->autoneg = AUTONEG_DISABLE;
220
221 idx = phy_find_valid(phy_find_setting(phydev->speed, phydev->duplex),
222 features);
223
224 phydev->speed = settings[idx].speed;
225 phydev->duplex = settings[idx].duplex;
226 }
227 EXPORT_SYMBOL(phy_sanitize_settings);
228
229 /**
230 * phy_ethtool_sset - generic ethtool sset function, handles all the details
231 * @phydev: target phy_device struct
232 * @cmd: ethtool_cmd
233 *
234 * A few notes about parameter checking:
235 * - We don't set port or transceiver, so we don't care what they
236 * were set to.
237 * - phy_start_aneg() will make sure forced settings are sane, and
238 * choose the next best ones from the ones selected, so we don't
239 * care if ethtool tries to give us bad values.
240 */
phy_ethtool_sset(struct phy_device * phydev,struct ethtool_cmd * cmd)241 int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd)
242 {
243 if (cmd->phy_address != phydev->addr)
244 return -EINVAL;
245
246 /* We make sure that we don't pass unsupported
247 * values in to the PHY */
248 cmd->advertising &= phydev->supported;
249
250 /* Verify the settings we care about. */
251 if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE)
252 return -EINVAL;
253
254 if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0)
255 return -EINVAL;
256
257 if (cmd->autoneg == AUTONEG_DISABLE
258 && ((cmd->speed != SPEED_1000
259 && cmd->speed != SPEED_100
260 && cmd->speed != SPEED_10)
261 || (cmd->duplex != DUPLEX_HALF
262 && cmd->duplex != DUPLEX_FULL)))
263 return -EINVAL;
264
265 phydev->autoneg = cmd->autoneg;
266
267 phydev->speed = cmd->speed;
268
269 phydev->advertising = cmd->advertising;
270
271 if (AUTONEG_ENABLE == cmd->autoneg)
272 phydev->advertising |= ADVERTISED_Autoneg;
273 else
274 phydev->advertising &= ~ADVERTISED_Autoneg;
275
276 phydev->duplex = cmd->duplex;
277
278 /* Restart the PHY */
279 phy_start_aneg(phydev);
280
281 return 0;
282 }
283 EXPORT_SYMBOL(phy_ethtool_sset);
284
phy_ethtool_gset(struct phy_device * phydev,struct ethtool_cmd * cmd)285 int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd)
286 {
287 cmd->supported = phydev->supported;
288
289 cmd->advertising = phydev->advertising;
290
291 cmd->speed = phydev->speed;
292 cmd->duplex = phydev->duplex;
293 cmd->port = PORT_MII;
294 cmd->phy_address = phydev->addr;
295 cmd->transceiver = XCVR_EXTERNAL;
296 cmd->autoneg = phydev->autoneg;
297
298 return 0;
299 }
300 EXPORT_SYMBOL(phy_ethtool_gset);
301
302 /**
303 * phy_mii_ioctl - generic PHY MII ioctl interface
304 * @phydev: the phy_device struct
305 * @mii_data: MII ioctl data
306 * @cmd: ioctl cmd to execute
307 *
308 * Note that this function is currently incompatible with the
309 * PHYCONTROL layer. It changes registers without regard to
310 * current state. Use at own risk.
311 */
phy_mii_ioctl(struct phy_device * phydev,struct mii_ioctl_data * mii_data,int cmd)312 int phy_mii_ioctl(struct phy_device *phydev,
313 struct mii_ioctl_data *mii_data, int cmd)
314 {
315 u16 val = mii_data->val_in;
316
317 switch (cmd) {
318 case SIOCGMIIPHY:
319 mii_data->phy_id = phydev->addr;
320 /* fall through */
321
322 case SIOCGMIIREG:
323 mii_data->val_out = phy_read(phydev, mii_data->reg_num);
324 break;
325
326 case SIOCSMIIREG:
327 if (!capable(CAP_NET_ADMIN))
328 return -EPERM;
329
330 if (mii_data->phy_id == phydev->addr) {
331 switch(mii_data->reg_num) {
332 case MII_BMCR:
333 if ((val & (BMCR_RESET|BMCR_ANENABLE)) == 0)
334 phydev->autoneg = AUTONEG_DISABLE;
335 else
336 phydev->autoneg = AUTONEG_ENABLE;
337 if ((!phydev->autoneg) && (val & BMCR_FULLDPLX))
338 phydev->duplex = DUPLEX_FULL;
339 else
340 phydev->duplex = DUPLEX_HALF;
341 if ((!phydev->autoneg) &&
342 (val & BMCR_SPEED1000))
343 phydev->speed = SPEED_1000;
344 else if ((!phydev->autoneg) &&
345 (val & BMCR_SPEED100))
346 phydev->speed = SPEED_100;
347 break;
348 case MII_ADVERTISE:
349 phydev->advertising = val;
350 break;
351 default:
352 /* do nothing */
353 break;
354 }
355 }
356
357 phy_write(phydev, mii_data->reg_num, val);
358
359 if (mii_data->reg_num == MII_BMCR
360 && val & BMCR_RESET
361 && phydev->drv->config_init) {
362 phy_scan_fixups(phydev);
363 phydev->drv->config_init(phydev);
364 }
365 break;
366
367 default:
368 return -EOPNOTSUPP;
369 }
370
371 return 0;
372 }
373 EXPORT_SYMBOL(phy_mii_ioctl);
374
375 /**
376 * phy_start_aneg - start auto-negotiation for this PHY device
377 * @phydev: the phy_device struct
378 *
379 * Description: Sanitizes the settings (if we're not autonegotiating
380 * them), and then calls the driver's config_aneg function.
381 * If the PHYCONTROL Layer is operating, we change the state to
382 * reflect the beginning of Auto-negotiation or forcing.
383 */
phy_start_aneg(struct phy_device * phydev)384 int phy_start_aneg(struct phy_device *phydev)
385 {
386 int err;
387
388 mutex_lock(&phydev->lock);
389
390 if (AUTONEG_DISABLE == phydev->autoneg)
391 phy_sanitize_settings(phydev);
392
393 err = phydev->drv->config_aneg(phydev);
394
395 if (err < 0)
396 goto out_unlock;
397
398 if (phydev->state != PHY_HALTED) {
399 if (AUTONEG_ENABLE == phydev->autoneg) {
400 phydev->state = PHY_AN;
401 phydev->link_timeout = PHY_AN_TIMEOUT;
402 } else {
403 phydev->state = PHY_FORCING;
404 phydev->link_timeout = PHY_FORCE_TIMEOUT;
405 }
406 }
407
408 out_unlock:
409 mutex_unlock(&phydev->lock);
410 return err;
411 }
412 EXPORT_SYMBOL(phy_start_aneg);
413
414
415 static void phy_change(struct work_struct *work);
416 static void phy_state_machine(struct work_struct *work);
417 static void phy_timer(unsigned long data);
418
419 /**
420 * phy_start_machine - start PHY state machine tracking
421 * @phydev: the phy_device struct
422 * @handler: callback function for state change notifications
423 *
424 * Description: The PHY infrastructure can run a state machine
425 * which tracks whether the PHY is starting up, negotiating,
426 * etc. This function starts the timer which tracks the state
427 * of the PHY. If you want to be notified when the state changes,
428 * pass in the callback @handler, otherwise, pass NULL. If you
429 * want to maintain your own state machine, do not call this
430 * function.
431 */
phy_start_machine(struct phy_device * phydev,void (* handler)(struct net_device *))432 void phy_start_machine(struct phy_device *phydev,
433 void (*handler)(struct net_device *))
434 {
435 phydev->adjust_state = handler;
436
437 INIT_WORK(&phydev->state_queue, phy_state_machine);
438 init_timer(&phydev->phy_timer);
439 phydev->phy_timer.function = &phy_timer;
440 phydev->phy_timer.data = (unsigned long) phydev;
441 mod_timer(&phydev->phy_timer, jiffies + HZ);
442 }
443
444 /**
445 * phy_stop_machine - stop the PHY state machine tracking
446 * @phydev: target phy_device struct
447 *
448 * Description: Stops the state machine timer, sets the state to UP
449 * (unless it wasn't up yet). This function must be called BEFORE
450 * phy_detach.
451 */
phy_stop_machine(struct phy_device * phydev)452 void phy_stop_machine(struct phy_device *phydev)
453 {
454 del_timer_sync(&phydev->phy_timer);
455 cancel_work_sync(&phydev->state_queue);
456
457 mutex_lock(&phydev->lock);
458 if (phydev->state > PHY_UP)
459 phydev->state = PHY_UP;
460 mutex_unlock(&phydev->lock);
461
462 phydev->adjust_state = NULL;
463 }
464
465 /**
466 * phy_force_reduction - reduce PHY speed/duplex settings by one step
467 * @phydev: target phy_device struct
468 *
469 * Description: Reduces the speed/duplex settings by one notch,
470 * in this order--
471 * 1000/FULL, 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
472 * The function bottoms out at 10/HALF.
473 */
phy_force_reduction(struct phy_device * phydev)474 static void phy_force_reduction(struct phy_device *phydev)
475 {
476 int idx;
477
478 idx = phy_find_setting(phydev->speed, phydev->duplex);
479
480 idx++;
481
482 idx = phy_find_valid(idx, phydev->supported);
483
484 phydev->speed = settings[idx].speed;
485 phydev->duplex = settings[idx].duplex;
486
487 pr_info("Trying %d/%s\n", phydev->speed,
488 DUPLEX_FULL == phydev->duplex ?
489 "FULL" : "HALF");
490 }
491
492
493 /**
494 * phy_error - enter HALTED state for this PHY device
495 * @phydev: target phy_device struct
496 *
497 * Moves the PHY to the HALTED state in response to a read
498 * or write error, and tells the controller the link is down.
499 * Must not be called from interrupt context, or while the
500 * phydev->lock is held.
501 */
phy_error(struct phy_device * phydev)502 static void phy_error(struct phy_device *phydev)
503 {
504 mutex_lock(&phydev->lock);
505 phydev->state = PHY_HALTED;
506 mutex_unlock(&phydev->lock);
507 }
508
509 /**
510 * phy_interrupt - PHY interrupt handler
511 * @irq: interrupt line
512 * @phy_dat: phy_device pointer
513 *
514 * Description: When a PHY interrupt occurs, the handler disables
515 * interrupts, and schedules a work task to clear the interrupt.
516 */
phy_interrupt(int irq,void * phy_dat)517 static irqreturn_t phy_interrupt(int irq, void *phy_dat)
518 {
519 struct phy_device *phydev = phy_dat;
520
521 if (PHY_HALTED == phydev->state)
522 return IRQ_NONE; /* It can't be ours. */
523
524 /* The MDIO bus is not allowed to be written in interrupt
525 * context, so we need to disable the irq here. A work
526 * queue will write the PHY to disable and clear the
527 * interrupt, and then reenable the irq line. */
528 disable_irq_nosync(irq);
529 atomic_inc(&phydev->irq_disable);
530
531 schedule_work(&phydev->phy_queue);
532
533 return IRQ_HANDLED;
534 }
535
536 /**
537 * phy_enable_interrupts - Enable the interrupts from the PHY side
538 * @phydev: target phy_device struct
539 */
phy_enable_interrupts(struct phy_device * phydev)540 int phy_enable_interrupts(struct phy_device *phydev)
541 {
542 int err;
543
544 err = phy_clear_interrupt(phydev);
545
546 if (err < 0)
547 return err;
548
549 err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
550
551 return err;
552 }
553 EXPORT_SYMBOL(phy_enable_interrupts);
554
555 /**
556 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
557 * @phydev: target phy_device struct
558 */
phy_disable_interrupts(struct phy_device * phydev)559 int phy_disable_interrupts(struct phy_device *phydev)
560 {
561 int err;
562
563 /* Disable PHY interrupts */
564 err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
565
566 if (err)
567 goto phy_err;
568
569 /* Clear the interrupt */
570 err = phy_clear_interrupt(phydev);
571
572 if (err)
573 goto phy_err;
574
575 return 0;
576
577 phy_err:
578 phy_error(phydev);
579
580 return err;
581 }
582 EXPORT_SYMBOL(phy_disable_interrupts);
583
584 /**
585 * phy_start_interrupts - request and enable interrupts for a PHY device
586 * @phydev: target phy_device struct
587 *
588 * Description: Request the interrupt for the given PHY.
589 * If this fails, then we set irq to PHY_POLL.
590 * Otherwise, we enable the interrupts in the PHY.
591 * This should only be called with a valid IRQ number.
592 * Returns 0 on success or < 0 on error.
593 */
phy_start_interrupts(struct phy_device * phydev)594 int phy_start_interrupts(struct phy_device *phydev)
595 {
596 int err = 0;
597
598 INIT_WORK(&phydev->phy_queue, phy_change);
599
600 atomic_set(&phydev->irq_disable, 0);
601 if (request_irq(phydev->irq, phy_interrupt,
602 IRQF_SHARED,
603 "phy_interrupt",
604 phydev) < 0) {
605 printk(KERN_WARNING "%s: Can't get IRQ %d (PHY)\n",
606 phydev->bus->name,
607 phydev->irq);
608 phydev->irq = PHY_POLL;
609 return 0;
610 }
611
612 err = phy_enable_interrupts(phydev);
613
614 return err;
615 }
616 EXPORT_SYMBOL(phy_start_interrupts);
617
618 /**
619 * phy_stop_interrupts - disable interrupts from a PHY device
620 * @phydev: target phy_device struct
621 */
phy_stop_interrupts(struct phy_device * phydev)622 int phy_stop_interrupts(struct phy_device *phydev)
623 {
624 int err;
625
626 err = phy_disable_interrupts(phydev);
627
628 if (err)
629 phy_error(phydev);
630
631 free_irq(phydev->irq, phydev);
632
633 /*
634 * Cannot call flush_scheduled_work() here as desired because
635 * of rtnl_lock(), but we do not really care about what would
636 * be done, except from enable_irq(), so cancel any work
637 * possibly pending and take care of the matter below.
638 */
639 cancel_work_sync(&phydev->phy_queue);
640 /*
641 * If work indeed has been cancelled, disable_irq() will have
642 * been left unbalanced from phy_interrupt() and enable_irq()
643 * has to be called so that other devices on the line work.
644 */
645 while (atomic_dec_return(&phydev->irq_disable) >= 0)
646 enable_irq(phydev->irq);
647
648 return err;
649 }
650 EXPORT_SYMBOL(phy_stop_interrupts);
651
652
653 /**
654 * phy_change - Scheduled by the phy_interrupt/timer to handle PHY changes
655 * @work: work_struct that describes the work to be done
656 */
phy_change(struct work_struct * work)657 static void phy_change(struct work_struct *work)
658 {
659 int err;
660 struct phy_device *phydev =
661 container_of(work, struct phy_device, phy_queue);
662
663 err = phy_disable_interrupts(phydev);
664
665 if (err)
666 goto phy_err;
667
668 mutex_lock(&phydev->lock);
669 if ((PHY_RUNNING == phydev->state) || (PHY_NOLINK == phydev->state))
670 phydev->state = PHY_CHANGELINK;
671 mutex_unlock(&phydev->lock);
672
673 atomic_dec(&phydev->irq_disable);
674 enable_irq(phydev->irq);
675
676 /* Reenable interrupts */
677 if (PHY_HALTED != phydev->state)
678 err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
679
680 if (err)
681 goto irq_enable_err;
682
683 /* Stop timer and run the state queue now. The work function for
684 * state_queue will start the timer up again.
685 */
686 del_timer(&phydev->phy_timer);
687 schedule_work(&phydev->state_queue);
688
689 return;
690
691 irq_enable_err:
692 disable_irq(phydev->irq);
693 atomic_inc(&phydev->irq_disable);
694 phy_err:
695 phy_error(phydev);
696 }
697
698 /**
699 * phy_stop - Bring down the PHY link, and stop checking the status
700 * @phydev: target phy_device struct
701 */
phy_stop(struct phy_device * phydev)702 void phy_stop(struct phy_device *phydev)
703 {
704 mutex_lock(&phydev->lock);
705
706 if (PHY_HALTED == phydev->state)
707 goto out_unlock;
708
709 if (phydev->irq != PHY_POLL) {
710 /* Disable PHY Interrupts */
711 phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
712
713 /* Clear any pending interrupts */
714 phy_clear_interrupt(phydev);
715 }
716
717 phydev->state = PHY_HALTED;
718
719 out_unlock:
720 mutex_unlock(&phydev->lock);
721
722 /*
723 * Cannot call flush_scheduled_work() here as desired because
724 * of rtnl_lock(), but PHY_HALTED shall guarantee phy_change()
725 * will not reenable interrupts.
726 */
727 }
728
729
730 /**
731 * phy_start - start or restart a PHY device
732 * @phydev: target phy_device struct
733 *
734 * Description: Indicates the attached device's readiness to
735 * handle PHY-related work. Used during startup to start the
736 * PHY, and after a call to phy_stop() to resume operation.
737 * Also used to indicate the MDIO bus has cleared an error
738 * condition.
739 */
phy_start(struct phy_device * phydev)740 void phy_start(struct phy_device *phydev)
741 {
742 mutex_lock(&phydev->lock);
743
744 switch (phydev->state) {
745 case PHY_STARTING:
746 phydev->state = PHY_PENDING;
747 break;
748 case PHY_READY:
749 phydev->state = PHY_UP;
750 break;
751 case PHY_HALTED:
752 phydev->state = PHY_RESUMING;
753 default:
754 break;
755 }
756 mutex_unlock(&phydev->lock);
757 }
758 EXPORT_SYMBOL(phy_stop);
759 EXPORT_SYMBOL(phy_start);
760
761 /**
762 * phy_state_machine - Handle the state machine
763 * @work: work_struct that describes the work to be done
764 *
765 * Description: Scheduled by the state_queue workqueue each time
766 * phy_timer is triggered.
767 */
phy_state_machine(struct work_struct * work)768 static void phy_state_machine(struct work_struct *work)
769 {
770 struct phy_device *phydev =
771 container_of(work, struct phy_device, state_queue);
772 int needs_aneg = 0;
773 int err = 0;
774
775 mutex_lock(&phydev->lock);
776
777 if (phydev->adjust_state)
778 phydev->adjust_state(phydev->attached_dev);
779
780 switch(phydev->state) {
781 case PHY_DOWN:
782 case PHY_STARTING:
783 case PHY_READY:
784 case PHY_PENDING:
785 break;
786 case PHY_UP:
787 needs_aneg = 1;
788
789 phydev->link_timeout = PHY_AN_TIMEOUT;
790
791 break;
792 case PHY_AN:
793 err = phy_read_status(phydev);
794
795 if (err < 0)
796 break;
797
798 /* If the link is down, give up on
799 * negotiation for now */
800 if (!phydev->link) {
801 phydev->state = PHY_NOLINK;
802 netif_carrier_off(phydev->attached_dev);
803 phydev->adjust_link(phydev->attached_dev);
804 break;
805 }
806
807 /* Check if negotiation is done. Break
808 * if there's an error */
809 err = phy_aneg_done(phydev);
810 if (err < 0)
811 break;
812
813 /* If AN is done, we're running */
814 if (err > 0) {
815 phydev->state = PHY_RUNNING;
816 netif_carrier_on(phydev->attached_dev);
817 phydev->adjust_link(phydev->attached_dev);
818
819 } else if (0 == phydev->link_timeout--) {
820 int idx;
821
822 needs_aneg = 1;
823 /* If we have the magic_aneg bit,
824 * we try again */
825 if (phydev->drv->flags & PHY_HAS_MAGICANEG)
826 break;
827
828 /* The timer expired, and we still
829 * don't have a setting, so we try
830 * forcing it until we find one that
831 * works, starting from the fastest speed,
832 * and working our way down */
833 idx = phy_find_valid(0, phydev->supported);
834
835 phydev->speed = settings[idx].speed;
836 phydev->duplex = settings[idx].duplex;
837
838 phydev->autoneg = AUTONEG_DISABLE;
839
840 pr_info("Trying %d/%s\n", phydev->speed,
841 DUPLEX_FULL ==
842 phydev->duplex ?
843 "FULL" : "HALF");
844 }
845 break;
846 case PHY_NOLINK:
847 err = phy_read_status(phydev);
848
849 if (err)
850 break;
851
852 if (phydev->link) {
853 phydev->state = PHY_RUNNING;
854 netif_carrier_on(phydev->attached_dev);
855 phydev->adjust_link(phydev->attached_dev);
856 }
857 break;
858 case PHY_FORCING:
859 err = genphy_update_link(phydev);
860
861 if (err)
862 break;
863
864 if (phydev->link) {
865 phydev->state = PHY_RUNNING;
866 netif_carrier_on(phydev->attached_dev);
867 } else {
868 if (0 == phydev->link_timeout--) {
869 phy_force_reduction(phydev);
870 needs_aneg = 1;
871 }
872 }
873
874 phydev->adjust_link(phydev->attached_dev);
875 break;
876 case PHY_RUNNING:
877 /* Only register a CHANGE if we are
878 * polling */
879 if (PHY_POLL == phydev->irq)
880 phydev->state = PHY_CHANGELINK;
881 break;
882 case PHY_CHANGELINK:
883 err = phy_read_status(phydev);
884
885 if (err)
886 break;
887
888 if (phydev->link) {
889 phydev->state = PHY_RUNNING;
890 netif_carrier_on(phydev->attached_dev);
891 } else {
892 phydev->state = PHY_NOLINK;
893 netif_carrier_off(phydev->attached_dev);
894 }
895
896 phydev->adjust_link(phydev->attached_dev);
897
898 if (PHY_POLL != phydev->irq)
899 err = phy_config_interrupt(phydev,
900 PHY_INTERRUPT_ENABLED);
901 break;
902 case PHY_HALTED:
903 if (phydev->link) {
904 phydev->link = 0;
905 netif_carrier_off(phydev->attached_dev);
906 phydev->adjust_link(phydev->attached_dev);
907 }
908 break;
909 case PHY_RESUMING:
910
911 err = phy_clear_interrupt(phydev);
912
913 if (err)
914 break;
915
916 err = phy_config_interrupt(phydev,
917 PHY_INTERRUPT_ENABLED);
918
919 if (err)
920 break;
921
922 if (AUTONEG_ENABLE == phydev->autoneg) {
923 err = phy_aneg_done(phydev);
924 if (err < 0)
925 break;
926
927 /* err > 0 if AN is done.
928 * Otherwise, it's 0, and we're
929 * still waiting for AN */
930 if (err > 0) {
931 phydev->state = PHY_RUNNING;
932 } else {
933 phydev->state = PHY_AN;
934 phydev->link_timeout = PHY_AN_TIMEOUT;
935 }
936 } else
937 phydev->state = PHY_RUNNING;
938 break;
939 }
940
941 mutex_unlock(&phydev->lock);
942
943 if (needs_aneg)
944 err = phy_start_aneg(phydev);
945
946 if (err < 0)
947 phy_error(phydev);
948
949 mod_timer(&phydev->phy_timer, jiffies + PHY_STATE_TIME * HZ);
950 }
951
952 /* PHY timer which schedules the state machine work */
phy_timer(unsigned long data)953 static void phy_timer(unsigned long data)
954 {
955 struct phy_device *phydev = (struct phy_device *)data;
956
957 /*
958 * PHY I/O operations can potentially sleep so we ensure that
959 * it's done from a process context
960 */
961 schedule_work(&phydev->state_queue);
962 }
963