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 .flags = PHY_HAS_INTERRUPT, 223 224 .probe = smsc_phy_probe, 225 226 /* basic functions */ 227 .config_init = smsc_phy_config_init, 228 .soft_reset = smsc_phy_reset, 229 230 /* IRQ related */ 231 .ack_interrupt = smsc_phy_ack_interrupt, 232 .config_intr = smsc_phy_config_intr, 233 234 .suspend = genphy_suspend, 235 .resume = genphy_resume, 236 }, { 237 .phy_id = 0x0007c0b0, /* OUI=0x00800f, Model#=0x0b */ 238 .phy_id_mask = 0xfffffff0, 239 .name = "SMSC LAN8187", 240 241 .features = PHY_BASIC_FEATURES, 242 .flags = PHY_HAS_INTERRUPT, 243 244 .probe = smsc_phy_probe, 245 246 /* basic functions */ 247 .config_init = smsc_phy_config_init, 248 .soft_reset = smsc_phy_reset, 249 250 /* IRQ related */ 251 .ack_interrupt = smsc_phy_ack_interrupt, 252 .config_intr = smsc_phy_config_intr, 253 254 /* Statistics */ 255 .get_sset_count = smsc_get_sset_count, 256 .get_strings = smsc_get_strings, 257 .get_stats = smsc_get_stats, 258 259 .suspend = genphy_suspend, 260 .resume = genphy_resume, 261 }, { 262 .phy_id = 0x0007c0c0, /* OUI=0x00800f, Model#=0x0c */ 263 .phy_id_mask = 0xfffffff0, 264 .name = "SMSC LAN8700", 265 266 .features = PHY_BASIC_FEATURES, 267 .flags = PHY_HAS_INTERRUPT, 268 269 .probe = smsc_phy_probe, 270 271 /* basic functions */ 272 .read_status = lan87xx_read_status, 273 .config_init = smsc_phy_config_init, 274 .soft_reset = smsc_phy_reset, 275 276 /* IRQ related */ 277 .ack_interrupt = smsc_phy_ack_interrupt, 278 .config_intr = smsc_phy_config_intr, 279 280 /* Statistics */ 281 .get_sset_count = smsc_get_sset_count, 282 .get_strings = smsc_get_strings, 283 .get_stats = smsc_get_stats, 284 285 .suspend = genphy_suspend, 286 .resume = genphy_resume, 287 }, { 288 .phy_id = 0x0007c0d0, /* OUI=0x00800f, Model#=0x0d */ 289 .phy_id_mask = 0xfffffff0, 290 .name = "SMSC LAN911x Internal PHY", 291 292 .features = PHY_BASIC_FEATURES, 293 .flags = PHY_HAS_INTERRUPT, 294 295 .probe = smsc_phy_probe, 296 297 /* basic functions */ 298 .config_init = lan911x_config_init, 299 300 /* IRQ related */ 301 .ack_interrupt = smsc_phy_ack_interrupt, 302 .config_intr = smsc_phy_config_intr, 303 304 .suspend = genphy_suspend, 305 .resume = genphy_resume, 306 }, { 307 .phy_id = 0x0007c0f0, /* OUI=0x00800f, Model#=0x0f */ 308 .phy_id_mask = 0xfffffff0, 309 .name = "SMSC LAN8710/LAN8720", 310 311 .features = PHY_BASIC_FEATURES, 312 .flags = PHY_HAS_INTERRUPT | PHY_RST_AFTER_CLK_EN, 313 314 .probe = smsc_phy_probe, 315 316 /* basic functions */ 317 .read_status = lan87xx_read_status, 318 .config_init = smsc_phy_config_init, 319 .soft_reset = smsc_phy_reset, 320 321 /* IRQ related */ 322 .ack_interrupt = smsc_phy_ack_interrupt, 323 .config_intr = smsc_phy_config_intr, 324 325 /* Statistics */ 326 .get_sset_count = smsc_get_sset_count, 327 .get_strings = smsc_get_strings, 328 .get_stats = smsc_get_stats, 329 330 .suspend = genphy_suspend, 331 .resume = genphy_resume, 332 }, { 333 .phy_id = 0x0007c110, 334 .phy_id_mask = 0xfffffff0, 335 .name = "SMSC LAN8740", 336 337 .features = PHY_BASIC_FEATURES, 338 .flags = PHY_HAS_INTERRUPT, 339 340 .probe = smsc_phy_probe, 341 342 /* basic functions */ 343 .read_status = lan87xx_read_status, 344 .config_init = smsc_phy_config_init, 345 .soft_reset = smsc_phy_reset, 346 347 /* IRQ related */ 348 .ack_interrupt = smsc_phy_ack_interrupt, 349 .config_intr = smsc_phy_config_intr, 350 351 /* Statistics */ 352 .get_sset_count = smsc_get_sset_count, 353 .get_strings = smsc_get_strings, 354 .get_stats = smsc_get_stats, 355 356 .suspend = genphy_suspend, 357 .resume = genphy_resume, 358 } }; 359 360 module_phy_driver(smsc_phy_driver); 361 362 MODULE_DESCRIPTION("SMSC PHY driver"); 363 MODULE_AUTHOR("Herbert Valerio Riedel"); 364 MODULE_LICENSE("GPL"); 365 366 static struct mdio_device_id __maybe_unused smsc_tbl[] = { 367 { 0x0007c0a0, 0xfffffff0 }, 368 { 0x0007c0b0, 0xfffffff0 }, 369 { 0x0007c0c0, 0xfffffff0 }, 370 { 0x0007c0d0, 0xfffffff0 }, 371 { 0x0007c0f0, 0xfffffff0 }, 372 { 0x0007c110, 0xfffffff0 }, 373 { } 374 }; 375 376 MODULE_DEVICE_TABLE(mdio, smsc_tbl); 377