• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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