~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/phy.h

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp