1 /*
2 * 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
19 #include <linux/compiler.h>
20 #include <linux/spinlock.h>
21 #include <linux/ethtool.h>
22 #include <linux/mdio.h>
23 #include <linux/mii.h>
24 #include <linux/module.h>
25 #include <linux/timer.h>
26 #include <linux/workqueue.h>
27 #include <linux/mod_devicetable.h>
28
29 #include <linux/atomic.h>
30
31 #define PHY_DEFAULT_FEATURES (SUPPORTED_Autoneg | \
32 SUPPORTED_TP | \
33 SUPPORTED_MII)
34
35 #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 | \
42 SUPPORTED_1000baseT_Full)
43
44 #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
52 /*
53 * Set phydev->irq to PHY_POLL if interrupts are not supported,
54 * 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_IS_INTERNAL 0x00000002
62 #define MDIO_DEVICE_IS_PHY 0x80000000
63
64 /* Interface Mode definitions */
65 typedef enum {
66 PHY_INTERFACE_MODE_NA,
67 PHY_INTERFACE_MODE_INTERNAL,
68 PHY_INTERFACE_MODE_MII,
69 PHY_INTERFACE_MODE_GMII,
70 PHY_INTERFACE_MODE_SGMII,
71 PHY_INTERFACE_MODE_TBI,
72 PHY_INTERFACE_MODE_REVMII,
73 PHY_INTERFACE_MODE_RMII,
74 PHY_INTERFACE_MODE_RGMII,
75 PHY_INTERFACE_MODE_RGMII_ID,
76 PHY_INTERFACE_MODE_RGMII_RXID,
77 PHY_INTERFACE_MODE_RGMII_TXID,
78 PHY_INTERFACE_MODE_RTBI,
79 PHY_INTERFACE_MODE_SMII,
80 PHY_INTERFACE_MODE_XGMII,
81 PHY_INTERFACE_MODE_MOCA,
82 PHY_INTERFACE_MODE_QSGMII,
83 PHY_INTERFACE_MODE_TRGMII,
84 PHY_INTERFACE_MODE_1000BASEX,
85 PHY_INTERFACE_MODE_2500BASEX,
86 PHY_INTERFACE_MODE_RXAUI,
87 PHY_INTERFACE_MODE_XAUI,
88 /* 10GBASE-KR, XFI, SFI - single lane 10G Serdes */
89 PHY_INTERFACE_MODE_10GKR,
90 PHY_INTERFACE_MODE_MAX,
91 } phy_interface_t;
92
93 /**
94 * phy_supported_speeds - return all speeds currently supported by a phy device
95 * @phy: The phy device to return supported speeds of.
96 * @speeds: buffer to store supported speeds in.
97 * @size: size of speeds buffer.
98 *
99 * Description: Returns the number of supported speeds, and
100 * fills the speeds * buffer with the supported speeds. If speeds buffer is
101 * too small to contain * all currently supported speeds, will return as
102 * many speeds as can fit.
103 */
104 unsigned int phy_supported_speeds(struct phy_device *phy,
105 unsigned int *speeds,
106 unsigned int size);
107
108 /**
109 * It maps 'enum phy_interface_t' found in include/linux/phy.h
110 * into the device tree binding of 'phy-mode', so that Ethernet
111 * device driver can get phy interface from device tree.
112 */
113 static inline const char *phy_modes(phy_interface_t interface)
114 {
115 switch (interface) {
116 case PHY_INTERFACE_MODE_NA:
117 return "";
118 case PHY_INTERFACE_MODE_INTERNAL:
119 return "internal";
120 case PHY_INTERFACE_MODE_MII:
121 return "mii";
122 case PHY_INTERFACE_MODE_GMII:
123 return "gmii";
124 case PHY_INTERFACE_MODE_SGMII:
125 return "sgmii";
126 case PHY_INTERFACE_MODE_TBI:
127 return "tbi";
128 case PHY_INTERFACE_MODE_REVMII:
129 return "rev-mii";
130 case PHY_INTERFACE_MODE_RMII:
131 return "rmii";
132 case PHY_INTERFACE_MODE_RGMII:
133 return "rgmii";
134 case PHY_INTERFACE_MODE_RGMII_ID:
135 return "rgmii-id";
136 case PHY_INTERFACE_MODE_RGMII_RXID:
137 return "rgmii-rxid";
138 case PHY_INTERFACE_MODE_RGMII_TXID:
139 return "rgmii-txid";
140 case PHY_INTERFACE_MODE_RTBI:
141 return "rtbi";
142 case PHY_INTERFACE_MODE_SMII:
143 return "smii";
144 case PHY_INTERFACE_MODE_XGMII:
145 return "xgmii";
146 case PHY_INTERFACE_MODE_MOCA:
147 return "moca";
148 case PHY_INTERFACE_MODE_QSGMII:
149 return "qsgmii";
150 case PHY_INTERFACE_MODE_TRGMII:
151 return "trgmii";
152 case PHY_INTERFACE_MODE_1000BASEX:
153 return "1000base-x";
154 case PHY_INTERFACE_MODE_2500BASEX:
155 return "2500base-x";
156 case PHY_INTERFACE_MODE_RXAUI:
157 return "rxaui";
158 case PHY_INTERFACE_MODE_XAUI:
159 return "xaui";
160 case PHY_INTERFACE_MODE_10GKR:
161 return "10gbase-kr";
162 default:
163 return "unknown";
164 }
165 }
166
167
168 #define PHY_INIT_TIMEOUT 100000
169 #define PHY_STATE_TIME 1
170 #define PHY_FORCE_TIMEOUT 10
171 #define PHY_AN_TIMEOUT 10
172
173 #define PHY_MAX_ADDR 32
174
175 /* Used when trying to connect to a specific phy (mii bus id:phy device id) */
176 #define PHY_ID_FMT "%s:%02x"
177
178 #define MII_BUS_ID_SIZE 61
179
180 /* Or MII_ADDR_C45 into regnum for read/write on mii_bus to enable the 21 bit
181 IEEE 802.3ae clause 45 addressing mode used by 10GIGE phy chips. */
182 #define MII_ADDR_C45 (1<<30)
183
184 struct device;
185 struct phylink;
186 struct sk_buff;
187
188 /*
189 * The Bus class for PHYs. Devices which provide access to
190 * PHYs should register using this structure
191 */
192 struct mii_bus {
193 struct module *owner;
194 const char *name;
195 char id[MII_BUS_ID_SIZE];
196 void *priv;
197 int (*read)(struct mii_bus *bus, int addr, int regnum);
198 int (*write)(struct mii_bus *bus, int addr, int regnum, u16 val);
199 int (*reset)(struct mii_bus *bus);
200
201 /*
202 * A lock to ensure that only one thing can read/write
203 * the MDIO bus at a time
204 */
205 struct mutex mdio_lock;
206
207 struct device *parent;
208 enum {
209 MDIOBUS_ALLOCATED = 1,
210 MDIOBUS_REGISTERED,
211 MDIOBUS_UNREGISTERED,
212 MDIOBUS_RELEASED,
213 } state;
214 struct device dev;
215
216 /* list of all PHYs on bus */
217 struct mdio_device *mdio_map[PHY_MAX_ADDR];
218
219 /* PHY addresses to be ignored when probing */
220 u32 phy_mask;
221
222 /* PHY addresses to ignore the TA/read failure */
223 u32 phy_ignore_ta_mask;
224
225 /*
226 * An array of interrupts, each PHY's interrupt at the index
227 * matching its address
228 */
229 int irq[PHY_MAX_ADDR];
230
231 /* GPIO reset pulse width in microseconds */
232 int reset_delay_us;
233 /* RESET GPIO descriptor pointer */
234 struct gpio_desc *reset_gpiod;
235 };
236 #define to_mii_bus(d) container_of(d, struct mii_bus, dev)
237
238 struct mii_bus *mdiobus_alloc_size(size_t);
239 static inline struct mii_bus *mdiobus_alloc(void)
240 {
241 return mdiobus_alloc_size(0);
242 }
243
244 int __mdiobus_register(struct mii_bus *bus, struct module *owner);
245 #define mdiobus_register(bus) __mdiobus_register(bus, THIS_MODULE)
246 void mdiobus_unregister(struct mii_bus *bus);
247 void mdiobus_free(struct mii_bus *bus);
248 struct mii_bus *devm_mdiobus_alloc_size(struct device *dev, int sizeof_priv);
249 static inline struct mii_bus *devm_mdiobus_alloc(struct device *dev)
250 {
251 return devm_mdiobus_alloc_size(dev, 0);
252 }
253
254 void devm_mdiobus_free(struct device *dev, struct mii_bus *bus);
255 struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr);
256
257 #define PHY_INTERRUPT_DISABLED 0x0
258 #define PHY_INTERRUPT_ENABLED 0x80000000
259
260 /* PHY state machine states:
261 *
262 * DOWN: PHY device and driver are not ready for anything. probe
263 * should be called if and only if the PHY is in this state,
264 * given that the PHY device exists.
265 * - PHY driver probe function will, depending on the PHY, set
266 * the state to STARTING or READY
267 *
268 * STARTING: PHY device is coming up, and the ethernet driver is
269 * not ready. PHY drivers may set this in the probe function.
270 * If they do, they are responsible for making sure the state is
271 * eventually set to indicate whether the PHY is UP or READY,
272 * depending on the state when the PHY is done starting up.
273 * - PHY driver will set the state to READY
274 * - start will set the state to PENDING
275 *
276 * READY: PHY is ready to send and receive packets, but the
277 * controller is not. By default, PHYs which do not implement
278 * probe will be set to this state by phy_probe(). If the PHY
279 * driver knows the PHY is ready, and the PHY state is STARTING,
280 * then it sets this STATE.
281 * - start will set the state to UP
282 *
283 * PENDING: PHY device is coming up, but the ethernet driver is
284 * ready. phy_start will set this state if the PHY state is
285 * STARTING.
286 * - PHY driver will set the state to UP when the PHY is ready
287 *
288 * UP: The PHY and attached device are ready to do work.
289 * Interrupts should be started here.
290 * - timer moves to AN
291 *
292 * AN: The PHY is currently negotiating the link state. Link is
293 * therefore down for now. phy_timer will set this state when it
294 * detects the state is UP. config_aneg will set this state
295 * whenever called with phydev->autoneg set to AUTONEG_ENABLE.
296 * - If autonegotiation finishes, but there's no link, it sets
297 * the state to NOLINK.
298 * - If aneg finishes with link, it sets the state to RUNNING,
299 * and calls adjust_link
300 * - If autonegotiation did not finish after an arbitrary amount
301 * of time, autonegotiation should be tried again if the PHY
302 * supports "magic" autonegotiation (back to AN)
303 * - If it didn't finish, and no magic_aneg, move to FORCING.
304 *
305 * NOLINK: PHY is up, but not currently plugged in.
306 * - If the timer notes that the link comes back, we move to RUNNING
307 * - config_aneg moves to AN
308 * - phy_stop moves to HALTED
309 *
310 * FORCING: PHY is being configured with forced settings
311 * - if link is up, move to RUNNING
312 * - If link is down, we drop to the next highest setting, and
313 * retry (FORCING) after a timeout
314 * - phy_stop moves to HALTED
315 *
316 * RUNNING: PHY is currently up, running, and possibly sending
317 * and/or receiving packets
318 * - timer will set CHANGELINK if we're polling (this ensures the
319 * link state is polled every other cycle of this state machine,
320 * which makes it every other second)
321 * - irq will set CHANGELINK
322 * - config_aneg will set AN
323 * - phy_stop moves to HALTED
324 *
325 * CHANGELINK: PHY experienced a change in link state
326 * - timer moves to RUNNING if link
327 * - timer moves to NOLINK if the link is down
328 * - phy_stop moves to HALTED
329 *
330 * HALTED: PHY is up, but no polling or interrupts are done. Or
331 * PHY is in an error state.
332 *
333 * - phy_start moves to RESUMING
334 *
335 * RESUMING: PHY was halted, but now wants to run again.
336 * - If we are forcing, or aneg is done, timer moves to RUNNING
337 * - If aneg is not done, timer moves to AN
338 * - phy_stop moves to HALTED
339 */
340 enum phy_state {
341 PHY_DOWN = 0,
342 PHY_STARTING,
343 PHY_READY,
344 PHY_PENDING,
345 PHY_UP,
346 PHY_AN,
347 PHY_RUNNING,
348 PHY_NOLINK,
349 PHY_FORCING,
350 PHY_CHANGELINK,
351 PHY_HALTED,
352 PHY_RESUMING
353 };
354
355 /**
356 * struct phy_c45_device_ids - 802.3-c45 Device Identifiers
357 * @devices_in_package: Bit vector of devices present.
358 * @device_ids: The device identifer for each present device.
359 */
360 struct phy_c45_device_ids {
361 u32 devices_in_package;
362 u32 device_ids[8];
363 };
364
365 /* phy_device: An instance of a PHY
366 *
367 * drv: Pointer to the driver for this PHY instance
368 * phy_id: UID for this device found during discovery
369 * c45_ids: 802.3-c45 Device Identifers if is_c45.
370 * is_c45: Set to true if this phy uses clause 45 addressing.
371 * is_internal: Set to true if this phy is internal to a MAC.
372 * is_pseudo_fixed_link: Set to true if this phy is an Ethernet switch, etc.
373 * has_fixups: Set to true if this phy has fixups/quirks.
374 * suspended: Set to true if this phy has been suspended successfully.
375 * sysfs_links: Internal boolean tracking sysfs symbolic links setup/removal.
376 * loopback_enabled: Set true if this phy has been loopbacked successfully.
377 * state: state of the PHY for management purposes
378 * dev_flags: Device-specific flags used by the PHY driver.
379 * link_timeout: The number of timer firings to wait before the
380 * giving up on the current attempt at acquiring a link
381 * irq: IRQ number of the PHY's interrupt (-1 if none)
382 * phy_timer: The timer for handling the state machine
383 * phy_queue: A work_queue for the phy_mac_interrupt
384 * attached_dev: The attached enet driver's device instance ptr
385 * adjust_link: Callback for the enet controller to respond to
386 * changes in the link state.
387 *
388 * speed, duplex, pause, supported, advertising, lp_advertising,
389 * and autoneg are used like in mii_if_info
390 *
391 * interrupts currently only supports enabled or disabled,
392 * but could be changed in the future to support enabling
393 * and disabling specific interrupts
394 *
395 * Contains some infrastructure for polling and interrupt
396 * handling, as well as handling shifts in PHY hardware state
397 */
398 struct phy_device {
399 struct mdio_device mdio;
400
401 /* Information about the PHY type */
402 /* And management functions */
403 struct phy_driver *drv;
404
405 u32 phy_id;
406
407 struct phy_c45_device_ids c45_ids;
408 bool is_c45;
409 bool is_internal;
410 bool is_pseudo_fixed_link;
411 bool has_fixups;
412 bool suspended;
413 bool sysfs_links;
414 bool loopback_enabled;
415
416 enum phy_state state;
417
418 u32 dev_flags;
419
420 phy_interface_t interface;
421
422 /*
423 * forced speed & duplex (no autoneg)
424 * partner speed & duplex & pause (autoneg)
425 */
426 int speed;
427 int duplex;
428 int pause;
429 int asym_pause;
430
431 /* The most recently read link state */
432 int link;
433
434 /* Enabled Interrupts */
435 u32 interrupts;
436
437 /* Union of PHY and Attached devices' supported modes */
438 /* See mii.h for more info */
439 u32 supported;
440 u32 advertising;
441 u32 lp_advertising;
442
443 /* Energy efficient ethernet modes which should be prohibited */
444 u32 eee_broken_modes;
445
446 int autoneg;
447
448 int link_timeout;
449
450 #ifdef CONFIG_LED_TRIGGER_PHY
451 struct phy_led_trigger *phy_led_triggers;
452 unsigned int phy_num_led_triggers;
453 struct phy_led_trigger *last_triggered;
454
455 struct phy_led_trigger *led_link_trigger;
456 #endif
457
458 /*
459 * Interrupt number for this PHY
460 * -1 means no interrupt
461 */
462 int irq;
463
464 /* private data pointer */
465 /* For use by PHYs to maintain extra state */
466 void *priv;
467
468 /* Interrupt and Polling infrastructure */
469 struct work_struct phy_queue;
470 struct delayed_work state_queue;
471 atomic_t irq_disable;
472
473 struct mutex lock;
474
475 struct phylink *phylink;
476 struct net_device *attached_dev;
477
478 u8 mdix;
479 u8 mdix_ctrl;
480
481 void (*phy_link_change)(struct phy_device *, bool up, bool do_carrier);
482 void (*adjust_link)(struct net_device *dev);
483 };
484 #define to_phy_device(d) container_of(to_mdio_device(d), \
485 struct phy_device, mdio)
486
487 /* struct phy_driver: Driver structure for a particular PHY type
488 *
489 * driver_data: static driver data
490 * phy_id: The result of reading the UID registers of this PHY
491 * type, and ANDing them with the phy_id_mask. This driver
492 * only works for PHYs with IDs which match this field
493 * name: The friendly name of this PHY type
494 * phy_id_mask: Defines the important bits of the phy_id
495 * features: A list of features (speed, duplex, etc) supported
496 * by this PHY
497 * flags: A bitfield defining certain other features this PHY
498 * supports (like interrupts)
499 *
500 * The drivers must implement config_aneg and read_status. All
501 * other functions are optional. Note that none of these
502 * functions should be called from interrupt time. The goal is
503 * for the bus read/write functions to be able to block when the
504 * bus transaction is happening, and be freed up by an interrupt
505 * (The MPC85xx has this ability, though it is not currently
506 * supported in the driver).
507 */
508 struct phy_driver {
509 struct mdio_driver_common mdiodrv;
510 u32 phy_id;
511 char *name;
512 unsigned int phy_id_mask;
513 u32 features;
514 u32 flags;
515 const void *driver_data;
516
517 /*
518 * Called to issue a PHY software reset
519 */
520 int (*soft_reset)(struct phy_device *phydev);
521
522 /*
523 * Called to initialize the PHY,
524 * including after a reset
525 */
526 int (*config_init)(struct phy_device *phydev);
527
528 /*
529 * Called during discovery. Used to set
530 * up device-specific structures, if any
531 */
532 int (*probe)(struct phy_device *phydev);
533
534 /* PHY Power Management */
535 int (*suspend)(struct phy_device *phydev);
536 int (*resume)(struct phy_device *phydev);
537
538 /*
539 * Configures the advertisement and resets
540 * autonegotiation if phydev->autoneg is on,
541 * forces the speed to the current settings in phydev
542 * if phydev->autoneg is off
543 */
544 int (*config_aneg)(struct phy_device *phydev);
545
546 /* Determines the auto negotiation result */
547 int (*aneg_done)(struct phy_device *phydev);
548
549 /* Determines the negotiated speed and duplex */
550 int (*read_status)(struct phy_device *phydev);
551
552 /* Clears any pending interrupts */
553 int (*ack_interrupt)(struct phy_device *phydev);
554
555 /* Enables or disables interrupts */
556 int (*config_intr)(struct phy_device *phydev);
557
558 /*
559 * Checks if the PHY generated an interrupt.
560 * For multi-PHY devices with shared PHY interrupt pin
561 */
562 int (*did_interrupt)(struct phy_device *phydev);
563
564 /* Clears up any memory if needed */
565 void (*remove)(struct phy_device *phydev);
566
567 /* Returns true if this is a suitable driver for the given
568 * phydev. If NULL, matching is based on phy_id and
569 * phy_id_mask.
570 */
571 int (*match_phy_device)(struct phy_device *phydev);
572
573 /* Handles ethtool queries for hardware time stamping. */
574 int (*ts_info)(struct phy_device *phydev, struct ethtool_ts_info *ti);
575
576 /* Handles SIOCSHWTSTAMP ioctl for hardware time stamping. */
577 int (*hwtstamp)(struct phy_device *phydev, struct ifreq *ifr);
578
579 /*
580 * Requests a Rx timestamp for 'skb'. If the skb is accepted,
581 * the phy driver promises to deliver it using netif_rx() as
582 * soon as a timestamp becomes available. One of the
583 * PTP_CLASS_ values is passed in 'type'. The function must
584 * return true if the skb is accepted for delivery.
585 */
586 bool (*rxtstamp)(struct phy_device *dev, struct sk_buff *skb, int type);
587
588 /*
589 * Requests a Tx timestamp for 'skb'. The phy driver promises
590 * to deliver it using skb_complete_tx_timestamp() as soon as a
591 * timestamp becomes available. One of the PTP_CLASS_ values
592 * is passed in 'type'.
593 */
594 void (*txtstamp)(struct phy_device *dev, struct sk_buff *skb, int type);
595
596 /* Some devices (e.g. qnap TS-119P II) require PHY register changes to
597 * enable Wake on LAN, so set_wol is provided to be called in the
598 * ethernet driver's set_wol function. */
599 int (*set_wol)(struct phy_device *dev, struct ethtool_wolinfo *wol);
600
601 /* See set_wol, but for checking whether Wake on LAN is enabled. */
602 void (*get_wol)(struct phy_device *dev, struct ethtool_wolinfo *wol);
603
604 /*
605 * Called to inform a PHY device driver when the core is about to
606 * change the link state. This callback is supposed to be used as
607 * fixup hook for drivers that need to take action when the link
608 * state changes. Drivers are by no means allowed to mess with the
609 * PHY device structure in their implementations.
610 */
611 void (*link_change_notify)(struct phy_device *dev);
612
613 /*
614 * Phy specific driver override for reading a MMD register.
615 * This function is optional for PHY specific drivers. When
616 * not provided, the default MMD read function will be used
617 * by phy_read_mmd(), which will use either a direct read for
618 * Clause 45 PHYs or an indirect read for Clause 22 PHYs.
619 * devnum is the MMD device number within the PHY device,
620 * regnum is the register within the selected MMD device.
621 */
622 int (*read_mmd)(struct phy_device *dev, int devnum, u16 regnum);
623
624 /*
625 * Phy specific driver override for writing a MMD register.
626 * This function is optional for PHY specific drivers. When
627 * not provided, the default MMD write function will be used
628 * by phy_write_mmd(), which will use either a direct write for
629 * Clause 45 PHYs, or an indirect write for Clause 22 PHYs.
630 * devnum is the MMD device number within the PHY device,
631 * regnum is the register within the selected MMD device.
632 * val is the value to be written.
633 */
634 int (*write_mmd)(struct phy_device *dev, int devnum, u16 regnum,
635 u16 val);
636
637 /* Get the size and type of the eeprom contained within a plug-in
638 * module */
639 int (*module_info)(struct phy_device *dev,
640 struct ethtool_modinfo *modinfo);
641
642 /* Get the eeprom information from the plug-in module */
643 int (*module_eeprom)(struct phy_device *dev,
644 struct ethtool_eeprom *ee, u8 *data);
645
646 /* Get statistics from the phy using ethtool */
647 int (*get_sset_count)(struct phy_device *dev);
648 void (*get_strings)(struct phy_device *dev, u8 *data);
649 void (*get_stats)(struct phy_device *dev,
650 struct ethtool_stats *stats, u64 *data);
651
652 /* Get and Set PHY tunables */
653 int (*get_tunable)(struct phy_device *dev,
654 struct ethtool_tunable *tuna, void *data);
655 int (*set_tunable)(struct phy_device *dev,
656 struct ethtool_tunable *tuna,
657 const void *data);
658 int (*set_loopback)(struct phy_device *dev, bool enable);
659 };
660 #define to_phy_driver(d) container_of(to_mdio_common_driver(d), \
661 struct phy_driver, mdiodrv)
662
663 #define PHY_ANY_ID "MATCH ANY PHY"
664 #define PHY_ANY_UID 0xffffffff
665
666 /* A Structure for boards to register fixups with the PHY Lib */
667 struct phy_fixup {
668 struct list_head list;
669 char bus_id[MII_BUS_ID_SIZE + 3];
670 u32 phy_uid;
671 u32 phy_uid_mask;
672 int (*run)(struct phy_device *phydev);
673 };
674
675 const char *phy_speed_to_str(int speed);
676 const char *phy_duplex_to_str(unsigned int duplex);
677
678 /* A structure for mapping a particular speed and duplex
679 * combination to a particular SUPPORTED and ADVERTISED value
680 */
681 struct phy_setting {
682 u32 speed;
683 u8 duplex;
684 u8 bit;
685 };
686
687 const struct phy_setting *
688 phy_lookup_setting(int speed, int duplex, const unsigned long *mask,
689 size_t maxbit, bool exact);
690 size_t phy_speeds(unsigned int *speeds, size_t size,
691 unsigned long *mask, size_t maxbit);
692
693 /**
694 * phy_read_mmd - Convenience function for reading a register
695 * from an MMD on a given PHY.
696 * @phydev: The phy_device struct
697 * @devad: The MMD to read from
698 * @regnum: The register on the MMD to read
699 *
700 * Same rules as for phy_read();
701 */
702 int phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum);
703
704 /**
705 * phy_read - Convenience function for reading a given PHY register
706 * @phydev: the phy_device struct
707 * @regnum: register number to read
708 *
709 * NOTE: MUST NOT be called from interrupt context,
710 * because the bus read/write functions may wait for an interrupt
711 * to conclude the operation.
712 */
713 static inline int phy_read(struct phy_device *phydev, u32 regnum)
714 {
715 return mdiobus_read(phydev->mdio.bus, phydev->mdio.addr, regnum);
716 }
717
718 /**
719 * phy_write - Convenience function for writing a given PHY register
720 * @phydev: the phy_device struct
721 * @regnum: register number to write
722 * @val: value to write to @regnum
723 *
724 * NOTE: MUST NOT be called from interrupt context,
725 * because the bus read/write functions may wait for an interrupt
726 * to conclude the operation.
727 */
728 static inline int phy_write(struct phy_device *phydev, u32 regnum, u16 val)
729 {
730 return mdiobus_write(phydev->mdio.bus, phydev->mdio.addr, regnum, val);
731 }
732
733 /**
734 * phy_interrupt_is_valid - Convenience function for testing a given PHY irq
735 * @phydev: the phy_device struct
736 *
737 * NOTE: must be kept in sync with addition/removal of PHY_POLL and
738 * PHY_IGNORE_INTERRUPT
739 */
740 static inline bool phy_interrupt_is_valid(struct phy_device *phydev)
741 {
742 return phydev->irq != PHY_POLL && phydev->irq != PHY_IGNORE_INTERRUPT;
743 }
744
745 /**
746 * phy_is_internal - Convenience function for testing if a PHY is internal
747 * @phydev: the phy_device struct
748 */
749 static inline bool phy_is_internal(struct phy_device *phydev)
750 {
751 return phydev->is_internal;
752 }
753
754 /**
755 * phy_interface_mode_is_rgmii - Convenience function for testing if a
756 * PHY interface mode is RGMII (all variants)
757 * @mode: the phy_interface_t enum
758 */
759 static inline bool phy_interface_mode_is_rgmii(phy_interface_t mode)
760 {
761 return mode >= PHY_INTERFACE_MODE_RGMII &&
762 mode <= PHY_INTERFACE_MODE_RGMII_TXID;
763 };
764
765 /**
766 * phy_interface_is_rgmii - Convenience function for testing if a PHY interface
767 * is RGMII (all variants)
768 * @phydev: the phy_device struct
769 */
770 static inline bool phy_interface_is_rgmii(struct phy_device *phydev)
771 {
772 return phy_interface_mode_is_rgmii(phydev->interface);
773 };
774
775 /*
776 * phy_is_pseudo_fixed_link - Convenience function for testing if this
777 * PHY is the CPU port facing side of an Ethernet switch, or similar.
778 * @phydev: the phy_device struct
779 */
780 static inline bool phy_is_pseudo_fixed_link(struct phy_device *phydev)
781 {
782 return phydev->is_pseudo_fixed_link;
783 }
784
785 /**
786 * phy_write_mmd - Convenience function for writing a register
787 * on an MMD on a given PHY.
788 * @phydev: The phy_device struct
789 * @devad: The MMD to read from
790 * @regnum: The register on the MMD to read
791 * @val: value to write to @regnum
792 *
793 * Same rules as for phy_write();
794 */
795 int phy_write_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val);
796
797 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
798 bool is_c45,
799 struct phy_c45_device_ids *c45_ids);
800 #if IS_ENABLED(CONFIG_PHYLIB)
801 struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45);
802 int phy_device_register(struct phy_device *phy);
803 void phy_device_free(struct phy_device *phydev);
804 #else
805 static inline
806 struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
807 {
808 return NULL;
809 }
810
811 static inline int phy_device_register(struct phy_device *phy)
812 {
813 return 0;
814 }
815
816 static inline void phy_device_free(struct phy_device *phydev) { }
817 #endif /* CONFIG_PHYLIB */
818 void phy_device_remove(struct phy_device *phydev);
819 int phy_init_hw(struct phy_device *phydev);
820 int phy_suspend(struct phy_device *phydev);
821 int phy_resume(struct phy_device *phydev);
822 int __phy_resume(struct phy_device *phydev);
823 int phy_loopback(struct phy_device *phydev, bool enable);
824 struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
825 phy_interface_t interface);
826 struct phy_device *phy_find_first(struct mii_bus *bus);
827 int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
828 u32 flags, phy_interface_t interface);
829 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
830 void (*handler)(struct net_device *),
831 phy_interface_t interface);
832 struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
833 void (*handler)(struct net_device *),
834 phy_interface_t interface);
835 void phy_disconnect(struct phy_device *phydev);
836 void phy_detach(struct phy_device *phydev);
837 void phy_start(struct phy_device *phydev);
838 void phy_stop(struct phy_device *phydev);
839 int phy_start_aneg(struct phy_device *phydev);
840 int phy_aneg_done(struct phy_device *phydev);
841
842 int phy_stop_interrupts(struct phy_device *phydev);
843 int phy_restart_aneg(struct phy_device *phydev);
844
845 static inline int phy_read_status(struct phy_device *phydev)
846 {
847 if (!phydev->drv)
848 return -EIO;
849
850 return phydev->drv->read_status(phydev);
851 }
852
853 #define phydev_err(_phydev, format, args...) \
854 dev_err(&_phydev->mdio.dev, format, ##args)
855
856 #define phydev_dbg(_phydev, format, args...) \
857 dev_dbg(&_phydev->mdio.dev, format, ##args)
858
859 static inline const char *phydev_name(const struct phy_device *phydev)
860 {
861 return dev_name(&phydev->mdio.dev);
862 }
863
864 void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
865 __printf(2, 3);
866 void phy_attached_info(struct phy_device *phydev);
867
868 /* Clause 22 PHY */
869 int genphy_config_init(struct phy_device *phydev);
870 int genphy_setup_forced(struct phy_device *phydev);
871 int genphy_restart_aneg(struct phy_device *phydev);
872 int genphy_config_aneg(struct phy_device *phydev);
873 int genphy_aneg_done(struct phy_device *phydev);
874 int genphy_update_link(struct phy_device *phydev);
875 int genphy_read_status(struct phy_device *phydev);
876 int genphy_suspend(struct phy_device *phydev);
877 int genphy_resume(struct phy_device *phydev);
878 int genphy_loopback(struct phy_device *phydev, bool enable);
879 int genphy_soft_reset(struct phy_device *phydev);
880 static inline int genphy_no_soft_reset(struct phy_device *phydev)
881 {
882 return 0;
883 }
884
885 /* Clause 45 PHY */
886 int genphy_c45_restart_aneg(struct phy_device *phydev);
887 int genphy_c45_aneg_done(struct phy_device *phydev);
888 int genphy_c45_read_link(struct phy_device *phydev, u32 mmd_mask);
889 int genphy_c45_read_lpa(struct phy_device *phydev);
890 int genphy_c45_read_pma(struct phy_device *phydev);
891 int genphy_c45_pma_setup_forced(struct phy_device *phydev);
892 int genphy_c45_an_disable_aneg(struct phy_device *phydev);
893
894 void phy_driver_unregister(struct phy_driver *drv);
895 void phy_drivers_unregister(struct phy_driver *drv, int n);
896 int phy_driver_register(struct phy_driver *new_driver, struct module *owner);
897 int phy_drivers_register(struct phy_driver *new_driver, int n,
898 struct module *owner);
899 void phy_state_machine(struct work_struct *work);
900 void phy_change_work(struct work_struct *work);
901 void phy_mac_interrupt(struct phy_device *phydev, int new_link);
902 void phy_start_machine(struct phy_device *phydev);
903 void phy_stop_machine(struct phy_device *phydev);
904 void phy_trigger_machine(struct phy_device *phydev, bool sync);
905 int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd);
906 void phy_ethtool_ksettings_get(struct phy_device *phydev,
907 struct ethtool_link_ksettings *cmd);
908 int phy_ethtool_ksettings_set(struct phy_device *phydev,
909 const struct ethtool_link_ksettings *cmd);
910 int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd);
911 int phy_start_interrupts(struct phy_device *phydev);
912 void phy_print_status(struct phy_device *phydev);
913 int phy_set_max_speed(struct phy_device *phydev, u32 max_speed);
914
915 int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
916 int (*run)(struct phy_device *));
917 int phy_register_fixup_for_id(const char *bus_id,
918 int (*run)(struct phy_device *));
919 int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
920 int (*run)(struct phy_device *));
921
922 int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask);
923 int phy_unregister_fixup_for_id(const char *bus_id);
924 int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask);
925
926 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable);
927 int phy_get_eee_err(struct phy_device *phydev);
928 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data);
929 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data);
930 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol);
931 void phy_ethtool_get_wol(struct phy_device *phydev,
932 struct ethtool_wolinfo *wol);
933 int phy_ethtool_get_link_ksettings(struct net_device *ndev,
934 struct ethtool_link_ksettings *cmd);
935 int phy_ethtool_set_link_ksettings(struct net_device *ndev,
936 const struct ethtool_link_ksettings *cmd);
937 int phy_ethtool_nway_reset(struct net_device *ndev);
938
939 #if IS_ENABLED(CONFIG_PHYLIB)
940 int __init mdio_bus_init(void);
941 void mdio_bus_exit(void);
942 #endif
943
944 extern struct bus_type mdio_bus_type;
945
946 struct mdio_board_info {
947 const char *bus_id;
948 char modalias[MDIO_NAME_SIZE];
949 int mdio_addr;
950 const void *platform_data;
951 };
952
953 #if IS_ENABLED(CONFIG_MDIO_DEVICE)
954 int mdiobus_register_board_info(const struct mdio_board_info *info,
955 unsigned int n);
956 #else
957 static inline int mdiobus_register_board_info(const struct mdio_board_info *i,
958 unsigned int n)
959 {
960 return 0;
961 }
962 #endif
963
964
965 /**
966 * module_phy_driver() - Helper macro for registering PHY drivers
967 * @__phy_drivers: array of PHY drivers to register
968 *
969 * Helper macro for PHY drivers which do not do anything special in module
970 * init/exit. Each module may only use this macro once, and calling it
971 * replaces module_init() and module_exit().
972 */
973 #define phy_module_driver(__phy_drivers, __count) \
974 static int __init phy_module_init(void) \
975 { \
976 return phy_drivers_register(__phy_drivers, __count, THIS_MODULE); \
977 } \
978 module_init(phy_module_init); \
979 static void __exit phy_module_exit(void) \
980 { \
981 phy_drivers_unregister(__phy_drivers, __count); \
982 } \
983 module_exit(phy_module_exit)
984
985 #define module_phy_driver(__phy_drivers) \
986 phy_module_driver(__phy_drivers, ARRAY_SIZE(__phy_drivers))
987
988 #endif /* __PHY_H */
989
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.