blob: 867110c9d707934c183590ca2469aae594940518 [file] [log] [blame]
Andy Fleming00db8182005-07-30 19:31:23 -04001/*
Andy Fleming00db8182005-07-30 19:31:23 -04002 * Framework and drivers for configuring and reading different PHYs
3 * Based on code in sungem_phy.c and gianfar_phy.c
4 *
5 * Author: Andy Fleming
6 *
7 * Copyright (c) 2004 Freescale Semiconductor, Inc.
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2 of the License, or (at your
12 * option) any later version.
13 *
14 */
15
16#ifndef __PHY_H
17#define __PHY_H
18
Andrew Lunn22209432016-01-06 20:11:13 +010019#include <linux/compiler.h>
Andy Fleming00db8182005-07-30 19:31:23 -040020#include <linux/spinlock.h>
Maciej W. Rozycki13df29f2006-10-03 16:18:28 +010021#include <linux/ethtool.h>
Andrew Lunnbac83c62016-01-06 20:11:07 +010022#include <linux/mdio.h>
Maciej W. Rozycki13df29f2006-10-03 16:18:28 +010023#include <linux/mii.h>
Russell King3e3aaf62015-09-24 20:36:02 +010024#include <linux/module.h>
Maciej W. Rozycki13df29f2006-10-03 16:18:28 +010025#include <linux/timer.h>
26#include <linux/workqueue.h>
David Woodhouse8626d3b2010-04-02 01:05:27 +000027#include <linux/mod_devicetable.h>
Andy Fleming00db8182005-07-30 19:31:23 -040028
Arun Sharma600634972011-07-26 16:09:06 -070029#include <linux/atomic.h>
Maciej W. Rozycki0ac49522007-09-28 22:42:14 -070030
Florian Fainellie9fbdf12013-12-05 14:52:13 -080031#define PHY_DEFAULT_FEATURES (SUPPORTED_Autoneg | \
Andy Fleming00db8182005-07-30 19:31:23 -040032 SUPPORTED_TP | \
33 SUPPORTED_MII)
34
Florian Fainellie9fbdf12013-12-05 14:52:13 -080035#define PHY_10BT_FEATURES (SUPPORTED_10baseT_Half | \
36 SUPPORTED_10baseT_Full)
37
38#define PHY_100BT_FEATURES (SUPPORTED_100baseT_Half | \
39 SUPPORTED_100baseT_Full)
40
41#define PHY_1000BT_FEATURES (SUPPORTED_1000baseT_Half | \
Andy Fleming00db8182005-07-30 19:31:23 -040042 SUPPORTED_1000baseT_Full)
43
Florian Fainellie9fbdf12013-12-05 14:52:13 -080044#define PHY_BASIC_FEATURES (PHY_10BT_FEATURES | \
45 PHY_100BT_FEATURES | \
46 PHY_DEFAULT_FEATURES)
47
48#define PHY_GBIT_FEATURES (PHY_BASIC_FEATURES | \
49 PHY_1000BT_FEATURES)
50
51
Andy Flemingc5e38a92008-04-09 19:38:27 -050052/*
53 * Set phydev->irq to PHY_POLL if interrupts are not supported,
Andy Fleming00db8182005-07-30 19:31:23 -040054 * or not desired for this PHY. Set to PHY_IGNORE_INTERRUPT if
55 * the attached driver handles the interrupt
56 */
57#define PHY_POLL -1
58#define PHY_IGNORE_INTERRUPT -2
59
60#define PHY_HAS_INTERRUPT 0x00000001
61#define PHY_HAS_MAGICANEG 0x00000002
Florian Fainelli4284b6a2013-05-23 01:11:12 +000062#define PHY_IS_INTERNAL 0x00000004
Andrew Lunna9049e02016-01-06 20:11:26 +010063#define MDIO_DEVICE_IS_PHY 0x80000000
Andy Fleming00db8182005-07-30 19:31:23 -040064
Andy Fleminge8a2b6a2006-12-01 12:01:06 -060065/* Interface Mode definitions */
66typedef enum {
Shawn Guo4157ef12011-07-05 16:42:09 +080067 PHY_INTERFACE_MODE_NA,
Andy Fleminge8a2b6a2006-12-01 12:01:06 -060068 PHY_INTERFACE_MODE_MII,
69 PHY_INTERFACE_MODE_GMII,
70 PHY_INTERFACE_MODE_SGMII,
71 PHY_INTERFACE_MODE_TBI,
Florian Fainelli2cc70ba2013-05-28 04:07:21 +000072 PHY_INTERFACE_MODE_REVMII,
Andy Fleminge8a2b6a2006-12-01 12:01:06 -060073 PHY_INTERFACE_MODE_RMII,
74 PHY_INTERFACE_MODE_RGMII,
Kim Phillipsa9995892007-04-13 01:25:57 -050075 PHY_INTERFACE_MODE_RGMII_ID,
Kim Phillips7d400a42007-11-26 16:17:48 -060076 PHY_INTERFACE_MODE_RGMII_RXID,
77 PHY_INTERFACE_MODE_RGMII_TXID,
Shawn Guo4157ef12011-07-05 16:42:09 +080078 PHY_INTERFACE_MODE_RTBI,
79 PHY_INTERFACE_MODE_SMII,
Andy Fleming898dd0b2014-01-10 14:26:46 +080080 PHY_INTERFACE_MODE_XGMII,
Florian Fainellifd70f722014-02-13 16:08:42 -080081 PHY_INTERFACE_MODE_MOCA,
Thomas Petazzonib9d12082014-04-15 15:50:19 +020082 PHY_INTERFACE_MODE_QSGMII,
Sean Wang572de602016-09-22 10:33:54 +080083 PHY_INTERFACE_MODE_TRGMII,
Florian Fainelli8a2fe562014-02-11 17:27:39 -080084 PHY_INTERFACE_MODE_MAX,
Andy Fleminge8a2b6a2006-12-01 12:01:06 -060085} phy_interface_t;
86
Florian Fainelli8a2fe562014-02-11 17:27:39 -080087/**
88 * It maps 'enum phy_interface_t' found in include/linux/phy.h
89 * into the device tree binding of 'phy-mode', so that Ethernet
90 * device driver can get phy interface from device tree.
91 */
92static inline const char *phy_modes(phy_interface_t interface)
93{
94 switch (interface) {
95 case PHY_INTERFACE_MODE_NA:
96 return "";
97 case PHY_INTERFACE_MODE_MII:
98 return "mii";
99 case PHY_INTERFACE_MODE_GMII:
100 return "gmii";
101 case PHY_INTERFACE_MODE_SGMII:
102 return "sgmii";
103 case PHY_INTERFACE_MODE_TBI:
104 return "tbi";
105 case PHY_INTERFACE_MODE_REVMII:
106 return "rev-mii";
107 case PHY_INTERFACE_MODE_RMII:
108 return "rmii";
109 case PHY_INTERFACE_MODE_RGMII:
110 return "rgmii";
111 case PHY_INTERFACE_MODE_RGMII_ID:
112 return "rgmii-id";
113 case PHY_INTERFACE_MODE_RGMII_RXID:
114 return "rgmii-rxid";
115 case PHY_INTERFACE_MODE_RGMII_TXID:
116 return "rgmii-txid";
117 case PHY_INTERFACE_MODE_RTBI:
118 return "rtbi";
119 case PHY_INTERFACE_MODE_SMII:
120 return "smii";
121 case PHY_INTERFACE_MODE_XGMII:
122 return "xgmii";
Florian Fainellifd70f722014-02-13 16:08:42 -0800123 case PHY_INTERFACE_MODE_MOCA:
124 return "moca";
Thomas Petazzonib9d12082014-04-15 15:50:19 +0200125 case PHY_INTERFACE_MODE_QSGMII:
126 return "qsgmii";
Sean Wang572de602016-09-22 10:33:54 +0800127 case PHY_INTERFACE_MODE_TRGMII:
128 return "trgmii";
Florian Fainelli8a2fe562014-02-11 17:27:39 -0800129 default:
130 return "unknown";
131 }
132}
133
Andy Fleming00db8182005-07-30 19:31:23 -0400134
Andy Fleminge8a2b6a2006-12-01 12:01:06 -0600135#define PHY_INIT_TIMEOUT 100000
Andy Fleming00db8182005-07-30 19:31:23 -0400136#define PHY_STATE_TIME 1
137#define PHY_FORCE_TIMEOUT 10
138#define PHY_AN_TIMEOUT 10
139
Andy Fleminge8a2b6a2006-12-01 12:01:06 -0600140#define PHY_MAX_ADDR 32
Andy Fleming00db8182005-07-30 19:31:23 -0400141
Kumar Galaa4d00f12006-01-11 11:27:33 -0800142/* Used when trying to connect to a specific phy (mii bus id:phy device id) */
Andy Fleming9d9326d2008-04-09 19:38:13 -0500143#define PHY_ID_FMT "%s:%02x"
144
Volodymyr Bendiugaa88a9012017-01-19 17:05:04 +0100145#define MII_BUS_ID_SIZE 61
Kumar Galaa4d00f12006-01-11 11:27:33 -0800146
Jason Gunthorpeabf35df2010-03-09 09:17:42 +0000147/* Or MII_ADDR_C45 into regnum for read/write on mii_bus to enable the 21 bit
148 IEEE 802.3ae clause 45 addressing mode used by 10GIGE phy chips. */
149#define MII_ADDR_C45 (1<<30)
150
Paul Gortmaker313162d2012-01-30 11:46:54 -0500151struct device;
152struct sk_buff;
153
Andy Flemingc5e38a92008-04-09 19:38:27 -0500154/*
155 * The Bus class for PHYs. Devices which provide access to
156 * PHYs should register using this structure
157 */
Andy Fleming00db8182005-07-30 19:31:23 -0400158struct mii_bus {
Russell King3e3aaf62015-09-24 20:36:02 +0100159 struct module *owner;
Andy Fleming00db8182005-07-30 19:31:23 -0400160 const char *name;
Andy Fleming9d9326d2008-04-09 19:38:13 -0500161 char id[MII_BUS_ID_SIZE];
Andy Fleming00db8182005-07-30 19:31:23 -0400162 void *priv;
Andrew Lunnccaa9532016-01-06 20:11:06 +0100163 int (*read)(struct mii_bus *bus, int addr, int regnum);
164 int (*write)(struct mii_bus *bus, int addr, int regnum, u16 val);
Andy Fleming00db8182005-07-30 19:31:23 -0400165 int (*reset)(struct mii_bus *bus);
166
Andy Flemingc5e38a92008-04-09 19:38:27 -0500167 /*
168 * A lock to ensure that only one thing can read/write
169 * the MDIO bus at a time
170 */
Nate Case35b5f6b2008-01-29 10:05:09 -0600171 struct mutex mdio_lock;
Andy Fleming00db8182005-07-30 19:31:23 -0400172
Lennert Buytenhek18ee49d2008-10-01 15:41:33 +0000173 struct device *parent;
Lennert Buytenhek46abc022008-10-08 16:33:40 -0700174 enum {
175 MDIOBUS_ALLOCATED = 1,
176 MDIOBUS_REGISTERED,
177 MDIOBUS_UNREGISTERED,
178 MDIOBUS_RELEASED,
179 } state;
180 struct device dev;
Andy Fleming00db8182005-07-30 19:31:23 -0400181
182 /* list of all PHYs on bus */
Andrew Lunn7f854422016-01-06 20:11:18 +0100183 struct mdio_device *mdio_map[PHY_MAX_ADDR];
Andy Fleming00db8182005-07-30 19:31:23 -0400184
Peter Meerwaldc6883992010-09-02 04:06:24 +0000185 /* PHY addresses to be ignored when probing */
Matt Porterf896424c2005-11-02 16:13:06 -0700186 u32 phy_mask;
187
Florian Fainelli922f2dd2015-05-12 10:33:24 -0700188 /* PHY addresses to ignore the TA/read failure */
189 u32 phy_ignore_ta_mask;
190
Andy Flemingc5e38a92008-04-09 19:38:27 -0500191 /*
Andrew Lunne7f4dc32016-01-06 20:11:15 +0100192 * An array of interrupts, each PHY's interrupt at the index
193 * matching its address
Andy Flemingc5e38a92008-04-09 19:38:27 -0500194 */
Andrew Lunne7f4dc32016-01-06 20:11:15 +0100195 int irq[PHY_MAX_ADDR];
Andy Fleming00db8182005-07-30 19:31:23 -0400196};
Lennert Buytenhek46abc022008-10-08 16:33:40 -0700197#define to_mii_bus(d) container_of(d, struct mii_bus, dev)
Andy Fleming00db8182005-07-30 19:31:23 -0400198
Timur Tabieb8a54a72012-01-12 15:23:04 -0800199struct mii_bus *mdiobus_alloc_size(size_t);
200static inline struct mii_bus *mdiobus_alloc(void)
201{
202 return mdiobus_alloc_size(0);
203}
204
Russell King3e3aaf62015-09-24 20:36:02 +0100205int __mdiobus_register(struct mii_bus *bus, struct module *owner);
206#define mdiobus_register(bus) __mdiobus_register(bus, THIS_MODULE)
Lennert Buytenhek2e888102008-09-29 17:12:35 +0000207void mdiobus_unregister(struct mii_bus *bus);
208void mdiobus_free(struct mii_bus *bus);
Grygorii Strashko6d48f442014-04-30 15:23:33 +0300209struct mii_bus *devm_mdiobus_alloc_size(struct device *dev, int sizeof_priv);
210static inline struct mii_bus *devm_mdiobus_alloc(struct device *dev)
211{
212 return devm_mdiobus_alloc_size(dev, 0);
213}
214
215void devm_mdiobus_free(struct device *dev, struct mii_bus *bus);
Lennert Buytenhek2e888102008-09-29 17:12:35 +0000216struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr);
Lennert Buytenhek2e888102008-09-29 17:12:35 +0000217
Andy Fleminge8a2b6a2006-12-01 12:01:06 -0600218#define PHY_INTERRUPT_DISABLED 0x0
219#define PHY_INTERRUPT_ENABLED 0x80000000
Andy Fleming00db8182005-07-30 19:31:23 -0400220
221/* PHY state machine states:
222 *
223 * DOWN: PHY device and driver are not ready for anything. probe
224 * should be called if and only if the PHY is in this state,
225 * given that the PHY device exists.
226 * - PHY driver probe function will, depending on the PHY, set
227 * the state to STARTING or READY
228 *
229 * STARTING: PHY device is coming up, and the ethernet driver is
230 * not ready. PHY drivers may set this in the probe function.
231 * If they do, they are responsible for making sure the state is
232 * eventually set to indicate whether the PHY is UP or READY,
233 * depending on the state when the PHY is done starting up.
234 * - PHY driver will set the state to READY
235 * - start will set the state to PENDING
236 *
237 * READY: PHY is ready to send and receive packets, but the
238 * controller is not. By default, PHYs which do not implement
239 * probe will be set to this state by phy_probe(). If the PHY
240 * driver knows the PHY is ready, and the PHY state is STARTING,
241 * then it sets this STATE.
242 * - start will set the state to UP
243 *
244 * PENDING: PHY device is coming up, but the ethernet driver is
245 * ready. phy_start will set this state if the PHY state is
246 * STARTING.
247 * - PHY driver will set the state to UP when the PHY is ready
248 *
249 * UP: The PHY and attached device are ready to do work.
250 * Interrupts should be started here.
251 * - timer moves to AN
252 *
253 * AN: The PHY is currently negotiating the link state. Link is
254 * therefore down for now. phy_timer will set this state when it
255 * detects the state is UP. config_aneg will set this state
256 * whenever called with phydev->autoneg set to AUTONEG_ENABLE.
257 * - If autonegotiation finishes, but there's no link, it sets
258 * the state to NOLINK.
259 * - If aneg finishes with link, it sets the state to RUNNING,
260 * and calls adjust_link
261 * - If autonegotiation did not finish after an arbitrary amount
262 * of time, autonegotiation should be tried again if the PHY
263 * supports "magic" autonegotiation (back to AN)
264 * - If it didn't finish, and no magic_aneg, move to FORCING.
265 *
266 * NOLINK: PHY is up, but not currently plugged in.
267 * - If the timer notes that the link comes back, we move to RUNNING
268 * - config_aneg moves to AN
269 * - phy_stop moves to HALTED
270 *
271 * FORCING: PHY is being configured with forced settings
272 * - if link is up, move to RUNNING
273 * - If link is down, we drop to the next highest setting, and
274 * retry (FORCING) after a timeout
275 * - phy_stop moves to HALTED
276 *
277 * RUNNING: PHY is currently up, running, and possibly sending
278 * and/or receiving packets
279 * - timer will set CHANGELINK if we're polling (this ensures the
280 * link state is polled every other cycle of this state machine,
281 * which makes it every other second)
282 * - irq will set CHANGELINK
283 * - config_aneg will set AN
284 * - phy_stop moves to HALTED
285 *
286 * CHANGELINK: PHY experienced a change in link state
287 * - timer moves to RUNNING if link
288 * - timer moves to NOLINK if the link is down
289 * - phy_stop moves to HALTED
290 *
291 * HALTED: PHY is up, but no polling or interrupts are done. Or
292 * PHY is in an error state.
293 *
294 * - phy_start moves to RESUMING
295 *
296 * RESUMING: PHY was halted, but now wants to run again.
297 * - If we are forcing, or aneg is done, timer moves to RUNNING
298 * - If aneg is not done, timer moves to AN
299 * - phy_stop moves to HALTED
300 */
301enum phy_state {
Sergei Shtylyov4017b4d2014-01-05 03:20:17 +0300302 PHY_DOWN = 0,
Andy Fleming00db8182005-07-30 19:31:23 -0400303 PHY_STARTING,
304 PHY_READY,
305 PHY_PENDING,
306 PHY_UP,
307 PHY_AN,
308 PHY_RUNNING,
309 PHY_NOLINK,
310 PHY_FORCING,
311 PHY_CHANGELINK,
312 PHY_HALTED,
313 PHY_RESUMING
314};
315
David Daneyac28b9f2012-06-27 07:33:35 +0000316/**
317 * struct phy_c45_device_ids - 802.3-c45 Device Identifiers
318 * @devices_in_package: Bit vector of devices present.
319 * @device_ids: The device identifer for each present device.
320 */
321struct phy_c45_device_ids {
322 u32 devices_in_package;
323 u32 device_ids[8];
324};
Richard Cochranc1f19b52010-07-17 08:49:36 +0000325
Andy Fleming00db8182005-07-30 19:31:23 -0400326/* phy_device: An instance of a PHY
327 *
328 * drv: Pointer to the driver for this PHY instance
Andy Fleming00db8182005-07-30 19:31:23 -0400329 * phy_id: UID for this device found during discovery
David Daneyac28b9f2012-06-27 07:33:35 +0000330 * c45_ids: 802.3-c45 Device Identifers if is_c45.
331 * is_c45: Set to true if this phy uses clause 45 addressing.
Florian Fainelli4284b6a2013-05-23 01:11:12 +0000332 * is_internal: Set to true if this phy is internal to a MAC.
Florian Fainelli5a11dd72015-08-31 15:56:46 +0200333 * is_pseudo_fixed_link: Set to true if this phy is an Ethernet switch, etc.
Florian Fainelliaae88262015-01-26 22:05:38 -0800334 * has_fixups: Set to true if this phy has fixups/quirks.
Florian Fainelli8a477a62015-01-26 22:05:39 -0800335 * suspended: Set to true if this phy has been suspended successfully.
Andy Fleming00db8182005-07-30 19:31:23 -0400336 * state: state of the PHY for management purposes
337 * dev_flags: Device-specific flags used by the PHY driver.
Andy Fleming00db8182005-07-30 19:31:23 -0400338 * link_timeout: The number of timer firings to wait before the
339 * giving up on the current attempt at acquiring a link
340 * irq: IRQ number of the PHY's interrupt (-1 if none)
341 * phy_timer: The timer for handling the state machine
342 * phy_queue: A work_queue for the interrupt
343 * attached_dev: The attached enet driver's device instance ptr
344 * adjust_link: Callback for the enet controller to respond to
345 * changes in the link state.
Andy Fleming00db8182005-07-30 19:31:23 -0400346 *
Florian Fainelli114002b2013-12-06 13:01:30 -0800347 * speed, duplex, pause, supported, advertising, lp_advertising,
348 * and autoneg are used like in mii_if_info
Andy Fleming00db8182005-07-30 19:31:23 -0400349 *
350 * interrupts currently only supports enabled or disabled,
351 * but could be changed in the future to support enabling
352 * and disabling specific interrupts
353 *
354 * Contains some infrastructure for polling and interrupt
355 * handling, as well as handling shifts in PHY hardware state
356 */
357struct phy_device {
Andrew Lunne5a03bf2016-01-06 20:11:16 +0100358 struct mdio_device mdio;
359
Andy Fleming00db8182005-07-30 19:31:23 -0400360 /* Information about the PHY type */
361 /* And management functions */
362 struct phy_driver *drv;
363
Andy Fleming00db8182005-07-30 19:31:23 -0400364 u32 phy_id;
365
David Daneyac28b9f2012-06-27 07:33:35 +0000366 struct phy_c45_device_ids c45_ids;
367 bool is_c45;
Florian Fainelli4284b6a2013-05-23 01:11:12 +0000368 bool is_internal;
Florian Fainelli5a11dd72015-08-31 15:56:46 +0200369 bool is_pseudo_fixed_link;
Florian Fainellib0ae0092014-02-11 17:27:41 -0800370 bool has_fixups;
Florian Fainelli8a477a62015-01-26 22:05:39 -0800371 bool suspended;
David Daneyac28b9f2012-06-27 07:33:35 +0000372
Andy Fleming00db8182005-07-30 19:31:23 -0400373 enum phy_state state;
374
375 u32 dev_flags;
376
Andy Fleminge8a2b6a2006-12-01 12:01:06 -0600377 phy_interface_t interface;
378
Andy Flemingc5e38a92008-04-09 19:38:27 -0500379 /*
380 * forced speed & duplex (no autoneg)
Andy Fleming00db8182005-07-30 19:31:23 -0400381 * partner speed & duplex & pause (autoneg)
382 */
383 int speed;
384 int duplex;
385 int pause;
386 int asym_pause;
387
388 /* The most recently read link state */
389 int link;
390
391 /* Enabled Interrupts */
392 u32 interrupts;
393
394 /* Union of PHY and Attached devices' supported modes */
395 /* See mii.h for more info */
396 u32 supported;
397 u32 advertising;
Florian Fainelli114002b2013-12-06 13:01:30 -0800398 u32 lp_advertising;
Andy Fleming00db8182005-07-30 19:31:23 -0400399
jbrunet97ace182016-11-28 10:46:46 +0100400 /* Energy efficient ethernet modes which should be prohibited */
401 u32 eee_broken_modes;
402
Andy Fleming00db8182005-07-30 19:31:23 -0400403 int autoneg;
404
405 int link_timeout;
406
Andy Flemingc5e38a92008-04-09 19:38:27 -0500407 /*
408 * Interrupt number for this PHY
409 * -1 means no interrupt
410 */
Andy Fleming00db8182005-07-30 19:31:23 -0400411 int irq;
412
413 /* private data pointer */
414 /* For use by PHYs to maintain extra state */
415 void *priv;
416
417 /* Interrupt and Polling infrastructure */
418 struct work_struct phy_queue;
Marcin Slusarza390d1f2009-03-13 15:41:19 -0700419 struct delayed_work state_queue;
Maciej W. Rozycki0ac49522007-09-28 22:42:14 -0700420 atomic_t irq_disable;
Andy Fleming00db8182005-07-30 19:31:23 -0400421
Nate Case35b5f6b2008-01-29 10:05:09 -0600422 struct mutex lock;
Andy Fleming00db8182005-07-30 19:31:23 -0400423
424 struct net_device *attached_dev;
425
David Thomson634ec362015-07-10 13:56:54 +1200426 u8 mdix;
427
Andy Fleming00db8182005-07-30 19:31:23 -0400428 void (*adjust_link)(struct net_device *dev);
Andy Fleming00db8182005-07-30 19:31:23 -0400429};
Andrew Lunne5a03bf2016-01-06 20:11:16 +0100430#define to_phy_device(d) container_of(to_mdio_device(d), \
431 struct phy_device, mdio)
Andy Fleming00db8182005-07-30 19:31:23 -0400432
433/* struct phy_driver: Driver structure for a particular PHY type
434 *
Andrew Lunna9049e02016-01-06 20:11:26 +0100435 * driver_data: static driver data
Andy Fleming00db8182005-07-30 19:31:23 -0400436 * phy_id: The result of reading the UID registers of this PHY
437 * type, and ANDing them with the phy_id_mask. This driver
438 * only works for PHYs with IDs which match this field
439 * name: The friendly name of this PHY type
440 * phy_id_mask: Defines the important bits of the phy_id
441 * features: A list of features (speed, duplex, etc) supported
442 * by this PHY
443 * flags: A bitfield defining certain other features this PHY
444 * supports (like interrupts)
445 *
446 * The drivers must implement config_aneg and read_status. All
447 * other functions are optional. Note that none of these
448 * functions should be called from interrupt time. The goal is
449 * for the bus read/write functions to be able to block when the
450 * bus transaction is happening, and be freed up by an interrupt
451 * (The MPC85xx has this ability, though it is not currently
452 * supported in the driver).
453 */
454struct phy_driver {
Andrew Lunna9049e02016-01-06 20:11:26 +0100455 struct mdio_driver_common mdiodrv;
Andy Fleming00db8182005-07-30 19:31:23 -0400456 u32 phy_id;
457 char *name;
458 unsigned int phy_id_mask;
459 u32 features;
460 u32 flags;
Johan Hovold860f6e92014-11-19 12:59:14 +0100461 const void *driver_data;
Andy Fleming00db8182005-07-30 19:31:23 -0400462
Andy Flemingc5e38a92008-04-09 19:38:27 -0500463 /*
Florian Fainelli9df81dd2014-02-17 13:34:03 -0800464 * Called to issue a PHY software reset
465 */
466 int (*soft_reset)(struct phy_device *phydev);
467
468 /*
Andy Flemingc5e38a92008-04-09 19:38:27 -0500469 * Called to initialize the PHY,
470 * including after a reset
471 */
Andy Fleming00db8182005-07-30 19:31:23 -0400472 int (*config_init)(struct phy_device *phydev);
473
Andy Flemingc5e38a92008-04-09 19:38:27 -0500474 /*
475 * Called during discovery. Used to set
476 * up device-specific structures, if any
477 */
Andy Fleming00db8182005-07-30 19:31:23 -0400478 int (*probe)(struct phy_device *phydev);
479
480 /* PHY Power Management */
481 int (*suspend)(struct phy_device *phydev);
482 int (*resume)(struct phy_device *phydev);
483
Andy Flemingc5e38a92008-04-09 19:38:27 -0500484 /*
485 * Configures the advertisement and resets
Andy Fleming00db8182005-07-30 19:31:23 -0400486 * autonegotiation if phydev->autoneg is on,
487 * forces the speed to the current settings in phydev
Andy Flemingc5e38a92008-04-09 19:38:27 -0500488 * if phydev->autoneg is off
489 */
Andy Fleming00db8182005-07-30 19:31:23 -0400490 int (*config_aneg)(struct phy_device *phydev);
491
Florian Fainelli76a423a2014-02-11 17:27:37 -0800492 /* Determines the auto negotiation result */
493 int (*aneg_done)(struct phy_device *phydev);
494
Andy Fleming00db8182005-07-30 19:31:23 -0400495 /* Determines the negotiated speed and duplex */
496 int (*read_status)(struct phy_device *phydev);
497
498 /* Clears any pending interrupts */
499 int (*ack_interrupt)(struct phy_device *phydev);
500
501 /* Enables or disables interrupts */
502 int (*config_intr)(struct phy_device *phydev);
503
Anatolij Gustschina8729eb2009-04-07 02:01:42 +0000504 /*
505 * Checks if the PHY generated an interrupt.
506 * For multi-PHY devices with shared PHY interrupt pin
507 */
508 int (*did_interrupt)(struct phy_device *phydev);
509
Andy Fleming00db8182005-07-30 19:31:23 -0400510 /* Clears up any memory if needed */
511 void (*remove)(struct phy_device *phydev);
512
David Daneya30e2c12012-06-27 07:33:37 +0000513 /* Returns true if this is a suitable driver for the given
514 * phydev. If NULL, matching is based on phy_id and
515 * phy_id_mask.
516 */
517 int (*match_phy_device)(struct phy_device *phydev);
518
Richard Cochranc8f3a8c2012-04-03 22:59:17 +0000519 /* Handles ethtool queries for hardware time stamping. */
520 int (*ts_info)(struct phy_device *phydev, struct ethtool_ts_info *ti);
521
Richard Cochranc1f19b52010-07-17 08:49:36 +0000522 /* Handles SIOCSHWTSTAMP ioctl for hardware time stamping. */
523 int (*hwtstamp)(struct phy_device *phydev, struct ifreq *ifr);
524
525 /*
526 * Requests a Rx timestamp for 'skb'. If the skb is accepted,
527 * the phy driver promises to deliver it using netif_rx() as
528 * soon as a timestamp becomes available. One of the
529 * PTP_CLASS_ values is passed in 'type'. The function must
530 * return true if the skb is accepted for delivery.
531 */
532 bool (*rxtstamp)(struct phy_device *dev, struct sk_buff *skb, int type);
533
534 /*
535 * Requests a Tx timestamp for 'skb'. The phy driver promises
Richard Cochranda92b192011-10-21 00:49:15 +0000536 * to deliver it using skb_complete_tx_timestamp() as soon as a
Richard Cochranc1f19b52010-07-17 08:49:36 +0000537 * timestamp becomes available. One of the PTP_CLASS_ values
538 * is passed in 'type'.
539 */
540 void (*txtstamp)(struct phy_device *dev, struct sk_buff *skb, int type);
541
Michael Stapelberg42e836e2013-03-11 13:56:44 +0000542 /* Some devices (e.g. qnap TS-119P II) require PHY register changes to
543 * enable Wake on LAN, so set_wol is provided to be called in the
544 * ethernet driver's set_wol function. */
545 int (*set_wol)(struct phy_device *dev, struct ethtool_wolinfo *wol);
546
547 /* See set_wol, but for checking whether Wake on LAN is enabled. */
548 void (*get_wol)(struct phy_device *dev, struct ethtool_wolinfo *wol);
549
Daniel Mack2b8f2a22014-06-18 11:01:41 +0200550 /*
551 * Called to inform a PHY device driver when the core is about to
552 * change the link state. This callback is supposed to be used as
553 * fixup hook for drivers that need to take action when the link
554 * state changes. Drivers are by no means allowed to mess with the
555 * PHY device structure in their implementations.
556 */
557 void (*link_change_notify)(struct phy_device *dev);
558
Vince Bridgers0c1d77d2014-07-29 15:19:57 -0500559 /* A function provided by a phy specific driver to override the
560 * the PHY driver framework support for reading a MMD register
561 * from the PHY. If not supported, return -1. This function is
562 * optional for PHY specific drivers, if not provided then the
563 * default MMD read function is used by the PHY framework.
564 */
565 int (*read_mmd_indirect)(struct phy_device *dev, int ptrad,
566 int devnum, int regnum);
567
568 /* A function provided by a phy specific driver to override the
569 * the PHY driver framework support for writing a MMD register
570 * from the PHY. This function is optional for PHY specific drivers,
571 * if not provided then the default MMD read function is used by
572 * the PHY framework.
573 */
574 void (*write_mmd_indirect)(struct phy_device *dev, int ptrad,
575 int devnum, int regnum, u32 val);
576
Ed Swierk2f438362015-01-02 17:27:56 -0800577 /* Get the size and type of the eeprom contained within a plug-in
578 * module */
579 int (*module_info)(struct phy_device *dev,
580 struct ethtool_modinfo *modinfo);
581
582 /* Get the eeprom information from the plug-in module */
583 int (*module_eeprom)(struct phy_device *dev,
584 struct ethtool_eeprom *ee, u8 *data);
585
Andrew Lunnf3a40942015-12-30 16:28:25 +0100586 /* Get statistics from the phy using ethtool */
587 int (*get_sset_count)(struct phy_device *dev);
588 void (*get_strings)(struct phy_device *dev, u8 *data);
589 void (*get_stats)(struct phy_device *dev,
590 struct ethtool_stats *stats, u64 *data);
Andy Fleming00db8182005-07-30 19:31:23 -0400591};
Andrew Lunna9049e02016-01-06 20:11:26 +0100592#define to_phy_driver(d) container_of(to_mdio_common_driver(d), \
593 struct phy_driver, mdiodrv)
Andy Fleming00db8182005-07-30 19:31:23 -0400594
Andy Flemingf62220d2008-04-18 17:29:54 -0500595#define PHY_ANY_ID "MATCH ANY PHY"
596#define PHY_ANY_UID 0xffffffff
597
598/* A Structure for boards to register fixups with the PHY Lib */
599struct phy_fixup {
600 struct list_head list;
Volodymyr Bendiugaa88a9012017-01-19 17:05:04 +0100601 char bus_id[MII_BUS_ID_SIZE + 3];
Andy Flemingf62220d2008-04-18 17:29:54 -0500602 u32 phy_uid;
603 u32 phy_uid_mask;
604 int (*run)(struct phy_device *phydev);
605};
606
Lennert Buytenhek2e888102008-09-29 17:12:35 +0000607/**
Andy Flemingefabdfb2014-01-10 14:25:09 +0800608 * phy_read_mmd - Convenience function for reading a register
609 * from an MMD on a given PHY.
610 * @phydev: The phy_device struct
611 * @devad: The MMD to read from
612 * @regnum: The register on the MMD to read
613 *
614 * Same rules as for phy_read();
615 */
616static inline int phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum)
617{
618 if (!phydev->is_c45)
619 return -EOPNOTSUPP;
620
Andrew Lunne5a03bf2016-01-06 20:11:16 +0100621 return mdiobus_read(phydev->mdio.bus, phydev->mdio.addr,
Andy Flemingefabdfb2014-01-10 14:25:09 +0800622 MII_ADDR_C45 | (devad << 16) | (regnum & 0xffff));
623}
624
625/**
Florian Fainelli66ce7fb2014-08-22 18:55:43 -0700626 * phy_read_mmd_indirect - reads data from the MMD registers
627 * @phydev: The PHY device bus
628 * @prtad: MMD Address
Florian Fainelli66ce7fb2014-08-22 18:55:43 -0700629 * @addr: PHY address on the MII bus
630 *
631 * Description: it reads data from the MMD registers (clause 22 to access to
632 * clause 45) of the specified phy address.
633 */
Andrew Lunn053e7e12016-01-06 20:11:12 +0100634int phy_read_mmd_indirect(struct phy_device *phydev, int prtad, int devad);
Florian Fainelli66ce7fb2014-08-22 18:55:43 -0700635
636/**
Lennert Buytenhek2e888102008-09-29 17:12:35 +0000637 * phy_read - Convenience function for reading a given PHY register
638 * @phydev: the phy_device struct
639 * @regnum: register number to read
640 *
641 * NOTE: MUST NOT be called from interrupt context,
642 * because the bus read/write functions may wait for an interrupt
643 * to conclude the operation.
644 */
Jason Gunthorpeabf35df2010-03-09 09:17:42 +0000645static inline int phy_read(struct phy_device *phydev, u32 regnum)
Lennert Buytenhek2e888102008-09-29 17:12:35 +0000646{
Andrew Lunne5a03bf2016-01-06 20:11:16 +0100647 return mdiobus_read(phydev->mdio.bus, phydev->mdio.addr, regnum);
Lennert Buytenhek2e888102008-09-29 17:12:35 +0000648}
649
650/**
651 * phy_write - Convenience function for writing a given PHY register
652 * @phydev: the phy_device struct
653 * @regnum: register number to write
654 * @val: value to write to @regnum
655 *
656 * NOTE: MUST NOT be called from interrupt context,
657 * because the bus read/write functions may wait for an interrupt
658 * to conclude the operation.
659 */
Jason Gunthorpeabf35df2010-03-09 09:17:42 +0000660static inline int phy_write(struct phy_device *phydev, u32 regnum, u16 val)
Lennert Buytenhek2e888102008-09-29 17:12:35 +0000661{
Andrew Lunne5a03bf2016-01-06 20:11:16 +0100662 return mdiobus_write(phydev->mdio.bus, phydev->mdio.addr, regnum, val);
Lennert Buytenhek2e888102008-09-29 17:12:35 +0000663}
664
Florian Fainelli2c7b4922013-05-19 22:53:42 +0000665/**
666 * phy_interrupt_is_valid - Convenience function for testing a given PHY irq
667 * @phydev: the phy_device struct
668 *
669 * NOTE: must be kept in sync with addition/removal of PHY_POLL and
670 * PHY_IGNORE_INTERRUPT
671 */
672static inline bool phy_interrupt_is_valid(struct phy_device *phydev)
673{
674 return phydev->irq != PHY_POLL && phydev->irq != PHY_IGNORE_INTERRUPT;
675}
676
Florian Fainelli4284b6a2013-05-23 01:11:12 +0000677/**
678 * phy_is_internal - Convenience function for testing if a PHY is internal
679 * @phydev: the phy_device struct
680 */
681static inline bool phy_is_internal(struct phy_device *phydev)
682{
683 return phydev->is_internal;
684}
685
Andy Flemingefabdfb2014-01-10 14:25:09 +0800686/**
Jerome Brunet6f237182018-01-03 16:46:29 +0100687 * phy_interface_mode_is_rgmii - Convenience function for testing if a
688 * PHY interface mode is RGMII (all variants)
689 * @mode: the phy_interface_t enum
690 */
691static inline bool phy_interface_mode_is_rgmii(phy_interface_t mode)
692{
693 return mode >= PHY_INTERFACE_MODE_RGMII &&
694 mode <= PHY_INTERFACE_MODE_RGMII_TXID;
695};
696
697/**
Florian Fainellie463d882015-05-26 12:19:58 -0700698 * phy_interface_is_rgmii - Convenience function for testing if a PHY interface
699 * is RGMII (all variants)
700 * @phydev: the phy_device struct
701 */
702static inline bool phy_interface_is_rgmii(struct phy_device *phydev)
703{
704 return phydev->interface >= PHY_INTERFACE_MODE_RGMII &&
705 phydev->interface <= PHY_INTERFACE_MODE_RGMII_TXID;
Florian Fainelli5a11dd72015-08-31 15:56:46 +0200706};
707
708/*
709 * phy_is_pseudo_fixed_link - Convenience function for testing if this
710 * PHY is the CPU port facing side of an Ethernet switch, or similar.
711 * @phydev: the phy_device struct
712 */
713static inline bool phy_is_pseudo_fixed_link(struct phy_device *phydev)
714{
715 return phydev->is_pseudo_fixed_link;
Florian Fainellie463d882015-05-26 12:19:58 -0700716}
717
718/**
Andy Flemingefabdfb2014-01-10 14:25:09 +0800719 * phy_write_mmd - Convenience function for writing a register
720 * on an MMD on a given PHY.
721 * @phydev: The phy_device struct
722 * @devad: The MMD to read from
723 * @regnum: The register on the MMD to read
724 * @val: value to write to @regnum
725 *
726 * Same rules as for phy_write();
727 */
728static inline int phy_write_mmd(struct phy_device *phydev, int devad,
729 u32 regnum, u16 val)
730{
731 if (!phydev->is_c45)
732 return -EOPNOTSUPP;
733
734 regnum = MII_ADDR_C45 | ((devad & 0x1f) << 16) | (regnum & 0xffff);
735
Andrew Lunne5a03bf2016-01-06 20:11:16 +0100736 return mdiobus_write(phydev->mdio.bus, phydev->mdio.addr, regnum, val);
Andy Flemingefabdfb2014-01-10 14:25:09 +0800737}
738
Florian Fainelli66ce7fb2014-08-22 18:55:43 -0700739/**
740 * phy_write_mmd_indirect - writes data to the MMD registers
741 * @phydev: The PHY device
742 * @prtad: MMD Address
743 * @devad: MMD DEVAD
Florian Fainelli66ce7fb2014-08-22 18:55:43 -0700744 * @data: data to write in the MMD register
745 *
746 * Description: Write data from the MMD registers of the specified
747 * phy address.
748 */
749void phy_write_mmd_indirect(struct phy_device *phydev, int prtad,
Andrew Lunn053e7e12016-01-06 20:11:12 +0100750 int devad, u32 data);
Florian Fainelli66ce7fb2014-08-22 18:55:43 -0700751
David Daneyac28b9f2012-06-27 07:33:35 +0000752struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
Sergei Shtylyov4017b4d2014-01-05 03:20:17 +0300753 bool is_c45,
754 struct phy_c45_device_ids *c45_ids);
David Daneyac28b9f2012-06-27 07:33:35 +0000755struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45);
Grant Likely4dea5472009-04-25 12:52:46 +0000756int phy_device_register(struct phy_device *phy);
Russell King38737e42015-09-24 20:36:28 +0100757void phy_device_remove(struct phy_device *phydev);
Anton Vorontsov2f5cb432009-12-30 08:23:30 +0000758int phy_init_hw(struct phy_device *phydev);
Sebastian Hesselbarth481b5d92013-12-13 10:20:27 +0100759int phy_suspend(struct phy_device *phydev);
760int phy_resume(struct phy_device *phydev);
Sergei Shtylyov4017b4d2014-01-05 03:20:17 +0300761struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
762 phy_interface_t interface);
Jiri Pirkof8f76db2010-02-04 10:23:02 -0800763struct phy_device *phy_find_first(struct mii_bus *bus);
Andy Fleming257184d2014-01-10 14:27:54 +0800764int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
765 u32 flags, phy_interface_t interface);
Grant Likelyfa94f6d2009-04-25 12:52:51 +0000766int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
Sergei Shtylyov4017b4d2014-01-05 03:20:17 +0300767 void (*handler)(struct net_device *),
768 phy_interface_t interface);
769struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
770 void (*handler)(struct net_device *),
771 phy_interface_t interface);
Andy Fleminge1393452005-08-24 18:46:21 -0500772void phy_disconnect(struct phy_device *phydev);
773void phy_detach(struct phy_device *phydev);
774void phy_start(struct phy_device *phydev);
775void phy_stop(struct phy_device *phydev);
776int phy_start_aneg(struct phy_device *phydev);
777
Andy Fleminge1393452005-08-24 18:46:21 -0500778int phy_stop_interrupts(struct phy_device *phydev);
Andy Fleming00db8182005-07-30 19:31:23 -0400779
Sergei Shtylyov4017b4d2014-01-05 03:20:17 +0300780static inline int phy_read_status(struct phy_device *phydev)
781{
Andy Fleming00db8182005-07-30 19:31:23 -0400782 return phydev->drv->read_status(phydev);
783}
784
Andrew Lunn72ba48b2016-01-06 20:11:09 +0100785#define phydev_err(_phydev, format, args...) \
Andrew Lunne5a03bf2016-01-06 20:11:16 +0100786 dev_err(&_phydev->mdio.dev, format, ##args)
Andrew Lunn72ba48b2016-01-06 20:11:09 +0100787
788#define phydev_dbg(_phydev, format, args...) \
Andrew Lunne5a03bf2016-01-06 20:11:16 +0100789 dev_dbg(&_phydev->mdio.dev, format, ##args);
Andrew Lunn72ba48b2016-01-06 20:11:09 +0100790
Andrew Lunn84eff6d2016-01-06 20:11:10 +0100791static inline const char *phydev_name(const struct phy_device *phydev)
792{
Andrew Lunne5a03bf2016-01-06 20:11:16 +0100793 return dev_name(&phydev->mdio.dev);
Andrew Lunn84eff6d2016-01-06 20:11:10 +0100794}
795
Andrew Lunn22209432016-01-06 20:11:13 +0100796void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
797 __printf(2, 3);
798void phy_attached_info(struct phy_device *phydev);
Daniel Mackaf6b6962014-04-16 17:19:12 +0200799int genphy_config_init(struct phy_device *phydev);
Madalin Bucur3fb69bc2013-11-20 16:38:19 -0600800int genphy_setup_forced(struct phy_device *phydev);
Andy Fleming00db8182005-07-30 19:31:23 -0400801int genphy_restart_aneg(struct phy_device *phydev);
802int genphy_config_aneg(struct phy_device *phydev);
Florian Fainellia9fa6e62014-02-11 17:27:36 -0800803int genphy_aneg_done(struct phy_device *phydev);
Andy Fleming00db8182005-07-30 19:31:23 -0400804int genphy_update_link(struct phy_device *phydev);
805int genphy_read_status(struct phy_device *phydev);
Giuseppe Cavallaro0f0ca342008-11-28 16:24:56 -0800806int genphy_suspend(struct phy_device *phydev);
807int genphy_resume(struct phy_device *phydev);
Florian Fainelli797ac072014-02-17 13:34:02 -0800808int genphy_soft_reset(struct phy_device *phydev);
Florian Fainelli6c781972017-03-05 12:34:49 -0800809static inline int genphy_no_soft_reset(struct phy_device *phydev)
810{
811 return 0;
812}
Andy Fleming00db8182005-07-30 19:31:23 -0400813void phy_driver_unregister(struct phy_driver *drv);
Christian Hohnstaedtd5bf9072012-07-04 05:44:34 +0000814void phy_drivers_unregister(struct phy_driver *drv, int n);
Andrew Lunnbe01da72016-01-06 20:11:22 +0100815int phy_driver_register(struct phy_driver *new_driver, struct module *owner);
816int phy_drivers_register(struct phy_driver *new_driver, int n,
817 struct module *owner);
Anton Vorontsov4f9c85a2010-01-18 05:37:16 +0000818void phy_state_machine(struct work_struct *work);
Florian Fainelli5ea94e72013-05-19 22:53:43 +0000819void phy_change(struct work_struct *work);
820void phy_mac_interrupt(struct phy_device *phydev, int new_link);
Sergei Shtylyov29935ae2014-01-05 03:27:17 +0300821void phy_start_machine(struct phy_device *phydev);
Andy Fleming00db8182005-07-30 19:31:23 -0400822void phy_stop_machine(struct phy_device *phydev);
Alexander Kochetkovae6a7622017-04-20 14:00:04 +0300823void phy_trigger_machine(struct phy_device *phydev, bool sync);
Andy Fleming00db8182005-07-30 19:31:23 -0400824int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd);
825int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd);
Philippe Reynes2d551732016-04-15 00:35:00 +0200826int phy_ethtool_ksettings_get(struct phy_device *phydev,
827 struct ethtool_link_ksettings *cmd);
828int phy_ethtool_ksettings_set(struct phy_device *phydev,
829 const struct ethtool_link_ksettings *cmd);
Sergei Shtylyov4017b4d2014-01-05 03:20:17 +0300830int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd);
Andy Fleminge1393452005-08-24 18:46:21 -0500831int phy_start_interrupts(struct phy_device *phydev);
832void phy_print_status(struct phy_device *phydev);
Anton Vorontsov6f4a7f42007-12-04 16:17:33 +0300833void phy_device_free(struct phy_device *phydev);
Simon Hormanf3a6bd32015-09-30 15:15:52 +0900834int phy_set_max_speed(struct phy_device *phydev, u32 max_speed);
Andy Fleming00db8182005-07-30 19:31:23 -0400835
Andy Flemingf62220d2008-04-18 17:29:54 -0500836int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
Sergei Shtylyov4017b4d2014-01-05 03:20:17 +0300837 int (*run)(struct phy_device *));
Andy Flemingf62220d2008-04-18 17:29:54 -0500838int phy_register_fixup_for_id(const char *bus_id,
Sergei Shtylyov4017b4d2014-01-05 03:20:17 +0300839 int (*run)(struct phy_device *));
Andy Flemingf62220d2008-04-18 17:29:54 -0500840int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
Sergei Shtylyov4017b4d2014-01-05 03:20:17 +0300841 int (*run)(struct phy_device *));
Andy Flemingf62220d2008-04-18 17:29:54 -0500842
Giuseppe CAVALLAROa59a4d12012-06-27 21:14:38 +0000843int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable);
844int phy_get_eee_err(struct phy_device *phydev);
845int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data);
846int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data);
Michael Stapelberg42e836e2013-03-11 13:56:44 +0000847int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol);
Sergei Shtylyov4017b4d2014-01-05 03:20:17 +0300848void phy_ethtool_get_wol(struct phy_device *phydev,
849 struct ethtool_wolinfo *wol);
Philippe Reynes9d9a77c2016-05-10 00:19:41 +0200850int phy_ethtool_get_link_ksettings(struct net_device *ndev,
851 struct ethtool_link_ksettings *cmd);
852int phy_ethtool_set_link_ksettings(struct net_device *ndev,
853 const struct ethtool_link_ksettings *cmd);
Giuseppe CAVALLAROa59a4d12012-06-27 21:14:38 +0000854
Andy Fleming9b9a8bf2008-05-02 13:00:51 -0500855int __init mdio_bus_init(void);
856void mdio_bus_exit(void);
857
Andy Fleming00db8182005-07-30 19:31:23 -0400858extern struct bus_type mdio_bus_type;
Johan Hovoldc31accd2014-11-11 19:45:57 +0100859
860/**
861 * module_phy_driver() - Helper macro for registering PHY drivers
862 * @__phy_drivers: array of PHY drivers to register
863 *
864 * Helper macro for PHY drivers which do not do anything special in module
865 * init/exit. Each module may only use this macro once, and calling it
866 * replaces module_init() and module_exit().
867 */
868#define phy_module_driver(__phy_drivers, __count) \
869static int __init phy_module_init(void) \
870{ \
Andrew Lunnbe01da72016-01-06 20:11:22 +0100871 return phy_drivers_register(__phy_drivers, __count, THIS_MODULE); \
Johan Hovoldc31accd2014-11-11 19:45:57 +0100872} \
873module_init(phy_module_init); \
874static void __exit phy_module_exit(void) \
875{ \
876 phy_drivers_unregister(__phy_drivers, __count); \
877} \
878module_exit(phy_module_exit)
879
880#define module_phy_driver(__phy_drivers) \
881 phy_module_driver(__phy_drivers, ARRAY_SIZE(__phy_drivers))
882
Andy Fleming00db8182005-07-30 19:31:23 -0400883#endif /* __PHY_H */