[linux-2.6-block.git] / drivers / net / phy / smsc.c

/*
 * drivers/net/phy/smsc.c
 *
 * Driver for SMSC PHYs
 *
 * Author: Herbert Valerio Riedel
 *
 * Copyright (c) 2006 Herbert Valerio Riedel <hvr@gnu.org>
 *
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 *
 * Support added for SMSC LAN8187 and LAN8700 by steve.glendinning@shawell.net
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mii.h>
#include <linux/ethtool.h>
#include <linux/phy.h>
#include <linux/netdevice.h>
#include <linux/smscphy.h>

struct smsc_phy_priv {
	bool energy_enable;
};

static int smsc_phy_config_intr(struct phy_device *phydev)
{
	int rc = phy_write (phydev, MII_LAN83C185_IM,
			((PHY_INTERRUPT_ENABLED == phydev->interrupts)
			? MII_LAN83C185_ISF_INT_PHYLIB_EVENTS
			: 0));

	return rc < 0 ? rc : 0;
}

static int smsc_phy_ack_interrupt(struct phy_device *phydev)
{
	int rc = phy_read (phydev, MII_LAN83C185_ISF);

	return rc < 0 ? rc : 0;
}

static int smsc_phy_config_init(struct phy_device *phydev)
{
	struct smsc_phy_priv *priv = phydev->priv;

	int rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);

	if (rc < 0)
		return rc;

	if (priv->energy_enable) {
		/* Enable energy detect mode for this SMSC Transceivers */
		rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS,
			       rc | MII_LAN83C185_EDPWRDOWN);
		if (rc < 0)
			return rc;
	}

	return smsc_phy_ack_interrupt(phydev);
}

static int smsc_phy_reset(struct phy_device *phydev)
{
	int rc = phy_read(phydev, MII_LAN83C185_SPECIAL_MODES);
	if (rc < 0)
		return rc;

	/* If the SMSC PHY is in power down mode, then set it
	 * in all capable mode before using it.
	 */
	if ((rc & MII_LAN83C185_MODE_MASK) == MII_LAN83C185_MODE_POWERDOWN) {
		/* set "all capable" mode */
		rc |= MII_LAN83C185_MODE_ALL;
		phy_write(phydev, MII_LAN83C185_SPECIAL_MODES, rc);
	}

	/* reset the phy */
	return genphy_soft_reset(phydev);
}

static int lan911x_config_init(struct phy_device *phydev)
{
	return smsc_phy_ack_interrupt(phydev);
}

/*
 * The LAN87xx suffers from rare absence of the ENERGYON-bit when Ethernet cable
 * plugs in while LAN87xx is in Energy Detect Power-Down mode. This leads to
 * unstable detection of plugging in Ethernet cable.
 * This workaround disables Energy Detect Power-Down mode and waiting for
 * response on link pulses to detect presence of plugged Ethernet cable.
 * The Energy Detect Power-Down mode is enabled again in the end of procedure to
 * save approximately 220 mW of power if cable is unplugged.
 */
static int lan87xx_read_status(struct phy_device *phydev)
{
	struct smsc_phy_priv *priv = phydev->priv;

	int err = genphy_read_status(phydev);

	if (!phydev->link && priv->energy_enable) {
		int i;

		/* Disable EDPD to wake up PHY */
		int rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);
		if (rc < 0)
			return rc;

		rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS,
			       rc & ~MII_LAN83C185_EDPWRDOWN);
		if (rc < 0)
			return rc;

		/* Wait max 640 ms to detect energy */
		for (i = 0; i < 64; i++) {
			/* Sleep to allow link test pulses to be sent */
			msleep(10);
			rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);
			if (rc < 0)
				return rc;
			if (rc & MII_LAN83C185_ENERGYON)
				break;
		}

		/* Re-enable EDPD */
		rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);
		if (rc < 0)
			return rc;

		rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS,
			       rc | MII_LAN83C185_EDPWRDOWN);
		if (rc < 0)
			return rc;
	}

	return err;
}

