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