xref: /openbmc/linux/drivers/net/phy/phy.c (revision 92a2c6b2)
1 /* Framework for configuring and reading PHY devices
2  * Based on code in sungem_phy.c and gianfar_phy.c
3  *
4  * Author: Andy Fleming
5  *
6  * Copyright (c) 2004 Freescale Semiconductor, Inc.
7  * Copyright (c) 2006, 2007  Maciej W. Rozycki
8  *
9  * This program is free software; you can redistribute  it and/or modify it
10  * under  the terms of  the GNU General  Public License as published by the
11  * Free Software Foundation;  either version 2 of the  License, or (at your
12  * option) any later version.
13  *
14  */
15 
16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17 
18 #include <linux/kernel.h>
19 #include <linux/string.h>
20 #include <linux/errno.h>
21 #include <linux/unistd.h>
22 #include <linux/interrupt.h>
23 #include <linux/delay.h>
24 #include <linux/netdevice.h>
25 #include <linux/etherdevice.h>
26 #include <linux/skbuff.h>
27 #include <linux/mm.h>
28 #include <linux/module.h>
29 #include <linux/mii.h>
30 #include <linux/ethtool.h>
31 #include <linux/phy.h>
32 #include <linux/timer.h>
33 #include <linux/workqueue.h>
34 #include <linux/mdio.h>
35 #include <linux/io.h>
36 #include <linux/uaccess.h>
37 #include <linux/atomic.h>
38 
39 #include <asm/irq.h>
40 
41 static const char *phy_speed_to_str(int speed)
42 {
43 	switch (speed) {
44 	case SPEED_10:
45 		return "10Mbps";
46 	case SPEED_100:
47 		return "100Mbps";
48 	case SPEED_1000:
49 		return "1Gbps";
50 	case SPEED_2500:
51 		return "2.5Gbps";
52 	case SPEED_10000:
53 		return "10Gbps";
54 	case SPEED_UNKNOWN:
55 		return "Unknown";
56 	default:
57 		return "Unsupported (update phy.c)";
58 	}
59 }
60 
61 /**
62  * phy_print_status - Convenience function to print out the current phy status
63  * @phydev: the phy_device struct
64  */
65 void phy_print_status(struct phy_device *phydev)
66 {
67 	if (phydev->link) {
68 		netdev_info(phydev->attached_dev,
69 			"Link is Up - %s/%s - flow control %s\n",
70 			phy_speed_to_str(phydev->speed),
71 			DUPLEX_FULL == phydev->duplex ? "Full" : "Half",
72 			phydev->pause ? "rx/tx" : "off");
73 	} else	{
74 		netdev_info(phydev->attached_dev, "Link is Down\n");
75 	}
76 }
77 EXPORT_SYMBOL(phy_print_status);
78 
79 /**
80  * phy_clear_interrupt - Ack the phy device's interrupt
81  * @phydev: the phy_device struct
82  *
83  * If the @phydev driver has an ack_interrupt function, call it to
84  * ack and clear the phy device's interrupt.
85  *
86  * Returns 0 on success or < 0 on error.
87  */
88 static int phy_clear_interrupt(struct phy_device *phydev)
89 {
90 	if (phydev->drv->ack_interrupt)
91 		return phydev->drv->ack_interrupt(phydev);
92 
93 	return 0;
94 }
95 
96 /**
97  * phy_config_interrupt - configure the PHY device for the requested interrupts
98  * @phydev: the phy_device struct
99  * @interrupts: interrupt flags to configure for this @phydev
100  *
101  * Returns 0 on success or < 0 on error.
102  */
103 static int phy_config_interrupt(struct phy_device *phydev, u32 interrupts)
104 {
105 	phydev->interrupts = interrupts;
106 	if (phydev->drv->config_intr)
107 		return phydev->drv->config_intr(phydev);
108 
109 	return 0;
110 }
111 
112 
113 /**
114  * phy_aneg_done - return auto-negotiation status
115  * @phydev: target phy_device struct
116  *
117  * Description: Return the auto-negotiation status from this @phydev
118  * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation
119  * is still pending.
120  */
121 static inline int phy_aneg_done(struct phy_device *phydev)
122 {
123 	if (phydev->drv->aneg_done)
124 		return phydev->drv->aneg_done(phydev);
125 
126 	return genphy_aneg_done(phydev);
127 }
128 
129 /* A structure for mapping a particular speed and duplex
130  * combination to a particular SUPPORTED and ADVERTISED value
131  */
132 struct phy_setting {
133 	int speed;
134 	int duplex;
135 	u32 setting;
136 };
137 
138 /* A mapping of all SUPPORTED settings to speed/duplex */
139 static const struct phy_setting settings[] = {
140 	{
141 		.speed = SPEED_10000,
142 		.duplex = DUPLEX_FULL,
143 		.setting = SUPPORTED_10000baseKR_Full,
144 	},
145 	{
146 		.speed = SPEED_10000,
147 		.duplex = DUPLEX_FULL,
148 		.setting = SUPPORTED_10000baseKX4_Full,
149 	},
150 	{
151 		.speed = SPEED_10000,
152 		.duplex = DUPLEX_FULL,
153 		.setting = SUPPORTED_10000baseT_Full,
154 	},
155 	{
156 		.speed = SPEED_2500,
157 		.duplex = DUPLEX_FULL,
158 		.setting = SUPPORTED_2500baseX_Full,
159 	},
160 	{
161 		.speed = SPEED_1000,
162 		.duplex = DUPLEX_FULL,
163 		.setting = SUPPORTED_1000baseKX_Full,
164 	},
165 	{
166 		.speed = SPEED_1000,
167 		.duplex = DUPLEX_FULL,
168 		.setting = SUPPORTED_1000baseT_Full,
169 	},
170 	{
171 		.speed = SPEED_1000,
172 		.duplex = DUPLEX_HALF,
173 		.setting = SUPPORTED_1000baseT_Half,
174 	},
175 	{
176 		.speed = SPEED_100,
177 		.duplex = DUPLEX_FULL,
178 		.setting = SUPPORTED_100baseT_Full,
179 	},
180 	{
181 		.speed = SPEED_100,
182 		.duplex = DUPLEX_HALF,
183 		.setting = SUPPORTED_100baseT_Half,
184 	},
185 	{
186 		.speed = SPEED_10,
187 		.duplex = DUPLEX_FULL,
188 		.setting = SUPPORTED_10baseT_Full,
189 	},
190 	{
191 		.speed = SPEED_10,
192 		.duplex = DUPLEX_HALF,
193 		.setting = SUPPORTED_10baseT_Half,
194 	},
195 };
196 
197 #define MAX_NUM_SETTINGS ARRAY_SIZE(settings)
198 
199 /**
200  * phy_find_setting - find a PHY settings array entry that matches speed & duplex
201  * @speed: speed to match
202  * @duplex: duplex to match
203  *
204  * Description: Searches the settings array for the setting which
205  *   matches the desired speed and duplex, and returns the index
206  *   of that setting.  Returns the index of the last setting if
207  *   none of the others match.
208  */
209 static inline unsigned int phy_find_setting(int speed, int duplex)
210 {
211 	unsigned int idx = 0;
212 
213 	while (idx < ARRAY_SIZE(settings) &&
214 	       (settings[idx].speed != speed || settings[idx].duplex != duplex))
215 		idx++;
216 
217 	return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1;
218 }
219 
220 /**
221  * phy_find_valid - find a PHY setting that matches the requested features mask
222  * @idx: The first index in settings[] to search
223  * @features: A mask of the valid settings
224  *
225  * Description: Returns the index of the first valid setting less
226  *   than or equal to the one pointed to by idx, as determined by
227  *   the mask in features.  Returns the index of the last setting
228  *   if nothing else matches.
229  */
230 static inline unsigned int phy_find_valid(unsigned int idx, u32 features)
231 {
232 	while (idx < MAX_NUM_SETTINGS && !(settings[idx].setting & features))
233 		idx++;
234 
235 	return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1;
236 }
237 
238 /**
239  * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
240  * @phydev: the target phy_device struct
241  *
242  * Description: Make sure the PHY is set to supported speeds and
243  *   duplexes.  Drop down by one in this order:  1000/FULL,
244  *   1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
245  */
246 static void phy_sanitize_settings(struct phy_device *phydev)
247 {
248 	u32 features = phydev->supported;
249 	unsigned int idx;
250 
251 	/* Sanitize settings based on PHY capabilities */
252 	if ((features & SUPPORTED_Autoneg) == 0)
253 		phydev->autoneg = AUTONEG_DISABLE;
254 
255 	idx = phy_find_valid(phy_find_setting(phydev->speed, phydev->duplex),
256 			features);
257 
258 	phydev->speed = settings[idx].speed;
259 	phydev->duplex = settings[idx].duplex;
260 }
261 
262 /**
263  * phy_ethtool_sset - generic ethtool sset function, handles all the details
264  * @phydev: target phy_device struct
265  * @cmd: ethtool_cmd
266  *
267  * A few notes about parameter checking:
268  * - We don't set port or transceiver, so we don't care what they
269  *   were set to.
270  * - phy_start_aneg() will make sure forced settings are sane, and
271  *   choose the next best ones from the ones selected, so we don't
272  *   care if ethtool tries to give us bad values.
273  */
274 int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd)
275 {
276 	u32 speed = ethtool_cmd_speed(cmd);
277 
278 	if (cmd->phy_address != phydev->addr)
279 		return -EINVAL;
280 
281 	/* We make sure that we don't pass unsupported values in to the PHY */
282 	cmd->advertising &= phydev->supported;
283 
284 	/* Verify the settings we care about. */
285 	if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE)
286 		return -EINVAL;
287 
288 	if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0)
289 		return -EINVAL;
290 
291 	if (cmd->autoneg == AUTONEG_DISABLE &&
292 	    ((speed != SPEED_1000 &&
293 	      speed != SPEED_100 &&
294 	      speed != SPEED_10) ||
295 	     (cmd->duplex != DUPLEX_HALF &&
296 	      cmd->duplex != DUPLEX_FULL)))
297 		return -EINVAL;
298 
299 	phydev->autoneg = cmd->autoneg;
300 
301 	phydev->speed = speed;
302 
303 	phydev->advertising = cmd->advertising;
304 
305 	if (AUTONEG_ENABLE == cmd->autoneg)
306 		phydev->advertising |= ADVERTISED_Autoneg;
307 	else
308 		phydev->advertising &= ~ADVERTISED_Autoneg;
309 
310 	phydev->duplex = cmd->duplex;
311 
312 	/* Restart the PHY */
313 	phy_start_aneg(phydev);
314 
315 	return 0;
316 }
317 EXPORT_SYMBOL(phy_ethtool_sset);
318 
319 int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd)
320 {
321 	cmd->supported = phydev->supported;
322 
323 	cmd->advertising = phydev->advertising;
324 	cmd->lp_advertising = phydev->lp_advertising;
325 
326 	ethtool_cmd_speed_set(cmd, phydev->speed);
327 	cmd->duplex = phydev->duplex;
328 	if (phydev->interface == PHY_INTERFACE_MODE_MOCA)
329 		cmd->port = PORT_BNC;
330 	else
331 		cmd->port = PORT_MII;
332 	cmd->phy_address = phydev->addr;
333 	cmd->transceiver = phy_is_internal(phydev) ?
334 		XCVR_INTERNAL : XCVR_EXTERNAL;
335 	cmd->autoneg = phydev->autoneg;
336 
337 	return 0;
338 }
339 EXPORT_SYMBOL(phy_ethtool_gset);
340 
341 /**
342  * phy_mii_ioctl - generic PHY MII ioctl interface
343  * @phydev: the phy_device struct
344  * @ifr: &struct ifreq for socket ioctl's
345  * @cmd: ioctl cmd to execute
346  *
347  * Note that this function is currently incompatible with the
348  * PHYCONTROL layer.  It changes registers without regard to
349  * current state.  Use at own risk.
350  */
351 int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)
352 {
353 	struct mii_ioctl_data *mii_data = if_mii(ifr);
354 	u16 val = mii_data->val_in;
355 	bool change_autoneg = false;
356 
357 	switch (cmd) {
358 	case SIOCGMIIPHY:
359 		mii_data->phy_id = phydev->addr;
360 		/* fall through */
361 
362 	case SIOCGMIIREG:
363 		mii_data->val_out = mdiobus_read(phydev->bus, mii_data->phy_id,
364 						 mii_data->reg_num);
365 		return 0;
366 
367 	case SIOCSMIIREG:
368 		if (mii_data->phy_id == phydev->addr) {
369 			switch (mii_data->reg_num) {
370 			case MII_BMCR:
371 				if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) {
372 					if (phydev->autoneg == AUTONEG_ENABLE)
373 						change_autoneg = true;
374 					phydev->autoneg = AUTONEG_DISABLE;
375 					if (val & BMCR_FULLDPLX)
376 						phydev->duplex = DUPLEX_FULL;
377 					else
378 						phydev->duplex = DUPLEX_HALF;
379 					if (val & BMCR_SPEED1000)
380 						phydev->speed = SPEED_1000;
381 					else if (val & BMCR_SPEED100)
382 						phydev->speed = SPEED_100;
383 					else phydev->speed = SPEED_10;
384 				}
385 				else {
386 					if (phydev->autoneg == AUTONEG_DISABLE)
387 						change_autoneg = true;
388 					phydev->autoneg = AUTONEG_ENABLE;
389 				}
390 				break;
391 			case MII_ADVERTISE:
392 				phydev->advertising = mii_adv_to_ethtool_adv_t(val);
393 				change_autoneg = true;
394 				break;
395 			default:
396 				/* do nothing */
397 				break;
398 			}
399 		}
400 
401 		mdiobus_write(phydev->bus, mii_data->phy_id,
402 			      mii_data->reg_num, val);
403 
404 		if (mii_data->reg_num == MII_BMCR &&
405 		    val & BMCR_RESET)
406 			return phy_init_hw(phydev);
407 
408 		if (change_autoneg)
409 			return phy_start_aneg(phydev);
410 
411 		return 0;
412 
413 	case SIOCSHWTSTAMP:
414 		if (phydev->drv->hwtstamp)
415 			return phydev->drv->hwtstamp(phydev, ifr);
416 		/* fall through */
417 
418 	default:
419 		return -EOPNOTSUPP;
420 	}
421 }
422 EXPORT_SYMBOL(phy_mii_ioctl);
423 
424 /**
425  * phy_start_aneg - start auto-negotiation for this PHY device
426  * @phydev: the phy_device struct
427  *
428  * Description: Sanitizes the settings (if we're not autonegotiating
429  *   them), and then calls the driver's config_aneg function.
430  *   If the PHYCONTROL Layer is operating, we change the state to
431  *   reflect the beginning of Auto-negotiation or forcing.
432  */
433 int phy_start_aneg(struct phy_device *phydev)
434 {
435 	int err;
436 
437 	mutex_lock(&phydev->lock);
438 
439 	if (AUTONEG_DISABLE == phydev->autoneg)
440 		phy_sanitize_settings(phydev);
441 
442 	/* Invalidate LP advertising flags */
443 	phydev->lp_advertising = 0;
444 
445 	err = phydev->drv->config_aneg(phydev);
446 	if (err < 0)
447 		goto out_unlock;
448 
449 	if (phydev->state != PHY_HALTED) {
450 		if (AUTONEG_ENABLE == phydev->autoneg) {
451 			phydev->state = PHY_AN;
452 			phydev->link_timeout = PHY_AN_TIMEOUT;
453 		} else {
454 			phydev->state = PHY_FORCING;
455 			phydev->link_timeout = PHY_FORCE_TIMEOUT;
456 		}
457 	}
458 
459 out_unlock:
460 	mutex_unlock(&phydev->lock);
461 	return err;
462 }
463 EXPORT_SYMBOL(phy_start_aneg);
464 
465 /**
466  * phy_start_machine - start PHY state machine tracking
467  * @phydev: the phy_device struct
468  *
469  * Description: The PHY infrastructure can run a state machine
470  *   which tracks whether the PHY is starting up, negotiating,
471  *   etc.  This function starts the timer which tracks the state
472  *   of the PHY.  If you want to maintain your own state machine,
473  *   do not call this function.
474  */
475 void phy_start_machine(struct phy_device *phydev)
476 {
477 	queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, HZ);
478 }
479 
480 /**
481  * phy_stop_machine - stop the PHY state machine tracking
482  * @phydev: target phy_device struct
483  *
484  * Description: Stops the state machine timer, sets the state to UP
485  *   (unless it wasn't up yet). This function must be called BEFORE
486  *   phy_detach.
487  */
488 void phy_stop_machine(struct phy_device *phydev)
489 {
490 	cancel_delayed_work_sync(&phydev->state_queue);
491 
492 	mutex_lock(&phydev->lock);
493 	if (phydev->state > PHY_UP)
494 		phydev->state = PHY_UP;
495 	mutex_unlock(&phydev->lock);
496 }
497 
498 /**
499  * phy_error - enter HALTED state for this PHY device
500  * @phydev: target phy_device struct
501  *
502  * Moves the PHY to the HALTED state in response to a read
503  * or write error, and tells the controller the link is down.
504  * Must not be called from interrupt context, or while the
505  * phydev->lock is held.
506  */
507 static void phy_error(struct phy_device *phydev)
508 {
509 	mutex_lock(&phydev->lock);
510 	phydev->state = PHY_HALTED;
511 	mutex_unlock(&phydev->lock);
512 }
513 
514 /**
515  * phy_interrupt - PHY interrupt handler
516  * @irq: interrupt line
517  * @phy_dat: phy_device pointer
518  *
519  * Description: When a PHY interrupt occurs, the handler disables
520  * interrupts, and schedules a work task to clear the interrupt.
521  */
522 static irqreturn_t phy_interrupt(int irq, void *phy_dat)
523 {
524 	struct phy_device *phydev = phy_dat;
525 
526 	if (PHY_HALTED == phydev->state)
527 		return IRQ_NONE;		/* It can't be ours.  */
528 
529 	/* The MDIO bus is not allowed to be written in interrupt
530 	 * context, so we need to disable the irq here.  A work
531 	 * queue will write the PHY to disable and clear the
532 	 * interrupt, and then reenable the irq line.
533 	 */
534 	disable_irq_nosync(irq);
535 	atomic_inc(&phydev->irq_disable);
536 
537 	queue_work(system_power_efficient_wq, &phydev->phy_queue);
538 
539 	return IRQ_HANDLED;
540 }
541 
542 /**
543  * phy_enable_interrupts - Enable the interrupts from the PHY side
544  * @phydev: target phy_device struct
545  */
546 static int phy_enable_interrupts(struct phy_device *phydev)
547 {
548 	int err = phy_clear_interrupt(phydev);
549 
550 	if (err < 0)
551 		return err;
552 
553 	return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
554 }
555 
556 /**
557  * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
558  * @phydev: target phy_device struct
559  */
560 static int phy_disable_interrupts(struct phy_device *phydev)
561 {
562 	int err;
563 
564 	/* Disable PHY interrupts */
565 	err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
566 	if (err)
567 		goto phy_err;
568 
569 	/* Clear the interrupt */
570 	err = phy_clear_interrupt(phydev);
571 	if (err)
572 		goto phy_err;
573 
574 	return 0;
575 
576 phy_err:
577 	phy_error(phydev);
578 
579 	return err;
580 }
581 
582 /**
583  * phy_start_interrupts - request and enable interrupts for a PHY device
584  * @phydev: target phy_device struct
585  *
586  * Description: Request the interrupt for the given PHY.
587  *   If this fails, then we set irq to PHY_POLL.
588  *   Otherwise, we enable the interrupts in the PHY.
589  *   This should only be called with a valid IRQ number.
590  *   Returns 0 on success or < 0 on error.
591  */
592 int phy_start_interrupts(struct phy_device *phydev)
593 {
594 	atomic_set(&phydev->irq_disable, 0);
595 	if (request_irq(phydev->irq, phy_interrupt, 0, "phy_interrupt",
596 			phydev) < 0) {
597 		pr_warn("%s: Can't get IRQ %d (PHY)\n",
598 			phydev->bus->name, phydev->irq);
599 		phydev->irq = PHY_POLL;
600 		return 0;
601 	}
602 
603 	return phy_enable_interrupts(phydev);
604 }
605 EXPORT_SYMBOL(phy_start_interrupts);
606 
607 /**
608  * phy_stop_interrupts - disable interrupts from a PHY device
609  * @phydev: target phy_device struct
610  */
611 int phy_stop_interrupts(struct phy_device *phydev)
612 {
613 	int err = phy_disable_interrupts(phydev);
614 
615 	if (err)
616 		phy_error(phydev);
617 
618 	free_irq(phydev->irq, phydev);
619 
620 	/* Cannot call flush_scheduled_work() here as desired because
621 	 * of rtnl_lock(), but we do not really care about what would
622 	 * be done, except from enable_irq(), so cancel any work
623 	 * possibly pending and take care of the matter below.
624 	 */
625 	cancel_work_sync(&phydev->phy_queue);
626 	/* If work indeed has been cancelled, disable_irq() will have
627 	 * been left unbalanced from phy_interrupt() and enable_irq()
628 	 * has to be called so that other devices on the line work.
629 	 */
630 	while (atomic_dec_return(&phydev->irq_disable) >= 0)
631 		enable_irq(phydev->irq);
632 
633 	return err;
634 }
635 EXPORT_SYMBOL(phy_stop_interrupts);
636 
637 /**
638  * phy_change - Scheduled by the phy_interrupt/timer to handle PHY changes
639  * @work: work_struct that describes the work to be done
640  */
641 void phy_change(struct work_struct *work)
642 {
643 	struct phy_device *phydev =
644 		container_of(work, struct phy_device, phy_queue);
645 
646 	if (phydev->drv->did_interrupt &&
647 	    !phydev->drv->did_interrupt(phydev))
648 		goto ignore;
649 
650 	if (phy_disable_interrupts(phydev))
651 		goto phy_err;
652 
653 	mutex_lock(&phydev->lock);
654 	if ((PHY_RUNNING == phydev->state) || (PHY_NOLINK == phydev->state))
655 		phydev->state = PHY_CHANGELINK;
656 	mutex_unlock(&phydev->lock);
657 
658 	atomic_dec(&phydev->irq_disable);
659 	enable_irq(phydev->irq);
660 
661 	/* Reenable interrupts */
662 	if (PHY_HALTED != phydev->state &&
663 	    phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED))
664 		goto irq_enable_err;
665 
666 	/* reschedule state queue work to run as soon as possible */
667 	cancel_delayed_work_sync(&phydev->state_queue);
668 	queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, 0);
669 	return;
670 
671 ignore:
672 	atomic_dec(&phydev->irq_disable);
673 	enable_irq(phydev->irq);
674 	return;
675 
676 irq_enable_err:
677 	disable_irq(phydev->irq);
678 	atomic_inc(&phydev->irq_disable);
679 phy_err:
680 	phy_error(phydev);
681 }
682 
683 /**
684  * phy_stop - Bring down the PHY link, and stop checking the status
685  * @phydev: target phy_device struct
686  */
687 void phy_stop(struct phy_device *phydev)
688 {
689 	mutex_lock(&phydev->lock);
690 
691 	if (PHY_HALTED == phydev->state)
692 		goto out_unlock;
693 
694 	if (phy_interrupt_is_valid(phydev)) {
695 		/* Disable PHY Interrupts */
696 		phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
697 
698 		/* Clear any pending interrupts */
699 		phy_clear_interrupt(phydev);
700 	}
701 
702 	phydev->state = PHY_HALTED;
703 
704 out_unlock:
705 	mutex_unlock(&phydev->lock);
706 
707 	/* Cannot call flush_scheduled_work() here as desired because
708 	 * of rtnl_lock(), but PHY_HALTED shall guarantee phy_change()
709 	 * will not reenable interrupts.
710 	 */
711 }
712 EXPORT_SYMBOL(phy_stop);
713 
714 /**
715  * phy_start - start or restart a PHY device
716  * @phydev: target phy_device struct
717  *
718  * Description: Indicates the attached device's readiness to
719  *   handle PHY-related work.  Used during startup to start the
720  *   PHY, and after a call to phy_stop() to resume operation.
721  *   Also used to indicate the MDIO bus has cleared an error
722  *   condition.
723  */
724 void phy_start(struct phy_device *phydev)
725 {
726 	mutex_lock(&phydev->lock);
727 
728 	switch (phydev->state) {
729 	case PHY_STARTING:
730 		phydev->state = PHY_PENDING;
731 		break;
732 	case PHY_READY:
733 		phydev->state = PHY_UP;
734 		break;
735 	case PHY_HALTED:
736 		phydev->state = PHY_RESUMING;
737 	default:
738 		break;
739 	}
740 	mutex_unlock(&phydev->lock);
741 }
742 EXPORT_SYMBOL(phy_start);
743 
744 /**
745  * phy_state_machine - Handle the state machine
746  * @work: work_struct that describes the work to be done
747  */
748 void phy_state_machine(struct work_struct *work)
749 {
750 	struct delayed_work *dwork = to_delayed_work(work);
751 	struct phy_device *phydev =
752 			container_of(dwork, struct phy_device, state_queue);
753 	bool needs_aneg = false, do_suspend = false, do_resume = false;
754 	int err = 0;
755 
756 	mutex_lock(&phydev->lock);
757 
758 	if (phydev->drv->link_change_notify)
759 		phydev->drv->link_change_notify(phydev);
760 
761 	switch (phydev->state) {
762 	case PHY_DOWN:
763 	case PHY_STARTING:
764 	case PHY_READY:
765 	case PHY_PENDING:
766 		break;
767 	case PHY_UP:
768 		needs_aneg = true;
769 
770 		phydev->link_timeout = PHY_AN_TIMEOUT;
771 
772 		break;
773 	case PHY_AN:
774 		err = phy_read_status(phydev);
775 		if (err < 0)
776 			break;
777 
778 		/* If the link is down, give up on negotiation for now */
779 		if (!phydev->link) {
780 			phydev->state = PHY_NOLINK;
781 			netif_carrier_off(phydev->attached_dev);
782 			phydev->adjust_link(phydev->attached_dev);
783 			break;
784 		}
785 
786 		/* Check if negotiation is done.  Break if there's an error */
787 		err = phy_aneg_done(phydev);
788 		if (err < 0)
789 			break;
790 
791 		/* If AN is done, we're running */
792 		if (err > 0) {
793 			phydev->state = PHY_RUNNING;
794 			netif_carrier_on(phydev->attached_dev);
795 			phydev->adjust_link(phydev->attached_dev);
796 
797 		} else if (0 == phydev->link_timeout--)
798 			needs_aneg = true;
799 		break;
800 	case PHY_NOLINK:
801 		err = phy_read_status(phydev);
802 		if (err)
803 			break;
804 
805 		if (phydev->link) {
806 			if (AUTONEG_ENABLE == phydev->autoneg) {
807 				err = phy_aneg_done(phydev);
808 				if (err < 0)
809 					break;
810 
811 				if (!err) {
812 					phydev->state = PHY_AN;
813 					phydev->link_timeout = PHY_AN_TIMEOUT;
814 					break;
815 				}
816 			}
817 			phydev->state = PHY_RUNNING;
818 			netif_carrier_on(phydev->attached_dev);
819 			phydev->adjust_link(phydev->attached_dev);
820 		}
821 		break;
822 	case PHY_FORCING:
823 		err = genphy_update_link(phydev);
824 		if (err)
825 			break;
826 
827 		if (phydev->link) {
828 			phydev->state = PHY_RUNNING;
829 			netif_carrier_on(phydev->attached_dev);
830 		} else {
831 			if (0 == phydev->link_timeout--)
832 				needs_aneg = true;
833 		}
834 
835 		phydev->adjust_link(phydev->attached_dev);
836 		break;
837 	case PHY_RUNNING:
838 		/* Only register a CHANGE if we are
839 		 * polling or ignoring interrupts
840 		 */
841 		if (!phy_interrupt_is_valid(phydev))
842 			phydev->state = PHY_CHANGELINK;
843 		break;
844 	case PHY_CHANGELINK:
845 		err = phy_read_status(phydev);
846 		if (err)
847 			break;
848 
849 		if (phydev->link) {
850 			phydev->state = PHY_RUNNING;
851 			netif_carrier_on(phydev->attached_dev);
852 		} else {
853 			phydev->state = PHY_NOLINK;
854 			netif_carrier_off(phydev->attached_dev);
855 		}
856 
857 		phydev->adjust_link(phydev->attached_dev);
858 
859 		if (phy_interrupt_is_valid(phydev))
860 			err = phy_config_interrupt(phydev,
861 						   PHY_INTERRUPT_ENABLED);
862 		break;
863 	case PHY_HALTED:
864 		if (phydev->link) {
865 			phydev->link = 0;
866 			netif_carrier_off(phydev->attached_dev);
867 			phydev->adjust_link(phydev->attached_dev);
868 			do_suspend = true;
869 		}
870 		break;
871 	case PHY_RESUMING:
872 		err = phy_clear_interrupt(phydev);
873 		if (err)
874 			break;
875 
876 		err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
877 		if (err)
878 			break;
879 
880 		if (AUTONEG_ENABLE == phydev->autoneg) {
881 			err = phy_aneg_done(phydev);
882 			if (err < 0)
883 				break;
884 
885 			/* err > 0 if AN is done.
886 			 * Otherwise, it's 0, and we're  still waiting for AN
887 			 */
888 			if (err > 0) {
889 				err = phy_read_status(phydev);
890 				if (err)
891 					break;
892 
893 				if (phydev->link) {
894 					phydev->state = PHY_RUNNING;
895 					netif_carrier_on(phydev->attached_dev);
896 				} else	{
897 					phydev->state = PHY_NOLINK;
898 				}
899 				phydev->adjust_link(phydev->attached_dev);
900 			} else {
901 				phydev->state = PHY_AN;
902 				phydev->link_timeout = PHY_AN_TIMEOUT;
903 			}
904 		} else {
905 			err = phy_read_status(phydev);
906 			if (err)
907 				break;
908 
909 			if (phydev->link) {
910 				phydev->state = PHY_RUNNING;
911 				netif_carrier_on(phydev->attached_dev);
912 			} else	{
913 				phydev->state = PHY_NOLINK;
914 			}
915 			phydev->adjust_link(phydev->attached_dev);
916 		}
917 		do_resume = true;
918 		break;
919 	}
920 
921 	mutex_unlock(&phydev->lock);
922 
923 	if (needs_aneg)
924 		err = phy_start_aneg(phydev);
925 	else if (do_suspend)
926 		phy_suspend(phydev);
927 	else if (do_resume)
928 		phy_resume(phydev);
929 
930 	if (err < 0)
931 		phy_error(phydev);
932 
933 	queue_delayed_work(system_power_efficient_wq, &phydev->state_queue,
934 			   PHY_STATE_TIME * HZ);
935 }
936 
937 void phy_mac_interrupt(struct phy_device *phydev, int new_link)
938 {
939 	cancel_work_sync(&phydev->phy_queue);
940 	phydev->link = new_link;
941 	schedule_work(&phydev->phy_queue);
942 }
943 EXPORT_SYMBOL(phy_mac_interrupt);
944 
945 static inline void mmd_phy_indirect(struct mii_bus *bus, int prtad, int devad,
946 				    int addr)
947 {
948 	/* Write the desired MMD Devad */
949 	bus->write(bus, addr, MII_MMD_CTRL, devad);
950 
951 	/* Write the desired MMD register address */
952 	bus->write(bus, addr, MII_MMD_DATA, prtad);
953 
954 	/* Select the Function : DATA with no post increment */
955 	bus->write(bus, addr, MII_MMD_CTRL, (devad | MII_MMD_CTRL_NOINCR));
956 }
957 
958 /**
959  * phy_read_mmd_indirect - reads data from the MMD registers
960  * @phydev: The PHY device bus
961  * @prtad: MMD Address
962  * @devad: MMD DEVAD
963  * @addr: PHY address on the MII bus
964  *
965  * Description: it reads data from the MMD registers (clause 22 to access to
966  * clause 45) of the specified phy address.
967  * To read these register we have:
968  * 1) Write reg 13 // DEVAD
969  * 2) Write reg 14 // MMD Address
970  * 3) Write reg 13 // MMD Data Command for MMD DEVAD
971  * 3) Read  reg 14 // Read MMD data
972  */
973 int phy_read_mmd_indirect(struct phy_device *phydev, int prtad,
974 				 int devad, int addr)
975 {
976 	struct phy_driver *phydrv = phydev->drv;
977 	int value = -1;
978 
979 	if (phydrv->read_mmd_indirect == NULL) {
980 		mmd_phy_indirect(phydev->bus, prtad, devad, addr);
981 
982 		/* Read the content of the MMD's selected register */
983 		value = phydev->bus->read(phydev->bus, addr, MII_MMD_DATA);
984 	} else {
985 		value = phydrv->read_mmd_indirect(phydev, prtad, devad, addr);
986 	}
987 	return value;
988 }
989 EXPORT_SYMBOL(phy_read_mmd_indirect);
990 
991 /**
992  * phy_write_mmd_indirect - writes data to the MMD registers
993  * @phydev: The PHY device
994  * @prtad: MMD Address
995  * @devad: MMD DEVAD
996  * @addr: PHY address on the MII bus
997  * @data: data to write in the MMD register
998  *
999  * Description: Write data from the MMD registers of the specified
1000  * phy address.
1001  * To write these register we have:
1002  * 1) Write reg 13 // DEVAD
1003  * 2) Write reg 14 // MMD Address
1004  * 3) Write reg 13 // MMD Data Command for MMD DEVAD
1005  * 3) Write reg 14 // Write MMD data
1006  */
1007 void phy_write_mmd_indirect(struct phy_device *phydev, int prtad,
1008 				   int devad, int addr, u32 data)
1009 {
1010 	struct phy_driver *phydrv = phydev->drv;
1011 
1012 	if (phydrv->write_mmd_indirect == NULL) {
1013 		mmd_phy_indirect(phydev->bus, prtad, devad, addr);
1014 
1015 		/* Write the data into MMD's selected register */
1016 		phydev->bus->write(phydev->bus, addr, MII_MMD_DATA, data);
1017 	} else {
1018 		phydrv->write_mmd_indirect(phydev, prtad, devad, addr, data);
1019 	}
1020 }
1021 EXPORT_SYMBOL(phy_write_mmd_indirect);
1022 
1023 /**
1024  * phy_init_eee - init and check the EEE feature
1025  * @phydev: target phy_device struct
1026  * @clk_stop_enable: PHY may stop the clock during LPI
1027  *
1028  * Description: it checks if the Energy-Efficient Ethernet (EEE)
1029  * is supported by looking at the MMD registers 3.20 and 7.60/61
1030  * and it programs the MMD register 3.0 setting the "Clock stop enable"
1031  * bit if required.
1032  */
1033 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
1034 {
1035 	/* According to 802.3az,the EEE is supported only in full duplex-mode.
1036 	 * Also EEE feature is active when core is operating with MII, GMII
1037 	 * or RGMII. Internal PHYs are also allowed to proceed and should
1038 	 * return an error if they do not support EEE.
1039 	 */
1040 	if ((phydev->duplex == DUPLEX_FULL) &&
1041 	    ((phydev->interface == PHY_INTERFACE_MODE_MII) ||
1042 	    (phydev->interface == PHY_INTERFACE_MODE_GMII) ||
1043 	    (phydev->interface == PHY_INTERFACE_MODE_RGMII) ||
1044 	     phy_is_internal(phydev))) {
1045 		int eee_lp, eee_cap, eee_adv;
1046 		u32 lp, cap, adv;
1047 		int status;
1048 		unsigned int idx;
1049 
1050 		/* Read phy status to properly get the right settings */
1051 		status = phy_read_status(phydev);
1052 		if (status)
1053 			return status;
1054 
1055 		/* First check if the EEE ability is supported */
1056 		eee_cap = phy_read_mmd_indirect(phydev, MDIO_PCS_EEE_ABLE,
1057 						MDIO_MMD_PCS, phydev->addr);
1058 		if (eee_cap <= 0)
1059 			goto eee_exit_err;
1060 
1061 		cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap);
1062 		if (!cap)
1063 			goto eee_exit_err;
1064 
1065 		/* Check which link settings negotiated and verify it in
1066 		 * the EEE advertising registers.
1067 		 */
1068 		eee_lp = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_LPABLE,
1069 					       MDIO_MMD_AN, phydev->addr);
1070 		if (eee_lp <= 0)
1071 			goto eee_exit_err;
1072 
1073 		eee_adv = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_ADV,
1074 						MDIO_MMD_AN, phydev->addr);
1075 		if (eee_adv <= 0)
1076 			goto eee_exit_err;
1077 
1078 		adv = mmd_eee_adv_to_ethtool_adv_t(eee_adv);
1079 		lp = mmd_eee_adv_to_ethtool_adv_t(eee_lp);
1080 		idx = phy_find_setting(phydev->speed, phydev->duplex);
1081 		if (!(lp & adv & settings[idx].setting))
1082 			goto eee_exit_err;
1083 
1084 		if (clk_stop_enable) {
1085 			/* Configure the PHY to stop receiving xMII
1086 			 * clock while it is signaling LPI.
1087 			 */
1088 			int val = phy_read_mmd_indirect(phydev, MDIO_CTRL1,
1089 							MDIO_MMD_PCS,
1090 							phydev->addr);
1091 			if (val < 0)
1092 				return val;
1093 
1094 			val |= MDIO_PCS_CTRL1_CLKSTOP_EN;
1095 			phy_write_mmd_indirect(phydev, MDIO_CTRL1,
1096 					       MDIO_MMD_PCS, phydev->addr,
1097 					       val);
1098 		}
1099 
1100 		return 0; /* EEE supported */
1101 	}
1102 eee_exit_err:
1103 	return -EPROTONOSUPPORT;
1104 }
1105 EXPORT_SYMBOL(phy_init_eee);
1106 
1107 /**
1108  * phy_get_eee_err - report the EEE wake error count
1109  * @phydev: target phy_device struct
1110  *
1111  * Description: it is to report the number of time where the PHY
1112  * failed to complete its normal wake sequence.
1113  */
1114 int phy_get_eee_err(struct phy_device *phydev)
1115 {
1116 	return phy_read_mmd_indirect(phydev, MDIO_PCS_EEE_WK_ERR,
1117 				     MDIO_MMD_PCS, phydev->addr);
1118 }
1119 EXPORT_SYMBOL(phy_get_eee_err);
1120 
1121 /**
1122  * phy_ethtool_get_eee - get EEE supported and status
1123  * @phydev: target phy_device struct
1124  * @data: ethtool_eee data
1125  *
1126  * Description: it reportes the Supported/Advertisement/LP Advertisement
1127  * capabilities.
1128  */
1129 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data)
1130 {
1131 	int val;
1132 
1133 	/* Get Supported EEE */
1134 	val = phy_read_mmd_indirect(phydev, MDIO_PCS_EEE_ABLE,
1135 				    MDIO_MMD_PCS, phydev->addr);
1136 	if (val < 0)
1137 		return val;
1138 	data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
1139 
1140 	/* Get advertisement EEE */
1141 	val = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_ADV,
1142 				    MDIO_MMD_AN, phydev->addr);
1143 	if (val < 0)
1144 		return val;
1145 	data->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1146 
1147 	/* Get LP advertisement EEE */
1148 	val = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_LPABLE,
1149 				    MDIO_MMD_AN, phydev->addr);
1150 	if (val < 0)
1151 		return val;
1152 	data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1153 
1154 	return 0;
1155 }
1156 EXPORT_SYMBOL(phy_ethtool_get_eee);
1157 
1158 /**
1159  * phy_ethtool_set_eee - set EEE supported and status
1160  * @phydev: target phy_device struct
1161  * @data: ethtool_eee data
1162  *
1163  * Description: it is to program the Advertisement EEE register.
1164  */
1165 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data)
1166 {
1167 	int val = ethtool_adv_to_mmd_eee_adv_t(data->advertised);
1168 
1169 	phy_write_mmd_indirect(phydev, MDIO_AN_EEE_ADV, MDIO_MMD_AN,
1170 			       phydev->addr, val);
1171 
1172 	return 0;
1173 }
1174 EXPORT_SYMBOL(phy_ethtool_set_eee);
1175 
1176 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1177 {
1178 	if (phydev->drv->set_wol)
1179 		return phydev->drv->set_wol(phydev, wol);
1180 
1181 	return -EOPNOTSUPP;
1182 }
1183 EXPORT_SYMBOL(phy_ethtool_set_wol);
1184 
1185 void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1186 {
1187 	if (phydev->drv->get_wol)
1188 		phydev->drv->get_wol(phydev, wol);
1189 }
1190 EXPORT_SYMBOL(phy_ethtool_get_wol);
1191