static int smsc_phy_probe(struct phy_device *phydev)
{
	struct device *dev = &phydev->mdio.dev;
	struct device_node *of_node = dev->of_node;
	struct smsc_phy_priv *priv;

	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	priv->energy_enable = true;

	if (of_property_read_bool(of_node, "smsc,disable-energy-detect"))
		priv->energy_enable = false;

	phydev->priv = priv;

	return 0;
}

static struct phy_driver smsc_phy_driver[] = {
{
	.phy_id		= 0x0007c0a0, /* OUI=0x00800f, Model#=0x0a */
	.phy_id_mask	= 0xfffffff0,
	.name		= "SMSC LAN83C185",

	.features	= (PHY_BASIC_FEATURES | SUPPORTED_Pause
				| SUPPORTED_Asym_Pause),
	.flags		= PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,

	.probe		= smsc_phy_probe,

	/* basic functions */
	.config_aneg	= genphy_config_aneg,
	.read_status	= genphy_read_status,
	.config_init	= smsc_phy_config_init,
	.soft_reset	= smsc_phy_reset,

	/* IRQ related */
	.ack_interrupt	= smsc_phy_ack_interrupt,
	.config_intr	= smsc_phy_config_intr,

	.suspend	= genphy_suspend,
	.resume		= genphy_resume,
}, {
	.phy_id		= 0x0007c0b0, /* OUI=0x00800f, Model#=0x0b */
	.phy_id_mask	= 0xfffffff0,
	.name		= "SMSC LAN8187",

	.features	= (PHY_BASIC_FEATURES | SUPPORTED_Pause
				| SUPPORTED_Asym_Pause),
	.flags		= PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,

	.probe		= smsc_phy_probe,

	/* basic functions */
	.config_aneg	= genphy_config_aneg,
	.read_status	= genphy_read_status,
	.config_init	= smsc_phy_config_init,
	.soft_reset	= smsc_phy_reset,

	/* IRQ related */
	.ack_interrupt	= smsc_phy_ack_interrupt,
	.config_intr	= smsc_phy_config_intr,

	.suspend	= genphy_suspend,
	.resume		= genphy_resume,
}, {
	.phy_id		= 0x0007c0c0, /* OUI=0x00800f, Model#=0x0c */
	.phy_id_mask	= 0xfffffff0,
	.name		= "SMSC LAN8700",

	.features	= (PHY_BASIC_FEATURES | SUPPORTED_Pause
				| SUPPORTED_Asym_Pause),
	.flags		= PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,

	.probe		= smsc_phy_probe,

	/* basic functions */
	.config_aneg	= genphy_config_aneg,
	.read_status	= lan87xx_read_status,
	.config_init	= smsc_phy_config_init,
	.soft_reset	= smsc_phy_reset,

	/* IRQ related */
	.ack_interrupt	= smsc_phy_ack_interrupt,
	.config_intr	= smsc_phy_config_intr,

	.suspend	= genphy_suspend,
	.resume		= genphy_resume,
}, {
	.phy_id		= 0x0007c0d0, /* OUI=0x00800f, Model#=0x0d */
	.phy_id_mask	= 0xfffffff0,
	.name		= "SMSC LAN911x Internal PHY",

	.features	= (PHY_BASIC_FEATURES | SUPPORTED_Pause
				| SUPPORTED_Asym_Pause),
	.flags		= PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,

	.probe		= smsc_phy_probe,

	/* basic functions */
	.config_aneg	= genphy_config_aneg,
	.read_status	= genphy_read_status,
	.config_init	= lan911x_config_init,

	/* IRQ related */
	.ack_interrupt	= smsc_phy_ack_interrupt,
	.config_intr	= smsc_phy_config_intr,

	.suspend	= genphy_suspend,
	.resume		= genphy_resume,
}, {
	.phy_id		= 0x0007c0f0, /* OUI=0x00800f, Model#=0x0f */
	.phy_id_mask	= 0xfffffff0,
	.name		= "SMSC LAN8710/LAN8720",

	.features	= (PHY_BASIC_FEATURES | SUPPORTED_Pause
				| SUPPORTED_Asym_Pause),
	.flags		= PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,

	.probe		= smsc_phy_probe,

	/* basic functions */
	.config_aneg	= genphy_config_aneg,
	.read_status	= lan87xx_read_status,
	.config_init	= smsc_phy_config_init,
	.soft_reset	= smsc_phy_reset,

	/* IRQ related */
	.ack_interrupt	= smsc_phy_ack_interrupt,
	.config_intr	= smsc_phy_config_intr,

	.suspend	= genphy_suspend,
	.resume		= genphy_resume,
}, {
	.phy_id		= 0x0007c110,
	.phy_id_mask	= 0xfffffff0,
	.name		= "SMSC LAN8740",

	.features	= (PHY_BASIC_FEATURES | SUPPORTED_Pause
				| SUPPORTED_Asym_Pause),
	.flags		= PHY_HAS_INTERRUPT | PHY_HAS_MAGICANEG,

	.probe		= smsc_phy_probe,

	/* basic functions */
	.config_aneg	= genphy_config_aneg,
	.read_status	= lan87xx_read_status,
	.config_init	= smsc_phy_config_init,
	.soft_reset	= smsc_phy_reset,

	/* IRQ related */
	.ack_interrupt	= smsc_phy_ack_interrupt,
	.config_intr	= smsc_phy_config_intr,

	.suspend	= genphy_suspend,
	.resume		= genphy_resume,
} };

