[linux-2.6-block.git] / drivers / net / phy / phy-core.c

/*
 * Core PHY library, taken from phy.c
 *
 * 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.
 */
#include <linux/export.h>
#include <linux/phy.h>

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_5000:
		return "5Gbps";
	case SPEED_10000:
		return "10Gbps";
	case SPEED_14000:
		return "14Gbps";
	case SPEED_20000:
		return "20Gbps";
	case SPEED_25000:
		return "25Gbps";
	case SPEED_40000:
		return "40Gbps";
	case SPEED_50000:
		return "50Gbps";
	case SPEED_56000:
		return "56Gbps";
	case SPEED_100000:
		return "100Gbps";
	case SPEED_UNKNOWN:
		return "Unknown";
	default:
		return "Unsupported (update phy-core.c)";
	}
}
EXPORT_SYMBOL_GPL(phy_speed_to_str);

const char *phy_duplex_to_str(unsigned int duplex)
{
	if (duplex == DUPLEX_HALF)
		return "Half";
	if (duplex == DUPLEX_FULL)
		return "Full";
	if (duplex == DUPLEX_UNKNOWN)
		return "Unknown";
	return "Unsupported (update phy-core.c)";
}
EXPORT_SYMBOL_GPL(phy_duplex_to_str);

/* A mapping of all SUPPORTED settings to speed/duplex.  This table
 * must be grouped by speed and sorted in descending match priority
 * - iow, descending speed. */
static const struct phy_setting settings[] = {
	{
		.speed = SPEED_10000,
		.duplex = DUPLEX_FULL,
		.bit = ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
	},
	{
		.speed = SPEED_10000,
		.duplex = DUPLEX_FULL,
		.bit = ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
	},
	{
		.speed = SPEED_10000,
		.duplex = DUPLEX_FULL,
		.bit = ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
	},
	{
		.speed = SPEED_2500,
		.duplex = DUPLEX_FULL,
		.bit = ETHTOOL_LINK_MODE_2500baseX_Full_BIT,
	},
	{
		.speed = SPEED_1000,
		.duplex = DUPLEX_FULL,
		.bit = ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
	},
	{
		.speed = SPEED_1000,
		.duplex = DUPLEX_FULL,
		.bit = ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
	},
	{
		.speed = SPEED_1000,
		.duplex = DUPLEX_FULL,
		.bit = ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
	},
	{
		.speed = SPEED_1000,
		.duplex = DUPLEX_HALF,
		.bit = ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
	},
	{
		.speed = SPEED_100,
		.duplex = DUPLEX_FULL,
		.bit = ETHTOOL_LINK_MODE_100baseT_Full_BIT,
	},
	{
		.speed = SPEED_100,
		.duplex = DUPLEX_HALF,
		.bit = ETHTOOL_LINK_MODE_100baseT_Half_BIT,
	},
	{
		.speed = SPEED_10,
		.duplex = DUPLEX_FULL,
		.bit = ETHTOOL_LINK_MODE_10baseT_Full_BIT,
	},
	{
		.speed = SPEED_10,
		.duplex = DUPLEX_HALF,
		.bit = ETHTOOL_LINK_MODE_10baseT_Half_BIT,
	},
};

/**
 * phy_lookup_setting - lookup a PHY setting
 * @speed: speed to match
 * @duplex: duplex to match
 * @mask: allowed link modes
 * @maxbit: bit size of link modes
 * @exact: an exact match is required
 *
 * Search the settings array for a setting that matches the speed and
 * duplex, and which is supported.
 *
 * If @exact is unset, either an exact match or %NULL for no match will
 * be returned.
 *
 * If @exact is set, an exact match, the fastest supported setting at
 * or below the specified speed, the slowest supported setting, or if
 * they all fail, %NULL will be returned.
 */
const struct phy_setting *
phy_lookup_setting(int speed, int duplex, const unsigned long *mask,
		   size_t maxbit, bool exact)
{
	const struct phy_setting *p, *match = NULL, *last = NULL;
	int i;

	for (i = 0, p = settings; i < ARRAY_SIZE(settings); i++, p++) {
		if (p->bit < maxbit && test_bit(p->bit, mask)) {
			last = p;
			if (p->speed == speed && p->duplex == duplex) {
				/* Exact match for speed and duplex */
				match = p;
				break;
			} else if (!exact) {
				if (!match && p->speed <= speed)
					/* Candidate */
					match = p;

				if (p->speed < speed)
					break;
			}
		}
	}

	if (!match && !exact)
		match = last;

	return match;
}
EXPORT_SYMBOL_GPL(phy_lookup_setting);

