1 /* 2 * ethtool.h: Defines for Linux ethtool. 3 * 4 * Copyright (C) 1998 David S. Miller ([email protected]) 5 * Copyright 2001 Jeff Garzik <[email protected]> 6 * Portions Copyright 2001 Sun Microsystems ([email protected]) 7 * Portions Copyright 2002 Intel ([email protected], 8 * [email protected], 9 * [email protected]) 10 * Portions Copyright (C) Sun Microsystems 2008 11 */ 12 13 #ifndef _LINUX_ETHTOOL_H 14 #define _LINUX_ETHTOOL_H 15 16 #include <linux/types.h> 17 18 /* This should work for both 32 and 64 bit userland. */ 19 struct ethtool_cmd { 20 __u32 cmd; 21 __u32 supported; /* Features this interface supports */ 22 __u32 advertising; /* Features this interface advertises */ 23 __u16 speed; /* The forced speed, 10Mb, 100Mb, gigabit */ 24 __u8 duplex; /* Duplex, half or full */ 25 __u8 port; /* Which connector port */ 26 __u8 phy_address; 27 __u8 transceiver; /* Which transceiver to use */ 28 __u8 autoneg; /* Enable or disable autonegotiation */ 29 __u8 mdio_support; 30 __u32 maxtxpkt; /* Tx pkts before generating tx int */ 31 __u32 maxrxpkt; /* Rx pkts before generating rx int */ 32 __u16 speed_hi; 33 __u8 eth_tp_mdix; 34 __u8 reserved2; 35 __u32 lp_advertising; /* Features the link partner advertises */ 36 __u32 reserved[2]; 37 }; 38 39 static inline void ethtool_cmd_speed_set(struct ethtool_cmd *ep, 40 __u32 speed) 41 { 42 43 ep->speed = (__u16)speed; 44 ep->speed_hi = (__u16)(speed >> 16); 45 } 46 47 static inline __u32 ethtool_cmd_speed(struct ethtool_cmd *ep) 48 { 49 return (ep->speed_hi << 16) | ep->speed; 50 } 51 52 #define ETHTOOL_FWVERS_LEN 32 53 #define ETHTOOL_BUSINFO_LEN 32 54 /* these strings are set to whatever the driver author decides... */ 55 struct ethtool_drvinfo { 56 __u32 cmd; 57 char driver[32]; /* driver short name, "tulip", "eepro100" */ 58 char version[32]; /* driver version string */ 59 char fw_version[ETHTOOL_FWVERS_LEN]; /* firmware version string */ 60 char bus_info[ETHTOOL_BUSINFO_LEN]; /* Bus info for this IF. */ 61 /* For PCI devices, use pci_name(pci_dev). */ 62 char reserved1[32]; 63 char reserved2[12]; 64 __u32 n_priv_flags; /* number of flags valid in ETHTOOL_GPFLAGS */ 65 __u32 n_stats; /* number of u64's from ETHTOOL_GSTATS */ 66 __u32 testinfo_len; 67 __u32 eedump_len; /* Size of data from ETHTOOL_GEEPROM (bytes) */ 68 __u32 regdump_len; /* Size of data from ETHTOOL_GREGS (bytes) */ 69 }; 70 71 #define SOPASS_MAX 6 72 /* wake-on-lan settings */ 73 struct ethtool_wolinfo { 74 __u32 cmd; 75 __u32 supported; 76 __u32 wolopts; 77 __u8 sopass[SOPASS_MAX]; /* SecureOn(tm) password */ 78 }; 79 80 /* for passing single values */ 81 struct ethtool_value { 82 __u32 cmd; 83 __u32 data; 84 }; 85 86 /* for passing big chunks of data */ 87 struct ethtool_regs { 88 __u32 cmd; 89 __u32 version; /* driver-specific, indicates different chips/revs */ 90 __u32 len; /* bytes */ 91 __u8 data[0]; 92 }; 93 94 /* for passing EEPROM chunks */ 95 struct ethtool_eeprom { 96 __u32 cmd; 97 __u32 magic; 98 __u32 offset; /* in bytes */ 99 __u32 len; /* in bytes */ 100 __u8 data[0]; 101 }; 102 103 /* for configuring coalescing parameters of chip */ 104 struct ethtool_coalesce { 105 __u32 cmd; /* ETHTOOL_{G,S}COALESCE */ 106 107 /* How many usecs to delay an RX interrupt after 108 * a packet arrives. If 0, only rx_max_coalesced_frames 109 * is used. 110 */ 111 __u32 rx_coalesce_usecs; 112 113 /* How many packets to delay an RX interrupt after 114 * a packet arrives. If 0, only rx_coalesce_usecs is 115 * used. It is illegal to set both usecs and max frames 116 * to zero as this would cause RX interrupts to never be 117 * generated. 118 */ 119 __u32 rx_max_coalesced_frames; 120 121 /* Same as above two parameters, except that these values 122 * apply while an IRQ is being serviced by the host. Not 123 * all cards support this feature and the values are ignored 124 * in that case. 125 */ 126 __u32 rx_coalesce_usecs_irq; 127 __u32 rx_max_coalesced_frames_irq; 128 129 /* How many usecs to delay a TX interrupt after 130 * a packet is sent. If 0, only tx_max_coalesced_frames 131 * is used. 132 */ 133 __u32 tx_coalesce_usecs; 134 135 /* How many packets to delay a TX interrupt after 136 * a packet is sent. If 0, only tx_coalesce_usecs is 137 * used. It is illegal to set both usecs and max frames 138 * to zero as this would cause TX interrupts to never be 139 * generated. 140 */ 141 __u32 tx_max_coalesced_frames; 142 143 /* Same as above two parameters, except that these values 144 * apply while an IRQ is being serviced by the host. Not 145 * all cards support this feature and the values are ignored 146 * in that case. 147 */ 148 __u32 tx_coalesce_usecs_irq; 149 __u32 tx_max_coalesced_frames_irq; 150 151 /* How many usecs to delay in-memory statistics 152 * block updates. Some drivers do not have an in-memory 153 * statistic block, and in such cases this value is ignored. 154 * This value must not be zero. 155 */ 156 __u32 stats_block_coalesce_usecs; 157 158 /* Adaptive RX/TX coalescing is an algorithm implemented by 159 * some drivers to improve latency under low packet rates and 160 * improve throughput under high packet rates. Some drivers 161 * only implement one of RX or TX adaptive coalescing. Anything 162 * not implemented by the driver causes these values to be 163 * silently ignored. 164 */ 165 __u32 use_adaptive_rx_coalesce; 166 __u32 use_adaptive_tx_coalesce; 167 168 /* When the packet rate (measured in packets per second) 169 * is below pkt_rate_low, the {rx,tx}_*_low parameters are 170 * used. 171 */ 172 __u32 pkt_rate_low; 173 __u32 rx_coalesce_usecs_low; 174 __u32 rx_max_coalesced_frames_low; 175 __u32 tx_coalesce_usecs_low; 176 __u32 tx_max_coalesced_frames_low; 177 178 /* When the packet rate is below pkt_rate_high but above 179 * pkt_rate_low (both measured in packets per second) the 180 * normal {rx,tx}_* coalescing parameters are used. 181 */ 182 183 /* When the packet rate is (measured in packets per second) 184 * is above pkt_rate_high, the {rx,tx}_*_high parameters are 185 * used. 186 */ 187 __u32 pkt_rate_high; 188 __u32 rx_coalesce_usecs_high; 189 __u32 rx_max_coalesced_frames_high; 190 __u32 tx_coalesce_usecs_high; 191 __u32 tx_max_coalesced_frames_high; 192 193 /* How often to do adaptive coalescing packet rate sampling, 194 * measured in seconds. Must not be zero. 195 */ 196 __u32 rate_sample_interval; 197 }; 198 199 /* for configuring RX/TX ring parameters */ 200 struct ethtool_ringparam { 201 __u32 cmd; /* ETHTOOL_{G,S}RINGPARAM */ 202 203 /* Read only attributes. These indicate the maximum number 204 * of pending RX/TX ring entries the driver will allow the 205 * user to set. 206 */ 207 __u32 rx_max_pending; 208 __u32 rx_mini_max_pending; 209 __u32 rx_jumbo_max_pending; 210 __u32 tx_max_pending; 211 212 /* Values changeable by the user. The valid values are 213 * in the range 1 to the "*_max_pending" counterpart above. 214 */ 215 __u32 rx_pending; 216 __u32 rx_mini_pending; 217 __u32 rx_jumbo_pending; 218 __u32 tx_pending; 219 }; 220 221 /* for configuring link flow control parameters */ 222 struct ethtool_pauseparam { 223 __u32 cmd; /* ETHTOOL_{G,S}PAUSEPARAM */ 224 225 /* If the link is being auto-negotiated (via ethtool_cmd.autoneg 226 * being true) the user may set 'autonet' here non-zero to have the 227 * pause parameters be auto-negotiated too. In such a case, the 228 * {rx,tx}_pause values below determine what capabilities are 229 * advertised. 230 * 231 * If 'autoneg' is zero or the link is not being auto-negotiated, 232 * then {rx,tx}_pause force the driver to use/not-use pause 233 * flow control. 234 */ 235 __u32 autoneg; 236 __u32 rx_pause; 237 __u32 tx_pause; 238 }; 239 240 #define ETH_GSTRING_LEN 32 241 enum ethtool_stringset { 242 ETH_SS_TEST = 0, 243 ETH_SS_STATS, 244 ETH_SS_PRIV_FLAGS, 245 }; 246 247 /* for passing string sets for data tagging */ 248 struct ethtool_gstrings { 249 __u32 cmd; /* ETHTOOL_GSTRINGS */ 250 __u32 string_set; /* string set id e.c. ETH_SS_TEST, etc*/ 251 __u32 len; /* number of strings in the string set */ 252 __u8 data[0]; 253 }; 254 255 enum ethtool_test_flags { 256 ETH_TEST_FL_OFFLINE = (1 << 0), /* online / offline */ 257 ETH_TEST_FL_FAILED = (1 << 1), /* test passed / failed */ 258 }; 259 260 /* for requesting NIC test and getting results*/ 261 struct ethtool_test { 262 __u32 cmd; /* ETHTOOL_TEST */ 263 __u32 flags; /* ETH_TEST_FL_xxx */ 264 __u32 reserved; 265 __u32 len; /* result length, in number of u64 elements */ 266 __u64 data[0]; 267 }; 268 269 /* for dumping NIC-specific statistics */ 270 struct ethtool_stats { 271 __u32 cmd; /* ETHTOOL_GSTATS */ 272 __u32 n_stats; /* number of u64's being returned */ 273 __u64 data[0]; 274 }; 275 276 struct ethtool_perm_addr { 277 __u32 cmd; /* ETHTOOL_GPERMADDR */ 278 __u32 size; 279 __u8 data[0]; 280 }; 281 282 /* boolean flags controlling per-interface behavior characteristics. 283 * When reading, the flag indicates whether or not a certain behavior 284 * is enabled/present. When writing, the flag indicates whether 285 * or not the driver should turn on (set) or off (clear) a behavior. 286 * 287 * Some behaviors may read-only (unconditionally absent or present). 288 * If such is the case, return EINVAL in the set-flags operation if the 289 * flag differs from the read-only value. 290 */ 291 enum ethtool_flags { 292 ETH_FLAG_LRO = (1 << 15), /* LRO is enabled */ 293 }; 294 295 /* The following structures are for supporting RX network flow 296 * classification configuration. Note, all multibyte fields, e.g., 297 * ip4src, ip4dst, psrc, pdst, spi, etc. are expected to be in network 298 * byte order. 299 */ 300 struct ethtool_tcpip4_spec { 301 __be32 ip4src; 302 __be32 ip4dst; 303 __be16 psrc; 304 __be16 pdst; 305 __u8 tos; 306 }; 307 308 struct ethtool_ah_espip4_spec { 309 __be32 ip4src; 310 __be32 ip4dst; 311 __be32 spi; 312 __u8 tos; 313 }; 314 315 struct ethtool_rawip4_spec { 316 __be32 ip4src; 317 __be32 ip4dst; 318 __u8 hdata[64]; 319 }; 320 321 struct ethtool_ether_spec { 322 __be16 ether_type; 323 __u8 frame_size; 324 __u8 eframe[16]; 325 }; 326 327 #define ETH_RX_NFC_IP4 1 328 #define ETH_RX_NFC_IP6 2 329 330 struct ethtool_usrip4_spec { 331 __be32 ip4src; 332 __be32 ip4dst; 333 __be32 l4_4_bytes; 334 __u8 tos; 335 __u8 ip_ver; 336 __u8 proto; 337 }; 338 339 struct ethtool_rx_flow_spec { 340 __u32 flow_type; 341 union { 342 struct ethtool_tcpip4_spec tcp_ip4_spec; 343 struct ethtool_tcpip4_spec udp_ip4_spec; 344 struct ethtool_tcpip4_spec sctp_ip4_spec; 345 struct ethtool_ah_espip4_spec ah_ip4_spec; 346 struct ethtool_ah_espip4_spec esp_ip4_spec; 347 struct ethtool_rawip4_spec raw_ip4_spec; 348 struct ethtool_ether_spec ether_spec; 349 struct ethtool_usrip4_spec usr_ip4_spec; 350 __u8 hdata[64]; 351 } h_u, m_u; /* entry, mask */ 352 __u64 ring_cookie; 353 __u32 location; 354 }; 355 356 struct ethtool_rxnfc { 357 __u32 cmd; 358 __u32 flow_type; 359 /* The rx flow hash value or the rule DB size */ 360 __u64 data; 361 struct ethtool_rx_flow_spec fs; 362 __u32 rule_cnt; 363 __u32 rule_locs[0]; 364 }; 365 366 #define ETHTOOL_FLASH_MAX_FILENAME 128 367 enum ethtool_flash_op_type { 368 ETHTOOL_FLASH_ALL_REGIONS = 0, 369 }; 370 371 /* for passing firmware flashing related parameters */ 372 struct ethtool_flash { 373 __u32 cmd; 374 __u32 region; 375 char data[ETHTOOL_FLASH_MAX_FILENAME]; 376 }; 377 378 #ifdef __KERNEL__ 379 380 struct net_device; 381 382 /* Some generic methods drivers may use in their ethtool_ops */ 383 u32 ethtool_op_get_link(struct net_device *dev); 384 u32 ethtool_op_get_rx_csum(struct net_device *dev); 385 u32 ethtool_op_get_tx_csum(struct net_device *dev); 386 int ethtool_op_set_tx_csum(struct net_device *dev, u32 data); 387 int ethtool_op_set_tx_hw_csum(struct net_device *dev, u32 data); 388 int ethtool_op_set_tx_ipv6_csum(struct net_device *dev, u32 data); 389 u32 ethtool_op_get_sg(struct net_device *dev); 390 int ethtool_op_set_sg(struct net_device *dev, u32 data); 391 u32 ethtool_op_get_tso(struct net_device *dev); 392 int ethtool_op_set_tso(struct net_device *dev, u32 data); 393 u32 ethtool_op_get_ufo(struct net_device *dev); 394 int ethtool_op_set_ufo(struct net_device *dev, u32 data); 395 u32 ethtool_op_get_flags(struct net_device *dev); 396 int ethtool_op_set_flags(struct net_device *dev, u32 data); 397 398 /** 399 * ðtool_ops - Alter and report network device settings 400 * get_settings: Get device-specific settings 401 * set_settings: Set device-specific settings 402 * get_drvinfo: Report driver information 403 * get_regs: Get device registers 404 * get_wol: Report whether Wake-on-Lan is enabled 405 * set_wol: Turn Wake-on-Lan on or off 406 * get_msglevel: Report driver message level 407 * set_msglevel: Set driver message level 408 * nway_reset: Restart autonegotiation 409 * get_link: Get link status 410 * get_eeprom: Read data from the device EEPROM 411 * set_eeprom: Write data to the device EEPROM 412 * get_coalesce: Get interrupt coalescing parameters 413 * set_coalesce: Set interrupt coalescing parameters 414 * get_ringparam: Report ring sizes 415 * set_ringparam: Set ring sizes 416 * get_pauseparam: Report pause parameters 417 * set_pauseparam: Set pause parameters 418 * get_rx_csum: Report whether receive checksums are turned on or off 419 * set_rx_csum: Turn receive checksum on or off 420 * get_tx_csum: Report whether transmit checksums are turned on or off 421 * set_tx_csum: Turn transmit checksums on or off 422 * get_sg: Report whether scatter-gather is enabled 423 * set_sg: Turn scatter-gather on or off 424 * get_tso: Report whether TCP segmentation offload is enabled 425 * set_tso: Turn TCP segmentation offload on or off 426 * get_ufo: Report whether UDP fragmentation offload is enabled 427 * set_ufo: Turn UDP fragmentation offload on or off 428 * self_test: Run specified self-tests 429 * get_strings: Return a set of strings that describe the requested objects 430 * phys_id: Identify the device 431 * get_stats: Return statistics about the device 432 * get_flags: get 32-bit flags bitmap 433 * set_flags: set 32-bit flags bitmap 434 * 435 * Description: 436 * 437 * get_settings: 438 * @get_settings is passed an ðtool_cmd to fill in. It returns 439 * an negative errno or zero. 440 * 441 * set_settings: 442 * @set_settings is passed an ðtool_cmd and should attempt to set 443 * all the settings this device supports. It may return an error value 444 * if something goes wrong (otherwise 0). 445 * 446 * get_eeprom: 447 * Should fill in the magic field. Don't need to check len for zero 448 * or wraparound. Fill in the data argument with the eeprom values 449 * from offset to offset + len. Update len to the amount read. 450 * Returns an error or zero. 451 * 452 * set_eeprom: 453 * Should validate the magic field. Don't need to check len for zero 454 * or wraparound. Update len to the amount written. Returns an error 455 * or zero. 456 */ 457 struct ethtool_ops { 458 int (*get_settings)(struct net_device *, struct ethtool_cmd *); 459 int (*set_settings)(struct net_device *, struct ethtool_cmd *); 460 void (*get_drvinfo)(struct net_device *, struct ethtool_drvinfo *); 461 int (*get_regs_len)(struct net_device *); 462 void (*get_regs)(struct net_device *, struct ethtool_regs *, void *); 463 void (*get_wol)(struct net_device *, struct ethtool_wolinfo *); 464 int (*set_wol)(struct net_device *, struct ethtool_wolinfo *); 465 u32 (*get_msglevel)(struct net_device *); 466 void (*set_msglevel)(struct net_device *, u32); 467 int (*nway_reset)(struct net_device *); 468 u32 (*get_link)(struct net_device *); 469 int (*get_eeprom_len)(struct net_device *); 470 int (*get_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *); 471 int (*set_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *); 472 int (*get_coalesce)(struct net_device *, struct ethtool_coalesce *); 473 int (*set_coalesce)(struct net_device *, struct ethtool_coalesce *); 474 void (*get_ringparam)(struct net_device *, struct ethtool_ringparam *); 475 int (*set_ringparam)(struct net_device *, struct ethtool_ringparam *); 476 void (*get_pauseparam)(struct net_device *, struct ethtool_pauseparam*); 477 int (*set_pauseparam)(struct net_device *, struct ethtool_pauseparam*); 478 u32 (*get_rx_csum)(struct net_device *); 479 int (*set_rx_csum)(struct net_device *, u32); 480 u32 (*get_tx_csum)(struct net_device *); 481 int (*set_tx_csum)(struct net_device *, u32); 482 u32 (*get_sg)(struct net_device *); 483 int (*set_sg)(struct net_device *, u32); 484 u32 (*get_tso)(struct net_device *); 485 int (*set_tso)(struct net_device *, u32); 486 void (*self_test)(struct net_device *, struct ethtool_test *, u64 *); 487 void (*get_strings)(struct net_device *, u32 stringset, u8 *); 488 int (*phys_id)(struct net_device *, u32); 489 void (*get_ethtool_stats)(struct net_device *, struct ethtool_stats *, u64 *); 490 int (*begin)(struct net_device *); 491 void (*complete)(struct net_device *); 492 u32 (*get_ufo)(struct net_device *); 493 int (*set_ufo)(struct net_device *, u32); 494 u32 (*get_flags)(struct net_device *); 495 int (*set_flags)(struct net_device *, u32); 496 u32 (*get_priv_flags)(struct net_device *); 497 int (*set_priv_flags)(struct net_device *, u32); 498 int (*get_sset_count)(struct net_device *, int); 499 int (*get_rxnfc)(struct net_device *, struct ethtool_rxnfc *, void *); 500 int (*set_rxnfc)(struct net_device *, struct ethtool_rxnfc *); 501 int (*flash_device)(struct net_device *, struct ethtool_flash *); 502 int (*reset)(struct net_device *, u32 *); 503 }; 504 #endif /* __KERNEL__ */ 505 506 /* CMDs currently supported */ 507 #define ETHTOOL_GSET 0x00000001 /* Get settings. */ 508 #define ETHTOOL_SSET 0x00000002 /* Set settings. */ 509 #define ETHTOOL_GDRVINFO 0x00000003 /* Get driver info. */ 510 #define ETHTOOL_GREGS 0x00000004 /* Get NIC registers. */ 511 #define ETHTOOL_GWOL 0x00000005 /* Get wake-on-lan options. */ 512 #define ETHTOOL_SWOL 0x00000006 /* Set wake-on-lan options. */ 513 #define ETHTOOL_GMSGLVL 0x00000007 /* Get driver message level */ 514 #define ETHTOOL_SMSGLVL 0x00000008 /* Set driver msg level. */ 515 #define ETHTOOL_NWAY_RST 0x00000009 /* Restart autonegotiation. */ 516 #define ETHTOOL_GLINK 0x0000000a /* Get link status (ethtool_value) */ 517 #define ETHTOOL_GEEPROM 0x0000000b /* Get EEPROM data */ 518 #define ETHTOOL_SEEPROM 0x0000000c /* Set EEPROM data. */ 519 #define ETHTOOL_GCOALESCE 0x0000000e /* Get coalesce config */ 520 #define ETHTOOL_SCOALESCE 0x0000000f /* Set coalesce config. */ 521 #define ETHTOOL_GRINGPARAM 0x00000010 /* Get ring parameters */ 522 #define ETHTOOL_SRINGPARAM 0x00000011 /* Set ring parameters. */ 523 #define ETHTOOL_GPAUSEPARAM 0x00000012 /* Get pause parameters */ 524 #define ETHTOOL_SPAUSEPARAM 0x00000013 /* Set pause parameters. */ 525 #define ETHTOOL_GRXCSUM 0x00000014 /* Get RX hw csum enable (ethtool_value) */ 526 #define ETHTOOL_SRXCSUM 0x00000015 /* Set RX hw csum enable (ethtool_value) */ 527 #define ETHTOOL_GTXCSUM 0x00000016 /* Get TX hw csum enable (ethtool_value) */ 528 #define ETHTOOL_STXCSUM 0x00000017 /* Set TX hw csum enable (ethtool_value) */ 529 #define ETHTOOL_GSG 0x00000018 /* Get scatter-gather enable 530 * (ethtool_value) */ 531 #define ETHTOOL_SSG 0x00000019 /* Set scatter-gather enable 532 * (ethtool_value). */ 533 #define ETHTOOL_TEST 0x0000001a /* execute NIC self-test. */ 534 #define ETHTOOL_GSTRINGS 0x0000001b /* get specified string set */ 535 #define ETHTOOL_PHYS_ID 0x0000001c /* identify the NIC */ 536 #define ETHTOOL_GSTATS 0x0000001d /* get NIC-specific statistics */ 537 #define ETHTOOL_GTSO 0x0000001e /* Get TSO enable (ethtool_value) */ 538 #define ETHTOOL_STSO 0x0000001f /* Set TSO enable (ethtool_value) */ 539 #define ETHTOOL_GPERMADDR 0x00000020 /* Get permanent hardware address */ 540 #define ETHTOOL_GUFO 0x00000021 /* Get UFO enable (ethtool_value) */ 541 #define ETHTOOL_SUFO 0x00000022 /* Set UFO enable (ethtool_value) */ 542 #define ETHTOOL_GGSO 0x00000023 /* Get GSO enable (ethtool_value) */ 543 #define ETHTOOL_SGSO 0x00000024 /* Set GSO enable (ethtool_value) */ 544 #define ETHTOOL_GFLAGS 0x00000025 /* Get flags bitmap(ethtool_value) */ 545 #define ETHTOOL_SFLAGS 0x00000026 /* Set flags bitmap(ethtool_value) */ 546 #define ETHTOOL_GPFLAGS 0x00000027 /* Get driver-private flags bitmap */ 547 #define ETHTOOL_SPFLAGS 0x00000028 /* Set driver-private flags bitmap */ 548 549 #define ETHTOOL_GRXFH 0x00000029 /* Get RX flow hash configuration */ 550 #define ETHTOOL_SRXFH 0x0000002a /* Set RX flow hash configuration */ 551 #define ETHTOOL_GGRO 0x0000002b /* Get GRO enable (ethtool_value) */ 552 #define ETHTOOL_SGRO 0x0000002c /* Set GRO enable (ethtool_value) */ 553 #define ETHTOOL_GRXRINGS 0x0000002d /* Get RX rings available for LB */ 554 #define ETHTOOL_GRXCLSRLCNT 0x0000002e /* Get RX class rule count */ 555 #define ETHTOOL_GRXCLSRULE 0x0000002f /* Get RX classification rule */ 556 #define ETHTOOL_GRXCLSRLALL 0x00000030 /* Get all RX classification rule */ 557 #define ETHTOOL_SRXCLSRLDEL 0x00000031 /* Delete RX classification rule */ 558 #define ETHTOOL_SRXCLSRLINS 0x00000032 /* Insert RX classification rule */ 559 #define ETHTOOL_FLASHDEV 0x00000033 /* Flash firmware to device */ 560 #define ETHTOOL_RESET 0x00000034 /* Reset hardware */ 561 562 /* compatibility with older code */ 563 #define SPARC_ETH_GSET ETHTOOL_GSET 564 #define SPARC_ETH_SSET ETHTOOL_SSET 565 566 /* Indicates what features are supported by the interface. */ 567 #define SUPPORTED_10baseT_Half (1 << 0) 568 #define SUPPORTED_10baseT_Full (1 << 1) 569 #define SUPPORTED_100baseT_Half (1 << 2) 570 #define SUPPORTED_100baseT_Full (1 << 3) 571 #define SUPPORTED_1000baseT_Half (1 << 4) 572 #define SUPPORTED_1000baseT_Full (1 << 5) 573 #define SUPPORTED_Autoneg (1 << 6) 574 #define SUPPORTED_TP (1 << 7) 575 #define SUPPORTED_AUI (1 << 8) 576 #define SUPPORTED_MII (1 << 9) 577 #define SUPPORTED_FIBRE (1 << 10) 578 #define SUPPORTED_BNC (1 << 11) 579 #define SUPPORTED_10000baseT_Full (1 << 12) 580 #define SUPPORTED_Pause (1 << 13) 581 #define SUPPORTED_Asym_Pause (1 << 14) 582 #define SUPPORTED_2500baseX_Full (1 << 15) 583 #define SUPPORTED_Backplane (1 << 16) 584 #define SUPPORTED_1000baseKX_Full (1 << 17) 585 #define SUPPORTED_10000baseKX4_Full (1 << 18) 586 #define SUPPORTED_10000baseKR_Full (1 << 19) 587 #define SUPPORTED_10000baseR_FEC (1 << 20) 588 589 /* Indicates what features are advertised by the interface. */ 590 #define ADVERTISED_10baseT_Half (1 << 0) 591 #define ADVERTISED_10baseT_Full (1 << 1) 592 #define ADVERTISED_100baseT_Half (1 << 2) 593 #define ADVERTISED_100baseT_Full (1 << 3) 594 #define ADVERTISED_1000baseT_Half (1 << 4) 595 #define ADVERTISED_1000baseT_Full (1 << 5) 596 #define ADVERTISED_Autoneg (1 << 6) 597 #define ADVERTISED_TP (1 << 7) 598 #define ADVERTISED_AUI (1 << 8) 599 #define ADVERTISED_MII (1 << 9) 600 #define ADVERTISED_FIBRE (1 << 10) 601 #define ADVERTISED_BNC (1 << 11) 602 #define ADVERTISED_10000baseT_Full (1 << 12) 603 #define ADVERTISED_Pause (1 << 13) 604 #define ADVERTISED_Asym_Pause (1 << 14) 605 #define ADVERTISED_2500baseX_Full (1 << 15) 606 #define ADVERTISED_Backplane (1 << 16) 607 #define ADVERTISED_1000baseKX_Full (1 << 17) 608 #define ADVERTISED_10000baseKX4_Full (1 << 18) 609 #define ADVERTISED_10000baseKR_Full (1 << 19) 610 #define ADVERTISED_10000baseR_FEC (1 << 20) 611 612 /* The following are all involved in forcing a particular link 613 * mode for the device for setting things. When getting the 614 * devices settings, these indicate the current mode and whether 615 * it was foced up into this mode or autonegotiated. 616 */ 617 618 /* The forced speed, 10Mb, 100Mb, gigabit, 2.5Gb, 10GbE. */ 619 #define SPEED_10 10 620 #define SPEED_100 100 621 #define SPEED_1000 1000 622 #define SPEED_2500 2500 623 #define SPEED_10000 10000 624 625 /* Duplex, half or full. */ 626 #define DUPLEX_HALF 0x00 627 #define DUPLEX_FULL 0x01 628 629 /* Which connector port. */ 630 #define PORT_TP 0x00 631 #define PORT_AUI 0x01 632 #define PORT_MII 0x02 633 #define PORT_FIBRE 0x03 634 #define PORT_BNC 0x04 635 #define PORT_DA 0x05 636 #define PORT_NONE 0xef 637 #define PORT_OTHER 0xff 638 639 /* Which transceiver to use. */ 640 #define XCVR_INTERNAL 0x00 641 #define XCVR_EXTERNAL 0x01 642 #define XCVR_DUMMY1 0x02 643 #define XCVR_DUMMY2 0x03 644 #define XCVR_DUMMY3 0x04 645 646 /* Enable or disable autonegotiation. If this is set to enable, 647 * the forced link modes above are completely ignored. 648 */ 649 #define AUTONEG_DISABLE 0x00 650 #define AUTONEG_ENABLE 0x01 651 652 /* Mode MDI or MDI-X */ 653 #define ETH_TP_MDI_INVALID 0x00 654 #define ETH_TP_MDI 0x01 655 #define ETH_TP_MDI_X 0x02 656 657 /* Wake-On-Lan options. */ 658 #define WAKE_PHY (1 << 0) 659 #define WAKE_UCAST (1 << 1) 660 #define WAKE_MCAST (1 << 2) 661 #define WAKE_BCAST (1 << 3) 662 #define WAKE_ARP (1 << 4) 663 #define WAKE_MAGIC (1 << 5) 664 #define WAKE_MAGICSECURE (1 << 6) /* only meaningful if WAKE_MAGIC */ 665 666 /* L3-L4 network traffic flow types */ 667 #define TCP_V4_FLOW 0x01 668 #define UDP_V4_FLOW 0x02 669 #define SCTP_V4_FLOW 0x03 670 #define AH_ESP_V4_FLOW 0x04 671 #define TCP_V6_FLOW 0x05 672 #define UDP_V6_FLOW 0x06 673 #define SCTP_V6_FLOW 0x07 674 #define AH_ESP_V6_FLOW 0x08 675 #define AH_V4_FLOW 0x09 676 #define ESP_V4_FLOW 0x0a 677 #define AH_V6_FLOW 0x0b 678 #define ESP_V6_FLOW 0x0c 679 #define IP_USER_FLOW 0x0d 680 #define IPV4_FLOW 0x10 681 #define IPV6_FLOW 0x11 682 683 /* L3-L4 network traffic flow hash options */ 684 #define RXH_L2DA (1 << 1) 685 #define RXH_VLAN (1 << 2) 686 #define RXH_L3_PROTO (1 << 3) 687 #define RXH_IP_SRC (1 << 4) 688 #define RXH_IP_DST (1 << 5) 689 #define RXH_L4_B_0_1 (1 << 6) /* src port in case of TCP/UDP/SCTP */ 690 #define RXH_L4_B_2_3 (1 << 7) /* dst port in case of TCP/UDP/SCTP */ 691 #define RXH_DISCARD (1 << 31) 692 693 #define RX_CLS_FLOW_DISC 0xffffffffffffffffULL 694 695 /* Reset flags */ 696 /* The reset() operation must clear the flags for the components which 697 * were actually reset. On successful return, the flags indicate the 698 * components which were not reset, either because they do not exist 699 * in the hardware or because they cannot be reset independently. The 700 * driver must never reset any components that were not requested. 701 */ 702 enum ethtool_reset_flags { 703 /* These flags represent components dedicated to the interface 704 * the command is addressed to. Shift any flag left by 705 * ETH_RESET_SHARED_SHIFT to reset a shared component of the 706 * same type. 707 */ 708 ETH_RESET_MGMT = 1 << 0, /* Management processor */ 709 ETH_RESET_IRQ = 1 << 1, /* Interrupt requester */ 710 ETH_RESET_DMA = 1 << 2, /* DMA engine */ 711 ETH_RESET_FILTER = 1 << 3, /* Filtering/flow direction */ 712 ETH_RESET_OFFLOAD = 1 << 4, /* Protocol offload */ 713 ETH_RESET_MAC = 1 << 5, /* Media access controller */ 714 ETH_RESET_PHY = 1 << 6, /* Transceiver/PHY */ 715 ETH_RESET_RAM = 1 << 7, /* RAM shared between 716 * multiple components */ 717 718 ETH_RESET_DEDICATED = 0x0000ffff, /* All components dedicated to 719 * this interface */ 720 ETH_RESET_ALL = 0xffffffff, /* All components used by this 721 * interface, even if shared */ 722 }; 723 #define ETH_RESET_SHARED_SHIFT 16 724 725 #endif /* _LINUX_ETHTOOL_H */ 726