drivers/net/phy/smsc.c

   1 /*
   2  * drivers/net/phy/smsc.c
   3  *
   4  * Driver for SMSC PHYs
   5  *
   6  * Author: Herbert Valerio Riedel
   7  *
   8  * Copyright (c) 2006 Herbert Valerio Riedel <hvr@gnu.org>
   9  *
  10  * This program is free software; you can redistribute  it and/or modify it
  11  * under  the terms of  the GNU General  Public License as published by the
  12  * Free Software Foundation;  either version 2 of the  License, or (at your
  13  * option) any later version.
  14  *
  15  * Support added for SMSC LAN8187 and LAN8700 by steve.glendinning@shawell.net
  16  *
  17  */
  18
  19 #include <linux/kernel.h>
  20 #include <linux/module.h>
  21 #include <linux/mii.h>
  22 #include <linux/ethtool.h>
  23 #include <linux/phy.h>
  24 #include <linux/netdevice.h>
  25 #include <linux/smscphy.h>
  26
  27 struct smsc_phy_priv {
  28         bool energy_enable;
  29 };
  30
  31 static int smsc_phy_config_intr(struct phy_device *phydev)
  32 {
  33         int rc = phy_write (phydev, MII_LAN83C185_IM,
  34                         ((PHY_INTERRUPT_ENABLED == phydev->interrupts)
  35                         ? MII_LAN83C185_ISF_INT_PHYLIB_EVENTS
  36                         : 0));
  37
  38         return rc < 0 ? rc : 0;
  39 }
  40
  41 static int smsc_phy_ack_interrupt(struct phy_device *phydev)
  42 {
  43         int rc = phy_read (phydev, MII_LAN83C185_ISF);
  44
  45         return rc < 0 ? rc : 0;
  46 }
  47
  48 static int smsc_phy_config_init(struct phy_device *phydev)
  49 {
  50         struct smsc_phy_priv *priv = phydev->priv;
  51
  52         int rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);
  53
  54         if (rc < 0)
  55                 return rc;
  56
  57         if (priv->energy_enable) {
  58                 /* Enable energy detect mode for this SMSC Transceivers */
  59                 rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS,
  60                                rc | MII_LAN83C185_EDPWRDOWN);
  61                 if (rc < 0)
  62                         return rc;
  63         }
  64
  65         return smsc_phy_ack_interrupt(phydev);
  66 }
  67
  68 static int smsc_phy_reset(struct phy_device *phydev)
  69 {
  70         int rc = phy_read(phydev, MII_LAN83C185_SPECIAL_MODES);
  71         if (rc < 0)
  72                 return rc;
  73
  74         /* If the SMSC PHY is in power down mode, then set it
  75          * in all capable mode before using it.
  76          */
  77         if ((rc & MII_LAN83C185_MODE_MASK) == MII_LAN83C185_MODE_POWERDOWN) {
  78                 int timeout = 50000;
  79
  80                 /* set "all capable" mode and reset the phy */
  81                 rc |= MII_LAN83C185_MODE_ALL;
  82                 phy_write(phydev, MII_LAN83C185_SPECIAL_MODES, rc);
  83                 phy_write(phydev, MII_BMCR, BMCR_RESET);
  84
  85                 /* wait end of reset (max 500 ms) */
  86                 do {
  87                         udelay(10);
  88                         if (timeout-- == 0)
  89                                 return -1;
  90                         rc = phy_read(phydev, MII_BMCR);
  91                 } while (rc & BMCR_RESET);
  92         }
  93         return 0;
  94 }
  95
  96 static int lan911x_config_init(struct phy_device *phydev)
  97 {
  98         return smsc_phy_ack_interrupt(phydev);
  99 }
 100
 101 /*
 102  * The LAN87xx suffers from rare absence of the ENERGYON-bit when Ethernet cable
 103  * plugs in while LAN87xx is in Energy Detect Power-Down mode. This leads to
 104  * unstable detection of plugging in Ethernet cable.
 105  * This workaround disables Energy Detect Power-Down mode and waiting for
 106  * response on link pulses to detect presence of plugged Ethernet cable.
 107  * The Energy Detect Power-Down mode is enabled again in the end of procedure to
 108  * save approximately 220 mW of power if cable is unplugged.
 109  */
 110 static int lan87xx_read_status(struct phy_device *phydev)
 111 {
 112         struct smsc_phy_priv *priv = phydev->priv;
 113
 114         int err = genphy_read_status(phydev);
 115
 116         if (!phydev->link && priv->energy_enable) {
 117                 int i;
 118
 119                 /* Disable EDPD to wake up PHY */
 120                 int rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);
 121                 if (rc < 0)
 122                         return rc;
 123
 124                 rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS,
 125                                rc & ~MII_LAN83C185_EDPWRDOWN);
 126                 if (rc < 0)
 127                         return rc;
 128
 129                 /* Wait max 640 ms to detect energy */
 130                 for (i = 0; i < 64; i++) {
 131                         /* Sleep to allow link test pulses to be sent */
 132                         msleep(10);
 133                         rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);
 134                         if (rc < 0)
 135                                 return rc;
 136                         if (rc & MII_LAN83C185_ENERGYON)
 137                                 break;
 138                 }
 139
 140                 /* Re-enable EDPD */
 141                 rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);
 142                 if (rc < 0)
 143                         return rc;
 144
 145                 rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS,
 146                                rc | MII_LAN83C185_EDPWRDOWN);
 147                 if (rc < 0)
 148                         return rc;
 149         }
 150
 151         return err;
 152 }
 153
 154 static int smsc_phy_probe(struct phy_device *phydev)
 155 {
 156         struct device *dev = &phydev->mdio.dev;
 157         struct device_node *of_node = dev->of_node;
 158         struct smsc_phy_priv *priv;
 159
 160         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 161         if (!priv)
 162                 return -ENOMEM;
 163
 164         priv->energy_enable = true;
 165
 166         if (of_property_read_bool(of_node, "smsc,disable-energy-detect"))
 167                 priv->energy_enable = false;
 168
 169         phydev->priv = priv;
 170
 171         return 0;
 172 }
 173
 174 static struct phy_driver smsc_phy_driver[] = {
 175 {
 176         .phy_id         = 0x0007c0a0, /* OUI=0x00800f, Model#=0x0a */
 177         .phy_id_mask    = 0xfffffff0,
 178         .name           = "SMSC LAN83C185",
 179
 180         .features       = (PHY_BASIC_FEATURES | SUPPORTED_Pause
 181                                 | SUPPORTED_Asym_Pause),
 182         .flags          = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,
 183
 184         .probe          = smsc_phy_probe,
 185
 186         /* basic functions */
 187         .config_aneg    = genphy_config_aneg,
 188         .read_status    = genphy_read_status,
 189         .config_init    = smsc_phy_config_init,
 190         .soft_reset     = smsc_phy_reset,
 191
 192         /* IRQ related */
 193         .ack_interrupt  = smsc_phy_ack_interrupt,
 194         .config_intr    = smsc_phy_config_intr,
 195
 196         .suspend        = genphy_suspend,
 197         .resume         = genphy_resume,
 198 }, {
 199         .phy_id         = 0x0007c0b0, /* OUI=0x00800f, Model#=0x0b */
 200         .phy_id_mask    = 0xfffffff0,
 201         .name           = "SMSC LAN8187",
 202
 203         .features       = (PHY_BASIC_FEATURES | SUPPORTED_Pause
 204                                 | SUPPORTED_Asym_Pause),
 205         .flags          = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,
 206
 207         .probe          = smsc_phy_probe,
 208
 209         /* basic functions */
 210         .config_aneg    = genphy_config_aneg,
 211         .read_status    = genphy_read_status,
 212         .config_init    = smsc_phy_config_init,
 213         .soft_reset     = smsc_phy_reset,
 214
 215         /* IRQ related */
 216         .ack_interrupt  = smsc_phy_ack_interrupt,
 217         .config_intr    = smsc_phy_config_intr,
 218
 219         .suspend        = genphy_suspend,
 220         .resume         = genphy_resume,
 221 }, {
 222         .phy_id         = 0x0007c0c0, /* OUI=0x00800f, Model#=0x0c */
 223         .phy_id_mask    = 0xfffffff0,
 224         .name           = "SMSC LAN8700",
 225
 226         .features       = (PHY_BASIC_FEATURES | SUPPORTED_Pause
 227                                 | SUPPORTED_Asym_Pause),
 228         .flags          = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,
 229
 230         .probe          = smsc_phy_probe,
 231
 232         /* basic functions */
 233         .config_aneg    = genphy_config_aneg,
 234         .read_status    = lan87xx_read_status,
 235         .config_init    = smsc_phy_config_init,
 236         .soft_reset     = smsc_phy_reset,
 237
 238         /* IRQ related */
 239         .ack_interrupt  = smsc_phy_ack_interrupt,
 240         .config_intr    = smsc_phy_config_intr,
 241
 242         .suspend        = genphy_suspend,
 243         .resume         = genphy_resume,
 244 }, {
 245         .phy_id         = 0x0007c0d0, /* OUI=0x00800f, Model#=0x0d */
 246         .phy_id_mask    = 0xfffffff0,
 247         .name           = "SMSC LAN911x Internal PHY",
 248
 249         .features       = (PHY_BASIC_FEATURES | SUPPORTED_Pause
 250                                 | SUPPORTED_Asym_Pause),
 251         .flags          = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,
 252
 253         .probe          = smsc_phy_probe,
 254
 255         /* basic functions */
 256         .config_aneg    = genphy_config_aneg,
 257         .read_status    = genphy_read_status,
 258         .config_init    = lan911x_config_init,
 259
 260         /* IRQ related */
 261         .ack_interrupt  = smsc_phy_ack_interrupt,
 262         .config_intr    = smsc_phy_config_intr,
 263
 264         .suspend        = genphy_suspend,
 265         .resume         = genphy_resume,
 266 }, {
 267         .phy_id         = 0x0007c0f0, /* OUI=0x00800f, Model#=0x0f */
 268         .phy_id_mask    = 0xfffffff0,
 269         .name           = "SMSC LAN8710/LAN8720",
 270
 271         .features       = (PHY_BASIC_FEATURES | SUPPORTED_Pause
 272                                 | SUPPORTED_Asym_Pause),
 273         .flags          = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,
 274
 275         .probe          = smsc_phy_probe,
 276
 277         /* basic functions */
 278         .config_aneg    = genphy_config_aneg,
 279         .read_status    = lan87xx_read_status,
 280         .config_init    = smsc_phy_config_init,
 281         .soft_reset     = smsc_phy_reset,
 282
 283         /* IRQ related */
 284         .ack_interrupt  = smsc_phy_ack_interrupt,
 285         .config_intr    = smsc_phy_config_intr,
 286
 287         .suspend        = genphy_suspend,
 288         .resume         = genphy_resume,
 289 }, {
 290         .phy_id         = 0x0007c110,
 291         .phy_id_mask    = 0xfffffff0,
 292         .name           = "SMSC LAN8740",
 293
 294         .features       = (PHY_BASIC_FEATURES | SUPPORTED_Pause
 295                                 | SUPPORTED_Asym_Pause),
 296         .flags          = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,
 297
 298         .probe          = smsc_phy_probe,
 299
 300         /* basic functions */
 301         .config_aneg    = genphy_config_aneg,
 302         .read_status    = lan87xx_read_status,
 303         .config_init    = smsc_phy_config_init,
 304         .soft_reset     = smsc_phy_reset,
 305
 306         /* IRQ related */
 307         .ack_interrupt  = smsc_phy_ack_interrupt,
 308         .config_intr    = smsc_phy_config_intr,
 309
 310         .suspend        = genphy_suspend,
 311         .resume         = genphy_resume,
 312 } };
 313
 314 module_phy_driver(smsc_phy_driver);
 315
 316 MODULE_DESCRIPTION("SMSC PHY driver");
 317 MODULE_AUTHOR("Herbert Valerio Riedel");
 318 MODULE_LICENSE("GPL");
 319
 320 static struct mdio_device_id __maybe_unused smsc_tbl[] = {
 321         { 0x0007c0a0, 0xfffffff0 },
 322         { 0x0007c0b0, 0xfffffff0 },
 323         { 0x0007c0c0, 0xfffffff0 },
 324         { 0x0007c0d0, 0xfffffff0 },
 325         { 0x0007c0f0, 0xfffffff0 },
 326         { 0x0007c110, 0xfffffff0 },
 327         { }
 328 };
 329
 330 MODULE_DEVICE_TABLE(mdio, smsc_tbl);