size_t phy_speeds(unsigned int *speeds, size_t size,
		  unsigned long *mask, size_t maxbit)
{
	size_t count;
	int i;

	for (i = 0, count = 0; i < ARRAY_SIZE(settings) && count < size; i++)
		if (settings[i].bit < maxbit &&
		    test_bit(settings[i].bit, mask) &&
		    (count == 0 || speeds[count - 1] != settings[i].speed))
			speeds[count++] = settings[i].speed;

	return count;
}

/**
 * phy_resolve_aneg_linkmode - resolve the advertisments into phy settings
 * @phydev: The phy_device struct
 *
 * Resolve our and the link partner advertisments into their corresponding
 * speed and duplex. If full duplex was negotiated, extract the pause mode
 * from the link partner mask.
 */
void phy_resolve_aneg_linkmode(struct phy_device *phydev)
{
	u32 common = phydev->lp_advertising & phydev->advertising;

	if (common & ADVERTISED_10000baseT_Full) {
		phydev->speed = SPEED_10000;
		phydev->duplex = DUPLEX_FULL;
	} else if (common & ADVERTISED_1000baseT_Full) {
		phydev->speed = SPEED_1000;
		phydev->duplex = DUPLEX_FULL;
	} else if (common & ADVERTISED_1000baseT_Half) {
		phydev->speed = SPEED_1000;
		phydev->duplex = DUPLEX_HALF;
	} else if (common & ADVERTISED_100baseT_Full) {
		phydev->speed = SPEED_100;
		phydev->duplex = DUPLEX_FULL;
	} else if (common & ADVERTISED_100baseT_Half) {
		phydev->speed = SPEED_100;
		phydev->duplex = DUPLEX_HALF;
	} else if (common & ADVERTISED_10baseT_Full) {
		phydev->speed = SPEED_10;
		phydev->duplex = DUPLEX_FULL;
	} else if (common & ADVERTISED_10baseT_Half) {
		phydev->speed = SPEED_10;
		phydev->duplex = DUPLEX_HALF;
	}

	if (phydev->duplex == DUPLEX_FULL) {
		phydev->pause = !!(phydev->lp_advertising & ADVERTISED_Pause);
		phydev->asym_pause = !!(phydev->lp_advertising &
					ADVERTISED_Asym_Pause);
	}
}
EXPORT_SYMBOL_GPL(phy_resolve_aneg_linkmode);

static void mmd_phy_indirect(struct mii_bus *bus, int phy_addr, int devad,
			     u16 regnum)
{
	/* Write the desired MMD Devad */
	__mdiobus_write(bus, phy_addr, MII_MMD_CTRL, devad);

	/* Write the desired MMD register address */
	__mdiobus_write(bus, phy_addr, MII_MMD_DATA, regnum);

	/* Select the Function : DATA with no post increment */
	__mdiobus_write(bus, phy_addr, MII_MMD_CTRL,
			devad | MII_MMD_CTRL_NOINCR);
}

/**
 * phy_read_mmd - Convenience function for reading a register
 * from an MMD on a given PHY.
 * @phydev: The phy_device struct
 * @devad: The MMD to read from (0..31)
 * @regnum: The register on the MMD to read (0..65535)
 *
 * Same rules as for phy_read();
 */
int phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum)
{
	int val;

	if (regnum > (u16)~0 || devad > 32)
		return -EINVAL;

	if (phydev->drv->read_mmd) {
		val = phydev->drv->read_mmd(phydev, devad, regnum);
	} else if (phydev->is_c45) {
		u32 addr = MII_ADDR_C45 | (devad << 16) | (regnum & 0xffff);

		val = mdiobus_read(phydev->mdio.bus, phydev->mdio.addr, addr);
	} else {
		struct mii_bus *bus = phydev->mdio.bus;
		int phy_addr = phydev->mdio.addr;

		mutex_lock(&bus->mdio_lock);
		mmd_phy_indirect(bus, phy_addr, devad, regnum);

		/* Read the content of the MMD's selected register */
		val = __mdiobus_read(bus, phy_addr, MII_MMD_DATA);
		mutex_unlock(&bus->mdio_lock);
	}
	return val;
}
EXPORT_SYMBOL(phy_read_mmd);

/**
 * phy_write_mmd - Convenience function for writing a register
 * on an MMD on a given PHY.
 * @phydev: The phy_device struct
 * @devad: The MMD to read from
 * @regnum: The register on the MMD to read
 * @val: value to write to @regnum
 *
 * Same rules as for phy_write();
 */
