[mirror_ubuntu-zesty-kernel.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) {
		int timeout = 50000;

		/* set "all capable" mode and reset the phy */
		rc |= MII_LAN83C185_MODE_ALL;
		phy_write(phydev, MII_LAN83C185_SPECIAL_MODES, rc);
		phy_write(phydev, MII_BMCR, BMCR_RESET);

		/* wait end of reset (max 500 ms) */
		do {
			udelay(10);
			if (timeout-- == 0)
				return -1;
			rc = phy_read(phydev, MII_BMCR);
		} while (rc & BMCR_RESET);
	}
	return 0;
}

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