module_phy_driver(smsc_phy_driver);

MODULE_DESCRIPTION("SMSC PHY driver");
MODULE_AUTHOR("Herbert Valerio Riedel");
MODULE_LICENSE("GPL");

static struct mdio_device_id __maybe_unused smsc_tbl[] = {
	{ 0x0007c0a0, 0xfffffff0 },
	{ 0x0007c0b0, 0xfffffff0 },
	{ 0x0007c0c0, 0xfffffff0 },
	{ 0x0007c0d0, 0xfffffff0 },
	{ 0x0007c0f0, 0xfffffff0 },
	{ 0x0007c110, 0xfffffff0 },
	{ }
};

MODULE_DEVICE_TABLE(mdio, smsc_tbl);
Commit	Line	Data
c9e055ac HVR	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	*
90b24cfb	15	* Support added for SMSC LAN8187 and LAN8700 by steve.glendinning@shawell.net
4d9b1a02	16	*
c9e055ac HVR	17	*/
c9e055ac HVR	18
c9e055ac HVR	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>
43c6759e	25	#include <linux/smscphy.h>
c9e055ac	26
0a9c453e TR	27	struct smsc_phy_priv {
	28	bool energy_enable;
	29	};
	30
48c41b99	31	static int smsc_phy_config_intr(struct phy_device *phydev)
c9e055ac HVR	32	{
	33	int rc = phy_write (phydev, MII_LAN83C185_IM,
	34	((PHY_INTERRUPT_ENABLED == phydev->interrupts)
	35	? MII_LAN83C185_ISF_INT_PHYLIB_EVENTS
	36	: 0));
	37
	38	return rc < 0 ? rc : 0;
	39	}
	40
48c41b99	41	static int smsc_phy_ack_interrupt(struct phy_device *phydev)
c9e055ac HVR	42	{
	43	int rc = phy_read (phydev, MII_LAN83C185_ISF);
	44
	45	return rc < 0 ? rc : 0;
	46	}
	47
48c41b99	48	static int smsc_phy_config_init(struct phy_device *phydev)
21009686	49	{
0a9c453e TR	50	struct smsc_phy_priv *priv = phydev->priv;
0a9c453e TR	51
21009686 GGM	52	int rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);
	53
	54	if (rc < 0)
	55	return rc;
	56
0a9c453e	57	if (priv->energy_enable) {
d88ecb37 HS	58	/* Enable energy detect mode for this SMSC Transceivers */
	59	rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS,
	60	rc \| MII_LAN83C185_EDPWRDOWN);
	61	if (rc < 0)
	62	return rc;
	63	}