int phy_write_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val)
{
	int ret;

	if (regnum > (u16)~0 || devad > 32)
		return -EINVAL;

	if (phydev->drv->write_mmd) {
		ret = phydev->drv->write_mmd(phydev, devad, regnum, val);
	} else if (phydev->is_c45) {
		u32 addr = MII_ADDR_C45 | (devad << 16) | (regnum & 0xffff);

		ret = mdiobus_write(phydev->mdio.bus, phydev->mdio.addr,
				    addr, val);
	} else {
		struct mii_bus *bus = phydev->mdio.bus;
		int phy_addr = phydev->mdio.addr;

		mutex_lock(&bus->mdio_lock);
		mmd_phy_indirect(bus, phy_addr, devad, regnum);

		/* Write the data into MMD's selected register */
		__mdiobus_write(bus, phy_addr, MII_MMD_DATA, val);
		mutex_unlock(&bus->mdio_lock);

		ret = 0;
	}
	return ret;
}
EXPORT_SYMBOL(phy_write_mmd);

/**
 * __phy_modify() - Convenience function for modifying a PHY register
 * @phydev: a pointer to a &struct phy_device
 * @regnum: register number
 * @mask: bit mask of bits to clear
 * @set: bit mask of bits to set
 *
 * Unlocked helper function which allows a PHY register to be modified as
 * new register value = (old register value & ~mask) | set
 */
int __phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)
{
	int ret;

	ret = __phy_read(phydev, regnum);
	if (ret < 0)
		return ret;

	ret = __phy_write(phydev, regnum, (ret & ~mask) | set);

	return ret < 0 ? ret : 0;
}
EXPORT_SYMBOL_GPL(__phy_modify);

/**
 * phy_modify - Convenience function for modifying a given PHY register
 * @phydev: the phy_device struct
 * @regnum: register number to write
 * @mask: bit mask of bits to clear
 * @set: new value of bits set in mask to write to @regnum
 *
 * NOTE: MUST NOT be called from interrupt context,
 * because the bus read/write functions may wait for an interrupt
 * to conclude the operation.
 */
int phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)
{
	int ret;

	mutex_lock(&phydev->mdio.bus->mdio_lock);
	ret = __phy_modify(phydev, regnum, mask, set);
	mutex_unlock(&phydev->mdio.bus->mdio_lock);

	return ret;
}
EXPORT_SYMBOL_GPL(phy_modify);

static int __phy_read_page(struct phy_device *phydev)
{
	return phydev->drv->read_page(phydev);
}

static int __phy_write_page(struct phy_device *phydev, int page)
{
	return phydev->drv->write_page(phydev, page);
}

/**
 * phy_save_page() - take the bus lock and save the current page
 * @phydev: a pointer to a &struct phy_device
 *
 * Take the MDIO bus lock, and return the current page number. On error,
 * returns a negative errno. phy_restore_page() must always be called
 * after this, irrespective of success or failure of this call.
 */
int phy_save_page(struct phy_device *phydev)
{
	mutex_lock(&phydev->mdio.bus->mdio_lock);
	return __phy_read_page(phydev);
}
EXPORT_SYMBOL_GPL(phy_save_page);

/**
 * phy_select_page() - take the bus lock, save the current page, and set a page
 * @phydev: a pointer to a &struct phy_device
 * @page: desired page
 *
 * Take the MDIO bus lock to protect against concurrent access, save the
 * current PHY page, and set the current page.  On error, returns a
 * negative errno, otherwise returns the previous page number.
 * phy_restore_page() must always be called after this, irrespective
 * of success or failure of this call.
 */
int phy_select_page(struct phy_device *phydev, int page)
{
	int ret, oldpage;

	oldpage = ret = phy_save_page(phydev);
	if (ret < 0)
		return ret;

	if (oldpage != page) {
		ret = __phy_write_page(phydev, page);
		if (ret < 0)
			return ret;
	}

	return oldpage;
}
EXPORT_SYMBOL_GPL(phy_select_page);

/**
 * phy_restore_page() - restore the page register and release the bus lock
 * @phydev: a pointer to a &struct phy_device
 * @oldpage: the old page, return value from phy_save_page() or phy_select_page()
 * @ret: operation's return code
 *
 * Release the MDIO bus lock, restoring @oldpage if it is a valid page.
 * This function propagates the earliest error code from the group of
 * operations.
 *
 * Returns:
 *   @oldpage if it was a negative value, otherwise
 *   @ret if it was a negative errno value, otherwise
 *   phy_write_page()'s negative value if it were in error, otherwise
 *   @ret.
 */
