phylib: Fix delay argument of schedule_delayed_work
[linux-2.6.git] / drivers / net / phy / phy.c
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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
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  */
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  */
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
418 /**
419  * phy_start_machine - start PHY state machine tracking
420  * @phydev: the phy_device struct
421  * @handler: callback function for state change notifications
422  *
423  * Description: The PHY infrastructure can run a state machine
424  *   which tracks whether the PHY is starting up, negotiating,
425  *   etc.  This function starts the timer which tracks the state
426  *   of the PHY.  If you want to be notified when the state changes,
427  *   pass in the callback @handler, otherwise, pass NULL.  If you
428  *   want to maintain your own state machine, do not call this
429  *   function.
430  */
431 void phy_start_machine(struct phy_device *phydev,
432                 void (*handler)(struct net_device *))
433 {
434         phydev->adjust_state = handler;
435
436         INIT_DELAYED_WORK(&phydev->state_queue, phy_state_machine);
437         schedule_delayed_work(&phydev->state_queue, HZ);
438 }
439
440 /**
441  * phy_stop_machine - stop the PHY state machine tracking
442  * @phydev: target phy_device struct
443  *
444  * Description: Stops the state machine timer, sets the state to UP
445  *   (unless it wasn't up yet). This function must be called BEFORE
446  *   phy_detach.
447  */
448 void phy_stop_machine(struct phy_device *phydev)
449 {
450         cancel_delayed_work_sync(&phydev->state_queue);
451
452         mutex_lock(&phydev->lock);
453         if (phydev->state > PHY_UP)
454                 phydev->state = PHY_UP;
455         mutex_unlock(&phydev->lock);
456
457         phydev->adjust_state = NULL;
458 }
459
460 /**
461  * phy_force_reduction - reduce PHY speed/duplex settings by one step
462  * @phydev: target phy_device struct
463  *
464  * Description: Reduces the speed/duplex settings by one notch,
465  *   in this order--
466  *   1000/FULL, 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
467  *   The function bottoms out at 10/HALF.
468  */
469 static void phy_force_reduction(struct phy_device *phydev)
470 {
471         int idx;
472
473         idx = phy_find_setting(phydev->speed, phydev->duplex);
474         
475         idx++;
476
477         idx = phy_find_valid(idx, phydev->supported);
478
479         phydev->speed = settings[idx].speed;
480         phydev->duplex = settings[idx].duplex;
481
482         pr_info("Trying %d/%s\n", phydev->speed,
483                         DUPLEX_FULL == phydev->duplex ?
484                         "FULL" : "HALF");
485 }
486
487
488 /**
489  * phy_error - enter HALTED state for this PHY device
490  * @phydev: target phy_device struct
491  *
492  * Moves the PHY to the HALTED state in response to a read
493  * or write error, and tells the controller the link is down.
494  * Must not be called from interrupt context, or while the
495  * phydev->lock is held.
496  */
497 static void phy_error(struct phy_device *phydev)
498 {
499         mutex_lock(&phydev->lock);
500         phydev->state = PHY_HALTED;
501         mutex_unlock(&phydev->lock);
502 }
503
504 /**
505  * phy_interrupt - PHY interrupt handler
506  * @irq: interrupt line
507  * @phy_dat: phy_device pointer
508  *
509  * Description: When a PHY interrupt occurs, the handler disables
510  * interrupts, and schedules a work task to clear the interrupt.
511  */
512 static irqreturn_t phy_interrupt(int irq, void *phy_dat)
513 {
514         struct phy_device *phydev = phy_dat;
515
516         if (PHY_HALTED == phydev->state)
517                 return IRQ_NONE;                /* It can't be ours.  */
518
519         /* The MDIO bus is not allowed to be written in interrupt
520          * context, so we need to disable the irq here.  A work
521          * queue will write the PHY to disable and clear the
522          * interrupt, and then reenable the irq line. */
523         disable_irq_nosync(irq);
524         atomic_inc(&phydev->irq_disable);
525
526         schedule_work(&phydev->phy_queue);
527
528         return IRQ_HANDLED;
529 }
530
531 /**
532  * phy_enable_interrupts - Enable the interrupts from the PHY side
533  * @phydev: target phy_device struct
534  */
535 int phy_enable_interrupts(struct phy_device *phydev)
536 {
537         int err;
538
539         err = phy_clear_interrupt(phydev);
540
541         if (err < 0)
542                 return err;
543
544         err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
545
546         return err;
547 }
548 EXPORT_SYMBOL(phy_enable_interrupts);
549
550 /**
551  * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
552  * @phydev: target phy_device struct
553  */
554 int phy_disable_interrupts(struct phy_device *phydev)
555 {
556         int err;
557
558         /* Disable PHY interrupts */
559         err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
560
561         if (err)
562                 goto phy_err;
563
564         /* Clear the interrupt */
565         err = phy_clear_interrupt(phydev);
566
567         if (err)
568                 goto phy_err;
569
570         return 0;
571
572 phy_err:
573         phy_error(phydev);
574
575         return err;
576 }
577 EXPORT_SYMBOL(phy_disable_interrupts);
578
579 /**
580  * phy_start_interrupts - request and enable interrupts for a PHY device
581  * @phydev: target phy_device struct
582  *
583  * Description: Request the interrupt for the given PHY.
584  *   If this fails, then we set irq to PHY_POLL.
585  *   Otherwise, we enable the interrupts in the PHY.
586  *   This should only be called with a valid IRQ number.
587  *   Returns 0 on success or < 0 on error.
588  */
589 int phy_start_interrupts(struct phy_device *phydev)
590 {
591         int err = 0;
592
593         INIT_WORK(&phydev->phy_queue, phy_change);
594
595         atomic_set(&phydev->irq_disable, 0);
596         if (request_irq(phydev->irq, phy_interrupt,
597                                 IRQF_SHARED,
598                                 "phy_interrupt",
599                                 phydev) < 0) {
600                 printk(KERN_WARNING "%s: Can't get IRQ %d (PHY)\n",
601                                 phydev->bus->name,
602                                 phydev->irq);
603                 phydev->irq = PHY_POLL;
604                 return 0;
605         }
606
607         err = phy_enable_interrupts(phydev);
608
609         return err;
610 }
611 EXPORT_SYMBOL(phy_start_interrupts);
612
613 /**
614  * phy_stop_interrupts - disable interrupts from a PHY device
615  * @phydev: target phy_device struct
616  */
617 int phy_stop_interrupts(struct phy_device *phydev)
618 {
619         int err;
620
621         err = phy_disable_interrupts(phydev);
622
623         if (err)
624                 phy_error(phydev);
625
626         free_irq(phydev->irq, phydev);
627
628         /*
629          * Cannot call flush_scheduled_work() here as desired because
630          * of rtnl_lock(), but we do not really care about what would
631          * be done, except from enable_irq(), so cancel any work
632          * possibly pending and take care of the matter below.
633          */
634         cancel_work_sync(&phydev->phy_queue);
635         /*
636          * If work indeed has been cancelled, disable_irq() will have
637          * been left unbalanced from phy_interrupt() and enable_irq()
638          * has to be called so that other devices on the line work.
639          */
640         while (atomic_dec_return(&phydev->irq_disable) >= 0)
641                 enable_irq(phydev->irq);
642
643         return err;
644 }
645 EXPORT_SYMBOL(phy_stop_interrupts);
646
647
648 /**
649  * phy_change - Scheduled by the phy_interrupt/timer to handle PHY changes
650  * @work: work_struct that describes the work to be done
651  */
652 static void phy_change(struct work_struct *work)
653 {
654         int err;
655         struct phy_device *phydev =
656                 container_of(work, struct phy_device, phy_queue);
657
658         if (phydev->drv->did_interrupt &&
659             !phydev->drv->did_interrupt(phydev))
660                 goto ignore;
661
662         err = phy_disable_interrupts(phydev);
663
664         if (err)
665                 goto phy_err;
666
667         mutex_lock(&phydev->lock);
668         if ((PHY_RUNNING == phydev->state) || (PHY_NOLINK == phydev->state))
669                 phydev->state = PHY_CHANGELINK;
670         mutex_unlock(&phydev->lock);
671
672         atomic_dec(&phydev->irq_disable);
673         enable_irq(phydev->irq);
674
675         /* Reenable interrupts */
676         if (PHY_HALTED != phydev->state)
677                 err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
678
679         if (err)
680                 goto irq_enable_err;
681
682         /* reschedule state queue work to run as soon as possible */
683         cancel_delayed_work_sync(&phydev->state_queue);
684         schedule_delayed_work(&phydev->state_queue, 0);
685
686         return;
687
688 ignore:
689         atomic_dec(&phydev->irq_disable);
690         enable_irq(phydev->irq);
691         return;
692
693 irq_enable_err:
694         disable_irq(phydev->irq);
695         atomic_inc(&phydev->irq_disable);
696 phy_err:
697         phy_error(phydev);
698 }
699
700 /**
701  * phy_stop - Bring down the PHY link, and stop checking the status
702  * @phydev: target phy_device struct
703  */
704 void phy_stop(struct phy_device *phydev)
705 {
706         mutex_lock(&phydev->lock);
707
708         if (PHY_HALTED == phydev->state)
709                 goto out_unlock;
710
711         if (phydev->irq != PHY_POLL) {
712                 /* Disable PHY Interrupts */
713                 phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
714
715                 /* Clear any pending interrupts */
716                 phy_clear_interrupt(phydev);
717         }
718
719         phydev->state = PHY_HALTED;
720
721 out_unlock:
722         mutex_unlock(&phydev->lock);
723
724         /*
725          * Cannot call flush_scheduled_work() here as desired because
726          * of rtnl_lock(), but PHY_HALTED shall guarantee phy_change()
727          * will not reenable interrupts.
728          */
729 }
730
731
732 /**
733  * phy_start - start or restart a PHY device
734  * @phydev: target phy_device struct
735  *
736  * Description: Indicates the attached device's readiness to
737  *   handle PHY-related work.  Used during startup to start the
738  *   PHY, and after a call to phy_stop() to resume operation.
739  *   Also used to indicate the MDIO bus has cleared an error
740  *   condition.
741  */
742 void phy_start(struct phy_device *phydev)
743 {
744         mutex_lock(&phydev->lock);
745
746         switch (phydev->state) {
747                 case PHY_STARTING:
748                         phydev->state = PHY_PENDING;
749                         break;
750                 case PHY_READY:
751                         phydev->state = PHY_UP;
752                         break;
753                 case PHY_HALTED:
754                         phydev->state = PHY_RESUMING;
755                 default:
756                         break;
757         }
758         mutex_unlock(&phydev->lock);
759 }
760 EXPORT_SYMBOL(phy_stop);
761 EXPORT_SYMBOL(phy_start);
762
763 /**
764  * phy_state_machine - Handle the state machine
765  * @work: work_struct that describes the work to be done
766  */
767 static void phy_state_machine(struct work_struct *work)
768 {
769         struct delayed_work *dwork = to_delayed_work(work);
770         struct phy_device *phydev =
771                         container_of(dwork, 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         schedule_delayed_work(&phydev->state_queue, PHY_STATE_TIME * HZ);
950 }