Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 
0003 #include <linux/ethtool_netlink.h>
0004 #include <linux/net_tstamp.h>
0005 #include <linux/phy.h>
0006 #include <linux/rtnetlink.h>
0007 #include <linux/ptp_clock_kernel.h>
0008 
0009 #include "common.h"
0010 
0011 const char netdev_features_strings[NETDEV_FEATURE_COUNT][ETH_GSTRING_LEN] = {
0012     [NETIF_F_SG_BIT] =               "tx-scatter-gather",
0013     [NETIF_F_IP_CSUM_BIT] =          "tx-checksum-ipv4",
0014     [NETIF_F_HW_CSUM_BIT] =          "tx-checksum-ip-generic",
0015     [NETIF_F_IPV6_CSUM_BIT] =        "tx-checksum-ipv6",
0016     [NETIF_F_HIGHDMA_BIT] =          "highdma",
0017     [NETIF_F_FRAGLIST_BIT] =         "tx-scatter-gather-fraglist",
0018     [NETIF_F_HW_VLAN_CTAG_TX_BIT] =  "tx-vlan-hw-insert",
0019 
0020     [NETIF_F_HW_VLAN_CTAG_RX_BIT] =  "rx-vlan-hw-parse",
0021     [NETIF_F_HW_VLAN_CTAG_FILTER_BIT] = "rx-vlan-filter",
0022     [NETIF_F_HW_VLAN_STAG_TX_BIT] =  "tx-vlan-stag-hw-insert",
0023     [NETIF_F_HW_VLAN_STAG_RX_BIT] =  "rx-vlan-stag-hw-parse",
0024     [NETIF_F_HW_VLAN_STAG_FILTER_BIT] = "rx-vlan-stag-filter",
0025     [NETIF_F_VLAN_CHALLENGED_BIT] =  "vlan-challenged",
0026     [NETIF_F_GSO_BIT] =              "tx-generic-segmentation",
0027     [NETIF_F_LLTX_BIT] =             "tx-lockless",
0028     [NETIF_F_NETNS_LOCAL_BIT] =      "netns-local",
0029     [NETIF_F_GRO_BIT] =              "rx-gro",
0030     [NETIF_F_GRO_HW_BIT] =           "rx-gro-hw",
0031     [NETIF_F_LRO_BIT] =              "rx-lro",
0032 
0033     [NETIF_F_TSO_BIT] =              "tx-tcp-segmentation",
0034     [NETIF_F_GSO_ROBUST_BIT] =       "tx-gso-robust",
0035     [NETIF_F_TSO_ECN_BIT] =          "tx-tcp-ecn-segmentation",
0036     [NETIF_F_TSO_MANGLEID_BIT] =     "tx-tcp-mangleid-segmentation",
0037     [NETIF_F_TSO6_BIT] =             "tx-tcp6-segmentation",
0038     [NETIF_F_FSO_BIT] =              "tx-fcoe-segmentation",
0039     [NETIF_F_GSO_GRE_BIT] =      "tx-gre-segmentation",
0040     [NETIF_F_GSO_GRE_CSUM_BIT] =     "tx-gre-csum-segmentation",
0041     [NETIF_F_GSO_IPXIP4_BIT] =   "tx-ipxip4-segmentation",
0042     [NETIF_F_GSO_IPXIP6_BIT] =   "tx-ipxip6-segmentation",
0043     [NETIF_F_GSO_UDP_TUNNEL_BIT] =   "tx-udp_tnl-segmentation",
0044     [NETIF_F_GSO_UDP_TUNNEL_CSUM_BIT] = "tx-udp_tnl-csum-segmentation",
0045     [NETIF_F_GSO_PARTIAL_BIT] =  "tx-gso-partial",
0046     [NETIF_F_GSO_TUNNEL_REMCSUM_BIT] = "tx-tunnel-remcsum-segmentation",
0047     [NETIF_F_GSO_SCTP_BIT] =     "tx-sctp-segmentation",
0048     [NETIF_F_GSO_ESP_BIT] =      "tx-esp-segmentation",
0049     [NETIF_F_GSO_UDP_L4_BIT] =   "tx-udp-segmentation",
0050     [NETIF_F_GSO_FRAGLIST_BIT] =     "tx-gso-list",
0051 
0052     [NETIF_F_FCOE_CRC_BIT] =         "tx-checksum-fcoe-crc",
0053     [NETIF_F_SCTP_CRC_BIT] =        "tx-checksum-sctp",
0054     [NETIF_F_FCOE_MTU_BIT] =         "fcoe-mtu",
0055     [NETIF_F_NTUPLE_BIT] =           "rx-ntuple-filter",
0056     [NETIF_F_RXHASH_BIT] =           "rx-hashing",
0057     [NETIF_F_RXCSUM_BIT] =           "rx-checksum",
0058     [NETIF_F_NOCACHE_COPY_BIT] =     "tx-nocache-copy",
0059     [NETIF_F_LOOPBACK_BIT] =         "loopback",
0060     [NETIF_F_RXFCS_BIT] =            "rx-fcs",
0061     [NETIF_F_RXALL_BIT] =            "rx-all",
0062     [NETIF_F_HW_L2FW_DOFFLOAD_BIT] = "l2-fwd-offload",
0063     [NETIF_F_HW_TC_BIT] =        "hw-tc-offload",
0064     [NETIF_F_HW_ESP_BIT] =       "esp-hw-offload",
0065     [NETIF_F_HW_ESP_TX_CSUM_BIT] =   "esp-tx-csum-hw-offload",
0066     [NETIF_F_RX_UDP_TUNNEL_PORT_BIT] =   "rx-udp_tunnel-port-offload",
0067     [NETIF_F_HW_TLS_RECORD_BIT] =   "tls-hw-record",
0068     [NETIF_F_HW_TLS_TX_BIT] =    "tls-hw-tx-offload",
0069     [NETIF_F_HW_TLS_RX_BIT] =    "tls-hw-rx-offload",
0070     [NETIF_F_GRO_FRAGLIST_BIT] =     "rx-gro-list",
0071     [NETIF_F_HW_MACSEC_BIT] =    "macsec-hw-offload",
0072     [NETIF_F_GRO_UDP_FWD_BIT] =  "rx-udp-gro-forwarding",
0073     [NETIF_F_HW_HSR_TAG_INS_BIT] =   "hsr-tag-ins-offload",
0074     [NETIF_F_HW_HSR_TAG_RM_BIT] =    "hsr-tag-rm-offload",
0075     [NETIF_F_HW_HSR_FWD_BIT] =   "hsr-fwd-offload",
0076     [NETIF_F_HW_HSR_DUP_BIT] =   "hsr-dup-offload",
0077 };
0078 
0079 const char
0080 rss_hash_func_strings[ETH_RSS_HASH_FUNCS_COUNT][ETH_GSTRING_LEN] = {
0081     [ETH_RSS_HASH_TOP_BIT] =    "toeplitz",
0082     [ETH_RSS_HASH_XOR_BIT] =    "xor",
0083     [ETH_RSS_HASH_CRC32_BIT] =  "crc32",
0084 };
0085 
0086 const char
0087 tunable_strings[__ETHTOOL_TUNABLE_COUNT][ETH_GSTRING_LEN] = {
0088     [ETHTOOL_ID_UNSPEC]     = "Unspec",
0089     [ETHTOOL_RX_COPYBREAK]  = "rx-copybreak",
0090     [ETHTOOL_TX_COPYBREAK]  = "tx-copybreak",
0091     [ETHTOOL_PFC_PREVENTION_TOUT] = "pfc-prevention-tout",
0092     [ETHTOOL_TX_COPYBREAK_BUF_SIZE] = "tx-copybreak-buf-size",
0093 };
0094 
0095 const char
0096 phy_tunable_strings[__ETHTOOL_PHY_TUNABLE_COUNT][ETH_GSTRING_LEN] = {
0097     [ETHTOOL_ID_UNSPEC]     = "Unspec",
0098     [ETHTOOL_PHY_DOWNSHIFT] = "phy-downshift",
0099     [ETHTOOL_PHY_FAST_LINK_DOWN] = "phy-fast-link-down",
0100     [ETHTOOL_PHY_EDPD]  = "phy-energy-detect-power-down",
0101 };
0102 
0103 #define __LINK_MODE_NAME(speed, type, duplex) \
0104     #speed "base" #type "/" #duplex
0105 #define __DEFINE_LINK_MODE_NAME(speed, type, duplex) \
0106     [ETHTOOL_LINK_MODE(speed, type, duplex)] = \
0107     __LINK_MODE_NAME(speed, type, duplex)
0108 #define __DEFINE_SPECIAL_MODE_NAME(_mode, _name) \
0109     [ETHTOOL_LINK_MODE_ ## _mode ## _BIT] = _name
0110 
0111 const char link_mode_names[][ETH_GSTRING_LEN] = {
0112     __DEFINE_LINK_MODE_NAME(10, T, Half),
0113     __DEFINE_LINK_MODE_NAME(10, T, Full),
0114     __DEFINE_LINK_MODE_NAME(100, T, Half),
0115     __DEFINE_LINK_MODE_NAME(100, T, Full),
0116     __DEFINE_LINK_MODE_NAME(1000, T, Half),
0117     __DEFINE_LINK_MODE_NAME(1000, T, Full),
0118     __DEFINE_SPECIAL_MODE_NAME(Autoneg, "Autoneg"),
0119     __DEFINE_SPECIAL_MODE_NAME(TP, "TP"),
0120     __DEFINE_SPECIAL_MODE_NAME(AUI, "AUI"),
0121     __DEFINE_SPECIAL_MODE_NAME(MII, "MII"),
0122     __DEFINE_SPECIAL_MODE_NAME(FIBRE, "FIBRE"),
0123     __DEFINE_SPECIAL_MODE_NAME(BNC, "BNC"),
0124     __DEFINE_LINK_MODE_NAME(10000, T, Full),
0125     __DEFINE_SPECIAL_MODE_NAME(Pause, "Pause"),
0126     __DEFINE_SPECIAL_MODE_NAME(Asym_Pause, "Asym_Pause"),
0127     __DEFINE_LINK_MODE_NAME(2500, X, Full),
0128     __DEFINE_SPECIAL_MODE_NAME(Backplane, "Backplane"),
0129     __DEFINE_LINK_MODE_NAME(1000, KX, Full),
0130     __DEFINE_LINK_MODE_NAME(10000, KX4, Full),
0131     __DEFINE_LINK_MODE_NAME(10000, KR, Full),
0132     __DEFINE_SPECIAL_MODE_NAME(10000baseR_FEC, "10000baseR_FEC"),
0133     __DEFINE_LINK_MODE_NAME(20000, MLD2, Full),
0134     __DEFINE_LINK_MODE_NAME(20000, KR2, Full),
0135     __DEFINE_LINK_MODE_NAME(40000, KR4, Full),
0136     __DEFINE_LINK_MODE_NAME(40000, CR4, Full),
0137     __DEFINE_LINK_MODE_NAME(40000, SR4, Full),
0138     __DEFINE_LINK_MODE_NAME(40000, LR4, Full),
0139     __DEFINE_LINK_MODE_NAME(56000, KR4, Full),
0140     __DEFINE_LINK_MODE_NAME(56000, CR4, Full),
0141     __DEFINE_LINK_MODE_NAME(56000, SR4, Full),
0142     __DEFINE_LINK_MODE_NAME(56000, LR4, Full),
0143     __DEFINE_LINK_MODE_NAME(25000, CR, Full),
0144     __DEFINE_LINK_MODE_NAME(25000, KR, Full),
0145     __DEFINE_LINK_MODE_NAME(25000, SR, Full),
0146     __DEFINE_LINK_MODE_NAME(50000, CR2, Full),
0147     __DEFINE_LINK_MODE_NAME(50000, KR2, Full),
0148     __DEFINE_LINK_MODE_NAME(100000, KR4, Full),
0149     __DEFINE_LINK_MODE_NAME(100000, SR4, Full),
0150     __DEFINE_LINK_MODE_NAME(100000, CR4, Full),
0151     __DEFINE_LINK_MODE_NAME(100000, LR4_ER4, Full),
0152     __DEFINE_LINK_MODE_NAME(50000, SR2, Full),
0153     __DEFINE_LINK_MODE_NAME(1000, X, Full),
0154     __DEFINE_LINK_MODE_NAME(10000, CR, Full),
0155     __DEFINE_LINK_MODE_NAME(10000, SR, Full),
0156     __DEFINE_LINK_MODE_NAME(10000, LR, Full),
0157     __DEFINE_LINK_MODE_NAME(10000, LRM, Full),
0158     __DEFINE_LINK_MODE_NAME(10000, ER, Full),
0159     __DEFINE_LINK_MODE_NAME(2500, T, Full),
0160     __DEFINE_LINK_MODE_NAME(5000, T, Full),
0161     __DEFINE_SPECIAL_MODE_NAME(FEC_NONE, "None"),
0162     __DEFINE_SPECIAL_MODE_NAME(FEC_RS, "RS"),
0163     __DEFINE_SPECIAL_MODE_NAME(FEC_BASER, "BASER"),
0164     __DEFINE_LINK_MODE_NAME(50000, KR, Full),
0165     __DEFINE_LINK_MODE_NAME(50000, SR, Full),
0166     __DEFINE_LINK_MODE_NAME(50000, CR, Full),
0167     __DEFINE_LINK_MODE_NAME(50000, LR_ER_FR, Full),
0168     __DEFINE_LINK_MODE_NAME(50000, DR, Full),
0169     __DEFINE_LINK_MODE_NAME(100000, KR2, Full),
0170     __DEFINE_LINK_MODE_NAME(100000, SR2, Full),
0171     __DEFINE_LINK_MODE_NAME(100000, CR2, Full),
0172     __DEFINE_LINK_MODE_NAME(100000, LR2_ER2_FR2, Full),
0173     __DEFINE_LINK_MODE_NAME(100000, DR2, Full),
0174     __DEFINE_LINK_MODE_NAME(200000, KR4, Full),
0175     __DEFINE_LINK_MODE_NAME(200000, SR4, Full),
0176     __DEFINE_LINK_MODE_NAME(200000, LR4_ER4_FR4, Full),
0177     __DEFINE_LINK_MODE_NAME(200000, DR4, Full),
0178     __DEFINE_LINK_MODE_NAME(200000, CR4, Full),
0179     __DEFINE_LINK_MODE_NAME(100, T1, Full),
0180     __DEFINE_LINK_MODE_NAME(1000, T1, Full),
0181     __DEFINE_LINK_MODE_NAME(400000, KR8, Full),
0182     __DEFINE_LINK_MODE_NAME(400000, SR8, Full),
0183     __DEFINE_LINK_MODE_NAME(400000, LR8_ER8_FR8, Full),
0184     __DEFINE_LINK_MODE_NAME(400000, DR8, Full),
0185     __DEFINE_LINK_MODE_NAME(400000, CR8, Full),
0186     __DEFINE_SPECIAL_MODE_NAME(FEC_LLRS, "LLRS"),
0187     __DEFINE_LINK_MODE_NAME(100000, KR, Full),
0188     __DEFINE_LINK_MODE_NAME(100000, SR, Full),
0189     __DEFINE_LINK_MODE_NAME(100000, LR_ER_FR, Full),
0190     __DEFINE_LINK_MODE_NAME(100000, DR, Full),
0191     __DEFINE_LINK_MODE_NAME(100000, CR, Full),
0192     __DEFINE_LINK_MODE_NAME(200000, KR2, Full),
0193     __DEFINE_LINK_MODE_NAME(200000, SR2, Full),
0194     __DEFINE_LINK_MODE_NAME(200000, LR2_ER2_FR2, Full),
0195     __DEFINE_LINK_MODE_NAME(200000, DR2, Full),
0196     __DEFINE_LINK_MODE_NAME(200000, CR2, Full),
0197     __DEFINE_LINK_MODE_NAME(400000, KR4, Full),
0198     __DEFINE_LINK_MODE_NAME(400000, SR4, Full),
0199     __DEFINE_LINK_MODE_NAME(400000, LR4_ER4_FR4, Full),
0200     __DEFINE_LINK_MODE_NAME(400000, DR4, Full),
0201     __DEFINE_LINK_MODE_NAME(400000, CR4, Full),
0202     __DEFINE_LINK_MODE_NAME(100, FX, Half),
0203     __DEFINE_LINK_MODE_NAME(100, FX, Full),
0204     __DEFINE_LINK_MODE_NAME(10, T1L, Full),
0205 };
0206 static_assert(ARRAY_SIZE(link_mode_names) == __ETHTOOL_LINK_MODE_MASK_NBITS);
0207 
0208 #define __LINK_MODE_LANES_CR        1
0209 #define __LINK_MODE_LANES_CR2       2
0210 #define __LINK_MODE_LANES_CR4       4
0211 #define __LINK_MODE_LANES_CR8       8
0212 #define __LINK_MODE_LANES_DR        1
0213 #define __LINK_MODE_LANES_DR2       2
0214 #define __LINK_MODE_LANES_DR4       4
0215 #define __LINK_MODE_LANES_DR8       8
0216 #define __LINK_MODE_LANES_KR        1
0217 #define __LINK_MODE_LANES_KR2       2
0218 #define __LINK_MODE_LANES_KR4       4
0219 #define __LINK_MODE_LANES_KR8       8
0220 #define __LINK_MODE_LANES_SR        1
0221 #define __LINK_MODE_LANES_SR2       2
0222 #define __LINK_MODE_LANES_SR4       4
0223 #define __LINK_MODE_LANES_SR8       8
0224 #define __LINK_MODE_LANES_ER        1
0225 #define __LINK_MODE_LANES_KX        1
0226 #define __LINK_MODE_LANES_KX4       4
0227 #define __LINK_MODE_LANES_LR        1
0228 #define __LINK_MODE_LANES_LR4       4
0229 #define __LINK_MODE_LANES_LR4_ER4   4
0230 #define __LINK_MODE_LANES_LR_ER_FR  1
0231 #define __LINK_MODE_LANES_LR2_ER2_FR2   2
0232 #define __LINK_MODE_LANES_LR4_ER4_FR4   4
0233 #define __LINK_MODE_LANES_LR8_ER8_FR8   8
0234 #define __LINK_MODE_LANES_LRM       1
0235 #define __LINK_MODE_LANES_MLD2      2
0236 #define __LINK_MODE_LANES_T     1
0237 #define __LINK_MODE_LANES_T1        1
0238 #define __LINK_MODE_LANES_X     1
0239 #define __LINK_MODE_LANES_FX        1
0240 #define __LINK_MODE_LANES_T1L       1
0241 
0242 #define __DEFINE_LINK_MODE_PARAMS(_speed, _type, _duplex)   \
0243     [ETHTOOL_LINK_MODE(_speed, _type, _duplex)] = {     \
0244         .speed  = SPEED_ ## _speed, \
0245         .lanes  = __LINK_MODE_LANES_ ## _type, \
0246         .duplex = __DUPLEX_ ## _duplex \
0247     }
0248 #define __DUPLEX_Half DUPLEX_HALF
0249 #define __DUPLEX_Full DUPLEX_FULL
0250 #define __DEFINE_SPECIAL_MODE_PARAMS(_mode) \
0251     [ETHTOOL_LINK_MODE_ ## _mode ## _BIT] = { \
0252         .speed  = SPEED_UNKNOWN, \
0253         .lanes  = 0, \
0254         .duplex = DUPLEX_UNKNOWN, \
0255     }
0256 
0257 const struct link_mode_info link_mode_params[] = {
0258     __DEFINE_LINK_MODE_PARAMS(10, T, Half),
0259     __DEFINE_LINK_MODE_PARAMS(10, T, Full),
0260     __DEFINE_LINK_MODE_PARAMS(100, T, Half),
0261     __DEFINE_LINK_MODE_PARAMS(100, T, Full),
0262     __DEFINE_LINK_MODE_PARAMS(1000, T, Half),
0263     __DEFINE_LINK_MODE_PARAMS(1000, T, Full),
0264     __DEFINE_SPECIAL_MODE_PARAMS(Autoneg),
0265     __DEFINE_SPECIAL_MODE_PARAMS(TP),
0266     __DEFINE_SPECIAL_MODE_PARAMS(AUI),
0267     __DEFINE_SPECIAL_MODE_PARAMS(MII),
0268     __DEFINE_SPECIAL_MODE_PARAMS(FIBRE),
0269     __DEFINE_SPECIAL_MODE_PARAMS(BNC),
0270     __DEFINE_LINK_MODE_PARAMS(10000, T, Full),
0271     __DEFINE_SPECIAL_MODE_PARAMS(Pause),
0272     __DEFINE_SPECIAL_MODE_PARAMS(Asym_Pause),
0273     __DEFINE_LINK_MODE_PARAMS(2500, X, Full),
0274     __DEFINE_SPECIAL_MODE_PARAMS(Backplane),
0275     __DEFINE_LINK_MODE_PARAMS(1000, KX, Full),
0276     __DEFINE_LINK_MODE_PARAMS(10000, KX4, Full),
0277     __DEFINE_LINK_MODE_PARAMS(10000, KR, Full),
0278     [ETHTOOL_LINK_MODE_10000baseR_FEC_BIT] = {
0279         .speed  = SPEED_10000,
0280         .lanes  = 1,
0281         .duplex = DUPLEX_FULL,
0282     },
0283     __DEFINE_LINK_MODE_PARAMS(20000, MLD2, Full),
0284     __DEFINE_LINK_MODE_PARAMS(20000, KR2, Full),
0285     __DEFINE_LINK_MODE_PARAMS(40000, KR4, Full),
0286     __DEFINE_LINK_MODE_PARAMS(40000, CR4, Full),
0287     __DEFINE_LINK_MODE_PARAMS(40000, SR4, Full),
0288     __DEFINE_LINK_MODE_PARAMS(40000, LR4, Full),
0289     __DEFINE_LINK_MODE_PARAMS(56000, KR4, Full),
0290     __DEFINE_LINK_MODE_PARAMS(56000, CR4, Full),
0291     __DEFINE_LINK_MODE_PARAMS(56000, SR4, Full),
0292     __DEFINE_LINK_MODE_PARAMS(56000, LR4, Full),
0293     __DEFINE_LINK_MODE_PARAMS(25000, CR, Full),
0294     __DEFINE_LINK_MODE_PARAMS(25000, KR, Full),
0295     __DEFINE_LINK_MODE_PARAMS(25000, SR, Full),
0296     __DEFINE_LINK_MODE_PARAMS(50000, CR2, Full),
0297     __DEFINE_LINK_MODE_PARAMS(50000, KR2, Full),
0298     __DEFINE_LINK_MODE_PARAMS(100000, KR4, Full),
0299     __DEFINE_LINK_MODE_PARAMS(100000, SR4, Full),
0300     __DEFINE_LINK_MODE_PARAMS(100000, CR4, Full),
0301     __DEFINE_LINK_MODE_PARAMS(100000, LR4_ER4, Full),
0302     __DEFINE_LINK_MODE_PARAMS(50000, SR2, Full),
0303     __DEFINE_LINK_MODE_PARAMS(1000, X, Full),
0304     __DEFINE_LINK_MODE_PARAMS(10000, CR, Full),
0305     __DEFINE_LINK_MODE_PARAMS(10000, SR, Full),
0306     __DEFINE_LINK_MODE_PARAMS(10000, LR, Full),
0307     __DEFINE_LINK_MODE_PARAMS(10000, LRM, Full),
0308     __DEFINE_LINK_MODE_PARAMS(10000, ER, Full),
0309     __DEFINE_LINK_MODE_PARAMS(2500, T, Full),
0310     __DEFINE_LINK_MODE_PARAMS(5000, T, Full),
0311     __DEFINE_SPECIAL_MODE_PARAMS(FEC_NONE),
0312     __DEFINE_SPECIAL_MODE_PARAMS(FEC_RS),
0313     __DEFINE_SPECIAL_MODE_PARAMS(FEC_BASER),
0314     __DEFINE_LINK_MODE_PARAMS(50000, KR, Full),
0315     __DEFINE_LINK_MODE_PARAMS(50000, SR, Full),
0316     __DEFINE_LINK_MODE_PARAMS(50000, CR, Full),
0317     __DEFINE_LINK_MODE_PARAMS(50000, LR_ER_FR, Full),
0318     __DEFINE_LINK_MODE_PARAMS(50000, DR, Full),
0319     __DEFINE_LINK_MODE_PARAMS(100000, KR2, Full),
0320     __DEFINE_LINK_MODE_PARAMS(100000, SR2, Full),
0321     __DEFINE_LINK_MODE_PARAMS(100000, CR2, Full),
0322     __DEFINE_LINK_MODE_PARAMS(100000, LR2_ER2_FR2, Full),
0323     __DEFINE_LINK_MODE_PARAMS(100000, DR2, Full),
0324     __DEFINE_LINK_MODE_PARAMS(200000, KR4, Full),
0325     __DEFINE_LINK_MODE_PARAMS(200000, SR4, Full),
0326     __DEFINE_LINK_MODE_PARAMS(200000, LR4_ER4_FR4, Full),
0327     __DEFINE_LINK_MODE_PARAMS(200000, DR4, Full),
0328     __DEFINE_LINK_MODE_PARAMS(200000, CR4, Full),
0329     __DEFINE_LINK_MODE_PARAMS(100, T1, Full),
0330     __DEFINE_LINK_MODE_PARAMS(1000, T1, Full),
0331     __DEFINE_LINK_MODE_PARAMS(400000, KR8, Full),
0332     __DEFINE_LINK_MODE_PARAMS(400000, SR8, Full),
0333     __DEFINE_LINK_MODE_PARAMS(400000, LR8_ER8_FR8, Full),
0334     __DEFINE_LINK_MODE_PARAMS(400000, DR8, Full),
0335     __DEFINE_LINK_MODE_PARAMS(400000, CR8, Full),
0336     __DEFINE_SPECIAL_MODE_PARAMS(FEC_LLRS),
0337     __DEFINE_LINK_MODE_PARAMS(100000, KR, Full),
0338     __DEFINE_LINK_MODE_PARAMS(100000, SR, Full),
0339     __DEFINE_LINK_MODE_PARAMS(100000, LR_ER_FR, Full),
0340     __DEFINE_LINK_MODE_PARAMS(100000, DR, Full),
0341     __DEFINE_LINK_MODE_PARAMS(100000, CR, Full),
0342     __DEFINE_LINK_MODE_PARAMS(200000, KR2, Full),
0343     __DEFINE_LINK_MODE_PARAMS(200000, SR2, Full),
0344     __DEFINE_LINK_MODE_PARAMS(200000, LR2_ER2_FR2, Full),
0345     __DEFINE_LINK_MODE_PARAMS(200000, DR2, Full),
0346     __DEFINE_LINK_MODE_PARAMS(200000, CR2, Full),
0347     __DEFINE_LINK_MODE_PARAMS(400000, KR4, Full),
0348     __DEFINE_LINK_MODE_PARAMS(400000, SR4, Full),
0349     __DEFINE_LINK_MODE_PARAMS(400000, LR4_ER4_FR4, Full),
0350     __DEFINE_LINK_MODE_PARAMS(400000, DR4, Full),
0351     __DEFINE_LINK_MODE_PARAMS(400000, CR4, Full),
0352     __DEFINE_LINK_MODE_PARAMS(100, FX, Half),
0353     __DEFINE_LINK_MODE_PARAMS(100, FX, Full),
0354     __DEFINE_LINK_MODE_PARAMS(10, T1L, Full),
0355 };
0356 static_assert(ARRAY_SIZE(link_mode_params) == __ETHTOOL_LINK_MODE_MASK_NBITS);
0357 
0358 const char netif_msg_class_names[][ETH_GSTRING_LEN] = {
0359     [NETIF_MSG_DRV_BIT]     = "drv",
0360     [NETIF_MSG_PROBE_BIT]       = "probe",
0361     [NETIF_MSG_LINK_BIT]        = "link",
0362     [NETIF_MSG_TIMER_BIT]       = "timer",
0363     [NETIF_MSG_IFDOWN_BIT]      = "ifdown",
0364     [NETIF_MSG_IFUP_BIT]        = "ifup",
0365     [NETIF_MSG_RX_ERR_BIT]      = "rx_err",
0366     [NETIF_MSG_TX_ERR_BIT]      = "tx_err",
0367     [NETIF_MSG_TX_QUEUED_BIT]   = "tx_queued",
0368     [NETIF_MSG_INTR_BIT]        = "intr",
0369     [NETIF_MSG_TX_DONE_BIT]     = "tx_done",
0370     [NETIF_MSG_RX_STATUS_BIT]   = "rx_status",
0371     [NETIF_MSG_PKTDATA_BIT]     = "pktdata",
0372     [NETIF_MSG_HW_BIT]      = "hw",
0373     [NETIF_MSG_WOL_BIT]     = "wol",
0374 };
0375 static_assert(ARRAY_SIZE(netif_msg_class_names) == NETIF_MSG_CLASS_COUNT);
0376 
0377 const char wol_mode_names[][ETH_GSTRING_LEN] = {
0378     [const_ilog2(WAKE_PHY)]     = "phy",
0379     [const_ilog2(WAKE_UCAST)]   = "ucast",
0380     [const_ilog2(WAKE_MCAST)]   = "mcast",
0381     [const_ilog2(WAKE_BCAST)]   = "bcast",
0382     [const_ilog2(WAKE_ARP)]     = "arp",
0383     [const_ilog2(WAKE_MAGIC)]   = "magic",
0384     [const_ilog2(WAKE_MAGICSECURE)] = "magicsecure",
0385     [const_ilog2(WAKE_FILTER)]  = "filter",
0386 };
0387 static_assert(ARRAY_SIZE(wol_mode_names) == WOL_MODE_COUNT);
0388 
0389 const char sof_timestamping_names[][ETH_GSTRING_LEN] = {
0390     [const_ilog2(SOF_TIMESTAMPING_TX_HARDWARE)]  = "hardware-transmit",
0391     [const_ilog2(SOF_TIMESTAMPING_TX_SOFTWARE)]  = "software-transmit",
0392     [const_ilog2(SOF_TIMESTAMPING_RX_HARDWARE)]  = "hardware-receive",
0393     [const_ilog2(SOF_TIMESTAMPING_RX_SOFTWARE)]  = "software-receive",
0394     [const_ilog2(SOF_TIMESTAMPING_SOFTWARE)]     = "software-system-clock",
0395     [const_ilog2(SOF_TIMESTAMPING_SYS_HARDWARE)] = "hardware-legacy-clock",
0396     [const_ilog2(SOF_TIMESTAMPING_RAW_HARDWARE)] = "hardware-raw-clock",
0397     [const_ilog2(SOF_TIMESTAMPING_OPT_ID)]       = "option-id",
0398     [const_ilog2(SOF_TIMESTAMPING_TX_SCHED)]     = "sched-transmit",
0399     [const_ilog2(SOF_TIMESTAMPING_TX_ACK)]       = "ack-transmit",
0400     [const_ilog2(SOF_TIMESTAMPING_OPT_CMSG)]     = "option-cmsg",
0401     [const_ilog2(SOF_TIMESTAMPING_OPT_TSONLY)]   = "option-tsonly",
0402     [const_ilog2(SOF_TIMESTAMPING_OPT_STATS)]    = "option-stats",
0403     [const_ilog2(SOF_TIMESTAMPING_OPT_PKTINFO)]  = "option-pktinfo",
0404     [const_ilog2(SOF_TIMESTAMPING_OPT_TX_SWHW)]  = "option-tx-swhw",
0405     [const_ilog2(SOF_TIMESTAMPING_BIND_PHC)]     = "bind-phc",
0406 };
0407 static_assert(ARRAY_SIZE(sof_timestamping_names) == __SOF_TIMESTAMPING_CNT);
0408 
0409 const char ts_tx_type_names[][ETH_GSTRING_LEN] = {
0410     [HWTSTAMP_TX_OFF]       = "off",
0411     [HWTSTAMP_TX_ON]        = "on",
0412     [HWTSTAMP_TX_ONESTEP_SYNC]  = "onestep-sync",
0413     [HWTSTAMP_TX_ONESTEP_P2P]   = "onestep-p2p",
0414 };
0415 static_assert(ARRAY_SIZE(ts_tx_type_names) == __HWTSTAMP_TX_CNT);
0416 
0417 const char ts_rx_filter_names[][ETH_GSTRING_LEN] = {
0418     [HWTSTAMP_FILTER_NONE]          = "none",
0419     [HWTSTAMP_FILTER_ALL]           = "all",
0420     [HWTSTAMP_FILTER_SOME]          = "some",
0421     [HWTSTAMP_FILTER_PTP_V1_L4_EVENT]   = "ptpv1-l4-event",
0422     [HWTSTAMP_FILTER_PTP_V1_L4_SYNC]    = "ptpv1-l4-sync",
0423     [HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ]   = "ptpv1-l4-delay-req",
0424     [HWTSTAMP_FILTER_PTP_V2_L4_EVENT]   = "ptpv2-l4-event",
0425     [HWTSTAMP_FILTER_PTP_V2_L4_SYNC]    = "ptpv2-l4-sync",
0426     [HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ]   = "ptpv2-l4-delay-req",
0427     [HWTSTAMP_FILTER_PTP_V2_L2_EVENT]   = "ptpv2-l2-event",
0428     [HWTSTAMP_FILTER_PTP_V2_L2_SYNC]    = "ptpv2-l2-sync",
0429     [HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ]   = "ptpv2-l2-delay-req",
0430     [HWTSTAMP_FILTER_PTP_V2_EVENT]      = "ptpv2-event",
0431     [HWTSTAMP_FILTER_PTP_V2_SYNC]       = "ptpv2-sync",
0432     [HWTSTAMP_FILTER_PTP_V2_DELAY_REQ]  = "ptpv2-delay-req",
0433     [HWTSTAMP_FILTER_NTP_ALL]       = "ntp-all",
0434 };
0435 static_assert(ARRAY_SIZE(ts_rx_filter_names) == __HWTSTAMP_FILTER_CNT);
0436 
0437 const char udp_tunnel_type_names[][ETH_GSTRING_LEN] = {
0438     [ETHTOOL_UDP_TUNNEL_TYPE_VXLAN]     = "vxlan",
0439     [ETHTOOL_UDP_TUNNEL_TYPE_GENEVE]    = "geneve",
0440     [ETHTOOL_UDP_TUNNEL_TYPE_VXLAN_GPE] = "vxlan-gpe",
0441 };
0442 static_assert(ARRAY_SIZE(udp_tunnel_type_names) ==
0443           __ETHTOOL_UDP_TUNNEL_TYPE_CNT);
0444 
0445 /* return false if legacy contained non-0 deprecated fields
0446  * maxtxpkt/maxrxpkt. rest of ksettings always updated
0447  */
0448 bool
0449 convert_legacy_settings_to_link_ksettings(
0450     struct ethtool_link_ksettings *link_ksettings,
0451     const struct ethtool_cmd *legacy_settings)
0452 {
0453     bool retval = true;
0454 
0455     memset(link_ksettings, 0, sizeof(*link_ksettings));
0456 
0457     /* This is used to tell users that driver is still using these
0458      * deprecated legacy fields, and they should not use
0459      * %ETHTOOL_GLINKSETTINGS/%ETHTOOL_SLINKSETTINGS
0460      */
0461     if (legacy_settings->maxtxpkt ||
0462         legacy_settings->maxrxpkt)
0463         retval = false;
0464 
0465     ethtool_convert_legacy_u32_to_link_mode(
0466         link_ksettings->link_modes.supported,
0467         legacy_settings->supported);
0468     ethtool_convert_legacy_u32_to_link_mode(
0469         link_ksettings->link_modes.advertising,
0470         legacy_settings->advertising);
0471     ethtool_convert_legacy_u32_to_link_mode(
0472         link_ksettings->link_modes.lp_advertising,
0473         legacy_settings->lp_advertising);
0474     link_ksettings->base.speed
0475         = ethtool_cmd_speed(legacy_settings);
0476     link_ksettings->base.duplex
0477         = legacy_settings->duplex;
0478     link_ksettings->base.port
0479         = legacy_settings->port;
0480     link_ksettings->base.phy_address
0481         = legacy_settings->phy_address;
0482     link_ksettings->base.autoneg
0483         = legacy_settings->autoneg;
0484     link_ksettings->base.mdio_support
0485         = legacy_settings->mdio_support;
0486     link_ksettings->base.eth_tp_mdix
0487         = legacy_settings->eth_tp_mdix;
0488     link_ksettings->base.eth_tp_mdix_ctrl
0489         = legacy_settings->eth_tp_mdix_ctrl;
0490     return retval;
0491 }
0492 
0493 int __ethtool_get_link(struct net_device *dev)
0494 {
0495     if (!dev->ethtool_ops->get_link)
0496         return -EOPNOTSUPP;
0497 
0498     return netif_running(dev) && dev->ethtool_ops->get_link(dev);
0499 }
0500 
0501 int ethtool_get_max_rxfh_channel(struct net_device *dev, u32 *max)
0502 {
0503     u32 dev_size, current_max = 0;
0504     u32 *indir;
0505     int ret;
0506 
0507     if (!dev->ethtool_ops->get_rxfh_indir_size ||
0508         !dev->ethtool_ops->get_rxfh)
0509         return -EOPNOTSUPP;
0510     dev_size = dev->ethtool_ops->get_rxfh_indir_size(dev);
0511     if (dev_size == 0)
0512         return -EOPNOTSUPP;
0513 
0514     indir = kcalloc(dev_size, sizeof(indir[0]), GFP_USER);
0515     if (!indir)
0516         return -ENOMEM;
0517 
0518     ret = dev->ethtool_ops->get_rxfh(dev, indir, NULL, NULL);
0519     if (ret)
0520         goto out;
0521 
0522     while (dev_size--)
0523         current_max = max(current_max, indir[dev_size]);
0524 
0525     *max = current_max;
0526 
0527 out:
0528     kfree(indir);
0529     return ret;
0530 }
0531 
0532 int ethtool_check_ops(const struct ethtool_ops *ops)
0533 {
0534     if (WARN_ON(ops->set_coalesce && !ops->supported_coalesce_params))
0535         return -EINVAL;
0536     /* NOTE: sufficiently insane drivers may swap ethtool_ops at runtime,
0537      * the fact that ops are checked at registration time does not
0538      * mean the ops attached to a netdev later on are sane.
0539      */
0540     return 0;
0541 }
0542 
0543 int __ethtool_get_ts_info(struct net_device *dev, struct ethtool_ts_info *info)
0544 {
0545     const struct ethtool_ops *ops = dev->ethtool_ops;
0546     struct phy_device *phydev = dev->phydev;
0547 
0548     memset(info, 0, sizeof(*info));
0549     info->cmd = ETHTOOL_GET_TS_INFO;
0550 
0551     if (phy_has_tsinfo(phydev))
0552         return phy_ts_info(phydev, info);
0553     if (ops->get_ts_info)
0554         return ops->get_ts_info(dev, info);
0555 
0556     info->so_timestamping = SOF_TIMESTAMPING_RX_SOFTWARE |
0557                 SOF_TIMESTAMPING_SOFTWARE;
0558     info->phc_index = -1;
0559 
0560     return 0;
0561 }
0562 
0563 int ethtool_get_phc_vclocks(struct net_device *dev, int **vclock_index)
0564 {
0565     struct ethtool_ts_info info = { };
0566     int num = 0;
0567 
0568     if (!__ethtool_get_ts_info(dev, &info))
0569         num = ptp_get_vclocks_index(info.phc_index, vclock_index);
0570 
0571     return num;
0572 }
0573 EXPORT_SYMBOL(ethtool_get_phc_vclocks);
0574 
0575 const struct ethtool_phy_ops *ethtool_phy_ops;
0576 
0577 void ethtool_set_ethtool_phy_ops(const struct ethtool_phy_ops *ops)
0578 {
0579     rtnl_lock();
0580     ethtool_phy_ops = ops;
0581     rtnl_unlock();
0582 }
0583 EXPORT_SYMBOL_GPL(ethtool_set_ethtool_phy_ops);
0584 
0585 void
0586 ethtool_params_from_link_mode(struct ethtool_link_ksettings *link_ksettings,
0587                   enum ethtool_link_mode_bit_indices link_mode)
0588 {
0589     const struct link_mode_info *link_info;
0590 
0591     if (WARN_ON_ONCE(link_mode >= __ETHTOOL_LINK_MODE_MASK_NBITS))
0592         return;
0593 
0594     link_info = &link_mode_params[link_mode];
0595     link_ksettings->base.speed = link_info->speed;
0596     link_ksettings->lanes = link_info->lanes;
0597     link_ksettings->base.duplex = link_info->duplex;
0598 }
0599 EXPORT_SYMBOL_GPL(ethtool_params_from_link_mode);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!