int phy_restore_page(struct phy_device *phydev, int oldpage, int ret)
{
	int r;

	if (oldpage >= 0) {
		r = __phy_write_page(phydev, oldpage);

		/* Propagate the operation return code if the page write
		 * was successful.
		 */
		if (ret >= 0 && r < 0)
			ret = r;
	} else {
		/* Propagate the phy page selection error code */
		ret = oldpage;
	}

	mutex_unlock(&phydev->mdio.bus->mdio_lock);

	return ret;
}
EXPORT_SYMBOL_GPL(phy_restore_page);

/**
 * phy_read_paged() - Convenience function for reading a paged register
 * @phydev: a pointer to a &struct phy_device
 * @page: the page for the phy
 * @regnum: register number
 *
 * Same rules as for phy_read().
 */
int phy_read_paged(struct phy_device *phydev, int page, u32 regnum)
{
	int ret = 0, oldpage;

	oldpage = phy_select_page(phydev, page);
	if (oldpage >= 0)
		ret = __phy_read(phydev, regnum);

	return phy_restore_page(phydev, oldpage, ret);
}
EXPORT_SYMBOL(phy_read_paged);

/**
 * phy_write_paged() - Convenience function for writing a paged register
 * @phydev: a pointer to a &struct phy_device
 * @page: the page for the phy
 * @regnum: register number
 * @val: value to write
 *
 * Same rules as for phy_write().
 */
int phy_write_paged(struct phy_device *phydev, int page, u32 regnum, u16 val)
{
	int ret = 0, oldpage;

	oldpage = phy_select_page(phydev, page);
	if (oldpage >= 0)
		ret = __phy_write(phydev, regnum, val);

	return phy_restore_page(phydev, oldpage, ret);
}
EXPORT_SYMBOL(phy_write_paged);

/**
 * phy_modify_paged() - Convenience function for modifying a paged register
 * @phydev: a pointer to a &struct phy_device
 * @page: the page for the phy
 * @regnum: register number
 * @mask: bit mask of bits to clear
 * @set: bit mask of bits to set
 *
 * Same rules as for phy_read() and phy_write().
 */
int phy_modify_paged(struct phy_device *phydev, int page, u32 regnum,
		     u16 mask, u16 set)
{
	int ret = 0, oldpage;

	oldpage = phy_select_page(phydev, page);
	if (oldpage >= 0)
		ret = __phy_modify(phydev, regnum, mask, set);

	return phy_restore_page(phydev, oldpage, ret);
}
EXPORT_SYMBOL(phy_modify_paged);
Commit	Line	Data
9860118b RK	1	/*
	2	* Core PHY library, taken from phy.c
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU General Public License as published by the
	6	* Free Software Foundation; either version 2 of the License, or (at your
	7	* option) any later version.
	8	*/
	9	#include <linux/export.h>
	10	#include <linux/phy.h>
	11
da4625ac RK	12	const char *phy_speed_to_str(int speed)
	13	{
	14	switch (speed) {
	15	case SPEED_10:
	16	return "10Mbps";
	17	case SPEED_100:
	18	return "100Mbps";
	19	case SPEED_1000:
	20	return "1Gbps";
	21	case SPEED_2500:
	22	return "2.5Gbps";
	23	case SPEED_5000:
	24	return "5Gbps";
	25	case SPEED_10000:
	26	return "10Gbps";
	27	case SPEED_14000:
	28	return "14Gbps";
	29	case SPEED_20000:
	30	return "20Gbps";
	31	case SPEED_25000:
	32	return "25Gbps";
	33	case SPEED_40000:
	34	return "40Gbps";
	35	case SPEED_50000:
	36	return "50Gbps";
	37	case SPEED_56000:
	38	return "56Gbps";
	39	case SPEED_100000:
	40	return "100Gbps";
	41	case SPEED_UNKNOWN:
	42	return "Unknown";
	43	default:
	44	return "Unsupported (update phy-core.c)";
	45	}
	46	}
	47	EXPORT_SYMBOL_GPL(phy_speed_to_str);
	48
	49	const char *phy_duplex_to_str(unsigned int duplex)
	50	{
	51	if (duplex == DUPLEX_HALF)
	52	return "Half";
	53	if (duplex == DUPLEX_FULL)
	54	return "Full";
	55	if (duplex == DUPLEX_UNKNOWN)
	56	return "Unknown";
	57	return "Unsupported (update phy-core.c)";
	58	}
	59	EXPORT_SYMBOL_GPL(phy_duplex_to_str);
	60
