// SPDX-License-Identifier: GPL-2.0-or-later #include <linux/ethtool.h>#include <linux/linkmode.h>#include <linux/phy.h> #include "phy-caps.h" static struct link_capabilities link_caps[__LINK_CAPA_MAX] __ro_after_init = { { SPEED_10, DUPLEX_HALF, {0} }, /* LINK_CAPA_10HD */ { SPEED_10, DUPLEX_FULL, {0} }, /* LINK_CAPA_10FD */ { SPEED_100, DUPLEX_HALF, {0} }, /* LINK_CAPA_100HD */ { SPEED_100, DUPLEX_FULL, {0} }, /* LINK_CAPA_100FD */ { SPEED_1000, DUPLEX_HALF, {0} }, /* LINK_CAPA_1000HD */ { SPEED_1000, DUPLEX_FULL, {0} }, /* LINK_CAPA_1000FD */ { SPEED_2500, DUPLEX_FULL, {0} }, /* LINK_CAPA_2500FD */ { SPEED_5000, DUPLEX_FULL, {0} }, /* LINK_CAPA_5000FD */ { SPEED_10000, DUPLEX_FULL, {0} }, /* LINK_CAPA_10000FD */ { SPEED_20000, DUPLEX_FULL, {0} }, /* LINK_CAPA_20000FD */ { SPEED_25000, DUPLEX_FULL, {0} }, /* LINK_CAPA_25000FD */ { SPEED_40000, DUPLEX_FULL, {0} }, /* LINK_CAPA_40000FD */ { SPEED_50000, DUPLEX_FULL, {0} }, /* LINK_CAPA_50000FD */ { SPEED_56000, DUPLEX_FULL, {0} }, /* LINK_CAPA_56000FD */ { SPEED_80000, DUPLEX_FULL, {0} }, /* LINK_CAPA_80000FD */ { SPEED_100000, DUPLEX_FULL, {0} }, /* LINK_CAPA_100000FD */ { SPEED_200000, DUPLEX_FULL, {0} }, /* LINK_CAPA_200000FD */ { SPEED_400000, DUPLEX_FULL, {0} }, /* LINK_CAPA_400000FD */ { SPEED_800000, DUPLEX_FULL, {0} }, /* LINK_CAPA_800000FD */ { SPEED_1600000, DUPLEX_FULL, {0} }, /* LINK_CAPA_1600000FD */}; static int speed_duplex_to_capa(int speed, unsigned int duplex){ if (duplex == DUPLEX_UNKNOWN || (speed > SPEED_1000 && duplex != DUPLEX_FULL)) return -EINVAL; switch (speed) { case SPEED_10: return duplex == DUPLEX_FULL ? LINK_CAPA_10FD : LINK_CAPA_10HD; case SPEED_100: return duplex == DUPLEX_FULL ? LINK_CAPA_100FD : LINK_CAPA_100HD; case SPEED_1000: return duplex == DUPLEX_FULL ? LINK_CAPA_1000FD : LINK_CAPA_1000HD; case SPEED_2500: return LINK_CAPA_2500FD; case SPEED_5000: return LINK_CAPA_5000FD; case SPEED_10000: return LINK_CAPA_10000FD; case SPEED_20000: return LINK_CAPA_20000FD; case SPEED_25000: return LINK_CAPA_25000FD; case SPEED_40000: return LINK_CAPA_40000FD; case SPEED_50000: return LINK_CAPA_50000FD; case SPEED_56000: return LINK_CAPA_56000FD; case SPEED_80000: return LINK_CAPA_80000FD; case SPEED_100000: return LINK_CAPA_100000FD; case SPEED_200000: return LINK_CAPA_200000FD; case SPEED_400000: return LINK_CAPA_400000FD; case SPEED_800000: return LINK_CAPA_800000FD; case SPEED_1600000: return LINK_CAPA_1600000FD; } return -EINVAL;} #define for_each_link_caps_asc_speed(cap) \ for (cap = link_caps; cap < &link_caps[__LINK_CAPA_MAX]; cap++) #define for_each_link_caps_desc_speed(cap) \ for (cap = &link_caps[__LINK_CAPA_MAX - 1]; cap >= link_caps; cap--) /** * phy_caps_init() - Initializes the link_caps array from the link_mode_params. * * Returns: 0 if phy caps init was successful, -EINVAL if we found an * unexpected linkmode setting that requires LINK_CAPS update. * */int __init phy_caps_init(void){ const struct link_mode_info *linkmode; int i, capa; /* Fill the caps array from net/ethtool/common.c */ for (i = 0; i < __ETHTOOL_LINK_MODE_MASK_NBITS; i++) { linkmode = &link_mode_params[i]; /* Sanity check the linkmodes array for number of pairs */ if (linkmode->pairs < linkmode->min_pairs) { pr_err("Pairs count must not be under min_pairs for linkmode %d\n", i); return -EINVAL; } capa = speed_duplex_to_capa(linkmode->speed, linkmode->duplex); if (capa < 0) { if (linkmode->speed != SPEED_UNKNOWN) { pr_err("Unknown speed %d, please update LINK_CAPS\n", linkmode->speed); return -EINVAL; } continue; } __set_bit(i, link_caps[capa].linkmodes); } return 0;} /** * phy_caps_speeds() - Fill an array of supported SPEED_* values for given modes * @speeds: Output array to store the speeds list into * @size: Size of the output array * @linkmodes: Linkmodes to get the speeds from * * Fills the speeds array with all possible speeds that can be achieved with * the specified linkmodes. * * Returns: The number of speeds filled into the array. If the input array isn't * big enough to store all speeds, fill it as much as possible. */size_t phy_caps_speeds(unsigned int *speeds, size_t size, unsigned long *linkmodes){ struct link_capabilities *lcap; size_t count = 0; for_each_link_caps_asc_speed(lcap) { if (linkmode_intersects(lcap->linkmodes, linkmodes) && (count == 0 || speeds[count - 1] != lcap->speed)) { speeds[count++] = lcap->speed; if (count >= size) break; } } return count;} /** * phy_caps_lookup_by_linkmode() - Lookup the fastest matching link_capabilities * @linkmodes: Linkmodes to match against * * Returns: The highest-speed link_capabilities that intersects the given * linkmodes. In case several DUPLEX_ options exist at that speed, * DUPLEX_FULL is matched first. NULL is returned if no match. */const struct link_capabilities *phy_caps_lookup_by_linkmode(const unsigned long *linkmodes){ struct link_capabilities *lcap; for_each_link_caps_desc_speed(lcap) if (linkmode_intersects(lcap->linkmodes, linkmodes)) return lcap; return NULL;} /** * phy_caps_lookup_by_linkmode_rev() - Lookup the slowest matching link_capabilities * @linkmodes: Linkmodes to match against * @fdx_only: Full duplex match only when set * * Returns: The lowest-speed link_capabilities that intersects the given * linkmodes. When set, fdx_only will ignore half-duplex matches. * NULL is returned if no match. */const struct link_capabilities *phy_caps_lookup_by_linkmode_rev(const unsigned long *linkmodes, bool fdx_only){ struct link_capabilities *lcap; for_each_link_caps_asc_speed(lcap) { if (fdx_only && lcap->duplex != DUPLEX_FULL) continue; if (linkmode_intersects(lcap->linkmodes, linkmodes)) return lcap; } return NULL;} /** * phy_caps_lookup() - Lookup capabilities by speed/duplex that matches a mask * @speed: Speed to match * @duplex: Duplex to match * @supported: Mask of linkmodes to match * @exact: Perform an exact match or not. * * Lookup a link_capabilities entry that intersect the supported linkmodes mask, * and that matches the passed speed and duplex. * * When @exact is set, an exact match is performed on speed and duplex, meaning * that if the linkmodes for the given speed and duplex intersect the supported * mask, this capability is returned, otherwise we don't have a match and return * NULL. * * When @exact is not set, we return either an exact match, or matching capabilities * at lower speed, or the lowest matching speed, or NULL. * * Non-exact matches will try to return an exact speed and duplex match, but may * return matching capabilities with same speed but a different duplex. * * Returns: a matched link_capabilities according to the above process, NULL * otherwise. */const struct link_capabilities *phy_caps_lookup(int speed, unsigned int duplex, const unsigned long *supported, bool exact){ const struct link_capabilities *lcap, *match = NULL, *last = NULL; for_each_link_caps_desc_speed(lcap) { if (linkmode_intersects(lcap->linkmodes, supported)) { last = lcap; /* exact match on speed and duplex*/ if (lcap->speed == speed && lcap->duplex == duplex) { return lcap; } else if (!exact) { if (!match && lcap->speed <= speed) match = lcap; if (lcap->speed < speed) break; } } } if (!match && !exact) match = last; return match;}EXPORT_SYMBOL_GPL(phy_caps_lookup); /** * phy_caps_linkmode_max_speed() - Clamp a linkmodes set to a max speed * @max_speed: Speed limit for the linkmode set * @linkmodes: Linkmodes to limit */void phy_caps_linkmode_max_speed(u32 max_speed, unsigned long *linkmodes){ struct link_capabilities *lcap; for_each_link_caps_desc_speed(lcap) if (lcap->speed > max_speed) linkmode_andnot(linkmodes, linkmodes, lcap->linkmodes); else break;} /** * phy_caps_valid() - Validate a linkmodes set agains given speed and duplex * @speed: input speed to validate * @duplex: input duplex to validate. Passing DUPLEX_UNKNOWN is always not valid * @linkmodes: The linkmodes to validate * * Returns: True if at least one of the linkmodes in @linkmodes can function at * the given speed and duplex, false otherwise. */bool phy_caps_valid(int speed, int duplex, const unsigned long *linkmodes){ int capa = speed_duplex_to_capa(speed, duplex); if (capa < 0) return false; return linkmode_intersects(link_caps[capa].linkmodes, linkmodes);} /** * phy_caps_linkmodes() - Convert a bitfield of capabilities into linkmodes * @caps: The list of caps, each bit corresponding to a LINK_CAPA value * @linkmodes: The set of linkmodes to fill. Must be previously initialized. */void phy_caps_linkmodes(unsigned long caps, unsigned long *linkmodes){ unsigned long capa; for_each_set_bit(capa, &caps, __LINK_CAPA_MAX) linkmode_or(linkmodes, linkmodes, link_caps[capa].linkmodes);}EXPORT_SYMBOL_GPL(phy_caps_linkmodes); /** * phy_caps_from_interface() - Get the link capa from a given PHY interface * @interface: The PHY interface we want to get the possible Speed/Duplex from * * Returns: A bitmask of LINK_CAPA_xxx values that can be achieved with the * provided interface. */unsigned long phy_caps_from_interface(phy_interface_t interface){ unsigned long link_caps = 0; switch (interface) { case PHY_INTERFACE_MODE_USXGMII: link_caps |= BIT(LINK_CAPA_10000FD) | BIT(LINK_CAPA_5000FD); fallthrough; case PHY_INTERFACE_MODE_10G_QXGMII: link_caps |= BIT(LINK_CAPA_2500FD); fallthrough; case PHY_INTERFACE_MODE_RGMII_TXID: case PHY_INTERFACE_MODE_RGMII_RXID: case PHY_INTERFACE_MODE_RGMII_ID: case PHY_INTERFACE_MODE_RGMII: case PHY_INTERFACE_MODE_PSGMII: case PHY_INTERFACE_MODE_QSGMII: case PHY_INTERFACE_MODE_QUSGMII: case PHY_INTERFACE_MODE_SGMII: case PHY_INTERFACE_MODE_GMII: link_caps |= BIT(LINK_CAPA_1000HD) | BIT(LINK_CAPA_1000FD); fallthrough; case PHY_INTERFACE_MODE_REVRMII: case PHY_INTERFACE_MODE_RMII: case PHY_INTERFACE_MODE_SMII: case PHY_INTERFACE_MODE_REVMII: case PHY_INTERFACE_MODE_MII: link_caps |= BIT(LINK_CAPA_10HD) | BIT(LINK_CAPA_10FD); fallthrough; case PHY_INTERFACE_MODE_100BASEX: link_caps |= BIT(LINK_CAPA_100HD) | BIT(LINK_CAPA_100FD); break; case PHY_INTERFACE_MODE_MIILITE: link_caps |= BIT(LINK_CAPA_10FD) | BIT(LINK_CAPA_100FD); break; case PHY_INTERFACE_MODE_TBI: case PHY_INTERFACE_MODE_MOCA: case PHY_INTERFACE_MODE_RTBI: case PHY_INTERFACE_MODE_1000BASEX: link_caps |= BIT(LINK_CAPA_1000HD); fallthrough; case PHY_INTERFACE_MODE_1000BASEKX: case PHY_INTERFACE_MODE_TRGMII: link_caps |= BIT(LINK_CAPA_1000FD); break; case PHY_INTERFACE_MODE_2500BASEX: link_caps |= BIT(LINK_CAPA_2500FD); break; case PHY_INTERFACE_MODE_5GBASER: link_caps |= BIT(LINK_CAPA_5000FD); break; case PHY_INTERFACE_MODE_XGMII: case PHY_INTERFACE_MODE_RXAUI: case PHY_INTERFACE_MODE_XAUI: case PHY_INTERFACE_MODE_10GBASER: case PHY_INTERFACE_MODE_10GKR: link_caps |= BIT(LINK_CAPA_10000FD); break; case PHY_INTERFACE_MODE_25GBASER: link_caps |= BIT(LINK_CAPA_25000FD); break; case PHY_INTERFACE_MODE_XLGMII: link_caps |= BIT(LINK_CAPA_40000FD); break; case PHY_INTERFACE_MODE_50GBASER: case PHY_INTERFACE_MODE_LAUI: link_caps |= BIT(LINK_CAPA_50000FD); break; case PHY_INTERFACE_MODE_100GBASEP: link_caps |= BIT(LINK_CAPA_100000FD); break; case PHY_INTERFACE_MODE_INTERNAL: link_caps |= LINK_CAPA_ALL; break; case PHY_INTERFACE_MODE_NA: case PHY_INTERFACE_MODE_MAX: break; } return link_caps;}EXPORT_SYMBOL_GPL(phy_caps_from_interface); /** * phy_caps_medium_get_supported() - Returns linkmodes supported on a given medium * @supported: After this call, contains all possible linkmodes on a given medium, * and with the given number of pairs, or less. * @medium: The medium to get the support from * @pairs: The number of pairs used on the given medium. Only relevant for modes * that support this notion, such as BaseT. Pass 0 if not applicable. * * If no match exists, the supported field is left untouched. */void phy_caps_medium_get_supported(unsigned long *supported, enum ethtool_link_medium medium, int pairs){ int i; for (i = 0; i < __ETHTOOL_LINK_MODE_MASK_NBITS; i++) { /* Special bits such as Autoneg, Pause, Asym_pause, etc. are * set and will be masked away by the port parent. */ if (link_mode_params[i].mediums == BIT(ETHTOOL_LINK_MEDIUM_NONE)) { linkmode_set_bit(i, supported); continue; } /* If this medium matches, and had a non-zero min-pairs */ if (link_mode_params[i].mediums & BIT(medium) && (!link_mode_params[i].min_pairs || (link_mode_params[i].min_pairs <= pairs && link_mode_params[i].pairs >= pairs))) linkmode_set_bit(i, supported); }}EXPORT_SYMBOL_GPL(phy_caps_medium_get_supported); /** * phy_caps_mediums_from_linkmodes() - Get all mediums from a linkmodes list * @linkmodes: A bitset of linkmodes to get the mediums from * * Returns: A bitset of ETHTOOL_MEDIUM_XXX values corresponding to all medium * types in the linkmodes list */u32 phy_caps_mediums_from_linkmodes(unsigned long *linkmodes){ const struct link_mode_info *linkmode; u32 mediums = 0; int i; for_each_set_bit(i, linkmodes, __ETHTOOL_LINK_MODE_MASK_NBITS) { linkmode = &link_mode_params[i]; mediums |= linkmode->mediums; } return mediums;}EXPORT_SYMBOL_GPL(phy_caps_mediums_from_linkmodes);
// SPDX-License-Identifier: GPL-2.0-or-later
#include <linux/ethtool.h>
#include <linux/linkmode.h>
#include <linux/phy.h>
#include "phy-caps.h"
static struct link_capabilities link_caps[__LINK_CAPA_MAX] __ro_after_init = {
{ SPEED_10, DUPLEX_HALF, {0} }, /* LINK_CAPA_10HD */
{ SPEED_10, DUPLEX_FULL, {0} }, /* LINK_CAPA_10FD */
{ SPEED_100, DUPLEX_HALF, {0} }, /* LINK_CAPA_100HD */
{ SPEED_100, DUPLEX_FULL, {0} }, /* LINK_CAPA_100FD */
{ SPEED_1000, DUPLEX_HALF, {0} }, /* LINK_CAPA_1000HD */
{ SPEED_1000, DUPLEX_FULL, {0} }, /* LINK_CAPA_1000FD */
{ SPEED_2500, DUPLEX_FULL, {0} }, /* LINK_CAPA_2500FD */
{ SPEED_5000, DUPLEX_FULL, {0} }, /* LINK_CAPA_5000FD */
{ SPEED_10000, DUPLEX_FULL, {0} }, /* LINK_CAPA_10000FD */
{ SPEED_20000, DUPLEX_FULL, {0} }, /* LINK_CAPA_20000FD */
{ SPEED_25000, DUPLEX_FULL, {0} }, /* LINK_CAPA_25000FD */
{ SPEED_40000, DUPLEX_FULL, {0} }, /* LINK_CAPA_40000FD */
{ SPEED_50000, DUPLEX_FULL, {0} }, /* LINK_CAPA_50000FD */
{ SPEED_56000, DUPLEX_FULL, {0} }, /* LINK_CAPA_56000FD */
{ SPEED_80000, DUPLEX_FULL, {0} }, /* LINK_CAPA_80000FD */
{ SPEED_100000, DUPLEX_FULL, {0} }, /* LINK_CAPA_100000FD */
{ SPEED_200000, DUPLEX_FULL, {0} }, /* LINK_CAPA_200000FD */
{ SPEED_400000, DUPLEX_FULL, {0} }, /* LINK_CAPA_400000FD */
{ SPEED_800000, DUPLEX_FULL, {0} }, /* LINK_CAPA_800000FD */
{ SPEED_1600000, DUPLEX_FULL, {0} }, /* LINK_CAPA_1600000FD */
};
static int speed_duplex_to_capa(int speed, unsigned int duplex)
{
if (duplex == DUPLEX_UNKNOWN ||
(speed > SPEED_1000 && duplex != DUPLEX_FULL))
return -EINVAL;
switch (speed) {
case SPEED_10: return duplex == DUPLEX_FULL ?
LINK_CAPA_10FD : LINK_CAPA_10HD;
case SPEED_100: return duplex == DUPLEX_FULL ?
LINK_CAPA_100FD : LINK_CAPA_100HD;
case SPEED_1000: return duplex == DUPLEX_FULL ?
LINK_CAPA_1000FD : LINK_CAPA_1000HD;
case SPEED_2500: return LINK_CAPA_2500FD;
case SPEED_5000: return LINK_CAPA_5000FD;
case SPEED_10000: return LINK_CAPA_10000FD;
case SPEED_20000: return LINK_CAPA_20000FD;
case SPEED_25000: return LINK_CAPA_25000FD;
case SPEED_40000: return LINK_CAPA_40000FD;
case SPEED_50000: return LINK_CAPA_50000FD;
case SPEED_56000: return LINK_CAPA_56000FD;
case SPEED_80000: return LINK_CAPA_80000FD;
case SPEED_100000: return LINK_CAPA_100000FD;
case SPEED_200000: return LINK_CAPA_200000FD;
case SPEED_400000: return LINK_CAPA_400000FD;
case SPEED_800000: return LINK_CAPA_800000FD;
case SPEED_1600000: return LINK_CAPA_1600000FD;
}
return -EINVAL;
}
#define for_each_link_caps_asc_speed(cap) \
for (cap = link_caps; cap < &link_caps[__LINK_CAPA_MAX]; cap++)
#define for_each_link_caps_desc_speed(cap) \
for (cap = &link_caps[__LINK_CAPA_MAX - 1]; cap >= link_caps; cap--)
/**
* phy_caps_init() - Initializes the link_caps array from the link_mode_params.
*
* Returns: 0 if phy caps init was successful, -EINVAL if we found an
* unexpected linkmode setting that requires LINK_CAPS update.
*
*/
int __init phy_caps_init(void)
{
const struct link_mode_info *linkmode;
int i, capa;
/* Fill the caps array from net/ethtool/common.c */
for (i = 0; i < __ETHTOOL_LINK_MODE_MASK_NBITS; i++) {
linkmode = &link_mode_params[i];
/* Sanity check the linkmodes array for number of pairs */
if (linkmode->pairs < linkmode->min_pairs) {
pr_err("Pairs count must not be under min_pairs for linkmode %d\n",
i);
return -EINVAL;
}
capa = speed_duplex_to_capa(linkmode->speed, linkmode->duplex);
if (capa < 0) {
if (linkmode->speed != SPEED_UNKNOWN) {
pr_err("Unknown speed %d, please update LINK_CAPS\n",
linkmode->speed);
return -EINVAL;
}
continue;
}
__set_bit(i, link_caps[capa].linkmodes);
}
return 0;
}
/**
* phy_caps_speeds() - Fill an array of supported SPEED_* values for given modes
* @speeds: Output array to store the speeds list into
* @size: Size of the output array
* @linkmodes: Linkmodes to get the speeds from
*
* Fills the speeds array with all possible speeds that can be achieved with
* the specified linkmodes.
*
* Returns: The number of speeds filled into the array. If the input array isn't
* big enough to store all speeds, fill it as much as possible.
*/
size_t phy_caps_speeds(unsigned int *speeds, size_t size,
unsigned long *linkmodes)
{
struct link_capabilities *lcap;
size_t count = 0;
for_each_link_caps_asc_speed(lcap) {
if (linkmode_intersects(lcap->linkmodes, linkmodes) &&
(count == 0 || speeds[count - 1] != lcap->speed)) {
speeds[count++] = lcap->speed;
if (count >= size)
break;
}
}
return count;
}
/**
* phy_caps_lookup_by_linkmode() - Lookup the fastest matching link_capabilities
* @linkmodes: Linkmodes to match against
*
* Returns: The highest-speed link_capabilities that intersects the given
* linkmodes. In case several DUPLEX_ options exist at that speed,
* DUPLEX_FULL is matched first. NULL is returned if no match.
*/
const struct link_capabilities *
phy_caps_lookup_by_linkmode(const unsigned long *linkmodes)
{
struct link_capabilities *lcap;
for_each_link_caps_desc_speed(lcap)
if (linkmode_intersects(lcap->linkmodes, linkmodes))
return lcap;
return NULL;
}
/**
* phy_caps_lookup_by_linkmode_rev() - Lookup the slowest matching link_capabilities
* @linkmodes: Linkmodes to match against
* @fdx_only: Full duplex match only when set
*
* Returns: The lowest-speed link_capabilities that intersects the given
* linkmodes. When set, fdx_only will ignore half-duplex matches.
* NULL is returned if no match.
*/
const struct link_capabilities *
phy_caps_lookup_by_linkmode_rev(const unsigned long *linkmodes, bool fdx_only)
{
struct link_capabilities *lcap;
for_each_link_caps_asc_speed(lcap) {
if (fdx_only && lcap->duplex != DUPLEX_FULL)
continue;
if (linkmode_intersects(lcap->linkmodes, linkmodes))
return lcap;
}
return NULL;
}
/**
* phy_caps_lookup() - Lookup capabilities by speed/duplex that matches a mask
* @speed: Speed to match
* @duplex: Duplex to match
* @supported: Mask of linkmodes to match
* @exact: Perform an exact match or not.
*
* Lookup a link_capabilities entry that intersect the supported linkmodes mask,
* and that matches the passed speed and duplex.
*
* When @exact is set, an exact match is performed on speed and duplex, meaning
* that if the linkmodes for the given speed and duplex intersect the supported
* mask, this capability is returned, otherwise we don't have a match and return
* NULL.
*
* When @exact is not set, we return either an exact match, or matching capabilities
* at lower speed, or the lowest matching speed, or NULL.
*
* Non-exact matches will try to return an exact speed and duplex match, but may
* return matching capabilities with same speed but a different duplex.
*
* Returns: a matched link_capabilities according to the above process, NULL
* otherwise.
*/
const struct link_capabilities *
phy_caps_lookup(int speed, unsigned int duplex, const unsigned long *supported,
bool exact)
{
const struct link_capabilities *lcap, *match = NULL, *last = NULL;
for_each_link_caps_desc_speed(lcap) {
if (linkmode_intersects(lcap->linkmodes, supported)) {
last = lcap;
/* exact match on speed and duplex*/
if (lcap->speed == speed && lcap->duplex == duplex) {
return lcap;
} else if (!exact) {
if (!match && lcap->speed <= speed)
match = lcap;
if (lcap->speed < speed)
break;
}
}
}
if (!match && !exact)
match = last;
return match;
}
EXPORT_SYMBOL_GPL(phy_caps_lookup);
/**
* phy_caps_linkmode_max_speed() - Clamp a linkmodes set to a max speed
* @max_speed: Speed limit for the linkmode set
* @linkmodes: Linkmodes to limit
*/
void phy_caps_linkmode_max_speed(u32 max_speed, unsigned long *linkmodes)
{
struct link_capabilities *lcap;
for_each_link_caps_desc_speed(lcap)
if (lcap->speed > max_speed)
linkmode_andnot(linkmodes, linkmodes, lcap->linkmodes);
else
break;
}
/**
* phy_caps_valid() - Validate a linkmodes set agains given speed and duplex
* @speed: input speed to validate
* @duplex: input duplex to validate. Passing DUPLEX_UNKNOWN is always not valid
* @linkmodes: The linkmodes to validate
*
* Returns: True if at least one of the linkmodes in @linkmodes can function at
* the given speed and duplex, false otherwise.
*/
bool phy_caps_valid(int speed, int duplex, const unsigned long *linkmodes)
{
int capa = speed_duplex_to_capa(speed, duplex);
if (capa < 0)
return false;
return linkmode_intersects(link_caps[capa].linkmodes, linkmodes);
}
/**
* phy_caps_linkmodes() - Convert a bitfield of capabilities into linkmodes
* @caps: The list of caps, each bit corresponding to a LINK_CAPA value
* @linkmodes: The set of linkmodes to fill. Must be previously initialized.
*/
void phy_caps_linkmodes(unsigned long caps, unsigned long *linkmodes)
{
unsigned long capa;
for_each_set_bit(capa, &caps, __LINK_CAPA_MAX)
linkmode_or(linkmodes, linkmodes, link_caps[capa].linkmodes);
}
EXPORT_SYMBOL_GPL(phy_caps_linkmodes);
/**
* phy_caps_from_interface() - Get the link capa from a given PHY interface
* @interface: The PHY interface we want to get the possible Speed/Duplex from
*
* Returns: A bitmask of LINK_CAPA_xxx values that can be achieved with the
* provided interface.
*/
unsigned long phy_caps_from_interface(phy_interface_t interface)
{
unsigned long link_caps = 0;
switch (interface) {
case PHY_INTERFACE_MODE_USXGMII:
link_caps |= BIT(LINK_CAPA_10000FD) | BIT(LINK_CAPA_5000FD);
fallthrough;
case PHY_INTERFACE_MODE_10G_QXGMII:
link_caps |= BIT(LINK_CAPA_2500FD);
fallthrough;
case PHY_INTERFACE_MODE_RGMII_TXID:
case PHY_INTERFACE_MODE_RGMII_RXID:
case PHY_INTERFACE_MODE_RGMII_ID:
case PHY_INTERFACE_MODE_RGMII:
case PHY_INTERFACE_MODE_PSGMII:
case PHY_INTERFACE_MODE_QSGMII:
case PHY_INTERFACE_MODE_QUSGMII:
case PHY_INTERFACE_MODE_SGMII:
case PHY_INTERFACE_MODE_GMII:
link_caps |= BIT(LINK_CAPA_1000HD) | BIT(LINK_CAPA_1000FD);
fallthrough;
case PHY_INTERFACE_MODE_REVRMII:
case PHY_INTERFACE_MODE_RMII:
case PHY_INTERFACE_MODE_SMII:
case PHY_INTERFACE_MODE_REVMII:
case PHY_INTERFACE_MODE_MII:
link_caps |= BIT(LINK_CAPA_10HD) | BIT(LINK_CAPA_10FD);
fallthrough;
case PHY_INTERFACE_MODE_100BASEX:
link_caps |= BIT(LINK_CAPA_100HD) | BIT(LINK_CAPA_100FD);
break;
case PHY_INTERFACE_MODE_MIILITE:
link_caps |= BIT(LINK_CAPA_10FD) | BIT(LINK_CAPA_100FD);
break;
case PHY_INTERFACE_MODE_TBI:
case PHY_INTERFACE_MODE_MOCA:
case PHY_INTERFACE_MODE_RTBI:
case PHY_INTERFACE_MODE_1000BASEX:
link_caps |= BIT(LINK_CAPA_1000HD);
fallthrough;
case PHY_INTERFACE_MODE_1000BASEKX:
case PHY_INTERFACE_MODE_TRGMII:
link_caps |= BIT(LINK_CAPA_1000FD);
break;
case PHY_INTERFACE_MODE_2500BASEX:
link_caps |= BIT(LINK_CAPA_2500FD);
break;
case PHY_INTERFACE_MODE_5GBASER:
link_caps |= BIT(LINK_CAPA_5000FD);
break;
case PHY_INTERFACE_MODE_XGMII:
case PHY_INTERFACE_MODE_RXAUI:
case PHY_INTERFACE_MODE_XAUI:
case PHY_INTERFACE_MODE_10GBASER:
case PHY_INTERFACE_MODE_10GKR:
link_caps |= BIT(LINK_CAPA_10000FD);
break;
case PHY_INTERFACE_MODE_25GBASER:
link_caps |= BIT(LINK_CAPA_25000FD);
break;
case PHY_INTERFACE_MODE_XLGMII:
link_caps |= BIT(LINK_CAPA_40000FD);
break;
case PHY_INTERFACE_MODE_50GBASER:
case PHY_INTERFACE_MODE_LAUI:
link_caps |= BIT(LINK_CAPA_50000FD);
break;
case PHY_INTERFACE_MODE_100GBASEP:
link_caps |= BIT(LINK_CAPA_100000FD);
break;
case PHY_INTERFACE_MODE_INTERNAL:
link_caps |= LINK_CAPA_ALL;
break;
case PHY_INTERFACE_MODE_NA:
case PHY_INTERFACE_MODE_MAX:
break;
}
return link_caps;
}
EXPORT_SYMBOL_GPL(phy_caps_from_interface);
/**
* phy_caps_medium_get_supported() - Returns linkmodes supported on a given medium
* @supported: After this call, contains all possible linkmodes on a given medium,
* and with the given number of pairs, or less.
* @medium: The medium to get the support from
* @pairs: The number of pairs used on the given medium. Only relevant for modes
* that support this notion, such as BaseT. Pass 0 if not applicable.
*
* If no match exists, the supported field is left untouched.
*/
void phy_caps_medium_get_supported(unsigned long *supported,
enum ethtool_link_medium medium,
int pairs)
{
int i;
for (i = 0; i < __ETHTOOL_LINK_MODE_MASK_NBITS; i++) {
/* Special bits such as Autoneg, Pause, Asym_pause, etc. are
* set and will be masked away by the port parent.
*/
if (link_mode_params[i].mediums == BIT(ETHTOOL_LINK_MEDIUM_NONE)) {
linkmode_set_bit(i, supported);
continue;
}
/* If this medium matches, and had a non-zero min-pairs */
if (link_mode_params[i].mediums & BIT(medium) &&
(!link_mode_params[i].min_pairs ||
(link_mode_params[i].min_pairs <= pairs &&
link_mode_params[i].pairs >= pairs)))
linkmode_set_bit(i, supported);
}
}
EXPORT_SYMBOL_GPL(phy_caps_medium_get_supported);
/**
* phy_caps_mediums_from_linkmodes() - Get all mediums from a linkmodes list
* @linkmodes: A bitset of linkmodes to get the mediums from
*
* Returns: A bitset of ETHTOOL_MEDIUM_XXX values corresponding to all medium
* types in the linkmodes list
*/
u32 phy_caps_mediums_from_linkmodes(unsigned long *linkmodes)
{
const struct link_mode_info *linkmode;
u32 mediums = 0;
int i;
for_each_set_bit(i, linkmodes, __ETHTOOL_LINK_MODE_MASK_NBITS) {
linkmode = &link_mode_params[i];
mediums |= linkmode->mediums;
}
return mediums;
}
EXPORT_SYMBOL_GPL(phy_caps_mediums_from_linkmodes);