blob: 39794c4d7b21b78cf21166d13f5d89133850d12e [file] [log] [blame]
Sergei Shtylyov2f53e902014-01-05 03:17:06 +03001/* Framework for finding and configuring PHYs.
Andy Fleming00db8182005-07-30 19:31:23 -04002 * Also contains generic PHY driver
3 *
4 * Author: Andy Fleming
5 *
6 * Copyright (c) 2004 Freescale Semiconductor, Inc.
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
Joe Perches8d242482012-06-09 07:49:07 +000014
15#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16
Andy Fleming00db8182005-07-30 19:31:23 -040017#include <linux/kernel.h>
Andy Fleming00db8182005-07-30 19:31:23 -040018#include <linux/string.h>
19#include <linux/errno.h>
20#include <linux/unistd.h>
21#include <linux/slab.h>
22#include <linux/interrupt.h>
23#include <linux/init.h>
24#include <linux/delay.h>
25#include <linux/netdevice.h>
26#include <linux/etherdevice.h>
27#include <linux/skbuff.h>
Andy Fleming00db8182005-07-30 19:31:23 -040028#include <linux/mm.h>
29#include <linux/module.h>
Andy Fleming00db8182005-07-30 19:31:23 -040030#include <linux/mii.h>
31#include <linux/ethtool.h>
32#include <linux/phy.h>
Andy Fleming124059f2014-01-10 14:27:37 +080033#include <linux/mdio.h>
Sergei Shtylyov2f53e902014-01-05 03:17:06 +030034#include <linux/io.h>
35#include <linux/uaccess.h>
Andy Fleming00db8182005-07-30 19:31:23 -040036
Andy Fleming00db8182005-07-30 19:31:23 -040037#include <asm/irq.h>
Andy Fleming00db8182005-07-30 19:31:23 -040038
Olaf Heringafcceaa2005-12-14 00:33:49 +010039MODULE_DESCRIPTION("PHY library");
40MODULE_AUTHOR("Andy Fleming");
41MODULE_LICENSE("GPL");
42
Anton Vorontsov6f4a7f42007-12-04 16:17:33 +030043void phy_device_free(struct phy_device *phydev)
44{
Petr Malatb2a43192013-02-28 01:01:52 +000045 put_device(&phydev->dev);
Anton Vorontsov6f4a7f42007-12-04 16:17:33 +030046}
Grant Likely4dea5472009-04-25 12:52:46 +000047EXPORT_SYMBOL(phy_device_free);
Anton Vorontsov6f4a7f42007-12-04 16:17:33 +030048
49static void phy_device_release(struct device *dev)
50{
Petr Malatb2a43192013-02-28 01:01:52 +000051 kfree(to_phy_device(dev));
Anton Vorontsov6f4a7f42007-12-04 16:17:33 +030052}
53
Shaohui Xieab2145e2014-01-10 14:27:22 +080054enum genphy_driver {
55 GENPHY_DRV_1G,
Andy Fleming124059f2014-01-10 14:27:37 +080056 GENPHY_DRV_10G,
Shaohui Xieab2145e2014-01-10 14:27:22 +080057 GENPHY_DRV_MAX
58};
59
60static struct phy_driver genphy_driver[GENPHY_DRV_MAX];
Grant Likely4dea5472009-04-25 12:52:46 +000061
Andy Flemingf62220d2008-04-18 17:29:54 -050062static LIST_HEAD(phy_fixup_list);
63static DEFINE_MUTEX(phy_fixup_lock);
64
Sergei Shtylyov2f53e902014-01-05 03:17:06 +030065/**
66 * phy_register_fixup - creates a new phy_fixup and adds it to the list
Andy Flemingf62220d2008-04-18 17:29:54 -050067 * @bus_id: A string which matches phydev->dev.bus_id (or PHY_ANY_ID)
68 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
Sergei Shtylyov2f53e902014-01-05 03:17:06 +030069 * It can also be PHY_ANY_UID
Andy Flemingf62220d2008-04-18 17:29:54 -050070 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
Sergei Shtylyov2f53e902014-01-05 03:17:06 +030071 * comparison
Andy Flemingf62220d2008-04-18 17:29:54 -050072 * @run: The actual code to be run when a matching PHY is found
73 */
74int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
Sergei Shtylyov2f53e902014-01-05 03:17:06 +030075 int (*run)(struct phy_device *))
Andy Flemingf62220d2008-04-18 17:29:54 -050076{
Sergei Shtylyov553fe922014-01-05 03:23:19 +030077 struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL);
Andy Flemingf62220d2008-04-18 17:29:54 -050078
Andy Flemingf62220d2008-04-18 17:29:54 -050079 if (!fixup)
80 return -ENOMEM;
81
Kay Sieversfb28ad32008-11-10 13:55:14 -080082 strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
Andy Flemingf62220d2008-04-18 17:29:54 -050083 fixup->phy_uid = phy_uid;
84 fixup->phy_uid_mask = phy_uid_mask;
85 fixup->run = run;
86
87 mutex_lock(&phy_fixup_lock);
88 list_add_tail(&fixup->list, &phy_fixup_list);
89 mutex_unlock(&phy_fixup_lock);
90
91 return 0;
92}
93EXPORT_SYMBOL(phy_register_fixup);
94
95/* Registers a fixup to be run on any PHY with the UID in phy_uid */
96int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
Sergei Shtylyov2f53e902014-01-05 03:17:06 +030097 int (*run)(struct phy_device *))
Andy Flemingf62220d2008-04-18 17:29:54 -050098{
99 return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
100}
101EXPORT_SYMBOL(phy_register_fixup_for_uid);
102
103/* Registers a fixup to be run on the PHY with id string bus_id */
104int phy_register_fixup_for_id(const char *bus_id,
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300105 int (*run)(struct phy_device *))
Andy Flemingf62220d2008-04-18 17:29:54 -0500106{
107 return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
108}
109EXPORT_SYMBOL(phy_register_fixup_for_id);
110
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300111/* Returns 1 if fixup matches phydev in bus_id and phy_uid.
Andy Flemingf62220d2008-04-18 17:29:54 -0500112 * Fixups can be set to match any in one or more fields.
113 */
114static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
115{
Kay Sieversfb28ad32008-11-10 13:55:14 -0800116 if (strcmp(fixup->bus_id, dev_name(&phydev->dev)) != 0)
Andy Flemingf62220d2008-04-18 17:29:54 -0500117 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
118 return 0;
119
120 if ((fixup->phy_uid & fixup->phy_uid_mask) !=
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300121 (phydev->phy_id & fixup->phy_uid_mask))
Andy Flemingf62220d2008-04-18 17:29:54 -0500122 if (fixup->phy_uid != PHY_ANY_UID)
123 return 0;
124
125 return 1;
126}
127
128/* Runs any matching fixups for this phydev */
Sergei Shtylyovfbfcec62014-01-05 03:28:27 +0300129static int phy_scan_fixups(struct phy_device *phydev)
Andy Flemingf62220d2008-04-18 17:29:54 -0500130{
131 struct phy_fixup *fixup;
132
133 mutex_lock(&phy_fixup_lock);
134 list_for_each_entry(fixup, &phy_fixup_list, list) {
135 if (phy_needs_fixup(phydev, fixup)) {
Sergei Shtylyov553fe922014-01-05 03:23:19 +0300136 int err = fixup->run(phydev);
Andy Flemingf62220d2008-04-18 17:29:54 -0500137
Jiri Slabybc232832009-07-13 11:23:39 +0000138 if (err < 0) {
139 mutex_unlock(&phy_fixup_lock);
Andy Flemingf62220d2008-04-18 17:29:54 -0500140 return err;
Jiri Slabybc232832009-07-13 11:23:39 +0000141 }
Andy Flemingf62220d2008-04-18 17:29:54 -0500142 }
143 }
144 mutex_unlock(&phy_fixup_lock);
145
146 return 0;
147}
Andy Flemingf62220d2008-04-18 17:29:54 -0500148
David Daneyac28b9f2012-06-27 07:33:35 +0000149struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300150 bool is_c45,
151 struct phy_c45_device_ids *c45_ids)
Vitaly Bordug11b0bac2006-08-14 23:00:29 -0700152{
153 struct phy_device *dev;
David Woodhouse8626d3b2010-04-02 01:05:27 +0000154
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300155 /* We allocate the device, and initialize the default values */
Robert P. J. Daycd861282006-12-13 00:34:52 -0800156 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
Vitaly Bordug11b0bac2006-08-14 23:00:29 -0700157 if (NULL == dev)
Florian Fainellie1093742013-12-17 21:38:12 -0800158 return (struct phy_device *)PTR_ERR((void *)-ENOMEM);
Vitaly Bordug11b0bac2006-08-14 23:00:29 -0700159
Anton Vorontsov6f4a7f42007-12-04 16:17:33 +0300160 dev->dev.release = phy_device_release;
161
Vitaly Bordug11b0bac2006-08-14 23:00:29 -0700162 dev->speed = 0;
163 dev->duplex = -1;
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300164 dev->pause = 0;
165 dev->asym_pause = 0;
Vitaly Bordug11b0bac2006-08-14 23:00:29 -0700166 dev->link = 1;
Andy Fleminge8a2b6a2006-12-01 12:01:06 -0600167 dev->interface = PHY_INTERFACE_MODE_GMII;
Vitaly Bordug11b0bac2006-08-14 23:00:29 -0700168
169 dev->autoneg = AUTONEG_ENABLE;
170
David Daneyac28b9f2012-06-27 07:33:35 +0000171 dev->is_c45 = is_c45;
Vitaly Bordug11b0bac2006-08-14 23:00:29 -0700172 dev->addr = addr;
173 dev->phy_id = phy_id;
David Daneyac28b9f2012-06-27 07:33:35 +0000174 if (c45_ids)
175 dev->c45_ids = *c45_ids;
Vitaly Bordug11b0bac2006-08-14 23:00:29 -0700176 dev->bus = bus;
Grant Likely4dea5472009-04-25 12:52:46 +0000177 dev->dev.parent = bus->parent;
178 dev->dev.bus = &mdio_bus_type;
179 dev->irq = bus->irq != NULL ? bus->irq[addr] : PHY_POLL;
180 dev_set_name(&dev->dev, PHY_ID_FMT, bus->id, addr);
Vitaly Bordug11b0bac2006-08-14 23:00:29 -0700181
182 dev->state = PHY_DOWN;
183
Nate Case35b5f6b2008-01-29 10:05:09 -0600184 mutex_init(&dev->lock);
Anton Vorontsov4f9c85a2010-01-18 05:37:16 +0000185 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
Florian Fainelli5ea94e72013-05-19 22:53:43 +0000186 INIT_WORK(&dev->phy_queue, phy_change);
Vitaly Bordug11b0bac2006-08-14 23:00:29 -0700187
David Woodhouse8626d3b2010-04-02 01:05:27 +0000188 /* Request the appropriate module unconditionally; don't
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300189 * bother trying to do so only if it isn't already loaded,
190 * because that gets complicated. A hotplug event would have
191 * done an unconditional modprobe anyway.
192 * We don't do normal hotplug because it won't work for MDIO
193 * -- because it relies on the device staying around for long
194 * enough for the driver to get loaded. With MDIO, the NIC
195 * driver will get bored and give up as soon as it finds that
196 * there's no driver _already_ loaded.
197 */
David Woodhouse8626d3b2010-04-02 01:05:27 +0000198 request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, MDIO_ID_ARGS(phy_id));
199
Petr Malatb2a43192013-02-28 01:01:52 +0000200 device_initialize(&dev->dev);
201
Vitaly Bordug11b0bac2006-08-14 23:00:29 -0700202 return dev;
203}
David Daneyac28b9f2012-06-27 07:33:35 +0000204EXPORT_SYMBOL(phy_device_create);
205
206/**
207 * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.
208 * @bus: the target MII bus
209 * @addr: PHY address on the MII bus
210 * @phy_id: where to store the ID retrieved.
211 * @c45_ids: where to store the c45 ID information.
212 *
213 * If the PHY devices-in-package appears to be valid, it and the
214 * corresponding identifiers are stored in @c45_ids, zero is stored
215 * in @phy_id. Otherwise 0xffffffff is stored in @phy_id. Returns
216 * zero on success.
217 *
218 */
219static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id,
220 struct phy_c45_device_ids *c45_ids) {
221 int phy_reg;
222 int i, reg_addr;
223 const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
224
225 /* Find first non-zero Devices In package. Device
226 * zero is reserved, so don't probe it.
227 */
228 for (i = 1;
229 i < num_ids && c45_ids->devices_in_package == 0;
230 i++) {
231 reg_addr = MII_ADDR_C45 | i << 16 | 6;
232 phy_reg = mdiobus_read(bus, addr, reg_addr);
233 if (phy_reg < 0)
234 return -EIO;
235 c45_ids->devices_in_package = (phy_reg & 0xffff) << 16;
236
237 reg_addr = MII_ADDR_C45 | i << 16 | 5;
238 phy_reg = mdiobus_read(bus, addr, reg_addr);
239 if (phy_reg < 0)
240 return -EIO;
241 c45_ids->devices_in_package |= (phy_reg & 0xffff);
242
243 /* If mostly Fs, there is no device there,
244 * let's get out of here.
245 */
246 if ((c45_ids->devices_in_package & 0x1fffffff) == 0x1fffffff) {
247 *phy_id = 0xffffffff;
248 return 0;
249 }
250 }
251
252 /* Now probe Device Identifiers for each device present. */
253 for (i = 1; i < num_ids; i++) {
254 if (!(c45_ids->devices_in_package & (1 << i)))
255 continue;
256
257 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID1;
258 phy_reg = mdiobus_read(bus, addr, reg_addr);
259 if (phy_reg < 0)
260 return -EIO;
261 c45_ids->device_ids[i] = (phy_reg & 0xffff) << 16;
262
263 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID2;
264 phy_reg = mdiobus_read(bus, addr, reg_addr);
265 if (phy_reg < 0)
266 return -EIO;
267 c45_ids->device_ids[i] |= (phy_reg & 0xffff);
268 }
269 *phy_id = 0;
270 return 0;
271}
Vitaly Bordug11b0bac2006-08-14 23:00:29 -0700272
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800273/**
Paul Gortmakercac1f3c2008-04-15 12:49:21 -0400274 * get_phy_id - reads the specified addr for its ID.
275 * @bus: the target MII bus
276 * @addr: PHY address on the MII bus
277 * @phy_id: where to store the ID retrieved.
David Daneyac28b9f2012-06-27 07:33:35 +0000278 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
279 * @c45_ids: where to store the c45 ID information.
Paul Gortmakercac1f3c2008-04-15 12:49:21 -0400280 *
David Daneyac28b9f2012-06-27 07:33:35 +0000281 * Description: In the case of a 802.3-c22 PHY, reads the ID registers
282 * of the PHY at @addr on the @bus, stores it in @phy_id and returns
283 * zero on success.
284 *
285 * In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and
286 * its return value is in turn returned.
287 *
Paul Gortmakercac1f3c2008-04-15 12:49:21 -0400288 */
David Daneyac28b9f2012-06-27 07:33:35 +0000289static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id,
290 bool is_c45, struct phy_c45_device_ids *c45_ids)
Paul Gortmakercac1f3c2008-04-15 12:49:21 -0400291{
292 int phy_reg;
293
David Daneyac28b9f2012-06-27 07:33:35 +0000294 if (is_c45)
295 return get_phy_c45_ids(bus, addr, phy_id, c45_ids);
296
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300297 /* Grab the bits from PHYIR1, and put them in the upper half */
David Daney6fe32642011-09-30 11:51:22 +0000298 phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
Paul Gortmakercac1f3c2008-04-15 12:49:21 -0400299 if (phy_reg < 0)
300 return -EIO;
301
302 *phy_id = (phy_reg & 0xffff) << 16;
303
304 /* Grab the bits from PHYIR2, and put them in the lower half */
David Daney6fe32642011-09-30 11:51:22 +0000305 phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
Paul Gortmakercac1f3c2008-04-15 12:49:21 -0400306 if (phy_reg < 0)
307 return -EIO;
308
309 *phy_id |= (phy_reg & 0xffff);
310
311 return 0;
312}
313
314/**
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300315 * get_phy_device - reads the specified PHY device and returns its @phy_device
316 * struct
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800317 * @bus: the target MII bus
318 * @addr: PHY address on the MII bus
David Daneyac28b9f2012-06-27 07:33:35 +0000319 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
Andy Fleming00db8182005-07-30 19:31:23 -0400320 *
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800321 * Description: Reads the ID registers of the PHY at @addr on the
322 * @bus, then allocates and returns the phy_device to represent it.
Andy Fleming00db8182005-07-30 19:31:23 -0400323 */
David Daneyac28b9f2012-06-27 07:33:35 +0000324struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
Andy Fleming00db8182005-07-30 19:31:23 -0400325{
David Daneyac28b9f2012-06-27 07:33:35 +0000326 struct phy_c45_device_ids c45_ids = {0};
David S. Miller160c85f2012-06-27 21:28:14 -0700327 u32 phy_id = 0;
Paul Gortmakercac1f3c2008-04-15 12:49:21 -0400328 int r;
Andy Fleming00db8182005-07-30 19:31:23 -0400329
David Daneyac28b9f2012-06-27 07:33:35 +0000330 r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids);
Paul Gortmakercac1f3c2008-04-15 12:49:21 -0400331 if (r)
332 return ERR_PTR(r);
Andy Fleming00db8182005-07-30 19:31:23 -0400333
Giuseppe Cavallaro6436cbc2008-11-20 20:43:18 -0800334 /* If the phy_id is mostly Fs, there is no device there */
335 if ((phy_id & 0x1fffffff) == 0x1fffffff)
336 return NULL;
337
Sergei Shtylyove62a7682014-01-05 03:21:52 +0300338 return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);
Andy Fleming00db8182005-07-30 19:31:23 -0400339}
Grant Likely4dea5472009-04-25 12:52:46 +0000340EXPORT_SYMBOL(get_phy_device);
341
342/**
343 * phy_device_register - Register the phy device on the MDIO bus
Randy Dunlap1d4ac5d2009-06-16 16:56:33 +0000344 * @phydev: phy_device structure to be added to the MDIO bus
Grant Likely4dea5472009-04-25 12:52:46 +0000345 */
346int phy_device_register(struct phy_device *phydev)
347{
348 int err;
349
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300350 /* Don't register a phy if one is already registered at this address */
Grant Likely4dea5472009-04-25 12:52:46 +0000351 if (phydev->bus->phy_map[phydev->addr])
352 return -EINVAL;
353 phydev->bus->phy_map[phydev->addr] = phydev;
354
355 /* Run all of the fixups for this PHY */
Florian Fainelli87aa9f92013-12-06 13:01:34 -0800356 err = phy_init_hw(phydev);
357 if (err) {
358 pr_err("PHY %d failed to initialize\n", phydev->addr);
359 goto out;
360 }
Grant Likely4dea5472009-04-25 12:52:46 +0000361
Petr Malatb2a43192013-02-28 01:01:52 +0000362 err = device_add(&phydev->dev);
Grant Likely4dea5472009-04-25 12:52:46 +0000363 if (err) {
Petr Malatb2a43192013-02-28 01:01:52 +0000364 pr_err("PHY %d failed to add\n", phydev->addr);
Grant Likely4dea5472009-04-25 12:52:46 +0000365 goto out;
366 }
367
368 return 0;
369
370 out:
371 phydev->bus->phy_map[phydev->addr] = NULL;
372 return err;
373}
374EXPORT_SYMBOL(phy_device_register);
Andy Fleming00db8182005-07-30 19:31:23 -0400375
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800376/**
Jiri Pirkof8f76db2010-02-04 10:23:02 -0800377 * phy_find_first - finds the first PHY device on the bus
378 * @bus: the target MII bus
379 */
380struct phy_device *phy_find_first(struct mii_bus *bus)
381{
382 int addr;
383
384 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
385 if (bus->phy_map[addr])
386 return bus->phy_map[addr];
387 }
388 return NULL;
389}
390EXPORT_SYMBOL(phy_find_first);
391
392/**
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800393 * phy_prepare_link - prepares the PHY layer to monitor link status
394 * @phydev: target phy_device struct
395 * @handler: callback function for link status change notifications
Andy Fleming00db8182005-07-30 19:31:23 -0400396 *
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800397 * Description: Tells the PHY infrastructure to handle the
Andy Fleming00db8182005-07-30 19:31:23 -0400398 * gory details on monitoring link status (whether through
399 * polling or an interrupt), and to call back to the
400 * connected device driver when the link status changes.
401 * If you want to monitor your own link state, don't call
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800402 * this function.
403 */
stephen hemminger89ff05e2010-10-21 08:37:41 +0000404static void phy_prepare_link(struct phy_device *phydev,
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300405 void (*handler)(struct net_device *))
Andy Fleming00db8182005-07-30 19:31:23 -0400406{
407 phydev->adjust_link = handler;
408}
409
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800410/**
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000411 * phy_connect_direct - connect an ethernet device to a specific phy_device
412 * @dev: the network device to connect
413 * @phydev: the pointer to the phy device
414 * @handler: callback function for state change notifications
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000415 * @interface: PHY device's interface
416 */
417int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
Florian Fainellif9a8f832013-01-14 00:52:52 +0000418 void (*handler)(struct net_device *),
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000419 phy_interface_t interface)
420{
421 int rc;
422
Florian Fainellif9a8f832013-01-14 00:52:52 +0000423 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000424 if (rc)
425 return rc;
426
427 phy_prepare_link(phydev, handler);
Sergei Shtylyov29935ae2014-01-05 03:27:17 +0300428 phy_start_machine(phydev);
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000429 if (phydev->irq > 0)
430 phy_start_interrupts(phydev);
431
432 return 0;
433}
434EXPORT_SYMBOL(phy_connect_direct);
435
436/**
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800437 * phy_connect - connect an ethernet device to a PHY device
438 * @dev: the network device to connect
Randy Dunlap5d12b132008-04-28 10:58:22 -0700439 * @bus_id: the id string of the PHY device to connect
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800440 * @handler: callback function for state change notifications
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800441 * @interface: PHY device's interface
Andy Fleminge1393452005-08-24 18:46:21 -0500442 *
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800443 * Description: Convenience function for connecting ethernet
Andy Fleminge1393452005-08-24 18:46:21 -0500444 * devices to PHY devices. The default behavior is for
445 * the PHY infrastructure to handle everything, and only notify
446 * the connected driver when the link status changes. If you
447 * don't want, or can't use the provided functionality, you may
448 * choose to call only the subset of functions which provide
449 * the desired functionality.
450 */
Florian Fainellie1093742013-12-17 21:38:12 -0800451struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300452 void (*handler)(struct net_device *),
453 phy_interface_t interface)
Andy Fleminge1393452005-08-24 18:46:21 -0500454{
455 struct phy_device *phydev;
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000456 struct device *d;
457 int rc;
Andy Fleminge1393452005-08-24 18:46:21 -0500458
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000459 /* Search the list of PHY devices on the mdio bus for the
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300460 * PHY with the requested name
461 */
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000462 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
463 if (!d) {
464 pr_err("PHY %s not found\n", bus_id);
465 return ERR_PTR(-ENODEV);
466 }
467 phydev = to_phy_device(d);
Andy Fleminge1393452005-08-24 18:46:21 -0500468
Florian Fainellif9a8f832013-01-14 00:52:52 +0000469 rc = phy_connect_direct(dev, phydev, handler, interface);
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000470 if (rc)
471 return ERR_PTR(rc);
Andy Fleminge1393452005-08-24 18:46:21 -0500472
473 return phydev;
474}
475EXPORT_SYMBOL(phy_connect);
476
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800477/**
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300478 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY
479 * device
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800480 * @phydev: target phy_device struct
481 */
Andy Fleminge1393452005-08-24 18:46:21 -0500482void phy_disconnect(struct phy_device *phydev)
483{
484 if (phydev->irq > 0)
485 phy_stop_interrupts(phydev);
486
487 phy_stop_machine(phydev);
Florian Fainellie1093742013-12-17 21:38:12 -0800488
Andy Fleminge1393452005-08-24 18:46:21 -0500489 phydev->adjust_link = NULL;
490
491 phy_detach(phydev);
492}
493EXPORT_SYMBOL(phy_disconnect);
494
Florian Fainelli87aa9f92013-12-06 13:01:34 -0800495/**
496 * phy_poll_reset - Safely wait until a PHY reset has properly completed
497 * @phydev: The PHY device to poll
498 *
499 * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as
500 * published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR
501 * register must be polled until the BMCR_RESET bit clears.
502 *
503 * Furthermore, any attempts to write to PHY registers may have no effect
504 * or even generate MDIO bus errors until this is complete.
505 *
506 * Some PHYs (such as the Marvell 88E1111) don't entirely conform to the
507 * standard and do not fully reset after the BMCR_RESET bit is set, and may
508 * even *REQUIRE* a soft-reset to properly restart autonegotiation. In an
509 * effort to support such broken PHYs, this function is separate from the
510 * standard phy_init_hw() which will zero all the other bits in the BMCR
511 * and reapply all driver-specific and board-specific fixups.
512 */
513static int phy_poll_reset(struct phy_device *phydev)
514{
515 /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
516 unsigned int retries = 12;
517 int ret;
518
519 do {
520 msleep(50);
521 ret = phy_read(phydev, MII_BMCR);
522 if (ret < 0)
523 return ret;
524 } while (ret & BMCR_RESET && --retries);
525 if (ret & BMCR_RESET)
526 return -ETIMEDOUT;
527
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300528 /* Some chips (smsc911x) may still need up to another 1ms after the
Florian Fainelli87aa9f92013-12-06 13:01:34 -0800529 * BMCR_RESET bit is cleared before they are usable.
530 */
531 msleep(1);
532 return 0;
533}
534
Anton Vorontsov2f5cb432009-12-30 08:23:30 +0000535int phy_init_hw(struct phy_device *phydev)
536{
537 int ret;
538
539 if (!phydev->drv || !phydev->drv->config_init)
540 return 0;
541
Florian Fainelli87aa9f92013-12-06 13:01:34 -0800542 ret = phy_write(phydev, MII_BMCR, BMCR_RESET);
543 if (ret < 0)
544 return ret;
545
546 ret = phy_poll_reset(phydev);
547 if (ret < 0)
548 return ret;
549
Anton Vorontsov2f5cb432009-12-30 08:23:30 +0000550 ret = phy_scan_fixups(phydev);
551 if (ret < 0)
552 return ret;
553
554 return phydev->drv->config_init(phydev);
555}
Florian Fainelli87aa9f92013-12-06 13:01:34 -0800556EXPORT_SYMBOL(phy_init_hw);
Anton Vorontsov2f5cb432009-12-30 08:23:30 +0000557
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800558/**
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000559 * phy_attach_direct - attach a network device to a given PHY device pointer
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800560 * @dev: network device to attach
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000561 * @phydev: Pointer to phy_device to attach
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800562 * @flags: PHY device's dev_flags
563 * @interface: PHY device's interface
564 *
565 * Description: Called by drivers to attach to a particular PHY
566 * device. The phy_device is found, and properly hooked up
Andy Fleming257184d2014-01-10 14:27:54 +0800567 * to the phy_driver. If no driver is attached, then a
568 * generic driver is used. The phy_device is given a ptr to
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800569 * the attaching device, and given a callback for link status
570 * change. The phy_device is returned to the attaching driver.
571 */
Andy Fleming257184d2014-01-10 14:27:54 +0800572int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
573 u32 flags, phy_interface_t interface)
Andy Fleminge1393452005-08-24 18:46:21 -0500574{
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000575 struct device *d = &phydev->dev;
Marc Kleine-Budded005a092011-03-28 14:54:08 +0000576 int err;
Andy Fleminge1393452005-08-24 18:46:21 -0500577
578 /* Assume that if there is no driver, that it doesn't
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300579 * exist, and we should use the genphy driver.
580 */
Andy Fleminge1393452005-08-24 18:46:21 -0500581 if (NULL == d->driver) {
Andy Fleming257184d2014-01-10 14:27:54 +0800582 if (phydev->is_c45)
583 d->driver = &genphy_driver[GENPHY_DRV_10G].driver;
584 else
585 d->driver = &genphy_driver[GENPHY_DRV_1G].driver;
Andy Fleminge1393452005-08-24 18:46:21 -0500586
587 err = d->driver->probe(d);
Jeff Garzikb7a00ec2006-10-01 07:27:46 -0400588 if (err >= 0)
589 err = device_bind_driver(d);
Andy Fleminge1393452005-08-24 18:46:21 -0500590
Jeff Garzikb7a00ec2006-10-01 07:27:46 -0400591 if (err)
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000592 return err;
Andy Fleminge1393452005-08-24 18:46:21 -0500593 }
594
595 if (phydev->attached_dev) {
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000596 dev_err(&dev->dev, "PHY already attached\n");
597 return -EBUSY;
Andy Fleminge1393452005-08-24 18:46:21 -0500598 }
599
600 phydev->attached_dev = dev;
Richard Cochranc1f19b52010-07-17 08:49:36 +0000601 dev->phydev = phydev;
Andy Fleminge1393452005-08-24 18:46:21 -0500602
603 phydev->dev_flags = flags;
604
Andy Fleminge8a2b6a2006-12-01 12:01:06 -0600605 phydev->interface = interface;
606
Anton Vorontsovef24b162010-08-24 14:46:12 -0700607 phydev->state = PHY_READY;
608
Andy Fleminge8a2b6a2006-12-01 12:01:06 -0600609 /* Do initial configuration here, now that
610 * we have certain key parameters
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300611 * (dev_flags and interface)
612 */
Marc Kleine-Budded005a092011-03-28 14:54:08 +0000613 err = phy_init_hw(phydev);
614 if (err)
615 phy_detach(phydev);
616
Sebastian Hesselbarth1211ce52013-12-13 10:20:28 +0100617 phy_resume(phydev);
618
Marc Kleine-Budded005a092011-03-28 14:54:08 +0000619 return err;
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000620}
Andy Fleming257184d2014-01-10 14:27:54 +0800621EXPORT_SYMBOL(phy_attach_direct);
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000622
623/**
624 * phy_attach - attach a network device to a particular PHY device
625 * @dev: network device to attach
626 * @bus_id: Bus ID of PHY device to attach
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000627 * @interface: PHY device's interface
628 *
629 * Description: Same as phy_attach_direct() except that a PHY bus_id
630 * string is passed instead of a pointer to a struct phy_device.
631 */
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300632struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
633 phy_interface_t interface)
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000634{
635 struct bus_type *bus = &mdio_bus_type;
636 struct phy_device *phydev;
637 struct device *d;
638 int rc;
639
640 /* Search the list of PHY devices on the mdio bus for the
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300641 * PHY with the requested name
642 */
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000643 d = bus_find_device_by_name(bus, NULL, bus_id);
644 if (!d) {
645 pr_err("PHY %s not found\n", bus_id);
646 return ERR_PTR(-ENODEV);
647 }
648 phydev = to_phy_device(d);
649
Florian Fainellif9a8f832013-01-14 00:52:52 +0000650 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000651 if (rc)
652 return ERR_PTR(rc);
653
Andy Fleminge1393452005-08-24 18:46:21 -0500654 return phydev;
655}
656EXPORT_SYMBOL(phy_attach);
657
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800658/**
659 * phy_detach - detach a PHY device from its network device
660 * @phydev: target phy_device struct
661 */
Andy Fleminge1393452005-08-24 18:46:21 -0500662void phy_detach(struct phy_device *phydev)
663{
Shaohui Xieab2145e2014-01-10 14:27:22 +0800664 int i;
Richard Cochranc1f19b52010-07-17 08:49:36 +0000665 phydev->attached_dev->phydev = NULL;
Andy Fleminge1393452005-08-24 18:46:21 -0500666 phydev->attached_dev = NULL;
Sebastian Hesselbarth1211ce52013-12-13 10:20:28 +0100667 phy_suspend(phydev);
Andy Fleminge1393452005-08-24 18:46:21 -0500668
669 /* If the device had no specific driver before (i.e. - it
670 * was using the generic driver), we unbind the device
671 * from the generic driver so that there's a chance a
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300672 * real driver could be loaded
673 */
Shaohui Xieab2145e2014-01-10 14:27:22 +0800674 for (i = 0; i < ARRAY_SIZE(genphy_driver); i++) {
675 if (phydev->dev.driver == &genphy_driver[i].driver) {
676 device_release_driver(&phydev->dev);
677 break;
678 }
679 }
Andy Fleminge1393452005-08-24 18:46:21 -0500680}
681EXPORT_SYMBOL(phy_detach);
682
Sebastian Hesselbarth481b5d92013-12-13 10:20:27 +0100683int phy_suspend(struct phy_device *phydev)
684{
685 struct phy_driver *phydrv = to_phy_driver(phydev->dev.driver);
686 struct ethtool_wolinfo wol;
687
688 /* If the device has WOL enabled, we cannot suspend the PHY */
689 wol.cmd = ETHTOOL_GWOL;
690 phy_ethtool_get_wol(phydev, &wol);
691 if (wol.wolopts)
692 return -EBUSY;
693
694 if (phydrv->suspend)
695 return phydrv->suspend(phydev);
696 return 0;
697}
698
699int phy_resume(struct phy_device *phydev)
700{
701 struct phy_driver *phydrv = to_phy_driver(phydev->dev.driver);
702
703 if (phydrv->resume)
704 return phydrv->resume(phydev);
705 return 0;
706}
Andy Fleminge1393452005-08-24 18:46:21 -0500707
Andy Fleming00db8182005-07-30 19:31:23 -0400708/* Generic PHY support and helper functions */
709
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800710/**
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300711 * genphy_config_advert - sanitize and advertise auto-negotiation parameters
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800712 * @phydev: target phy_device struct
Andy Fleming00db8182005-07-30 19:31:23 -0400713 *
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800714 * Description: Writes MII_ADVERTISE with the appropriate values,
Andy Fleming00db8182005-07-30 19:31:23 -0400715 * after sanitizing the values to make sure we only advertise
Trent Piepho51e2a382008-09-24 10:55:46 +0000716 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
717 * hasn't changed, and > 0 if it has changed.
Andy Fleming00db8182005-07-30 19:31:23 -0400718 */
stephen hemminger89ff05e2010-10-21 08:37:41 +0000719static int genphy_config_advert(struct phy_device *phydev)
Andy Fleming00db8182005-07-30 19:31:23 -0400720{
721 u32 advertise;
Trent Piepho51e2a382008-09-24 10:55:46 +0000722 int oldadv, adv;
723 int err, changed = 0;
Andy Fleming00db8182005-07-30 19:31:23 -0400724
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300725 /* Only allow advertising what this PHY supports */
Andy Fleming00db8182005-07-30 19:31:23 -0400726 phydev->advertising &= phydev->supported;
727 advertise = phydev->advertising;
728
729 /* Setup standard advertisement */
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300730 adv = phy_read(phydev, MII_ADVERTISE);
Andy Fleming00db8182005-07-30 19:31:23 -0400731 if (adv < 0)
732 return adv;
733
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300734 oldadv = adv;
Matt Carlson28011cf2011-11-16 18:36:59 -0500735 adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP |
Andy Fleming00db8182005-07-30 19:31:23 -0400736 ADVERTISE_PAUSE_ASYM);
Matt Carlson37f07022011-11-17 14:30:55 +0000737 adv |= ethtool_adv_to_mii_adv_t(advertise);
Andy Fleming00db8182005-07-30 19:31:23 -0400738
Trent Piepho51e2a382008-09-24 10:55:46 +0000739 if (adv != oldadv) {
740 err = phy_write(phydev, MII_ADVERTISE, adv);
Andy Fleming00db8182005-07-30 19:31:23 -0400741
Trent Piepho51e2a382008-09-24 10:55:46 +0000742 if (err < 0)
743 return err;
744 changed = 1;
745 }
Andy Fleming00db8182005-07-30 19:31:23 -0400746
747 /* Configure gigabit if it's supported */
748 if (phydev->supported & (SUPPORTED_1000baseT_Half |
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300749 SUPPORTED_1000baseT_Full)) {
750 adv = phy_read(phydev, MII_CTRL1000);
Andy Fleming00db8182005-07-30 19:31:23 -0400751 if (adv < 0)
752 return adv;
753
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300754 oldadv = adv;
Andy Fleming00db8182005-07-30 19:31:23 -0400755 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
Matt Carlson37f07022011-11-17 14:30:55 +0000756 adv |= ethtool_adv_to_mii_ctrl1000_t(advertise);
Andy Fleming00db8182005-07-30 19:31:23 -0400757
Trent Piepho51e2a382008-09-24 10:55:46 +0000758 if (adv != oldadv) {
759 err = phy_write(phydev, MII_CTRL1000, adv);
760
761 if (err < 0)
762 return err;
763 changed = 1;
764 }
Andy Fleming00db8182005-07-30 19:31:23 -0400765 }
766
Trent Piepho51e2a382008-09-24 10:55:46 +0000767 return changed;
Andy Fleming00db8182005-07-30 19:31:23 -0400768}
Andy Fleming00db8182005-07-30 19:31:23 -0400769
Andy Fleming124059f2014-01-10 14:27:37 +0800770int gen10g_config_advert(struct phy_device *dev)
771{
772 return 0;
773}
774EXPORT_SYMBOL(gen10g_config_advert);
775
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800776/**
777 * genphy_setup_forced - configures/forces speed/duplex from @phydev
778 * @phydev: target phy_device struct
Andy Fleming00db8182005-07-30 19:31:23 -0400779 *
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800780 * Description: Configures MII_BMCR to force speed/duplex
Andy Fleming00db8182005-07-30 19:31:23 -0400781 * to the values in phydev. Assumes that the values are valid.
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800782 * Please see phy_sanitize_settings().
783 */
Madalin Bucur3fb69bc2013-11-20 16:38:19 -0600784int genphy_setup_forced(struct phy_device *phydev)
Andy Fleming00db8182005-07-30 19:31:23 -0400785{
Domen Puncerbc1e0a02007-08-17 08:54:45 +0200786 int ctl = 0;
Andy Fleming00db8182005-07-30 19:31:23 -0400787
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300788 phydev->pause = 0;
789 phydev->asym_pause = 0;
Andy Fleming00db8182005-07-30 19:31:23 -0400790
791 if (SPEED_1000 == phydev->speed)
792 ctl |= BMCR_SPEED1000;
793 else if (SPEED_100 == phydev->speed)
794 ctl |= BMCR_SPEED100;
795
796 if (DUPLEX_FULL == phydev->duplex)
797 ctl |= BMCR_FULLDPLX;
Florian Fainellie1093742013-12-17 21:38:12 -0800798
Sergei Shtylyove62a7682014-01-05 03:21:52 +0300799 return phy_write(phydev, MII_BMCR, ctl);
Andy Fleming00db8182005-07-30 19:31:23 -0400800}
Madalin Bucur3fb69bc2013-11-20 16:38:19 -0600801EXPORT_SYMBOL(genphy_setup_forced);
Andy Fleming00db8182005-07-30 19:31:23 -0400802
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800803/**
804 * genphy_restart_aneg - Enable and Restart Autonegotiation
805 * @phydev: target phy_device struct
806 */
Andy Fleming00db8182005-07-30 19:31:23 -0400807int genphy_restart_aneg(struct phy_device *phydev)
808{
Sergei Shtylyov553fe922014-01-05 03:23:19 +0300809 int ctl = phy_read(phydev, MII_BMCR);
Andy Fleming00db8182005-07-30 19:31:23 -0400810
811 if (ctl < 0)
812 return ctl;
813
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300814 ctl |= BMCR_ANENABLE | BMCR_ANRESTART;
Andy Fleming00db8182005-07-30 19:31:23 -0400815
816 /* Don't isolate the PHY if we're negotiating */
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300817 ctl &= ~BMCR_ISOLATE;
Andy Fleming00db8182005-07-30 19:31:23 -0400818
Sergei Shtylyov553fe922014-01-05 03:23:19 +0300819 return phy_write(phydev, MII_BMCR, ctl);
Andy Fleming00db8182005-07-30 19:31:23 -0400820}
Adrian Bunk892871d2008-10-13 18:48:09 -0700821EXPORT_SYMBOL(genphy_restart_aneg);
Andy Fleming00db8182005-07-30 19:31:23 -0400822
Andy Fleming124059f2014-01-10 14:27:37 +0800823int gen10g_restart_aneg(struct phy_device *phydev)
824{
825 return 0;
826}
827EXPORT_SYMBOL(gen10g_restart_aneg);
828
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800829/**
830 * genphy_config_aneg - restart auto-negotiation or write BMCR
831 * @phydev: target phy_device struct
Andy Fleming00db8182005-07-30 19:31:23 -0400832 *
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800833 * Description: If auto-negotiation is enabled, we configure the
Andy Fleming00db8182005-07-30 19:31:23 -0400834 * advertising, and then restart auto-negotiation. If it is not
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800835 * enabled, then we write the BMCR.
Andy Fleming00db8182005-07-30 19:31:23 -0400836 */
837int genphy_config_aneg(struct phy_device *phydev)
838{
Trent Piephode339c22008-11-19 15:52:41 -0800839 int result;
Andy Fleming00db8182005-07-30 19:31:23 -0400840
Trent Piephode339c22008-11-19 15:52:41 -0800841 if (AUTONEG_ENABLE != phydev->autoneg)
842 return genphy_setup_forced(phydev);
Andy Fleming00db8182005-07-30 19:31:23 -0400843
Trent Piephode339c22008-11-19 15:52:41 -0800844 result = genphy_config_advert(phydev);
Trent Piephode339c22008-11-19 15:52:41 -0800845 if (result < 0) /* error */
846 return result;
Trent Piephode339c22008-11-19 15:52:41 -0800847 if (result == 0) {
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300848 /* Advertisement hasn't changed, but maybe aneg was never on to
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300849 * begin with? Or maybe phy was isolated?
850 */
Trent Piephode339c22008-11-19 15:52:41 -0800851 int ctl = phy_read(phydev, MII_BMCR);
852
853 if (ctl < 0)
854 return ctl;
855
856 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
857 result = 1; /* do restart aneg */
858 }
859
860 /* Only restart aneg if we are advertising something different
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300861 * than we were before.
862 */
Trent Piephode339c22008-11-19 15:52:41 -0800863 if (result > 0)
864 result = genphy_restart_aneg(phydev);
Andy Fleming00db8182005-07-30 19:31:23 -0400865
Trent Piepho51e2a382008-09-24 10:55:46 +0000866 return result;
Andy Fleming00db8182005-07-30 19:31:23 -0400867}
868EXPORT_SYMBOL(genphy_config_aneg);
869
Andy Fleming124059f2014-01-10 14:27:37 +0800870int gen10g_config_aneg(struct phy_device *phydev)
871{
872 return 0;
873}
874EXPORT_SYMBOL(gen10g_config_aneg);
875
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800876/**
877 * genphy_update_link - update link status in @phydev
878 * @phydev: target phy_device struct
Andy Fleming00db8182005-07-30 19:31:23 -0400879 *
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800880 * Description: Update the value in phydev->link to reflect the
Andy Fleming00db8182005-07-30 19:31:23 -0400881 * current link value. In order to do this, we need to read
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800882 * the status register twice, keeping the second value.
Andy Fleming00db8182005-07-30 19:31:23 -0400883 */
884int genphy_update_link(struct phy_device *phydev)
885{
886 int status;
887
888 /* Do a fake read */
889 status = phy_read(phydev, MII_BMSR);
Andy Fleming00db8182005-07-30 19:31:23 -0400890 if (status < 0)
891 return status;
892
893 /* Read link and autonegotiation status */
894 status = phy_read(phydev, MII_BMSR);
Andy Fleming00db8182005-07-30 19:31:23 -0400895 if (status < 0)
896 return status;
897
898 if ((status & BMSR_LSTATUS) == 0)
899 phydev->link = 0;
900 else
901 phydev->link = 1;
902
903 return 0;
904}
Andy Fleming6b655522006-10-16 16:19:17 -0500905EXPORT_SYMBOL(genphy_update_link);
Andy Fleming00db8182005-07-30 19:31:23 -0400906
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800907/**
908 * genphy_read_status - check the link status and update current link state
909 * @phydev: target phy_device struct
Andy Fleming00db8182005-07-30 19:31:23 -0400910 *
Randy Dunlapb3df0da2007-03-06 02:41:48 -0800911 * Description: Check the link, then figure out the current state
Andy Fleming00db8182005-07-30 19:31:23 -0400912 * by comparing what we advertise with what the link partner
913 * advertises. Start by checking the gigabit possibilities,
914 * then move on to 10/100.
915 */
916int genphy_read_status(struct phy_device *phydev)
917{
918 int adv;
919 int err;
920 int lpa;
921 int lpagb = 0;
922
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300923 /* Update the link, but return if there was an error */
Andy Fleming00db8182005-07-30 19:31:23 -0400924 err = genphy_update_link(phydev);
925 if (err)
926 return err;
927
Florian Fainelli114002b2013-12-06 13:01:30 -0800928 phydev->lp_advertising = 0;
929
Andy Fleming00db8182005-07-30 19:31:23 -0400930 if (AUTONEG_ENABLE == phydev->autoneg) {
931 if (phydev->supported & (SUPPORTED_1000baseT_Half
932 | SUPPORTED_1000baseT_Full)) {
933 lpagb = phy_read(phydev, MII_STAT1000);
Andy Fleming00db8182005-07-30 19:31:23 -0400934 if (lpagb < 0)
935 return lpagb;
936
937 adv = phy_read(phydev, MII_CTRL1000);
Andy Fleming00db8182005-07-30 19:31:23 -0400938 if (adv < 0)
939 return adv;
940
Florian Fainelli114002b2013-12-06 13:01:30 -0800941 phydev->lp_advertising =
942 mii_stat1000_to_ethtool_lpa_t(lpagb);
Andy Fleming00db8182005-07-30 19:31:23 -0400943 lpagb &= adv << 2;
944 }
945
946 lpa = phy_read(phydev, MII_LPA);
Andy Fleming00db8182005-07-30 19:31:23 -0400947 if (lpa < 0)
948 return lpa;
949
Florian Fainelli114002b2013-12-06 13:01:30 -0800950 phydev->lp_advertising |= mii_lpa_to_ethtool_lpa_t(lpa);
951
Andy Fleming00db8182005-07-30 19:31:23 -0400952 adv = phy_read(phydev, MII_ADVERTISE);
Andy Fleming00db8182005-07-30 19:31:23 -0400953 if (adv < 0)
954 return adv;
955
956 lpa &= adv;
957
958 phydev->speed = SPEED_10;
959 phydev->duplex = DUPLEX_HALF;
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300960 phydev->pause = 0;
961 phydev->asym_pause = 0;
Andy Fleming00db8182005-07-30 19:31:23 -0400962
963 if (lpagb & (LPA_1000FULL | LPA_1000HALF)) {
964 phydev->speed = SPEED_1000;
965
966 if (lpagb & LPA_1000FULL)
967 phydev->duplex = DUPLEX_FULL;
968 } else if (lpa & (LPA_100FULL | LPA_100HALF)) {
969 phydev->speed = SPEED_100;
Florian Fainellie1093742013-12-17 21:38:12 -0800970
Andy Fleming00db8182005-07-30 19:31:23 -0400971 if (lpa & LPA_100FULL)
972 phydev->duplex = DUPLEX_FULL;
973 } else
974 if (lpa & LPA_10FULL)
975 phydev->duplex = DUPLEX_FULL;
976
Florian Fainellie1093742013-12-17 21:38:12 -0800977 if (phydev->duplex == DUPLEX_FULL) {
Andy Fleming00db8182005-07-30 19:31:23 -0400978 phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
979 phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
980 }
981 } else {
982 int bmcr = phy_read(phydev, MII_BMCR);
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300983
Andy Fleming00db8182005-07-30 19:31:23 -0400984 if (bmcr < 0)
985 return bmcr;
986
987 if (bmcr & BMCR_FULLDPLX)
988 phydev->duplex = DUPLEX_FULL;
989 else
990 phydev->duplex = DUPLEX_HALF;
991
992 if (bmcr & BMCR_SPEED1000)
993 phydev->speed = SPEED_1000;
994 else if (bmcr & BMCR_SPEED100)
995 phydev->speed = SPEED_100;
996 else
997 phydev->speed = SPEED_10;
998
Sergei Shtylyov2f53e902014-01-05 03:17:06 +0300999 phydev->pause = 0;
1000 phydev->asym_pause = 0;
Andy Fleming00db8182005-07-30 19:31:23 -04001001 }
1002
1003 return 0;
1004}
1005EXPORT_SYMBOL(genphy_read_status);
1006
Andy Fleming124059f2014-01-10 14:27:37 +08001007int gen10g_read_status(struct phy_device *phydev)
1008{
1009 int devad, reg;
1010 u32 mmd_mask = phydev->c45_ids.devices_in_package;
1011
1012 phydev->link = 1;
1013
1014 /* For now just lie and say it's 10G all the time */
1015 phydev->speed = SPEED_10000;
1016 phydev->duplex = DUPLEX_FULL;
1017
1018 for (devad = 0; mmd_mask; devad++, mmd_mask = mmd_mask >> 1) {
1019 if (!(mmd_mask & 1))
1020 continue;
1021
1022 /* Read twice because link state is latched and a
1023 * read moves the current state into the register
1024 */
1025 phy_read_mmd(phydev, devad, MDIO_STAT1);
1026 reg = phy_read_mmd(phydev, devad, MDIO_STAT1);
1027 if (reg < 0 || !(reg & MDIO_STAT1_LSTATUS))
1028 phydev->link = 0;
1029 }
1030
1031 return 0;
1032}
1033EXPORT_SYMBOL(gen10g_read_status);
1034
Andy Fleming00db8182005-07-30 19:31:23 -04001035static int genphy_config_init(struct phy_device *phydev)
1036{
Eric Sesterhenn84c22d72006-09-25 16:39:22 -07001037 int val;
Andy Fleming00db8182005-07-30 19:31:23 -04001038 u32 features;
1039
1040 /* For now, I'll claim that the generic driver supports
Sergei Shtylyov2f53e902014-01-05 03:17:06 +03001041 * all possible port types
1042 */
Andy Fleming00db8182005-07-30 19:31:23 -04001043 features = (SUPPORTED_TP | SUPPORTED_MII
1044 | SUPPORTED_AUI | SUPPORTED_FIBRE |
1045 SUPPORTED_BNC);
1046
1047 /* Do we support autonegotiation? */
1048 val = phy_read(phydev, MII_BMSR);
Andy Fleming00db8182005-07-30 19:31:23 -04001049 if (val < 0)
1050 return val;
1051
1052 if (val & BMSR_ANEGCAPABLE)
1053 features |= SUPPORTED_Autoneg;
1054
1055 if (val & BMSR_100FULL)
1056 features |= SUPPORTED_100baseT_Full;
1057 if (val & BMSR_100HALF)
1058 features |= SUPPORTED_100baseT_Half;
1059 if (val & BMSR_10FULL)
1060 features |= SUPPORTED_10baseT_Full;
1061 if (val & BMSR_10HALF)
1062 features |= SUPPORTED_10baseT_Half;
1063
1064 if (val & BMSR_ESTATEN) {
1065 val = phy_read(phydev, MII_ESTATUS);
Andy Fleming00db8182005-07-30 19:31:23 -04001066 if (val < 0)
1067 return val;
1068
1069 if (val & ESTATUS_1000_TFULL)
1070 features |= SUPPORTED_1000baseT_Full;
1071 if (val & ESTATUS_1000_THALF)
1072 features |= SUPPORTED_1000baseT_Half;
1073 }
1074
1075 phydev->supported = features;
1076 phydev->advertising = features;
1077
1078 return 0;
1079}
Andy Fleming124059f2014-01-10 14:27:37 +08001080
1081static int gen10g_config_init(struct phy_device *phydev)
1082{
1083 /* Temporarily just say we support everything */
1084 phydev->supported = SUPPORTED_10000baseT_Full;
1085 phydev->advertising = SUPPORTED_10000baseT_Full;
1086
1087 return 0;
1088}
1089
Giuseppe Cavallaro0f0ca342008-11-28 16:24:56 -08001090int genphy_suspend(struct phy_device *phydev)
1091{
1092 int value;
Andy Fleming00db8182005-07-30 19:31:23 -04001093
Giuseppe Cavallaro0f0ca342008-11-28 16:24:56 -08001094 mutex_lock(&phydev->lock);
1095
1096 value = phy_read(phydev, MII_BMCR);
Sergei Shtylyov2f53e902014-01-05 03:17:06 +03001097 phy_write(phydev, MII_BMCR, value | BMCR_PDOWN);
Giuseppe Cavallaro0f0ca342008-11-28 16:24:56 -08001098
1099 mutex_unlock(&phydev->lock);
1100
1101 return 0;
1102}
1103EXPORT_SYMBOL(genphy_suspend);
1104
Andy Fleming124059f2014-01-10 14:27:37 +08001105int gen10g_suspend(struct phy_device *phydev)
1106{
1107 return 0;
1108}
1109EXPORT_SYMBOL(gen10g_suspend);
1110
Giuseppe Cavallaro0f0ca342008-11-28 16:24:56 -08001111int genphy_resume(struct phy_device *phydev)
1112{
1113 int value;
1114
1115 mutex_lock(&phydev->lock);
1116
1117 value = phy_read(phydev, MII_BMCR);
Sergei Shtylyov2f53e902014-01-05 03:17:06 +03001118 phy_write(phydev, MII_BMCR, value & ~BMCR_PDOWN);
Giuseppe Cavallaro0f0ca342008-11-28 16:24:56 -08001119
1120 mutex_unlock(&phydev->lock);
1121
1122 return 0;
1123}
1124EXPORT_SYMBOL(genphy_resume);
Andy Fleming00db8182005-07-30 19:31:23 -04001125
Andy Fleming124059f2014-01-10 14:27:37 +08001126int gen10g_resume(struct phy_device *phydev)
1127{
1128 return 0;
1129}
1130EXPORT_SYMBOL(gen10g_resume);
1131
Randy Dunlapb3df0da2007-03-06 02:41:48 -08001132/**
1133 * phy_probe - probe and init a PHY device
1134 * @dev: device to probe and init
Andy Fleming00db8182005-07-30 19:31:23 -04001135 *
Randy Dunlapb3df0da2007-03-06 02:41:48 -08001136 * Description: Take care of setting up the phy_device structure,
Andy Fleming00db8182005-07-30 19:31:23 -04001137 * set the state to READY (the driver's init function should
1138 * set it to STARTING if needed).
1139 */
1140static int phy_probe(struct device *dev)
1141{
Sergei Shtylyov553fe922014-01-05 03:23:19 +03001142 struct phy_device *phydev = to_phy_device(dev);
1143 struct device_driver *drv = phydev->dev.driver;
1144 struct phy_driver *phydrv = to_phy_driver(drv);
Andy Fleming00db8182005-07-30 19:31:23 -04001145 int err = 0;
1146
Andy Fleming00db8182005-07-30 19:31:23 -04001147 phydev->drv = phydrv;
1148
Florian Fainelli2c7b4922013-05-19 22:53:42 +00001149 /* Disable the interrupt if the PHY doesn't support it
1150 * but the interrupt is still a valid one
1151 */
1152 if (!(phydrv->flags & PHY_HAS_INTERRUPT) &&
Sergei Shtylyov2f53e902014-01-05 03:17:06 +03001153 phy_interrupt_is_valid(phydev))
Andy Fleming00db8182005-07-30 19:31:23 -04001154 phydev->irq = PHY_POLL;
1155
Florian Fainelli4284b6a2013-05-23 01:11:12 +00001156 if (phydrv->flags & PHY_IS_INTERNAL)
1157 phydev->is_internal = true;
1158
Nate Case35b5f6b2008-01-29 10:05:09 -06001159 mutex_lock(&phydev->lock);
Andy Fleming00db8182005-07-30 19:31:23 -04001160
1161 /* Start out supporting everything. Eventually,
1162 * a controller will attach, and may modify one
Sergei Shtylyov2f53e902014-01-05 03:17:06 +03001163 * or both of these values
1164 */
Andy Fleming00db8182005-07-30 19:31:23 -04001165 phydev->supported = phydrv->features;
1166 phydev->advertising = phydrv->features;
1167
1168 /* Set the state to READY by default */
1169 phydev->state = PHY_READY;
1170
1171 if (phydev->drv->probe)
1172 err = phydev->drv->probe(phydev);
1173
Nate Case35b5f6b2008-01-29 10:05:09 -06001174 mutex_unlock(&phydev->lock);
Andy Fleming00db8182005-07-30 19:31:23 -04001175
Andy Fleming00db8182005-07-30 19:31:23 -04001176 return err;
1177}
1178
1179static int phy_remove(struct device *dev)
1180{
Sergei Shtylyov553fe922014-01-05 03:23:19 +03001181 struct phy_device *phydev = to_phy_device(dev);
Andy Fleming00db8182005-07-30 19:31:23 -04001182
Nate Case35b5f6b2008-01-29 10:05:09 -06001183 mutex_lock(&phydev->lock);
Andy Fleming00db8182005-07-30 19:31:23 -04001184 phydev->state = PHY_DOWN;
Nate Case35b5f6b2008-01-29 10:05:09 -06001185 mutex_unlock(&phydev->lock);
Andy Fleming00db8182005-07-30 19:31:23 -04001186
1187 if (phydev->drv->remove)
1188 phydev->drv->remove(phydev);
Andy Fleming00db8182005-07-30 19:31:23 -04001189 phydev->drv = NULL;
1190
1191 return 0;
1192}
1193
Randy Dunlapb3df0da2007-03-06 02:41:48 -08001194/**
1195 * phy_driver_register - register a phy_driver with the PHY layer
1196 * @new_driver: new phy_driver to register
1197 */
Andy Fleming00db8182005-07-30 19:31:23 -04001198int phy_driver_register(struct phy_driver *new_driver)
1199{
1200 int retval;
1201
Andy Fleming00db8182005-07-30 19:31:23 -04001202 new_driver->driver.name = new_driver->name;
1203 new_driver->driver.bus = &mdio_bus_type;
1204 new_driver->driver.probe = phy_probe;
1205 new_driver->driver.remove = phy_remove;
1206
1207 retval = driver_register(&new_driver->driver);
Andy Fleming00db8182005-07-30 19:31:23 -04001208 if (retval) {
Joe Perches8d242482012-06-09 07:49:07 +00001209 pr_err("%s: Error %d in registering driver\n",
1210 new_driver->name, retval);
Andy Fleming00db8182005-07-30 19:31:23 -04001211
1212 return retval;
1213 }
1214
Olof Johanssonf2511f12007-11-04 16:09:23 -06001215 pr_debug("%s: Registered new driver\n", new_driver->name);
Andy Fleming00db8182005-07-30 19:31:23 -04001216
1217 return 0;
1218}
1219EXPORT_SYMBOL(phy_driver_register);
1220
Christian Hohnstaedtd5bf9072012-07-04 05:44:34 +00001221int phy_drivers_register(struct phy_driver *new_driver, int n)
1222{
1223 int i, ret = 0;
1224
1225 for (i = 0; i < n; i++) {
1226 ret = phy_driver_register(new_driver + i);
1227 if (ret) {
1228 while (i-- > 0)
1229 phy_driver_unregister(new_driver + i);
1230 break;
1231 }
1232 }
1233 return ret;
1234}
1235EXPORT_SYMBOL(phy_drivers_register);
1236
Andy Fleming00db8182005-07-30 19:31:23 -04001237void phy_driver_unregister(struct phy_driver *drv)
1238{
1239 driver_unregister(&drv->driver);
1240}
1241EXPORT_SYMBOL(phy_driver_unregister);
1242
Christian Hohnstaedtd5bf9072012-07-04 05:44:34 +00001243void phy_drivers_unregister(struct phy_driver *drv, int n)
1244{
1245 int i;
Sergei Shtylyov2f53e902014-01-05 03:17:06 +03001246
1247 for (i = 0; i < n; i++)
Christian Hohnstaedtd5bf9072012-07-04 05:44:34 +00001248 phy_driver_unregister(drv + i);
Christian Hohnstaedtd5bf9072012-07-04 05:44:34 +00001249}
1250EXPORT_SYMBOL(phy_drivers_unregister);
1251
Shaohui Xieab2145e2014-01-10 14:27:22 +08001252static struct phy_driver genphy_driver[] = {
1253{
Andy Fleminge1393452005-08-24 18:46:21 -05001254 .phy_id = 0xffffffff,
1255 .phy_id_mask = 0xffffffff,
1256 .name = "Generic PHY",
1257 .config_init = genphy_config_init,
1258 .features = 0,
1259 .config_aneg = genphy_config_aneg,
1260 .read_status = genphy_read_status,
Giuseppe Cavallaro0f0ca342008-11-28 16:24:56 -08001261 .suspend = genphy_suspend,
1262 .resume = genphy_resume,
Florian Fainellie1093742013-12-17 21:38:12 -08001263 .driver = { .owner = THIS_MODULE, },
Andy Fleming124059f2014-01-10 14:27:37 +08001264}, {
1265 .phy_id = 0xffffffff,
1266 .phy_id_mask = 0xffffffff,
1267 .name = "Generic 10G PHY",
1268 .config_init = gen10g_config_init,
1269 .features = 0,
1270 .config_aneg = gen10g_config_aneg,
1271 .read_status = gen10g_read_status,
1272 .suspend = gen10g_suspend,
1273 .resume = gen10g_resume,
1274 .driver = {.owner = THIS_MODULE, },
Shaohui Xieab2145e2014-01-10 14:27:22 +08001275} };
Andy Fleming00db8182005-07-30 19:31:23 -04001276
Jeff Garzik67c4f3f2005-08-11 02:07:25 -04001277static int __init phy_init(void)
Andy Fleming00db8182005-07-30 19:31:23 -04001278{
Jeff Garzik67c4f3f2005-08-11 02:07:25 -04001279 int rc;
Jeff Garzik67c4f3f2005-08-11 02:07:25 -04001280
1281 rc = mdio_bus_init();
1282 if (rc)
Andy Fleminge1393452005-08-24 18:46:21 -05001283 return rc;
Jeff Garzik67c4f3f2005-08-11 02:07:25 -04001284
Shaohui Xieab2145e2014-01-10 14:27:22 +08001285 rc = phy_drivers_register(genphy_driver,
1286 ARRAY_SIZE(genphy_driver));
Andy Fleminge1393452005-08-24 18:46:21 -05001287 if (rc)
1288 mdio_bus_exit();
Jeff Garzik67c4f3f2005-08-11 02:07:25 -04001289
Jeff Garzik67c4f3f2005-08-11 02:07:25 -04001290 return rc;
Andy Fleming00db8182005-07-30 19:31:23 -04001291}
1292
Jeff Garzik67c4f3f2005-08-11 02:07:25 -04001293static void __exit phy_exit(void)
Andy Fleming00db8182005-07-30 19:31:23 -04001294{
Shaohui Xieab2145e2014-01-10 14:27:22 +08001295 phy_drivers_unregister(genphy_driver,
1296 ARRAY_SIZE(genphy_driver));
Andy Fleminge1393452005-08-24 18:46:21 -05001297 mdio_bus_exit();
Andy Fleming00db8182005-07-30 19:31:23 -04001298}
1299
Andy Fleminge1393452005-08-24 18:46:21 -05001300subsys_initcall(phy_init);
Jeff Garzik67c4f3f2005-08-11 02:07:25 -04001301module_exit(phy_exit);