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