0ccb4fc6 RK	61	/* A mapping of all SUPPORTED settings to speed/duplex. This table
	62	* must be grouped by speed and sorted in descending match priority
	63	* - iow, descending speed. */
	64	static const struct phy_setting settings[] = {
	65	{
	66	.speed = SPEED_10000,
	67	.duplex = DUPLEX_FULL,
	68	.bit = ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
	69	},
	70	{
	71	.speed = SPEED_10000,
	72	.duplex = DUPLEX_FULL,
	73	.bit = ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
	74	},
	75	{
	76	.speed = SPEED_10000,
	77	.duplex = DUPLEX_FULL,
	78	.bit = ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
	79	},
	80	{
	81	.speed = SPEED_2500,
	82	.duplex = DUPLEX_FULL,
	83	.bit = ETHTOOL_LINK_MODE_2500baseX_Full_BIT,
	84	},
	85	{
	86	.speed = SPEED_1000,
	87	.duplex = DUPLEX_FULL,
	88	.bit = ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
	89	},
1f3645bb RK	90	{
	91	.speed = SPEED_1000,
	92	.duplex = DUPLEX_FULL,
	93	.bit = ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
	94	},
0ccb4fc6 RK	95	{
	96	.speed = SPEED_1000,
	97	.duplex = DUPLEX_FULL,
	98	.bit = ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
	99	},
	100	{
	101	.speed = SPEED_1000,
	102	.duplex = DUPLEX_HALF,
	103	.bit = ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
	104	},
	105	{
	106	.speed = SPEED_100,
	107	.duplex = DUPLEX_FULL,
	108	.bit = ETHTOOL_LINK_MODE_100baseT_Full_BIT,
	109	},
	110	{
	111	.speed = SPEED_100,
	112	.duplex = DUPLEX_HALF,
	113	.bit = ETHTOOL_LINK_MODE_100baseT_Half_BIT,
	114	},
	115	{
	116	.speed = SPEED_10,
	117	.duplex = DUPLEX_FULL,
	118	.bit = ETHTOOL_LINK_MODE_10baseT_Full_BIT,
	119	},
	120	{
	121	.speed = SPEED_10,
	122	.duplex = DUPLEX_HALF,
	123	.bit = ETHTOOL_LINK_MODE_10baseT_Half_BIT,
	124	},
	125	};
	126
	127	/**
	128	* phy_lookup_setting - lookup a PHY setting
	129	* @speed: speed to match
	130	* @duplex: duplex to match
	131	* @mask: allowed link modes
	132	* @maxbit: bit size of link modes
	133	* @exact: an exact match is required
	134	*
	135	* Search the settings array for a setting that matches the speed and
	136	* duplex, and which is supported.
	137	*
	138	* If @exact is unset, either an exact match or %NULL for no match will
	139	* be returned.
	140	*
	141	* If @exact is set, an exact match, the fastest supported setting at
	142	* or below the specified speed, the slowest supported setting, or if
	143	* they all fail, %NULL will be returned.
	144	*/
	145	const struct phy_setting *
	146	phy_lookup_setting(int speed, int duplex, const unsigned long *mask,
	147	size_t maxbit, bool exact)
	148	{
	149	const struct phy_setting p, match = NULL, *last = NULL;
	150	int i;
	151
	152	for (i = 0, p = settings; i < ARRAY_SIZE(settings); i++, p++) {
	153	if (p->bit < maxbit && test_bit(p->bit, mask)) {
	154	last = p;
	155	if (p->speed == speed && p->duplex == duplex) {
	156	/* Exact match for speed and duplex */
	157	match = p;
	158	break;
159	} else if (!exact) {
160	if (!match && p->speed <= speed)
161	/* Candidate */
162	match = p;
163
164	if (p->speed < speed)
165	break;
166	}
167	}
168	}
169
170	if (!match && !exact)
171	match = last;
172
173	return match;
174	}
175	EXPORT_SYMBOL_GPL(phy_lookup_setting);
176
177	size_t phy_speeds(unsigned int *speeds, size_t size,
178	unsigned long *mask, size_t maxbit)
179	{
180	size_t count;
181	int i;
182
183	for (i = 0, count = 0; i < ARRAY_SIZE(settings) && count < size; i++)
184	if (settings[i].bit < maxbit &&
185	test_bit(settings[i].bit, mask) &&
186	(count == 0 \|\| speeds[count - 1] != settings[i].speed))
187	speeds[count++] = settings[i].speed;
188
189	return count;
190	}
191
8c5e850c RK	192	/**
	193	* phy_resolve_aneg_linkmode - resolve the advertisments into phy settings
	194	* @phydev: The phy_device struct
	195	*
	196	* Resolve our and the link partner advertisments into their corresponding
	197	* speed and duplex. If full duplex was negotiated, extract the pause mode
	198	* from the link partner mask.
	199	*/
	200	void phy_resolve_aneg_linkmode(struct phy_device *phydev)
	201	{
	202	u32 common = phydev->lp_advertising & phydev->advertising;
	203
	204	if (common & ADVERTISED_10000baseT_Full) {
	205	phydev->speed = SPEED_10000;
	206	phydev->duplex = DUPLEX_FULL;
	207	} else if (common & ADVERTISED_1000baseT_Full) {
	208	phydev->speed = SPEED_1000;
	209	phydev->duplex = DUPLEX_FULL;
	210	} else if (common & ADVERTISED_1000baseT_Half) {
	211	phydev->speed = SPEED_1000;
	212	phydev->duplex = DUPLEX_HALF;
	213	} else if (common & ADVERTISED_100baseT_Full) {
	214	phydev->speed = SPEED_100;
	215	phydev->duplex = DUPLEX_FULL;
	216	} else if (common & ADVERTISED_100baseT_Half) {
	217	phydev->speed = SPEED_100;
	218	phydev->duplex = DUPLEX_HALF;
	219	} else if (common & ADVERTISED_10baseT_Full) {
	220	phydev->speed = SPEED_10;
	221	phydev->duplex = DUPLEX_FULL;
	222	} else if (common & ADVERTISED_10baseT_Half) {
	223	phydev->speed = SPEED_10;
	224	phydev->duplex = DUPLEX_HALF;
	225	}
	226
	227	if (phydev->duplex == DUPLEX_FULL) {
	228	phydev->pause = !!(phydev->lp_advertising & ADVERTISED_Pause);
	229	phydev->asym_pause = !!(phydev->lp_advertising &
	230	ADVERTISED_Asym_Pause);
	231	}
	232	}
	233	EXPORT_SYMBOL_GPL(phy_resolve_aneg_linkmode);
	234
