whiterose

linux unikernel
Log | Files | Refs | README | LICENSE | git clone https://git.ne02ptzero.me/git/whiterose

phy_device.c (61312B)


      1 // SPDX-License-Identifier: GPL-2.0+
      2 /* Framework for finding and configuring PHYs.
      3  * Also contains generic PHY driver
      4  *
      5  * Author: Andy Fleming
      6  *
      7  * Copyright (c) 2004 Freescale Semiconductor, Inc.
      8  */
      9 
     10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
     11 
     12 #include <linux/kernel.h>
     13 #include <linux/string.h>
     14 #include <linux/errno.h>
     15 #include <linux/unistd.h>
     16 #include <linux/slab.h>
     17 #include <linux/interrupt.h>
     18 #include <linux/init.h>
     19 #include <linux/delay.h>
     20 #include <linux/netdevice.h>
     21 #include <linux/etherdevice.h>
     22 #include <linux/skbuff.h>
     23 #include <linux/mm.h>
     24 #include <linux/module.h>
     25 #include <linux/mii.h>
     26 #include <linux/ethtool.h>
     27 #include <linux/bitmap.h>
     28 #include <linux/phy.h>
     29 #include <linux/phy_led_triggers.h>
     30 #include <linux/mdio.h>
     31 #include <linux/io.h>
     32 #include <linux/uaccess.h>
     33 
     34 MODULE_DESCRIPTION("PHY library");
     35 MODULE_AUTHOR("Andy Fleming");
     36 MODULE_LICENSE("GPL");
     37 
     38 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_features) __ro_after_init;
     39 EXPORT_SYMBOL_GPL(phy_basic_features);
     40 
     41 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1_features) __ro_after_init;
     42 EXPORT_SYMBOL_GPL(phy_basic_t1_features);
     43 
     44 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features) __ro_after_init;
     45 EXPORT_SYMBOL_GPL(phy_gbit_features);
     46 
     47 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init;
     48 EXPORT_SYMBOL_GPL(phy_gbit_fibre_features);
     49 
     50 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_all_ports_features) __ro_after_init;
     51 EXPORT_SYMBOL_GPL(phy_gbit_all_ports_features);
     52 
     53 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init;
     54 EXPORT_SYMBOL_GPL(phy_10gbit_features);
     55 
     56 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_fec_features) __ro_after_init;
     57 EXPORT_SYMBOL_GPL(phy_10gbit_fec_features);
     58 
     59 static const int phy_basic_ports_array[] = {
     60 	ETHTOOL_LINK_MODE_Autoneg_BIT,
     61 	ETHTOOL_LINK_MODE_TP_BIT,
     62 	ETHTOOL_LINK_MODE_MII_BIT,
     63 };
     64 EXPORT_SYMBOL_GPL(phy_basic_ports_array);
     65 
     66 static const int phy_fibre_port_array[] = {
     67 	ETHTOOL_LINK_MODE_FIBRE_BIT,
     68 };
     69 EXPORT_SYMBOL_GPL(phy_fibre_port_array);
     70 
     71 static const int phy_all_ports_features_array[] = {
     72 	ETHTOOL_LINK_MODE_Autoneg_BIT,
     73 	ETHTOOL_LINK_MODE_TP_BIT,
     74 	ETHTOOL_LINK_MODE_MII_BIT,
     75 	ETHTOOL_LINK_MODE_FIBRE_BIT,
     76 	ETHTOOL_LINK_MODE_AUI_BIT,
     77 	ETHTOOL_LINK_MODE_BNC_BIT,
     78 	ETHTOOL_LINK_MODE_Backplane_BIT,
     79 };
     80 EXPORT_SYMBOL_GPL(phy_all_ports_features_array);
     81 
     82 const int phy_10_100_features_array[4] = {
     83 	ETHTOOL_LINK_MODE_10baseT_Half_BIT,
     84 	ETHTOOL_LINK_MODE_10baseT_Full_BIT,
     85 	ETHTOOL_LINK_MODE_100baseT_Half_BIT,
     86 	ETHTOOL_LINK_MODE_100baseT_Full_BIT,
     87 };
     88 EXPORT_SYMBOL_GPL(phy_10_100_features_array);
     89 
     90 const int phy_basic_t1_features_array[2] = {
     91 	ETHTOOL_LINK_MODE_TP_BIT,
     92 	ETHTOOL_LINK_MODE_100baseT_Full_BIT,
     93 };
     94 EXPORT_SYMBOL_GPL(phy_basic_t1_features_array);
     95 
     96 const int phy_gbit_features_array[2] = {
     97 	ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
     98 	ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
     99 };
    100 EXPORT_SYMBOL_GPL(phy_gbit_features_array);
    101 
    102 const int phy_10gbit_features_array[1] = {
    103 	ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
    104 };
    105 EXPORT_SYMBOL_GPL(phy_10gbit_features_array);
    106 
    107 const int phy_10gbit_fec_features_array[1] = {
    108 	ETHTOOL_LINK_MODE_10000baseR_FEC_BIT,
    109 };
    110 EXPORT_SYMBOL_GPL(phy_10gbit_fec_features_array);
    111 
    112 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_init;
    113 EXPORT_SYMBOL_GPL(phy_10gbit_full_features);
    114 
    115 static const int phy_10gbit_full_features_array[] = {
    116 	ETHTOOL_LINK_MODE_10baseT_Full_BIT,
    117 	ETHTOOL_LINK_MODE_100baseT_Full_BIT,
    118 	ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
    119 	ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
    120 };
    121 
    122 static void features_init(void)
    123 {
    124 	/* 10/100 half/full*/
    125 	linkmode_set_bit_array(phy_basic_ports_array,
    126 			       ARRAY_SIZE(phy_basic_ports_array),
    127 			       phy_basic_features);
    128 	linkmode_set_bit_array(phy_10_100_features_array,
    129 			       ARRAY_SIZE(phy_10_100_features_array),
    130 			       phy_basic_features);
    131 
    132 	/* 100 full, TP */
    133 	linkmode_set_bit_array(phy_basic_t1_features_array,
    134 			       ARRAY_SIZE(phy_basic_t1_features_array),
    135 			       phy_basic_t1_features);
    136 
    137 	/* 10/100 half/full + 1000 half/full */
    138 	linkmode_set_bit_array(phy_basic_ports_array,
    139 			       ARRAY_SIZE(phy_basic_ports_array),
    140 			       phy_gbit_features);
    141 	linkmode_set_bit_array(phy_10_100_features_array,
    142 			       ARRAY_SIZE(phy_10_100_features_array),
    143 			       phy_gbit_features);
    144 	linkmode_set_bit_array(phy_gbit_features_array,
    145 			       ARRAY_SIZE(phy_gbit_features_array),
    146 			       phy_gbit_features);
    147 
    148 	/* 10/100 half/full + 1000 half/full + fibre*/
    149 	linkmode_set_bit_array(phy_basic_ports_array,
    150 			       ARRAY_SIZE(phy_basic_ports_array),
    151 			       phy_gbit_fibre_features);
    152 	linkmode_set_bit_array(phy_10_100_features_array,
    153 			       ARRAY_SIZE(phy_10_100_features_array),
    154 			       phy_gbit_fibre_features);
    155 	linkmode_set_bit_array(phy_gbit_features_array,
    156 			       ARRAY_SIZE(phy_gbit_features_array),
    157 			       phy_gbit_fibre_features);
    158 	linkmode_set_bit_array(phy_fibre_port_array,
    159 			       ARRAY_SIZE(phy_fibre_port_array),
    160 			       phy_gbit_fibre_features);
    161 
    162 	/* 10/100 half/full + 1000 half/full + TP/MII/FIBRE/AUI/BNC/Backplane*/
    163 	linkmode_set_bit_array(phy_all_ports_features_array,
    164 			       ARRAY_SIZE(phy_all_ports_features_array),
    165 			       phy_gbit_all_ports_features);
    166 	linkmode_set_bit_array(phy_10_100_features_array,
    167 			       ARRAY_SIZE(phy_10_100_features_array),
    168 			       phy_gbit_all_ports_features);
    169 	linkmode_set_bit_array(phy_gbit_features_array,
    170 			       ARRAY_SIZE(phy_gbit_features_array),
    171 			       phy_gbit_all_ports_features);
    172 
    173 	/* 10/100 half/full + 1000 half/full + 10G full*/
    174 	linkmode_set_bit_array(phy_all_ports_features_array,
    175 			       ARRAY_SIZE(phy_all_ports_features_array),
    176 			       phy_10gbit_features);
    177 	linkmode_set_bit_array(phy_10_100_features_array,
    178 			       ARRAY_SIZE(phy_10_100_features_array),
    179 			       phy_10gbit_features);
    180 	linkmode_set_bit_array(phy_gbit_features_array,
    181 			       ARRAY_SIZE(phy_gbit_features_array),
    182 			       phy_10gbit_features);
    183 	linkmode_set_bit_array(phy_10gbit_features_array,
    184 			       ARRAY_SIZE(phy_10gbit_features_array),
    185 			       phy_10gbit_features);
    186 
    187 	/* 10/100/1000/10G full */
    188 	linkmode_set_bit_array(phy_all_ports_features_array,
    189 			       ARRAY_SIZE(phy_all_ports_features_array),
    190 			       phy_10gbit_full_features);
    191 	linkmode_set_bit_array(phy_10gbit_full_features_array,
    192 			       ARRAY_SIZE(phy_10gbit_full_features_array),
    193 			       phy_10gbit_full_features);
    194 	/* 10G FEC only */
    195 	linkmode_set_bit_array(phy_10gbit_fec_features_array,
    196 			       ARRAY_SIZE(phy_10gbit_fec_features_array),
    197 			       phy_10gbit_fec_features);
    198 }
    199 
    200 void phy_device_free(struct phy_device *phydev)
    201 {
    202 	put_device(&phydev->mdio.dev);
    203 }
    204 EXPORT_SYMBOL(phy_device_free);
    205 
    206 static void phy_mdio_device_free(struct mdio_device *mdiodev)
    207 {
    208 	struct phy_device *phydev;
    209 
    210 	phydev = container_of(mdiodev, struct phy_device, mdio);
    211 	phy_device_free(phydev);
    212 }
    213 
    214 static void phy_device_release(struct device *dev)
    215 {
    216 	kfree(to_phy_device(dev));
    217 }
    218 
    219 static void phy_mdio_device_remove(struct mdio_device *mdiodev)
    220 {
    221 	struct phy_device *phydev;
    222 
    223 	phydev = container_of(mdiodev, struct phy_device, mdio);
    224 	phy_device_remove(phydev);
    225 }
    226 
    227 static struct phy_driver genphy_driver;
    228 extern struct phy_driver genphy_10g_driver;
    229 
    230 static LIST_HEAD(phy_fixup_list);
    231 static DEFINE_MUTEX(phy_fixup_lock);
    232 
    233 #ifdef CONFIG_PM
    234 static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
    235 {
    236 	struct device_driver *drv = phydev->mdio.dev.driver;
    237 	struct phy_driver *phydrv = to_phy_driver(drv);
    238 	struct net_device *netdev = phydev->attached_dev;
    239 
    240 	if (!drv || !phydrv->suspend)
    241 		return false;
    242 
    243 	/* PHY not attached? May suspend if the PHY has not already been
    244 	 * suspended as part of a prior call to phy_disconnect() ->
    245 	 * phy_detach() -> phy_suspend() because the parent netdev might be the
    246 	 * MDIO bus driver and clock gated at this point.
    247 	 */
    248 	if (!netdev)
    249 		return !phydev->suspended;
    250 
    251 	if (netdev->wol_enabled)
    252 		return false;
    253 
    254 	/* As long as not all affected network drivers support the
    255 	 * wol_enabled flag, let's check for hints that WoL is enabled.
    256 	 * Don't suspend PHY if the attached netdev parent may wake up.
    257 	 * The parent may point to a PCI device, as in tg3 driver.
    258 	 */
    259 	if (netdev->dev.parent && device_may_wakeup(netdev->dev.parent))
    260 		return false;
    261 
    262 	/* Also don't suspend PHY if the netdev itself may wakeup. This
    263 	 * is the case for devices w/o underlaying pwr. mgmt. aware bus,
    264 	 * e.g. SoC devices.
    265 	 */
    266 	if (device_may_wakeup(&netdev->dev))
    267 		return false;
    268 
    269 	return true;
    270 }
    271 
    272 static int mdio_bus_phy_suspend(struct device *dev)
    273 {
    274 	struct phy_device *phydev = to_phy_device(dev);
    275 
    276 	/* We must stop the state machine manually, otherwise it stops out of
    277 	 * control, possibly with the phydev->lock held. Upon resume, netdev
    278 	 * may call phy routines that try to grab the same lock, and that may
    279 	 * lead to a deadlock.
    280 	 */
    281 	if (phydev->attached_dev && phydev->adjust_link)
    282 		phy_stop_machine(phydev);
    283 
    284 	if (!mdio_bus_phy_may_suspend(phydev))
    285 		return 0;
    286 
    287 	return phy_suspend(phydev);
    288 }
    289 
    290 static int mdio_bus_phy_resume(struct device *dev)
    291 {
    292 	struct phy_device *phydev = to_phy_device(dev);
    293 	int ret;
    294 
    295 	if (!mdio_bus_phy_may_suspend(phydev))
    296 		goto no_resume;
    297 
    298 	ret = phy_resume(phydev);
    299 	if (ret < 0)
    300 		return ret;
    301 
    302 no_resume:
    303 	if (phydev->attached_dev && phydev->adjust_link)
    304 		phy_start_machine(phydev);
    305 
    306 	return 0;
    307 }
    308 
    309 static int mdio_bus_phy_restore(struct device *dev)
    310 {
    311 	struct phy_device *phydev = to_phy_device(dev);
    312 	struct net_device *netdev = phydev->attached_dev;
    313 	int ret;
    314 
    315 	if (!netdev)
    316 		return 0;
    317 
    318 	ret = phy_init_hw(phydev);
    319 	if (ret < 0)
    320 		return ret;
    321 
    322 	if (phydev->attached_dev && phydev->adjust_link)
    323 		phy_start_machine(phydev);
    324 
    325 	return 0;
    326 }
    327 
    328 static const struct dev_pm_ops mdio_bus_phy_pm_ops = {
    329 	.suspend = mdio_bus_phy_suspend,
    330 	.resume = mdio_bus_phy_resume,
    331 	.freeze = mdio_bus_phy_suspend,
    332 	.thaw = mdio_bus_phy_resume,
    333 	.restore = mdio_bus_phy_restore,
    334 };
    335 
    336 #define MDIO_BUS_PHY_PM_OPS (&mdio_bus_phy_pm_ops)
    337 
    338 #else
    339 
    340 #define MDIO_BUS_PHY_PM_OPS NULL
    341 
    342 #endif /* CONFIG_PM */
    343 
    344 /**
    345  * phy_register_fixup - creates a new phy_fixup and adds it to the list
    346  * @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID)
    347  * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
    348  *	It can also be PHY_ANY_UID
    349  * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
    350  *	comparison
    351  * @run: The actual code to be run when a matching PHY is found
    352  */
    353 int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
    354 		       int (*run)(struct phy_device *))
    355 {
    356 	struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL);
    357 
    358 	if (!fixup)
    359 		return -ENOMEM;
    360 
    361 	strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
    362 	fixup->phy_uid = phy_uid;
    363 	fixup->phy_uid_mask = phy_uid_mask;
    364 	fixup->run = run;
    365 
    366 	mutex_lock(&phy_fixup_lock);
    367 	list_add_tail(&fixup->list, &phy_fixup_list);
    368 	mutex_unlock(&phy_fixup_lock);
    369 
    370 	return 0;
    371 }
    372 EXPORT_SYMBOL(phy_register_fixup);
    373 
    374 /* Registers a fixup to be run on any PHY with the UID in phy_uid */
    375 int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
    376 			       int (*run)(struct phy_device *))
    377 {
    378 	return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
    379 }
    380 EXPORT_SYMBOL(phy_register_fixup_for_uid);
    381 
    382 /* Registers a fixup to be run on the PHY with id string bus_id */
    383 int phy_register_fixup_for_id(const char *bus_id,
    384 			      int (*run)(struct phy_device *))
    385 {
    386 	return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
    387 }
    388 EXPORT_SYMBOL(phy_register_fixup_for_id);
    389 
    390 /**
    391  * phy_unregister_fixup - remove a phy_fixup from the list
    392  * @bus_id: A string matches fixup->bus_id (or PHY_ANY_ID) in phy_fixup_list
    393  * @phy_uid: A phy id matches fixup->phy_id (or PHY_ANY_UID) in phy_fixup_list
    394  * @phy_uid_mask: Applied to phy_uid and fixup->phy_uid before comparison
    395  */
    396 int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask)
    397 {
    398 	struct list_head *pos, *n;
    399 	struct phy_fixup *fixup;
    400 	int ret;
    401 
    402 	ret = -ENODEV;
    403 
    404 	mutex_lock(&phy_fixup_lock);
    405 	list_for_each_safe(pos, n, &phy_fixup_list) {
    406 		fixup = list_entry(pos, struct phy_fixup, list);
    407 
    408 		if ((!strcmp(fixup->bus_id, bus_id)) &&
    409 		    ((fixup->phy_uid & phy_uid_mask) ==
    410 		     (phy_uid & phy_uid_mask))) {
    411 			list_del(&fixup->list);
    412 			kfree(fixup);
    413 			ret = 0;
    414 			break;
    415 		}
    416 	}
    417 	mutex_unlock(&phy_fixup_lock);
    418 
    419 	return ret;
    420 }
    421 EXPORT_SYMBOL(phy_unregister_fixup);
    422 
    423 /* Unregisters a fixup of any PHY with the UID in phy_uid */
    424 int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask)
    425 {
    426 	return phy_unregister_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask);
    427 }
    428 EXPORT_SYMBOL(phy_unregister_fixup_for_uid);
    429 
    430 /* Unregisters a fixup of the PHY with id string bus_id */
    431 int phy_unregister_fixup_for_id(const char *bus_id)
    432 {
    433 	return phy_unregister_fixup(bus_id, PHY_ANY_UID, 0xffffffff);
    434 }
    435 EXPORT_SYMBOL(phy_unregister_fixup_for_id);
    436 
    437 /* Returns 1 if fixup matches phydev in bus_id and phy_uid.
    438  * Fixups can be set to match any in one or more fields.
    439  */
    440 static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
    441 {
    442 	if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0)
    443 		if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
    444 			return 0;
    445 
    446 	if ((fixup->phy_uid & fixup->phy_uid_mask) !=
    447 	    (phydev->phy_id & fixup->phy_uid_mask))
    448 		if (fixup->phy_uid != PHY_ANY_UID)
    449 			return 0;
    450 
    451 	return 1;
    452 }
    453 
    454 /* Runs any matching fixups for this phydev */
    455 static int phy_scan_fixups(struct phy_device *phydev)
    456 {
    457 	struct phy_fixup *fixup;
    458 
    459 	mutex_lock(&phy_fixup_lock);
    460 	list_for_each_entry(fixup, &phy_fixup_list, list) {
    461 		if (phy_needs_fixup(phydev, fixup)) {
    462 			int err = fixup->run(phydev);
    463 
    464 			if (err < 0) {
    465 				mutex_unlock(&phy_fixup_lock);
    466 				return err;
    467 			}
    468 			phydev->has_fixups = true;
    469 		}
    470 	}
    471 	mutex_unlock(&phy_fixup_lock);
    472 
    473 	return 0;
    474 }
    475 
    476 static int phy_bus_match(struct device *dev, struct device_driver *drv)
    477 {
    478 	struct phy_device *phydev = to_phy_device(dev);
    479 	struct phy_driver *phydrv = to_phy_driver(drv);
    480 	const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
    481 	int i;
    482 
    483 	if (!(phydrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY))
    484 		return 0;
    485 
    486 	if (phydrv->match_phy_device)
    487 		return phydrv->match_phy_device(phydev);
    488 
    489 	if (phydev->is_c45) {
    490 		for (i = 1; i < num_ids; i++) {
    491 			if (!(phydev->c45_ids.devices_in_package & (1 << i)))
    492 				continue;
    493 
    494 			if ((phydrv->phy_id & phydrv->phy_id_mask) ==
    495 			    (phydev->c45_ids.device_ids[i] &
    496 			     phydrv->phy_id_mask))
    497 				return 1;
    498 		}
    499 		return 0;
    500 	} else {
    501 		return (phydrv->phy_id & phydrv->phy_id_mask) ==
    502 			(phydev->phy_id & phydrv->phy_id_mask);
    503 	}
    504 }
    505 
    506 static ssize_t
    507 phy_id_show(struct device *dev, struct device_attribute *attr, char *buf)
    508 {
    509 	struct phy_device *phydev = to_phy_device(dev);
    510 
    511 	return sprintf(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);
    512 }
    513 static DEVICE_ATTR_RO(phy_id);
    514 
    515 static ssize_t
    516 phy_interface_show(struct device *dev, struct device_attribute *attr, char *buf)
    517 {
    518 	struct phy_device *phydev = to_phy_device(dev);
    519 	const char *mode = NULL;
    520 
    521 	if (phy_is_internal(phydev))
    522 		mode = "internal";
    523 	else
    524 		mode = phy_modes(phydev->interface);
    525 
    526 	return sprintf(buf, "%s\n", mode);
    527 }
    528 static DEVICE_ATTR_RO(phy_interface);
    529 
    530 static ssize_t
    531 phy_has_fixups_show(struct device *dev, struct device_attribute *attr,
    532 		    char *buf)
    533 {
    534 	struct phy_device *phydev = to_phy_device(dev);
    535 
    536 	return sprintf(buf, "%d\n", phydev->has_fixups);
    537 }
    538 static DEVICE_ATTR_RO(phy_has_fixups);
    539 
    540 static struct attribute *phy_dev_attrs[] = {
    541 	&dev_attr_phy_id.attr,
    542 	&dev_attr_phy_interface.attr,
    543 	&dev_attr_phy_has_fixups.attr,
    544 	NULL,
    545 };
    546 ATTRIBUTE_GROUPS(phy_dev);
    547 
    548 static const struct device_type mdio_bus_phy_type = {
    549 	.name = "PHY",
    550 	.groups = phy_dev_groups,
    551 	.release = phy_device_release,
    552 	.pm = MDIO_BUS_PHY_PM_OPS,
    553 };
    554 
    555 static int phy_request_driver_module(struct phy_device *dev, int phy_id)
    556 {
    557 	int ret;
    558 
    559 	ret = request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT,
    560 			     MDIO_ID_ARGS(phy_id));
    561 	/* We only check for failures in executing the usermode binary,
    562 	 * not whether a PHY driver module exists for the PHY ID.
    563 	 * Accept -ENOENT because this may occur in case no initramfs exists,
    564 	 * then modprobe isn't available.
    565 	 */
    566 	if (IS_ENABLED(CONFIG_MODULES) && ret < 0 && ret != -ENOENT) {
    567 		phydev_err(dev, "error %d loading PHY driver module for ID 0x%08x\n",
    568 			   ret, phy_id);
    569 		return ret;
    570 	}
    571 
    572 	return 0;
    573 }
    574 
    575 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
    576 				     bool is_c45,
    577 				     struct phy_c45_device_ids *c45_ids)
    578 {
    579 	struct phy_device *dev;
    580 	struct mdio_device *mdiodev;
    581 	int ret = 0;
    582 
    583 	/* We allocate the device, and initialize the default values */
    584 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    585 	if (!dev)
    586 		return ERR_PTR(-ENOMEM);
    587 
    588 	mdiodev = &dev->mdio;
    589 	mdiodev->dev.parent = &bus->dev;
    590 	mdiodev->dev.bus = &mdio_bus_type;
    591 	mdiodev->dev.type = &mdio_bus_phy_type;
    592 	mdiodev->bus = bus;
    593 	mdiodev->bus_match = phy_bus_match;
    594 	mdiodev->addr = addr;
    595 	mdiodev->flags = MDIO_DEVICE_FLAG_PHY;
    596 	mdiodev->device_free = phy_mdio_device_free;
    597 	mdiodev->device_remove = phy_mdio_device_remove;
    598 
    599 	dev->speed = 0;
    600 	dev->duplex = -1;
    601 	dev->pause = 0;
    602 	dev->asym_pause = 0;
    603 	dev->link = 0;
    604 	dev->interface = PHY_INTERFACE_MODE_GMII;
    605 
    606 	dev->autoneg = AUTONEG_ENABLE;
    607 
    608 	dev->is_c45 = is_c45;
    609 	dev->phy_id = phy_id;
    610 	if (c45_ids)
    611 		dev->c45_ids = *c45_ids;
    612 	dev->irq = bus->irq[addr];
    613 	dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);
    614 
    615 	dev->state = PHY_DOWN;
    616 
    617 	mutex_init(&dev->lock);
    618 	INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
    619 
    620 	/* Request the appropriate module unconditionally; don't
    621 	 * bother trying to do so only if it isn't already loaded,
    622 	 * because that gets complicated. A hotplug event would have
    623 	 * done an unconditional modprobe anyway.
    624 	 * We don't do normal hotplug because it won't work for MDIO
    625 	 * -- because it relies on the device staying around for long
    626 	 * enough for the driver to get loaded. With MDIO, the NIC
    627 	 * driver will get bored and give up as soon as it finds that
    628 	 * there's no driver _already_ loaded.
    629 	 */
    630 	if (is_c45 && c45_ids) {
    631 		const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
    632 		int i;
    633 
    634 		for (i = 1; i < num_ids; i++) {
    635 			if (!(c45_ids->devices_in_package & (1 << i)))
    636 				continue;
    637 
    638 			ret = phy_request_driver_module(dev,
    639 						c45_ids->device_ids[i]);
    640 			if (ret)
    641 				break;
    642 		}
    643 	} else {
    644 		ret = phy_request_driver_module(dev, phy_id);
    645 	}
    646 
    647 	if (!ret) {
    648 		device_initialize(&mdiodev->dev);
    649 	} else {
    650 		kfree(dev);
    651 		dev = ERR_PTR(ret);
    652 	}
    653 
    654 	return dev;
    655 }
    656 EXPORT_SYMBOL(phy_device_create);
    657 
    658 /* get_phy_c45_devs_in_pkg - reads a MMD's devices in package registers.
    659  * @bus: the target MII bus
    660  * @addr: PHY address on the MII bus
    661  * @dev_addr: MMD address in the PHY.
    662  * @devices_in_package: where to store the devices in package information.
    663  *
    664  * Description: reads devices in package registers of a MMD at @dev_addr
    665  * from PHY at @addr on @bus.
    666  *
    667  * Returns: 0 on success, -EIO on failure.
    668  */
    669 static int get_phy_c45_devs_in_pkg(struct mii_bus *bus, int addr, int dev_addr,
    670 				   u32 *devices_in_package)
    671 {
    672 	int phy_reg, reg_addr;
    673 
    674 	reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS2;
    675 	phy_reg = mdiobus_read(bus, addr, reg_addr);
    676 	if (phy_reg < 0)
    677 		return -EIO;
    678 	*devices_in_package = phy_reg << 16;
    679 
    680 	reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS1;
    681 	phy_reg = mdiobus_read(bus, addr, reg_addr);
    682 	if (phy_reg < 0)
    683 		return -EIO;
    684 	*devices_in_package |= phy_reg;
    685 
    686 	/* Bit 0 doesn't represent a device, it indicates c22 regs presence */
    687 	*devices_in_package &= ~BIT(0);
    688 
    689 	return 0;
    690 }
    691 
    692 /**
    693  * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.
    694  * @bus: the target MII bus
    695  * @addr: PHY address on the MII bus
    696  * @phy_id: where to store the ID retrieved.
    697  * @c45_ids: where to store the c45 ID information.
    698  *
    699  *   If the PHY devices-in-package appears to be valid, it and the
    700  *   corresponding identifiers are stored in @c45_ids, zero is stored
    701  *   in @phy_id.  Otherwise 0xffffffff is stored in @phy_id.  Returns
    702  *   zero on success.
    703  *
    704  */
    705 static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id,
    706 			   struct phy_c45_device_ids *c45_ids) {
    707 	int phy_reg;
    708 	int i, reg_addr;
    709 	const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
    710 	u32 *devs = &c45_ids->devices_in_package;
    711 
    712 	/* Find first non-zero Devices In package. Device zero is reserved
    713 	 * for 802.3 c45 complied PHYs, so don't probe it at first.
    714 	 */
    715 	for (i = 1; i < num_ids && *devs == 0; i++) {
    716 		phy_reg = get_phy_c45_devs_in_pkg(bus, addr, i, devs);
    717 		if (phy_reg < 0)
    718 			return -EIO;
    719 
    720 		if ((*devs & 0x1fffffff) == 0x1fffffff) {
    721 			/*  If mostly Fs, there is no device there,
    722 			 *  then let's continue to probe more, as some
    723 			 *  10G PHYs have zero Devices In package,
    724 			 *  e.g. Cortina CS4315/CS4340 PHY.
    725 			 */
    726 			phy_reg = get_phy_c45_devs_in_pkg(bus, addr, 0, devs);
    727 			if (phy_reg < 0)
    728 				return -EIO;
    729 			/* no device there, let's get out of here */
    730 			if ((*devs & 0x1fffffff) == 0x1fffffff) {
    731 				*phy_id = 0xffffffff;
    732 				return 0;
    733 			} else {
    734 				break;
    735 			}
    736 		}
    737 	}
    738 
    739 	/* Now probe Device Identifiers for each device present. */
    740 	for (i = 1; i < num_ids; i++) {
    741 		if (!(c45_ids->devices_in_package & (1 << i)))
    742 			continue;
    743 
    744 		reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID1;
    745 		phy_reg = mdiobus_read(bus, addr, reg_addr);
    746 		if (phy_reg < 0)
    747 			return -EIO;
    748 		c45_ids->device_ids[i] = phy_reg << 16;
    749 
    750 		reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID2;
    751 		phy_reg = mdiobus_read(bus, addr, reg_addr);
    752 		if (phy_reg < 0)
    753 			return -EIO;
    754 		c45_ids->device_ids[i] |= phy_reg;
    755 	}
    756 	*phy_id = 0;
    757 	return 0;
    758 }
    759 
    760 /**
    761  * get_phy_id - reads the specified addr for its ID.
    762  * @bus: the target MII bus
    763  * @addr: PHY address on the MII bus
    764  * @phy_id: where to store the ID retrieved.
    765  * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
    766  * @c45_ids: where to store the c45 ID information.
    767  *
    768  * Description: In the case of a 802.3-c22 PHY, reads the ID registers
    769  *   of the PHY at @addr on the @bus, stores it in @phy_id and returns
    770  *   zero on success.
    771  *
    772  *   In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and
    773  *   its return value is in turn returned.
    774  *
    775  */
    776 static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id,
    777 		      bool is_c45, struct phy_c45_device_ids *c45_ids)
    778 {
    779 	int phy_reg;
    780 
    781 	if (is_c45)
    782 		return get_phy_c45_ids(bus, addr, phy_id, c45_ids);
    783 
    784 	/* Grab the bits from PHYIR1, and put them in the upper half */
    785 	phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
    786 	if (phy_reg < 0) {
    787 		/* returning -ENODEV doesn't stop bus scanning */
    788 		return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO;
    789 	}
    790 
    791 	*phy_id = phy_reg << 16;
    792 
    793 	/* Grab the bits from PHYIR2, and put them in the lower half */
    794 	phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
    795 	if (phy_reg < 0)
    796 		return -EIO;
    797 
    798 	*phy_id |= phy_reg;
    799 
    800 	return 0;
    801 }
    802 
    803 /**
    804  * get_phy_device - reads the specified PHY device and returns its @phy_device
    805  *		    struct
    806  * @bus: the target MII bus
    807  * @addr: PHY address on the MII bus
    808  * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
    809  *
    810  * Description: Reads the ID registers of the PHY at @addr on the
    811  *   @bus, then allocates and returns the phy_device to represent it.
    812  */
    813 struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
    814 {
    815 	struct phy_c45_device_ids c45_ids = {0};
    816 	u32 phy_id = 0;
    817 	int r;
    818 
    819 	r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids);
    820 	if (r)
    821 		return ERR_PTR(r);
    822 
    823 	/* If the phy_id is mostly Fs, there is no device there */
    824 	if ((phy_id & 0x1fffffff) == 0x1fffffff)
    825 		return ERR_PTR(-ENODEV);
    826 
    827 	return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);
    828 }
    829 EXPORT_SYMBOL(get_phy_device);
    830 
    831 /**
    832  * phy_device_register - Register the phy device on the MDIO bus
    833  * @phydev: phy_device structure to be added to the MDIO bus
    834  */
    835 int phy_device_register(struct phy_device *phydev)
    836 {
    837 	int err;
    838 
    839 	err = mdiobus_register_device(&phydev->mdio);
    840 	if (err)
    841 		return err;
    842 
    843 	/* Deassert the reset signal */
    844 	phy_device_reset(phydev, 0);
    845 
    846 	/* Run all of the fixups for this PHY */
    847 	err = phy_scan_fixups(phydev);
    848 	if (err) {
    849 		phydev_err(phydev, "failed to initialize\n");
    850 		goto out;
    851 	}
    852 
    853 	err = device_add(&phydev->mdio.dev);
    854 	if (err) {
    855 		phydev_err(phydev, "failed to add\n");
    856 		goto out;
    857 	}
    858 
    859 	return 0;
    860 
    861  out:
    862 	/* Assert the reset signal */
    863 	phy_device_reset(phydev, 1);
    864 
    865 	mdiobus_unregister_device(&phydev->mdio);
    866 	return err;
    867 }
    868 EXPORT_SYMBOL(phy_device_register);
    869 
    870 /**
    871  * phy_device_remove - Remove a previously registered phy device from the MDIO bus
    872  * @phydev: phy_device structure to remove
    873  *
    874  * This doesn't free the phy_device itself, it merely reverses the effects
    875  * of phy_device_register(). Use phy_device_free() to free the device
    876  * after calling this function.
    877  */
    878 void phy_device_remove(struct phy_device *phydev)
    879 {
    880 	device_del(&phydev->mdio.dev);
    881 
    882 	/* Assert the reset signal */
    883 	phy_device_reset(phydev, 1);
    884 
    885 	mdiobus_unregister_device(&phydev->mdio);
    886 }
    887 EXPORT_SYMBOL(phy_device_remove);
    888 
    889 /**
    890  * phy_find_first - finds the first PHY device on the bus
    891  * @bus: the target MII bus
    892  */
    893 struct phy_device *phy_find_first(struct mii_bus *bus)
    894 {
    895 	struct phy_device *phydev;
    896 	int addr;
    897 
    898 	for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
    899 		phydev = mdiobus_get_phy(bus, addr);
    900 		if (phydev)
    901 			return phydev;
    902 	}
    903 	return NULL;
    904 }
    905 EXPORT_SYMBOL(phy_find_first);
    906 
    907 static void phy_link_change(struct phy_device *phydev, bool up, bool do_carrier)
    908 {
    909 	struct net_device *netdev = phydev->attached_dev;
    910 
    911 	if (do_carrier) {
    912 		if (up)
    913 			netif_carrier_on(netdev);
    914 		else
    915 			netif_carrier_off(netdev);
    916 	}
    917 	phydev->adjust_link(netdev);
    918 }
    919 
    920 /**
    921  * phy_prepare_link - prepares the PHY layer to monitor link status
    922  * @phydev: target phy_device struct
    923  * @handler: callback function for link status change notifications
    924  *
    925  * Description: Tells the PHY infrastructure to handle the
    926  *   gory details on monitoring link status (whether through
    927  *   polling or an interrupt), and to call back to the
    928  *   connected device driver when the link status changes.
    929  *   If you want to monitor your own link state, don't call
    930  *   this function.
    931  */
    932 static void phy_prepare_link(struct phy_device *phydev,
    933 			     void (*handler)(struct net_device *))
    934 {
    935 	phydev->adjust_link = handler;
    936 }
    937 
    938 /**
    939  * phy_connect_direct - connect an ethernet device to a specific phy_device
    940  * @dev: the network device to connect
    941  * @phydev: the pointer to the phy device
    942  * @handler: callback function for state change notifications
    943  * @interface: PHY device's interface
    944  */
    945 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
    946 		       void (*handler)(struct net_device *),
    947 		       phy_interface_t interface)
    948 {
    949 	int rc;
    950 
    951 	rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
    952 	if (rc)
    953 		return rc;
    954 
    955 	phy_prepare_link(phydev, handler);
    956 	if (phy_interrupt_is_valid(phydev))
    957 		phy_request_interrupt(phydev);
    958 
    959 	return 0;
    960 }
    961 EXPORT_SYMBOL(phy_connect_direct);
    962 
    963 /**
    964  * phy_connect - connect an ethernet device to a PHY device
    965  * @dev: the network device to connect
    966  * @bus_id: the id string of the PHY device to connect
    967  * @handler: callback function for state change notifications
    968  * @interface: PHY device's interface
    969  *
    970  * Description: Convenience function for connecting ethernet
    971  *   devices to PHY devices.  The default behavior is for
    972  *   the PHY infrastructure to handle everything, and only notify
    973  *   the connected driver when the link status changes.  If you
    974  *   don't want, or can't use the provided functionality, you may
    975  *   choose to call only the subset of functions which provide
    976  *   the desired functionality.
    977  */
    978 struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
    979 			       void (*handler)(struct net_device *),
    980 			       phy_interface_t interface)
    981 {
    982 	struct phy_device *phydev;
    983 	struct device *d;
    984 	int rc;
    985 
    986 	/* Search the list of PHY devices on the mdio bus for the
    987 	 * PHY with the requested name
    988 	 */
    989 	d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
    990 	if (!d) {
    991 		pr_err("PHY %s not found\n", bus_id);
    992 		return ERR_PTR(-ENODEV);
    993 	}
    994 	phydev = to_phy_device(d);
    995 
    996 	rc = phy_connect_direct(dev, phydev, handler, interface);
    997 	put_device(d);
    998 	if (rc)
    999 		return ERR_PTR(rc);
   1000 
   1001 	return phydev;
   1002 }
   1003 EXPORT_SYMBOL(phy_connect);
   1004 
   1005 /**
   1006  * phy_disconnect - disable interrupts, stop state machine, and detach a PHY
   1007  *		    device
   1008  * @phydev: target phy_device struct
   1009  */
   1010 void phy_disconnect(struct phy_device *phydev)
   1011 {
   1012 	if (phy_is_started(phydev))
   1013 		phy_stop(phydev);
   1014 
   1015 	if (phy_interrupt_is_valid(phydev))
   1016 		free_irq(phydev->irq, phydev);
   1017 
   1018 	phydev->adjust_link = NULL;
   1019 
   1020 	phy_detach(phydev);
   1021 }
   1022 EXPORT_SYMBOL(phy_disconnect);
   1023 
   1024 /**
   1025  * phy_poll_reset - Safely wait until a PHY reset has properly completed
   1026  * @phydev: The PHY device to poll
   1027  *
   1028  * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as
   1029  *   published in 2008, a PHY reset may take up to 0.5 seconds.  The MII BMCR
   1030  *   register must be polled until the BMCR_RESET bit clears.
   1031  *
   1032  *   Furthermore, any attempts to write to PHY registers may have no effect
   1033  *   or even generate MDIO bus errors until this is complete.
   1034  *
   1035  *   Some PHYs (such as the Marvell 88E1111) don't entirely conform to the
   1036  *   standard and do not fully reset after the BMCR_RESET bit is set, and may
   1037  *   even *REQUIRE* a soft-reset to properly restart autonegotiation.  In an
   1038  *   effort to support such broken PHYs, this function is separate from the
   1039  *   standard phy_init_hw() which will zero all the other bits in the BMCR
   1040  *   and reapply all driver-specific and board-specific fixups.
   1041  */
   1042 static int phy_poll_reset(struct phy_device *phydev)
   1043 {
   1044 	/* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
   1045 	unsigned int retries = 12;
   1046 	int ret;
   1047 
   1048 	do {
   1049 		msleep(50);
   1050 		ret = phy_read(phydev, MII_BMCR);
   1051 		if (ret < 0)
   1052 			return ret;
   1053 	} while (ret & BMCR_RESET && --retries);
   1054 	if (ret & BMCR_RESET)
   1055 		return -ETIMEDOUT;
   1056 
   1057 	/* Some chips (smsc911x) may still need up to another 1ms after the
   1058 	 * BMCR_RESET bit is cleared before they are usable.
   1059 	 */
   1060 	msleep(1);
   1061 	return 0;
   1062 }
   1063 
   1064 int phy_init_hw(struct phy_device *phydev)
   1065 {
   1066 	int ret = 0;
   1067 
   1068 	/* Deassert the reset signal */
   1069 	phy_device_reset(phydev, 0);
   1070 
   1071 	if (!phydev->drv)
   1072 		return 0;
   1073 
   1074 	if (phydev->drv->soft_reset)
   1075 		ret = phydev->drv->soft_reset(phydev);
   1076 
   1077 	if (ret < 0)
   1078 		return ret;
   1079 
   1080 	ret = phy_scan_fixups(phydev);
   1081 	if (ret < 0)
   1082 		return ret;
   1083 
   1084 	if (phydev->drv->config_init)
   1085 		ret = phydev->drv->config_init(phydev);
   1086 
   1087 	return ret;
   1088 }
   1089 EXPORT_SYMBOL(phy_init_hw);
   1090 
   1091 void phy_attached_info(struct phy_device *phydev)
   1092 {
   1093 	phy_attached_print(phydev, NULL);
   1094 }
   1095 EXPORT_SYMBOL(phy_attached_info);
   1096 
   1097 #define ATTACHED_FMT "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%s)"
   1098 void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
   1099 {
   1100 	const char *drv_name = phydev->drv ? phydev->drv->name : "unbound";
   1101 	char *irq_str;
   1102 	char irq_num[8];
   1103 
   1104 	switch(phydev->irq) {
   1105 	case PHY_POLL:
   1106 		irq_str = "POLL";
   1107 		break;
   1108 	case PHY_IGNORE_INTERRUPT:
   1109 		irq_str = "IGNORE";
   1110 		break;
   1111 	default:
   1112 		snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq);
   1113 		irq_str = irq_num;
   1114 		break;
   1115 	}
   1116 
   1117 
   1118 	if (!fmt) {
   1119 		phydev_info(phydev, ATTACHED_FMT "\n",
   1120 			 drv_name, phydev_name(phydev),
   1121 			 irq_str);
   1122 	} else {
   1123 		va_list ap;
   1124 
   1125 		phydev_info(phydev, ATTACHED_FMT,
   1126 			 drv_name, phydev_name(phydev),
   1127 			 irq_str);
   1128 
   1129 		va_start(ap, fmt);
   1130 		vprintk(fmt, ap);
   1131 		va_end(ap);
   1132 	}
   1133 }
   1134 EXPORT_SYMBOL(phy_attached_print);
   1135 
   1136 /**
   1137  * phy_attach_direct - attach a network device to a given PHY device pointer
   1138  * @dev: network device to attach
   1139  * @phydev: Pointer to phy_device to attach
   1140  * @flags: PHY device's dev_flags
   1141  * @interface: PHY device's interface
   1142  *
   1143  * Description: Called by drivers to attach to a particular PHY
   1144  *     device. The phy_device is found, and properly hooked up
   1145  *     to the phy_driver.  If no driver is attached, then a
   1146  *     generic driver is used.  The phy_device is given a ptr to
   1147  *     the attaching device, and given a callback for link status
   1148  *     change.  The phy_device is returned to the attaching driver.
   1149  *     This function takes a reference on the phy device.
   1150  */
   1151 int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
   1152 		      u32 flags, phy_interface_t interface)
   1153 {
   1154 	struct module *ndev_owner = dev->dev.parent->driver->owner;
   1155 	struct mii_bus *bus = phydev->mdio.bus;
   1156 	struct device *d = &phydev->mdio.dev;
   1157 	bool using_genphy = false;
   1158 	int err;
   1159 
   1160 	/* For Ethernet device drivers that register their own MDIO bus, we
   1161 	 * will have bus->owner match ndev_mod, so we do not want to increment
   1162 	 * our own module->refcnt here, otherwise we would not be able to
   1163 	 * unload later on.
   1164 	 */
   1165 	if (ndev_owner != bus->owner && !try_module_get(bus->owner)) {
   1166 		dev_err(&dev->dev, "failed to get the bus module\n");
   1167 		return -EIO;
   1168 	}
   1169 
   1170 	get_device(d);
   1171 
   1172 	/* Assume that if there is no driver, that it doesn't
   1173 	 * exist, and we should use the genphy driver.
   1174 	 */
   1175 	if (!d->driver) {
   1176 		if (phydev->is_c45)
   1177 			d->driver = &genphy_10g_driver.mdiodrv.driver;
   1178 		else
   1179 			d->driver = &genphy_driver.mdiodrv.driver;
   1180 
   1181 		using_genphy = true;
   1182 	}
   1183 
   1184 	if (!try_module_get(d->driver->owner)) {
   1185 		dev_err(&dev->dev, "failed to get the device driver module\n");
   1186 		err = -EIO;
   1187 		goto error_put_device;
   1188 	}
   1189 
   1190 	if (using_genphy) {
   1191 		err = d->driver->probe(d);
   1192 		if (err >= 0)
   1193 			err = device_bind_driver(d);
   1194 
   1195 		if (err)
   1196 			goto error_module_put;
   1197 	}
   1198 
   1199 	if (phydev->attached_dev) {
   1200 		dev_err(&dev->dev, "PHY already attached\n");
   1201 		err = -EBUSY;
   1202 		goto error;
   1203 	}
   1204 
   1205 	phydev->phy_link_change = phy_link_change;
   1206 	phydev->attached_dev = dev;
   1207 	dev->phydev = phydev;
   1208 
   1209 	/* Some Ethernet drivers try to connect to a PHY device before
   1210 	 * calling register_netdevice() -> netdev_register_kobject() and
   1211 	 * does the dev->dev.kobj initialization. Here we only check for
   1212 	 * success which indicates that the network device kobject is
   1213 	 * ready. Once we do that we still need to keep track of whether
   1214 	 * links were successfully set up or not for phy_detach() to
   1215 	 * remove them accordingly.
   1216 	 */
   1217 	phydev->sysfs_links = false;
   1218 
   1219 	err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,
   1220 				"attached_dev");
   1221 	if (!err) {
   1222 		err = sysfs_create_link_nowarn(&dev->dev.kobj,
   1223 					       &phydev->mdio.dev.kobj,
   1224 					       "phydev");
   1225 		if (err) {
   1226 			dev_err(&dev->dev, "could not add device link to %s err %d\n",
   1227 				kobject_name(&phydev->mdio.dev.kobj),
   1228 				err);
   1229 			/* non-fatal - some net drivers can use one netdevice
   1230 			 * with more then one phy
   1231 			 */
   1232 		}
   1233 
   1234 		phydev->sysfs_links = true;
   1235 	}
   1236 
   1237 	phydev->dev_flags = flags;
   1238 
   1239 	phydev->interface = interface;
   1240 
   1241 	phydev->state = PHY_READY;
   1242 
   1243 	/* Initial carrier state is off as the phy is about to be
   1244 	 * (re)initialized.
   1245 	 */
   1246 	netif_carrier_off(phydev->attached_dev);
   1247 
   1248 	/* Do initial configuration here, now that
   1249 	 * we have certain key parameters
   1250 	 * (dev_flags and interface)
   1251 	 */
   1252 	err = phy_init_hw(phydev);
   1253 	if (err)
   1254 		goto error;
   1255 
   1256 	phy_resume(phydev);
   1257 	phy_led_triggers_register(phydev);
   1258 
   1259 	return err;
   1260 
   1261 error:
   1262 	/* phy_detach() does all of the cleanup below */
   1263 	phy_detach(phydev);
   1264 	return err;
   1265 
   1266 error_module_put:
   1267 	module_put(d->driver->owner);
   1268 error_put_device:
   1269 	put_device(d);
   1270 	if (ndev_owner != bus->owner)
   1271 		module_put(bus->owner);
   1272 	return err;
   1273 }
   1274 EXPORT_SYMBOL(phy_attach_direct);
   1275 
   1276 /**
   1277  * phy_attach - attach a network device to a particular PHY device
   1278  * @dev: network device to attach
   1279  * @bus_id: Bus ID of PHY device to attach
   1280  * @interface: PHY device's interface
   1281  *
   1282  * Description: Same as phy_attach_direct() except that a PHY bus_id
   1283  *     string is passed instead of a pointer to a struct phy_device.
   1284  */
   1285 struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
   1286 			      phy_interface_t interface)
   1287 {
   1288 	struct bus_type *bus = &mdio_bus_type;
   1289 	struct phy_device *phydev;
   1290 	struct device *d;
   1291 	int rc;
   1292 
   1293 	/* Search the list of PHY devices on the mdio bus for the
   1294 	 * PHY with the requested name
   1295 	 */
   1296 	d = bus_find_device_by_name(bus, NULL, bus_id);
   1297 	if (!d) {
   1298 		pr_err("PHY %s not found\n", bus_id);
   1299 		return ERR_PTR(-ENODEV);
   1300 	}
   1301 	phydev = to_phy_device(d);
   1302 
   1303 	rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
   1304 	put_device(d);
   1305 	if (rc)
   1306 		return ERR_PTR(rc);
   1307 
   1308 	return phydev;
   1309 }
   1310 EXPORT_SYMBOL(phy_attach);
   1311 
   1312 static bool phy_driver_is_genphy_kind(struct phy_device *phydev,
   1313 				      struct device_driver *driver)
   1314 {
   1315 	struct device *d = &phydev->mdio.dev;
   1316 	bool ret = false;
   1317 
   1318 	if (!phydev->drv)
   1319 		return ret;
   1320 
   1321 	get_device(d);
   1322 	ret = d->driver == driver;
   1323 	put_device(d);
   1324 
   1325 	return ret;
   1326 }
   1327 
   1328 bool phy_driver_is_genphy(struct phy_device *phydev)
   1329 {
   1330 	return phy_driver_is_genphy_kind(phydev,
   1331 					 &genphy_driver.mdiodrv.driver);
   1332 }
   1333 EXPORT_SYMBOL_GPL(phy_driver_is_genphy);
   1334 
   1335 bool phy_driver_is_genphy_10g(struct phy_device *phydev)
   1336 {
   1337 	return phy_driver_is_genphy_kind(phydev,
   1338 					 &genphy_10g_driver.mdiodrv.driver);
   1339 }
   1340 EXPORT_SYMBOL_GPL(phy_driver_is_genphy_10g);
   1341 
   1342 /**
   1343  * phy_detach - detach a PHY device from its network device
   1344  * @phydev: target phy_device struct
   1345  *
   1346  * This detaches the phy device from its network device and the phy
   1347  * driver, and drops the reference count taken in phy_attach_direct().
   1348  */
   1349 void phy_detach(struct phy_device *phydev)
   1350 {
   1351 	struct net_device *dev = phydev->attached_dev;
   1352 	struct module *ndev_owner = dev->dev.parent->driver->owner;
   1353 	struct mii_bus *bus;
   1354 
   1355 	if (phydev->sysfs_links) {
   1356 		sysfs_remove_link(&dev->dev.kobj, "phydev");
   1357 		sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev");
   1358 	}
   1359 	phy_suspend(phydev);
   1360 	phydev->attached_dev->phydev = NULL;
   1361 	phydev->attached_dev = NULL;
   1362 	phydev->phylink = NULL;
   1363 
   1364 	phy_led_triggers_unregister(phydev);
   1365 
   1366 	module_put(phydev->mdio.dev.driver->owner);
   1367 
   1368 	/* If the device had no specific driver before (i.e. - it
   1369 	 * was using the generic driver), we unbind the device
   1370 	 * from the generic driver so that there's a chance a
   1371 	 * real driver could be loaded
   1372 	 */
   1373 	if (phy_driver_is_genphy(phydev) ||
   1374 	    phy_driver_is_genphy_10g(phydev))
   1375 		device_release_driver(&phydev->mdio.dev);
   1376 
   1377 	/*
   1378 	 * The phydev might go away on the put_device() below, so avoid
   1379 	 * a use-after-free bug by reading the underlying bus first.
   1380 	 */
   1381 	bus = phydev->mdio.bus;
   1382 
   1383 	put_device(&phydev->mdio.dev);
   1384 	if (ndev_owner != bus->owner)
   1385 		module_put(bus->owner);
   1386 
   1387 	/* Assert the reset signal */
   1388 	phy_device_reset(phydev, 1);
   1389 }
   1390 EXPORT_SYMBOL(phy_detach);
   1391 
   1392 int phy_suspend(struct phy_device *phydev)
   1393 {
   1394 	struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
   1395 	struct net_device *netdev = phydev->attached_dev;
   1396 	struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
   1397 	int ret = 0;
   1398 
   1399 	/* If the device has WOL enabled, we cannot suspend the PHY */
   1400 	phy_ethtool_get_wol(phydev, &wol);
   1401 	if (wol.wolopts || (netdev && netdev->wol_enabled))
   1402 		return -EBUSY;
   1403 
   1404 	if (phydev->drv && phydrv->suspend)
   1405 		ret = phydrv->suspend(phydev);
   1406 
   1407 	if (ret)
   1408 		return ret;
   1409 
   1410 	phydev->suspended = true;
   1411 
   1412 	return ret;
   1413 }
   1414 EXPORT_SYMBOL(phy_suspend);
   1415 
   1416 int __phy_resume(struct phy_device *phydev)
   1417 {
   1418 	struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
   1419 	int ret = 0;
   1420 
   1421 	WARN_ON(!mutex_is_locked(&phydev->lock));
   1422 
   1423 	if (phydev->drv && phydrv->resume)
   1424 		ret = phydrv->resume(phydev);
   1425 
   1426 	if (ret)
   1427 		return ret;
   1428 
   1429 	phydev->suspended = false;
   1430 
   1431 	return ret;
   1432 }
   1433 EXPORT_SYMBOL(__phy_resume);
   1434 
   1435 int phy_resume(struct phy_device *phydev)
   1436 {
   1437 	int ret;
   1438 
   1439 	mutex_lock(&phydev->lock);
   1440 	ret = __phy_resume(phydev);
   1441 	mutex_unlock(&phydev->lock);
   1442 
   1443 	return ret;
   1444 }
   1445 EXPORT_SYMBOL(phy_resume);
   1446 
   1447 int phy_loopback(struct phy_device *phydev, bool enable)
   1448 {
   1449 	struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
   1450 	int ret = 0;
   1451 
   1452 	mutex_lock(&phydev->lock);
   1453 
   1454 	if (enable && phydev->loopback_enabled) {
   1455 		ret = -EBUSY;
   1456 		goto out;
   1457 	}
   1458 
   1459 	if (!enable && !phydev->loopback_enabled) {
   1460 		ret = -EINVAL;
   1461 		goto out;
   1462 	}
   1463 
   1464 	if (phydev->drv && phydrv->set_loopback)
   1465 		ret = phydrv->set_loopback(phydev, enable);
   1466 	else
   1467 		ret = -EOPNOTSUPP;
   1468 
   1469 	if (ret)
   1470 		goto out;
   1471 
   1472 	phydev->loopback_enabled = enable;
   1473 
   1474 out:
   1475 	mutex_unlock(&phydev->lock);
   1476 	return ret;
   1477 }
   1478 EXPORT_SYMBOL(phy_loopback);
   1479 
   1480 /**
   1481  * phy_reset_after_clk_enable - perform a PHY reset if needed
   1482  * @phydev: target phy_device struct
   1483  *
   1484  * Description: Some PHYs are known to need a reset after their refclk was
   1485  *   enabled. This function evaluates the flags and perform the reset if it's
   1486  *   needed. Returns < 0 on error, 0 if the phy wasn't reset and 1 if the phy
   1487  *   was reset.
   1488  */
   1489 int phy_reset_after_clk_enable(struct phy_device *phydev)
   1490 {
   1491 	if (!phydev || !phydev->drv)
   1492 		return -ENODEV;
   1493 
   1494 	if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) {
   1495 		phy_device_reset(phydev, 1);
   1496 		phy_device_reset(phydev, 0);
   1497 		return 1;
   1498 	}
   1499 
   1500 	return 0;
   1501 }
   1502 EXPORT_SYMBOL(phy_reset_after_clk_enable);
   1503 
   1504 /* Generic PHY support and helper functions */
   1505 
   1506 /**
   1507  * genphy_config_advert - sanitize and advertise auto-negotiation parameters
   1508  * @phydev: target phy_device struct
   1509  *
   1510  * Description: Writes MII_ADVERTISE with the appropriate values,
   1511  *   after sanitizing the values to make sure we only advertise
   1512  *   what is supported.  Returns < 0 on error, 0 if the PHY's advertisement
   1513  *   hasn't changed, and > 0 if it has changed.
   1514  */
   1515 static int genphy_config_advert(struct phy_device *phydev)
   1516 {
   1517 	u32 advertise;
   1518 	int bmsr, adv;
   1519 	int err, changed = 0;
   1520 
   1521 	/* Only allow advertising what this PHY supports */
   1522 	linkmode_and(phydev->advertising, phydev->advertising,
   1523 		     phydev->supported);
   1524 	if (!ethtool_convert_link_mode_to_legacy_u32(&advertise,
   1525 						     phydev->advertising))
   1526 		phydev_warn(phydev, "PHY advertising (%*pb) more modes than genphy supports, some modes not advertised.\n",
   1527 			    __ETHTOOL_LINK_MODE_MASK_NBITS,
   1528 			    phydev->advertising);
   1529 
   1530 	/* Setup standard advertisement */
   1531 	err = phy_modify_changed(phydev, MII_ADVERTISE,
   1532 				 ADVERTISE_ALL | ADVERTISE_100BASE4 |
   1533 				 ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM,
   1534 				 ethtool_adv_to_mii_adv_t(advertise));
   1535 	if (err < 0)
   1536 		return err;
   1537 	if (err > 0)
   1538 		changed = 1;
   1539 
   1540 	bmsr = phy_read(phydev, MII_BMSR);
   1541 	if (bmsr < 0)
   1542 		return bmsr;
   1543 
   1544 	/* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
   1545 	 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
   1546 	 * logical 1.
   1547 	 */
   1548 	if (!(bmsr & BMSR_ESTATEN))
   1549 		return changed;
   1550 
   1551 	/* Configure gigabit if it's supported */
   1552 	adv = 0;
   1553 	if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
   1554 			      phydev->supported) ||
   1555 	    linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
   1556 			      phydev->supported))
   1557 		adv = ethtool_adv_to_mii_ctrl1000_t(advertise);
   1558 
   1559 	err = phy_modify_changed(phydev, MII_CTRL1000,
   1560 				 ADVERTISE_1000FULL | ADVERTISE_1000HALF,
   1561 				 adv);
   1562 	if (err < 0)
   1563 		return err;
   1564 	if (err > 0)
   1565 		changed = 1;
   1566 
   1567 	return changed;
   1568 }
   1569 
   1570 /**
   1571  * genphy_config_eee_advert - disable unwanted eee mode advertisement
   1572  * @phydev: target phy_device struct
   1573  *
   1574  * Description: Writes MDIO_AN_EEE_ADV after disabling unsupported energy
   1575  *   efficent ethernet modes. Returns 0 if the PHY's advertisement hasn't
   1576  *   changed, and 1 if it has changed.
   1577  */
   1578 int genphy_config_eee_advert(struct phy_device *phydev)
   1579 {
   1580 	int err;
   1581 
   1582 	/* Nothing to disable */
   1583 	if (!phydev->eee_broken_modes)
   1584 		return 0;
   1585 
   1586 	err = phy_modify_mmd_changed(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV,
   1587 				     phydev->eee_broken_modes, 0);
   1588 	/* If the call failed, we assume that EEE is not supported */
   1589 	return err < 0 ? 0 : err;
   1590 }
   1591 EXPORT_SYMBOL(genphy_config_eee_advert);
   1592 
   1593 /**
   1594  * genphy_setup_forced - configures/forces speed/duplex from @phydev
   1595  * @phydev: target phy_device struct
   1596  *
   1597  * Description: Configures MII_BMCR to force speed/duplex
   1598  *   to the values in phydev. Assumes that the values are valid.
   1599  *   Please see phy_sanitize_settings().
   1600  */
   1601 int genphy_setup_forced(struct phy_device *phydev)
   1602 {
   1603 	u16 ctl = 0;
   1604 
   1605 	phydev->pause = 0;
   1606 	phydev->asym_pause = 0;
   1607 
   1608 	if (SPEED_1000 == phydev->speed)
   1609 		ctl |= BMCR_SPEED1000;
   1610 	else if (SPEED_100 == phydev->speed)
   1611 		ctl |= BMCR_SPEED100;
   1612 
   1613 	if (DUPLEX_FULL == phydev->duplex)
   1614 		ctl |= BMCR_FULLDPLX;
   1615 
   1616 	return phy_modify(phydev, MII_BMCR,
   1617 			  ~(BMCR_LOOPBACK | BMCR_ISOLATE | BMCR_PDOWN), ctl);
   1618 }
   1619 EXPORT_SYMBOL(genphy_setup_forced);
   1620 
   1621 /**
   1622  * genphy_restart_aneg - Enable and Restart Autonegotiation
   1623  * @phydev: target phy_device struct
   1624  */
   1625 int genphy_restart_aneg(struct phy_device *phydev)
   1626 {
   1627 	/* Don't isolate the PHY if we're negotiating */
   1628 	return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
   1629 			  BMCR_ANENABLE | BMCR_ANRESTART);
   1630 }
   1631 EXPORT_SYMBOL(genphy_restart_aneg);
   1632 
   1633 /**
   1634  * genphy_config_aneg - restart auto-negotiation or write BMCR
   1635  * @phydev: target phy_device struct
   1636  *
   1637  * Description: If auto-negotiation is enabled, we configure the
   1638  *   advertising, and then restart auto-negotiation.  If it is not
   1639  *   enabled, then we write the BMCR.
   1640  */
   1641 int genphy_config_aneg(struct phy_device *phydev)
   1642 {
   1643 	int err, changed;
   1644 
   1645 	changed = genphy_config_eee_advert(phydev);
   1646 
   1647 	if (AUTONEG_ENABLE != phydev->autoneg)
   1648 		return genphy_setup_forced(phydev);
   1649 
   1650 	err = genphy_config_advert(phydev);
   1651 	if (err < 0) /* error */
   1652 		return err;
   1653 
   1654 	changed |= err;
   1655 
   1656 	if (changed == 0) {
   1657 		/* Advertisement hasn't changed, but maybe aneg was never on to
   1658 		 * begin with?  Or maybe phy was isolated?
   1659 		 */
   1660 		int ctl = phy_read(phydev, MII_BMCR);
   1661 
   1662 		if (ctl < 0)
   1663 			return ctl;
   1664 
   1665 		if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
   1666 			changed = 1; /* do restart aneg */
   1667 	}
   1668 
   1669 	/* Only restart aneg if we are advertising something different
   1670 	 * than we were before.
   1671 	 */
   1672 	if (changed > 0)
   1673 		return genphy_restart_aneg(phydev);
   1674 
   1675 	return 0;
   1676 }
   1677 EXPORT_SYMBOL(genphy_config_aneg);
   1678 
   1679 /**
   1680  * genphy_aneg_done - return auto-negotiation status
   1681  * @phydev: target phy_device struct
   1682  *
   1683  * Description: Reads the status register and returns 0 either if
   1684  *   auto-negotiation is incomplete, or if there was an error.
   1685  *   Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.
   1686  */
   1687 int genphy_aneg_done(struct phy_device *phydev)
   1688 {
   1689 	int retval = phy_read(phydev, MII_BMSR);
   1690 
   1691 	return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
   1692 }
   1693 EXPORT_SYMBOL(genphy_aneg_done);
   1694 
   1695 /**
   1696  * genphy_update_link - update link status in @phydev
   1697  * @phydev: target phy_device struct
   1698  *
   1699  * Description: Update the value in phydev->link to reflect the
   1700  *   current link value.  In order to do this, we need to read
   1701  *   the status register twice, keeping the second value.
   1702  */
   1703 int genphy_update_link(struct phy_device *phydev)
   1704 {
   1705 	int status;
   1706 
   1707 	/* The link state is latched low so that momentary link
   1708 	 * drops can be detected. Do not double-read the status
   1709 	 * in polling mode to detect such short link drops.
   1710 	 */
   1711 	if (!phy_polling_mode(phydev)) {
   1712 		status = phy_read(phydev, MII_BMSR);
   1713 		if (status < 0) {
   1714 			return status;
   1715 		} else if (status & BMSR_LSTATUS) {
   1716 			phydev->link = 1;
   1717 			return 0;
   1718 		}
   1719 	}
   1720 
   1721 	/* Read link and autonegotiation status */
   1722 	status = phy_read(phydev, MII_BMSR);
   1723 	if (status < 0)
   1724 		return status;
   1725 
   1726 	if ((status & BMSR_LSTATUS) == 0)
   1727 		phydev->link = 0;
   1728 	else
   1729 		phydev->link = 1;
   1730 
   1731 	return 0;
   1732 }
   1733 EXPORT_SYMBOL(genphy_update_link);
   1734 
   1735 /**
   1736  * genphy_read_status - check the link status and update current link state
   1737  * @phydev: target phy_device struct
   1738  *
   1739  * Description: Check the link, then figure out the current state
   1740  *   by comparing what we advertise with what the link partner
   1741  *   advertises.  Start by checking the gigabit possibilities,
   1742  *   then move on to 10/100.
   1743  */
   1744 int genphy_read_status(struct phy_device *phydev)
   1745 {
   1746 	int adv;
   1747 	int err;
   1748 	int lpa;
   1749 	int lpagb = 0;
   1750 
   1751 	/* Update the link, but return if there was an error */
   1752 	err = genphy_update_link(phydev);
   1753 	if (err)
   1754 		return err;
   1755 
   1756 	linkmode_zero(phydev->lp_advertising);
   1757 
   1758 	if (AUTONEG_ENABLE == phydev->autoneg) {
   1759 		if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
   1760 				      phydev->supported) ||
   1761 		    linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
   1762 				      phydev->supported)) {
   1763 			lpagb = phy_read(phydev, MII_STAT1000);
   1764 			if (lpagb < 0)
   1765 				return lpagb;
   1766 
   1767 			adv = phy_read(phydev, MII_CTRL1000);
   1768 			if (adv < 0)
   1769 				return adv;
   1770 
   1771 			if (lpagb & LPA_1000MSFAIL) {
   1772 				if (adv & CTL1000_ENABLE_MASTER)
   1773 					phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n");
   1774 				else
   1775 					phydev_err(phydev, "Master/Slave resolution failed\n");
   1776 				return -ENOLINK;
   1777 			}
   1778 
   1779 			mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
   1780 							lpagb);
   1781 		}
   1782 
   1783 		lpa = phy_read(phydev, MII_LPA);
   1784 		if (lpa < 0)
   1785 			return lpa;
   1786 
   1787 		mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
   1788 
   1789 		phydev->speed = SPEED_UNKNOWN;
   1790 		phydev->duplex = DUPLEX_UNKNOWN;
   1791 		phydev->pause = 0;
   1792 		phydev->asym_pause = 0;
   1793 
   1794 		phy_resolve_aneg_linkmode(phydev);
   1795 	} else {
   1796 		int bmcr = phy_read(phydev, MII_BMCR);
   1797 
   1798 		if (bmcr < 0)
   1799 			return bmcr;
   1800 
   1801 		if (bmcr & BMCR_FULLDPLX)
   1802 			phydev->duplex = DUPLEX_FULL;
   1803 		else
   1804 			phydev->duplex = DUPLEX_HALF;
   1805 
   1806 		if (bmcr & BMCR_SPEED1000)
   1807 			phydev->speed = SPEED_1000;
   1808 		else if (bmcr & BMCR_SPEED100)
   1809 			phydev->speed = SPEED_100;
   1810 		else
   1811 			phydev->speed = SPEED_10;
   1812 
   1813 		phydev->pause = 0;
   1814 		phydev->asym_pause = 0;
   1815 	}
   1816 
   1817 	return 0;
   1818 }
   1819 EXPORT_SYMBOL(genphy_read_status);
   1820 
   1821 /**
   1822  * genphy_soft_reset - software reset the PHY via BMCR_RESET bit
   1823  * @phydev: target phy_device struct
   1824  *
   1825  * Description: Perform a software PHY reset using the standard
   1826  * BMCR_RESET bit and poll for the reset bit to be cleared.
   1827  *
   1828  * Returns: 0 on success, < 0 on failure
   1829  */
   1830 int genphy_soft_reset(struct phy_device *phydev)
   1831 {
   1832 	int ret;
   1833 
   1834 	ret = phy_set_bits(phydev, MII_BMCR, BMCR_RESET);
   1835 	if (ret < 0)
   1836 		return ret;
   1837 
   1838 	return phy_poll_reset(phydev);
   1839 }
   1840 EXPORT_SYMBOL(genphy_soft_reset);
   1841 
   1842 int genphy_config_init(struct phy_device *phydev)
   1843 {
   1844 	int val;
   1845 	__ETHTOOL_DECLARE_LINK_MODE_MASK(features) = { 0, };
   1846 
   1847 	linkmode_set_bit_array(phy_basic_ports_array,
   1848 			       ARRAY_SIZE(phy_basic_ports_array),
   1849 			       features);
   1850 	linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT, features);
   1851 	linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, features);
   1852 
   1853 	/* Do we support autonegotiation? */
   1854 	val = phy_read(phydev, MII_BMSR);
   1855 	if (val < 0)
   1856 		return val;
   1857 
   1858 	if (val & BMSR_ANEGCAPABLE)
   1859 		linkmode_set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, features);
   1860 
   1861 	if (val & BMSR_100FULL)
   1862 		linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, features);
   1863 	if (val & BMSR_100HALF)
   1864 		linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, features);
   1865 	if (val & BMSR_10FULL)
   1866 		linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, features);
   1867 	if (val & BMSR_10HALF)
   1868 		linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, features);
   1869 
   1870 	if (val & BMSR_ESTATEN) {
   1871 		val = phy_read(phydev, MII_ESTATUS);
   1872 		if (val < 0)
   1873 			return val;
   1874 
   1875 		if (val & ESTATUS_1000_TFULL)
   1876 			linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
   1877 					 features);
   1878 		if (val & ESTATUS_1000_THALF)
   1879 			linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
   1880 					 features);
   1881 	}
   1882 
   1883 	linkmode_and(phydev->supported, phydev->supported, features);
   1884 	linkmode_and(phydev->advertising, phydev->advertising, features);
   1885 
   1886 	return 0;
   1887 }
   1888 EXPORT_SYMBOL(genphy_config_init);
   1889 
   1890 /* This is used for the phy device which doesn't support the MMD extended
   1891  * register access, but it does have side effect when we are trying to access
   1892  * the MMD register via indirect method.
   1893  */
   1894 int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad, u16 regnum)
   1895 {
   1896 	return -EOPNOTSUPP;
   1897 }
   1898 EXPORT_SYMBOL(genphy_read_mmd_unsupported);
   1899 
   1900 int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum,
   1901 				 u16 regnum, u16 val)
   1902 {
   1903 	return -EOPNOTSUPP;
   1904 }
   1905 EXPORT_SYMBOL(genphy_write_mmd_unsupported);
   1906 
   1907 int genphy_suspend(struct phy_device *phydev)
   1908 {
   1909 	return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);
   1910 }
   1911 EXPORT_SYMBOL(genphy_suspend);
   1912 
   1913 int genphy_resume(struct phy_device *phydev)
   1914 {
   1915 	return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN);
   1916 }
   1917 EXPORT_SYMBOL(genphy_resume);
   1918 
   1919 int genphy_loopback(struct phy_device *phydev, bool enable)
   1920 {
   1921 	return phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK,
   1922 			  enable ? BMCR_LOOPBACK : 0);
   1923 }
   1924 EXPORT_SYMBOL(genphy_loopback);
   1925 
   1926 /**
   1927  * phy_remove_link_mode - Remove a supported link mode
   1928  * @phydev: phy_device structure to remove link mode from
   1929  * @link_mode: Link mode to be removed
   1930  *
   1931  * Description: Some MACs don't support all link modes which the PHY
   1932  * does.  e.g. a 1G MAC often does not support 1000Half. Add a helper
   1933  * to remove a link mode.
   1934  */
   1935 void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode)
   1936 {
   1937 	linkmode_clear_bit(link_mode, phydev->supported);
   1938 	linkmode_copy(phydev->advertising, phydev->supported);
   1939 }
   1940 EXPORT_SYMBOL(phy_remove_link_mode);
   1941 
   1942 /**
   1943  * phy_support_sym_pause - Enable support of symmetrical pause
   1944  * @phydev: target phy_device struct
   1945  *
   1946  * Description: Called by the MAC to indicate is supports symmetrical
   1947  * Pause, but not asym pause.
   1948  */
   1949 void phy_support_sym_pause(struct phy_device *phydev)
   1950 {
   1951 	linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported);
   1952 	linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported);
   1953 	linkmode_copy(phydev->advertising, phydev->supported);
   1954 }
   1955 EXPORT_SYMBOL(phy_support_sym_pause);
   1956 
   1957 /**
   1958  * phy_support_asym_pause - Enable support of asym pause
   1959  * @phydev: target phy_device struct
   1960  *
   1961  * Description: Called by the MAC to indicate is supports Asym Pause.
   1962  */
   1963 void phy_support_asym_pause(struct phy_device *phydev)
   1964 {
   1965 	linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported);
   1966 	linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported);
   1967 	linkmode_copy(phydev->advertising, phydev->supported);
   1968 }
   1969 EXPORT_SYMBOL(phy_support_asym_pause);
   1970 
   1971 /**
   1972  * phy_set_sym_pause - Configure symmetric Pause
   1973  * @phydev: target phy_device struct
   1974  * @rx: Receiver Pause is supported
   1975  * @tx: Transmit Pause is supported
   1976  * @autoneg: Auto neg should be used
   1977  *
   1978  * Description: Configure advertised Pause support depending on if
   1979  * receiver pause and pause auto neg is supported. Generally called
   1980  * from the set_pauseparam .ndo.
   1981  */
   1982 void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx,
   1983 		       bool autoneg)
   1984 {
   1985 	linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported);
   1986 
   1987 	if (rx && tx && autoneg)
   1988 		linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
   1989 				 phydev->supported);
   1990 
   1991 	linkmode_copy(phydev->advertising, phydev->supported);
   1992 }
   1993 EXPORT_SYMBOL(phy_set_sym_pause);
   1994 
   1995 /**
   1996  * phy_set_asym_pause - Configure Pause and Asym Pause
   1997  * @phydev: target phy_device struct
   1998  * @rx: Receiver Pause is supported
   1999  * @tx: Transmit Pause is supported
   2000  *
   2001  * Description: Configure advertised Pause support depending on if
   2002  * transmit and receiver pause is supported. If there has been a
   2003  * change in adverting, trigger a new autoneg. Generally called from
   2004  * the set_pauseparam .ndo.
   2005  */
   2006 void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx)
   2007 {
   2008 	__ETHTOOL_DECLARE_LINK_MODE_MASK(oldadv);
   2009 
   2010 	linkmode_copy(oldadv, phydev->advertising);
   2011 
   2012 	linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
   2013 			   phydev->advertising);
   2014 	linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
   2015 			   phydev->advertising);
   2016 
   2017 	if (rx) {
   2018 		linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
   2019 				 phydev->advertising);
   2020 		linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
   2021 				 phydev->advertising);
   2022 	}
   2023 
   2024 	if (tx)
   2025 		linkmode_change_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
   2026 				    phydev->advertising);
   2027 
   2028 	if (!linkmode_equal(oldadv, phydev->advertising) &&
   2029 	    phydev->autoneg)
   2030 		phy_start_aneg(phydev);
   2031 }
   2032 EXPORT_SYMBOL(phy_set_asym_pause);
   2033 
   2034 /**
   2035  * phy_validate_pause - Test if the PHY/MAC support the pause configuration
   2036  * @phydev: phy_device struct
   2037  * @pp: requested pause configuration
   2038  *
   2039  * Description: Test if the PHY/MAC combination supports the Pause
   2040  * configuration the user is requesting. Returns True if it is
   2041  * supported, false otherwise.
   2042  */
   2043 bool phy_validate_pause(struct phy_device *phydev,
   2044 			struct ethtool_pauseparam *pp)
   2045 {
   2046 	if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
   2047 			       phydev->supported) ||
   2048 	    (!linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
   2049 				phydev->supported) &&
   2050 	     pp->rx_pause != pp->tx_pause))
   2051 		return false;
   2052 	return true;
   2053 }
   2054 EXPORT_SYMBOL(phy_validate_pause);
   2055 
   2056 static bool phy_drv_supports_irq(struct phy_driver *phydrv)
   2057 {
   2058 	return phydrv->config_intr && phydrv->ack_interrupt;
   2059 }
   2060 
   2061 /**
   2062  * phy_probe - probe and init a PHY device
   2063  * @dev: device to probe and init
   2064  *
   2065  * Description: Take care of setting up the phy_device structure,
   2066  *   set the state to READY (the driver's init function should
   2067  *   set it to STARTING if needed).
   2068  */
   2069 static int phy_probe(struct device *dev)
   2070 {
   2071 	struct phy_device *phydev = to_phy_device(dev);
   2072 	struct device_driver *drv = phydev->mdio.dev.driver;
   2073 	struct phy_driver *phydrv = to_phy_driver(drv);
   2074 	int err = 0;
   2075 
   2076 	phydev->drv = phydrv;
   2077 
   2078 	/* Disable the interrupt if the PHY doesn't support it
   2079 	 * but the interrupt is still a valid one
   2080 	 */
   2081 	 if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev))
   2082 		phydev->irq = PHY_POLL;
   2083 
   2084 	if (phydrv->flags & PHY_IS_INTERNAL)
   2085 		phydev->is_internal = true;
   2086 
   2087 	mutex_lock(&phydev->lock);
   2088 
   2089 	if (phydev->drv->probe) {
   2090 		/* Deassert the reset signal */
   2091 		phy_device_reset(phydev, 0);
   2092 
   2093 		err = phydev->drv->probe(phydev);
   2094 		if (err) {
   2095 			/* Assert the reset signal */
   2096 			phy_device_reset(phydev, 1);
   2097 			goto out;
   2098 		}
   2099 	}
   2100 
   2101 	/* Start out supporting everything. Eventually,
   2102 	 * a controller will attach, and may modify one
   2103 	 * or both of these values
   2104 	 */
   2105 	if (phydrv->features) {
   2106 		linkmode_copy(phydev->supported, phydrv->features);
   2107 	} else {
   2108 		err = phydrv->get_features(phydev);
   2109 		if (err)
   2110 			goto out;
   2111 	}
   2112 
   2113 	of_set_phy_supported(phydev);
   2114 	linkmode_copy(phydev->advertising, phydev->supported);
   2115 
   2116 	/* Get the EEE modes we want to prohibit. We will ask
   2117 	 * the PHY stop advertising these mode later on
   2118 	 */
   2119 	of_set_phy_eee_broken(phydev);
   2120 
   2121 	/* The Pause Frame bits indicate that the PHY can support passing
   2122 	 * pause frames. During autonegotiation, the PHYs will determine if
   2123 	 * they should allow pause frames to pass.  The MAC driver should then
   2124 	 * use that result to determine whether to enable flow control via
   2125 	 * pause frames.
   2126 	 *
   2127 	 * Normally, PHY drivers should not set the Pause bits, and instead
   2128 	 * allow phylib to do that.  However, there may be some situations
   2129 	 * (e.g. hardware erratum) where the driver wants to set only one
   2130 	 * of these bits.
   2131 	 */
   2132 	if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported) &&
   2133 	    !test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported)) {
   2134 		linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
   2135 				 phydev->supported);
   2136 		linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
   2137 				 phydev->supported);
   2138 	}
   2139 
   2140 	/* Set the state to READY by default */
   2141 	phydev->state = PHY_READY;
   2142 
   2143 out:
   2144 	mutex_unlock(&phydev->lock);
   2145 
   2146 	return err;
   2147 }
   2148 
   2149 static int phy_remove(struct device *dev)
   2150 {
   2151 	struct phy_device *phydev = to_phy_device(dev);
   2152 
   2153 	cancel_delayed_work_sync(&phydev->state_queue);
   2154 
   2155 	mutex_lock(&phydev->lock);
   2156 	phydev->state = PHY_DOWN;
   2157 	mutex_unlock(&phydev->lock);
   2158 
   2159 	if (phydev->drv && phydev->drv->remove) {
   2160 		phydev->drv->remove(phydev);
   2161 
   2162 		/* Assert the reset signal */
   2163 		phy_device_reset(phydev, 1);
   2164 	}
   2165 	phydev->drv = NULL;
   2166 
   2167 	return 0;
   2168 }
   2169 
   2170 /**
   2171  * phy_driver_register - register a phy_driver with the PHY layer
   2172  * @new_driver: new phy_driver to register
   2173  * @owner: module owning this PHY
   2174  */
   2175 int phy_driver_register(struct phy_driver *new_driver, struct module *owner)
   2176 {
   2177 	int retval;
   2178 
   2179 	/* Either the features are hard coded, or dynamically
   2180 	 * determine. It cannot be both or neither
   2181 	 */
   2182 	if (WARN_ON((!new_driver->features && !new_driver->get_features) ||
   2183 		    (new_driver->features && new_driver->get_features))) {
   2184 		pr_err("%s: Driver features are missing\n", new_driver->name);
   2185 		return -EINVAL;
   2186 	}
   2187 
   2188 	new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY;
   2189 	new_driver->mdiodrv.driver.name = new_driver->name;
   2190 	new_driver->mdiodrv.driver.bus = &mdio_bus_type;
   2191 	new_driver->mdiodrv.driver.probe = phy_probe;
   2192 	new_driver->mdiodrv.driver.remove = phy_remove;
   2193 	new_driver->mdiodrv.driver.owner = owner;
   2194 
   2195 	retval = driver_register(&new_driver->mdiodrv.driver);
   2196 	if (retval) {
   2197 		pr_err("%s: Error %d in registering driver\n",
   2198 		       new_driver->name, retval);
   2199 
   2200 		return retval;
   2201 	}
   2202 
   2203 	pr_debug("%s: Registered new driver\n", new_driver->name);
   2204 
   2205 	return 0;
   2206 }
   2207 EXPORT_SYMBOL(phy_driver_register);
   2208 
   2209 int phy_drivers_register(struct phy_driver *new_driver, int n,
   2210 			 struct module *owner)
   2211 {
   2212 	int i, ret = 0;
   2213 
   2214 	for (i = 0; i < n; i++) {
   2215 		ret = phy_driver_register(new_driver + i, owner);
   2216 		if (ret) {
   2217 			while (i-- > 0)
   2218 				phy_driver_unregister(new_driver + i);
   2219 			break;
   2220 		}
   2221 	}
   2222 	return ret;
   2223 }
   2224 EXPORT_SYMBOL(phy_drivers_register);
   2225 
   2226 void phy_driver_unregister(struct phy_driver *drv)
   2227 {
   2228 	driver_unregister(&drv->mdiodrv.driver);
   2229 }
   2230 EXPORT_SYMBOL(phy_driver_unregister);
   2231 
   2232 void phy_drivers_unregister(struct phy_driver *drv, int n)
   2233 {
   2234 	int i;
   2235 
   2236 	for (i = 0; i < n; i++)
   2237 		phy_driver_unregister(drv + i);
   2238 }
   2239 EXPORT_SYMBOL(phy_drivers_unregister);
   2240 
   2241 static struct phy_driver genphy_driver = {
   2242 	.phy_id		= 0xffffffff,
   2243 	.phy_id_mask	= 0xffffffff,
   2244 	.name		= "Generic PHY",
   2245 	.soft_reset	= genphy_no_soft_reset,
   2246 	.config_init	= genphy_config_init,
   2247 	.features	= PHY_GBIT_ALL_PORTS_FEATURES,
   2248 	.aneg_done	= genphy_aneg_done,
   2249 	.suspend	= genphy_suspend,
   2250 	.resume		= genphy_resume,
   2251 	.set_loopback   = genphy_loopback,
   2252 };
   2253 
   2254 static int __init phy_init(void)
   2255 {
   2256 	int rc;
   2257 
   2258 	rc = mdio_bus_init();
   2259 	if (rc)
   2260 		return rc;
   2261 
   2262 	features_init();
   2263 
   2264 	rc = phy_driver_register(&genphy_10g_driver, THIS_MODULE);
   2265 	if (rc)
   2266 		goto err_10g;
   2267 
   2268 	rc = phy_driver_register(&genphy_driver, THIS_MODULE);
   2269 	if (rc) {
   2270 		phy_driver_unregister(&genphy_10g_driver);
   2271 err_10g:
   2272 		mdio_bus_exit();
   2273 	}
   2274 
   2275 	return rc;
   2276 }
   2277 
   2278 static void __exit phy_exit(void)
   2279 {
   2280 	phy_driver_unregister(&genphy_10g_driver);
   2281 	phy_driver_unregister(&genphy_driver);
   2282 	mdio_bus_exit();
   2283 }
   2284 
   2285 subsys_initcall(phy_init);
   2286 module_exit(phy_exit);