21009686 GGM	64
	65	return smsc_phy_ack_interrupt(phydev);
	66	}
	67
	68	static int smsc_phy_reset(struct phy_device *phydev)
c9e055ac	69	{
6ded7cd6	70	int rc = phy_read(phydev, MII_LAN83C185_SPECIAL_MODES);
	71	if (rc < 0)
	72	return rc;
	73
	74	/* If the SMSC PHY is in power down mode, then set it
	75	* in all capable mode before using it.
	76	*/
	77	if ((rc & MII_LAN83C185_MODE_MASK) == MII_LAN83C185_MODE_POWERDOWN) {
fc0f7e33	78	/* set "all capable" mode */
6ded7cd6	79	rc \|= MII_LAN83C185_MODE_ALL;
6ded7cd6	80	phy_write(phydev, MII_LAN83C185_SPECIAL_MODES, rc);
6ded7cd6	81	}
fc0f7e33 MS	82
	83	/* reset the phy */
	84	return genphy_soft_reset(phydev);
c9e055ac HVR	85	}
c9e055ac HVR	86
4223dbff	87	static int lan911x_config_init(struct phy_device *phydev)
b629820d	88	{
b629820d MV	89	return smsc_phy_ack_interrupt(phydev);
	90	}
	91
4223dbff	92	/*
776829de IP	93	* The LAN87xx suffers from rare absence of the ENERGYON-bit when Ethernet cable
	94	* plugs in while LAN87xx is in Energy Detect Power-Down mode. This leads to
	95	* unstable detection of plugging in Ethernet cable.
	96	* This workaround disables Energy Detect Power-Down mode and waiting for
	97	* response on link pulses to detect presence of plugged Ethernet cable.
	98	* The Energy Detect Power-Down mode is enabled again in the end of procedure to
	99	* save approximately 220 mW of power if cable is unplugged.
4223dbff PT	100	*/
4223dbff PT	101	static int lan87xx_read_status(struct phy_device *phydev)
698244ac	102	{
0a9c453e TR	103	struct smsc_phy_priv *priv = phydev->priv;
0a9c453e TR	104
4223dbff PT	105	int err = genphy_read_status(phydev);
4223dbff PT	106
0a9c453e TR	107	if (!phydev->link && priv->energy_enable) {
	108	int i;
	109
4223dbff PT	110	/* Disable EDPD to wake up PHY */
	111	int rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);
	112	if (rc < 0)
	113	return rc;
	114
	115	rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS,
	116	rc & ~MII_LAN83C185_EDPWRDOWN);
	117	if (rc < 0)
	118	return rc;
	119
776829de IP	120	/* Wait max 640 ms to detect energy */
	121	for (i = 0; i < 64; i++) {
	122	/* Sleep to allow link test pulses to be sent */
	123	msleep(10);
	124	rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);
	125	if (rc < 0)
	126	return rc;
	127	if (rc & MII_LAN83C185_ENERGYON)
	128	break;
ff94c742	129	}
4223dbff PT	130
	131	/* Re-enable EDPD */
	132	rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);
	133	if (rc < 0)
	134	return rc;
	135
	136	rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS,
	137	rc \| MII_LAN83C185_EDPWRDOWN);
	138	if (rc < 0)
	139	return rc;
	140	}
	141
	142	return err;
698244ac	143	}
c9e055ac	144
0a9c453e TR	145	static int smsc_phy_probe(struct phy_device *phydev)
	146	{
	147	struct device *dev = &phydev->mdio.dev;
	148	struct device_node *of_node = dev->of_node;
	149	struct smsc_phy_priv *priv;
	150
	151	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
	152	if (!priv)
	153	return -ENOMEM;
	154
	155	priv->energy_enable = true;
	156
	157	if (of_property_read_bool(of_node, "smsc,disable-energy-detect"))
	158	priv->energy_enable = false;
	159
	160	phydev->priv = priv;
	161
	162	return 0;
	163	}
	164
