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/of.h> 24 #include <linux/phy.h> 25 #include <linux/netdevice.h> 26 #include <linux/smscphy.h> 27 28 struct smsc_hw_stat { 29 const char *string; 30 u8 reg; 31 u8 bits; 32 }; 33 34 static struct smsc_hw_stat smsc_hw_stats[] = { 35 { "phy_symbol_errors", 26, 16}, 36 }; 37 38 struct smsc_phy_priv { 39 bool energy_enable; 40 }; 41 42 static int smsc_phy_config_intr(struct phy_device *phydev) 43 { 44 int rc = phy_write (phydev, MII_LAN83C185_IM, 45 ((PHY_INTERRUPT_ENABLED == phydev->interrupts) 46 ? MII_LAN83C185_ISF_INT_PHYLIB_EVENTS 47 : 0)); 48 49 return rc < 0 ? rc : 0; 50 } 51 52 static int smsc_phy_ack_interrupt(struct phy_device *phydev) 53 { 54 int rc = phy_read (phydev, MII_LAN83C185_ISF); 55 56 return rc < 0 ? rc : 0; 57 } 58 59 static int smsc_phy_config_init(struct phy_device *phydev) 60 { 61 struct smsc_phy_priv *priv = phydev->priv; 62 63 int rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS); 64 65 if (rc < 0) 66 return rc; 67 68 if (priv->energy_enable) { 69 /* Enable energy detect mode for this SMSC Transceivers */ 70 rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS, 71 rc | MII_LAN83C185_EDPWRDOWN); 72 if (rc < 0) 73 return rc; 74 } 75 76 return smsc_phy_ack_interrupt(phydev); 77 } 78 79 static int smsc_phy_reset(struct phy_device *phydev) 80 { 81 int rc = phy_read(phydev, MII_LAN83C185_SPECIAL_MODES); 82 if (rc < 0) 83 return rc; 84 85 /* If the SMSC PHY is in power down mode, then set it 86 * in all capable mode before using it. 87 */ 88 if ((rc & MII_LAN83C185_MODE_MASK) == MII_LAN83C185_MODE_POWERDOWN) { 89 /* set "all capable" mode */ 90 rc |= MII_LAN83C185_MODE_ALL; 91 phy_write(phydev, MII_LAN83C185_SPECIAL_MODES, rc); 92 } 93 94 /* reset the phy */ 95 return genphy_soft_reset(phydev); 96 } 97 98 static int lan911x_config_init(struct phy_device *phydev) 99 { 100 return smsc_phy_ack_interrupt(phydev); 101 } 102 103 /* 104 * The LAN87xx suffers from rare absence of the ENERGYON-bit when Ethernet cable 105 * plugs in while LAN87xx is in Energy Detect Power-Down mode. This leads to 106 * unstable detection of plugging in Ethernet cable. 107 * This workaround disables Energy Detect Power-Down mode and waiting for 108 * response on link pulses to detect presence of plugged Ethernet cable. 109 * The Energy Detect Power-Down mode is enabled again in the end of procedure to 110 * save approximately 220 mW of power if cable is unplugged. 111 */ 112 static int lan87xx_read_status(struct phy_device *phydev) 113 { 114 struct smsc_phy_priv *priv = phydev->priv; 115 116 int err = genphy_read_status(phydev); 117 118 if (!phydev->link && priv->energy_enable) { 119 int i; 120 121 /* Disable EDPD to wake up PHY */ 122 int rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS); 123 if (rc < 0) 124 return rc; 125 126 rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS, 127 rc & ~MII_LAN83C185_EDPWRDOWN); 128 if (rc < 0) 129 return rc; 130 131 /* Wait max 640 ms to detect energy */ 132 for (i = 0; i < 64; i++) { 133 /* Sleep to allow link test pulses to be sent */ 134 msleep(10); 135 rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS); 136 if (rc < 0) 137 return rc; 138 if (rc & MII_LAN83C185_ENERGYON) 139 break; 140 } 141 142 /* Re-enable EDPD */ 143 rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS); 144 if (rc < 0) 145 return rc; 146 147 rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS, 148 rc | MII_LAN83C185_EDPWRDOWN); 149 if (rc < 0) 150 return rc; 151 } 152 153 return err; 154 } 155 156 static int smsc_get_sset_count(struct phy_device *phydev) 157 { 158 return ARRAY_SIZE(smsc_hw_stats); 159 } 160 161 static void smsc_get_strings(struct phy_device *phydev, u8 *data) 162 { 163 int i; 164 165 for (i = 0; i < ARRAY_SIZE(smsc_hw_stats); i++) { 166 strncpy(data + i * ETH_GSTRING_LEN, 167 smsc_hw_stats[i].string, ETH_GSTRING_LEN); 168 } 169 } 170 171 static u64 smsc_get_stat(struct phy_device *phydev, int i) 172 { 173 struct smsc_hw_stat stat = smsc_hw_stats[i]; 174 int val; 175 u64 ret; 176 177 val = phy_read(phydev, stat.reg); 178 if (val < 0) 179 ret = U64_MAX; 180 else 181 ret = val; 182 183 return ret; 184 } 185 186 static void smsc_get_stats(struct phy_device *phydev, 187 struct ethtool_stats *stats, u64 *data) 188 { 189 int i; 190 191 for (i = 0; i < ARRAY_SIZE(smsc_hw_stats); i++) 192 data[i] = smsc_get_stat(phydev, i); 193 } 194 195 static int smsc_phy_probe(struct phy_device *phydev) 196 { 197 struct device *dev = &phydev->mdio.dev; 198 struct device_node *of_node = dev->of_node; 199 struct smsc_phy_priv *priv; 200 201 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 202 if (!priv) 203 return -ENOMEM; 204 205 priv->energy_enable = true; 206 207 if (of_property_read_bool(of_node, "smsc,disable-energy-detect")) 208 priv->energy_enable = false; 209 210 phydev->priv = priv; 211 212 return 0; 213 } 214 215 static struct phy_driver smsc_phy_driver[] = { 216 { 217 .phy_id = 0x0007c0a0, /* OUI=0x00800f, Model#=0x0a */ 218 .phy_id_mask = 0xfffffff0, 219 .name = "SMSC LAN83C185", 220 221 .features = PHY_BASIC_FEATURES, 222 223 .probe = smsc_phy_probe, 224 225 /* basic functions */ 226 .config_init = smsc_phy_config_init, 227 .soft_reset = smsc_phy_reset, 228 229 /* IRQ related */ 230 .ack_interrupt = smsc_phy_ack_interrupt, 231 .config_intr = smsc_phy_config_intr, 232 233 .suspend = genphy_suspend, 234 .resume = genphy_resume, 235 }, { 236 .phy_id = 0x0007c0b0, /* OUI=0x00800f, Model#=0x0b */ 237 .phy_id_mask = 0xfffffff0, 238 .name = "SMSC LAN8187", 239 240 .features = PHY_BASIC_FEATURES, 241 242 .probe = smsc_phy_probe, 243 244 /* basic functions */ 245 .config_init = smsc_phy_config_init, 246 .soft_reset = smsc_phy_reset, 247 248 /* IRQ related */ 249 .ack_interrupt = smsc_phy_ack_interrupt, 250 .config_intr = smsc_phy_config_intr, 251 252 /* Statistics */ 253 .get_sset_count = smsc_get_sset_count, 254 .get_strings = smsc_get_strings, 255 .get_stats = smsc_get_stats, 256 257 .suspend = genphy_suspend, 258 .resume = genphy_resume, 259 }, { 260 .phy_id = 0x0007c0c0, /* OUI=0x00800f, Model#=0x0c */ 261 .phy_id_mask = 0xfffffff0, 262 .name = "SMSC LAN8700", 263 264 .features = PHY_BASIC_FEATURES, 265 266 .probe = smsc_phy_probe, 267 268 /* basic functions */ 269 .read_status = lan87xx_read_status, 270 .config_init = smsc_phy_config_init, 271 .soft_reset = smsc_phy_reset, 272 273 /* IRQ related */ 274 .ack_interrupt = smsc_phy_ack_interrupt, 275 .config_intr = smsc_phy_config_intr, 276 277 /* Statistics */ 278 .get_sset_count = smsc_get_sset_count, 279 .get_strings = smsc_get_strings, 280 .get_stats = smsc_get_stats, 281 282 .suspend = genphy_suspend, 283 .resume = genphy_resume, 284 }, { 285 .phy_id = 0x0007c0d0, /* OUI=0x00800f, Model#=0x0d */ 286 .phy_id_mask = 0xfffffff0, 287 .name = "SMSC LAN911x Internal PHY", 288 289 .features = PHY_BASIC_FEATURES, 290 291 .probe = smsc_phy_probe, 292 293 /* basic functions */ 294 .config_init = lan911x_config_init, 295 296 /* IRQ related */ 297 .ack_interrupt = smsc_phy_ack_interrupt, 298 .config_intr = smsc_phy_config_intr, 299 300 .suspend = genphy_suspend, 301 .resume = genphy_resume, 302 }, { 303 .phy_id = 0x0007c0f0, /* OUI=0x00800f, Model#=0x0f */ 304 .phy_id_mask = 0xfffffff0, 305 .name = "SMSC LAN8710/LAN8720", 306 307 .features = PHY_BASIC_FEATURES, 308 .flags = PHY_RST_AFTER_CLK_EN, 309 310 .probe = smsc_phy_probe, 311 312 /* basic functions */ 313 .read_status = lan87xx_read_status, 314 .config_init = smsc_phy_config_init, 315 .soft_reset = smsc_phy_reset, 316 317 /* IRQ related */ 318 .ack_interrupt = smsc_phy_ack_interrupt, 319 .config_intr = smsc_phy_config_intr, 320 321 /* Statistics */ 322 .get_sset_count = smsc_get_sset_count, 323 .get_strings = smsc_get_strings, 324 .get_stats = smsc_get_stats, 325 326 .suspend = genphy_suspend, 327 .resume = genphy_resume, 328 }, { 329 .phy_id = 0x0007c110, 330 .phy_id_mask = 0xfffffff0, 331 .name = "SMSC LAN8740", 332 333 .features = PHY_BASIC_FEATURES, 334 335 .probe = smsc_phy_probe, 336 337 /* basic functions */ 338 .read_status = lan87xx_read_status, 339 .config_init = smsc_phy_config_init, 340 .soft_reset = smsc_phy_reset, 341 342 /* IRQ related */ 343 .ack_interrupt = smsc_phy_ack_interrupt, 344 .config_intr = smsc_phy_config_intr, 345 346 /* Statistics */ 347 .get_sset_count = smsc_get_sset_count, 348 .get_strings = smsc_get_strings, 349 .get_stats = smsc_get_stats, 350 351 .suspend = genphy_suspend, 352 .resume = genphy_resume, 353 } }; 354 355 module_phy_driver(smsc_phy_driver); 356 357 MODULE_DESCRIPTION("SMSC PHY driver"); 358 MODULE_AUTHOR("Herbert Valerio Riedel"); 359 MODULE_LICENSE("GPL"); 360 361 static struct mdio_device_id __maybe_unused smsc_tbl[] = { 362 { 0x0007c0a0, 0xfffffff0 }, 363 { 0x0007c0b0, 0xfffffff0 }, 364 { 0x0007c0c0, 0xfffffff0 }, 365 { 0x0007c0d0, 0xfffffff0 }, 366 { 0x0007c0f0, 0xfffffff0 }, 367 { 0x0007c110, 0xfffffff0 }, 368 { } 369 }; 370 371 MODULE_DEVICE_TABLE(mdio, smsc_tbl); 372