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 27static int smsc_phy_config_intr(struct phy_device *phydev) 28{ 29 int rc = phy_write (phydev, MII_LAN83C185_IM, 30 ((PHY_INTERRUPT_ENABLED == phydev->interrupts) 31 ? MII_LAN83C185_ISF_INT_PHYLIB_EVENTS 32 : 0)); 33 34 return rc < 0 ? rc : 0; 35} 36 37static int smsc_phy_ack_interrupt(struct phy_device *phydev) 38{ 39 int rc = phy_read (phydev, MII_LAN83C185_ISF); 40 41 return rc < 0 ? rc : 0; 42} 43 44static int smsc_phy_config_init(struct phy_device *phydev) 45{ 46 int rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS); 47 48 if (rc < 0) 49 return rc; 50 51 /* Enable energy detect mode for this SMSC Transceivers */ 52 rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS, 53 rc | MII_LAN83C185_EDPWRDOWN); 54 if (rc < 0) 55 return rc; 56 57 return smsc_phy_ack_interrupt(phydev); 58} 59 60static int smsc_phy_reset(struct phy_device *phydev) 61{ 62 int rc = phy_read(phydev, MII_LAN83C185_SPECIAL_MODES); 63 if (rc < 0) 64 return rc; 65 66 /* If the SMSC PHY is in power down mode, then set it 67 * in all capable mode before using it. 68 */ 69 if ((rc & MII_LAN83C185_MODE_MASK) == MII_LAN83C185_MODE_POWERDOWN) { 70 int timeout = 50000; 71 72 /* set "all capable" mode and reset the phy */ 73 rc |= MII_LAN83C185_MODE_ALL; 74 phy_write(phydev, MII_LAN83C185_SPECIAL_MODES, rc); 75 phy_write(phydev, MII_BMCR, BMCR_RESET); 76 77 /* wait end of reset (max 500 ms) */ 78 do { 79 udelay(10); 80 if (timeout-- == 0) 81 return -1; 82 rc = phy_read(phydev, MII_BMCR); 83 } while (rc & BMCR_RESET); 84 } 85 return 0; 86} 87 88static int lan911x_config_init(struct phy_device *phydev) 89{ 90 return smsc_phy_ack_interrupt(phydev); 91} 92 93/* 94 * The LAN8710/LAN8720 requires a minimum of 2 link pulses within 64ms of each 95 * other in order to set the ENERGYON bit and exit EDPD mode. If a link partner 96 * does send the pulses within this interval, the PHY will remained powered 97 * down. 98 * 99 * This workaround will manually toggle the PHY on/off upon calls to read_status 100 * in order to generate link test pulses if the link is down. If a link partner 101 * is present, it will respond to the pulses, which will cause the ENERGYON bit 102 * to be set and will cause the EDPD mode to be exited. 103 */ 104static int lan87xx_read_status(struct phy_device *phydev) 105{ 106 int err = genphy_read_status(phydev); 107 108 if (!phydev->link) { 109 /* Disable EDPD to wake up PHY */ 110 int rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS); 111 if (rc < 0) 112 return rc; 113 114 rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS, 115 rc & ~MII_LAN83C185_EDPWRDOWN); 116 if (rc < 0) 117 return rc; 118 119 /* Sleep 64 ms to allow ~5 link test pulses to be sent */ 120 msleep(64); 121 122 /* Re-enable EDPD */ 123 rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS); 124 if (rc < 0) 125 return rc; 126 127 rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS, 128 rc | MII_LAN83C185_EDPWRDOWN); 129 if (rc < 0) 130 return rc; 131 } 132 133 return err; 134} 135 136static struct phy_driver smsc_phy_driver[] = { 137{ 138 .phy_id = 0x0007c0a0, /* OUI=0x00800f, Model#=0x0a */ 139 .phy_id_mask = 0xfffffff0, 140 .name = "SMSC LAN83C185", 141 142 .features = (PHY_BASIC_FEATURES | SUPPORTED_Pause 143 | SUPPORTED_Asym_Pause), 144 .flags = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG, 145 146 /* basic functions */ 147 .config_aneg = genphy_config_aneg, 148 .read_status = genphy_read_status, 149 .config_init = smsc_phy_config_init, 150 .soft_reset = smsc_phy_reset, 151 152 /* IRQ related */ 153 .ack_interrupt = smsc_phy_ack_interrupt, 154 .config_intr = smsc_phy_config_intr, 155 156 .suspend = genphy_suspend, 157 .resume = genphy_resume, 158 159 .driver = { .owner = THIS_MODULE, } 160}, { 161 .phy_id = 0x0007c0b0, /* OUI=0x00800f, Model#=0x0b */ 162 .phy_id_mask = 0xfffffff0, 163 .name = "SMSC LAN8187", 164 165 .features = (PHY_BASIC_FEATURES | SUPPORTED_Pause 166 | SUPPORTED_Asym_Pause), 167 .flags = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG, 168 169 /* basic functions */ 170 .config_aneg = genphy_config_aneg, 171 .read_status = genphy_read_status, 172 .config_init = smsc_phy_config_init, 173 .soft_reset = smsc_phy_reset, 174 175 /* IRQ related */ 176 .ack_interrupt = smsc_phy_ack_interrupt, 177 .config_intr = smsc_phy_config_intr, 178 179 .suspend = genphy_suspend, 180 .resume = genphy_resume, 181 182 .driver = { .owner = THIS_MODULE, } 183}, { 184 .phy_id = 0x0007c0c0, /* OUI=0x00800f, Model#=0x0c */ 185 .phy_id_mask = 0xfffffff0, 186 .name = "SMSC LAN8700", 187 188 .features = (PHY_BASIC_FEATURES | SUPPORTED_Pause 189 | SUPPORTED_Asym_Pause), 190 .flags = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG, 191 192 /* basic functions */ 193 .config_aneg = genphy_config_aneg, 194 .read_status = genphy_read_status, 195 .config_init = smsc_phy_config_init, 196 .soft_reset = smsc_phy_reset, 197 198 /* IRQ related */ 199 .ack_interrupt = smsc_phy_ack_interrupt, 200 .config_intr = smsc_phy_config_intr, 201 202 .suspend = genphy_suspend, 203 .resume = genphy_resume, 204 205 .driver = { .owner = THIS_MODULE, } 206}, { 207 .phy_id = 0x0007c0d0, /* OUI=0x00800f, Model#=0x0d */ 208 .phy_id_mask = 0xfffffff0, 209 .name = "SMSC LAN911x Internal PHY", 210 211 .features = (PHY_BASIC_FEATURES | SUPPORTED_Pause 212 | SUPPORTED_Asym_Pause), 213 .flags = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG, 214 215 /* basic functions */ 216 .config_aneg = genphy_config_aneg, 217 .read_status = genphy_read_status, 218 .config_init = lan911x_config_init, 219 220 /* IRQ related */ 221 .ack_interrupt = smsc_phy_ack_interrupt, 222 .config_intr = smsc_phy_config_intr, 223 224 .suspend = genphy_suspend, 225 .resume = genphy_resume, 226 227 .driver = { .owner = THIS_MODULE, } 228}, { 229 .phy_id = 0x0007c0f0, /* OUI=0x00800f, Model#=0x0f */ 230 .phy_id_mask = 0xfffffff0, 231 .name = "SMSC LAN8710/LAN8720", 232 233 .features = (PHY_BASIC_FEATURES | SUPPORTED_Pause 234 | SUPPORTED_Asym_Pause), 235 .flags = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG, 236 237 /* basic functions */ 238 .config_aneg = genphy_config_aneg, 239 .read_status = lan87xx_read_status, 240 .config_init = smsc_phy_config_init, 241 .soft_reset = smsc_phy_reset, 242 243 /* IRQ related */ 244 .ack_interrupt = smsc_phy_ack_interrupt, 245 .config_intr = smsc_phy_config_intr, 246 247 .suspend = genphy_suspend, 248 .resume = genphy_resume, 249 250 .driver = { .owner = THIS_MODULE, } 251} }; 252 253module_phy_driver(smsc_phy_driver); 254 255MODULE_DESCRIPTION("SMSC PHY driver"); 256MODULE_AUTHOR("Herbert Valerio Riedel"); 257MODULE_LICENSE("GPL"); 258 259static struct mdio_device_id __maybe_unused smsc_tbl[] = { 260 { 0x0007c0a0, 0xfffffff0 }, 261 { 0x0007c0b0, 0xfffffff0 }, 262 { 0x0007c0c0, 0xfffffff0 }, 263 { 0x0007c0d0, 0xfffffff0 }, 264 { 0x0007c0f0, 0xfffffff0 }, 265 { } 266}; 267 268MODULE_DEVICE_TABLE(mdio, smsc_tbl); 269