060fbc89 RK	235	static void mmd_phy_indirect(struct mii_bus *bus, int phy_addr, int devad,
060fbc89 RK	236	u16 regnum)
9860118b RK	237	{
9860118b RK	238	/* Write the desired MMD Devad */
1b2dea2e	239	__mdiobus_write(bus, phy_addr, MII_MMD_CTRL, devad);
9860118b RK	240
9860118b RK	241	/* Write the desired MMD register address */
1b2dea2e	242	__mdiobus_write(bus, phy_addr, MII_MMD_DATA, regnum);
9860118b RK	243
9860118b RK	244	/* Select the Function : DATA with no post increment */
1b2dea2e RK	245	__mdiobus_write(bus, phy_addr, MII_MMD_CTRL,
1b2dea2e RK	246	devad \| MII_MMD_CTRL_NOINCR);
9860118b RK	247	}
9860118b RK	248
9860118b RK	249	/**
	250	* phy_read_mmd - Convenience function for reading a register
	251	* from an MMD on a given PHY.
	252	* @phydev: The phy_device struct
3b85d8df RK	253	* @devad: The MMD to read from (0..31)
3b85d8df RK	254	* @regnum: The register on the MMD to read (0..65535)
9860118b RK	255	*
	256	* Same rules as for phy_read();
	257	*/
	258	int phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum)
	259	{
3b85d8df RK	260	int val;
3b85d8df RK	261
1ee6b9bc RK	262	if (regnum > (u16)~0 \|\| devad > 32)
1ee6b9bc RK	263	return -EINVAL;
9860118b	264
3b85d8df RK	265	if (phydev->drv->read_mmd) {
	266	val = phydev->drv->read_mmd(phydev, devad, regnum);
	267	} else if (phydev->is_c45) {
1ee6b9bc	268	u32 addr = MII_ADDR_C45 \| (devad << 16) \| (regnum & 0xffff);
1ee6b9bc	269
3b85d8df RK	270	val = mdiobus_read(phydev->mdio.bus, phydev->mdio.addr, addr);
3b85d8df RK	271	} else {
9860118b	272	struct mii_bus *bus = phydev->mdio.bus;
3b85d8df	273	int phy_addr = phydev->mdio.addr;
9860118b RK	274
9860118b RK	275	mutex_lock(&bus->mdio_lock);
060fbc89	276	mmd_phy_indirect(bus, phy_addr, devad, regnum);
9860118b	277
3b85d8df	278	/* Read the content of the MMD's selected register */
1b2dea2e	279	val = __mdiobus_read(bus, phy_addr, MII_MMD_DATA);
9860118b	280	mutex_unlock(&bus->mdio_lock);
9860118b	281	}
3b85d8df	282	return val;
9860118b	283	}
3b85d8df	284	EXPORT_SYMBOL(phy_read_mmd);
9860118b RK	285
	286	/**
	287	* phy_write_mmd - Convenience function for writing a register
	288	* on an MMD on a given PHY.
	289	* @phydev: The phy_device struct
	290	* @devad: The MMD to read from
	291	* @regnum: The register on the MMD to read
	292	* @val: value to write to @regnum
	293	*
	294	* Same rules as for phy_write();
	295	*/
	296	int phy_write_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val)
	297	{
3b85d8df RK	298	int ret;
3b85d8df RK	299
1ee6b9bc RK	300	if (regnum > (u16)~0 \|\| devad > 32)
	301	return -EINVAL;
	302
1dbba4cb	303	if (phydev->drv->write_mmd) {
3b85d8df RK	304	ret = phydev->drv->write_mmd(phydev, devad, regnum, val);
3b85d8df RK	305	} else if (phydev->is_c45) {
1ee6b9bc RK	306	u32 addr = MII_ADDR_C45 \| (devad << 16) \| (regnum & 0xffff);
1ee6b9bc RK	307
3b85d8df RK	308	ret = mdiobus_write(phydev->mdio.bus, phydev->mdio.addr,
	309	addr, val);
	310	} else {
	311	struct mii_bus *bus = phydev->mdio.bus;
	312	int phy_addr = phydev->mdio.addr;
9860118b	313
3b85d8df	314	mutex_lock(&bus->mdio_lock);
060fbc89	315	mmd_phy_indirect(bus, phy_addr, devad, regnum);
9860118b	316
3b85d8df	317	/* Write the data into MMD's selected register */
1b2dea2e	318	__mdiobus_write(bus, phy_addr, MII_MMD_DATA, val);
3b85d8df RK	319	mutex_unlock(&bus->mdio_lock);
	320
	321	ret = 0;
	322	}
	323	return ret;
9860118b RK	324	}
9860118b RK	325	EXPORT_SYMBOL(phy_write_mmd);
788f9933 RK	326
	327	/**
	328	* __phy_modify() - Convenience function for modifying a PHY register
	329	* @phydev: a pointer to a &struct phy_device
	330	* @regnum: register number
	331	* @mask: bit mask of bits to clear
	332	* @set: bit mask of bits to set
	333	*
	334	* Unlocked helper function which allows a PHY register to be modified as
f102852f	335	* new register value = (old register value & ~mask) \| set
788f9933 RK	336	*/
	337	int __phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)
	338	{
9f239fe6	339	int ret;
788f9933 RK	340
788f9933 RK	341	ret = __phy_read(phydev, regnum);
9f239fe6 AL	342	if (ret < 0)
9f239fe6 AL	343	return ret;
788f9933	344
9f239fe6 AL	345	ret = __phy_write(phydev, regnum, (ret & ~mask) \| set);
	346
	347	return ret < 0 ? ret : 0;
788f9933 RK	348	}
788f9933 RK	349	EXPORT_SYMBOL_GPL(__phy_modify);
78ffc4ac	350
2b74e5be RK	351	/**
	352	* phy_modify - Convenience function for modifying a given PHY register
	353	* @phydev: the phy_device struct
	354	* @regnum: register number to write
	355	* @mask: bit mask of bits to clear
	356	* @set: new value of bits set in mask to write to @regnum
	357	*
	358	* NOTE: MUST NOT be called from interrupt context,
	359	* because the bus read/write functions may wait for an interrupt
	360	* to conclude the operation.
	361	*/
	362	int phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)
	363	{
	364	int ret;
	365
	366	mutex_lock(&phydev->mdio.bus->mdio_lock);
	367	ret = __phy_modify(phydev, regnum, mask, set);
	368	mutex_unlock(&phydev->mdio.bus->mdio_lock);
	369
	370	return ret;
	371	}
	372	EXPORT_SYMBOL_GPL(phy_modify);
	373
