Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging-2.6
[linux-2.6] / 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", phydev->dev.bus_id,
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 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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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 */
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 }