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 /* set "all capable" mode */ 79 rc |= MII_LAN83C185_MODE_ALL; 80 phy_write(phydev, MII_LAN83C185_SPECIAL_MODES, rc); 81 } 82 83 /* reset the phy */ 84 return genphy_soft_reset(phydev); 85 } 86 87 static int lan911x_config_init(struct phy_device *phydev) 88 { 89 return smsc_phy_ack_interrupt(phydev); 90 } 91 92 /* 93 * The LAN87xx suffers from rare absence of the ENERGYON-bit when Ethernet cable 94 * plugs in while LAN87xx is in Energy Detect Power-Down mode. This leads to 95 * unstable detection of plugging in Ethernet cable. 96 * This workaround disables Energy Detect Power-Down mode and waiting for 97 * response on link pulses to detect presence of plugged Ethernet cable. 98 * The Energy Detect Power-Down mode is enabled again in the end of procedure to 99 * save approximately 220 mW of power if cable is unplugged. 100 */ 101 static int lan87xx_read_status(struct phy_device *phydev) 102 { 103 struct smsc_phy_priv *priv = phydev->priv; 104 105 int err = genphy_read_status(phydev); 106 107 if (!phydev->link && priv->energy_enable) { 108 int i; 109 110 /* Disable EDPD to wake up PHY */ 111 int rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS); 112 if (rc < 0) 113 return rc; 114 115 rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS, 116 rc & ~MII_LAN83C185_EDPWRDOWN); 117 if (rc < 0) 118 return rc; 119 120 /* Wait max 640 ms to detect energy */ 121 for (i = 0; i < 64; i++) { 122 /* Sleep to allow link test pulses to be sent */ 123 msleep(10); 124 rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS); 125 if (rc < 0) 126 return rc; 127 if (rc & MII_LAN83C185_ENERGYON) 128 break; 129 } 130 131 /* Re-enable EDPD */ 132 rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS); 133 if (rc < 0) 134 return rc; 135 136 rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS, 137 rc | MII_LAN83C185_EDPWRDOWN); 138 if (rc < 0) 139 return rc; 140 } 141 142 return err; 143 } 144 145 static int smsc_phy_probe(struct phy_device *phydev) 146 { 147 struct device *dev = &phydev->mdio.dev; 148 struct device_node *of_node = dev->of_node; 149 struct smsc_phy_priv *priv; 150 151 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 152 if (!priv) 153 return -ENOMEM; 154 155 priv->energy_enable = true; 156 157 if (of_property_read_bool(of_node, "smsc,disable-energy-detect")) 158 priv->energy_enable = false; 159 160 phydev->priv = priv; 161 162 return 0; 163 } 164 165 static struct phy_driver smsc_phy_driver[] = { 166 { 167 .phy_id = 0x0007c0a0, /* OUI=0x00800f, Model#=0x0a */ 168 .phy_id_mask = 0xfffffff0, 169 .name = "SMSC LAN83C185", 170 171 .features = PHY_BASIC_FEATURES, 172 .flags = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG, 173 174 .probe = smsc_phy_probe, 175 176 /* basic functions */ 177 .config_aneg = genphy_config_aneg, 178 .read_status = genphy_read_status, 179 .config_init = smsc_phy_config_init, 180 .soft_reset = smsc_phy_reset, 181 182 /* IRQ related */ 183 .ack_interrupt = smsc_phy_ack_interrupt, 184 .config_intr = smsc_phy_config_intr, 185 186 .suspend = genphy_suspend, 187 .resume = genphy_resume, 188 }, { 189 .phy_id = 0x0007c0b0, /* OUI=0x00800f, Model#=0x0b */ 190 .phy_id_mask = 0xfffffff0, 191 .name = "SMSC LAN8187", 192 193 .features = PHY_BASIC_FEATURES, 194 .flags = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG, 195 196 .probe = smsc_phy_probe, 197 198 /* basic functions */ 199 .config_aneg = genphy_config_aneg, 200 .read_status = genphy_read_status, 201 .config_init = smsc_phy_config_init, 202 .soft_reset = smsc_phy_reset, 203 204 /* IRQ related */ 205 .ack_interrupt = smsc_phy_ack_interrupt, 206 .config_intr = smsc_phy_config_intr, 207 208 .suspend = genphy_suspend, 209 .resume = genphy_resume, 210 }, { 211 .phy_id = 0x0007c0c0, /* OUI=0x00800f, Model#=0x0c */ 212 .phy_id_mask = 0xfffffff0, 213 .name = "SMSC LAN8700", 214 215 .features = PHY_BASIC_FEATURES, 216 .flags = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG, 217 218 .probe = smsc_phy_probe, 219 220 /* basic functions */ 221 .config_aneg = genphy_config_aneg, 222 .read_status = lan87xx_read_status, 223 .config_init = smsc_phy_config_init, 224 .soft_reset = smsc_phy_reset, 225 226 /* IRQ related */ 227 .ack_interrupt = smsc_phy_ack_interrupt, 228 .config_intr = smsc_phy_config_intr, 229 230 .suspend = genphy_suspend, 231 .resume = genphy_resume, 232 }, { 233 .phy_id = 0x0007c0d0, /* OUI=0x00800f, Model#=0x0d */ 234 .phy_id_mask = 0xfffffff0, 235 .name = "SMSC LAN911x Internal PHY", 236 237 .features = PHY_BASIC_FEATURES, 238 .flags = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG, 239 240 .probe = smsc_phy_probe, 241 242 /* basic functions */ 243 .config_aneg = genphy_config_aneg, 244 .read_status = genphy_read_status, 245 .config_init = lan911x_config_init, 246 247 /* IRQ related */ 248 .ack_interrupt = smsc_phy_ack_interrupt, 249 .config_intr = smsc_phy_config_intr, 250 251 .suspend = genphy_suspend, 252 .resume = genphy_resume, 253 }, { 254 .phy_id = 0x0007c0f0, /* OUI=0x00800f, Model#=0x0f */ 255 .phy_id_mask = 0xfffffff0, 256 .name = "SMSC LAN8710/LAN8720", 257 258 .features = PHY_BASIC_FEATURES, 259 .flags = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG, 260 261 .probe = smsc_phy_probe, 262 263 /* basic functions */ 264 .config_aneg = genphy_config_aneg, 265 .read_status = lan87xx_read_status, 266 .config_init = smsc_phy_config_init, 267 .soft_reset = smsc_phy_reset, 268 269 /* IRQ related */ 270 .ack_interrupt = smsc_phy_ack_interrupt, 271 .config_intr = smsc_phy_config_intr, 272 273 .suspend = genphy_suspend, 274 .resume = genphy_resume, 275 }, { 276 .phy_id = 0x0007c110, 277 .phy_id_mask = 0xfffffff0, 278 .name = "SMSC LAN8740", 279 280 .features = PHY_BASIC_FEATURES, 281 .flags = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG, 282 283 .probe = smsc_phy_probe, 284 285 /* basic functions */ 286 .config_aneg = genphy_config_aneg, 287 .read_status = lan87xx_read_status, 288 .config_init = smsc_phy_config_init, 289 .soft_reset = smsc_phy_reset, 290 291 /* IRQ related */ 292 .ack_interrupt = smsc_phy_ack_interrupt, 293 .config_intr = smsc_phy_config_intr, 294 295 .suspend = genphy_suspend, 296 .resume = genphy_resume, 297 } }; 298 299 module_phy_driver(smsc_phy_driver); 300 301 MODULE_DESCRIPTION("SMSC PHY driver"); 302 MODULE_AUTHOR("Herbert Valerio Riedel"); 303 MODULE_LICENSE("GPL"); 304 305 static struct mdio_device_id __maybe_unused smsc_tbl[] = { 306 { 0x0007c0a0, 0xfffffff0 }, 307 { 0x0007c0b0, 0xfffffff0 }, 308 { 0x0007c0c0, 0xfffffff0 }, 309 { 0x0007c0d0, 0xfffffff0 }, 310 { 0x0007c0f0, 0xfffffff0 }, 311 { 0x0007c110, 0xfffffff0 }, 312 { } 313 }; 314 315 MODULE_DEVICE_TABLE(mdio, smsc_tbl); 316