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