78ffc4ac RK	374	static int __phy_read_page(struct phy_device *phydev)
	375	{
	376	return phydev->drv->read_page(phydev);
	377	}
	378
	379	static int __phy_write_page(struct phy_device *phydev, int page)
	380	{
	381	return phydev->drv->write_page(phydev, page);
	382	}
	383
	384	/**
	385	* phy_save_page() - take the bus lock and save the current page
	386	* @phydev: a pointer to a &struct phy_device
	387	*
	388	* Take the MDIO bus lock, and return the current page number. On error,
	389	* returns a negative errno. phy_restore_page() must always be called
	390	* after this, irrespective of success or failure of this call.
	391	*/
	392	int phy_save_page(struct phy_device *phydev)
	393	{
	394	mutex_lock(&phydev->mdio.bus->mdio_lock);
	395	return __phy_read_page(phydev);
	396	}
	397	EXPORT_SYMBOL_GPL(phy_save_page);
	398
	399	/**
	400	* phy_select_page() - take the bus lock, save the current page, and set a page
	401	* @phydev: a pointer to a &struct phy_device
	402	* @page: desired page
	403	*
	404	* Take the MDIO bus lock to protect against concurrent access, save the
	405	* current PHY page, and set the current page. On error, returns a
	406	* negative errno, otherwise returns the previous page number.
	407	* phy_restore_page() must always be called after this, irrespective
	408	* of success or failure of this call.
	409	*/
	410	int phy_select_page(struct phy_device *phydev, int page)
	411	{
	412	int ret, oldpage;
	413
	414	oldpage = ret = phy_save_page(phydev);
	415	if (ret < 0)
	416	return ret;
	417
	418	if (oldpage != page) {
	419	ret = __phy_write_page(phydev, page);
	420	if (ret < 0)
	421	return ret;
	422	}
	423
	424	return oldpage;
	425	}
	426	EXPORT_SYMBOL_GPL(phy_select_page);
	427
	428	/**
	429	* phy_restore_page() - restore the page register and release the bus lock
	430	* @phydev: a pointer to a &struct phy_device
	431	* @oldpage: the old page, return value from phy_save_page() or phy_select_page()
	432	* @ret: operation's return code
	433	*
	434	* Release the MDIO bus lock, restoring @oldpage if it is a valid page.
	435	* This function propagates the earliest error code from the group of
	436	* operations.
	437	*
438	* Returns:
439	* @oldpage if it was a negative value, otherwise
440	* @ret if it was a negative errno value, otherwise
441	* phy_write_page()'s negative value if it were in error, otherwise
442	* @ret.
443	*/
444	int phy_restore_page(struct phy_device *phydev, int oldpage, int ret)
445	{
446	int r;
447
448	if (oldpage >= 0) {
449	r = __phy_write_page(phydev, oldpage);
450
451	/* Propagate the operation return code if the page write
452	* was successful.
453	*/
454	if (ret >= 0 && r < 0)
455	ret = r;
456	} else {
457	/* Propagate the phy page selection error code */
458	ret = oldpage;
459	}
460
461	mutex_unlock(&phydev->mdio.bus->mdio_lock);
462
463	return ret;
464	}
465	EXPORT_SYMBOL_GPL(phy_restore_page);
466
467	/**
468	* phy_read_paged() - Convenience function for reading a paged register
469	* @phydev: a pointer to a &struct phy_device
470	* @page: the page for the phy
471	* @regnum: register number
472	*
473	* Same rules as for phy_read().
474	*/
475	int phy_read_paged(struct phy_device *phydev, int page, u32 regnum)
476	{
477	int ret = 0, oldpage;
478
479	oldpage = phy_select_page(phydev, page);
480	if (oldpage >= 0)
481	ret = __phy_read(phydev, regnum);
482
483	return phy_restore_page(phydev, oldpage, ret);
484	}
485	EXPORT_SYMBOL(phy_read_paged);
486
487	/**
488	* phy_write_paged() - Convenience function for writing a paged register
489	* @phydev: a pointer to a &struct phy_device
490	* @page: the page for the phy
491	* @regnum: register number
492	* @val: value to write
493	*
494	* Same rules as for phy_write().
495	*/
496	int phy_write_paged(struct phy_device *phydev, int page, u32 regnum, u16 val)
497	{
498	int ret = 0, oldpage;
499
500	oldpage = phy_select_page(phydev, page);
501	if (oldpage >= 0)
502	ret = __phy_write(phydev, regnum, val);
503
504	return phy_restore_page(phydev, oldpage, ret);
505	}
506	EXPORT_SYMBOL(phy_write_paged);
507
508	/**
509	* phy_modify_paged() - Convenience function for modifying a paged register
510	* @phydev: a pointer to a &struct phy_device
511	* @page: the page for the phy
512	* @regnum: register number
513	* @mask: bit mask of bits to clear
514	* @set: bit mask of bits to set
515	*
516	* Same rules as for phy_read() and phy_write().
517	*/
518	int phy_modify_paged(struct phy_device *phydev, int page, u32 regnum,
519	u16 mask, u16 set)
520	{
521	int ret = 0, oldpage;
522
523	oldpage = phy_select_page(phydev, page);
524	if (oldpage >= 0)
525	ret = __phy_modify(phydev, regnum, mask, set);
526
527	return phy_restore_page(phydev, oldpage, ret);
528	}
529	EXPORT_SYMBOL(phy_modify_paged);