1257 lines · 31.3 KB · C
RawDownload
/* Framework for configuring and reading PHY devices * Based on code in sungem_phy.c and gianfar_phy.c * * Author: Andy Fleming * * Copyright (c) 2004 Freescale Semiconductor, Inc. * Copyright (c) 2006, 2007  Maciej W. Rozycki * * This program is free software; you can redistribute  it and/or modify it * under  the terms of  the GNU General  Public License as published by the * Free Software Foundation;  either version 2 of the  License, or (at your * option) any later version. * */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/kernel.h>#include <linux/string.h>#include <linux/errno.h>#include <linux/unistd.h>#include <linux/interrupt.h>#include <linux/delay.h>#include <linux/netdevice.h>#include <linux/etherdevice.h>#include <linux/skbuff.h>#include <linux/mm.h>#include <linux/module.h>#include <linux/mii.h>#include <linux/ethtool.h>#include <linux/phy.h>#include <linux/timer.h>#include <linux/workqueue.h>#include <linux/mdio.h>#include <linux/io.h>#include <linux/uaccess.h>#include <linux/atomic.h> #include <asm/irq.h> static const char *phy_speed_to_str(int speed){	switch (speed) {	case SPEED_10:		return "10Mbps";	case SPEED_100:		return "100Mbps";	case SPEED_1000:		return "1Gbps";	case SPEED_2500:		return "2.5Gbps";	case SPEED_10000:		return "10Gbps";	case SPEED_UNKNOWN:		return "Unknown";	default:		return "Unsupported (update phy.c)";	}} #define PHY_STATE_STR(_state)			\	case PHY_##_state:			\		return __stringify(_state);	\ static const char *phy_state_to_str(enum phy_state st){	switch (st) {	PHY_STATE_STR(DOWN)	PHY_STATE_STR(STARTING)	PHY_STATE_STR(READY)	PHY_STATE_STR(PENDING)	PHY_STATE_STR(UP)	PHY_STATE_STR(AN)	PHY_STATE_STR(RUNNING)	PHY_STATE_STR(NOLINK)	PHY_STATE_STR(FORCING)	PHY_STATE_STR(CHANGELINK)	PHY_STATE_STR(HALTED)	PHY_STATE_STR(RESUMING)	} 	return NULL;}  /** * phy_print_status - Convenience function to print out the current phy status * @phydev: the phy_device struct */void phy_print_status(struct phy_device *phydev){	if (phydev->link) {		netdev_info(phydev->attached_dev,			"Link is Up - %s/%s - flow control %s\n",			phy_speed_to_str(phydev->speed),			DUPLEX_FULL == phydev->duplex ? "Full" : "Half",			phydev->pause ? "rx/tx" : "off");	} else	{		netdev_info(phydev->attached_dev, "Link is Down\n");	}}EXPORT_SYMBOL(phy_print_status); /** * phy_clear_interrupt - Ack the phy device's interrupt * @phydev: the phy_device struct * * If the @phydev driver has an ack_interrupt function, call it to * ack and clear the phy device's interrupt. * * Returns 0 on success or < 0 on error. */static int phy_clear_interrupt(struct phy_device *phydev){	if (phydev->drv->ack_interrupt)		return phydev->drv->ack_interrupt(phydev); 	return 0;} /** * phy_config_interrupt - configure the PHY device for the requested interrupts * @phydev: the phy_device struct * @interrupts: interrupt flags to configure for this @phydev * * Returns 0 on success or < 0 on error. */static int phy_config_interrupt(struct phy_device *phydev, u32 interrupts){	phydev->interrupts = interrupts;	if (phydev->drv->config_intr)		return phydev->drv->config_intr(phydev); 	return 0;}  /** * phy_aneg_done - return auto-negotiation status * @phydev: target phy_device struct * * Description: Return the auto-negotiation status from this @phydev * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation * is still pending. */static inline int phy_aneg_done(struct phy_device *phydev){	if (phydev->drv->aneg_done)		return phydev->drv->aneg_done(phydev); 	return genphy_aneg_done(phydev);} /* A structure for mapping a particular speed and duplex * combination to a particular SUPPORTED and ADVERTISED value */struct phy_setting {	int speed;	int duplex;	u32 setting;}; /* A mapping of all SUPPORTED settings to speed/duplex */static const struct phy_setting settings[] = {	{		.speed = SPEED_10000,		.duplex = DUPLEX_FULL,		.setting = SUPPORTED_10000baseKR_Full,	},	{		.speed = SPEED_10000,		.duplex = DUPLEX_FULL,		.setting = SUPPORTED_10000baseKX4_Full,	},	{		.speed = SPEED_10000,		.duplex = DUPLEX_FULL,		.setting = SUPPORTED_10000baseT_Full,	},	{		.speed = SPEED_2500,		.duplex = DUPLEX_FULL,		.setting = SUPPORTED_2500baseX_Full,	},	{		.speed = SPEED_1000,		.duplex = DUPLEX_FULL,		.setting = SUPPORTED_1000baseKX_Full,	},	{		.speed = SPEED_1000,		.duplex = DUPLEX_FULL,		.setting = SUPPORTED_1000baseT_Full,	},	{		.speed = SPEED_1000,		.duplex = DUPLEX_HALF,		.setting = SUPPORTED_1000baseT_Half,	},	{		.speed = SPEED_100,		.duplex = DUPLEX_FULL,		.setting = SUPPORTED_100baseT_Full,	},	{		.speed = SPEED_100,		.duplex = DUPLEX_HALF,		.setting = SUPPORTED_100baseT_Half,	},	{		.speed = SPEED_10,		.duplex = DUPLEX_FULL,		.setting = SUPPORTED_10baseT_Full,	},	{		.speed = SPEED_10,		.duplex = DUPLEX_HALF,		.setting = SUPPORTED_10baseT_Half,	},}; #define MAX_NUM_SETTINGS ARRAY_SIZE(settings) /** * phy_find_setting - find a PHY settings array entry that matches speed & duplex * @speed: speed to match * @duplex: duplex to match * * Description: Searches the settings array for the setting which *   matches the desired speed and duplex, and returns the index *   of that setting.  Returns the index of the last setting if *   none of the others match. */static inline unsigned int phy_find_setting(int speed, int duplex){	unsigned int idx = 0; 	while (idx < ARRAY_SIZE(settings) &&	       (settings[idx].speed != speed || settings[idx].duplex != duplex))		idx++; 	return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1;} /** * phy_find_valid - find a PHY setting that matches the requested features mask * @idx: The first index in settings[] to search * @features: A mask of the valid settings * * Description: Returns the index of the first valid setting less *   than or equal to the one pointed to by idx, as determined by *   the mask in features.  Returns the index of the last setting *   if nothing else matches. */static inline unsigned int phy_find_valid(unsigned int idx, u32 features){	while (idx < MAX_NUM_SETTINGS && !(settings[idx].setting & features))		idx++; 	return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1;} /** * phy_check_valid - check if there is a valid PHY setting which matches *		     speed, duplex, and feature mask * @speed: speed to match * @duplex: duplex to match * @features: A mask of the valid settings * * Description: Returns true if there is a valid setting, false otherwise. */static inline bool phy_check_valid(int speed, int duplex, u32 features){	unsigned int idx; 	idx = phy_find_valid(phy_find_setting(speed, duplex), features); 	return settings[idx].speed == speed && settings[idx].duplex == duplex &&		(settings[idx].setting & features);} /** * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex * @phydev: the target phy_device struct * * Description: Make sure the PHY is set to supported speeds and *   duplexes.  Drop down by one in this order:  1000/FULL, *   1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF. */static void phy_sanitize_settings(struct phy_device *phydev){	u32 features = phydev->supported;	unsigned int idx; 	/* Sanitize settings based on PHY capabilities */	if ((features & SUPPORTED_Autoneg) == 0)		phydev->autoneg = AUTONEG_DISABLE; 	idx = phy_find_valid(phy_find_setting(phydev->speed, phydev->duplex),			features); 	phydev->speed = settings[idx].speed;	phydev->duplex = settings[idx].duplex;} /** * phy_ethtool_sset - generic ethtool sset function, handles all the details * @phydev: target phy_device struct * @cmd: ethtool_cmd * * A few notes about parameter checking: * - We don't set port or transceiver, so we don't care what they *   were set to. * - phy_start_aneg() will make sure forced settings are sane, and *   choose the next best ones from the ones selected, so we don't *   care if ethtool tries to give us bad values. */int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd){	u32 speed = ethtool_cmd_speed(cmd); 	if (cmd->phy_address != phydev->addr)		return -EINVAL; 	/* We make sure that we don't pass unsupported values in to the PHY */	cmd->advertising &= phydev->supported; 	/* Verify the settings we care about. */	if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE)		return -EINVAL; 	if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0)		return -EINVAL; 	if (cmd->autoneg == AUTONEG_DISABLE &&	    ((speed != SPEED_1000 &&	      speed != SPEED_100 &&	      speed != SPEED_10) ||	     (cmd->duplex != DUPLEX_HALF &&	      cmd->duplex != DUPLEX_FULL)))		return -EINVAL; 	phydev->autoneg = cmd->autoneg; 	phydev->speed = speed; 	phydev->advertising = cmd->advertising; 	if (AUTONEG_ENABLE == cmd->autoneg)		phydev->advertising |= ADVERTISED_Autoneg;	else		phydev->advertising &= ~ADVERTISED_Autoneg; 	phydev->duplex = cmd->duplex; 	/* Restart the PHY */	phy_start_aneg(phydev); 	return 0;}EXPORT_SYMBOL(phy_ethtool_sset); int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd){	cmd->supported = phydev->supported; 	cmd->advertising = phydev->advertising;	cmd->lp_advertising = phydev->lp_advertising; 	ethtool_cmd_speed_set(cmd, phydev->speed);	cmd->duplex = phydev->duplex;	if (phydev->interface == PHY_INTERFACE_MODE_MOCA)		cmd->port = PORT_BNC;	else		cmd->port = PORT_MII;	cmd->phy_address = phydev->addr;	cmd->transceiver = phy_is_internal(phydev) ?		XCVR_INTERNAL : XCVR_EXTERNAL;	cmd->autoneg = phydev->autoneg; 	return 0;}EXPORT_SYMBOL(phy_ethtool_gset); /** * phy_mii_ioctl - generic PHY MII ioctl interface * @phydev: the phy_device struct * @ifr: &struct ifreq for socket ioctl's * @cmd: ioctl cmd to execute * * Note that this function is currently incompatible with the * PHYCONTROL layer.  It changes registers without regard to * current state.  Use at own risk. */int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd){	struct mii_ioctl_data *mii_data = if_mii(ifr);	u16 val = mii_data->val_in;	bool change_autoneg = false; 	switch (cmd) {	case SIOCGMIIPHY:		mii_data->phy_id = phydev->addr;		/* fall through */ 	case SIOCGMIIREG:		mii_data->val_out = mdiobus_read(phydev->bus, mii_data->phy_id,						 mii_data->reg_num);		return 0; 	case SIOCSMIIREG:		if (mii_data->phy_id == phydev->addr) {			switch (mii_data->reg_num) {			case MII_BMCR:				if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) {					if (phydev->autoneg == AUTONEG_ENABLE)						change_autoneg = true;					phydev->autoneg = AUTONEG_DISABLE;					if (val & BMCR_FULLDPLX)						phydev->duplex = DUPLEX_FULL;					else						phydev->duplex = DUPLEX_HALF;					if (val & BMCR_SPEED1000)						phydev->speed = SPEED_1000;					else if (val & BMCR_SPEED100)						phydev->speed = SPEED_100;					else phydev->speed = SPEED_10;				}				else {					if (phydev->autoneg == AUTONEG_DISABLE)						change_autoneg = true;					phydev->autoneg = AUTONEG_ENABLE;				}				break;			case MII_ADVERTISE:				phydev->advertising = mii_adv_to_ethtool_adv_t(val);				change_autoneg = true;				break;			default:				/* do nothing */				break;			}		} 		mdiobus_write(phydev->bus, mii_data->phy_id,			      mii_data->reg_num, val); 		if (mii_data->reg_num == MII_BMCR &&		    val & BMCR_RESET)			return phy_init_hw(phydev); 		if (change_autoneg)			return phy_start_aneg(phydev); 		return 0; 	case SIOCSHWTSTAMP:		if (phydev->drv->hwtstamp)			return phydev->drv->hwtstamp(phydev, ifr);		/* fall through */ 	default:		return -EOPNOTSUPP;	}}EXPORT_SYMBOL(phy_mii_ioctl); /** * phy_start_aneg - start auto-negotiation for this PHY device * @phydev: the phy_device struct * * Description: Sanitizes the settings (if we're not autonegotiating *   them), and then calls the driver's config_aneg function. *   If the PHYCONTROL Layer is operating, we change the state to *   reflect the beginning of Auto-negotiation or forcing. */int phy_start_aneg(struct phy_device *phydev){	int err; 	mutex_lock(&phydev->lock); 	if (AUTONEG_DISABLE == phydev->autoneg)		phy_sanitize_settings(phydev); 	/* Invalidate LP advertising flags */	phydev->lp_advertising = 0; 	err = phydev->drv->config_aneg(phydev);	if (err < 0)		goto out_unlock; 	if (phydev->state != PHY_HALTED) {		if (AUTONEG_ENABLE == phydev->autoneg) {			phydev->state = PHY_AN;			phydev->link_timeout = PHY_AN_TIMEOUT;		} else {			phydev->state = PHY_FORCING;			phydev->link_timeout = PHY_FORCE_TIMEOUT;		}

Lines 1–500 of 1257.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t