d5bf9071 CH	165	static struct phy_driver smsc_phy_driver[] = {
d5bf9071 CH	166	{
c9e055ac HVR	167	.phy_id = 0x0007c0a0, /* OUI=0x00800f, Model#=0x0a */
	168	.phy_id_mask = 0xfffffff0,
	169	.name = "SMSC LAN83C185",
	170
	171	.features = (PHY_BASIC_FEATURES \| SUPPORTED_Pause
	172	\| SUPPORTED_Asym_Pause),
	173	.flags = PHY_HAS_INTERRUPT \| PHY_HAS_MAGICANEG,
	174
0a9c453e TR	175	.probe = smsc_phy_probe,
0a9c453e TR	176
c9e055ac HVR	177	/* basic functions */
	178	.config_aneg = genphy_config_aneg,
	179	.read_status = genphy_read_status,
48c41b99	180	.config_init = smsc_phy_config_init,
21009686	181	.soft_reset = smsc_phy_reset,
c9e055ac HVR	182
c9e055ac HVR	183	/* IRQ related */
48c41b99 SG	184	.ack_interrupt = smsc_phy_ack_interrupt,
48c41b99 SG	185	.config_intr = smsc_phy_config_intr,
c9e055ac	186
c64d2a9a SG	187	.suspend = genphy_suspend,
c64d2a9a SG	188	.resume = genphy_resume,
d5bf9071	189	}, {
4d9b1a02 SG	190	.phy_id = 0x0007c0b0, /* OUI=0x00800f, Model#=0x0b */
	191	.phy_id_mask = 0xfffffff0,
	192	.name = "SMSC LAN8187",
	193
	194	.features = (PHY_BASIC_FEATURES \| SUPPORTED_Pause
	195	\| SUPPORTED_Asym_Pause),
	196	.flags = PHY_HAS_INTERRUPT \| PHY_HAS_MAGICANEG,
	197
0a9c453e TR	198	.probe = smsc_phy_probe,
0a9c453e TR	199
4d9b1a02 SG	200	/* basic functions */
	201	.config_aneg = genphy_config_aneg,
	202	.read_status = genphy_read_status,
	203	.config_init = smsc_phy_config_init,
21009686	204	.soft_reset = smsc_phy_reset,
4d9b1a02 SG	205
	206	/* IRQ related */
	207	.ack_interrupt = smsc_phy_ack_interrupt,
	208	.config_intr = smsc_phy_config_intr,
	209
c64d2a9a SG	210	.suspend = genphy_suspend,
c64d2a9a SG	211	.resume = genphy_resume,
d5bf9071	212	}, {
4d9b1a02 SG	213	.phy_id = 0x0007c0c0, /* OUI=0x00800f, Model#=0x0c */
	214	.phy_id_mask = 0xfffffff0,
	215	.name = "SMSC LAN8700",
	216
	217	.features = (PHY_BASIC_FEATURES \| SUPPORTED_Pause
	218	\| SUPPORTED_Asym_Pause),
	219	.flags = PHY_HAS_INTERRUPT \| PHY_HAS_MAGICANEG,
	220
0a9c453e TR	221	.probe = smsc_phy_probe,
0a9c453e TR	222
4d9b1a02 SG	223	/* basic functions */
4d9b1a02 SG	224	.config_aneg = genphy_config_aneg,
776829de	225	.read_status = lan87xx_read_status,
4d9b1a02	226	.config_init = smsc_phy_config_init,
21009686	227	.soft_reset = smsc_phy_reset,
4d9b1a02 SG	228
	229	/* IRQ related */
	230	.ack_interrupt = smsc_phy_ack_interrupt,
	231	.config_intr = smsc_phy_config_intr,
	232
c64d2a9a SG	233	.suspend = genphy_suspend,
c64d2a9a SG	234	.resume = genphy_resume,
d5bf9071	235	}, {
fd9abb3d SG	236	.phy_id = 0x0007c0d0, /* OUI=0x00800f, Model#=0x0d */
	237	.phy_id_mask = 0xfffffff0,
	238	.name = "SMSC LAN911x Internal PHY",
	239
	240	.features = (PHY_BASIC_FEATURES \| SUPPORTED_Pause
	241	\| SUPPORTED_Asym_Pause),
	242	.flags = PHY_HAS_INTERRUPT \| PHY_HAS_MAGICANEG,
	243
0a9c453e TR	244	.probe = smsc_phy_probe,
0a9c453e TR	245
fd9abb3d SG	246	/* basic functions */
	247	.config_aneg = genphy_config_aneg,
	248	.read_status = genphy_read_status,
698244ac	249	.config_init = lan911x_config_init,
fd9abb3d SG	250
	251	/* IRQ related */
	252	.ack_interrupt = smsc_phy_ack_interrupt,
	253	.config_intr = smsc_phy_config_intr,
	254
c64d2a9a SG	255	.suspend = genphy_suspend,
c64d2a9a SG	256	.resume = genphy_resume,
d5bf9071	257	}, {
e072b639 SG	258	.phy_id = 0x0007c0f0, /* OUI=0x00800f, Model#=0x0f */
	259	.phy_id_mask = 0xfffffff0,
	260	.name = "SMSC LAN8710/LAN8720",
	261
	262	.features = (PHY_BASIC_FEATURES \| SUPPORTED_Pause
	263	\| SUPPORTED_Asym_Pause),
	264	.flags = PHY_HAS_INTERRUPT \| PHY_HAS_MAGICANEG,
	265
0a9c453e TR	266	.probe = smsc_phy_probe,
0a9c453e TR	267
e072b639 SG	268	/* basic functions */
e072b639 SG	269	.config_aneg = genphy_config_aneg,
4223dbff	270	.read_status = lan87xx_read_status,
4257d583	271	.config_init = smsc_phy_config_init,
21009686	272	.soft_reset = smsc_phy_reset,
e072b639 SG	273
	274	/* IRQ related */
	275	.ack_interrupt = smsc_phy_ack_interrupt,
	276	.config_intr = smsc_phy_config_intr,
	277
26706d43 JH	278	.suspend = genphy_suspend,
	279	.resume = genphy_resume,
	280	}, {
	281	.phy_id = 0x0007c110,
	282	.phy_id_mask = 0xfffffff0,
	283	.name = "SMSC LAN8740",
	284
	285	.features = (PHY_BASIC_FEATURES \| SUPPORTED_Pause
	286	\| SUPPORTED_Asym_Pause),
	287	.flags = PHY_HAS_INTERRUPT \| PHY_HAS_MAGICANEG,
	288
0a9c453e TR	289	.probe = smsc_phy_probe,
0a9c453e TR	290
26706d43 JH	291	/* basic functions */
	292	.config_aneg = genphy_config_aneg,
	293	.read_status = lan87xx_read_status,
	294	.config_init = smsc_phy_config_init,
	295	.soft_reset = smsc_phy_reset,
	296
	297	/* IRQ related */
	298	.ack_interrupt = smsc_phy_ack_interrupt,
	299	.config_intr = smsc_phy_config_intr,
	300
e072b639 SG	301	.suspend = genphy_suspend,
e072b639 SG	302	.resume = genphy_resume,
d5bf9071	303	} };
e072b639	304
50fd7150	305	module_phy_driver(smsc_phy_driver);
c9e055ac HVR	306
	307	MODULE_DESCRIPTION("SMSC PHY driver");
	308	MODULE_AUTHOR("Herbert Valerio Riedel");
	309	MODULE_LICENSE("GPL");
	310
cf93c945	311	static struct mdio_device_id __maybe_unused smsc_tbl[] = {
4e4f10f6 DW	312	{ 0x0007c0a0, 0xfffffff0 },
	313	{ 0x0007c0b0, 0xfffffff0 },
	314	{ 0x0007c0c0, 0xfffffff0 },
	315	{ 0x0007c0d0, 0xfffffff0 },
	316	{ 0x0007c0f0, 0xfffffff0 },
26706d43	317	{ 0x0007c110, 0xfffffff0 },
4e4f10f6 DW	318	{ }
	319	};
	320
	321	MODULE_DEVICE_TABLE(mdio, smsc_tbl);