Dr Andrew Scott G7VAV

My photo
 
June 2025
Mo Tu We Th Fr Sa Su
26 27 28 29 30 31 1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 1 2 3 4 5 6


ethtool.h
001: /*
002:  * ethtool.h: Defines for Linux ethtool.
003:  *
004:  * Copyright (C) 1998 David S. Miller (davem@redhat.com)
005:  * Copyright 2001 Jeff Garzik <jgarzik@pobox.com>
006:  * Portions Copyright 2001 Sun Microsystems (thockin@sun.com)
007:  * Portions Copyright 2002 Intel (eli.kupermann@intel.com,
008:  *                                christopher.leech@intel.com,
009:  *                                scott.feldman@intel.com)
010:  * Portions Copyright (C) Sun Microsystems 2008
011:  */
012: 
013: #ifndef _LINUX_ETHTOOL_H
014: #define _LINUX_ETHTOOL_H
015: 
016: #include <linux/types.h>
017: #include <linux/if_ether.h>
018: 
019: /* This should work for both 32 and 64 bit userland. */
020: struct ethtool_cmd {
021:         __u32   cmd;
022:         __u32   supported;      /* Features this interface supports */
023:         __u32   advertising;    /* Features this interface advertises */
024:         __u16   speed;          /* The forced speed (lower bits) in
025:                                  * Mbps. Please use
026:                                  * ethtool_cmd_speed()/_set() to
027:                                  * access it */
028:         __u8    duplex;         /* Duplex, half or full */
029:         __u8    port;           /* Which connector port */
030:         __u8    phy_address;
031:         __u8    transceiver;    /* Which transceiver to use */
032:         __u8    autoneg;        /* Enable or disable autonegotiation */
033:         __u8    mdio_support;
034:         __u32   maxtxpkt;       /* Tx pkts before generating tx int */
035:         __u32   maxrxpkt;       /* Rx pkts before generating rx int */
036:         __u16   speed_hi;       /* The forced speed (upper
037:                                  * bits) in Mbps. Please use
038:                                  * ethtool_cmd_speed()/_set() to
039:                                  * access it */
040:         __u8    eth_tp_mdix;
041:         __u8    reserved2;
042:         __u32   lp_advertising; /* Features the link partner advertises */
043:         __u32   reserved[2];
044: };
045: 
046: static __inline__ void ethtool_cmd_speed_set(struct ethtool_cmd *ep,
047:                                          __u32 speed)
048: {
049: 
050:         ep->speed = (__u16)speed;
051:         ep->speed_hi = (__u16)(speed >> 16);
052: }
053: 
054: static __inline__ __u32 ethtool_cmd_speed(const struct ethtool_cmd *ep)
055: {
056:         return (ep->speed_hi << 16) | ep->speed;
057: }
058: 
059: #define ETHTOOL_FWVERS_LEN      32
060: #define ETHTOOL_BUSINFO_LEN     32
061: /* these strings are set to whatever the driver author decides... */
062: struct ethtool_drvinfo {
063:         __u32   cmd;
064:         char    driver[32];     /* driver short name, "tulip", "eepro100" */
065:         char    version[32];    /* driver version string */
066:         char    fw_version[ETHTOOL_FWVERS_LEN]; /* firmware version string */
067:         char    bus_info[ETHTOOL_BUSINFO_LEN];  /* Bus info for this IF. */
068:                                 /* For PCI devices, use pci_name(pci_dev). */
069:         char    reserved1[32];
070:         char    reserved2[12];
071:                                 /*
072:                                  * Some struct members below are filled in
073:                                  * using ops->get_sset_count().  Obtaining
074:                                  * this info from ethtool_drvinfo is now
075:                                  * deprecated; Use ETHTOOL_GSSET_INFO
076:                                  * instead.
077:                                  */
078:         __u32   n_priv_flags;   /* number of flags valid in ETHTOOL_GPFLAGS */
079:         __u32   n_stats;        /* number of u64's from ETHTOOL_GSTATS */
080:         __u32   testinfo_len;
081:         __u32   eedump_len;     /* Size of data from ETHTOOL_GEEPROM (bytes) */
082:         __u32   regdump_len;    /* Size of data from ETHTOOL_GREGS (bytes) */
083: };
084: 
085: #define SOPASS_MAX      6
086: /* wake-on-lan settings */
087: struct ethtool_wolinfo {
088:         __u32   cmd;
089:         __u32   supported;
090:         __u32   wolopts;
091:         __u8    sopass[SOPASS_MAX]; /* SecureOn(tm) password */
092: };
093: 
094: /* for passing single values */
095: struct ethtool_value {
096:         __u32   cmd;
097:         __u32   data;
098: };
099: 
100: /* for passing big chunks of data */
101: struct ethtool_regs {
102:         __u32   cmd;
103:         __u32   version; /* driver-specific, indicates different chips/revs */
104:         __u32   len; /* bytes */
105:         __u8    data[0];
106: };
107: 
108: /* for passing EEPROM chunks */
109: struct ethtool_eeprom {
110:         __u32   cmd;
111:         __u32   magic;
112:         __u32   offset; /* in bytes */
113:         __u32   len; /* in bytes */
114:         __u8    data[0];
115: };
116: 
117: /**
118:  * struct ethtool_coalesce - coalescing parameters for IRQs and stats updates
119:  * @cmd: ETHTOOL_{G,S}COALESCE
120:  * @rx_coalesce_usecs: How many usecs to delay an RX interrupt after
121:  *      a packet arrives.
122:  * @rx_max_coalesced_frames: Maximum number of packets to receive
123:  *      before an RX interrupt.
124:  * @rx_coalesce_usecs_irq: Same as @rx_coalesce_usecs, except that
125:  *      this value applies while an IRQ is being serviced by the host.
126:  * @rx_max_coalesced_frames_irq: Same as @rx_max_coalesced_frames,
127:  *      except that this value applies while an IRQ is being serviced
128:  *      by the host.
129:  * @tx_coalesce_usecs: How many usecs to delay a TX interrupt after
130:  *      a packet is sent.
131:  * @tx_max_coalesced_frames: Maximum number of packets to be sent
132:  *      before a TX interrupt.
133:  * @tx_coalesce_usecs_irq: Same as @tx_coalesce_usecs, except that
134:  *      this value applies while an IRQ is being serviced by the host.
135:  * @tx_max_coalesced_frames_irq: Same as @tx_max_coalesced_frames,
136:  *      except that this value applies while an IRQ is being serviced
137:  *      by the host.
138:  * @stats_block_coalesce_usecs: How many usecs to delay in-memory
139:  *      statistics block updates.  Some drivers do not have an
140:  *      in-memory statistic block, and in such cases this value is
141:  *      ignored.  This value must not be zero.
142:  * @use_adaptive_rx_coalesce: Enable adaptive RX coalescing.
143:  * @use_adaptive_tx_coalesce: Enable adaptive TX coalescing.
144:  * @pkt_rate_low: Threshold for low packet rate (packets per second).
145:  * @rx_coalesce_usecs_low: How many usecs to delay an RX interrupt after
146:  *      a packet arrives, when the packet rate is below @pkt_rate_low.
147:  * @rx_max_coalesced_frames_low: Maximum number of packets to be received
148:  *      before an RX interrupt, when the packet rate is below @pkt_rate_low.
149:  * @tx_coalesce_usecs_low: How many usecs to delay a TX interrupt after
150:  *      a packet is sent, when the packet rate is below @pkt_rate_low.
151:  * @tx_max_coalesced_frames_low: Maximum nuumber of packets to be sent before
152:  *      a TX interrupt, when the packet rate is below @pkt_rate_low.
153:  * @pkt_rate_high: Threshold for high packet rate (packets per second).
154:  * @rx_coalesce_usecs_high: How many usecs to delay an RX interrupt after
155:  *      a packet arrives, when the packet rate is above @pkt_rate_high.
156:  * @rx_max_coalesced_frames_high: Maximum number of packets to be received
157:  *      before an RX interrupt, when the packet rate is above @pkt_rate_high.
158:  * @tx_coalesce_usecs_high: How many usecs to delay a TX interrupt after
159:  *      a packet is sent, when the packet rate is above @pkt_rate_high.
160:  * @tx_max_coalesced_frames_high: Maximum number of packets to be sent before
161:  *      a TX interrupt, when the packet rate is above @pkt_rate_high.
162:  * @rate_sample_interval: How often to do adaptive coalescing packet rate
163:  *      sampling, measured in seconds.  Must not be zero.
164:  *
165:  * Each pair of (usecs, max_frames) fields specifies this exit
166:  * condition for interrupt coalescing:
167:  *      (usecs > 0 && time_since_first_completion >= usecs) ||
168:  *      (max_frames > 0 && completed_frames >= max_frames)
169:  * It is illegal to set both usecs and max_frames to zero as this
170:  * would cause interrupts to never be generated.  To disable
171:  * coalescing, set usecs = 0 and max_frames = 1.
172:  *
173:  * Some implementations ignore the value of max_frames and use the
174:  * condition:
175:  *      time_since_first_completion >= usecs
176:  * This is deprecated.  Drivers for hardware that does not support
177:  * counting completions should validate that max_frames == !rx_usecs.
178:  *
179:  * Adaptive RX/TX coalescing is an algorithm implemented by some
180:  * drivers to improve latency under low packet rates and improve
181:  * throughput under high packet rates.  Some drivers only implement
182:  * one of RX or TX adaptive coalescing.  Anything not implemented by
183:  * the driver causes these values to be silently ignored.
184:  *
185:  * When the packet rate is below @pkt_rate_high but above
186:  * @pkt_rate_low (both measured in packets per second) the
187:  * normal {rx,tx}_* coalescing parameters are used.
188:  */
189: struct ethtool_coalesce {
190:         __u32   cmd;
191:         __u32   rx_coalesce_usecs;
192:         __u32   rx_max_coalesced_frames;
193:         __u32   rx_coalesce_usecs_irq;
194:         __u32   rx_max_coalesced_frames_irq;
195:         __u32   tx_coalesce_usecs;
196:         __u32   tx_max_coalesced_frames;
197:         __u32   tx_coalesce_usecs_irq;
198:         __u32   tx_max_coalesced_frames_irq;
199:         __u32   stats_block_coalesce_usecs;
200:         __u32   use_adaptive_rx_coalesce;
201:         __u32   use_adaptive_tx_coalesce;
202:         __u32   pkt_rate_low;
203:         __u32   rx_coalesce_usecs_low;
204:         __u32   rx_max_coalesced_frames_low;
205:         __u32   tx_coalesce_usecs_low;
206:         __u32   tx_max_coalesced_frames_low;
207:         __u32   pkt_rate_high;
208:         __u32   rx_coalesce_usecs_high;
209:         __u32   rx_max_coalesced_frames_high;
210:         __u32   tx_coalesce_usecs_high;
211:         __u32   tx_max_coalesced_frames_high;
212:         __u32   rate_sample_interval;
213: };
214: 
215: /* for configuring RX/TX ring parameters */
216: struct ethtool_ringparam {
217:         __u32   cmd;    /* ETHTOOL_{G,S}RINGPARAM */
218: 
219:         /* Read only attributes.  These indicate the maximum number
220:          * of pending RX/TX ring entries the driver will allow the
221:          * user to set.
222:          */
223:         __u32   rx_max_pending;
224:         __u32   rx_mini_max_pending;
225:         __u32   rx_jumbo_max_pending;
226:         __u32   tx_max_pending;
227: 
228:         /* Values changeable by the user.  The valid values are
229:          * in the range 1 to the "*_max_pending" counterpart above.
230:          */
231:         __u32   rx_pending;
232:         __u32   rx_mini_pending;
233:         __u32   rx_jumbo_pending;
234:         __u32   tx_pending;
235: };
236: 
237: /**
238:  * struct ethtool_channels - configuring number of network channel
239:  * @cmd: ETHTOOL_{G,S}CHANNELS
240:  * @max_rx: Read only. Maximum number of receive channel the driver support.
241:  * @max_tx: Read only. Maximum number of transmit channel the driver support.
242:  * @max_other: Read only. Maximum number of other channel the driver support.
243:  * @max_combined: Read only. Maximum number of combined channel the driver
244:  *      support. Set of queues RX, TX or other.
245:  * @rx_count: Valid values are in the range 1 to the max_rx.
246:  * @tx_count: Valid values are in the range 1 to the max_tx.
247:  * @other_count: Valid values are in the range 1 to the max_other.
248:  * @combined_count: Valid values are in the range 1 to the max_combined.
249:  *
250:  * This can be used to configure RX, TX and other channels.
251:  */
252: 
253: struct ethtool_channels {
254:         __u32   cmd;
255:         __u32   max_rx;
256:         __u32   max_tx;
257:         __u32   max_other;
258:         __u32   max_combined;
259:         __u32   rx_count;
260:         __u32   tx_count;
261:         __u32   other_count;
262:         __u32   combined_count;
263: };
264: 
265: /* for configuring link flow control parameters */
266: struct ethtool_pauseparam {
267:         __u32   cmd;    /* ETHTOOL_{G,S}PAUSEPARAM */
268: 
269:         /* If the link is being auto-negotiated (via ethtool_cmd.autoneg
270:          * being true) the user may set 'autoneg' here non-zero to have the
271:          * pause parameters be auto-negotiated too.  In such a case, the
272:          * {rx,tx}_pause values below determine what capabilities are
273:          * advertised.
274:          *
275:          * If 'autoneg' is zero or the link is not being auto-negotiated,
276:          * then {rx,tx}_pause force the driver to use/not-use pause
277:          * flow control.
278:          */
279:         __u32   autoneg;
280:         __u32   rx_pause;
281:         __u32   tx_pause;
282: };
283: 
284: #define ETH_GSTRING_LEN         32
285: enum ethtool_stringset {
286:         ETH_SS_TEST             = 0,
287:         ETH_SS_STATS,
288:         ETH_SS_PRIV_FLAGS,
289:         ETH_SS_NTUPLE_FILTERS,  /* Do not use, GRXNTUPLE is now deprecated */
290:         ETH_SS_FEATURES,
291: };
292: 
293: /* for passing string sets for data tagging */
294: struct ethtool_gstrings {
295:         __u32   cmd;            /* ETHTOOL_GSTRINGS */
296:         __u32   string_set;     /* string set id e.c. ETH_SS_TEST, etc*/
297:         __u32   len;            /* number of strings in the string set */
298:         __u8    data[0];
299: };
300: 
301: struct ethtool_sset_info {
302:         __u32   cmd;            /* ETHTOOL_GSSET_INFO */
303:         __u32   reserved;
304:         __u64   sset_mask;      /* input: each bit selects an sset to query */
305:                                 /* output: each bit a returned sset */
306:         __u32   data[0];        /* ETH_SS_xxx count, in order, based on bits
307:                                    in sset_mask.  One bit implies one
308:                                    __u32, two bits implies two
309:                                    __u32's, etc. */
310: };
311: 
312: /**
313:  * enum ethtool_test_flags - flags definition of ethtool_test
314:  * @ETH_TEST_FL_OFFLINE: if set perform online and offline tests, otherwise
315:  *      only online tests.
316:  * @ETH_TEST_FL_FAILED: Driver set this flag if test fails.
317:  * @ETH_TEST_FL_EXTERNAL_LB: Application request to perform external loopback
318:  *      test.
319:  * @ETH_TEST_FL_EXTERNAL_LB_DONE: Driver performed the external loopback test
320:  */
321: 
322: enum ethtool_test_flags {
323:         ETH_TEST_FL_OFFLINE     = (1 << 0),
324:         ETH_TEST_FL_FAILED      = (1 << 1),
325:         ETH_TEST_FL_EXTERNAL_LB = (1 << 2),
326:         ETH_TEST_FL_EXTERNAL_LB_DONE    = (1 << 3),
327: };
328: 
329: /* for requesting NIC test and getting results*/
330: struct ethtool_test {
331:         __u32   cmd;            /* ETHTOOL_TEST */
332:         __u32   flags;          /* ETH_TEST_FL_xxx */
333:         __u32   reserved;
334:         __u32   len;            /* result length, in number of u64 elements */
335:         __u64   data[0];
336: };
337: 
338: /* for dumping NIC-specific statistics */
339: struct ethtool_stats {
340:         __u32   cmd;            /* ETHTOOL_GSTATS */
341:         __u32   n_stats;        /* number of u64's being returned */
342:         __u64   data[0];
343: };
344: 
345: struct ethtool_perm_addr {
346:         __u32   cmd;            /* ETHTOOL_GPERMADDR */
347:         __u32   size;
348:         __u8    data[0];
349: };
350: 
351: /* boolean flags controlling per-interface behavior characteristics.
352:  * When reading, the flag indicates whether or not a certain behavior
353:  * is enabled/present.  When writing, the flag indicates whether
354:  * or not the driver should turn on (set) or off (clear) a behavior.
355:  *
356:  * Some behaviors may read-only (unconditionally absent or present).
357:  * If such is the case, return EINVAL in the set-flags operation if the
358:  * flag differs from the read-only value.
359:  */
360: enum ethtool_flags {
361:         ETH_FLAG_TXVLAN         = (1 << 7),     /* TX VLAN offload enabled */
362:         ETH_FLAG_RXVLAN         = (1 << 8),     /* RX VLAN offload enabled */
363:         ETH_FLAG_LRO            = (1 << 15),    /* LRO is enabled */
364:         ETH_FLAG_NTUPLE         = (1 << 27),    /* N-tuple filters enabled */
365:         ETH_FLAG_RXHASH         = (1 << 28),
366: };
367: 
368: /* The following structures are for supporting RX network flow
369:  * classification and RX n-tuple configuration. Note, all multibyte
370:  * fields, e.g., ip4src, ip4dst, psrc, pdst, spi, etc. are expected to
371:  * be in network byte order.
372:  */
373: 
374: /**
375:  * struct ethtool_tcpip4_spec - flow specification for TCP/IPv4 etc.
376:  * @ip4src: Source host
377:  * @ip4dst: Destination host
378:  * @psrc: Source port
379:  * @pdst: Destination port
380:  * @tos: Type-of-service
381:  *
382:  * This can be used to specify a TCP/IPv4, UDP/IPv4 or SCTP/IPv4 flow.
383:  */
384: struct ethtool_tcpip4_spec {
385:         __be32  ip4src;
386:         __be32  ip4dst;
387:         __be16  psrc;
388:         __be16  pdst;
389:         __u8    tos;
390: };
391: 
392: /**
393:  * struct ethtool_ah_espip4_spec - flow specification for IPsec/IPv4
394:  * @ip4src: Source host
395:  * @ip4dst: Destination host
396:  * @spi: Security parameters index
397:  * @tos: Type-of-service
398:  *
399:  * This can be used to specify an IPsec transport or tunnel over IPv4.
400:  */
401: struct ethtool_ah_espip4_spec {
402:         __be32  ip4src;
403:         __be32  ip4dst;
404:         __be32  spi;
405:         __u8    tos;
406: };
407: 
408: #define ETH_RX_NFC_IP4  1
409: 
410: /**
411:  * struct ethtool_usrip4_spec - general flow specification for IPv4
412:  * @ip4src: Source host
413:  * @ip4dst: Destination host
414:  * @l4_4_bytes: First 4 bytes of transport (layer 4) header
415:  * @tos: Type-of-service
416:  * @ip_ver: Value must be %ETH_RX_NFC_IP4; mask must be 0
417:  * @proto: Transport protocol number; mask must be 0
418:  */
419: struct ethtool_usrip4_spec {
420:         __be32  ip4src;
421:         __be32  ip4dst;
422:         __be32  l4_4_bytes;
423:         __u8    tos;
424:         __u8    ip_ver;
425:         __u8    proto;
426: };
427: 
428: union ethtool_flow_union {
429:         struct ethtool_tcpip4_spec              tcp_ip4_spec;
430:         struct ethtool_tcpip4_spec              udp_ip4_spec;
431:         struct ethtool_tcpip4_spec              sctp_ip4_spec;
432:         struct ethtool_ah_espip4_spec           ah_ip4_spec;
433:         struct ethtool_ah_espip4_spec           esp_ip4_spec;
434:         struct ethtool_usrip4_spec              usr_ip4_spec;
435:         struct ethhdr                           ether_spec;
436:         __u8                                    hdata[60];
437: };
438: 
439: struct ethtool_flow_ext {
440:         __be16  vlan_etype;
441:         __be16  vlan_tci;
442:         __be32  data[2];
443: };
444: 
445: /**
446:  * struct ethtool_rx_flow_spec - classification rule for RX flows
447:  * @flow_type: Type of match to perform, e.g. %TCP_V4_FLOW
448:  * @h_u: Flow fields to match (dependent on @flow_type)
449:  * @h_ext: Additional fields to match
450:  * @m_u: Masks for flow field bits to be matched
451:  * @m_ext: Masks for additional field bits to be matched
452:  *      Note, all additional fields must be ignored unless @flow_type
453:  *      includes the %FLOW_EXT flag.
454:  * @ring_cookie: RX ring/queue index to deliver to, or %RX_CLS_FLOW_DISC
455:  *      if packets should be discarded
456:  * @location: Location of rule in the table.  Locations must be
457:  *      numbered such that a flow matching multiple rules will be
458:  *      classified according to the first (lowest numbered) rule.
459:  */
460: struct ethtool_rx_flow_spec {
461:         __u32           flow_type;
462:         union ethtool_flow_union h_u;
463:         struct ethtool_flow_ext h_ext;
464:         union ethtool_flow_union m_u;
465:         struct ethtool_flow_ext m_ext;
466:         __u64           ring_cookie;
467:         __u32           location;
468: };
469: 
470: /**
471:  * struct ethtool_rxnfc - command to get or set RX flow classification rules
472:  * @cmd: Specific command number - %ETHTOOL_GRXFH, %ETHTOOL_SRXFH,
473:  *      %ETHTOOL_GRXRINGS, %ETHTOOL_GRXCLSRLCNT, %ETHTOOL_GRXCLSRULE,
474:  *      %ETHTOOL_GRXCLSRLALL, %ETHTOOL_SRXCLSRLDEL or %ETHTOOL_SRXCLSRLINS
475:  * @flow_type: Type of flow to be affected, e.g. %TCP_V4_FLOW
476:  * @data: Command-dependent value
477:  * @fs: Flow classification rule
478:  * @rule_cnt: Number of rules to be affected
479:  * @rule_locs: Array of used rule locations
480:  *
481:  * For %ETHTOOL_GRXFH and %ETHTOOL_SRXFH, @data is a bitmask indicating
482:  * the fields included in the flow hash, e.g. %RXH_IP_SRC.  The following
483:  * structure fields must not be used.
484:  *
485:  * For %ETHTOOL_GRXRINGS, @data is set to the number of RX rings/queues
486:  * on return.
487:  *
488:  * For %ETHTOOL_GRXCLSRLCNT, @rule_cnt is set to the number of defined
489:  * rules on return.
490:  *
491:  * For %ETHTOOL_GRXCLSRULE, @fs.@location specifies the location of an
492:  * existing rule on entry and @fs contains the rule on return.
493:  *
494:  * For %ETHTOOL_GRXCLSRLALL, @rule_cnt specifies the array size of the
495:  * user buffer for @rule_locs on entry.  On return, @data is the size
496:  * of the rule table, @rule_cnt is the number of defined rules, and
497:  * @rule_locs contains the locations of the defined rules.  Drivers
498:  * must use the second parameter to get_rxnfc() instead of @rule_locs.
499:  *
500:  * For %ETHTOOL_SRXCLSRLINS, @fs specifies the rule to add or update.
501:  * @fs.@location specifies the location to use and must not be ignored.
502:  *
503:  * For %ETHTOOL_SRXCLSRLDEL, @fs.@location specifies the location of an
504:  * existing rule on entry.
505:  */
506: struct ethtool_rxnfc {
507:         __u32                           cmd;
508:         __u32                           flow_type;
509:         __u64                           data;
510:         struct ethtool_rx_flow_spec     fs;
511:         __u32                           rule_cnt;
512:         __u32                           rule_locs[0];
513: };
514: 
515: 
516: /**
517:  * struct ethtool_rxfh_indir - command to get or set RX flow hash indirection
518:  * @cmd: Specific command number - %ETHTOOL_GRXFHINDIR or %ETHTOOL_SRXFHINDIR
519:  * @size: On entry, the array size of the user buffer.  On return from
520:  *      %ETHTOOL_GRXFHINDIR, the array size of the hardware indirection table.
521:  * @ring_index: RX ring/queue index for each hash value
522:  */
523: struct ethtool_rxfh_indir {
524:         __u32   cmd;
525:         __u32   size;
526:         __u32   ring_index[0];
527: };
528: 
529: /**
530:  * struct ethtool_rx_ntuple_flow_spec - specification for RX flow filter
531:  * @flow_type: Type of match to perform, e.g. %TCP_V4_FLOW
532:  * @h_u: Flow field values to match (dependent on @flow_type)
533:  * @m_u: Masks for flow field value bits to be ignored
534:  * @vlan_tag: VLAN tag to match
535:  * @vlan_tag_mask: Mask for VLAN tag bits to be ignored
536:  * @data: Driver-dependent data to match
537:  * @data_mask: Mask for driver-dependent data bits to be ignored
538:  * @action: RX ring/queue index to deliver to (non-negative) or other action
539:  *      (negative, e.g. %ETHTOOL_RXNTUPLE_ACTION_DROP)
540:  *
541:  * For flow types %TCP_V4_FLOW, %UDP_V4_FLOW and %SCTP_V4_FLOW, where
542:  * a field value and mask are both zero this is treated as if all mask
543:  * bits are set i.e. the field is ignored.
544:  */
545: struct ethtool_rx_ntuple_flow_spec {
546:         __u32            flow_type;
547:         union {
548:                 struct ethtool_tcpip4_spec              tcp_ip4_spec;
549:                 struct ethtool_tcpip4_spec              udp_ip4_spec;
550:                 struct ethtool_tcpip4_spec              sctp_ip4_spec;
551:                 struct ethtool_ah_espip4_spec           ah_ip4_spec;
552:                 struct ethtool_ah_espip4_spec           esp_ip4_spec;
553:                 struct ethtool_usrip4_spec              usr_ip4_spec;
554:                 struct ethhdr                           ether_spec;
555:                 __u8                                    hdata[72];
556:         } h_u, m_u;
557: 
558:         __u16           vlan_tag;
559:         __u16           vlan_tag_mask;
560:         __u64           data;
561:         __u64           data_mask;
562: 
563:         __s32           action;
564: #define ETHTOOL_RXNTUPLE_ACTION_DROP    (-1)    /* drop packet */
565: #define ETHTOOL_RXNTUPLE_ACTION_CLEAR   (-2)    /* clear filter */
566: };
567: 
568: /**
569:  * struct ethtool_rx_ntuple - command to set or clear RX flow filter
570:  * @cmd: Command number - %ETHTOOL_SRXNTUPLE
571:  * @fs: Flow filter specification
572:  */
573: struct ethtool_rx_ntuple {
574:         __u32                                   cmd;
575:         struct ethtool_rx_ntuple_flow_spec      fs;
576: };
577: 
578: #define ETHTOOL_FLASH_MAX_FILENAME      128
579: enum ethtool_flash_op_type {
580:         ETHTOOL_FLASH_ALL_REGIONS       = 0,
581: };
582: 
583: /* for passing firmware flashing related parameters */
584: struct ethtool_flash {
585:         __u32   cmd;
586:         __u32   region;
587:         char    data[ETHTOOL_FLASH_MAX_FILENAME];
588: };
589: 
590: /**
591:  * struct ethtool_dump - used for retrieving, setting device dump
592:  * @cmd: Command number - %ETHTOOL_GET_DUMP_FLAG, %ETHTOOL_GET_DUMP_DATA, or
593:  *      %ETHTOOL_SET_DUMP
594:  * @version: FW version of the dump, filled in by driver
595:  * @flag: driver dependent flag for dump setting, filled in by driver during
596:  *        get and filled in by ethtool for set operation
597:  * @len: length of dump data, used as the length of the user buffer on entry to
598:  *       %ETHTOOL_GET_DUMP_DATA and this is returned as dump length by driver
599:  *       for %ETHTOOL_GET_DUMP_FLAG command
600:  * @data: data collected for get dump data operation
601:  */
602: struct ethtool_dump {
603:         __u32   cmd;
604:         __u32   version;
605:         __u32   flag;
606:         __u32   len;
607:         __u8    data[0];
608: };
609: 
610: /* for returning and changing feature sets */
611: 
612: /**
613:  * struct ethtool_get_features_block - block with state of 32 features
614:  * @available: mask of changeable features
615:  * @requested: mask of features requested to be enabled if possible
616:  * @active: mask of currently enabled features
617:  * @never_changed: mask of features not changeable for any device
618:  */
619: struct ethtool_get_features_block {
620:         __u32   available;
621:         __u32   requested;
622:         __u32   active;
623:         __u32   never_changed;
624: };
625: 
626: /**
627:  * struct ethtool_gfeatures - command to get state of device's features
628:  * @cmd: command number = %ETHTOOL_GFEATURES
629:  * @size: in: number of elements in the features[] array;
630:  *       out: number of elements in features[] needed to hold all features
631:  * @features: state of features
632:  */
633: struct ethtool_gfeatures {
634:         __u32   cmd;
635:         __u32   size;
636:         struct ethtool_get_features_block features[0];
637: };
638: 
639: /**
640:  * struct ethtool_set_features_block - block with request for 32 features
641:  * @valid: mask of features to be changed
642:  * @requested: values of features to be changed
643:  */
644: struct ethtool_set_features_block {
645:         __u32   valid;
646:         __u32   requested;
647: };
648: 
649: /**
650:  * struct ethtool_sfeatures - command to request change in device's features
651:  * @cmd: command number = %ETHTOOL_SFEATURES
652:  * @size: array size of the features[] array
653:  * @features: feature change masks
654:  */
655: struct ethtool_sfeatures {
656:         __u32   cmd;
657:         __u32   size;
658:         struct ethtool_set_features_block features[0];
659: };
660: 
661: /*
662:  * %ETHTOOL_SFEATURES changes features present in features[].valid to the
663:  * values of corresponding bits in features[].requested. Bits in .requested
664:  * not set in .valid or not changeable are ignored.
665:  *
666:  * Returns %EINVAL when .valid contains undefined or never-changeable bits
667:  * or size is not equal to required number of features words (32-bit blocks).
668:  * Returns >= 0 if request was completed; bits set in the value mean:
669:  *   %ETHTOOL_F_UNSUPPORTED - there were bits set in .valid that are not
670:  *      changeable (not present in %ETHTOOL_GFEATURES' features[].available)
671:  *      those bits were ignored.
672:  *   %ETHTOOL_F_WISH - some or all changes requested were recorded but the
673:  *      resulting state of bits masked by .valid is not equal to .requested.
674:  *      Probably there are other device-specific constraints on some features
675:  *      in the set. When %ETHTOOL_F_UNSUPPORTED is set, .valid is considered
676:  *      here as though ignored bits were cleared.
677:  *   %ETHTOOL_F_COMPAT - some or all changes requested were made by calling
678:  *      compatibility functions. Requested offload state cannot be properly
679:  *      managed by kernel.
680:  *
681:  * Meaning of bits in the masks are obtained by %ETHTOOL_GSSET_INFO (number of
682:  * bits in the arrays - always multiple of 32) and %ETHTOOL_GSTRINGS commands
683:  * for ETH_SS_FEATURES string set. First entry in the table corresponds to least
684:  * significant bit in features[0] fields. Empty strings mark undefined features.
685:  */
686: enum ethtool_sfeatures_retval_bits {
687:         ETHTOOL_F_UNSUPPORTED__BIT,
688:         ETHTOOL_F_WISH__BIT,
689:         ETHTOOL_F_COMPAT__BIT,
690: };
691: 
692: #define ETHTOOL_F_UNSUPPORTED   (1 << ETHTOOL_F_UNSUPPORTED__BIT)
693: #define ETHTOOL_F_WISH          (1 << ETHTOOL_F_WISH__BIT)
694: #define ETHTOOL_F_COMPAT        (1 << ETHTOOL_F_COMPAT__BIT)
695: 
696: 
697: /* CMDs currently supported */
698: #define ETHTOOL_GSET            0x00000001 /* Get settings. */
699: #define ETHTOOL_SSET            0x00000002 /* Set settings. */
700: #define ETHTOOL_GDRVINFO        0x00000003 /* Get driver info. */
701: #define ETHTOOL_GREGS           0x00000004 /* Get NIC registers. */
702: #define ETHTOOL_GWOL            0x00000005 /* Get wake-on-lan options. */
703: #define ETHTOOL_SWOL            0x00000006 /* Set wake-on-lan options. */
704: #define ETHTOOL_GMSGLVL         0x00000007 /* Get driver message level */
705: #define ETHTOOL_SMSGLVL         0x00000008 /* Set driver msg level. */
706: #define ETHTOOL_NWAY_RST        0x00000009 /* Restart autonegotiation. */
707: /* Get link status for host, i.e. whether the interface *and* the
708:  * physical port (if there is one) are up (ethtool_value). */
709: #define ETHTOOL_GLINK           0x0000000a
710: #define ETHTOOL_GEEPROM         0x0000000b /* Get EEPROM data */
711: #define ETHTOOL_SEEPROM         0x0000000c /* Set EEPROM data. */
712: #define ETHTOOL_GCOALESCE       0x0000000e /* Get coalesce config */
713: #define ETHTOOL_SCOALESCE       0x0000000f /* Set coalesce config. */
714: #define ETHTOOL_GRINGPARAM      0x00000010 /* Get ring parameters */
715: #define ETHTOOL_SRINGPARAM      0x00000011 /* Set ring parameters. */
716: #define ETHTOOL_GPAUSEPARAM     0x00000012 /* Get pause parameters */
717: #define ETHTOOL_SPAUSEPARAM     0x00000013 /* Set pause parameters. */
718: #define ETHTOOL_GRXCSUM         0x00000014 /* Get RX hw csum enable (ethtool_value) */
719: #define ETHTOOL_SRXCSUM         0x00000015 /* Set RX hw csum enable (ethtool_value) */
720: #define ETHTOOL_GTXCSUM         0x00000016 /* Get TX hw csum enable (ethtool_value) */
721: #define ETHTOOL_STXCSUM         0x00000017 /* Set TX hw csum enable (ethtool_value) */
722: #define ETHTOOL_GSG             0x00000018 /* Get scatter-gather enable
723:                                             * (ethtool_value) */
724: #define ETHTOOL_SSG             0x00000019 /* Set scatter-gather enable
725:                                             * (ethtool_value). */
726: #define ETHTOOL_TEST            0x0000001a /* execute NIC self-test. */
727: #define ETHTOOL_GSTRINGS        0x0000001b /* get specified string set */
728: #define ETHTOOL_PHYS_ID         0x0000001c /* identify the NIC */
729: #define ETHTOOL_GSTATS          0x0000001d /* get NIC-specific statistics */
730: #define ETHTOOL_GTSO            0x0000001e /* Get TSO enable (ethtool_value) */
731: #define ETHTOOL_STSO            0x0000001f /* Set TSO enable (ethtool_value) */
732: #define ETHTOOL_GPERMADDR       0x00000020 /* Get permanent hardware address */
733: #define ETHTOOL_GUFO            0x00000021 /* Get UFO enable (ethtool_value) */
734: #define ETHTOOL_SUFO            0x00000022 /* Set UFO enable (ethtool_value) */
735: #define ETHTOOL_GGSO            0x00000023 /* Get GSO enable (ethtool_value) */
736: #define ETHTOOL_SGSO            0x00000024 /* Set GSO enable (ethtool_value) */
737: #define ETHTOOL_GFLAGS          0x00000025 /* Get flags bitmap(ethtool_value) */
738: #define ETHTOOL_SFLAGS          0x00000026 /* Set flags bitmap(ethtool_value) */
739: #define ETHTOOL_GPFLAGS         0x00000027 /* Get driver-private flags bitmap */
740: #define ETHTOOL_SPFLAGS         0x00000028 /* Set driver-private flags bitmap */
741: 
742: #define ETHTOOL_GRXFH           0x00000029 /* Get RX flow hash configuration */
743: #define ETHTOOL_SRXFH           0x0000002a /* Set RX flow hash configuration */
744: #define ETHTOOL_GGRO            0x0000002b /* Get GRO enable (ethtool_value) */
745: #define ETHTOOL_SGRO            0x0000002c /* Set GRO enable (ethtool_value) */
746: #define ETHTOOL_GRXRINGS        0x0000002d /* Get RX rings available for LB */
747: #define ETHTOOL_GRXCLSRLCNT     0x0000002e /* Get RX class rule count */
748: #define ETHTOOL_GRXCLSRULE      0x0000002f /* Get RX classification rule */
749: #define ETHTOOL_GRXCLSRLALL     0x00000030 /* Get all RX classification rule */
750: #define ETHTOOL_SRXCLSRLDEL     0x00000031 /* Delete RX classification rule */
751: #define ETHTOOL_SRXCLSRLINS     0x00000032 /* Insert RX classification rule */
752: #define ETHTOOL_FLASHDEV        0x00000033 /* Flash firmware to device */
753: #define ETHTOOL_RESET           0x00000034 /* Reset hardware */
754: #define ETHTOOL_SRXNTUPLE       0x00000035 /* Add an n-tuple filter to device */
755: #define ETHTOOL_GRXNTUPLE       0x00000036 /* deprecated */
756: #define ETHTOOL_GSSET_INFO      0x00000037 /* Get string set info */
757: #define ETHTOOL_GRXFHINDIR      0x00000038 /* Get RX flow hash indir'n table */
758: #define ETHTOOL_SRXFHINDIR      0x00000039 /* Set RX flow hash indir'n table */
759: 
760: #define ETHTOOL_GFEATURES       0x0000003a /* Get device offload settings */
761: #define ETHTOOL_SFEATURES       0x0000003b /* Change device offload settings */
762: #define ETHTOOL_GCHANNELS       0x0000003c /* Get no of channels */
763: #define ETHTOOL_SCHANNELS       0x0000003d /* Set no of channels */
764: #define ETHTOOL_SET_DUMP        0x0000003e /* Set dump settings */
765: #define ETHTOOL_GET_DUMP_FLAG   0x0000003f /* Get dump settings */
766: #define ETHTOOL_GET_DUMP_DATA   0x00000040 /* Get dump data */
767: 
768: /* compatibility with older code */
769: #define SPARC_ETH_GSET          ETHTOOL_GSET
770: #define SPARC_ETH_SSET          ETHTOOL_SSET
771: 
772: /* Indicates what features are supported by the interface. */
773: #define SUPPORTED_10baseT_Half          (1 << 0)
774: #define SUPPORTED_10baseT_Full          (1 << 1)
775: #define SUPPORTED_100baseT_Half         (1 << 2)
776: #define SUPPORTED_100baseT_Full         (1 << 3)
777: #define SUPPORTED_1000baseT_Half        (1 << 4)
778: #define SUPPORTED_1000baseT_Full        (1 << 5)
779: #define SUPPORTED_Autoneg               (1 << 6)
780: #define SUPPORTED_TP                    (1 << 7)
781: #define SUPPORTED_AUI                   (1 << 8)
782: #define SUPPORTED_MII                   (1 << 9)
783: #define SUPPORTED_FIBRE                 (1 << 10)
784: #define SUPPORTED_BNC                   (1 << 11)
785: #define SUPPORTED_10000baseT_Full       (1 << 12)
786: #define SUPPORTED_Pause                 (1 << 13)
787: #define SUPPORTED_Asym_Pause            (1 << 14)
788: #define SUPPORTED_2500baseX_Full        (1 << 15)
789: #define SUPPORTED_Backplane             (1 << 16)
790: #define SUPPORTED_1000baseKX_Full       (1 << 17)
791: #define SUPPORTED_10000baseKX4_Full     (1 << 18)
792: #define SUPPORTED_10000baseKR_Full      (1 << 19)
793: #define SUPPORTED_10000baseR_FEC        (1 << 20)
794: #define SUPPORTED_20000baseMLD2_Full    (1 << 21)
795: #define SUPPORTED_20000baseKR2_Full     (1 << 22)
796: 
797: /* Indicates what features are advertised by the interface. */
798: #define ADVERTISED_10baseT_Half         (1 << 0)
799: #define ADVERTISED_10baseT_Full         (1 << 1)
800: #define ADVERTISED_100baseT_Half        (1 << 2)
801: #define ADVERTISED_100baseT_Full        (1 << 3)
802: #define ADVERTISED_1000baseT_Half       (1 << 4)
803: #define ADVERTISED_1000baseT_Full       (1 << 5)
804: #define ADVERTISED_Autoneg              (1 << 6)
805: #define ADVERTISED_TP                   (1 << 7)
806: #define ADVERTISED_AUI                  (1 << 8)
807: #define ADVERTISED_MII                  (1 << 9)
808: #define ADVERTISED_FIBRE                (1 << 10)
809: #define ADVERTISED_BNC                  (1 << 11)
810: #define ADVERTISED_10000baseT_Full      (1 << 12)
811: #define ADVERTISED_Pause                (1 << 13)
812: #define ADVERTISED_Asym_Pause           (1 << 14)
813: #define ADVERTISED_2500baseX_Full       (1 << 15)
814: #define ADVERTISED_Backplane            (1 << 16)
815: #define ADVERTISED_1000baseKX_Full      (1 << 17)
816: #define ADVERTISED_10000baseKX4_Full    (1 << 18)
817: #define ADVERTISED_10000baseKR_Full     (1 << 19)
818: #define ADVERTISED_10000baseR_FEC       (1 << 20)
819: #define ADVERTISED_20000baseMLD2_Full   (1 << 21)
820: #define ADVERTISED_20000baseKR2_Full    (1 << 22)
821: 
822: /* The following are all involved in forcing a particular link
823:  * mode for the device for setting things.  When getting the
824:  * devices settings, these indicate the current mode and whether
825:  * it was forced up into this mode or autonegotiated.
826:  */
827: 
828: /* The forced speed, 10Mb, 100Mb, gigabit, 2.5Gb, 10GbE. */
829: #define SPEED_10                10
830: #define SPEED_100               100
831: #define SPEED_1000              1000
832: #define SPEED_2500              2500
833: #define SPEED_10000             10000
834: #define SPEED_UNKNOWN           -1
835: 
836: /* Duplex, half or full. */
837: #define DUPLEX_HALF             0x00
838: #define DUPLEX_FULL             0x01
839: #define DUPLEX_UNKNOWN          0xff
840: 
841: /* Which connector port. */
842: #define PORT_TP                 0x00
843: #define PORT_AUI                0x01
844: #define PORT_MII                0x02
845: #define PORT_FIBRE              0x03
846: #define PORT_BNC                0x04
847: #define PORT_DA                 0x05
848: #define PORT_NONE               0xef
849: #define PORT_OTHER              0xff
850: 
851: /* Which transceiver to use. */
852: #define XCVR_INTERNAL           0x00
853: #define XCVR_EXTERNAL           0x01
854: #define XCVR_DUMMY1             0x02
855: #define XCVR_DUMMY2             0x03
856: #define XCVR_DUMMY3             0x04
857: 
858: /* Enable or disable autonegotiation.  If this is set to enable,
859:  * the forced link modes above are completely ignored.
860:  */
861: #define AUTONEG_DISABLE         0x00
862: #define AUTONEG_ENABLE          0x01
863: 
864: /* Mode MDI or MDI-X */
865: #define ETH_TP_MDI_INVALID      0x00
866: #define ETH_TP_MDI              0x01
867: #define ETH_TP_MDI_X            0x02
868: 
869: /* Wake-On-Lan options. */
870: #define WAKE_PHY                (1 << 0)
871: #define WAKE_UCAST              (1 << 1)
872: #define WAKE_MCAST              (1 << 2)
873: #define WAKE_BCAST              (1 << 3)
874: #define WAKE_ARP                (1 << 4)
875: #define WAKE_MAGIC              (1 << 5)
876: #define WAKE_MAGICSECURE        (1 << 6) /* only meaningful if WAKE_MAGIC */
877: 
878: /* L2-L4 network traffic flow types */
879: #define TCP_V4_FLOW     0x01    /* hash or spec (tcp_ip4_spec) */
880: #define UDP_V4_FLOW     0x02    /* hash or spec (udp_ip4_spec) */
881: #define SCTP_V4_FLOW    0x03    /* hash or spec (sctp_ip4_spec) */
882: #define AH_ESP_V4_FLOW  0x04    /* hash only */
883: #define TCP_V6_FLOW     0x05    /* hash only */
884: #define UDP_V6_FLOW     0x06    /* hash only */
885: #define SCTP_V6_FLOW    0x07    /* hash only */
886: #define AH_ESP_V6_FLOW  0x08    /* hash only */
887: #define AH_V4_FLOW      0x09    /* hash or spec (ah_ip4_spec) */
888: #define ESP_V4_FLOW     0x0a    /* hash or spec (esp_ip4_spec) */
889: #define AH_V6_FLOW      0x0b    /* hash only */
890: #define ESP_V6_FLOW     0x0c    /* hash only */
891: #define IP_USER_FLOW    0x0d    /* spec only (usr_ip4_spec) */
892: #define IPV4_FLOW       0x10    /* hash only */
893: #define IPV6_FLOW       0x11    /* hash only */
894: #define ETHER_FLOW      0x12    /* spec only (ether_spec) */
895: /* Flag to enable additional fields in struct ethtool_rx_flow_spec */
896: #define FLOW_EXT        0x80000000
897: 
898: /* L3-L4 network traffic flow hash options */
899: #define RXH_L2DA        (1 << 1)
900: #define RXH_VLAN        (1 << 2)
901: #define RXH_L3_PROTO    (1 << 3)
902: #define RXH_IP_SRC      (1 << 4)
903: #define RXH_IP_DST      (1 << 5)
904: #define RXH_L4_B_0_1    (1 << 6) /* src port in case of TCP/UDP/SCTP */
905: #define RXH_L4_B_2_3    (1 << 7) /* dst port in case of TCP/UDP/SCTP */
906: #define RXH_DISCARD     (1 << 31)
907: 
908: #define RX_CLS_FLOW_DISC        0xffffffffffffffffULL
909: 
910: /* Reset flags */
911: /* The reset() operation must clear the flags for the components which
912:  * were actually reset.  On successful return, the flags indicate the
913:  * components which were not reset, either because they do not exist
914:  * in the hardware or because they cannot be reset independently.  The
915:  * driver must never reset any components that were not requested.
916:  */
917: enum ethtool_reset_flags {
918:         /* These flags represent components dedicated to the interface
919:          * the command is addressed to.  Shift any flag left by
920:          * ETH_RESET_SHARED_SHIFT to reset a shared component of the
921:          * same type.
922:          */
923:         ETH_RESET_MGMT          = 1 << 0,       /* Management processor */
924:         ETH_RESET_IRQ           = 1 << 1,       /* Interrupt requester */
925:         ETH_RESET_DMA           = 1 << 2,       /* DMA engine */
926:         ETH_RESET_FILTER        = 1 << 3,       /* Filtering/flow direction */
927:         ETH_RESET_OFFLOAD       = 1 << 4,       /* Protocol offload */
928:         ETH_RESET_MAC           = 1 << 5,       /* Media access controller */
929:         ETH_RESET_PHY           = 1 << 6,       /* Transceiver/PHY */
930:         ETH_RESET_RAM           = 1 << 7,       /* RAM shared between
931:                                                  * multiple components */
932: 
933:         ETH_RESET_DEDICATED     = 0x0000ffff,   /* All components dedicated to
934:                                                  * this interface */
935:         ETH_RESET_ALL           = 0xffffffff,   /* All components used by this
936:                                                  * interface, even if shared */
937: };
938: #define ETH_RESET_SHARED_SHIFT  16
939: 
940: #endif /* _LINUX_ETHTOOL_H */
941: 


for client (none)
© Andrew Scott 2006 - 2025,
All Rights Reserved
http://www.andrew-scott.uk/
Andrew Scott
http://www.andrew-scott.co.uk/