drivers/net/phy/smsc.c

   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
  27 static 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
  37 static 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
  44 static 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
  60 static 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
  88 static int lan911x_config_init(struct phy_device *phydev)
  89 {
  90         return smsc_phy_ack_interrupt(phydev);
  91 }
  92
  93 /*
  94  * The LAN87xx suffers from rare absence of the ENERGYON-bit when Ethernet cable
  95  * plugs in while LAN87xx is in Energy Detect Power-Down mode. This leads to
  96  * unstable detection of plugging in Ethernet cable.
  97  * This workaround disables Energy Detect Power-Down mode and waiting for
  98  * response on link pulses to detect presence of plugged Ethernet cable.
  99  * The Energy Detect Power-Down mode is enabled again in the end of procedure to
 100  * save approximately 220 mW of power if cable is unplugged.
 101  */
 102 static int lan87xx_read_status(struct phy_device *phydev)
 103 {
 104         int err = genphy_read_status(phydev);
 105         int i;
 106
 107         if (!phydev->link) {
 108                 /* Disable EDPD to wake up PHY */
 109                 int rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);
 110                 if (rc < 0)
 111                         return rc;
 112
 113                 rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS,
 114                                rc & ~MII_LAN83C185_EDPWRDOWN);
 115                 if (rc < 0)
 116                         return rc;
 117
 118                 /* Wait max 640 ms to detect energy */
 119                 for (i = 0; i < 64; i++) {
 120                         /* Sleep to allow link test pulses to be sent */
 121                         msleep(10);
 122                         rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);
 123                         if (rc < 0)
 124                                 return rc;
 125                         if (rc & MII_LAN83C185_ENERGYON)
 126                                 break;
 127                 }
 128
 129                 /* Re-enable EDPD */
 130                 rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);
 131                 if (rc < 0)
 132                         return rc;
 133
 134                 rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS,
 135                                rc | MII_LAN83C185_EDPWRDOWN);
 136                 if (rc < 0)
 137                         return rc;
 138         }
 139
 140         return err;
 141 }
 142
 143 static struct phy_driver smsc_phy_driver[] = {
 144 {
 145         .phy_id         = 0x0007c0a0, /* OUI=0x00800f, Model#=0x0a */
 146         .phy_id_mask    = 0xfffffff0,
 147         .name           = "SMSC LAN83C185",
 148
 149         .features       = (PHY_BASIC_FEATURES | SUPPORTED_Pause
 150                                 | SUPPORTED_Asym_Pause),
 151         .flags          = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,
 152
 153         /* basic functions */
 154         .config_aneg    = genphy_config_aneg,
 155         .read_status    = genphy_read_status,
 156         .config_init    = smsc_phy_config_init,
 157         .soft_reset     = smsc_phy_reset,
 158
 159         /* IRQ related */
 160         .ack_interrupt  = smsc_phy_ack_interrupt,
 161         .config_intr    = smsc_phy_config_intr,
 162
 163         .suspend        = genphy_suspend,
 164         .resume         = genphy_resume,
 165
 166         .driver         = { .owner = THIS_MODULE, }
 167 }, {
 168         .phy_id         = 0x0007c0b0, /* OUI=0x00800f, Model#=0x0b */
 169         .phy_id_mask    = 0xfffffff0,
 170         .name           = "SMSC LAN8187",
 171
 172         .features       = (PHY_BASIC_FEATURES | SUPPORTED_Pause
 173                                 | SUPPORTED_Asym_Pause),
 174         .flags          = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,
 175
 176         /* basic functions */
 177         .config_aneg    = genphy_config_aneg,
 178         .read_status    = genphy_read_status,
 179         .config_init    = smsc_phy_config_init,
 180         .soft_reset     = smsc_phy_reset,
 181
 182         /* IRQ related */
 183         .ack_interrupt  = smsc_phy_ack_interrupt,
 184         .config_intr    = smsc_phy_config_intr,
 185
 186         .suspend        = genphy_suspend,
 187         .resume         = genphy_resume,
 188
 189         .driver         = { .owner = THIS_MODULE, }
 190 }, {
 191         .phy_id         = 0x0007c0c0, /* OUI=0x00800f, Model#=0x0c */
 192         .phy_id_mask    = 0xfffffff0,
 193         .name           = "SMSC LAN8700",
 194
 195         .features       = (PHY_BASIC_FEATURES | SUPPORTED_Pause
 196                                 | SUPPORTED_Asym_Pause),
 197         .flags          = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,
 198
 199         /* basic functions */
 200         .config_aneg    = genphy_config_aneg,
 201         .read_status    = lan87xx_read_status,
 202         .config_init    = smsc_phy_config_init,
 203         .soft_reset     = smsc_phy_reset,
 204
 205         /* IRQ related */
 206         .ack_interrupt  = smsc_phy_ack_interrupt,
 207         .config_intr    = smsc_phy_config_intr,
 208
 209         .suspend        = genphy_suspend,
 210         .resume         = genphy_resume,
 211
 212         .driver         = { .owner = THIS_MODULE, }
 213 }, {
 214         .phy_id         = 0x0007c0d0, /* OUI=0x00800f, Model#=0x0d */
 215         .phy_id_mask    = 0xfffffff0,
 216         .name           = "SMSC LAN911x Internal PHY",
 217
 218         .features       = (PHY_BASIC_FEATURES | SUPPORTED_Pause
 219                                 | SUPPORTED_Asym_Pause),
 220         .flags          = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,
 221
 222         /* basic functions */
 223         .config_aneg    = genphy_config_aneg,
 224         .read_status    = genphy_read_status,
 225         .config_init    = lan911x_config_init,
 226
 227         /* IRQ related */
 228         .ack_interrupt  = smsc_phy_ack_interrupt,
 229         .config_intr    = smsc_phy_config_intr,
 230
 231         .suspend        = genphy_suspend,
 232         .resume         = genphy_resume,
 233
 234         .driver         = { .owner = THIS_MODULE, }
 235 }, {
 236         .phy_id         = 0x0007c0f0, /* OUI=0x00800f, Model#=0x0f */
 237         .phy_id_mask    = 0xfffffff0,
 238         .name           = "SMSC LAN8710/LAN8720",
 239
 240         .features       = (PHY_BASIC_FEATURES | SUPPORTED_Pause
 241                                 | SUPPORTED_Asym_Pause),
 242         .flags          = PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,
 243
 244         /* basic functions */
 245         .config_aneg    = genphy_config_aneg,
 246         .read_status    = lan87xx_read_status,
 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         .suspend        = genphy_suspend,
 255         .resume         = genphy_resume,
 256
 257         .driver         = { .owner = THIS_MODULE, }
 258 } };
 259
 260 module_phy_driver(smsc_phy_driver);
 261
 262 MODULE_DESCRIPTION("SMSC PHY driver");
 263 MODULE_AUTHOR("Herbert Valerio Riedel");
 264 MODULE_LICENSE("GPL");
 265
 266 static struct mdio_device_id __maybe_unused smsc_tbl[] = {
 267         { 0x0007c0a0, 0xfffffff0 },
 268         { 0x0007c0b0, 0xfffffff0 },
 269         { 0x0007c0c0, 0xfffffff0 },
 270         { 0x0007c0d0, 0xfffffff0 },
 271         { 0x0007c0f0, 0xfffffff0 },
 272         { }
 273 };
 274
 275 MODULE_DEVICE_TABLE(mdio, smsc_tbl);