LCOV - code coverage report
Current view: top level - drivers/net/phy - phy_device.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 48 957 5.0 %
Date: 2022-03-28 16:04:14 Functions: 4 91 4.4 %
Branches: 10 529 1.9 %

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

Generated by: LCOV version 1.14