1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * ethtool.h: Defines for Linux ethtool. 4 * 5 * Copyright (C) 1998 David S. Miller ([email protected]) 6 * Copyright 2001 Jeff Garzik <[email protected]> 7 * Portions Copyright 2001 Sun Microsystems ([email protected]) 8 * Portions Copyright 2002 Intel ([email protected], 9 * [email protected], 10 * [email protected]) 11 * Portions Copyright (C) Sun Microsystems 2008 12 */ 13 #ifndef _LINUX_ETHTOOL_H 14 #define _LINUX_ETHTOOL_H 15 16 #include <linux/bitmap.h> 17 #include <linux/compat.h> 18 #include <linux/netlink.h> 19 #include <uapi/linux/ethtool.h> 20 21 struct compat_ethtool_rx_flow_spec { 22 u32 flow_type; 23 union ethtool_flow_union h_u; 24 struct ethtool_flow_ext h_ext; 25 union ethtool_flow_union m_u; 26 struct ethtool_flow_ext m_ext; 27 compat_u64 ring_cookie; 28 u32 location; 29 }; 30 31 struct compat_ethtool_rxnfc { 32 u32 cmd; 33 u32 flow_type; 34 compat_u64 data; 35 struct compat_ethtool_rx_flow_spec fs; 36 u32 rule_cnt; 37 u32 rule_locs[]; 38 }; 39 40 #include <linux/rculist.h> 41 42 /** 43 * enum ethtool_phys_id_state - indicator state for physical identification 44 * @ETHTOOL_ID_INACTIVE: Physical ID indicator should be deactivated 45 * @ETHTOOL_ID_ACTIVE: Physical ID indicator should be activated 46 * @ETHTOOL_ID_ON: LED should be turned on (used iff %ETHTOOL_ID_ACTIVE 47 * is not supported) 48 * @ETHTOOL_ID_OFF: LED should be turned off (used iff %ETHTOOL_ID_ACTIVE 49 * is not supported) 50 */ 51 enum ethtool_phys_id_state { 52 ETHTOOL_ID_INACTIVE, 53 ETHTOOL_ID_ACTIVE, 54 ETHTOOL_ID_ON, 55 ETHTOOL_ID_OFF 56 }; 57 58 enum { 59 ETH_RSS_HASH_TOP_BIT, /* Configurable RSS hash function - Toeplitz */ 60 ETH_RSS_HASH_XOR_BIT, /* Configurable RSS hash function - Xor */ 61 ETH_RSS_HASH_CRC32_BIT, /* Configurable RSS hash function - Crc32 */ 62 63 /* 64 * Add your fresh new hash function bits above and remember to update 65 * rss_hash_func_strings[] in ethtool.c 66 */ 67 ETH_RSS_HASH_FUNCS_COUNT 68 }; 69 70 /** 71 * struct kernel_ethtool_ringparam - RX/TX ring configuration 72 * @rx_buf_len: Current length of buffers on the rx ring. 73 * @tcp_data_split: Scatter packet headers and data to separate buffers 74 * @cqe_size: Size of TX/RX completion queue event 75 */ 76 struct kernel_ethtool_ringparam { 77 u32 rx_buf_len; 78 u8 tcp_data_split; 79 u32 cqe_size; 80 }; 81 82 /** 83 * enum ethtool_supported_ring_param - indicator caps for setting ring params 84 * @ETHTOOL_RING_USE_RX_BUF_LEN: capture for setting rx_buf_len 85 * @ETHTOOL_RING_USE_CQE_SIZE: capture for setting cqe_size 86 */ 87 enum ethtool_supported_ring_param { 88 ETHTOOL_RING_USE_RX_BUF_LEN = BIT(0), 89 ETHTOOL_RING_USE_CQE_SIZE = BIT(1), 90 }; 91 92 #define __ETH_RSS_HASH_BIT(bit) ((u32)1 << (bit)) 93 #define __ETH_RSS_HASH(name) __ETH_RSS_HASH_BIT(ETH_RSS_HASH_##name##_BIT) 94 95 #define ETH_RSS_HASH_TOP __ETH_RSS_HASH(TOP) 96 #define ETH_RSS_HASH_XOR __ETH_RSS_HASH(XOR) 97 #define ETH_RSS_HASH_CRC32 __ETH_RSS_HASH(CRC32) 98 99 #define ETH_RSS_HASH_UNKNOWN 0 100 #define ETH_RSS_HASH_NO_CHANGE 0 101 102 struct net_device; 103 struct netlink_ext_ack; 104 105 /* Some generic methods drivers may use in their ethtool_ops */ 106 u32 ethtool_op_get_link(struct net_device *dev); 107 int ethtool_op_get_ts_info(struct net_device *dev, struct ethtool_ts_info *eti); 108 109 110 /* Link extended state and substate. */ 111 struct ethtool_link_ext_state_info { 112 enum ethtool_link_ext_state link_ext_state; 113 union { 114 enum ethtool_link_ext_substate_autoneg autoneg; 115 enum ethtool_link_ext_substate_link_training link_training; 116 enum ethtool_link_ext_substate_link_logical_mismatch link_logical_mismatch; 117 enum ethtool_link_ext_substate_bad_signal_integrity bad_signal_integrity; 118 enum ethtool_link_ext_substate_cable_issue cable_issue; 119 enum ethtool_link_ext_substate_module module; 120 u32 __link_ext_substate; 121 }; 122 }; 123 124 /** 125 * ethtool_rxfh_indir_default - get default value for RX flow hash indirection 126 * @index: Index in RX flow hash indirection table 127 * @n_rx_rings: Number of RX rings to use 128 * 129 * This function provides the default policy for RX flow hash indirection. 130 */ 131 static inline u32 ethtool_rxfh_indir_default(u32 index, u32 n_rx_rings) 132 { 133 return index % n_rx_rings; 134 } 135 136 /* declare a link mode bitmap */ 137 #define __ETHTOOL_DECLARE_LINK_MODE_MASK(name) \ 138 DECLARE_BITMAP(name, __ETHTOOL_LINK_MODE_MASK_NBITS) 139 140 /* drivers must ignore base.cmd and base.link_mode_masks_nwords 141 * fields, but they are allowed to overwrite them (will be ignored). 142 */ 143 struct ethtool_link_ksettings { 144 struct ethtool_link_settings base; 145 struct { 146 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported); 147 __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising); 148 __ETHTOOL_DECLARE_LINK_MODE_MASK(lp_advertising); 149 } link_modes; 150 u32 lanes; 151 }; 152 153 /** 154 * ethtool_link_ksettings_zero_link_mode - clear link_ksettings link mode mask 155 * @ptr : pointer to struct ethtool_link_ksettings 156 * @name : one of supported/advertising/lp_advertising 157 */ 158 #define ethtool_link_ksettings_zero_link_mode(ptr, name) \ 159 bitmap_zero((ptr)->link_modes.name, __ETHTOOL_LINK_MODE_MASK_NBITS) 160 161 /** 162 * ethtool_link_ksettings_add_link_mode - set bit in link_ksettings 163 * link mode mask 164 * @ptr : pointer to struct ethtool_link_ksettings 165 * @name : one of supported/advertising/lp_advertising 166 * @mode : one of the ETHTOOL_LINK_MODE_*_BIT 167 * (not atomic, no bound checking) 168 */ 169 #define ethtool_link_ksettings_add_link_mode(ptr, name, mode) \ 170 __set_bit(ETHTOOL_LINK_MODE_ ## mode ## _BIT, (ptr)->link_modes.name) 171 172 /** 173 * ethtool_link_ksettings_del_link_mode - clear bit in link_ksettings 174 * link mode mask 175 * @ptr : pointer to struct ethtool_link_ksettings 176 * @name : one of supported/advertising/lp_advertising 177 * @mode : one of the ETHTOOL_LINK_MODE_*_BIT 178 * (not atomic, no bound checking) 179 */ 180 #define ethtool_link_ksettings_del_link_mode(ptr, name, mode) \ 181 __clear_bit(ETHTOOL_LINK_MODE_ ## mode ## _BIT, (ptr)->link_modes.name) 182 183 /** 184 * ethtool_link_ksettings_test_link_mode - test bit in ksettings link mode mask 185 * @ptr : pointer to struct ethtool_link_ksettings 186 * @name : one of supported/advertising/lp_advertising 187 * @mode : one of the ETHTOOL_LINK_MODE_*_BIT 188 * (not atomic, no bound checking) 189 * 190 * Returns true/false. 191 */ 192 #define ethtool_link_ksettings_test_link_mode(ptr, name, mode) \ 193 test_bit(ETHTOOL_LINK_MODE_ ## mode ## _BIT, (ptr)->link_modes.name) 194 195 extern int 196 __ethtool_get_link_ksettings(struct net_device *dev, 197 struct ethtool_link_ksettings *link_ksettings); 198 199 struct kernel_ethtool_coalesce { 200 u8 use_cqe_mode_tx; 201 u8 use_cqe_mode_rx; 202 }; 203 204 /** 205 * ethtool_intersect_link_masks - Given two link masks, AND them together 206 * @dst: first mask and where result is stored 207 * @src: second mask to intersect with 208 * 209 * Given two link mode masks, AND them together and save the result in dst. 210 */ 211 void ethtool_intersect_link_masks(struct ethtool_link_ksettings *dst, 212 struct ethtool_link_ksettings *src); 213 214 void ethtool_convert_legacy_u32_to_link_mode(unsigned long *dst, 215 u32 legacy_u32); 216 217 /* return false if src had higher bits set. lower bits always updated. */ 218 bool ethtool_convert_link_mode_to_legacy_u32(u32 *legacy_u32, 219 const unsigned long *src); 220 221 #define ETHTOOL_COALESCE_RX_USECS BIT(0) 222 #define ETHTOOL_COALESCE_RX_MAX_FRAMES BIT(1) 223 #define ETHTOOL_COALESCE_RX_USECS_IRQ BIT(2) 224 #define ETHTOOL_COALESCE_RX_MAX_FRAMES_IRQ BIT(3) 225 #define ETHTOOL_COALESCE_TX_USECS BIT(4) 226 #define ETHTOOL_COALESCE_TX_MAX_FRAMES BIT(5) 227 #define ETHTOOL_COALESCE_TX_USECS_IRQ BIT(6) 228 #define ETHTOOL_COALESCE_TX_MAX_FRAMES_IRQ BIT(7) 229 #define ETHTOOL_COALESCE_STATS_BLOCK_USECS BIT(8) 230 #define ETHTOOL_COALESCE_USE_ADAPTIVE_RX BIT(9) 231 #define ETHTOOL_COALESCE_USE_ADAPTIVE_TX BIT(10) 232 #define ETHTOOL_COALESCE_PKT_RATE_LOW BIT(11) 233 #define ETHTOOL_COALESCE_RX_USECS_LOW BIT(12) 234 #define ETHTOOL_COALESCE_RX_MAX_FRAMES_LOW BIT(13) 235 #define ETHTOOL_COALESCE_TX_USECS_LOW BIT(14) 236 #define ETHTOOL_COALESCE_TX_MAX_FRAMES_LOW BIT(15) 237 #define ETHTOOL_COALESCE_PKT_RATE_HIGH BIT(16) 238 #define ETHTOOL_COALESCE_RX_USECS_HIGH BIT(17) 239 #define ETHTOOL_COALESCE_RX_MAX_FRAMES_HIGH BIT(18) 240 #define ETHTOOL_COALESCE_TX_USECS_HIGH BIT(19) 241 #define ETHTOOL_COALESCE_TX_MAX_FRAMES_HIGH BIT(20) 242 #define ETHTOOL_COALESCE_RATE_SAMPLE_INTERVAL BIT(21) 243 #define ETHTOOL_COALESCE_USE_CQE_RX BIT(22) 244 #define ETHTOOL_COALESCE_USE_CQE_TX BIT(23) 245 #define ETHTOOL_COALESCE_ALL_PARAMS GENMASK(23, 0) 246 247 #define ETHTOOL_COALESCE_USECS \ 248 (ETHTOOL_COALESCE_RX_USECS | ETHTOOL_COALESCE_TX_USECS) 249 #define ETHTOOL_COALESCE_MAX_FRAMES \ 250 (ETHTOOL_COALESCE_RX_MAX_FRAMES | ETHTOOL_COALESCE_TX_MAX_FRAMES) 251 #define ETHTOOL_COALESCE_USECS_IRQ \ 252 (ETHTOOL_COALESCE_RX_USECS_IRQ | ETHTOOL_COALESCE_TX_USECS_IRQ) 253 #define ETHTOOL_COALESCE_MAX_FRAMES_IRQ \ 254 (ETHTOOL_COALESCE_RX_MAX_FRAMES_IRQ | \ 255 ETHTOOL_COALESCE_TX_MAX_FRAMES_IRQ) 256 #define ETHTOOL_COALESCE_USE_ADAPTIVE \ 257 (ETHTOOL_COALESCE_USE_ADAPTIVE_RX | ETHTOOL_COALESCE_USE_ADAPTIVE_TX) 258 #define ETHTOOL_COALESCE_USECS_LOW_HIGH \ 259 (ETHTOOL_COALESCE_RX_USECS_LOW | ETHTOOL_COALESCE_TX_USECS_LOW | \ 260 ETHTOOL_COALESCE_RX_USECS_HIGH | ETHTOOL_COALESCE_TX_USECS_HIGH) 261 #define ETHTOOL_COALESCE_MAX_FRAMES_LOW_HIGH \ 262 (ETHTOOL_COALESCE_RX_MAX_FRAMES_LOW | \ 263 ETHTOOL_COALESCE_TX_MAX_FRAMES_LOW | \ 264 ETHTOOL_COALESCE_RX_MAX_FRAMES_HIGH | \ 265 ETHTOOL_COALESCE_TX_MAX_FRAMES_HIGH) 266 #define ETHTOOL_COALESCE_PKT_RATE_RX_USECS \ 267 (ETHTOOL_COALESCE_USE_ADAPTIVE_RX | \ 268 ETHTOOL_COALESCE_RX_USECS_LOW | ETHTOOL_COALESCE_RX_USECS_HIGH | \ 269 ETHTOOL_COALESCE_PKT_RATE_LOW | ETHTOOL_COALESCE_PKT_RATE_HIGH | \ 270 ETHTOOL_COALESCE_RATE_SAMPLE_INTERVAL) 271 #define ETHTOOL_COALESCE_USE_CQE \ 272 (ETHTOOL_COALESCE_USE_CQE_RX | ETHTOOL_COALESCE_USE_CQE_TX) 273 274 #define ETHTOOL_STAT_NOT_SET (~0ULL) 275 276 static inline void ethtool_stats_init(u64 *stats, unsigned int n) 277 { 278 while (n--) 279 stats[n] = ETHTOOL_STAT_NOT_SET; 280 } 281 282 /* Basic IEEE 802.3 MAC statistics (30.3.1.1.*), not otherwise exposed 283 * via a more targeted API. 284 */ 285 struct ethtool_eth_mac_stats { 286 u64 FramesTransmittedOK; 287 u64 SingleCollisionFrames; 288 u64 MultipleCollisionFrames; 289 u64 FramesReceivedOK; 290 u64 FrameCheckSequenceErrors; 291 u64 AlignmentErrors; 292 u64 OctetsTransmittedOK; 293 u64 FramesWithDeferredXmissions; 294 u64 LateCollisions; 295 u64 FramesAbortedDueToXSColls; 296 u64 FramesLostDueToIntMACXmitError; 297 u64 CarrierSenseErrors; 298 u64 OctetsReceivedOK; 299 u64 FramesLostDueToIntMACRcvError; 300 u64 MulticastFramesXmittedOK; 301 u64 BroadcastFramesXmittedOK; 302 u64 FramesWithExcessiveDeferral; 303 u64 MulticastFramesReceivedOK; 304 u64 BroadcastFramesReceivedOK; 305 u64 InRangeLengthErrors; 306 u64 OutOfRangeLengthField; 307 u64 FrameTooLongErrors; 308 }; 309 310 /* Basic IEEE 802.3 PHY statistics (30.3.2.1.*), not otherwise exposed 311 * via a more targeted API. 312 */ 313 struct ethtool_eth_phy_stats { 314 u64 SymbolErrorDuringCarrier; 315 }; 316 317 /* Basic IEEE 802.3 MAC Ctrl statistics (30.3.3.*), not otherwise exposed 318 * via a more targeted API. 319 */ 320 struct ethtool_eth_ctrl_stats { 321 u64 MACControlFramesTransmitted; 322 u64 MACControlFramesReceived; 323 u64 UnsupportedOpcodesReceived; 324 }; 325 326 /** 327 * struct ethtool_pause_stats - statistics for IEEE 802.3x pause frames 328 * @tx_pause_frames: transmitted pause frame count. Reported to user space 329 * as %ETHTOOL_A_PAUSE_STAT_TX_FRAMES. 330 * 331 * Equivalent to `30.3.4.2 aPAUSEMACCtrlFramesTransmitted` 332 * from the standard. 333 * 334 * @rx_pause_frames: received pause frame count. Reported to user space 335 * as %ETHTOOL_A_PAUSE_STAT_RX_FRAMES. Equivalent to: 336 * 337 * Equivalent to `30.3.4.3 aPAUSEMACCtrlFramesReceived` 338 * from the standard. 339 */ 340 struct ethtool_pause_stats { 341 u64 tx_pause_frames; 342 u64 rx_pause_frames; 343 }; 344 345 #define ETHTOOL_MAX_LANES 8 346 347 /** 348 * struct ethtool_fec_stats - statistics for IEEE 802.3 FEC 349 * @corrected_blocks: number of received blocks corrected by FEC 350 * Reported to user space as %ETHTOOL_A_FEC_STAT_CORRECTED. 351 * 352 * Equivalent to `30.5.1.1.17 aFECCorrectedBlocks` from the standard. 353 * 354 * @uncorrectable_blocks: number of received blocks FEC was not able to correct 355 * Reported to user space as %ETHTOOL_A_FEC_STAT_UNCORR. 356 * 357 * Equivalent to `30.5.1.1.18 aFECUncorrectableBlocks` from the standard. 358 * 359 * @corrected_bits: number of bits corrected by FEC 360 * Similar to @corrected_blocks but counts individual bit changes, 361 * not entire FEC data blocks. This is a non-standard statistic. 362 * Reported to user space as %ETHTOOL_A_FEC_STAT_CORR_BITS. 363 * 364 * @lane: per-lane/PCS-instance counts as defined by the standard 365 * @total: error counts for the entire port, for drivers incapable of reporting 366 * per-lane stats 367 * 368 * Drivers should fill in either only total or per-lane statistics, core 369 * will take care of adding lane values up to produce the total. 370 */ 371 struct ethtool_fec_stats { 372 struct ethtool_fec_stat { 373 u64 total; 374 u64 lanes[ETHTOOL_MAX_LANES]; 375 } corrected_blocks, uncorrectable_blocks, corrected_bits; 376 }; 377 378 /** 379 * struct ethtool_rmon_hist_range - byte range for histogram statistics 380 * @low: low bound of the bucket (inclusive) 381 * @high: high bound of the bucket (inclusive) 382 */ 383 struct ethtool_rmon_hist_range { 384 u16 low; 385 u16 high; 386 }; 387 388 #define ETHTOOL_RMON_HIST_MAX 10 389 390 /** 391 * struct ethtool_rmon_stats - selected RMON (RFC 2819) statistics 392 * @undersize_pkts: Equivalent to `etherStatsUndersizePkts` from the RFC. 393 * @oversize_pkts: Equivalent to `etherStatsOversizePkts` from the RFC. 394 * @fragments: Equivalent to `etherStatsFragments` from the RFC. 395 * @jabbers: Equivalent to `etherStatsJabbers` from the RFC. 396 * @hist: Packet counter for packet length buckets (e.g. 397 * `etherStatsPkts128to255Octets` from the RFC). 398 * @hist_tx: Tx counters in similar form to @hist, not defined in the RFC. 399 * 400 * Selection of RMON (RFC 2819) statistics which are not exposed via different 401 * APIs, primarily the packet-length-based counters. 402 * Unfortunately different designs choose different buckets beyond 403 * the 1024B mark (jumbo frame teritory), so the definition of the bucket 404 * ranges is left to the driver. 405 */ 406 struct ethtool_rmon_stats { 407 u64 undersize_pkts; 408 u64 oversize_pkts; 409 u64 fragments; 410 u64 jabbers; 411 412 u64 hist[ETHTOOL_RMON_HIST_MAX]; 413 u64 hist_tx[ETHTOOL_RMON_HIST_MAX]; 414 }; 415 416 #define ETH_MODULE_EEPROM_PAGE_LEN 128 417 #define ETH_MODULE_MAX_I2C_ADDRESS 0x7f 418 419 /** 420 * struct ethtool_module_eeprom - EEPROM dump from specified page 421 * @offset: Offset within the specified EEPROM page to begin read, in bytes. 422 * @length: Number of bytes to read. 423 * @page: Page number to read from. 424 * @bank: Page bank number to read from, if applicable by EEPROM spec. 425 * @i2c_address: I2C address of a page. Value less than 0x7f expected. Most 426 * EEPROMs use 0x50 or 0x51. 427 * @data: Pointer to buffer with EEPROM data of @length size. 428 * 429 * This can be used to manage pages during EEPROM dump in ethtool and pass 430 * required information to the driver. 431 */ 432 struct ethtool_module_eeprom { 433 u32 offset; 434 u32 length; 435 u8 page; 436 u8 bank; 437 u8 i2c_address; 438 u8 *data; 439 }; 440 441 /** 442 * struct ethtool_module_power_mode_params - module power mode parameters 443 * @policy: The power mode policy enforced by the host for the plug-in module. 444 * @mode: The operational power mode of the plug-in module. Should be filled by 445 * device drivers on get operations. 446 */ 447 struct ethtool_module_power_mode_params { 448 enum ethtool_module_power_mode_policy policy; 449 enum ethtool_module_power_mode mode; 450 }; 451 452 /** 453 * struct ethtool_ops - optional netdev operations 454 * @cap_link_lanes_supported: indicates if the driver supports lanes 455 * parameter. 456 * @supported_coalesce_params: supported types of interrupt coalescing. 457 * @supported_ring_params: supported ring params. 458 * @get_drvinfo: Report driver/device information. Should only set the 459 * @driver, @version, @fw_version and @bus_info fields. If not 460 * implemented, the @driver and @bus_info fields will be filled in 461 * according to the netdev's parent device. 462 * @get_regs_len: Get buffer length required for @get_regs 463 * @get_regs: Get device registers 464 * @get_wol: Report whether Wake-on-Lan is enabled 465 * @set_wol: Turn Wake-on-Lan on or off. Returns a negative error code 466 * or zero. 467 * @get_msglevel: Report driver message level. This should be the value 468 * of the @msg_enable field used by netif logging functions. 469 * @set_msglevel: Set driver message level 470 * @nway_reset: Restart autonegotiation. Returns a negative error code 471 * or zero. 472 * @get_link: Report whether physical link is up. Will only be called if 473 * the netdev is up. Should usually be set to ethtool_op_get_link(), 474 * which uses netif_carrier_ok(). 475 * @get_link_ext_state: Report link extended state. Should set link_ext_state and 476 * link_ext_substate (link_ext_substate of 0 means link_ext_substate is unknown, 477 * do not attach ext_substate attribute to netlink message). If link_ext_state 478 * and link_ext_substate are unknown, return -ENODATA. If not implemented, 479 * link_ext_state and link_ext_substate will not be sent to userspace. 480 * @get_eeprom_len: Read range of EEPROM addresses for validation of 481 * @get_eeprom and @set_eeprom requests. 482 * Returns 0 if device does not support EEPROM access. 483 * @get_eeprom: Read data from the device EEPROM. 484 * Should fill in the magic field. Don't need to check len for zero 485 * or wraparound. Fill in the data argument with the eeprom values 486 * from offset to offset + len. Update len to the amount read. 487 * Returns an error or zero. 488 * @set_eeprom: Write data to the device EEPROM. 489 * Should validate the magic field. Don't need to check len for zero 490 * or wraparound. Update len to the amount written. Returns an error 491 * or zero. 492 * @get_coalesce: Get interrupt coalescing parameters. Returns a negative 493 * error code or zero. 494 * @set_coalesce: Set interrupt coalescing parameters. Supported coalescing 495 * types should be set in @supported_coalesce_params. 496 * Returns a negative error code or zero. 497 * @get_ringparam: Report ring sizes 498 * @set_ringparam: Set ring sizes. Returns a negative error code or zero. 499 * @get_pause_stats: Report pause frame statistics. Drivers must not zero 500 * statistics which they don't report. The stats structure is initialized 501 * to ETHTOOL_STAT_NOT_SET indicating driver does not report statistics. 502 * @get_pauseparam: Report pause parameters 503 * @set_pauseparam: Set pause parameters. Returns a negative error code 504 * or zero. 505 * @self_test: Run specified self-tests 506 * @get_strings: Return a set of strings that describe the requested objects 507 * @set_phys_id: Identify the physical devices, e.g. by flashing an LED 508 * attached to it. The implementation may update the indicator 509 * asynchronously or synchronously, but in either case it must return 510 * quickly. It is initially called with the argument %ETHTOOL_ID_ACTIVE, 511 * and must either activate asynchronous updates and return zero, return 512 * a negative error or return a positive frequency for synchronous 513 * indication (e.g. 1 for one on/off cycle per second). If it returns 514 * a frequency then it will be called again at intervals with the 515 * argument %ETHTOOL_ID_ON or %ETHTOOL_ID_OFF and should set the state of 516 * the indicator accordingly. Finally, it is called with the argument 517 * %ETHTOOL_ID_INACTIVE and must deactivate the indicator. Returns a 518 * negative error code or zero. 519 * @get_ethtool_stats: Return extended statistics about the device. 520 * This is only useful if the device maintains statistics not 521 * included in &struct rtnl_link_stats64. 522 * @begin: Function to be called before any other operation. Returns a 523 * negative error code or zero. 524 * @complete: Function to be called after any other operation except 525 * @begin. Will be called even if the other operation failed. 526 * @get_priv_flags: Report driver-specific feature flags. 527 * @set_priv_flags: Set driver-specific feature flags. Returns a negative 528 * error code or zero. 529 * @get_sset_count: Get number of strings that @get_strings will write. 530 * @get_rxnfc: Get RX flow classification rules. Returns a negative 531 * error code or zero. 532 * @set_rxnfc: Set RX flow classification rules. Returns a negative 533 * error code or zero. 534 * @flash_device: Write a firmware image to device's flash memory. 535 * Returns a negative error code or zero. 536 * @reset: Reset (part of) the device, as specified by a bitmask of 537 * flags from &enum ethtool_reset_flags. Returns a negative 538 * error code or zero. 539 * @get_rxfh_key_size: Get the size of the RX flow hash key. 540 * Returns zero if not supported for this specific device. 541 * @get_rxfh_indir_size: Get the size of the RX flow hash indirection table. 542 * Returns zero if not supported for this specific device. 543 * @get_rxfh: Get the contents of the RX flow hash indirection table, hash key 544 * and/or hash function. 545 * Returns a negative error code or zero. 546 * @set_rxfh: Set the contents of the RX flow hash indirection table, hash 547 * key, and/or hash function. Arguments which are set to %NULL or zero 548 * will remain unchanged. 549 * Returns a negative error code or zero. An error code must be returned 550 * if at least one unsupported change was requested. 551 * @get_rxfh_context: Get the contents of the RX flow hash indirection table, 552 * hash key, and/or hash function assiciated to the given rss context. 553 * Returns a negative error code or zero. 554 * @set_rxfh_context: Create, remove and configure RSS contexts. Allows setting 555 * the contents of the RX flow hash indirection table, hash key, and/or 556 * hash function associated to the given context. Arguments which are set 557 * to %NULL or zero will remain unchanged. 558 * Returns a negative error code or zero. An error code must be returned 559 * if at least one unsupported change was requested. 560 * @get_channels: Get number of channels. 561 * @set_channels: Set number of channels. Returns a negative error code or 562 * zero. 563 * @get_dump_flag: Get dump flag indicating current dump length, version, 564 * and flag of the device. 565 * @get_dump_data: Get dump data. 566 * @set_dump: Set dump specific flags to the device. 567 * @get_ts_info: Get the time stamping and PTP hardware clock capabilities. 568 * Drivers supporting transmit time stamps in software should set this to 569 * ethtool_op_get_ts_info(). 570 * @get_module_info: Get the size and type of the eeprom contained within 571 * a plug-in module. 572 * @get_module_eeprom: Get the eeprom information from the plug-in module 573 * @get_eee: Get Energy-Efficient (EEE) supported and status. 574 * @set_eee: Set EEE status (enable/disable) as well as LPI timers. 575 * @get_tunable: Read the value of a driver / device tunable. 576 * @set_tunable: Set the value of a driver / device tunable. 577 * @get_per_queue_coalesce: Get interrupt coalescing parameters per queue. 578 * It must check that the given queue number is valid. If neither a RX nor 579 * a TX queue has this number, return -EINVAL. If only a RX queue or a TX 580 * queue has this number, set the inapplicable fields to ~0 and return 0. 581 * Returns a negative error code or zero. 582 * @set_per_queue_coalesce: Set interrupt coalescing parameters per queue. 583 * It must check that the given queue number is valid. If neither a RX nor 584 * a TX queue has this number, return -EINVAL. If only a RX queue or a TX 585 * queue has this number, ignore the inapplicable fields. Supported 586 * coalescing types should be set in @supported_coalesce_params. 587 * Returns a negative error code or zero. 588 * @get_link_ksettings: Get various device settings including Ethernet link 589 * settings. The %cmd and %link_mode_masks_nwords fields should be 590 * ignored (use %__ETHTOOL_LINK_MODE_MASK_NBITS instead of the latter), 591 * any change to them will be overwritten by kernel. Returns a negative 592 * error code or zero. 593 * @set_link_ksettings: Set various device settings including Ethernet link 594 * settings. The %cmd and %link_mode_masks_nwords fields should be 595 * ignored (use %__ETHTOOL_LINK_MODE_MASK_NBITS instead of the latter), 596 * any change to them will be overwritten by kernel. Returns a negative 597 * error code or zero. 598 * @get_fec_stats: Report FEC statistics. 599 * Core will sum up per-lane stats to get the total. 600 * Drivers must not zero statistics which they don't report. The stats 601 * structure is initialized to ETHTOOL_STAT_NOT_SET indicating driver does 602 * not report statistics. 603 * @get_fecparam: Get the network device Forward Error Correction parameters. 604 * @set_fecparam: Set the network device Forward Error Correction parameters. 605 * @get_ethtool_phy_stats: Return extended statistics about the PHY device. 606 * This is only useful if the device maintains PHY statistics and 607 * cannot use the standard PHY library helpers. 608 * @get_phy_tunable: Read the value of a PHY tunable. 609 * @set_phy_tunable: Set the value of a PHY tunable. 610 * @get_module_eeprom_by_page: Get a region of plug-in module EEPROM data from 611 * specified page. Returns a negative error code or the amount of bytes 612 * read. 613 * @get_eth_phy_stats: Query some of the IEEE 802.3 PHY statistics. 614 * @get_eth_mac_stats: Query some of the IEEE 802.3 MAC statistics. 615 * @get_eth_ctrl_stats: Query some of the IEEE 802.3 MAC Ctrl statistics. 616 * @get_rmon_stats: Query some of the RMON (RFC 2819) statistics. 617 * Set %ranges to a pointer to zero-terminated array of byte ranges. 618 * @get_module_power_mode: Get the power mode policy for the plug-in module 619 * used by the network device and its operational power mode, if 620 * plugged-in. 621 * @set_module_power_mode: Set the power mode policy for the plug-in module 622 * used by the network device. 623 * 624 * All operations are optional (i.e. the function pointer may be set 625 * to %NULL) and callers must take this into account. Callers must 626 * hold the RTNL lock. 627 * 628 * See the structures used by these operations for further documentation. 629 * Note that for all operations using a structure ending with a zero- 630 * length array, the array is allocated separately in the kernel and 631 * is passed to the driver as an additional parameter. 632 * 633 * See &struct net_device and &struct net_device_ops for documentation 634 * of the generic netdev features interface. 635 */ 636 struct ethtool_ops { 637 u32 cap_link_lanes_supported:1; 638 u32 supported_coalesce_params; 639 u32 supported_ring_params; 640 void (*get_drvinfo)(struct net_device *, struct ethtool_drvinfo *); 641 int (*get_regs_len)(struct net_device *); 642 void (*get_regs)(struct net_device *, struct ethtool_regs *, void *); 643 void (*get_wol)(struct net_device *, struct ethtool_wolinfo *); 644 int (*set_wol)(struct net_device *, struct ethtool_wolinfo *); 645 u32 (*get_msglevel)(struct net_device *); 646 void (*set_msglevel)(struct net_device *, u32); 647 int (*nway_reset)(struct net_device *); 648 u32 (*get_link)(struct net_device *); 649 int (*get_link_ext_state)(struct net_device *, 650 struct ethtool_link_ext_state_info *); 651 int (*get_eeprom_len)(struct net_device *); 652 int (*get_eeprom)(struct net_device *, 653 struct ethtool_eeprom *, u8 *); 654 int (*set_eeprom)(struct net_device *, 655 struct ethtool_eeprom *, u8 *); 656 int (*get_coalesce)(struct net_device *, 657 struct ethtool_coalesce *, 658 struct kernel_ethtool_coalesce *, 659 struct netlink_ext_ack *); 660 int (*set_coalesce)(struct net_device *, 661 struct ethtool_coalesce *, 662 struct kernel_ethtool_coalesce *, 663 struct netlink_ext_ack *); 664 void (*get_ringparam)(struct net_device *, 665 struct ethtool_ringparam *, 666 struct kernel_ethtool_ringparam *, 667 struct netlink_ext_ack *); 668 int (*set_ringparam)(struct net_device *, 669 struct ethtool_ringparam *, 670 struct kernel_ethtool_ringparam *, 671 struct netlink_ext_ack *); 672 void (*get_pause_stats)(struct net_device *dev, 673 struct ethtool_pause_stats *pause_stats); 674 void (*get_pauseparam)(struct net_device *, 675 struct ethtool_pauseparam*); 676 int (*set_pauseparam)(struct net_device *, 677 struct ethtool_pauseparam*); 678 void (*self_test)(struct net_device *, struct ethtool_test *, u64 *); 679 void (*get_strings)(struct net_device *, u32 stringset, u8 *); 680 int (*set_phys_id)(struct net_device *, enum ethtool_phys_id_state); 681 void (*get_ethtool_stats)(struct net_device *, 682 struct ethtool_stats *, u64 *); 683 int (*begin)(struct net_device *); 684 void (*complete)(struct net_device *); 685 u32 (*get_priv_flags)(struct net_device *); 686 int (*set_priv_flags)(struct net_device *, u32); 687 int (*get_sset_count)(struct net_device *, int); 688 int (*get_rxnfc)(struct net_device *, 689 struct ethtool_rxnfc *, u32 *rule_locs); 690 int (*set_rxnfc)(struct net_device *, struct ethtool_rxnfc *); 691 int (*flash_device)(struct net_device *, struct ethtool_flash *); 692 int (*reset)(struct net_device *, u32 *); 693 u32 (*get_rxfh_key_size)(struct net_device *); 694 u32 (*get_rxfh_indir_size)(struct net_device *); 695 int (*get_rxfh)(struct net_device *, u32 *indir, u8 *key, 696 u8 *hfunc); 697 int (*set_rxfh)(struct net_device *, const u32 *indir, 698 const u8 *key, const u8 hfunc); 699 int (*get_rxfh_context)(struct net_device *, u32 *indir, u8 *key, 700 u8 *hfunc, u32 rss_context); 701 int (*set_rxfh_context)(struct net_device *, const u32 *indir, 702 const u8 *key, const u8 hfunc, 703 u32 *rss_context, bool delete); 704 void (*get_channels)(struct net_device *, struct ethtool_channels *); 705 int (*set_channels)(struct net_device *, struct ethtool_channels *); 706 int (*get_dump_flag)(struct net_device *, struct ethtool_dump *); 707 int (*get_dump_data)(struct net_device *, 708 struct ethtool_dump *, void *); 709 int (*set_dump)(struct net_device *, struct ethtool_dump *); 710 int (*get_ts_info)(struct net_device *, struct ethtool_ts_info *); 711 int (*get_module_info)(struct net_device *, 712 struct ethtool_modinfo *); 713 int (*get_module_eeprom)(struct net_device *, 714 struct ethtool_eeprom *, u8 *); 715 int (*get_eee)(struct net_device *, struct ethtool_eee *); 716 int (*set_eee)(struct net_device *, struct ethtool_eee *); 717 int (*get_tunable)(struct net_device *, 718 const struct ethtool_tunable *, void *); 719 int (*set_tunable)(struct net_device *, 720 const struct ethtool_tunable *, const void *); 721 int (*get_per_queue_coalesce)(struct net_device *, u32, 722 struct ethtool_coalesce *); 723 int (*set_per_queue_coalesce)(struct net_device *, u32, 724 struct ethtool_coalesce *); 725 int (*get_link_ksettings)(struct net_device *, 726 struct ethtool_link_ksettings *); 727 int (*set_link_ksettings)(struct net_device *, 728 const struct ethtool_link_ksettings *); 729 void (*get_fec_stats)(struct net_device *dev, 730 struct ethtool_fec_stats *fec_stats); 731 int (*get_fecparam)(struct net_device *, 732 struct ethtool_fecparam *); 733 int (*set_fecparam)(struct net_device *, 734 struct ethtool_fecparam *); 735 void (*get_ethtool_phy_stats)(struct net_device *, 736 struct ethtool_stats *, u64 *); 737 int (*get_phy_tunable)(struct net_device *, 738 const struct ethtool_tunable *, void *); 739 int (*set_phy_tunable)(struct net_device *, 740 const struct ethtool_tunable *, const void *); 741 int (*get_module_eeprom_by_page)(struct net_device *dev, 742 const struct ethtool_module_eeprom *page, 743 struct netlink_ext_ack *extack); 744 void (*get_eth_phy_stats)(struct net_device *dev, 745 struct ethtool_eth_phy_stats *phy_stats); 746 void (*get_eth_mac_stats)(struct net_device *dev, 747 struct ethtool_eth_mac_stats *mac_stats); 748 void (*get_eth_ctrl_stats)(struct net_device *dev, 749 struct ethtool_eth_ctrl_stats *ctrl_stats); 750 void (*get_rmon_stats)(struct net_device *dev, 751 struct ethtool_rmon_stats *rmon_stats, 752 const struct ethtool_rmon_hist_range **ranges); 753 int (*get_module_power_mode)(struct net_device *dev, 754 struct ethtool_module_power_mode_params *params, 755 struct netlink_ext_ack *extack); 756 int (*set_module_power_mode)(struct net_device *dev, 757 const struct ethtool_module_power_mode_params *params, 758 struct netlink_ext_ack *extack); 759 }; 760 761 int ethtool_check_ops(const struct ethtool_ops *ops); 762 763 struct ethtool_rx_flow_rule { 764 struct flow_rule *rule; 765 unsigned long priv[]; 766 }; 767 768 struct ethtool_rx_flow_spec_input { 769 const struct ethtool_rx_flow_spec *fs; 770 u32 rss_ctx; 771 }; 772 773 struct ethtool_rx_flow_rule * 774 ethtool_rx_flow_rule_create(const struct ethtool_rx_flow_spec_input *input); 775 void ethtool_rx_flow_rule_destroy(struct ethtool_rx_flow_rule *rule); 776 777 bool ethtool_virtdev_validate_cmd(const struct ethtool_link_ksettings *cmd); 778 int ethtool_virtdev_set_link_ksettings(struct net_device *dev, 779 const struct ethtool_link_ksettings *cmd, 780 u32 *dev_speed, u8 *dev_duplex); 781 782 struct phy_device; 783 struct phy_tdr_config; 784 785 /** 786 * struct ethtool_phy_ops - Optional PHY device options 787 * @get_sset_count: Get number of strings that @get_strings will write. 788 * @get_strings: Return a set of strings that describe the requested objects 789 * @get_stats: Return extended statistics about the PHY device. 790 * @start_cable_test: Start a cable test 791 * @start_cable_test_tdr: Start a Time Domain Reflectometry cable test 792 * 793 * All operations are optional (i.e. the function pointer may be set to %NULL) 794 * and callers must take this into account. Callers must hold the RTNL lock. 795 */ 796 struct ethtool_phy_ops { 797 int (*get_sset_count)(struct phy_device *dev); 798 int (*get_strings)(struct phy_device *dev, u8 *data); 799 int (*get_stats)(struct phy_device *dev, 800 struct ethtool_stats *stats, u64 *data); 801 int (*start_cable_test)(struct phy_device *phydev, 802 struct netlink_ext_ack *extack); 803 int (*start_cable_test_tdr)(struct phy_device *phydev, 804 struct netlink_ext_ack *extack, 805 const struct phy_tdr_config *config); 806 }; 807 808 /** 809 * ethtool_set_ethtool_phy_ops - Set the ethtool_phy_ops singleton 810 * @ops: Ethtool PHY operations to set 811 */ 812 void ethtool_set_ethtool_phy_ops(const struct ethtool_phy_ops *ops); 813 814 /** 815 * ethtool_params_from_link_mode - Derive link parameters from a given link mode 816 * @link_ksettings: Link parameters to be derived from the link mode 817 * @link_mode: Link mode 818 */ 819 void 820 ethtool_params_from_link_mode(struct ethtool_link_ksettings *link_ksettings, 821 enum ethtool_link_mode_bit_indices link_mode); 822 823 /** 824 * ethtool_get_phc_vclocks - Derive phc vclocks information, and caller 825 * is responsible to free memory of vclock_index 826 * @dev: pointer to net_device structure 827 * @vclock_index: pointer to pointer of vclock index 828 * 829 * Return number of phc vclocks 830 */ 831 int ethtool_get_phc_vclocks(struct net_device *dev, int **vclock_index); 832 833 /** 834 * ethtool_sprintf - Write formatted string to ethtool string data 835 * @data: Pointer to start of string to update 836 * @fmt: Format of string to write 837 * 838 * Write formatted string to data. Update data to point at start of 839 * next string. 840 */ 841 extern __printf(2, 3) void ethtool_sprintf(u8 **data, const char *fmt, ...); 842 #endif /* _LINUX_ETHTOOL_H */ 843