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 #ifndef UINT64_MAX 172 #define UINT64_MAX (u64)(~((u64)0)) 173 #endif 174 static u64 smsc_get_stat(struct phy_device *phydev, int i) 175 { 176 struct smsc_hw_stat stat = smsc_hw_stats[i]; 177 int val; 178 u64 ret; 179 180 val = phy_read(phydev, stat.reg); 181 if (val < 0) 182 ret = UINT64_MAX; 183 else 184 ret = val; 185 186 return ret; 187 } 188 189 static void smsc_get_stats(struct phy_device *phydev, 190 struct ethtool_stats *stats, u64 *data) 191 { 192 int i; 193 194 for (i = 0; i < ARRAY_SIZE(smsc_hw_stats); i++) 195 data[i] = smsc_get_stat(phydev, i); 196 } 197 198 static int smsc_phy_probe(struct phy_device *phydev) 199 { 200 struct device *dev = &phydev->mdio.dev; 201 struct device_node *of_node = dev->of_node; 202 struct smsc_phy_priv *priv; 203 204 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 205 if (!priv) 206 return -ENOMEM; 207 208 priv->energy_enable = true; 209 210 if (of_property_read_bool(of_node, "smsc,disable-energy-detect")) 211 priv->energy_enable = false; 212 213 phydev->priv = priv; 214 215 return 0; 216 } 217 218 static struct phy_driver smsc_phy_driver[] = { 219 { 220 .phy_id = 0x0007c0a0, /* OUI=0x00800f, Model#=0x0a */ 221 .phy_id_mask = 0xfffffff0, 222 .name = "SMSC LAN83C185", 223 224 .features = PHY_BASIC_FEATURES, 225 .flags = PHY_HAS_INTERRUPT, 226 227 .probe = smsc_phy_probe, 228 229 /* basic functions */ 230 .config_aneg = genphy_config_aneg, 231 .read_status = genphy_read_status, 232 .config_init = smsc_phy_config_init, 233 .soft_reset = smsc_phy_reset, 234 235 /* IRQ related */ 236 .ack_interrupt = smsc_phy_ack_interrupt, 237 .config_intr = smsc_phy_config_intr, 238 239 .suspend = genphy_suspend, 240 .resume = genphy_resume, 241 }, { 242 .phy_id = 0x0007c0b0, /* OUI=0x00800f, Model#=0x0b */ 243 .phy_id_mask = 0xfffffff0, 244 .name = "SMSC LAN8187", 245 246 .features = PHY_BASIC_FEATURES, 247 .flags = PHY_HAS_INTERRUPT, 248 249 .probe = smsc_phy_probe, 250 251 /* basic functions */ 252 .config_aneg = genphy_config_aneg, 253 .read_status = genphy_read_status, 254 .config_init = smsc_phy_config_init, 255 .soft_reset = smsc_phy_reset, 256 257 /* IRQ related */ 258 .ack_interrupt = smsc_phy_ack_interrupt, 259 .config_intr = smsc_phy_config_intr, 260 261 /* Statistics */ 262 .get_sset_count = smsc_get_sset_count, 263 .get_strings = smsc_get_strings, 264 .get_stats = smsc_get_stats, 265 266 .suspend = genphy_suspend, 267 .resume = genphy_resume, 268 }, { 269 .phy_id = 0x0007c0c0, /* OUI=0x00800f, Model#=0x0c */ 270 .phy_id_mask = 0xfffffff0, 271 .name = "SMSC LAN8700", 272 273 .features = PHY_BASIC_FEATURES, 274 .flags = PHY_HAS_INTERRUPT, 275 276 .probe = smsc_phy_probe, 277 278 /* basic functions */ 279 .config_aneg = genphy_config_aneg, 280 .read_status = lan87xx_read_status, 281 .config_init = smsc_phy_config_init, 282 .soft_reset = smsc_phy_reset, 283 284 /* IRQ related */ 285 .ack_interrupt = smsc_phy_ack_interrupt, 286 .config_intr = smsc_phy_config_intr, 287 288 /* Statistics */ 289 .get_sset_count = smsc_get_sset_count, 290 .get_strings = smsc_get_strings, 291 .get_stats = smsc_get_stats, 292 293 .suspend = genphy_suspend, 294 .resume = genphy_resume, 295 }, { 296 .phy_id = 0x0007c0d0, /* OUI=0x00800f, Model#=0x0d */ 297 .phy_id_mask = 0xfffffff0, 298 .name = "SMSC LAN911x Internal PHY", 299 300 .features = PHY_BASIC_FEATURES, 301 .flags = PHY_HAS_INTERRUPT, 302 303 .probe = smsc_phy_probe, 304 305 /* basic functions */ 306 .config_aneg = genphy_config_aneg, 307 .read_status = genphy_read_status, 308 .config_init = lan911x_config_init, 309 310 /* IRQ related */ 311 .ack_interrupt = smsc_phy_ack_interrupt, 312 .config_intr = smsc_phy_config_intr, 313 314 .suspend = genphy_suspend, 315 .resume = genphy_resume, 316 }, { 317 .phy_id = 0x0007c0f0, /* OUI=0x00800f, Model#=0x0f */ 318 .phy_id_mask = 0xfffffff0, 319 .name = "SMSC LAN8710/LAN8720", 320 321 .features = PHY_BASIC_FEATURES, 322 .flags = PHY_HAS_INTERRUPT, 323 324 .probe = smsc_phy_probe, 325 326 /* basic functions */ 327 .config_aneg = genphy_config_aneg, 328 .read_status = lan87xx_read_status, 329 .config_init = smsc_phy_config_init, 330 .soft_reset = smsc_phy_reset, 331 332 /* IRQ related */ 333 .ack_interrupt = smsc_phy_ack_interrupt, 334 .config_intr = smsc_phy_config_intr, 335 336 /* Statistics */ 337 .get_sset_count = smsc_get_sset_count, 338 .get_strings = smsc_get_strings, 339 .get_stats = smsc_get_stats, 340 341 .suspend = genphy_suspend, 342 .resume = genphy_resume, 343 }, { 344 .phy_id = 0x0007c110, 345 .phy_id_mask = 0xfffffff0, 346 .name = "SMSC LAN8740", 347 348 .features = PHY_BASIC_FEATURES, 349 .flags = PHY_HAS_INTERRUPT, 350 351 .probe = smsc_phy_probe, 352 353 /* basic functions */ 354 .config_aneg = genphy_config_aneg, 355 .read_status = lan87xx_read_status, 356 .config_init = smsc_phy_config_init, 357 .soft_reset = smsc_phy_reset, 358 359 /* IRQ related */ 360 .ack_interrupt = smsc_phy_ack_interrupt, 361 .config_intr = smsc_phy_config_intr, 362 363 /* Statistics */ 364 .get_sset_count = smsc_get_sset_count, 365 .get_strings = smsc_get_strings, 366 .get_stats = smsc_get_stats, 367 368 .suspend = genphy_suspend, 369 .resume = genphy_resume, 370 } }; 371 372 module_phy_driver(smsc_phy_driver); 373 374 MODULE_DESCRIPTION("SMSC PHY driver"); 375 MODULE_AUTHOR("Herbert Valerio Riedel"); 376 MODULE_LICENSE("GPL"); 377 378 static struct mdio_device_id __maybe_unused smsc_tbl[] = { 379 { 0x0007c0a0, 0xfffffff0 }, 380 { 0x0007c0b0, 0xfffffff0 }, 381 { 0x0007c0c0, 0xfffffff0 }, 382 { 0x0007c0d0, 0xfffffff0 }, 383 { 0x0007c0f0, 0xfffffff0 }, 384 { 0x0007c110, 0xfffffff0 }, 385 { } 386 }; 387 388 MODULE_DEVICE_TABLE(mdio, smsc_tbl); 389