tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
fork
Configure Feed
Select the types of activity you want to include in your feed.
1/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
2/* Do not edit directly, auto-generated from: */
3/* Documentation/netlink/specs/ethtool.yaml */
4/* YNL-GEN user header */
5/* YNL-ARG --user-header linux/ethtool_netlink.h --exclude-op stats-get */
6
7#ifndef _LINUX_ETHTOOL_GEN_H
8#define _LINUX_ETHTOOL_GEN_H
9
10#include <stdlib.h>
11#include <string.h>
12#include <linux/types.h>
13#include <linux/ethtool.h>
14
15struct ynl_sock;
16
17extern const struct ynl_family ynl_ethtool_family;
18
19/* Enums */
20const char *ethtool_op_str(int op);
21const char *ethtool_udp_tunnel_type_str(int value);
22const char *ethtool_stringset_str(enum ethtool_stringset value);
23
24/* Common nested types */
25struct ethtool_header {
26 struct {
27 __u32 dev_index:1;
28 __u32 dev_name_len;
29 __u32 flags:1;
30 } _present;
31
32 __u32 dev_index;
33 char *dev_name;
34 __u32 flags;
35};
36
37struct ethtool_pause_stat {
38 struct {
39 __u32 tx_frames:1;
40 __u32 rx_frames:1;
41 } _present;
42
43 __u64 tx_frames;
44 __u64 rx_frames;
45};
46
47struct ethtool_cable_test_tdr_cfg {
48 struct {
49 __u32 first:1;
50 __u32 last:1;
51 __u32 step:1;
52 __u32 pair:1;
53 } _present;
54
55 __u32 first;
56 __u32 last;
57 __u32 step;
58 __u8 pair;
59};
60
61struct ethtool_fec_stat {
62 struct {
63 __u32 corrected_len;
64 __u32 uncorr_len;
65 __u32 corr_bits_len;
66 } _present;
67
68 void *corrected;
69 void *uncorr;
70 void *corr_bits;
71};
72
73struct ethtool_mm_stat {
74 struct {
75 __u32 reassembly_errors:1;
76 __u32 smd_errors:1;
77 __u32 reassembly_ok:1;
78 __u32 rx_frag_count:1;
79 __u32 tx_frag_count:1;
80 __u32 hold_count:1;
81 } _present;
82
83 __u64 reassembly_errors;
84 __u64 smd_errors;
85 __u64 reassembly_ok;
86 __u64 rx_frag_count;
87 __u64 tx_frag_count;
88 __u64 hold_count;
89};
90
91struct ethtool_cable_result {
92 struct {
93 __u32 pair:1;
94 __u32 code:1;
95 } _present;
96
97 __u8 pair;
98 __u8 code;
99};
100
101struct ethtool_cable_fault_length {
102 struct {
103 __u32 pair:1;
104 __u32 cm:1;
105 } _present;
106
107 __u8 pair;
108 __u32 cm;
109};
110
111struct ethtool_bitset_bit {
112 struct {
113 __u32 index:1;
114 __u32 name_len;
115 __u32 value:1;
116 } _present;
117
118 __u32 index;
119 char *name;
120};
121
122struct ethtool_tunnel_udp_entry {
123 struct {
124 __u32 port:1;
125 __u32 type:1;
126 } _present;
127
128 __u16 port /* big-endian */;
129 __u32 type;
130};
131
132struct ethtool_string {
133 struct {
134 __u32 index:1;
135 __u32 value_len;
136 } _present;
137
138 __u32 index;
139 char *value;
140};
141
142struct ethtool_cable_nest {
143 struct {
144 __u32 result:1;
145 __u32 fault_length:1;
146 } _present;
147
148 struct ethtool_cable_result result;
149 struct ethtool_cable_fault_length fault_length;
150};
151
152struct ethtool_bitset_bits {
153 unsigned int n_bit;
154 struct ethtool_bitset_bit *bit;
155};
156
157struct ethtool_strings {
158 unsigned int n_string;
159 struct ethtool_string *string;
160};
161
162struct ethtool_bitset {
163 struct {
164 __u32 nomask:1;
165 __u32 size:1;
166 __u32 bits:1;
167 } _present;
168
169 __u32 size;
170 struct ethtool_bitset_bits bits;
171};
172
173struct ethtool_stringset_ {
174 struct {
175 __u32 id:1;
176 __u32 count:1;
177 } _present;
178
179 __u32 id;
180 __u32 count;
181 unsigned int n_strings;
182 struct ethtool_strings *strings;
183};
184
185struct ethtool_tunnel_udp_table {
186 struct {
187 __u32 size:1;
188 __u32 types:1;
189 } _present;
190
191 __u32 size;
192 struct ethtool_bitset types;
193 unsigned int n_entry;
194 struct ethtool_tunnel_udp_entry *entry;
195};
196
197struct ethtool_stringsets {
198 unsigned int n_stringset;
199 struct ethtool_stringset_ *stringset;
200};
201
202struct ethtool_tunnel_udp {
203 struct {
204 __u32 table:1;
205 } _present;
206
207 struct ethtool_tunnel_udp_table table;
208};
209
210/* ============== ETHTOOL_MSG_STRSET_GET ============== */
211/* ETHTOOL_MSG_STRSET_GET - do */
212struct ethtool_strset_get_req {
213 struct {
214 __u32 header:1;
215 __u32 stringsets:1;
216 __u32 counts_only:1;
217 } _present;
218
219 struct ethtool_header header;
220 struct ethtool_stringsets stringsets;
221};
222
223static inline struct ethtool_strset_get_req *ethtool_strset_get_req_alloc(void)
224{
225 return calloc(1, sizeof(struct ethtool_strset_get_req));
226}
227void ethtool_strset_get_req_free(struct ethtool_strset_get_req *req);
228
229static inline void
230ethtool_strset_get_req_set_header_dev_index(struct ethtool_strset_get_req *req,
231 __u32 dev_index)
232{
233 req->_present.header = 1;
234 req->header._present.dev_index = 1;
235 req->header.dev_index = dev_index;
236}
237static inline void
238ethtool_strset_get_req_set_header_dev_name(struct ethtool_strset_get_req *req,
239 const char *dev_name)
240{
241 free(req->header.dev_name);
242 req->header._present.dev_name_len = strlen(dev_name);
243 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
244 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
245 req->header.dev_name[req->header._present.dev_name_len] = 0;
246}
247static inline void
248ethtool_strset_get_req_set_header_flags(struct ethtool_strset_get_req *req,
249 __u32 flags)
250{
251 req->_present.header = 1;
252 req->header._present.flags = 1;
253 req->header.flags = flags;
254}
255static inline void
256__ethtool_strset_get_req_set_stringsets_stringset(struct ethtool_strset_get_req *req,
257 struct ethtool_stringset_ *stringset,
258 unsigned int n_stringset)
259{
260 free(req->stringsets.stringset);
261 req->stringsets.stringset = stringset;
262 req->stringsets.n_stringset = n_stringset;
263}
264static inline void
265ethtool_strset_get_req_set_counts_only(struct ethtool_strset_get_req *req)
266{
267 req->_present.counts_only = 1;
268}
269
270struct ethtool_strset_get_rsp {
271 struct {
272 __u32 header:1;
273 __u32 stringsets:1;
274 } _present;
275
276 struct ethtool_header header;
277 struct ethtool_stringsets stringsets;
278};
279
280void ethtool_strset_get_rsp_free(struct ethtool_strset_get_rsp *rsp);
281
282/*
283 * Get string set from the kernel.
284 */
285struct ethtool_strset_get_rsp *
286ethtool_strset_get(struct ynl_sock *ys, struct ethtool_strset_get_req *req);
287
288/* ETHTOOL_MSG_STRSET_GET - dump */
289struct ethtool_strset_get_req_dump {
290 struct {
291 __u32 header:1;
292 __u32 stringsets:1;
293 __u32 counts_only:1;
294 } _present;
295
296 struct ethtool_header header;
297 struct ethtool_stringsets stringsets;
298};
299
300static inline struct ethtool_strset_get_req_dump *
301ethtool_strset_get_req_dump_alloc(void)
302{
303 return calloc(1, sizeof(struct ethtool_strset_get_req_dump));
304}
305void ethtool_strset_get_req_dump_free(struct ethtool_strset_get_req_dump *req);
306
307static inline void
308ethtool_strset_get_req_dump_set_header_dev_index(struct ethtool_strset_get_req_dump *req,
309 __u32 dev_index)
310{
311 req->_present.header = 1;
312 req->header._present.dev_index = 1;
313 req->header.dev_index = dev_index;
314}
315static inline void
316ethtool_strset_get_req_dump_set_header_dev_name(struct ethtool_strset_get_req_dump *req,
317 const char *dev_name)
318{
319 free(req->header.dev_name);
320 req->header._present.dev_name_len = strlen(dev_name);
321 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
322 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
323 req->header.dev_name[req->header._present.dev_name_len] = 0;
324}
325static inline void
326ethtool_strset_get_req_dump_set_header_flags(struct ethtool_strset_get_req_dump *req,
327 __u32 flags)
328{
329 req->_present.header = 1;
330 req->header._present.flags = 1;
331 req->header.flags = flags;
332}
333static inline void
334__ethtool_strset_get_req_dump_set_stringsets_stringset(struct ethtool_strset_get_req_dump *req,
335 struct ethtool_stringset_ *stringset,
336 unsigned int n_stringset)
337{
338 free(req->stringsets.stringset);
339 req->stringsets.stringset = stringset;
340 req->stringsets.n_stringset = n_stringset;
341}
342static inline void
343ethtool_strset_get_req_dump_set_counts_only(struct ethtool_strset_get_req_dump *req)
344{
345 req->_present.counts_only = 1;
346}
347
348struct ethtool_strset_get_list {
349 struct ethtool_strset_get_list *next;
350 struct ethtool_strset_get_rsp obj __attribute__ ((aligned (8)));
351};
352
353void ethtool_strset_get_list_free(struct ethtool_strset_get_list *rsp);
354
355struct ethtool_strset_get_list *
356ethtool_strset_get_dump(struct ynl_sock *ys,
357 struct ethtool_strset_get_req_dump *req);
358
359/* ============== ETHTOOL_MSG_LINKINFO_GET ============== */
360/* ETHTOOL_MSG_LINKINFO_GET - do */
361struct ethtool_linkinfo_get_req {
362 struct {
363 __u32 header:1;
364 } _present;
365
366 struct ethtool_header header;
367};
368
369static inline struct ethtool_linkinfo_get_req *
370ethtool_linkinfo_get_req_alloc(void)
371{
372 return calloc(1, sizeof(struct ethtool_linkinfo_get_req));
373}
374void ethtool_linkinfo_get_req_free(struct ethtool_linkinfo_get_req *req);
375
376static inline void
377ethtool_linkinfo_get_req_set_header_dev_index(struct ethtool_linkinfo_get_req *req,
378 __u32 dev_index)
379{
380 req->_present.header = 1;
381 req->header._present.dev_index = 1;
382 req->header.dev_index = dev_index;
383}
384static inline void
385ethtool_linkinfo_get_req_set_header_dev_name(struct ethtool_linkinfo_get_req *req,
386 const char *dev_name)
387{
388 free(req->header.dev_name);
389 req->header._present.dev_name_len = strlen(dev_name);
390 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
391 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
392 req->header.dev_name[req->header._present.dev_name_len] = 0;
393}
394static inline void
395ethtool_linkinfo_get_req_set_header_flags(struct ethtool_linkinfo_get_req *req,
396 __u32 flags)
397{
398 req->_present.header = 1;
399 req->header._present.flags = 1;
400 req->header.flags = flags;
401}
402
403struct ethtool_linkinfo_get_rsp {
404 struct {
405 __u32 header:1;
406 __u32 port:1;
407 __u32 phyaddr:1;
408 __u32 tp_mdix:1;
409 __u32 tp_mdix_ctrl:1;
410 __u32 transceiver:1;
411 } _present;
412
413 struct ethtool_header header;
414 __u8 port;
415 __u8 phyaddr;
416 __u8 tp_mdix;
417 __u8 tp_mdix_ctrl;
418 __u8 transceiver;
419};
420
421void ethtool_linkinfo_get_rsp_free(struct ethtool_linkinfo_get_rsp *rsp);
422
423/*
424 * Get link info.
425 */
426struct ethtool_linkinfo_get_rsp *
427ethtool_linkinfo_get(struct ynl_sock *ys, struct ethtool_linkinfo_get_req *req);
428
429/* ETHTOOL_MSG_LINKINFO_GET - dump */
430struct ethtool_linkinfo_get_req_dump {
431 struct {
432 __u32 header:1;
433 } _present;
434
435 struct ethtool_header header;
436};
437
438static inline struct ethtool_linkinfo_get_req_dump *
439ethtool_linkinfo_get_req_dump_alloc(void)
440{
441 return calloc(1, sizeof(struct ethtool_linkinfo_get_req_dump));
442}
443void
444ethtool_linkinfo_get_req_dump_free(struct ethtool_linkinfo_get_req_dump *req);
445
446static inline void
447ethtool_linkinfo_get_req_dump_set_header_dev_index(struct ethtool_linkinfo_get_req_dump *req,
448 __u32 dev_index)
449{
450 req->_present.header = 1;
451 req->header._present.dev_index = 1;
452 req->header.dev_index = dev_index;
453}
454static inline void
455ethtool_linkinfo_get_req_dump_set_header_dev_name(struct ethtool_linkinfo_get_req_dump *req,
456 const char *dev_name)
457{
458 free(req->header.dev_name);
459 req->header._present.dev_name_len = strlen(dev_name);
460 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
461 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
462 req->header.dev_name[req->header._present.dev_name_len] = 0;
463}
464static inline void
465ethtool_linkinfo_get_req_dump_set_header_flags(struct ethtool_linkinfo_get_req_dump *req,
466 __u32 flags)
467{
468 req->_present.header = 1;
469 req->header._present.flags = 1;
470 req->header.flags = flags;
471}
472
473struct ethtool_linkinfo_get_list {
474 struct ethtool_linkinfo_get_list *next;
475 struct ethtool_linkinfo_get_rsp obj __attribute__ ((aligned (8)));
476};
477
478void ethtool_linkinfo_get_list_free(struct ethtool_linkinfo_get_list *rsp);
479
480struct ethtool_linkinfo_get_list *
481ethtool_linkinfo_get_dump(struct ynl_sock *ys,
482 struct ethtool_linkinfo_get_req_dump *req);
483
484/* ETHTOOL_MSG_LINKINFO_GET - notify */
485struct ethtool_linkinfo_get_ntf {
486 __u16 family;
487 __u8 cmd;
488 struct ynl_ntf_base_type *next;
489 void (*free)(struct ethtool_linkinfo_get_ntf *ntf);
490 struct ethtool_linkinfo_get_rsp obj __attribute__ ((aligned (8)));
491};
492
493void ethtool_linkinfo_get_ntf_free(struct ethtool_linkinfo_get_ntf *rsp);
494
495/* ============== ETHTOOL_MSG_LINKINFO_SET ============== */
496/* ETHTOOL_MSG_LINKINFO_SET - do */
497struct ethtool_linkinfo_set_req {
498 struct {
499 __u32 header:1;
500 __u32 port:1;
501 __u32 phyaddr:1;
502 __u32 tp_mdix:1;
503 __u32 tp_mdix_ctrl:1;
504 __u32 transceiver:1;
505 } _present;
506
507 struct ethtool_header header;
508 __u8 port;
509 __u8 phyaddr;
510 __u8 tp_mdix;
511 __u8 tp_mdix_ctrl;
512 __u8 transceiver;
513};
514
515static inline struct ethtool_linkinfo_set_req *
516ethtool_linkinfo_set_req_alloc(void)
517{
518 return calloc(1, sizeof(struct ethtool_linkinfo_set_req));
519}
520void ethtool_linkinfo_set_req_free(struct ethtool_linkinfo_set_req *req);
521
522static inline void
523ethtool_linkinfo_set_req_set_header_dev_index(struct ethtool_linkinfo_set_req *req,
524 __u32 dev_index)
525{
526 req->_present.header = 1;
527 req->header._present.dev_index = 1;
528 req->header.dev_index = dev_index;
529}
530static inline void
531ethtool_linkinfo_set_req_set_header_dev_name(struct ethtool_linkinfo_set_req *req,
532 const char *dev_name)
533{
534 free(req->header.dev_name);
535 req->header._present.dev_name_len = strlen(dev_name);
536 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
537 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
538 req->header.dev_name[req->header._present.dev_name_len] = 0;
539}
540static inline void
541ethtool_linkinfo_set_req_set_header_flags(struct ethtool_linkinfo_set_req *req,
542 __u32 flags)
543{
544 req->_present.header = 1;
545 req->header._present.flags = 1;
546 req->header.flags = flags;
547}
548static inline void
549ethtool_linkinfo_set_req_set_port(struct ethtool_linkinfo_set_req *req,
550 __u8 port)
551{
552 req->_present.port = 1;
553 req->port = port;
554}
555static inline void
556ethtool_linkinfo_set_req_set_phyaddr(struct ethtool_linkinfo_set_req *req,
557 __u8 phyaddr)
558{
559 req->_present.phyaddr = 1;
560 req->phyaddr = phyaddr;
561}
562static inline void
563ethtool_linkinfo_set_req_set_tp_mdix(struct ethtool_linkinfo_set_req *req,
564 __u8 tp_mdix)
565{
566 req->_present.tp_mdix = 1;
567 req->tp_mdix = tp_mdix;
568}
569static inline void
570ethtool_linkinfo_set_req_set_tp_mdix_ctrl(struct ethtool_linkinfo_set_req *req,
571 __u8 tp_mdix_ctrl)
572{
573 req->_present.tp_mdix_ctrl = 1;
574 req->tp_mdix_ctrl = tp_mdix_ctrl;
575}
576static inline void
577ethtool_linkinfo_set_req_set_transceiver(struct ethtool_linkinfo_set_req *req,
578 __u8 transceiver)
579{
580 req->_present.transceiver = 1;
581 req->transceiver = transceiver;
582}
583
584/*
585 * Set link info.
586 */
587int ethtool_linkinfo_set(struct ynl_sock *ys,
588 struct ethtool_linkinfo_set_req *req);
589
590/* ============== ETHTOOL_MSG_LINKMODES_GET ============== */
591/* ETHTOOL_MSG_LINKMODES_GET - do */
592struct ethtool_linkmodes_get_req {
593 struct {
594 __u32 header:1;
595 } _present;
596
597 struct ethtool_header header;
598};
599
600static inline struct ethtool_linkmodes_get_req *
601ethtool_linkmodes_get_req_alloc(void)
602{
603 return calloc(1, sizeof(struct ethtool_linkmodes_get_req));
604}
605void ethtool_linkmodes_get_req_free(struct ethtool_linkmodes_get_req *req);
606
607static inline void
608ethtool_linkmodes_get_req_set_header_dev_index(struct ethtool_linkmodes_get_req *req,
609 __u32 dev_index)
610{
611 req->_present.header = 1;
612 req->header._present.dev_index = 1;
613 req->header.dev_index = dev_index;
614}
615static inline void
616ethtool_linkmodes_get_req_set_header_dev_name(struct ethtool_linkmodes_get_req *req,
617 const char *dev_name)
618{
619 free(req->header.dev_name);
620 req->header._present.dev_name_len = strlen(dev_name);
621 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
622 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
623 req->header.dev_name[req->header._present.dev_name_len] = 0;
624}
625static inline void
626ethtool_linkmodes_get_req_set_header_flags(struct ethtool_linkmodes_get_req *req,
627 __u32 flags)
628{
629 req->_present.header = 1;
630 req->header._present.flags = 1;
631 req->header.flags = flags;
632}
633
634struct ethtool_linkmodes_get_rsp {
635 struct {
636 __u32 header:1;
637 __u32 autoneg:1;
638 __u32 ours:1;
639 __u32 peer:1;
640 __u32 speed:1;
641 __u32 duplex:1;
642 __u32 master_slave_cfg:1;
643 __u32 master_slave_state:1;
644 __u32 lanes:1;
645 __u32 rate_matching:1;
646 } _present;
647
648 struct ethtool_header header;
649 __u8 autoneg;
650 struct ethtool_bitset ours;
651 struct ethtool_bitset peer;
652 __u32 speed;
653 __u8 duplex;
654 __u8 master_slave_cfg;
655 __u8 master_slave_state;
656 __u32 lanes;
657 __u8 rate_matching;
658};
659
660void ethtool_linkmodes_get_rsp_free(struct ethtool_linkmodes_get_rsp *rsp);
661
662/*
663 * Get link modes.
664 */
665struct ethtool_linkmodes_get_rsp *
666ethtool_linkmodes_get(struct ynl_sock *ys,
667 struct ethtool_linkmodes_get_req *req);
668
669/* ETHTOOL_MSG_LINKMODES_GET - dump */
670struct ethtool_linkmodes_get_req_dump {
671 struct {
672 __u32 header:1;
673 } _present;
674
675 struct ethtool_header header;
676};
677
678static inline struct ethtool_linkmodes_get_req_dump *
679ethtool_linkmodes_get_req_dump_alloc(void)
680{
681 return calloc(1, sizeof(struct ethtool_linkmodes_get_req_dump));
682}
683void
684ethtool_linkmodes_get_req_dump_free(struct ethtool_linkmodes_get_req_dump *req);
685
686static inline void
687ethtool_linkmodes_get_req_dump_set_header_dev_index(struct ethtool_linkmodes_get_req_dump *req,
688 __u32 dev_index)
689{
690 req->_present.header = 1;
691 req->header._present.dev_index = 1;
692 req->header.dev_index = dev_index;
693}
694static inline void
695ethtool_linkmodes_get_req_dump_set_header_dev_name(struct ethtool_linkmodes_get_req_dump *req,
696 const char *dev_name)
697{
698 free(req->header.dev_name);
699 req->header._present.dev_name_len = strlen(dev_name);
700 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
701 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
702 req->header.dev_name[req->header._present.dev_name_len] = 0;
703}
704static inline void
705ethtool_linkmodes_get_req_dump_set_header_flags(struct ethtool_linkmodes_get_req_dump *req,
706 __u32 flags)
707{
708 req->_present.header = 1;
709 req->header._present.flags = 1;
710 req->header.flags = flags;
711}
712
713struct ethtool_linkmodes_get_list {
714 struct ethtool_linkmodes_get_list *next;
715 struct ethtool_linkmodes_get_rsp obj __attribute__ ((aligned (8)));
716};
717
718void ethtool_linkmodes_get_list_free(struct ethtool_linkmodes_get_list *rsp);
719
720struct ethtool_linkmodes_get_list *
721ethtool_linkmodes_get_dump(struct ynl_sock *ys,
722 struct ethtool_linkmodes_get_req_dump *req);
723
724/* ETHTOOL_MSG_LINKMODES_GET - notify */
725struct ethtool_linkmodes_get_ntf {
726 __u16 family;
727 __u8 cmd;
728 struct ynl_ntf_base_type *next;
729 void (*free)(struct ethtool_linkmodes_get_ntf *ntf);
730 struct ethtool_linkmodes_get_rsp obj __attribute__ ((aligned (8)));
731};
732
733void ethtool_linkmodes_get_ntf_free(struct ethtool_linkmodes_get_ntf *rsp);
734
735/* ============== ETHTOOL_MSG_LINKMODES_SET ============== */
736/* ETHTOOL_MSG_LINKMODES_SET - do */
737struct ethtool_linkmodes_set_req {
738 struct {
739 __u32 header:1;
740 __u32 autoneg:1;
741 __u32 ours:1;
742 __u32 peer:1;
743 __u32 speed:1;
744 __u32 duplex:1;
745 __u32 master_slave_cfg:1;
746 __u32 master_slave_state:1;
747 __u32 lanes:1;
748 __u32 rate_matching:1;
749 } _present;
750
751 struct ethtool_header header;
752 __u8 autoneg;
753 struct ethtool_bitset ours;
754 struct ethtool_bitset peer;
755 __u32 speed;
756 __u8 duplex;
757 __u8 master_slave_cfg;
758 __u8 master_slave_state;
759 __u32 lanes;
760 __u8 rate_matching;
761};
762
763static inline struct ethtool_linkmodes_set_req *
764ethtool_linkmodes_set_req_alloc(void)
765{
766 return calloc(1, sizeof(struct ethtool_linkmodes_set_req));
767}
768void ethtool_linkmodes_set_req_free(struct ethtool_linkmodes_set_req *req);
769
770static inline void
771ethtool_linkmodes_set_req_set_header_dev_index(struct ethtool_linkmodes_set_req *req,
772 __u32 dev_index)
773{
774 req->_present.header = 1;
775 req->header._present.dev_index = 1;
776 req->header.dev_index = dev_index;
777}
778static inline void
779ethtool_linkmodes_set_req_set_header_dev_name(struct ethtool_linkmodes_set_req *req,
780 const char *dev_name)
781{
782 free(req->header.dev_name);
783 req->header._present.dev_name_len = strlen(dev_name);
784 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
785 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
786 req->header.dev_name[req->header._present.dev_name_len] = 0;
787}
788static inline void
789ethtool_linkmodes_set_req_set_header_flags(struct ethtool_linkmodes_set_req *req,
790 __u32 flags)
791{
792 req->_present.header = 1;
793 req->header._present.flags = 1;
794 req->header.flags = flags;
795}
796static inline void
797ethtool_linkmodes_set_req_set_autoneg(struct ethtool_linkmodes_set_req *req,
798 __u8 autoneg)
799{
800 req->_present.autoneg = 1;
801 req->autoneg = autoneg;
802}
803static inline void
804ethtool_linkmodes_set_req_set_ours_nomask(struct ethtool_linkmodes_set_req *req)
805{
806 req->_present.ours = 1;
807 req->ours._present.nomask = 1;
808}
809static inline void
810ethtool_linkmodes_set_req_set_ours_size(struct ethtool_linkmodes_set_req *req,
811 __u32 size)
812{
813 req->_present.ours = 1;
814 req->ours._present.size = 1;
815 req->ours.size = size;
816}
817static inline void
818__ethtool_linkmodes_set_req_set_ours_bits_bit(struct ethtool_linkmodes_set_req *req,
819 struct ethtool_bitset_bit *bit,
820 unsigned int n_bit)
821{
822 free(req->ours.bits.bit);
823 req->ours.bits.bit = bit;
824 req->ours.bits.n_bit = n_bit;
825}
826static inline void
827ethtool_linkmodes_set_req_set_peer_nomask(struct ethtool_linkmodes_set_req *req)
828{
829 req->_present.peer = 1;
830 req->peer._present.nomask = 1;
831}
832static inline void
833ethtool_linkmodes_set_req_set_peer_size(struct ethtool_linkmodes_set_req *req,
834 __u32 size)
835{
836 req->_present.peer = 1;
837 req->peer._present.size = 1;
838 req->peer.size = size;
839}
840static inline void
841__ethtool_linkmodes_set_req_set_peer_bits_bit(struct ethtool_linkmodes_set_req *req,
842 struct ethtool_bitset_bit *bit,
843 unsigned int n_bit)
844{
845 free(req->peer.bits.bit);
846 req->peer.bits.bit = bit;
847 req->peer.bits.n_bit = n_bit;
848}
849static inline void
850ethtool_linkmodes_set_req_set_speed(struct ethtool_linkmodes_set_req *req,
851 __u32 speed)
852{
853 req->_present.speed = 1;
854 req->speed = speed;
855}
856static inline void
857ethtool_linkmodes_set_req_set_duplex(struct ethtool_linkmodes_set_req *req,
858 __u8 duplex)
859{
860 req->_present.duplex = 1;
861 req->duplex = duplex;
862}
863static inline void
864ethtool_linkmodes_set_req_set_master_slave_cfg(struct ethtool_linkmodes_set_req *req,
865 __u8 master_slave_cfg)
866{
867 req->_present.master_slave_cfg = 1;
868 req->master_slave_cfg = master_slave_cfg;
869}
870static inline void
871ethtool_linkmodes_set_req_set_master_slave_state(struct ethtool_linkmodes_set_req *req,
872 __u8 master_slave_state)
873{
874 req->_present.master_slave_state = 1;
875 req->master_slave_state = master_slave_state;
876}
877static inline void
878ethtool_linkmodes_set_req_set_lanes(struct ethtool_linkmodes_set_req *req,
879 __u32 lanes)
880{
881 req->_present.lanes = 1;
882 req->lanes = lanes;
883}
884static inline void
885ethtool_linkmodes_set_req_set_rate_matching(struct ethtool_linkmodes_set_req *req,
886 __u8 rate_matching)
887{
888 req->_present.rate_matching = 1;
889 req->rate_matching = rate_matching;
890}
891
892/*
893 * Set link modes.
894 */
895int ethtool_linkmodes_set(struct ynl_sock *ys,
896 struct ethtool_linkmodes_set_req *req);
897
898/* ============== ETHTOOL_MSG_LINKSTATE_GET ============== */
899/* ETHTOOL_MSG_LINKSTATE_GET - do */
900struct ethtool_linkstate_get_req {
901 struct {
902 __u32 header:1;
903 } _present;
904
905 struct ethtool_header header;
906};
907
908static inline struct ethtool_linkstate_get_req *
909ethtool_linkstate_get_req_alloc(void)
910{
911 return calloc(1, sizeof(struct ethtool_linkstate_get_req));
912}
913void ethtool_linkstate_get_req_free(struct ethtool_linkstate_get_req *req);
914
915static inline void
916ethtool_linkstate_get_req_set_header_dev_index(struct ethtool_linkstate_get_req *req,
917 __u32 dev_index)
918{
919 req->_present.header = 1;
920 req->header._present.dev_index = 1;
921 req->header.dev_index = dev_index;
922}
923static inline void
924ethtool_linkstate_get_req_set_header_dev_name(struct ethtool_linkstate_get_req *req,
925 const char *dev_name)
926{
927 free(req->header.dev_name);
928 req->header._present.dev_name_len = strlen(dev_name);
929 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
930 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
931 req->header.dev_name[req->header._present.dev_name_len] = 0;
932}
933static inline void
934ethtool_linkstate_get_req_set_header_flags(struct ethtool_linkstate_get_req *req,
935 __u32 flags)
936{
937 req->_present.header = 1;
938 req->header._present.flags = 1;
939 req->header.flags = flags;
940}
941
942struct ethtool_linkstate_get_rsp {
943 struct {
944 __u32 header:1;
945 __u32 link:1;
946 __u32 sqi:1;
947 __u32 sqi_max:1;
948 __u32 ext_state:1;
949 __u32 ext_substate:1;
950 __u32 ext_down_cnt:1;
951 } _present;
952
953 struct ethtool_header header;
954 __u8 link;
955 __u32 sqi;
956 __u32 sqi_max;
957 __u8 ext_state;
958 __u8 ext_substate;
959 __u32 ext_down_cnt;
960};
961
962void ethtool_linkstate_get_rsp_free(struct ethtool_linkstate_get_rsp *rsp);
963
964/*
965 * Get link state.
966 */
967struct ethtool_linkstate_get_rsp *
968ethtool_linkstate_get(struct ynl_sock *ys,
969 struct ethtool_linkstate_get_req *req);
970
971/* ETHTOOL_MSG_LINKSTATE_GET - dump */
972struct ethtool_linkstate_get_req_dump {
973 struct {
974 __u32 header:1;
975 } _present;
976
977 struct ethtool_header header;
978};
979
980static inline struct ethtool_linkstate_get_req_dump *
981ethtool_linkstate_get_req_dump_alloc(void)
982{
983 return calloc(1, sizeof(struct ethtool_linkstate_get_req_dump));
984}
985void
986ethtool_linkstate_get_req_dump_free(struct ethtool_linkstate_get_req_dump *req);
987
988static inline void
989ethtool_linkstate_get_req_dump_set_header_dev_index(struct ethtool_linkstate_get_req_dump *req,
990 __u32 dev_index)
991{
992 req->_present.header = 1;
993 req->header._present.dev_index = 1;
994 req->header.dev_index = dev_index;
995}
996static inline void
997ethtool_linkstate_get_req_dump_set_header_dev_name(struct ethtool_linkstate_get_req_dump *req,
998 const char *dev_name)
999{
1000 free(req->header.dev_name);
1001 req->header._present.dev_name_len = strlen(dev_name);
1002 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
1003 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
1004 req->header.dev_name[req->header._present.dev_name_len] = 0;
1005}
1006static inline void
1007ethtool_linkstate_get_req_dump_set_header_flags(struct ethtool_linkstate_get_req_dump *req,
1008 __u32 flags)
1009{
1010 req->_present.header = 1;
1011 req->header._present.flags = 1;
1012 req->header.flags = flags;
1013}
1014
1015struct ethtool_linkstate_get_list {
1016 struct ethtool_linkstate_get_list *next;
1017 struct ethtool_linkstate_get_rsp obj __attribute__ ((aligned (8)));
1018};
1019
1020void ethtool_linkstate_get_list_free(struct ethtool_linkstate_get_list *rsp);
1021
1022struct ethtool_linkstate_get_list *
1023ethtool_linkstate_get_dump(struct ynl_sock *ys,
1024 struct ethtool_linkstate_get_req_dump *req);
1025
1026/* ============== ETHTOOL_MSG_DEBUG_GET ============== */
1027/* ETHTOOL_MSG_DEBUG_GET - do */
1028struct ethtool_debug_get_req {
1029 struct {
1030 __u32 header:1;
1031 } _present;
1032
1033 struct ethtool_header header;
1034};
1035
1036static inline struct ethtool_debug_get_req *ethtool_debug_get_req_alloc(void)
1037{
1038 return calloc(1, sizeof(struct ethtool_debug_get_req));
1039}
1040void ethtool_debug_get_req_free(struct ethtool_debug_get_req *req);
1041
1042static inline void
1043ethtool_debug_get_req_set_header_dev_index(struct ethtool_debug_get_req *req,
1044 __u32 dev_index)
1045{
1046 req->_present.header = 1;
1047 req->header._present.dev_index = 1;
1048 req->header.dev_index = dev_index;
1049}
1050static inline void
1051ethtool_debug_get_req_set_header_dev_name(struct ethtool_debug_get_req *req,
1052 const char *dev_name)
1053{
1054 free(req->header.dev_name);
1055 req->header._present.dev_name_len = strlen(dev_name);
1056 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
1057 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
1058 req->header.dev_name[req->header._present.dev_name_len] = 0;
1059}
1060static inline void
1061ethtool_debug_get_req_set_header_flags(struct ethtool_debug_get_req *req,
1062 __u32 flags)
1063{
1064 req->_present.header = 1;
1065 req->header._present.flags = 1;
1066 req->header.flags = flags;
1067}
1068
1069struct ethtool_debug_get_rsp {
1070 struct {
1071 __u32 header:1;
1072 __u32 msgmask:1;
1073 } _present;
1074
1075 struct ethtool_header header;
1076 struct ethtool_bitset msgmask;
1077};
1078
1079void ethtool_debug_get_rsp_free(struct ethtool_debug_get_rsp *rsp);
1080
1081/*
1082 * Get debug message mask.
1083 */
1084struct ethtool_debug_get_rsp *
1085ethtool_debug_get(struct ynl_sock *ys, struct ethtool_debug_get_req *req);
1086
1087/* ETHTOOL_MSG_DEBUG_GET - dump */
1088struct ethtool_debug_get_req_dump {
1089 struct {
1090 __u32 header:1;
1091 } _present;
1092
1093 struct ethtool_header header;
1094};
1095
1096static inline struct ethtool_debug_get_req_dump *
1097ethtool_debug_get_req_dump_alloc(void)
1098{
1099 return calloc(1, sizeof(struct ethtool_debug_get_req_dump));
1100}
1101void ethtool_debug_get_req_dump_free(struct ethtool_debug_get_req_dump *req);
1102
1103static inline void
1104ethtool_debug_get_req_dump_set_header_dev_index(struct ethtool_debug_get_req_dump *req,
1105 __u32 dev_index)
1106{
1107 req->_present.header = 1;
1108 req->header._present.dev_index = 1;
1109 req->header.dev_index = dev_index;
1110}
1111static inline void
1112ethtool_debug_get_req_dump_set_header_dev_name(struct ethtool_debug_get_req_dump *req,
1113 const char *dev_name)
1114{
1115 free(req->header.dev_name);
1116 req->header._present.dev_name_len = strlen(dev_name);
1117 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
1118 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
1119 req->header.dev_name[req->header._present.dev_name_len] = 0;
1120}
1121static inline void
1122ethtool_debug_get_req_dump_set_header_flags(struct ethtool_debug_get_req_dump *req,
1123 __u32 flags)
1124{
1125 req->_present.header = 1;
1126 req->header._present.flags = 1;
1127 req->header.flags = flags;
1128}
1129
1130struct ethtool_debug_get_list {
1131 struct ethtool_debug_get_list *next;
1132 struct ethtool_debug_get_rsp obj __attribute__ ((aligned (8)));
1133};
1134
1135void ethtool_debug_get_list_free(struct ethtool_debug_get_list *rsp);
1136
1137struct ethtool_debug_get_list *
1138ethtool_debug_get_dump(struct ynl_sock *ys,
1139 struct ethtool_debug_get_req_dump *req);
1140
1141/* ETHTOOL_MSG_DEBUG_GET - notify */
1142struct ethtool_debug_get_ntf {
1143 __u16 family;
1144 __u8 cmd;
1145 struct ynl_ntf_base_type *next;
1146 void (*free)(struct ethtool_debug_get_ntf *ntf);
1147 struct ethtool_debug_get_rsp obj __attribute__ ((aligned (8)));
1148};
1149
1150void ethtool_debug_get_ntf_free(struct ethtool_debug_get_ntf *rsp);
1151
1152/* ============== ETHTOOL_MSG_DEBUG_SET ============== */
1153/* ETHTOOL_MSG_DEBUG_SET - do */
1154struct ethtool_debug_set_req {
1155 struct {
1156 __u32 header:1;
1157 __u32 msgmask:1;
1158 } _present;
1159
1160 struct ethtool_header header;
1161 struct ethtool_bitset msgmask;
1162};
1163
1164static inline struct ethtool_debug_set_req *ethtool_debug_set_req_alloc(void)
1165{
1166 return calloc(1, sizeof(struct ethtool_debug_set_req));
1167}
1168void ethtool_debug_set_req_free(struct ethtool_debug_set_req *req);
1169
1170static inline void
1171ethtool_debug_set_req_set_header_dev_index(struct ethtool_debug_set_req *req,
1172 __u32 dev_index)
1173{
1174 req->_present.header = 1;
1175 req->header._present.dev_index = 1;
1176 req->header.dev_index = dev_index;
1177}
1178static inline void
1179ethtool_debug_set_req_set_header_dev_name(struct ethtool_debug_set_req *req,
1180 const char *dev_name)
1181{
1182 free(req->header.dev_name);
1183 req->header._present.dev_name_len = strlen(dev_name);
1184 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
1185 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
1186 req->header.dev_name[req->header._present.dev_name_len] = 0;
1187}
1188static inline void
1189ethtool_debug_set_req_set_header_flags(struct ethtool_debug_set_req *req,
1190 __u32 flags)
1191{
1192 req->_present.header = 1;
1193 req->header._present.flags = 1;
1194 req->header.flags = flags;
1195}
1196static inline void
1197ethtool_debug_set_req_set_msgmask_nomask(struct ethtool_debug_set_req *req)
1198{
1199 req->_present.msgmask = 1;
1200 req->msgmask._present.nomask = 1;
1201}
1202static inline void
1203ethtool_debug_set_req_set_msgmask_size(struct ethtool_debug_set_req *req,
1204 __u32 size)
1205{
1206 req->_present.msgmask = 1;
1207 req->msgmask._present.size = 1;
1208 req->msgmask.size = size;
1209}
1210static inline void
1211__ethtool_debug_set_req_set_msgmask_bits_bit(struct ethtool_debug_set_req *req,
1212 struct ethtool_bitset_bit *bit,
1213 unsigned int n_bit)
1214{
1215 free(req->msgmask.bits.bit);
1216 req->msgmask.bits.bit = bit;
1217 req->msgmask.bits.n_bit = n_bit;
1218}
1219
1220/*
1221 * Set debug message mask.
1222 */
1223int ethtool_debug_set(struct ynl_sock *ys, struct ethtool_debug_set_req *req);
1224
1225/* ============== ETHTOOL_MSG_WOL_GET ============== */
1226/* ETHTOOL_MSG_WOL_GET - do */
1227struct ethtool_wol_get_req {
1228 struct {
1229 __u32 header:1;
1230 } _present;
1231
1232 struct ethtool_header header;
1233};
1234
1235static inline struct ethtool_wol_get_req *ethtool_wol_get_req_alloc(void)
1236{
1237 return calloc(1, sizeof(struct ethtool_wol_get_req));
1238}
1239void ethtool_wol_get_req_free(struct ethtool_wol_get_req *req);
1240
1241static inline void
1242ethtool_wol_get_req_set_header_dev_index(struct ethtool_wol_get_req *req,
1243 __u32 dev_index)
1244{
1245 req->_present.header = 1;
1246 req->header._present.dev_index = 1;
1247 req->header.dev_index = dev_index;
1248}
1249static inline void
1250ethtool_wol_get_req_set_header_dev_name(struct ethtool_wol_get_req *req,
1251 const char *dev_name)
1252{
1253 free(req->header.dev_name);
1254 req->header._present.dev_name_len = strlen(dev_name);
1255 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
1256 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
1257 req->header.dev_name[req->header._present.dev_name_len] = 0;
1258}
1259static inline void
1260ethtool_wol_get_req_set_header_flags(struct ethtool_wol_get_req *req,
1261 __u32 flags)
1262{
1263 req->_present.header = 1;
1264 req->header._present.flags = 1;
1265 req->header.flags = flags;
1266}
1267
1268struct ethtool_wol_get_rsp {
1269 struct {
1270 __u32 header:1;
1271 __u32 modes:1;
1272 __u32 sopass_len;
1273 } _present;
1274
1275 struct ethtool_header header;
1276 struct ethtool_bitset modes;
1277 void *sopass;
1278};
1279
1280void ethtool_wol_get_rsp_free(struct ethtool_wol_get_rsp *rsp);
1281
1282/*
1283 * Get WOL params.
1284 */
1285struct ethtool_wol_get_rsp *
1286ethtool_wol_get(struct ynl_sock *ys, struct ethtool_wol_get_req *req);
1287
1288/* ETHTOOL_MSG_WOL_GET - dump */
1289struct ethtool_wol_get_req_dump {
1290 struct {
1291 __u32 header:1;
1292 } _present;
1293
1294 struct ethtool_header header;
1295};
1296
1297static inline struct ethtool_wol_get_req_dump *
1298ethtool_wol_get_req_dump_alloc(void)
1299{
1300 return calloc(1, sizeof(struct ethtool_wol_get_req_dump));
1301}
1302void ethtool_wol_get_req_dump_free(struct ethtool_wol_get_req_dump *req);
1303
1304static inline void
1305ethtool_wol_get_req_dump_set_header_dev_index(struct ethtool_wol_get_req_dump *req,
1306 __u32 dev_index)
1307{
1308 req->_present.header = 1;
1309 req->header._present.dev_index = 1;
1310 req->header.dev_index = dev_index;
1311}
1312static inline void
1313ethtool_wol_get_req_dump_set_header_dev_name(struct ethtool_wol_get_req_dump *req,
1314 const char *dev_name)
1315{
1316 free(req->header.dev_name);
1317 req->header._present.dev_name_len = strlen(dev_name);
1318 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
1319 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
1320 req->header.dev_name[req->header._present.dev_name_len] = 0;
1321}
1322static inline void
1323ethtool_wol_get_req_dump_set_header_flags(struct ethtool_wol_get_req_dump *req,
1324 __u32 flags)
1325{
1326 req->_present.header = 1;
1327 req->header._present.flags = 1;
1328 req->header.flags = flags;
1329}
1330
1331struct ethtool_wol_get_list {
1332 struct ethtool_wol_get_list *next;
1333 struct ethtool_wol_get_rsp obj __attribute__ ((aligned (8)));
1334};
1335
1336void ethtool_wol_get_list_free(struct ethtool_wol_get_list *rsp);
1337
1338struct ethtool_wol_get_list *
1339ethtool_wol_get_dump(struct ynl_sock *ys, struct ethtool_wol_get_req_dump *req);
1340
1341/* ETHTOOL_MSG_WOL_GET - notify */
1342struct ethtool_wol_get_ntf {
1343 __u16 family;
1344 __u8 cmd;
1345 struct ynl_ntf_base_type *next;
1346 void (*free)(struct ethtool_wol_get_ntf *ntf);
1347 struct ethtool_wol_get_rsp obj __attribute__ ((aligned (8)));
1348};
1349
1350void ethtool_wol_get_ntf_free(struct ethtool_wol_get_ntf *rsp);
1351
1352/* ============== ETHTOOL_MSG_WOL_SET ============== */
1353/* ETHTOOL_MSG_WOL_SET - do */
1354struct ethtool_wol_set_req {
1355 struct {
1356 __u32 header:1;
1357 __u32 modes:1;
1358 __u32 sopass_len;
1359 } _present;
1360
1361 struct ethtool_header header;
1362 struct ethtool_bitset modes;
1363 void *sopass;
1364};
1365
1366static inline struct ethtool_wol_set_req *ethtool_wol_set_req_alloc(void)
1367{
1368 return calloc(1, sizeof(struct ethtool_wol_set_req));
1369}
1370void ethtool_wol_set_req_free(struct ethtool_wol_set_req *req);
1371
1372static inline void
1373ethtool_wol_set_req_set_header_dev_index(struct ethtool_wol_set_req *req,
1374 __u32 dev_index)
1375{
1376 req->_present.header = 1;
1377 req->header._present.dev_index = 1;
1378 req->header.dev_index = dev_index;
1379}
1380static inline void
1381ethtool_wol_set_req_set_header_dev_name(struct ethtool_wol_set_req *req,
1382 const char *dev_name)
1383{
1384 free(req->header.dev_name);
1385 req->header._present.dev_name_len = strlen(dev_name);
1386 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
1387 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
1388 req->header.dev_name[req->header._present.dev_name_len] = 0;
1389}
1390static inline void
1391ethtool_wol_set_req_set_header_flags(struct ethtool_wol_set_req *req,
1392 __u32 flags)
1393{
1394 req->_present.header = 1;
1395 req->header._present.flags = 1;
1396 req->header.flags = flags;
1397}
1398static inline void
1399ethtool_wol_set_req_set_modes_nomask(struct ethtool_wol_set_req *req)
1400{
1401 req->_present.modes = 1;
1402 req->modes._present.nomask = 1;
1403}
1404static inline void
1405ethtool_wol_set_req_set_modes_size(struct ethtool_wol_set_req *req, __u32 size)
1406{
1407 req->_present.modes = 1;
1408 req->modes._present.size = 1;
1409 req->modes.size = size;
1410}
1411static inline void
1412__ethtool_wol_set_req_set_modes_bits_bit(struct ethtool_wol_set_req *req,
1413 struct ethtool_bitset_bit *bit,
1414 unsigned int n_bit)
1415{
1416 free(req->modes.bits.bit);
1417 req->modes.bits.bit = bit;
1418 req->modes.bits.n_bit = n_bit;
1419}
1420static inline void
1421ethtool_wol_set_req_set_sopass(struct ethtool_wol_set_req *req,
1422 const void *sopass, size_t len)
1423{
1424 free(req->sopass);
1425 req->_present.sopass_len = len;
1426 req->sopass = malloc(req->_present.sopass_len);
1427 memcpy(req->sopass, sopass, req->_present.sopass_len);
1428}
1429
1430/*
1431 * Set WOL params.
1432 */
1433int ethtool_wol_set(struct ynl_sock *ys, struct ethtool_wol_set_req *req);
1434
1435/* ============== ETHTOOL_MSG_FEATURES_GET ============== */
1436/* ETHTOOL_MSG_FEATURES_GET - do */
1437struct ethtool_features_get_req {
1438 struct {
1439 __u32 header:1;
1440 } _present;
1441
1442 struct ethtool_header header;
1443};
1444
1445static inline struct ethtool_features_get_req *
1446ethtool_features_get_req_alloc(void)
1447{
1448 return calloc(1, sizeof(struct ethtool_features_get_req));
1449}
1450void ethtool_features_get_req_free(struct ethtool_features_get_req *req);
1451
1452static inline void
1453ethtool_features_get_req_set_header_dev_index(struct ethtool_features_get_req *req,
1454 __u32 dev_index)
1455{
1456 req->_present.header = 1;
1457 req->header._present.dev_index = 1;
1458 req->header.dev_index = dev_index;
1459}
1460static inline void
1461ethtool_features_get_req_set_header_dev_name(struct ethtool_features_get_req *req,
1462 const char *dev_name)
1463{
1464 free(req->header.dev_name);
1465 req->header._present.dev_name_len = strlen(dev_name);
1466 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
1467 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
1468 req->header.dev_name[req->header._present.dev_name_len] = 0;
1469}
1470static inline void
1471ethtool_features_get_req_set_header_flags(struct ethtool_features_get_req *req,
1472 __u32 flags)
1473{
1474 req->_present.header = 1;
1475 req->header._present.flags = 1;
1476 req->header.flags = flags;
1477}
1478
1479struct ethtool_features_get_rsp {
1480 struct {
1481 __u32 header:1;
1482 __u32 hw:1;
1483 __u32 wanted:1;
1484 __u32 active:1;
1485 __u32 nochange:1;
1486 } _present;
1487
1488 struct ethtool_header header;
1489 struct ethtool_bitset hw;
1490 struct ethtool_bitset wanted;
1491 struct ethtool_bitset active;
1492 struct ethtool_bitset nochange;
1493};
1494
1495void ethtool_features_get_rsp_free(struct ethtool_features_get_rsp *rsp);
1496
1497/*
1498 * Get features.
1499 */
1500struct ethtool_features_get_rsp *
1501ethtool_features_get(struct ynl_sock *ys, struct ethtool_features_get_req *req);
1502
1503/* ETHTOOL_MSG_FEATURES_GET - dump */
1504struct ethtool_features_get_req_dump {
1505 struct {
1506 __u32 header:1;
1507 } _present;
1508
1509 struct ethtool_header header;
1510};
1511
1512static inline struct ethtool_features_get_req_dump *
1513ethtool_features_get_req_dump_alloc(void)
1514{
1515 return calloc(1, sizeof(struct ethtool_features_get_req_dump));
1516}
1517void
1518ethtool_features_get_req_dump_free(struct ethtool_features_get_req_dump *req);
1519
1520static inline void
1521ethtool_features_get_req_dump_set_header_dev_index(struct ethtool_features_get_req_dump *req,
1522 __u32 dev_index)
1523{
1524 req->_present.header = 1;
1525 req->header._present.dev_index = 1;
1526 req->header.dev_index = dev_index;
1527}
1528static inline void
1529ethtool_features_get_req_dump_set_header_dev_name(struct ethtool_features_get_req_dump *req,
1530 const char *dev_name)
1531{
1532 free(req->header.dev_name);
1533 req->header._present.dev_name_len = strlen(dev_name);
1534 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
1535 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
1536 req->header.dev_name[req->header._present.dev_name_len] = 0;
1537}
1538static inline void
1539ethtool_features_get_req_dump_set_header_flags(struct ethtool_features_get_req_dump *req,
1540 __u32 flags)
1541{
1542 req->_present.header = 1;
1543 req->header._present.flags = 1;
1544 req->header.flags = flags;
1545}
1546
1547struct ethtool_features_get_list {
1548 struct ethtool_features_get_list *next;
1549 struct ethtool_features_get_rsp obj __attribute__ ((aligned (8)));
1550};
1551
1552void ethtool_features_get_list_free(struct ethtool_features_get_list *rsp);
1553
1554struct ethtool_features_get_list *
1555ethtool_features_get_dump(struct ynl_sock *ys,
1556 struct ethtool_features_get_req_dump *req);
1557
1558/* ETHTOOL_MSG_FEATURES_GET - notify */
1559struct ethtool_features_get_ntf {
1560 __u16 family;
1561 __u8 cmd;
1562 struct ynl_ntf_base_type *next;
1563 void (*free)(struct ethtool_features_get_ntf *ntf);
1564 struct ethtool_features_get_rsp obj __attribute__ ((aligned (8)));
1565};
1566
1567void ethtool_features_get_ntf_free(struct ethtool_features_get_ntf *rsp);
1568
1569/* ============== ETHTOOL_MSG_FEATURES_SET ============== */
1570/* ETHTOOL_MSG_FEATURES_SET - do */
1571struct ethtool_features_set_req {
1572 struct {
1573 __u32 header:1;
1574 __u32 hw:1;
1575 __u32 wanted:1;
1576 __u32 active:1;
1577 __u32 nochange:1;
1578 } _present;
1579
1580 struct ethtool_header header;
1581 struct ethtool_bitset hw;
1582 struct ethtool_bitset wanted;
1583 struct ethtool_bitset active;
1584 struct ethtool_bitset nochange;
1585};
1586
1587static inline struct ethtool_features_set_req *
1588ethtool_features_set_req_alloc(void)
1589{
1590 return calloc(1, sizeof(struct ethtool_features_set_req));
1591}
1592void ethtool_features_set_req_free(struct ethtool_features_set_req *req);
1593
1594static inline void
1595ethtool_features_set_req_set_header_dev_index(struct ethtool_features_set_req *req,
1596 __u32 dev_index)
1597{
1598 req->_present.header = 1;
1599 req->header._present.dev_index = 1;
1600 req->header.dev_index = dev_index;
1601}
1602static inline void
1603ethtool_features_set_req_set_header_dev_name(struct ethtool_features_set_req *req,
1604 const char *dev_name)
1605{
1606 free(req->header.dev_name);
1607 req->header._present.dev_name_len = strlen(dev_name);
1608 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
1609 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
1610 req->header.dev_name[req->header._present.dev_name_len] = 0;
1611}
1612static inline void
1613ethtool_features_set_req_set_header_flags(struct ethtool_features_set_req *req,
1614 __u32 flags)
1615{
1616 req->_present.header = 1;
1617 req->header._present.flags = 1;
1618 req->header.flags = flags;
1619}
1620static inline void
1621ethtool_features_set_req_set_hw_nomask(struct ethtool_features_set_req *req)
1622{
1623 req->_present.hw = 1;
1624 req->hw._present.nomask = 1;
1625}
1626static inline void
1627ethtool_features_set_req_set_hw_size(struct ethtool_features_set_req *req,
1628 __u32 size)
1629{
1630 req->_present.hw = 1;
1631 req->hw._present.size = 1;
1632 req->hw.size = size;
1633}
1634static inline void
1635__ethtool_features_set_req_set_hw_bits_bit(struct ethtool_features_set_req *req,
1636 struct ethtool_bitset_bit *bit,
1637 unsigned int n_bit)
1638{
1639 free(req->hw.bits.bit);
1640 req->hw.bits.bit = bit;
1641 req->hw.bits.n_bit = n_bit;
1642}
1643static inline void
1644ethtool_features_set_req_set_wanted_nomask(struct ethtool_features_set_req *req)
1645{
1646 req->_present.wanted = 1;
1647 req->wanted._present.nomask = 1;
1648}
1649static inline void
1650ethtool_features_set_req_set_wanted_size(struct ethtool_features_set_req *req,
1651 __u32 size)
1652{
1653 req->_present.wanted = 1;
1654 req->wanted._present.size = 1;
1655 req->wanted.size = size;
1656}
1657static inline void
1658__ethtool_features_set_req_set_wanted_bits_bit(struct ethtool_features_set_req *req,
1659 struct ethtool_bitset_bit *bit,
1660 unsigned int n_bit)
1661{
1662 free(req->wanted.bits.bit);
1663 req->wanted.bits.bit = bit;
1664 req->wanted.bits.n_bit = n_bit;
1665}
1666static inline void
1667ethtool_features_set_req_set_active_nomask(struct ethtool_features_set_req *req)
1668{
1669 req->_present.active = 1;
1670 req->active._present.nomask = 1;
1671}
1672static inline void
1673ethtool_features_set_req_set_active_size(struct ethtool_features_set_req *req,
1674 __u32 size)
1675{
1676 req->_present.active = 1;
1677 req->active._present.size = 1;
1678 req->active.size = size;
1679}
1680static inline void
1681__ethtool_features_set_req_set_active_bits_bit(struct ethtool_features_set_req *req,
1682 struct ethtool_bitset_bit *bit,
1683 unsigned int n_bit)
1684{
1685 free(req->active.bits.bit);
1686 req->active.bits.bit = bit;
1687 req->active.bits.n_bit = n_bit;
1688}
1689static inline void
1690ethtool_features_set_req_set_nochange_nomask(struct ethtool_features_set_req *req)
1691{
1692 req->_present.nochange = 1;
1693 req->nochange._present.nomask = 1;
1694}
1695static inline void
1696ethtool_features_set_req_set_nochange_size(struct ethtool_features_set_req *req,
1697 __u32 size)
1698{
1699 req->_present.nochange = 1;
1700 req->nochange._present.size = 1;
1701 req->nochange.size = size;
1702}
1703static inline void
1704__ethtool_features_set_req_set_nochange_bits_bit(struct ethtool_features_set_req *req,
1705 struct ethtool_bitset_bit *bit,
1706 unsigned int n_bit)
1707{
1708 free(req->nochange.bits.bit);
1709 req->nochange.bits.bit = bit;
1710 req->nochange.bits.n_bit = n_bit;
1711}
1712
1713struct ethtool_features_set_rsp {
1714 struct {
1715 __u32 header:1;
1716 __u32 hw:1;
1717 __u32 wanted:1;
1718 __u32 active:1;
1719 __u32 nochange:1;
1720 } _present;
1721
1722 struct ethtool_header header;
1723 struct ethtool_bitset hw;
1724 struct ethtool_bitset wanted;
1725 struct ethtool_bitset active;
1726 struct ethtool_bitset nochange;
1727};
1728
1729void ethtool_features_set_rsp_free(struct ethtool_features_set_rsp *rsp);
1730
1731/*
1732 * Set features.
1733 */
1734struct ethtool_features_set_rsp *
1735ethtool_features_set(struct ynl_sock *ys, struct ethtool_features_set_req *req);
1736
1737/* ============== ETHTOOL_MSG_PRIVFLAGS_GET ============== */
1738/* ETHTOOL_MSG_PRIVFLAGS_GET - do */
1739struct ethtool_privflags_get_req {
1740 struct {
1741 __u32 header:1;
1742 } _present;
1743
1744 struct ethtool_header header;
1745};
1746
1747static inline struct ethtool_privflags_get_req *
1748ethtool_privflags_get_req_alloc(void)
1749{
1750 return calloc(1, sizeof(struct ethtool_privflags_get_req));
1751}
1752void ethtool_privflags_get_req_free(struct ethtool_privflags_get_req *req);
1753
1754static inline void
1755ethtool_privflags_get_req_set_header_dev_index(struct ethtool_privflags_get_req *req,
1756 __u32 dev_index)
1757{
1758 req->_present.header = 1;
1759 req->header._present.dev_index = 1;
1760 req->header.dev_index = dev_index;
1761}
1762static inline void
1763ethtool_privflags_get_req_set_header_dev_name(struct ethtool_privflags_get_req *req,
1764 const char *dev_name)
1765{
1766 free(req->header.dev_name);
1767 req->header._present.dev_name_len = strlen(dev_name);
1768 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
1769 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
1770 req->header.dev_name[req->header._present.dev_name_len] = 0;
1771}
1772static inline void
1773ethtool_privflags_get_req_set_header_flags(struct ethtool_privflags_get_req *req,
1774 __u32 flags)
1775{
1776 req->_present.header = 1;
1777 req->header._present.flags = 1;
1778 req->header.flags = flags;
1779}
1780
1781struct ethtool_privflags_get_rsp {
1782 struct {
1783 __u32 header:1;
1784 __u32 flags:1;
1785 } _present;
1786
1787 struct ethtool_header header;
1788 struct ethtool_bitset flags;
1789};
1790
1791void ethtool_privflags_get_rsp_free(struct ethtool_privflags_get_rsp *rsp);
1792
1793/*
1794 * Get device private flags.
1795 */
1796struct ethtool_privflags_get_rsp *
1797ethtool_privflags_get(struct ynl_sock *ys,
1798 struct ethtool_privflags_get_req *req);
1799
1800/* ETHTOOL_MSG_PRIVFLAGS_GET - dump */
1801struct ethtool_privflags_get_req_dump {
1802 struct {
1803 __u32 header:1;
1804 } _present;
1805
1806 struct ethtool_header header;
1807};
1808
1809static inline struct ethtool_privflags_get_req_dump *
1810ethtool_privflags_get_req_dump_alloc(void)
1811{
1812 return calloc(1, sizeof(struct ethtool_privflags_get_req_dump));
1813}
1814void
1815ethtool_privflags_get_req_dump_free(struct ethtool_privflags_get_req_dump *req);
1816
1817static inline void
1818ethtool_privflags_get_req_dump_set_header_dev_index(struct ethtool_privflags_get_req_dump *req,
1819 __u32 dev_index)
1820{
1821 req->_present.header = 1;
1822 req->header._present.dev_index = 1;
1823 req->header.dev_index = dev_index;
1824}
1825static inline void
1826ethtool_privflags_get_req_dump_set_header_dev_name(struct ethtool_privflags_get_req_dump *req,
1827 const char *dev_name)
1828{
1829 free(req->header.dev_name);
1830 req->header._present.dev_name_len = strlen(dev_name);
1831 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
1832 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
1833 req->header.dev_name[req->header._present.dev_name_len] = 0;
1834}
1835static inline void
1836ethtool_privflags_get_req_dump_set_header_flags(struct ethtool_privflags_get_req_dump *req,
1837 __u32 flags)
1838{
1839 req->_present.header = 1;
1840 req->header._present.flags = 1;
1841 req->header.flags = flags;
1842}
1843
1844struct ethtool_privflags_get_list {
1845 struct ethtool_privflags_get_list *next;
1846 struct ethtool_privflags_get_rsp obj __attribute__ ((aligned (8)));
1847};
1848
1849void ethtool_privflags_get_list_free(struct ethtool_privflags_get_list *rsp);
1850
1851struct ethtool_privflags_get_list *
1852ethtool_privflags_get_dump(struct ynl_sock *ys,
1853 struct ethtool_privflags_get_req_dump *req);
1854
1855/* ETHTOOL_MSG_PRIVFLAGS_GET - notify */
1856struct ethtool_privflags_get_ntf {
1857 __u16 family;
1858 __u8 cmd;
1859 struct ynl_ntf_base_type *next;
1860 void (*free)(struct ethtool_privflags_get_ntf *ntf);
1861 struct ethtool_privflags_get_rsp obj __attribute__ ((aligned (8)));
1862};
1863
1864void ethtool_privflags_get_ntf_free(struct ethtool_privflags_get_ntf *rsp);
1865
1866/* ============== ETHTOOL_MSG_PRIVFLAGS_SET ============== */
1867/* ETHTOOL_MSG_PRIVFLAGS_SET - do */
1868struct ethtool_privflags_set_req {
1869 struct {
1870 __u32 header:1;
1871 __u32 flags:1;
1872 } _present;
1873
1874 struct ethtool_header header;
1875 struct ethtool_bitset flags;
1876};
1877
1878static inline struct ethtool_privflags_set_req *
1879ethtool_privflags_set_req_alloc(void)
1880{
1881 return calloc(1, sizeof(struct ethtool_privflags_set_req));
1882}
1883void ethtool_privflags_set_req_free(struct ethtool_privflags_set_req *req);
1884
1885static inline void
1886ethtool_privflags_set_req_set_header_dev_index(struct ethtool_privflags_set_req *req,
1887 __u32 dev_index)
1888{
1889 req->_present.header = 1;
1890 req->header._present.dev_index = 1;
1891 req->header.dev_index = dev_index;
1892}
1893static inline void
1894ethtool_privflags_set_req_set_header_dev_name(struct ethtool_privflags_set_req *req,
1895 const char *dev_name)
1896{
1897 free(req->header.dev_name);
1898 req->header._present.dev_name_len = strlen(dev_name);
1899 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
1900 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
1901 req->header.dev_name[req->header._present.dev_name_len] = 0;
1902}
1903static inline void
1904ethtool_privflags_set_req_set_header_flags(struct ethtool_privflags_set_req *req,
1905 __u32 flags)
1906{
1907 req->_present.header = 1;
1908 req->header._present.flags = 1;
1909 req->header.flags = flags;
1910}
1911static inline void
1912ethtool_privflags_set_req_set_flags_nomask(struct ethtool_privflags_set_req *req)
1913{
1914 req->_present.flags = 1;
1915 req->flags._present.nomask = 1;
1916}
1917static inline void
1918ethtool_privflags_set_req_set_flags_size(struct ethtool_privflags_set_req *req,
1919 __u32 size)
1920{
1921 req->_present.flags = 1;
1922 req->flags._present.size = 1;
1923 req->flags.size = size;
1924}
1925static inline void
1926__ethtool_privflags_set_req_set_flags_bits_bit(struct ethtool_privflags_set_req *req,
1927 struct ethtool_bitset_bit *bit,
1928 unsigned int n_bit)
1929{
1930 free(req->flags.bits.bit);
1931 req->flags.bits.bit = bit;
1932 req->flags.bits.n_bit = n_bit;
1933}
1934
1935/*
1936 * Set device private flags.
1937 */
1938int ethtool_privflags_set(struct ynl_sock *ys,
1939 struct ethtool_privflags_set_req *req);
1940
1941/* ============== ETHTOOL_MSG_RINGS_GET ============== */
1942/* ETHTOOL_MSG_RINGS_GET - do */
1943struct ethtool_rings_get_req {
1944 struct {
1945 __u32 header:1;
1946 } _present;
1947
1948 struct ethtool_header header;
1949};
1950
1951static inline struct ethtool_rings_get_req *ethtool_rings_get_req_alloc(void)
1952{
1953 return calloc(1, sizeof(struct ethtool_rings_get_req));
1954}
1955void ethtool_rings_get_req_free(struct ethtool_rings_get_req *req);
1956
1957static inline void
1958ethtool_rings_get_req_set_header_dev_index(struct ethtool_rings_get_req *req,
1959 __u32 dev_index)
1960{
1961 req->_present.header = 1;
1962 req->header._present.dev_index = 1;
1963 req->header.dev_index = dev_index;
1964}
1965static inline void
1966ethtool_rings_get_req_set_header_dev_name(struct ethtool_rings_get_req *req,
1967 const char *dev_name)
1968{
1969 free(req->header.dev_name);
1970 req->header._present.dev_name_len = strlen(dev_name);
1971 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
1972 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
1973 req->header.dev_name[req->header._present.dev_name_len] = 0;
1974}
1975static inline void
1976ethtool_rings_get_req_set_header_flags(struct ethtool_rings_get_req *req,
1977 __u32 flags)
1978{
1979 req->_present.header = 1;
1980 req->header._present.flags = 1;
1981 req->header.flags = flags;
1982}
1983
1984struct ethtool_rings_get_rsp {
1985 struct {
1986 __u32 header:1;
1987 __u32 rx_max:1;
1988 __u32 rx_mini_max:1;
1989 __u32 rx_jumbo_max:1;
1990 __u32 tx_max:1;
1991 __u32 rx:1;
1992 __u32 rx_mini:1;
1993 __u32 rx_jumbo:1;
1994 __u32 tx:1;
1995 __u32 rx_buf_len:1;
1996 __u32 tcp_data_split:1;
1997 __u32 cqe_size:1;
1998 __u32 tx_push:1;
1999 __u32 rx_push:1;
2000 __u32 tx_push_buf_len:1;
2001 __u32 tx_push_buf_len_max:1;
2002 } _present;
2003
2004 struct ethtool_header header;
2005 __u32 rx_max;
2006 __u32 rx_mini_max;
2007 __u32 rx_jumbo_max;
2008 __u32 tx_max;
2009 __u32 rx;
2010 __u32 rx_mini;
2011 __u32 rx_jumbo;
2012 __u32 tx;
2013 __u32 rx_buf_len;
2014 __u8 tcp_data_split;
2015 __u32 cqe_size;
2016 __u8 tx_push;
2017 __u8 rx_push;
2018 __u32 tx_push_buf_len;
2019 __u32 tx_push_buf_len_max;
2020};
2021
2022void ethtool_rings_get_rsp_free(struct ethtool_rings_get_rsp *rsp);
2023
2024/*
2025 * Get ring params.
2026 */
2027struct ethtool_rings_get_rsp *
2028ethtool_rings_get(struct ynl_sock *ys, struct ethtool_rings_get_req *req);
2029
2030/* ETHTOOL_MSG_RINGS_GET - dump */
2031struct ethtool_rings_get_req_dump {
2032 struct {
2033 __u32 header:1;
2034 } _present;
2035
2036 struct ethtool_header header;
2037};
2038
2039static inline struct ethtool_rings_get_req_dump *
2040ethtool_rings_get_req_dump_alloc(void)
2041{
2042 return calloc(1, sizeof(struct ethtool_rings_get_req_dump));
2043}
2044void ethtool_rings_get_req_dump_free(struct ethtool_rings_get_req_dump *req);
2045
2046static inline void
2047ethtool_rings_get_req_dump_set_header_dev_index(struct ethtool_rings_get_req_dump *req,
2048 __u32 dev_index)
2049{
2050 req->_present.header = 1;
2051 req->header._present.dev_index = 1;
2052 req->header.dev_index = dev_index;
2053}
2054static inline void
2055ethtool_rings_get_req_dump_set_header_dev_name(struct ethtool_rings_get_req_dump *req,
2056 const char *dev_name)
2057{
2058 free(req->header.dev_name);
2059 req->header._present.dev_name_len = strlen(dev_name);
2060 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
2061 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
2062 req->header.dev_name[req->header._present.dev_name_len] = 0;
2063}
2064static inline void
2065ethtool_rings_get_req_dump_set_header_flags(struct ethtool_rings_get_req_dump *req,
2066 __u32 flags)
2067{
2068 req->_present.header = 1;
2069 req->header._present.flags = 1;
2070 req->header.flags = flags;
2071}
2072
2073struct ethtool_rings_get_list {
2074 struct ethtool_rings_get_list *next;
2075 struct ethtool_rings_get_rsp obj __attribute__ ((aligned (8)));
2076};
2077
2078void ethtool_rings_get_list_free(struct ethtool_rings_get_list *rsp);
2079
2080struct ethtool_rings_get_list *
2081ethtool_rings_get_dump(struct ynl_sock *ys,
2082 struct ethtool_rings_get_req_dump *req);
2083
2084/* ETHTOOL_MSG_RINGS_GET - notify */
2085struct ethtool_rings_get_ntf {
2086 __u16 family;
2087 __u8 cmd;
2088 struct ynl_ntf_base_type *next;
2089 void (*free)(struct ethtool_rings_get_ntf *ntf);
2090 struct ethtool_rings_get_rsp obj __attribute__ ((aligned (8)));
2091};
2092
2093void ethtool_rings_get_ntf_free(struct ethtool_rings_get_ntf *rsp);
2094
2095/* ============== ETHTOOL_MSG_RINGS_SET ============== */
2096/* ETHTOOL_MSG_RINGS_SET - do */
2097struct ethtool_rings_set_req {
2098 struct {
2099 __u32 header:1;
2100 __u32 rx_max:1;
2101 __u32 rx_mini_max:1;
2102 __u32 rx_jumbo_max:1;
2103 __u32 tx_max:1;
2104 __u32 rx:1;
2105 __u32 rx_mini:1;
2106 __u32 rx_jumbo:1;
2107 __u32 tx:1;
2108 __u32 rx_buf_len:1;
2109 __u32 tcp_data_split:1;
2110 __u32 cqe_size:1;
2111 __u32 tx_push:1;
2112 __u32 rx_push:1;
2113 __u32 tx_push_buf_len:1;
2114 __u32 tx_push_buf_len_max:1;
2115 } _present;
2116
2117 struct ethtool_header header;
2118 __u32 rx_max;
2119 __u32 rx_mini_max;
2120 __u32 rx_jumbo_max;
2121 __u32 tx_max;
2122 __u32 rx;
2123 __u32 rx_mini;
2124 __u32 rx_jumbo;
2125 __u32 tx;
2126 __u32 rx_buf_len;
2127 __u8 tcp_data_split;
2128 __u32 cqe_size;
2129 __u8 tx_push;
2130 __u8 rx_push;
2131 __u32 tx_push_buf_len;
2132 __u32 tx_push_buf_len_max;
2133};
2134
2135static inline struct ethtool_rings_set_req *ethtool_rings_set_req_alloc(void)
2136{
2137 return calloc(1, sizeof(struct ethtool_rings_set_req));
2138}
2139void ethtool_rings_set_req_free(struct ethtool_rings_set_req *req);
2140
2141static inline void
2142ethtool_rings_set_req_set_header_dev_index(struct ethtool_rings_set_req *req,
2143 __u32 dev_index)
2144{
2145 req->_present.header = 1;
2146 req->header._present.dev_index = 1;
2147 req->header.dev_index = dev_index;
2148}
2149static inline void
2150ethtool_rings_set_req_set_header_dev_name(struct ethtool_rings_set_req *req,
2151 const char *dev_name)
2152{
2153 free(req->header.dev_name);
2154 req->header._present.dev_name_len = strlen(dev_name);
2155 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
2156 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
2157 req->header.dev_name[req->header._present.dev_name_len] = 0;
2158}
2159static inline void
2160ethtool_rings_set_req_set_header_flags(struct ethtool_rings_set_req *req,
2161 __u32 flags)
2162{
2163 req->_present.header = 1;
2164 req->header._present.flags = 1;
2165 req->header.flags = flags;
2166}
2167static inline void
2168ethtool_rings_set_req_set_rx_max(struct ethtool_rings_set_req *req,
2169 __u32 rx_max)
2170{
2171 req->_present.rx_max = 1;
2172 req->rx_max = rx_max;
2173}
2174static inline void
2175ethtool_rings_set_req_set_rx_mini_max(struct ethtool_rings_set_req *req,
2176 __u32 rx_mini_max)
2177{
2178 req->_present.rx_mini_max = 1;
2179 req->rx_mini_max = rx_mini_max;
2180}
2181static inline void
2182ethtool_rings_set_req_set_rx_jumbo_max(struct ethtool_rings_set_req *req,
2183 __u32 rx_jumbo_max)
2184{
2185 req->_present.rx_jumbo_max = 1;
2186 req->rx_jumbo_max = rx_jumbo_max;
2187}
2188static inline void
2189ethtool_rings_set_req_set_tx_max(struct ethtool_rings_set_req *req,
2190 __u32 tx_max)
2191{
2192 req->_present.tx_max = 1;
2193 req->tx_max = tx_max;
2194}
2195static inline void
2196ethtool_rings_set_req_set_rx(struct ethtool_rings_set_req *req, __u32 rx)
2197{
2198 req->_present.rx = 1;
2199 req->rx = rx;
2200}
2201static inline void
2202ethtool_rings_set_req_set_rx_mini(struct ethtool_rings_set_req *req,
2203 __u32 rx_mini)
2204{
2205 req->_present.rx_mini = 1;
2206 req->rx_mini = rx_mini;
2207}
2208static inline void
2209ethtool_rings_set_req_set_rx_jumbo(struct ethtool_rings_set_req *req,
2210 __u32 rx_jumbo)
2211{
2212 req->_present.rx_jumbo = 1;
2213 req->rx_jumbo = rx_jumbo;
2214}
2215static inline void
2216ethtool_rings_set_req_set_tx(struct ethtool_rings_set_req *req, __u32 tx)
2217{
2218 req->_present.tx = 1;
2219 req->tx = tx;
2220}
2221static inline void
2222ethtool_rings_set_req_set_rx_buf_len(struct ethtool_rings_set_req *req,
2223 __u32 rx_buf_len)
2224{
2225 req->_present.rx_buf_len = 1;
2226 req->rx_buf_len = rx_buf_len;
2227}
2228static inline void
2229ethtool_rings_set_req_set_tcp_data_split(struct ethtool_rings_set_req *req,
2230 __u8 tcp_data_split)
2231{
2232 req->_present.tcp_data_split = 1;
2233 req->tcp_data_split = tcp_data_split;
2234}
2235static inline void
2236ethtool_rings_set_req_set_cqe_size(struct ethtool_rings_set_req *req,
2237 __u32 cqe_size)
2238{
2239 req->_present.cqe_size = 1;
2240 req->cqe_size = cqe_size;
2241}
2242static inline void
2243ethtool_rings_set_req_set_tx_push(struct ethtool_rings_set_req *req,
2244 __u8 tx_push)
2245{
2246 req->_present.tx_push = 1;
2247 req->tx_push = tx_push;
2248}
2249static inline void
2250ethtool_rings_set_req_set_rx_push(struct ethtool_rings_set_req *req,
2251 __u8 rx_push)
2252{
2253 req->_present.rx_push = 1;
2254 req->rx_push = rx_push;
2255}
2256static inline void
2257ethtool_rings_set_req_set_tx_push_buf_len(struct ethtool_rings_set_req *req,
2258 __u32 tx_push_buf_len)
2259{
2260 req->_present.tx_push_buf_len = 1;
2261 req->tx_push_buf_len = tx_push_buf_len;
2262}
2263static inline void
2264ethtool_rings_set_req_set_tx_push_buf_len_max(struct ethtool_rings_set_req *req,
2265 __u32 tx_push_buf_len_max)
2266{
2267 req->_present.tx_push_buf_len_max = 1;
2268 req->tx_push_buf_len_max = tx_push_buf_len_max;
2269}
2270
2271/*
2272 * Set ring params.
2273 */
2274int ethtool_rings_set(struct ynl_sock *ys, struct ethtool_rings_set_req *req);
2275
2276/* ============== ETHTOOL_MSG_CHANNELS_GET ============== */
2277/* ETHTOOL_MSG_CHANNELS_GET - do */
2278struct ethtool_channels_get_req {
2279 struct {
2280 __u32 header:1;
2281 } _present;
2282
2283 struct ethtool_header header;
2284};
2285
2286static inline struct ethtool_channels_get_req *
2287ethtool_channels_get_req_alloc(void)
2288{
2289 return calloc(1, sizeof(struct ethtool_channels_get_req));
2290}
2291void ethtool_channels_get_req_free(struct ethtool_channels_get_req *req);
2292
2293static inline void
2294ethtool_channels_get_req_set_header_dev_index(struct ethtool_channels_get_req *req,
2295 __u32 dev_index)
2296{
2297 req->_present.header = 1;
2298 req->header._present.dev_index = 1;
2299 req->header.dev_index = dev_index;
2300}
2301static inline void
2302ethtool_channels_get_req_set_header_dev_name(struct ethtool_channels_get_req *req,
2303 const char *dev_name)
2304{
2305 free(req->header.dev_name);
2306 req->header._present.dev_name_len = strlen(dev_name);
2307 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
2308 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
2309 req->header.dev_name[req->header._present.dev_name_len] = 0;
2310}
2311static inline void
2312ethtool_channels_get_req_set_header_flags(struct ethtool_channels_get_req *req,
2313 __u32 flags)
2314{
2315 req->_present.header = 1;
2316 req->header._present.flags = 1;
2317 req->header.flags = flags;
2318}
2319
2320struct ethtool_channels_get_rsp {
2321 struct {
2322 __u32 header:1;
2323 __u32 rx_max:1;
2324 __u32 tx_max:1;
2325 __u32 other_max:1;
2326 __u32 combined_max:1;
2327 __u32 rx_count:1;
2328 __u32 tx_count:1;
2329 __u32 other_count:1;
2330 __u32 combined_count:1;
2331 } _present;
2332
2333 struct ethtool_header header;
2334 __u32 rx_max;
2335 __u32 tx_max;
2336 __u32 other_max;
2337 __u32 combined_max;
2338 __u32 rx_count;
2339 __u32 tx_count;
2340 __u32 other_count;
2341 __u32 combined_count;
2342};
2343
2344void ethtool_channels_get_rsp_free(struct ethtool_channels_get_rsp *rsp);
2345
2346/*
2347 * Get channel params.
2348 */
2349struct ethtool_channels_get_rsp *
2350ethtool_channels_get(struct ynl_sock *ys, struct ethtool_channels_get_req *req);
2351
2352/* ETHTOOL_MSG_CHANNELS_GET - dump */
2353struct ethtool_channels_get_req_dump {
2354 struct {
2355 __u32 header:1;
2356 } _present;
2357
2358 struct ethtool_header header;
2359};
2360
2361static inline struct ethtool_channels_get_req_dump *
2362ethtool_channels_get_req_dump_alloc(void)
2363{
2364 return calloc(1, sizeof(struct ethtool_channels_get_req_dump));
2365}
2366void
2367ethtool_channels_get_req_dump_free(struct ethtool_channels_get_req_dump *req);
2368
2369static inline void
2370ethtool_channels_get_req_dump_set_header_dev_index(struct ethtool_channels_get_req_dump *req,
2371 __u32 dev_index)
2372{
2373 req->_present.header = 1;
2374 req->header._present.dev_index = 1;
2375 req->header.dev_index = dev_index;
2376}
2377static inline void
2378ethtool_channels_get_req_dump_set_header_dev_name(struct ethtool_channels_get_req_dump *req,
2379 const char *dev_name)
2380{
2381 free(req->header.dev_name);
2382 req->header._present.dev_name_len = strlen(dev_name);
2383 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
2384 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
2385 req->header.dev_name[req->header._present.dev_name_len] = 0;
2386}
2387static inline void
2388ethtool_channels_get_req_dump_set_header_flags(struct ethtool_channels_get_req_dump *req,
2389 __u32 flags)
2390{
2391 req->_present.header = 1;
2392 req->header._present.flags = 1;
2393 req->header.flags = flags;
2394}
2395
2396struct ethtool_channels_get_list {
2397 struct ethtool_channels_get_list *next;
2398 struct ethtool_channels_get_rsp obj __attribute__ ((aligned (8)));
2399};
2400
2401void ethtool_channels_get_list_free(struct ethtool_channels_get_list *rsp);
2402
2403struct ethtool_channels_get_list *
2404ethtool_channels_get_dump(struct ynl_sock *ys,
2405 struct ethtool_channels_get_req_dump *req);
2406
2407/* ETHTOOL_MSG_CHANNELS_GET - notify */
2408struct ethtool_channels_get_ntf {
2409 __u16 family;
2410 __u8 cmd;
2411 struct ynl_ntf_base_type *next;
2412 void (*free)(struct ethtool_channels_get_ntf *ntf);
2413 struct ethtool_channels_get_rsp obj __attribute__ ((aligned (8)));
2414};
2415
2416void ethtool_channels_get_ntf_free(struct ethtool_channels_get_ntf *rsp);
2417
2418/* ============== ETHTOOL_MSG_CHANNELS_SET ============== */
2419/* ETHTOOL_MSG_CHANNELS_SET - do */
2420struct ethtool_channels_set_req {
2421 struct {
2422 __u32 header:1;
2423 __u32 rx_max:1;
2424 __u32 tx_max:1;
2425 __u32 other_max:1;
2426 __u32 combined_max:1;
2427 __u32 rx_count:1;
2428 __u32 tx_count:1;
2429 __u32 other_count:1;
2430 __u32 combined_count:1;
2431 } _present;
2432
2433 struct ethtool_header header;
2434 __u32 rx_max;
2435 __u32 tx_max;
2436 __u32 other_max;
2437 __u32 combined_max;
2438 __u32 rx_count;
2439 __u32 tx_count;
2440 __u32 other_count;
2441 __u32 combined_count;
2442};
2443
2444static inline struct ethtool_channels_set_req *
2445ethtool_channels_set_req_alloc(void)
2446{
2447 return calloc(1, sizeof(struct ethtool_channels_set_req));
2448}
2449void ethtool_channels_set_req_free(struct ethtool_channels_set_req *req);
2450
2451static inline void
2452ethtool_channels_set_req_set_header_dev_index(struct ethtool_channels_set_req *req,
2453 __u32 dev_index)
2454{
2455 req->_present.header = 1;
2456 req->header._present.dev_index = 1;
2457 req->header.dev_index = dev_index;
2458}
2459static inline void
2460ethtool_channels_set_req_set_header_dev_name(struct ethtool_channels_set_req *req,
2461 const char *dev_name)
2462{
2463 free(req->header.dev_name);
2464 req->header._present.dev_name_len = strlen(dev_name);
2465 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
2466 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
2467 req->header.dev_name[req->header._present.dev_name_len] = 0;
2468}
2469static inline void
2470ethtool_channels_set_req_set_header_flags(struct ethtool_channels_set_req *req,
2471 __u32 flags)
2472{
2473 req->_present.header = 1;
2474 req->header._present.flags = 1;
2475 req->header.flags = flags;
2476}
2477static inline void
2478ethtool_channels_set_req_set_rx_max(struct ethtool_channels_set_req *req,
2479 __u32 rx_max)
2480{
2481 req->_present.rx_max = 1;
2482 req->rx_max = rx_max;
2483}
2484static inline void
2485ethtool_channels_set_req_set_tx_max(struct ethtool_channels_set_req *req,
2486 __u32 tx_max)
2487{
2488 req->_present.tx_max = 1;
2489 req->tx_max = tx_max;
2490}
2491static inline void
2492ethtool_channels_set_req_set_other_max(struct ethtool_channels_set_req *req,
2493 __u32 other_max)
2494{
2495 req->_present.other_max = 1;
2496 req->other_max = other_max;
2497}
2498static inline void
2499ethtool_channels_set_req_set_combined_max(struct ethtool_channels_set_req *req,
2500 __u32 combined_max)
2501{
2502 req->_present.combined_max = 1;
2503 req->combined_max = combined_max;
2504}
2505static inline void
2506ethtool_channels_set_req_set_rx_count(struct ethtool_channels_set_req *req,
2507 __u32 rx_count)
2508{
2509 req->_present.rx_count = 1;
2510 req->rx_count = rx_count;
2511}
2512static inline void
2513ethtool_channels_set_req_set_tx_count(struct ethtool_channels_set_req *req,
2514 __u32 tx_count)
2515{
2516 req->_present.tx_count = 1;
2517 req->tx_count = tx_count;
2518}
2519static inline void
2520ethtool_channels_set_req_set_other_count(struct ethtool_channels_set_req *req,
2521 __u32 other_count)
2522{
2523 req->_present.other_count = 1;
2524 req->other_count = other_count;
2525}
2526static inline void
2527ethtool_channels_set_req_set_combined_count(struct ethtool_channels_set_req *req,
2528 __u32 combined_count)
2529{
2530 req->_present.combined_count = 1;
2531 req->combined_count = combined_count;
2532}
2533
2534/*
2535 * Set channel params.
2536 */
2537int ethtool_channels_set(struct ynl_sock *ys,
2538 struct ethtool_channels_set_req *req);
2539
2540/* ============== ETHTOOL_MSG_COALESCE_GET ============== */
2541/* ETHTOOL_MSG_COALESCE_GET - do */
2542struct ethtool_coalesce_get_req {
2543 struct {
2544 __u32 header:1;
2545 } _present;
2546
2547 struct ethtool_header header;
2548};
2549
2550static inline struct ethtool_coalesce_get_req *
2551ethtool_coalesce_get_req_alloc(void)
2552{
2553 return calloc(1, sizeof(struct ethtool_coalesce_get_req));
2554}
2555void ethtool_coalesce_get_req_free(struct ethtool_coalesce_get_req *req);
2556
2557static inline void
2558ethtool_coalesce_get_req_set_header_dev_index(struct ethtool_coalesce_get_req *req,
2559 __u32 dev_index)
2560{
2561 req->_present.header = 1;
2562 req->header._present.dev_index = 1;
2563 req->header.dev_index = dev_index;
2564}
2565static inline void
2566ethtool_coalesce_get_req_set_header_dev_name(struct ethtool_coalesce_get_req *req,
2567 const char *dev_name)
2568{
2569 free(req->header.dev_name);
2570 req->header._present.dev_name_len = strlen(dev_name);
2571 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
2572 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
2573 req->header.dev_name[req->header._present.dev_name_len] = 0;
2574}
2575static inline void
2576ethtool_coalesce_get_req_set_header_flags(struct ethtool_coalesce_get_req *req,
2577 __u32 flags)
2578{
2579 req->_present.header = 1;
2580 req->header._present.flags = 1;
2581 req->header.flags = flags;
2582}
2583
2584struct ethtool_coalesce_get_rsp {
2585 struct {
2586 __u32 header:1;
2587 __u32 rx_usecs:1;
2588 __u32 rx_max_frames:1;
2589 __u32 rx_usecs_irq:1;
2590 __u32 rx_max_frames_irq:1;
2591 __u32 tx_usecs:1;
2592 __u32 tx_max_frames:1;
2593 __u32 tx_usecs_irq:1;
2594 __u32 tx_max_frames_irq:1;
2595 __u32 stats_block_usecs:1;
2596 __u32 use_adaptive_rx:1;
2597 __u32 use_adaptive_tx:1;
2598 __u32 pkt_rate_low:1;
2599 __u32 rx_usecs_low:1;
2600 __u32 rx_max_frames_low:1;
2601 __u32 tx_usecs_low:1;
2602 __u32 tx_max_frames_low:1;
2603 __u32 pkt_rate_high:1;
2604 __u32 rx_usecs_high:1;
2605 __u32 rx_max_frames_high:1;
2606 __u32 tx_usecs_high:1;
2607 __u32 tx_max_frames_high:1;
2608 __u32 rate_sample_interval:1;
2609 __u32 use_cqe_mode_tx:1;
2610 __u32 use_cqe_mode_rx:1;
2611 __u32 tx_aggr_max_bytes:1;
2612 __u32 tx_aggr_max_frames:1;
2613 __u32 tx_aggr_time_usecs:1;
2614 } _present;
2615
2616 struct ethtool_header header;
2617 __u32 rx_usecs;
2618 __u32 rx_max_frames;
2619 __u32 rx_usecs_irq;
2620 __u32 rx_max_frames_irq;
2621 __u32 tx_usecs;
2622 __u32 tx_max_frames;
2623 __u32 tx_usecs_irq;
2624 __u32 tx_max_frames_irq;
2625 __u32 stats_block_usecs;
2626 __u8 use_adaptive_rx;
2627 __u8 use_adaptive_tx;
2628 __u32 pkt_rate_low;
2629 __u32 rx_usecs_low;
2630 __u32 rx_max_frames_low;
2631 __u32 tx_usecs_low;
2632 __u32 tx_max_frames_low;
2633 __u32 pkt_rate_high;
2634 __u32 rx_usecs_high;
2635 __u32 rx_max_frames_high;
2636 __u32 tx_usecs_high;
2637 __u32 tx_max_frames_high;
2638 __u32 rate_sample_interval;
2639 __u8 use_cqe_mode_tx;
2640 __u8 use_cqe_mode_rx;
2641 __u32 tx_aggr_max_bytes;
2642 __u32 tx_aggr_max_frames;
2643 __u32 tx_aggr_time_usecs;
2644};
2645
2646void ethtool_coalesce_get_rsp_free(struct ethtool_coalesce_get_rsp *rsp);
2647
2648/*
2649 * Get coalesce params.
2650 */
2651struct ethtool_coalesce_get_rsp *
2652ethtool_coalesce_get(struct ynl_sock *ys, struct ethtool_coalesce_get_req *req);
2653
2654/* ETHTOOL_MSG_COALESCE_GET - dump */
2655struct ethtool_coalesce_get_req_dump {
2656 struct {
2657 __u32 header:1;
2658 } _present;
2659
2660 struct ethtool_header header;
2661};
2662
2663static inline struct ethtool_coalesce_get_req_dump *
2664ethtool_coalesce_get_req_dump_alloc(void)
2665{
2666 return calloc(1, sizeof(struct ethtool_coalesce_get_req_dump));
2667}
2668void
2669ethtool_coalesce_get_req_dump_free(struct ethtool_coalesce_get_req_dump *req);
2670
2671static inline void
2672ethtool_coalesce_get_req_dump_set_header_dev_index(struct ethtool_coalesce_get_req_dump *req,
2673 __u32 dev_index)
2674{
2675 req->_present.header = 1;
2676 req->header._present.dev_index = 1;
2677 req->header.dev_index = dev_index;
2678}
2679static inline void
2680ethtool_coalesce_get_req_dump_set_header_dev_name(struct ethtool_coalesce_get_req_dump *req,
2681 const char *dev_name)
2682{
2683 free(req->header.dev_name);
2684 req->header._present.dev_name_len = strlen(dev_name);
2685 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
2686 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
2687 req->header.dev_name[req->header._present.dev_name_len] = 0;
2688}
2689static inline void
2690ethtool_coalesce_get_req_dump_set_header_flags(struct ethtool_coalesce_get_req_dump *req,
2691 __u32 flags)
2692{
2693 req->_present.header = 1;
2694 req->header._present.flags = 1;
2695 req->header.flags = flags;
2696}
2697
2698struct ethtool_coalesce_get_list {
2699 struct ethtool_coalesce_get_list *next;
2700 struct ethtool_coalesce_get_rsp obj __attribute__ ((aligned (8)));
2701};
2702
2703void ethtool_coalesce_get_list_free(struct ethtool_coalesce_get_list *rsp);
2704
2705struct ethtool_coalesce_get_list *
2706ethtool_coalesce_get_dump(struct ynl_sock *ys,
2707 struct ethtool_coalesce_get_req_dump *req);
2708
2709/* ETHTOOL_MSG_COALESCE_GET - notify */
2710struct ethtool_coalesce_get_ntf {
2711 __u16 family;
2712 __u8 cmd;
2713 struct ynl_ntf_base_type *next;
2714 void (*free)(struct ethtool_coalesce_get_ntf *ntf);
2715 struct ethtool_coalesce_get_rsp obj __attribute__ ((aligned (8)));
2716};
2717
2718void ethtool_coalesce_get_ntf_free(struct ethtool_coalesce_get_ntf *rsp);
2719
2720/* ============== ETHTOOL_MSG_COALESCE_SET ============== */
2721/* ETHTOOL_MSG_COALESCE_SET - do */
2722struct ethtool_coalesce_set_req {
2723 struct {
2724 __u32 header:1;
2725 __u32 rx_usecs:1;
2726 __u32 rx_max_frames:1;
2727 __u32 rx_usecs_irq:1;
2728 __u32 rx_max_frames_irq:1;
2729 __u32 tx_usecs:1;
2730 __u32 tx_max_frames:1;
2731 __u32 tx_usecs_irq:1;
2732 __u32 tx_max_frames_irq:1;
2733 __u32 stats_block_usecs:1;
2734 __u32 use_adaptive_rx:1;
2735 __u32 use_adaptive_tx:1;
2736 __u32 pkt_rate_low:1;
2737 __u32 rx_usecs_low:1;
2738 __u32 rx_max_frames_low:1;
2739 __u32 tx_usecs_low:1;
2740 __u32 tx_max_frames_low:1;
2741 __u32 pkt_rate_high:1;
2742 __u32 rx_usecs_high:1;
2743 __u32 rx_max_frames_high:1;
2744 __u32 tx_usecs_high:1;
2745 __u32 tx_max_frames_high:1;
2746 __u32 rate_sample_interval:1;
2747 __u32 use_cqe_mode_tx:1;
2748 __u32 use_cqe_mode_rx:1;
2749 __u32 tx_aggr_max_bytes:1;
2750 __u32 tx_aggr_max_frames:1;
2751 __u32 tx_aggr_time_usecs:1;
2752 } _present;
2753
2754 struct ethtool_header header;
2755 __u32 rx_usecs;
2756 __u32 rx_max_frames;
2757 __u32 rx_usecs_irq;
2758 __u32 rx_max_frames_irq;
2759 __u32 tx_usecs;
2760 __u32 tx_max_frames;
2761 __u32 tx_usecs_irq;
2762 __u32 tx_max_frames_irq;
2763 __u32 stats_block_usecs;
2764 __u8 use_adaptive_rx;
2765 __u8 use_adaptive_tx;
2766 __u32 pkt_rate_low;
2767 __u32 rx_usecs_low;
2768 __u32 rx_max_frames_low;
2769 __u32 tx_usecs_low;
2770 __u32 tx_max_frames_low;
2771 __u32 pkt_rate_high;
2772 __u32 rx_usecs_high;
2773 __u32 rx_max_frames_high;
2774 __u32 tx_usecs_high;
2775 __u32 tx_max_frames_high;
2776 __u32 rate_sample_interval;
2777 __u8 use_cqe_mode_tx;
2778 __u8 use_cqe_mode_rx;
2779 __u32 tx_aggr_max_bytes;
2780 __u32 tx_aggr_max_frames;
2781 __u32 tx_aggr_time_usecs;
2782};
2783
2784static inline struct ethtool_coalesce_set_req *
2785ethtool_coalesce_set_req_alloc(void)
2786{
2787 return calloc(1, sizeof(struct ethtool_coalesce_set_req));
2788}
2789void ethtool_coalesce_set_req_free(struct ethtool_coalesce_set_req *req);
2790
2791static inline void
2792ethtool_coalesce_set_req_set_header_dev_index(struct ethtool_coalesce_set_req *req,
2793 __u32 dev_index)
2794{
2795 req->_present.header = 1;
2796 req->header._present.dev_index = 1;
2797 req->header.dev_index = dev_index;
2798}
2799static inline void
2800ethtool_coalesce_set_req_set_header_dev_name(struct ethtool_coalesce_set_req *req,
2801 const char *dev_name)
2802{
2803 free(req->header.dev_name);
2804 req->header._present.dev_name_len = strlen(dev_name);
2805 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
2806 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
2807 req->header.dev_name[req->header._present.dev_name_len] = 0;
2808}
2809static inline void
2810ethtool_coalesce_set_req_set_header_flags(struct ethtool_coalesce_set_req *req,
2811 __u32 flags)
2812{
2813 req->_present.header = 1;
2814 req->header._present.flags = 1;
2815 req->header.flags = flags;
2816}
2817static inline void
2818ethtool_coalesce_set_req_set_rx_usecs(struct ethtool_coalesce_set_req *req,
2819 __u32 rx_usecs)
2820{
2821 req->_present.rx_usecs = 1;
2822 req->rx_usecs = rx_usecs;
2823}
2824static inline void
2825ethtool_coalesce_set_req_set_rx_max_frames(struct ethtool_coalesce_set_req *req,
2826 __u32 rx_max_frames)
2827{
2828 req->_present.rx_max_frames = 1;
2829 req->rx_max_frames = rx_max_frames;
2830}
2831static inline void
2832ethtool_coalesce_set_req_set_rx_usecs_irq(struct ethtool_coalesce_set_req *req,
2833 __u32 rx_usecs_irq)
2834{
2835 req->_present.rx_usecs_irq = 1;
2836 req->rx_usecs_irq = rx_usecs_irq;
2837}
2838static inline void
2839ethtool_coalesce_set_req_set_rx_max_frames_irq(struct ethtool_coalesce_set_req *req,
2840 __u32 rx_max_frames_irq)
2841{
2842 req->_present.rx_max_frames_irq = 1;
2843 req->rx_max_frames_irq = rx_max_frames_irq;
2844}
2845static inline void
2846ethtool_coalesce_set_req_set_tx_usecs(struct ethtool_coalesce_set_req *req,
2847 __u32 tx_usecs)
2848{
2849 req->_present.tx_usecs = 1;
2850 req->tx_usecs = tx_usecs;
2851}
2852static inline void
2853ethtool_coalesce_set_req_set_tx_max_frames(struct ethtool_coalesce_set_req *req,
2854 __u32 tx_max_frames)
2855{
2856 req->_present.tx_max_frames = 1;
2857 req->tx_max_frames = tx_max_frames;
2858}
2859static inline void
2860ethtool_coalesce_set_req_set_tx_usecs_irq(struct ethtool_coalesce_set_req *req,
2861 __u32 tx_usecs_irq)
2862{
2863 req->_present.tx_usecs_irq = 1;
2864 req->tx_usecs_irq = tx_usecs_irq;
2865}
2866static inline void
2867ethtool_coalesce_set_req_set_tx_max_frames_irq(struct ethtool_coalesce_set_req *req,
2868 __u32 tx_max_frames_irq)
2869{
2870 req->_present.tx_max_frames_irq = 1;
2871 req->tx_max_frames_irq = tx_max_frames_irq;
2872}
2873static inline void
2874ethtool_coalesce_set_req_set_stats_block_usecs(struct ethtool_coalesce_set_req *req,
2875 __u32 stats_block_usecs)
2876{
2877 req->_present.stats_block_usecs = 1;
2878 req->stats_block_usecs = stats_block_usecs;
2879}
2880static inline void
2881ethtool_coalesce_set_req_set_use_adaptive_rx(struct ethtool_coalesce_set_req *req,
2882 __u8 use_adaptive_rx)
2883{
2884 req->_present.use_adaptive_rx = 1;
2885 req->use_adaptive_rx = use_adaptive_rx;
2886}
2887static inline void
2888ethtool_coalesce_set_req_set_use_adaptive_tx(struct ethtool_coalesce_set_req *req,
2889 __u8 use_adaptive_tx)
2890{
2891 req->_present.use_adaptive_tx = 1;
2892 req->use_adaptive_tx = use_adaptive_tx;
2893}
2894static inline void
2895ethtool_coalesce_set_req_set_pkt_rate_low(struct ethtool_coalesce_set_req *req,
2896 __u32 pkt_rate_low)
2897{
2898 req->_present.pkt_rate_low = 1;
2899 req->pkt_rate_low = pkt_rate_low;
2900}
2901static inline void
2902ethtool_coalesce_set_req_set_rx_usecs_low(struct ethtool_coalesce_set_req *req,
2903 __u32 rx_usecs_low)
2904{
2905 req->_present.rx_usecs_low = 1;
2906 req->rx_usecs_low = rx_usecs_low;
2907}
2908static inline void
2909ethtool_coalesce_set_req_set_rx_max_frames_low(struct ethtool_coalesce_set_req *req,
2910 __u32 rx_max_frames_low)
2911{
2912 req->_present.rx_max_frames_low = 1;
2913 req->rx_max_frames_low = rx_max_frames_low;
2914}
2915static inline void
2916ethtool_coalesce_set_req_set_tx_usecs_low(struct ethtool_coalesce_set_req *req,
2917 __u32 tx_usecs_low)
2918{
2919 req->_present.tx_usecs_low = 1;
2920 req->tx_usecs_low = tx_usecs_low;
2921}
2922static inline void
2923ethtool_coalesce_set_req_set_tx_max_frames_low(struct ethtool_coalesce_set_req *req,
2924 __u32 tx_max_frames_low)
2925{
2926 req->_present.tx_max_frames_low = 1;
2927 req->tx_max_frames_low = tx_max_frames_low;
2928}
2929static inline void
2930ethtool_coalesce_set_req_set_pkt_rate_high(struct ethtool_coalesce_set_req *req,
2931 __u32 pkt_rate_high)
2932{
2933 req->_present.pkt_rate_high = 1;
2934 req->pkt_rate_high = pkt_rate_high;
2935}
2936static inline void
2937ethtool_coalesce_set_req_set_rx_usecs_high(struct ethtool_coalesce_set_req *req,
2938 __u32 rx_usecs_high)
2939{
2940 req->_present.rx_usecs_high = 1;
2941 req->rx_usecs_high = rx_usecs_high;
2942}
2943static inline void
2944ethtool_coalesce_set_req_set_rx_max_frames_high(struct ethtool_coalesce_set_req *req,
2945 __u32 rx_max_frames_high)
2946{
2947 req->_present.rx_max_frames_high = 1;
2948 req->rx_max_frames_high = rx_max_frames_high;
2949}
2950static inline void
2951ethtool_coalesce_set_req_set_tx_usecs_high(struct ethtool_coalesce_set_req *req,
2952 __u32 tx_usecs_high)
2953{
2954 req->_present.tx_usecs_high = 1;
2955 req->tx_usecs_high = tx_usecs_high;
2956}
2957static inline void
2958ethtool_coalesce_set_req_set_tx_max_frames_high(struct ethtool_coalesce_set_req *req,
2959 __u32 tx_max_frames_high)
2960{
2961 req->_present.tx_max_frames_high = 1;
2962 req->tx_max_frames_high = tx_max_frames_high;
2963}
2964static inline void
2965ethtool_coalesce_set_req_set_rate_sample_interval(struct ethtool_coalesce_set_req *req,
2966 __u32 rate_sample_interval)
2967{
2968 req->_present.rate_sample_interval = 1;
2969 req->rate_sample_interval = rate_sample_interval;
2970}
2971static inline void
2972ethtool_coalesce_set_req_set_use_cqe_mode_tx(struct ethtool_coalesce_set_req *req,
2973 __u8 use_cqe_mode_tx)
2974{
2975 req->_present.use_cqe_mode_tx = 1;
2976 req->use_cqe_mode_tx = use_cqe_mode_tx;
2977}
2978static inline void
2979ethtool_coalesce_set_req_set_use_cqe_mode_rx(struct ethtool_coalesce_set_req *req,
2980 __u8 use_cqe_mode_rx)
2981{
2982 req->_present.use_cqe_mode_rx = 1;
2983 req->use_cqe_mode_rx = use_cqe_mode_rx;
2984}
2985static inline void
2986ethtool_coalesce_set_req_set_tx_aggr_max_bytes(struct ethtool_coalesce_set_req *req,
2987 __u32 tx_aggr_max_bytes)
2988{
2989 req->_present.tx_aggr_max_bytes = 1;
2990 req->tx_aggr_max_bytes = tx_aggr_max_bytes;
2991}
2992static inline void
2993ethtool_coalesce_set_req_set_tx_aggr_max_frames(struct ethtool_coalesce_set_req *req,
2994 __u32 tx_aggr_max_frames)
2995{
2996 req->_present.tx_aggr_max_frames = 1;
2997 req->tx_aggr_max_frames = tx_aggr_max_frames;
2998}
2999static inline void
3000ethtool_coalesce_set_req_set_tx_aggr_time_usecs(struct ethtool_coalesce_set_req *req,
3001 __u32 tx_aggr_time_usecs)
3002{
3003 req->_present.tx_aggr_time_usecs = 1;
3004 req->tx_aggr_time_usecs = tx_aggr_time_usecs;
3005}
3006
3007/*
3008 * Set coalesce params.
3009 */
3010int ethtool_coalesce_set(struct ynl_sock *ys,
3011 struct ethtool_coalesce_set_req *req);
3012
3013/* ============== ETHTOOL_MSG_PAUSE_GET ============== */
3014/* ETHTOOL_MSG_PAUSE_GET - do */
3015struct ethtool_pause_get_req {
3016 struct {
3017 __u32 header:1;
3018 } _present;
3019
3020 struct ethtool_header header;
3021};
3022
3023static inline struct ethtool_pause_get_req *ethtool_pause_get_req_alloc(void)
3024{
3025 return calloc(1, sizeof(struct ethtool_pause_get_req));
3026}
3027void ethtool_pause_get_req_free(struct ethtool_pause_get_req *req);
3028
3029static inline void
3030ethtool_pause_get_req_set_header_dev_index(struct ethtool_pause_get_req *req,
3031 __u32 dev_index)
3032{
3033 req->_present.header = 1;
3034 req->header._present.dev_index = 1;
3035 req->header.dev_index = dev_index;
3036}
3037static inline void
3038ethtool_pause_get_req_set_header_dev_name(struct ethtool_pause_get_req *req,
3039 const char *dev_name)
3040{
3041 free(req->header.dev_name);
3042 req->header._present.dev_name_len = strlen(dev_name);
3043 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
3044 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
3045 req->header.dev_name[req->header._present.dev_name_len] = 0;
3046}
3047static inline void
3048ethtool_pause_get_req_set_header_flags(struct ethtool_pause_get_req *req,
3049 __u32 flags)
3050{
3051 req->_present.header = 1;
3052 req->header._present.flags = 1;
3053 req->header.flags = flags;
3054}
3055
3056struct ethtool_pause_get_rsp {
3057 struct {
3058 __u32 header:1;
3059 __u32 autoneg:1;
3060 __u32 rx:1;
3061 __u32 tx:1;
3062 __u32 stats:1;
3063 __u32 stats_src:1;
3064 } _present;
3065
3066 struct ethtool_header header;
3067 __u8 autoneg;
3068 __u8 rx;
3069 __u8 tx;
3070 struct ethtool_pause_stat stats;
3071 __u32 stats_src;
3072};
3073
3074void ethtool_pause_get_rsp_free(struct ethtool_pause_get_rsp *rsp);
3075
3076/*
3077 * Get pause params.
3078 */
3079struct ethtool_pause_get_rsp *
3080ethtool_pause_get(struct ynl_sock *ys, struct ethtool_pause_get_req *req);
3081
3082/* ETHTOOL_MSG_PAUSE_GET - dump */
3083struct ethtool_pause_get_req_dump {
3084 struct {
3085 __u32 header:1;
3086 } _present;
3087
3088 struct ethtool_header header;
3089};
3090
3091static inline struct ethtool_pause_get_req_dump *
3092ethtool_pause_get_req_dump_alloc(void)
3093{
3094 return calloc(1, sizeof(struct ethtool_pause_get_req_dump));
3095}
3096void ethtool_pause_get_req_dump_free(struct ethtool_pause_get_req_dump *req);
3097
3098static inline void
3099ethtool_pause_get_req_dump_set_header_dev_index(struct ethtool_pause_get_req_dump *req,
3100 __u32 dev_index)
3101{
3102 req->_present.header = 1;
3103 req->header._present.dev_index = 1;
3104 req->header.dev_index = dev_index;
3105}
3106static inline void
3107ethtool_pause_get_req_dump_set_header_dev_name(struct ethtool_pause_get_req_dump *req,
3108 const char *dev_name)
3109{
3110 free(req->header.dev_name);
3111 req->header._present.dev_name_len = strlen(dev_name);
3112 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
3113 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
3114 req->header.dev_name[req->header._present.dev_name_len] = 0;
3115}
3116static inline void
3117ethtool_pause_get_req_dump_set_header_flags(struct ethtool_pause_get_req_dump *req,
3118 __u32 flags)
3119{
3120 req->_present.header = 1;
3121 req->header._present.flags = 1;
3122 req->header.flags = flags;
3123}
3124
3125struct ethtool_pause_get_list {
3126 struct ethtool_pause_get_list *next;
3127 struct ethtool_pause_get_rsp obj __attribute__ ((aligned (8)));
3128};
3129
3130void ethtool_pause_get_list_free(struct ethtool_pause_get_list *rsp);
3131
3132struct ethtool_pause_get_list *
3133ethtool_pause_get_dump(struct ynl_sock *ys,
3134 struct ethtool_pause_get_req_dump *req);
3135
3136/* ETHTOOL_MSG_PAUSE_GET - notify */
3137struct ethtool_pause_get_ntf {
3138 __u16 family;
3139 __u8 cmd;
3140 struct ynl_ntf_base_type *next;
3141 void (*free)(struct ethtool_pause_get_ntf *ntf);
3142 struct ethtool_pause_get_rsp obj __attribute__ ((aligned (8)));
3143};
3144
3145void ethtool_pause_get_ntf_free(struct ethtool_pause_get_ntf *rsp);
3146
3147/* ============== ETHTOOL_MSG_PAUSE_SET ============== */
3148/* ETHTOOL_MSG_PAUSE_SET - do */
3149struct ethtool_pause_set_req {
3150 struct {
3151 __u32 header:1;
3152 __u32 autoneg:1;
3153 __u32 rx:1;
3154 __u32 tx:1;
3155 __u32 stats:1;
3156 __u32 stats_src:1;
3157 } _present;
3158
3159 struct ethtool_header header;
3160 __u8 autoneg;
3161 __u8 rx;
3162 __u8 tx;
3163 struct ethtool_pause_stat stats;
3164 __u32 stats_src;
3165};
3166
3167static inline struct ethtool_pause_set_req *ethtool_pause_set_req_alloc(void)
3168{
3169 return calloc(1, sizeof(struct ethtool_pause_set_req));
3170}
3171void ethtool_pause_set_req_free(struct ethtool_pause_set_req *req);
3172
3173static inline void
3174ethtool_pause_set_req_set_header_dev_index(struct ethtool_pause_set_req *req,
3175 __u32 dev_index)
3176{
3177 req->_present.header = 1;
3178 req->header._present.dev_index = 1;
3179 req->header.dev_index = dev_index;
3180}
3181static inline void
3182ethtool_pause_set_req_set_header_dev_name(struct ethtool_pause_set_req *req,
3183 const char *dev_name)
3184{
3185 free(req->header.dev_name);
3186 req->header._present.dev_name_len = strlen(dev_name);
3187 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
3188 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
3189 req->header.dev_name[req->header._present.dev_name_len] = 0;
3190}
3191static inline void
3192ethtool_pause_set_req_set_header_flags(struct ethtool_pause_set_req *req,
3193 __u32 flags)
3194{
3195 req->_present.header = 1;
3196 req->header._present.flags = 1;
3197 req->header.flags = flags;
3198}
3199static inline void
3200ethtool_pause_set_req_set_autoneg(struct ethtool_pause_set_req *req,
3201 __u8 autoneg)
3202{
3203 req->_present.autoneg = 1;
3204 req->autoneg = autoneg;
3205}
3206static inline void
3207ethtool_pause_set_req_set_rx(struct ethtool_pause_set_req *req, __u8 rx)
3208{
3209 req->_present.rx = 1;
3210 req->rx = rx;
3211}
3212static inline void
3213ethtool_pause_set_req_set_tx(struct ethtool_pause_set_req *req, __u8 tx)
3214{
3215 req->_present.tx = 1;
3216 req->tx = tx;
3217}
3218static inline void
3219ethtool_pause_set_req_set_stats_tx_frames(struct ethtool_pause_set_req *req,
3220 __u64 tx_frames)
3221{
3222 req->_present.stats = 1;
3223 req->stats._present.tx_frames = 1;
3224 req->stats.tx_frames = tx_frames;
3225}
3226static inline void
3227ethtool_pause_set_req_set_stats_rx_frames(struct ethtool_pause_set_req *req,
3228 __u64 rx_frames)
3229{
3230 req->_present.stats = 1;
3231 req->stats._present.rx_frames = 1;
3232 req->stats.rx_frames = rx_frames;
3233}
3234static inline void
3235ethtool_pause_set_req_set_stats_src(struct ethtool_pause_set_req *req,
3236 __u32 stats_src)
3237{
3238 req->_present.stats_src = 1;
3239 req->stats_src = stats_src;
3240}
3241
3242/*
3243 * Set pause params.
3244 */
3245int ethtool_pause_set(struct ynl_sock *ys, struct ethtool_pause_set_req *req);
3246
3247/* ============== ETHTOOL_MSG_EEE_GET ============== */
3248/* ETHTOOL_MSG_EEE_GET - do */
3249struct ethtool_eee_get_req {
3250 struct {
3251 __u32 header:1;
3252 } _present;
3253
3254 struct ethtool_header header;
3255};
3256
3257static inline struct ethtool_eee_get_req *ethtool_eee_get_req_alloc(void)
3258{
3259 return calloc(1, sizeof(struct ethtool_eee_get_req));
3260}
3261void ethtool_eee_get_req_free(struct ethtool_eee_get_req *req);
3262
3263static inline void
3264ethtool_eee_get_req_set_header_dev_index(struct ethtool_eee_get_req *req,
3265 __u32 dev_index)
3266{
3267 req->_present.header = 1;
3268 req->header._present.dev_index = 1;
3269 req->header.dev_index = dev_index;
3270}
3271static inline void
3272ethtool_eee_get_req_set_header_dev_name(struct ethtool_eee_get_req *req,
3273 const char *dev_name)
3274{
3275 free(req->header.dev_name);
3276 req->header._present.dev_name_len = strlen(dev_name);
3277 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
3278 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
3279 req->header.dev_name[req->header._present.dev_name_len] = 0;
3280}
3281static inline void
3282ethtool_eee_get_req_set_header_flags(struct ethtool_eee_get_req *req,
3283 __u32 flags)
3284{
3285 req->_present.header = 1;
3286 req->header._present.flags = 1;
3287 req->header.flags = flags;
3288}
3289
3290struct ethtool_eee_get_rsp {
3291 struct {
3292 __u32 header:1;
3293 __u32 modes_ours:1;
3294 __u32 modes_peer:1;
3295 __u32 active:1;
3296 __u32 enabled:1;
3297 __u32 tx_lpi_enabled:1;
3298 __u32 tx_lpi_timer:1;
3299 } _present;
3300
3301 struct ethtool_header header;
3302 struct ethtool_bitset modes_ours;
3303 struct ethtool_bitset modes_peer;
3304 __u8 active;
3305 __u8 enabled;
3306 __u8 tx_lpi_enabled;
3307 __u32 tx_lpi_timer;
3308};
3309
3310void ethtool_eee_get_rsp_free(struct ethtool_eee_get_rsp *rsp);
3311
3312/*
3313 * Get eee params.
3314 */
3315struct ethtool_eee_get_rsp *
3316ethtool_eee_get(struct ynl_sock *ys, struct ethtool_eee_get_req *req);
3317
3318/* ETHTOOL_MSG_EEE_GET - dump */
3319struct ethtool_eee_get_req_dump {
3320 struct {
3321 __u32 header:1;
3322 } _present;
3323
3324 struct ethtool_header header;
3325};
3326
3327static inline struct ethtool_eee_get_req_dump *
3328ethtool_eee_get_req_dump_alloc(void)
3329{
3330 return calloc(1, sizeof(struct ethtool_eee_get_req_dump));
3331}
3332void ethtool_eee_get_req_dump_free(struct ethtool_eee_get_req_dump *req);
3333
3334static inline void
3335ethtool_eee_get_req_dump_set_header_dev_index(struct ethtool_eee_get_req_dump *req,
3336 __u32 dev_index)
3337{
3338 req->_present.header = 1;
3339 req->header._present.dev_index = 1;
3340 req->header.dev_index = dev_index;
3341}
3342static inline void
3343ethtool_eee_get_req_dump_set_header_dev_name(struct ethtool_eee_get_req_dump *req,
3344 const char *dev_name)
3345{
3346 free(req->header.dev_name);
3347 req->header._present.dev_name_len = strlen(dev_name);
3348 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
3349 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
3350 req->header.dev_name[req->header._present.dev_name_len] = 0;
3351}
3352static inline void
3353ethtool_eee_get_req_dump_set_header_flags(struct ethtool_eee_get_req_dump *req,
3354 __u32 flags)
3355{
3356 req->_present.header = 1;
3357 req->header._present.flags = 1;
3358 req->header.flags = flags;
3359}
3360
3361struct ethtool_eee_get_list {
3362 struct ethtool_eee_get_list *next;
3363 struct ethtool_eee_get_rsp obj __attribute__ ((aligned (8)));
3364};
3365
3366void ethtool_eee_get_list_free(struct ethtool_eee_get_list *rsp);
3367
3368struct ethtool_eee_get_list *
3369ethtool_eee_get_dump(struct ynl_sock *ys, struct ethtool_eee_get_req_dump *req);
3370
3371/* ETHTOOL_MSG_EEE_GET - notify */
3372struct ethtool_eee_get_ntf {
3373 __u16 family;
3374 __u8 cmd;
3375 struct ynl_ntf_base_type *next;
3376 void (*free)(struct ethtool_eee_get_ntf *ntf);
3377 struct ethtool_eee_get_rsp obj __attribute__ ((aligned (8)));
3378};
3379
3380void ethtool_eee_get_ntf_free(struct ethtool_eee_get_ntf *rsp);
3381
3382/* ============== ETHTOOL_MSG_EEE_SET ============== */
3383/* ETHTOOL_MSG_EEE_SET - do */
3384struct ethtool_eee_set_req {
3385 struct {
3386 __u32 header:1;
3387 __u32 modes_ours:1;
3388 __u32 modes_peer:1;
3389 __u32 active:1;
3390 __u32 enabled:1;
3391 __u32 tx_lpi_enabled:1;
3392 __u32 tx_lpi_timer:1;
3393 } _present;
3394
3395 struct ethtool_header header;
3396 struct ethtool_bitset modes_ours;
3397 struct ethtool_bitset modes_peer;
3398 __u8 active;
3399 __u8 enabled;
3400 __u8 tx_lpi_enabled;
3401 __u32 tx_lpi_timer;
3402};
3403
3404static inline struct ethtool_eee_set_req *ethtool_eee_set_req_alloc(void)
3405{
3406 return calloc(1, sizeof(struct ethtool_eee_set_req));
3407}
3408void ethtool_eee_set_req_free(struct ethtool_eee_set_req *req);
3409
3410static inline void
3411ethtool_eee_set_req_set_header_dev_index(struct ethtool_eee_set_req *req,
3412 __u32 dev_index)
3413{
3414 req->_present.header = 1;
3415 req->header._present.dev_index = 1;
3416 req->header.dev_index = dev_index;
3417}
3418static inline void
3419ethtool_eee_set_req_set_header_dev_name(struct ethtool_eee_set_req *req,
3420 const char *dev_name)
3421{
3422 free(req->header.dev_name);
3423 req->header._present.dev_name_len = strlen(dev_name);
3424 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
3425 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
3426 req->header.dev_name[req->header._present.dev_name_len] = 0;
3427}
3428static inline void
3429ethtool_eee_set_req_set_header_flags(struct ethtool_eee_set_req *req,
3430 __u32 flags)
3431{
3432 req->_present.header = 1;
3433 req->header._present.flags = 1;
3434 req->header.flags = flags;
3435}
3436static inline void
3437ethtool_eee_set_req_set_modes_ours_nomask(struct ethtool_eee_set_req *req)
3438{
3439 req->_present.modes_ours = 1;
3440 req->modes_ours._present.nomask = 1;
3441}
3442static inline void
3443ethtool_eee_set_req_set_modes_ours_size(struct ethtool_eee_set_req *req,
3444 __u32 size)
3445{
3446 req->_present.modes_ours = 1;
3447 req->modes_ours._present.size = 1;
3448 req->modes_ours.size = size;
3449}
3450static inline void
3451__ethtool_eee_set_req_set_modes_ours_bits_bit(struct ethtool_eee_set_req *req,
3452 struct ethtool_bitset_bit *bit,
3453 unsigned int n_bit)
3454{
3455 free(req->modes_ours.bits.bit);
3456 req->modes_ours.bits.bit = bit;
3457 req->modes_ours.bits.n_bit = n_bit;
3458}
3459static inline void
3460ethtool_eee_set_req_set_modes_peer_nomask(struct ethtool_eee_set_req *req)
3461{
3462 req->_present.modes_peer = 1;
3463 req->modes_peer._present.nomask = 1;
3464}
3465static inline void
3466ethtool_eee_set_req_set_modes_peer_size(struct ethtool_eee_set_req *req,
3467 __u32 size)
3468{
3469 req->_present.modes_peer = 1;
3470 req->modes_peer._present.size = 1;
3471 req->modes_peer.size = size;
3472}
3473static inline void
3474__ethtool_eee_set_req_set_modes_peer_bits_bit(struct ethtool_eee_set_req *req,
3475 struct ethtool_bitset_bit *bit,
3476 unsigned int n_bit)
3477{
3478 free(req->modes_peer.bits.bit);
3479 req->modes_peer.bits.bit = bit;
3480 req->modes_peer.bits.n_bit = n_bit;
3481}
3482static inline void
3483ethtool_eee_set_req_set_active(struct ethtool_eee_set_req *req, __u8 active)
3484{
3485 req->_present.active = 1;
3486 req->active = active;
3487}
3488static inline void
3489ethtool_eee_set_req_set_enabled(struct ethtool_eee_set_req *req, __u8 enabled)
3490{
3491 req->_present.enabled = 1;
3492 req->enabled = enabled;
3493}
3494static inline void
3495ethtool_eee_set_req_set_tx_lpi_enabled(struct ethtool_eee_set_req *req,
3496 __u8 tx_lpi_enabled)
3497{
3498 req->_present.tx_lpi_enabled = 1;
3499 req->tx_lpi_enabled = tx_lpi_enabled;
3500}
3501static inline void
3502ethtool_eee_set_req_set_tx_lpi_timer(struct ethtool_eee_set_req *req,
3503 __u32 tx_lpi_timer)
3504{
3505 req->_present.tx_lpi_timer = 1;
3506 req->tx_lpi_timer = tx_lpi_timer;
3507}
3508
3509/*
3510 * Set eee params.
3511 */
3512int ethtool_eee_set(struct ynl_sock *ys, struct ethtool_eee_set_req *req);
3513
3514/* ============== ETHTOOL_MSG_TSINFO_GET ============== */
3515/* ETHTOOL_MSG_TSINFO_GET - do */
3516struct ethtool_tsinfo_get_req {
3517 struct {
3518 __u32 header:1;
3519 } _present;
3520
3521 struct ethtool_header header;
3522};
3523
3524static inline struct ethtool_tsinfo_get_req *ethtool_tsinfo_get_req_alloc(void)
3525{
3526 return calloc(1, sizeof(struct ethtool_tsinfo_get_req));
3527}
3528void ethtool_tsinfo_get_req_free(struct ethtool_tsinfo_get_req *req);
3529
3530static inline void
3531ethtool_tsinfo_get_req_set_header_dev_index(struct ethtool_tsinfo_get_req *req,
3532 __u32 dev_index)
3533{
3534 req->_present.header = 1;
3535 req->header._present.dev_index = 1;
3536 req->header.dev_index = dev_index;
3537}
3538static inline void
3539ethtool_tsinfo_get_req_set_header_dev_name(struct ethtool_tsinfo_get_req *req,
3540 const char *dev_name)
3541{
3542 free(req->header.dev_name);
3543 req->header._present.dev_name_len = strlen(dev_name);
3544 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
3545 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
3546 req->header.dev_name[req->header._present.dev_name_len] = 0;
3547}
3548static inline void
3549ethtool_tsinfo_get_req_set_header_flags(struct ethtool_tsinfo_get_req *req,
3550 __u32 flags)
3551{
3552 req->_present.header = 1;
3553 req->header._present.flags = 1;
3554 req->header.flags = flags;
3555}
3556
3557struct ethtool_tsinfo_get_rsp {
3558 struct {
3559 __u32 header:1;
3560 __u32 timestamping:1;
3561 __u32 tx_types:1;
3562 __u32 rx_filters:1;
3563 __u32 phc_index:1;
3564 } _present;
3565
3566 struct ethtool_header header;
3567 struct ethtool_bitset timestamping;
3568 struct ethtool_bitset tx_types;
3569 struct ethtool_bitset rx_filters;
3570 __u32 phc_index;
3571};
3572
3573void ethtool_tsinfo_get_rsp_free(struct ethtool_tsinfo_get_rsp *rsp);
3574
3575/*
3576 * Get tsinfo params.
3577 */
3578struct ethtool_tsinfo_get_rsp *
3579ethtool_tsinfo_get(struct ynl_sock *ys, struct ethtool_tsinfo_get_req *req);
3580
3581/* ETHTOOL_MSG_TSINFO_GET - dump */
3582struct ethtool_tsinfo_get_req_dump {
3583 struct {
3584 __u32 header:1;
3585 } _present;
3586
3587 struct ethtool_header header;
3588};
3589
3590static inline struct ethtool_tsinfo_get_req_dump *
3591ethtool_tsinfo_get_req_dump_alloc(void)
3592{
3593 return calloc(1, sizeof(struct ethtool_tsinfo_get_req_dump));
3594}
3595void ethtool_tsinfo_get_req_dump_free(struct ethtool_tsinfo_get_req_dump *req);
3596
3597static inline void
3598ethtool_tsinfo_get_req_dump_set_header_dev_index(struct ethtool_tsinfo_get_req_dump *req,
3599 __u32 dev_index)
3600{
3601 req->_present.header = 1;
3602 req->header._present.dev_index = 1;
3603 req->header.dev_index = dev_index;
3604}
3605static inline void
3606ethtool_tsinfo_get_req_dump_set_header_dev_name(struct ethtool_tsinfo_get_req_dump *req,
3607 const char *dev_name)
3608{
3609 free(req->header.dev_name);
3610 req->header._present.dev_name_len = strlen(dev_name);
3611 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
3612 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
3613 req->header.dev_name[req->header._present.dev_name_len] = 0;
3614}
3615static inline void
3616ethtool_tsinfo_get_req_dump_set_header_flags(struct ethtool_tsinfo_get_req_dump *req,
3617 __u32 flags)
3618{
3619 req->_present.header = 1;
3620 req->header._present.flags = 1;
3621 req->header.flags = flags;
3622}
3623
3624struct ethtool_tsinfo_get_list {
3625 struct ethtool_tsinfo_get_list *next;
3626 struct ethtool_tsinfo_get_rsp obj __attribute__ ((aligned (8)));
3627};
3628
3629void ethtool_tsinfo_get_list_free(struct ethtool_tsinfo_get_list *rsp);
3630
3631struct ethtool_tsinfo_get_list *
3632ethtool_tsinfo_get_dump(struct ynl_sock *ys,
3633 struct ethtool_tsinfo_get_req_dump *req);
3634
3635/* ============== ETHTOOL_MSG_CABLE_TEST_ACT ============== */
3636/* ETHTOOL_MSG_CABLE_TEST_ACT - do */
3637struct ethtool_cable_test_act_req {
3638 struct {
3639 __u32 header:1;
3640 } _present;
3641
3642 struct ethtool_header header;
3643};
3644
3645static inline struct ethtool_cable_test_act_req *
3646ethtool_cable_test_act_req_alloc(void)
3647{
3648 return calloc(1, sizeof(struct ethtool_cable_test_act_req));
3649}
3650void ethtool_cable_test_act_req_free(struct ethtool_cable_test_act_req *req);
3651
3652static inline void
3653ethtool_cable_test_act_req_set_header_dev_index(struct ethtool_cable_test_act_req *req,
3654 __u32 dev_index)
3655{
3656 req->_present.header = 1;
3657 req->header._present.dev_index = 1;
3658 req->header.dev_index = dev_index;
3659}
3660static inline void
3661ethtool_cable_test_act_req_set_header_dev_name(struct ethtool_cable_test_act_req *req,
3662 const char *dev_name)
3663{
3664 free(req->header.dev_name);
3665 req->header._present.dev_name_len = strlen(dev_name);
3666 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
3667 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
3668 req->header.dev_name[req->header._present.dev_name_len] = 0;
3669}
3670static inline void
3671ethtool_cable_test_act_req_set_header_flags(struct ethtool_cable_test_act_req *req,
3672 __u32 flags)
3673{
3674 req->_present.header = 1;
3675 req->header._present.flags = 1;
3676 req->header.flags = flags;
3677}
3678
3679/*
3680 * Cable test.
3681 */
3682int ethtool_cable_test_act(struct ynl_sock *ys,
3683 struct ethtool_cable_test_act_req *req);
3684
3685/* ============== ETHTOOL_MSG_CABLE_TEST_TDR_ACT ============== */
3686/* ETHTOOL_MSG_CABLE_TEST_TDR_ACT - do */
3687struct ethtool_cable_test_tdr_act_req {
3688 struct {
3689 __u32 header:1;
3690 } _present;
3691
3692 struct ethtool_header header;
3693};
3694
3695static inline struct ethtool_cable_test_tdr_act_req *
3696ethtool_cable_test_tdr_act_req_alloc(void)
3697{
3698 return calloc(1, sizeof(struct ethtool_cable_test_tdr_act_req));
3699}
3700void
3701ethtool_cable_test_tdr_act_req_free(struct ethtool_cable_test_tdr_act_req *req);
3702
3703static inline void
3704ethtool_cable_test_tdr_act_req_set_header_dev_index(struct ethtool_cable_test_tdr_act_req *req,
3705 __u32 dev_index)
3706{
3707 req->_present.header = 1;
3708 req->header._present.dev_index = 1;
3709 req->header.dev_index = dev_index;
3710}
3711static inline void
3712ethtool_cable_test_tdr_act_req_set_header_dev_name(struct ethtool_cable_test_tdr_act_req *req,
3713 const char *dev_name)
3714{
3715 free(req->header.dev_name);
3716 req->header._present.dev_name_len = strlen(dev_name);
3717 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
3718 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
3719 req->header.dev_name[req->header._present.dev_name_len] = 0;
3720}
3721static inline void
3722ethtool_cable_test_tdr_act_req_set_header_flags(struct ethtool_cable_test_tdr_act_req *req,
3723 __u32 flags)
3724{
3725 req->_present.header = 1;
3726 req->header._present.flags = 1;
3727 req->header.flags = flags;
3728}
3729
3730/*
3731 * Cable test TDR.
3732 */
3733int ethtool_cable_test_tdr_act(struct ynl_sock *ys,
3734 struct ethtool_cable_test_tdr_act_req *req);
3735
3736/* ============== ETHTOOL_MSG_TUNNEL_INFO_GET ============== */
3737/* ETHTOOL_MSG_TUNNEL_INFO_GET - do */
3738struct ethtool_tunnel_info_get_req {
3739 struct {
3740 __u32 header:1;
3741 } _present;
3742
3743 struct ethtool_header header;
3744};
3745
3746static inline struct ethtool_tunnel_info_get_req *
3747ethtool_tunnel_info_get_req_alloc(void)
3748{
3749 return calloc(1, sizeof(struct ethtool_tunnel_info_get_req));
3750}
3751void ethtool_tunnel_info_get_req_free(struct ethtool_tunnel_info_get_req *req);
3752
3753static inline void
3754ethtool_tunnel_info_get_req_set_header_dev_index(struct ethtool_tunnel_info_get_req *req,
3755 __u32 dev_index)
3756{
3757 req->_present.header = 1;
3758 req->header._present.dev_index = 1;
3759 req->header.dev_index = dev_index;
3760}
3761static inline void
3762ethtool_tunnel_info_get_req_set_header_dev_name(struct ethtool_tunnel_info_get_req *req,
3763 const char *dev_name)
3764{
3765 free(req->header.dev_name);
3766 req->header._present.dev_name_len = strlen(dev_name);
3767 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
3768 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
3769 req->header.dev_name[req->header._present.dev_name_len] = 0;
3770}
3771static inline void
3772ethtool_tunnel_info_get_req_set_header_flags(struct ethtool_tunnel_info_get_req *req,
3773 __u32 flags)
3774{
3775 req->_present.header = 1;
3776 req->header._present.flags = 1;
3777 req->header.flags = flags;
3778}
3779
3780struct ethtool_tunnel_info_get_rsp {
3781 struct {
3782 __u32 header:1;
3783 __u32 udp_ports:1;
3784 } _present;
3785
3786 struct ethtool_header header;
3787 struct ethtool_tunnel_udp udp_ports;
3788};
3789
3790void ethtool_tunnel_info_get_rsp_free(struct ethtool_tunnel_info_get_rsp *rsp);
3791
3792/*
3793 * Get tsinfo params.
3794 */
3795struct ethtool_tunnel_info_get_rsp *
3796ethtool_tunnel_info_get(struct ynl_sock *ys,
3797 struct ethtool_tunnel_info_get_req *req);
3798
3799/* ETHTOOL_MSG_TUNNEL_INFO_GET - dump */
3800struct ethtool_tunnel_info_get_req_dump {
3801 struct {
3802 __u32 header:1;
3803 } _present;
3804
3805 struct ethtool_header header;
3806};
3807
3808static inline struct ethtool_tunnel_info_get_req_dump *
3809ethtool_tunnel_info_get_req_dump_alloc(void)
3810{
3811 return calloc(1, sizeof(struct ethtool_tunnel_info_get_req_dump));
3812}
3813void
3814ethtool_tunnel_info_get_req_dump_free(struct ethtool_tunnel_info_get_req_dump *req);
3815
3816static inline void
3817ethtool_tunnel_info_get_req_dump_set_header_dev_index(struct ethtool_tunnel_info_get_req_dump *req,
3818 __u32 dev_index)
3819{
3820 req->_present.header = 1;
3821 req->header._present.dev_index = 1;
3822 req->header.dev_index = dev_index;
3823}
3824static inline void
3825ethtool_tunnel_info_get_req_dump_set_header_dev_name(struct ethtool_tunnel_info_get_req_dump *req,
3826 const char *dev_name)
3827{
3828 free(req->header.dev_name);
3829 req->header._present.dev_name_len = strlen(dev_name);
3830 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
3831 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
3832 req->header.dev_name[req->header._present.dev_name_len] = 0;
3833}
3834static inline void
3835ethtool_tunnel_info_get_req_dump_set_header_flags(struct ethtool_tunnel_info_get_req_dump *req,
3836 __u32 flags)
3837{
3838 req->_present.header = 1;
3839 req->header._present.flags = 1;
3840 req->header.flags = flags;
3841}
3842
3843struct ethtool_tunnel_info_get_list {
3844 struct ethtool_tunnel_info_get_list *next;
3845 struct ethtool_tunnel_info_get_rsp obj __attribute__ ((aligned (8)));
3846};
3847
3848void
3849ethtool_tunnel_info_get_list_free(struct ethtool_tunnel_info_get_list *rsp);
3850
3851struct ethtool_tunnel_info_get_list *
3852ethtool_tunnel_info_get_dump(struct ynl_sock *ys,
3853 struct ethtool_tunnel_info_get_req_dump *req);
3854
3855/* ============== ETHTOOL_MSG_FEC_GET ============== */
3856/* ETHTOOL_MSG_FEC_GET - do */
3857struct ethtool_fec_get_req {
3858 struct {
3859 __u32 header:1;
3860 } _present;
3861
3862 struct ethtool_header header;
3863};
3864
3865static inline struct ethtool_fec_get_req *ethtool_fec_get_req_alloc(void)
3866{
3867 return calloc(1, sizeof(struct ethtool_fec_get_req));
3868}
3869void ethtool_fec_get_req_free(struct ethtool_fec_get_req *req);
3870
3871static inline void
3872ethtool_fec_get_req_set_header_dev_index(struct ethtool_fec_get_req *req,
3873 __u32 dev_index)
3874{
3875 req->_present.header = 1;
3876 req->header._present.dev_index = 1;
3877 req->header.dev_index = dev_index;
3878}
3879static inline void
3880ethtool_fec_get_req_set_header_dev_name(struct ethtool_fec_get_req *req,
3881 const char *dev_name)
3882{
3883 free(req->header.dev_name);
3884 req->header._present.dev_name_len = strlen(dev_name);
3885 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
3886 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
3887 req->header.dev_name[req->header._present.dev_name_len] = 0;
3888}
3889static inline void
3890ethtool_fec_get_req_set_header_flags(struct ethtool_fec_get_req *req,
3891 __u32 flags)
3892{
3893 req->_present.header = 1;
3894 req->header._present.flags = 1;
3895 req->header.flags = flags;
3896}
3897
3898struct ethtool_fec_get_rsp {
3899 struct {
3900 __u32 header:1;
3901 __u32 modes:1;
3902 __u32 auto_:1;
3903 __u32 active:1;
3904 __u32 stats:1;
3905 } _present;
3906
3907 struct ethtool_header header;
3908 struct ethtool_bitset modes;
3909 __u8 auto_;
3910 __u32 active;
3911 struct ethtool_fec_stat stats;
3912};
3913
3914void ethtool_fec_get_rsp_free(struct ethtool_fec_get_rsp *rsp);
3915
3916/*
3917 * Get FEC params.
3918 */
3919struct ethtool_fec_get_rsp *
3920ethtool_fec_get(struct ynl_sock *ys, struct ethtool_fec_get_req *req);
3921
3922/* ETHTOOL_MSG_FEC_GET - dump */
3923struct ethtool_fec_get_req_dump {
3924 struct {
3925 __u32 header:1;
3926 } _present;
3927
3928 struct ethtool_header header;
3929};
3930
3931static inline struct ethtool_fec_get_req_dump *
3932ethtool_fec_get_req_dump_alloc(void)
3933{
3934 return calloc(1, sizeof(struct ethtool_fec_get_req_dump));
3935}
3936void ethtool_fec_get_req_dump_free(struct ethtool_fec_get_req_dump *req);
3937
3938static inline void
3939ethtool_fec_get_req_dump_set_header_dev_index(struct ethtool_fec_get_req_dump *req,
3940 __u32 dev_index)
3941{
3942 req->_present.header = 1;
3943 req->header._present.dev_index = 1;
3944 req->header.dev_index = dev_index;
3945}
3946static inline void
3947ethtool_fec_get_req_dump_set_header_dev_name(struct ethtool_fec_get_req_dump *req,
3948 const char *dev_name)
3949{
3950 free(req->header.dev_name);
3951 req->header._present.dev_name_len = strlen(dev_name);
3952 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
3953 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
3954 req->header.dev_name[req->header._present.dev_name_len] = 0;
3955}
3956static inline void
3957ethtool_fec_get_req_dump_set_header_flags(struct ethtool_fec_get_req_dump *req,
3958 __u32 flags)
3959{
3960 req->_present.header = 1;
3961 req->header._present.flags = 1;
3962 req->header.flags = flags;
3963}
3964
3965struct ethtool_fec_get_list {
3966 struct ethtool_fec_get_list *next;
3967 struct ethtool_fec_get_rsp obj __attribute__ ((aligned (8)));
3968};
3969
3970void ethtool_fec_get_list_free(struct ethtool_fec_get_list *rsp);
3971
3972struct ethtool_fec_get_list *
3973ethtool_fec_get_dump(struct ynl_sock *ys, struct ethtool_fec_get_req_dump *req);
3974
3975/* ETHTOOL_MSG_FEC_GET - notify */
3976struct ethtool_fec_get_ntf {
3977 __u16 family;
3978 __u8 cmd;
3979 struct ynl_ntf_base_type *next;
3980 void (*free)(struct ethtool_fec_get_ntf *ntf);
3981 struct ethtool_fec_get_rsp obj __attribute__ ((aligned (8)));
3982};
3983
3984void ethtool_fec_get_ntf_free(struct ethtool_fec_get_ntf *rsp);
3985
3986/* ============== ETHTOOL_MSG_FEC_SET ============== */
3987/* ETHTOOL_MSG_FEC_SET - do */
3988struct ethtool_fec_set_req {
3989 struct {
3990 __u32 header:1;
3991 __u32 modes:1;
3992 __u32 auto_:1;
3993 __u32 active:1;
3994 __u32 stats:1;
3995 } _present;
3996
3997 struct ethtool_header header;
3998 struct ethtool_bitset modes;
3999 __u8 auto_;
4000 __u32 active;
4001 struct ethtool_fec_stat stats;
4002};
4003
4004static inline struct ethtool_fec_set_req *ethtool_fec_set_req_alloc(void)
4005{
4006 return calloc(1, sizeof(struct ethtool_fec_set_req));
4007}
4008void ethtool_fec_set_req_free(struct ethtool_fec_set_req *req);
4009
4010static inline void
4011ethtool_fec_set_req_set_header_dev_index(struct ethtool_fec_set_req *req,
4012 __u32 dev_index)
4013{
4014 req->_present.header = 1;
4015 req->header._present.dev_index = 1;
4016 req->header.dev_index = dev_index;
4017}
4018static inline void
4019ethtool_fec_set_req_set_header_dev_name(struct ethtool_fec_set_req *req,
4020 const char *dev_name)
4021{
4022 free(req->header.dev_name);
4023 req->header._present.dev_name_len = strlen(dev_name);
4024 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
4025 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
4026 req->header.dev_name[req->header._present.dev_name_len] = 0;
4027}
4028static inline void
4029ethtool_fec_set_req_set_header_flags(struct ethtool_fec_set_req *req,
4030 __u32 flags)
4031{
4032 req->_present.header = 1;
4033 req->header._present.flags = 1;
4034 req->header.flags = flags;
4035}
4036static inline void
4037ethtool_fec_set_req_set_modes_nomask(struct ethtool_fec_set_req *req)
4038{
4039 req->_present.modes = 1;
4040 req->modes._present.nomask = 1;
4041}
4042static inline void
4043ethtool_fec_set_req_set_modes_size(struct ethtool_fec_set_req *req, __u32 size)
4044{
4045 req->_present.modes = 1;
4046 req->modes._present.size = 1;
4047 req->modes.size = size;
4048}
4049static inline void
4050__ethtool_fec_set_req_set_modes_bits_bit(struct ethtool_fec_set_req *req,
4051 struct ethtool_bitset_bit *bit,
4052 unsigned int n_bit)
4053{
4054 free(req->modes.bits.bit);
4055 req->modes.bits.bit = bit;
4056 req->modes.bits.n_bit = n_bit;
4057}
4058static inline void
4059ethtool_fec_set_req_set_auto_(struct ethtool_fec_set_req *req, __u8 auto_)
4060{
4061 req->_present.auto_ = 1;
4062 req->auto_ = auto_;
4063}
4064static inline void
4065ethtool_fec_set_req_set_active(struct ethtool_fec_set_req *req, __u32 active)
4066{
4067 req->_present.active = 1;
4068 req->active = active;
4069}
4070static inline void
4071ethtool_fec_set_req_set_stats_corrected(struct ethtool_fec_set_req *req,
4072 const void *corrected, size_t len)
4073{
4074 free(req->stats.corrected);
4075 req->stats._present.corrected_len = len;
4076 req->stats.corrected = malloc(req->stats._present.corrected_len);
4077 memcpy(req->stats.corrected, corrected, req->stats._present.corrected_len);
4078}
4079static inline void
4080ethtool_fec_set_req_set_stats_uncorr(struct ethtool_fec_set_req *req,
4081 const void *uncorr, size_t len)
4082{
4083 free(req->stats.uncorr);
4084 req->stats._present.uncorr_len = len;
4085 req->stats.uncorr = malloc(req->stats._present.uncorr_len);
4086 memcpy(req->stats.uncorr, uncorr, req->stats._present.uncorr_len);
4087}
4088static inline void
4089ethtool_fec_set_req_set_stats_corr_bits(struct ethtool_fec_set_req *req,
4090 const void *corr_bits, size_t len)
4091{
4092 free(req->stats.corr_bits);
4093 req->stats._present.corr_bits_len = len;
4094 req->stats.corr_bits = malloc(req->stats._present.corr_bits_len);
4095 memcpy(req->stats.corr_bits, corr_bits, req->stats._present.corr_bits_len);
4096}
4097
4098/*
4099 * Set FEC params.
4100 */
4101int ethtool_fec_set(struct ynl_sock *ys, struct ethtool_fec_set_req *req);
4102
4103/* ============== ETHTOOL_MSG_MODULE_EEPROM_GET ============== */
4104/* ETHTOOL_MSG_MODULE_EEPROM_GET - do */
4105struct ethtool_module_eeprom_get_req {
4106 struct {
4107 __u32 header:1;
4108 } _present;
4109
4110 struct ethtool_header header;
4111};
4112
4113static inline struct ethtool_module_eeprom_get_req *
4114ethtool_module_eeprom_get_req_alloc(void)
4115{
4116 return calloc(1, sizeof(struct ethtool_module_eeprom_get_req));
4117}
4118void
4119ethtool_module_eeprom_get_req_free(struct ethtool_module_eeprom_get_req *req);
4120
4121static inline void
4122ethtool_module_eeprom_get_req_set_header_dev_index(struct ethtool_module_eeprom_get_req *req,
4123 __u32 dev_index)
4124{
4125 req->_present.header = 1;
4126 req->header._present.dev_index = 1;
4127 req->header.dev_index = dev_index;
4128}
4129static inline void
4130ethtool_module_eeprom_get_req_set_header_dev_name(struct ethtool_module_eeprom_get_req *req,
4131 const char *dev_name)
4132{
4133 free(req->header.dev_name);
4134 req->header._present.dev_name_len = strlen(dev_name);
4135 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
4136 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
4137 req->header.dev_name[req->header._present.dev_name_len] = 0;
4138}
4139static inline void
4140ethtool_module_eeprom_get_req_set_header_flags(struct ethtool_module_eeprom_get_req *req,
4141 __u32 flags)
4142{
4143 req->_present.header = 1;
4144 req->header._present.flags = 1;
4145 req->header.flags = flags;
4146}
4147
4148struct ethtool_module_eeprom_get_rsp {
4149 struct {
4150 __u32 header:1;
4151 __u32 offset:1;
4152 __u32 length:1;
4153 __u32 page:1;
4154 __u32 bank:1;
4155 __u32 i2c_address:1;
4156 __u32 data_len;
4157 } _present;
4158
4159 struct ethtool_header header;
4160 __u32 offset;
4161 __u32 length;
4162 __u8 page;
4163 __u8 bank;
4164 __u8 i2c_address;
4165 void *data;
4166};
4167
4168void
4169ethtool_module_eeprom_get_rsp_free(struct ethtool_module_eeprom_get_rsp *rsp);
4170
4171/*
4172 * Get module EEPROM params.
4173 */
4174struct ethtool_module_eeprom_get_rsp *
4175ethtool_module_eeprom_get(struct ynl_sock *ys,
4176 struct ethtool_module_eeprom_get_req *req);
4177
4178/* ETHTOOL_MSG_MODULE_EEPROM_GET - dump */
4179struct ethtool_module_eeprom_get_req_dump {
4180 struct {
4181 __u32 header:1;
4182 } _present;
4183
4184 struct ethtool_header header;
4185};
4186
4187static inline struct ethtool_module_eeprom_get_req_dump *
4188ethtool_module_eeprom_get_req_dump_alloc(void)
4189{
4190 return calloc(1, sizeof(struct ethtool_module_eeprom_get_req_dump));
4191}
4192void
4193ethtool_module_eeprom_get_req_dump_free(struct ethtool_module_eeprom_get_req_dump *req);
4194
4195static inline void
4196ethtool_module_eeprom_get_req_dump_set_header_dev_index(struct ethtool_module_eeprom_get_req_dump *req,
4197 __u32 dev_index)
4198{
4199 req->_present.header = 1;
4200 req->header._present.dev_index = 1;
4201 req->header.dev_index = dev_index;
4202}
4203static inline void
4204ethtool_module_eeprom_get_req_dump_set_header_dev_name(struct ethtool_module_eeprom_get_req_dump *req,
4205 const char *dev_name)
4206{
4207 free(req->header.dev_name);
4208 req->header._present.dev_name_len = strlen(dev_name);
4209 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
4210 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
4211 req->header.dev_name[req->header._present.dev_name_len] = 0;
4212}
4213static inline void
4214ethtool_module_eeprom_get_req_dump_set_header_flags(struct ethtool_module_eeprom_get_req_dump *req,
4215 __u32 flags)
4216{
4217 req->_present.header = 1;
4218 req->header._present.flags = 1;
4219 req->header.flags = flags;
4220}
4221
4222struct ethtool_module_eeprom_get_list {
4223 struct ethtool_module_eeprom_get_list *next;
4224 struct ethtool_module_eeprom_get_rsp obj __attribute__ ((aligned (8)));
4225};
4226
4227void
4228ethtool_module_eeprom_get_list_free(struct ethtool_module_eeprom_get_list *rsp);
4229
4230struct ethtool_module_eeprom_get_list *
4231ethtool_module_eeprom_get_dump(struct ynl_sock *ys,
4232 struct ethtool_module_eeprom_get_req_dump *req);
4233
4234/* ============== ETHTOOL_MSG_PHC_VCLOCKS_GET ============== */
4235/* ETHTOOL_MSG_PHC_VCLOCKS_GET - do */
4236struct ethtool_phc_vclocks_get_req {
4237 struct {
4238 __u32 header:1;
4239 } _present;
4240
4241 struct ethtool_header header;
4242};
4243
4244static inline struct ethtool_phc_vclocks_get_req *
4245ethtool_phc_vclocks_get_req_alloc(void)
4246{
4247 return calloc(1, sizeof(struct ethtool_phc_vclocks_get_req));
4248}
4249void ethtool_phc_vclocks_get_req_free(struct ethtool_phc_vclocks_get_req *req);
4250
4251static inline void
4252ethtool_phc_vclocks_get_req_set_header_dev_index(struct ethtool_phc_vclocks_get_req *req,
4253 __u32 dev_index)
4254{
4255 req->_present.header = 1;
4256 req->header._present.dev_index = 1;
4257 req->header.dev_index = dev_index;
4258}
4259static inline void
4260ethtool_phc_vclocks_get_req_set_header_dev_name(struct ethtool_phc_vclocks_get_req *req,
4261 const char *dev_name)
4262{
4263 free(req->header.dev_name);
4264 req->header._present.dev_name_len = strlen(dev_name);
4265 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
4266 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
4267 req->header.dev_name[req->header._present.dev_name_len] = 0;
4268}
4269static inline void
4270ethtool_phc_vclocks_get_req_set_header_flags(struct ethtool_phc_vclocks_get_req *req,
4271 __u32 flags)
4272{
4273 req->_present.header = 1;
4274 req->header._present.flags = 1;
4275 req->header.flags = flags;
4276}
4277
4278struct ethtool_phc_vclocks_get_rsp {
4279 struct {
4280 __u32 header:1;
4281 __u32 num:1;
4282 } _present;
4283
4284 struct ethtool_header header;
4285 __u32 num;
4286};
4287
4288void ethtool_phc_vclocks_get_rsp_free(struct ethtool_phc_vclocks_get_rsp *rsp);
4289
4290/*
4291 * Get PHC VCLOCKs.
4292 */
4293struct ethtool_phc_vclocks_get_rsp *
4294ethtool_phc_vclocks_get(struct ynl_sock *ys,
4295 struct ethtool_phc_vclocks_get_req *req);
4296
4297/* ETHTOOL_MSG_PHC_VCLOCKS_GET - dump */
4298struct ethtool_phc_vclocks_get_req_dump {
4299 struct {
4300 __u32 header:1;
4301 } _present;
4302
4303 struct ethtool_header header;
4304};
4305
4306static inline struct ethtool_phc_vclocks_get_req_dump *
4307ethtool_phc_vclocks_get_req_dump_alloc(void)
4308{
4309 return calloc(1, sizeof(struct ethtool_phc_vclocks_get_req_dump));
4310}
4311void
4312ethtool_phc_vclocks_get_req_dump_free(struct ethtool_phc_vclocks_get_req_dump *req);
4313
4314static inline void
4315ethtool_phc_vclocks_get_req_dump_set_header_dev_index(struct ethtool_phc_vclocks_get_req_dump *req,
4316 __u32 dev_index)
4317{
4318 req->_present.header = 1;
4319 req->header._present.dev_index = 1;
4320 req->header.dev_index = dev_index;
4321}
4322static inline void
4323ethtool_phc_vclocks_get_req_dump_set_header_dev_name(struct ethtool_phc_vclocks_get_req_dump *req,
4324 const char *dev_name)
4325{
4326 free(req->header.dev_name);
4327 req->header._present.dev_name_len = strlen(dev_name);
4328 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
4329 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
4330 req->header.dev_name[req->header._present.dev_name_len] = 0;
4331}
4332static inline void
4333ethtool_phc_vclocks_get_req_dump_set_header_flags(struct ethtool_phc_vclocks_get_req_dump *req,
4334 __u32 flags)
4335{
4336 req->_present.header = 1;
4337 req->header._present.flags = 1;
4338 req->header.flags = flags;
4339}
4340
4341struct ethtool_phc_vclocks_get_list {
4342 struct ethtool_phc_vclocks_get_list *next;
4343 struct ethtool_phc_vclocks_get_rsp obj __attribute__ ((aligned (8)));
4344};
4345
4346void
4347ethtool_phc_vclocks_get_list_free(struct ethtool_phc_vclocks_get_list *rsp);
4348
4349struct ethtool_phc_vclocks_get_list *
4350ethtool_phc_vclocks_get_dump(struct ynl_sock *ys,
4351 struct ethtool_phc_vclocks_get_req_dump *req);
4352
4353/* ============== ETHTOOL_MSG_MODULE_GET ============== */
4354/* ETHTOOL_MSG_MODULE_GET - do */
4355struct ethtool_module_get_req {
4356 struct {
4357 __u32 header:1;
4358 } _present;
4359
4360 struct ethtool_header header;
4361};
4362
4363static inline struct ethtool_module_get_req *ethtool_module_get_req_alloc(void)
4364{
4365 return calloc(1, sizeof(struct ethtool_module_get_req));
4366}
4367void ethtool_module_get_req_free(struct ethtool_module_get_req *req);
4368
4369static inline void
4370ethtool_module_get_req_set_header_dev_index(struct ethtool_module_get_req *req,
4371 __u32 dev_index)
4372{
4373 req->_present.header = 1;
4374 req->header._present.dev_index = 1;
4375 req->header.dev_index = dev_index;
4376}
4377static inline void
4378ethtool_module_get_req_set_header_dev_name(struct ethtool_module_get_req *req,
4379 const char *dev_name)
4380{
4381 free(req->header.dev_name);
4382 req->header._present.dev_name_len = strlen(dev_name);
4383 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
4384 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
4385 req->header.dev_name[req->header._present.dev_name_len] = 0;
4386}
4387static inline void
4388ethtool_module_get_req_set_header_flags(struct ethtool_module_get_req *req,
4389 __u32 flags)
4390{
4391 req->_present.header = 1;
4392 req->header._present.flags = 1;
4393 req->header.flags = flags;
4394}
4395
4396struct ethtool_module_get_rsp {
4397 struct {
4398 __u32 header:1;
4399 __u32 power_mode_policy:1;
4400 __u32 power_mode:1;
4401 } _present;
4402
4403 struct ethtool_header header;
4404 __u8 power_mode_policy;
4405 __u8 power_mode;
4406};
4407
4408void ethtool_module_get_rsp_free(struct ethtool_module_get_rsp *rsp);
4409
4410/*
4411 * Get module params.
4412 */
4413struct ethtool_module_get_rsp *
4414ethtool_module_get(struct ynl_sock *ys, struct ethtool_module_get_req *req);
4415
4416/* ETHTOOL_MSG_MODULE_GET - dump */
4417struct ethtool_module_get_req_dump {
4418 struct {
4419 __u32 header:1;
4420 } _present;
4421
4422 struct ethtool_header header;
4423};
4424
4425static inline struct ethtool_module_get_req_dump *
4426ethtool_module_get_req_dump_alloc(void)
4427{
4428 return calloc(1, sizeof(struct ethtool_module_get_req_dump));
4429}
4430void ethtool_module_get_req_dump_free(struct ethtool_module_get_req_dump *req);
4431
4432static inline void
4433ethtool_module_get_req_dump_set_header_dev_index(struct ethtool_module_get_req_dump *req,
4434 __u32 dev_index)
4435{
4436 req->_present.header = 1;
4437 req->header._present.dev_index = 1;
4438 req->header.dev_index = dev_index;
4439}
4440static inline void
4441ethtool_module_get_req_dump_set_header_dev_name(struct ethtool_module_get_req_dump *req,
4442 const char *dev_name)
4443{
4444 free(req->header.dev_name);
4445 req->header._present.dev_name_len = strlen(dev_name);
4446 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
4447 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
4448 req->header.dev_name[req->header._present.dev_name_len] = 0;
4449}
4450static inline void
4451ethtool_module_get_req_dump_set_header_flags(struct ethtool_module_get_req_dump *req,
4452 __u32 flags)
4453{
4454 req->_present.header = 1;
4455 req->header._present.flags = 1;
4456 req->header.flags = flags;
4457}
4458
4459struct ethtool_module_get_list {
4460 struct ethtool_module_get_list *next;
4461 struct ethtool_module_get_rsp obj __attribute__ ((aligned (8)));
4462};
4463
4464void ethtool_module_get_list_free(struct ethtool_module_get_list *rsp);
4465
4466struct ethtool_module_get_list *
4467ethtool_module_get_dump(struct ynl_sock *ys,
4468 struct ethtool_module_get_req_dump *req);
4469
4470/* ETHTOOL_MSG_MODULE_GET - notify */
4471struct ethtool_module_get_ntf {
4472 __u16 family;
4473 __u8 cmd;
4474 struct ynl_ntf_base_type *next;
4475 void (*free)(struct ethtool_module_get_ntf *ntf);
4476 struct ethtool_module_get_rsp obj __attribute__ ((aligned (8)));
4477};
4478
4479void ethtool_module_get_ntf_free(struct ethtool_module_get_ntf *rsp);
4480
4481/* ============== ETHTOOL_MSG_MODULE_SET ============== */
4482/* ETHTOOL_MSG_MODULE_SET - do */
4483struct ethtool_module_set_req {
4484 struct {
4485 __u32 header:1;
4486 __u32 power_mode_policy:1;
4487 __u32 power_mode:1;
4488 } _present;
4489
4490 struct ethtool_header header;
4491 __u8 power_mode_policy;
4492 __u8 power_mode;
4493};
4494
4495static inline struct ethtool_module_set_req *ethtool_module_set_req_alloc(void)
4496{
4497 return calloc(1, sizeof(struct ethtool_module_set_req));
4498}
4499void ethtool_module_set_req_free(struct ethtool_module_set_req *req);
4500
4501static inline void
4502ethtool_module_set_req_set_header_dev_index(struct ethtool_module_set_req *req,
4503 __u32 dev_index)
4504{
4505 req->_present.header = 1;
4506 req->header._present.dev_index = 1;
4507 req->header.dev_index = dev_index;
4508}
4509static inline void
4510ethtool_module_set_req_set_header_dev_name(struct ethtool_module_set_req *req,
4511 const char *dev_name)
4512{
4513 free(req->header.dev_name);
4514 req->header._present.dev_name_len = strlen(dev_name);
4515 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
4516 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
4517 req->header.dev_name[req->header._present.dev_name_len] = 0;
4518}
4519static inline void
4520ethtool_module_set_req_set_header_flags(struct ethtool_module_set_req *req,
4521 __u32 flags)
4522{
4523 req->_present.header = 1;
4524 req->header._present.flags = 1;
4525 req->header.flags = flags;
4526}
4527static inline void
4528ethtool_module_set_req_set_power_mode_policy(struct ethtool_module_set_req *req,
4529 __u8 power_mode_policy)
4530{
4531 req->_present.power_mode_policy = 1;
4532 req->power_mode_policy = power_mode_policy;
4533}
4534static inline void
4535ethtool_module_set_req_set_power_mode(struct ethtool_module_set_req *req,
4536 __u8 power_mode)
4537{
4538 req->_present.power_mode = 1;
4539 req->power_mode = power_mode;
4540}
4541
4542/*
4543 * Set module params.
4544 */
4545int ethtool_module_set(struct ynl_sock *ys, struct ethtool_module_set_req *req);
4546
4547/* ============== ETHTOOL_MSG_PSE_GET ============== */
4548/* ETHTOOL_MSG_PSE_GET - do */
4549struct ethtool_pse_get_req {
4550 struct {
4551 __u32 header:1;
4552 } _present;
4553
4554 struct ethtool_header header;
4555};
4556
4557static inline struct ethtool_pse_get_req *ethtool_pse_get_req_alloc(void)
4558{
4559 return calloc(1, sizeof(struct ethtool_pse_get_req));
4560}
4561void ethtool_pse_get_req_free(struct ethtool_pse_get_req *req);
4562
4563static inline void
4564ethtool_pse_get_req_set_header_dev_index(struct ethtool_pse_get_req *req,
4565 __u32 dev_index)
4566{
4567 req->_present.header = 1;
4568 req->header._present.dev_index = 1;
4569 req->header.dev_index = dev_index;
4570}
4571static inline void
4572ethtool_pse_get_req_set_header_dev_name(struct ethtool_pse_get_req *req,
4573 const char *dev_name)
4574{
4575 free(req->header.dev_name);
4576 req->header._present.dev_name_len = strlen(dev_name);
4577 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
4578 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
4579 req->header.dev_name[req->header._present.dev_name_len] = 0;
4580}
4581static inline void
4582ethtool_pse_get_req_set_header_flags(struct ethtool_pse_get_req *req,
4583 __u32 flags)
4584{
4585 req->_present.header = 1;
4586 req->header._present.flags = 1;
4587 req->header.flags = flags;
4588}
4589
4590struct ethtool_pse_get_rsp {
4591 struct {
4592 __u32 header:1;
4593 __u32 admin_state:1;
4594 __u32 admin_control:1;
4595 __u32 pw_d_status:1;
4596 } _present;
4597
4598 struct ethtool_header header;
4599 __u32 admin_state;
4600 __u32 admin_control;
4601 __u32 pw_d_status;
4602};
4603
4604void ethtool_pse_get_rsp_free(struct ethtool_pse_get_rsp *rsp);
4605
4606/*
4607 * Get Power Sourcing Equipment params.
4608 */
4609struct ethtool_pse_get_rsp *
4610ethtool_pse_get(struct ynl_sock *ys, struct ethtool_pse_get_req *req);
4611
4612/* ETHTOOL_MSG_PSE_GET - dump */
4613struct ethtool_pse_get_req_dump {
4614 struct {
4615 __u32 header:1;
4616 } _present;
4617
4618 struct ethtool_header header;
4619};
4620
4621static inline struct ethtool_pse_get_req_dump *
4622ethtool_pse_get_req_dump_alloc(void)
4623{
4624 return calloc(1, sizeof(struct ethtool_pse_get_req_dump));
4625}
4626void ethtool_pse_get_req_dump_free(struct ethtool_pse_get_req_dump *req);
4627
4628static inline void
4629ethtool_pse_get_req_dump_set_header_dev_index(struct ethtool_pse_get_req_dump *req,
4630 __u32 dev_index)
4631{
4632 req->_present.header = 1;
4633 req->header._present.dev_index = 1;
4634 req->header.dev_index = dev_index;
4635}
4636static inline void
4637ethtool_pse_get_req_dump_set_header_dev_name(struct ethtool_pse_get_req_dump *req,
4638 const char *dev_name)
4639{
4640 free(req->header.dev_name);
4641 req->header._present.dev_name_len = strlen(dev_name);
4642 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
4643 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
4644 req->header.dev_name[req->header._present.dev_name_len] = 0;
4645}
4646static inline void
4647ethtool_pse_get_req_dump_set_header_flags(struct ethtool_pse_get_req_dump *req,
4648 __u32 flags)
4649{
4650 req->_present.header = 1;
4651 req->header._present.flags = 1;
4652 req->header.flags = flags;
4653}
4654
4655struct ethtool_pse_get_list {
4656 struct ethtool_pse_get_list *next;
4657 struct ethtool_pse_get_rsp obj __attribute__ ((aligned (8)));
4658};
4659
4660void ethtool_pse_get_list_free(struct ethtool_pse_get_list *rsp);
4661
4662struct ethtool_pse_get_list *
4663ethtool_pse_get_dump(struct ynl_sock *ys, struct ethtool_pse_get_req_dump *req);
4664
4665/* ============== ETHTOOL_MSG_PSE_SET ============== */
4666/* ETHTOOL_MSG_PSE_SET - do */
4667struct ethtool_pse_set_req {
4668 struct {
4669 __u32 header:1;
4670 __u32 admin_state:1;
4671 __u32 admin_control:1;
4672 __u32 pw_d_status:1;
4673 } _present;
4674
4675 struct ethtool_header header;
4676 __u32 admin_state;
4677 __u32 admin_control;
4678 __u32 pw_d_status;
4679};
4680
4681static inline struct ethtool_pse_set_req *ethtool_pse_set_req_alloc(void)
4682{
4683 return calloc(1, sizeof(struct ethtool_pse_set_req));
4684}
4685void ethtool_pse_set_req_free(struct ethtool_pse_set_req *req);
4686
4687static inline void
4688ethtool_pse_set_req_set_header_dev_index(struct ethtool_pse_set_req *req,
4689 __u32 dev_index)
4690{
4691 req->_present.header = 1;
4692 req->header._present.dev_index = 1;
4693 req->header.dev_index = dev_index;
4694}
4695static inline void
4696ethtool_pse_set_req_set_header_dev_name(struct ethtool_pse_set_req *req,
4697 const char *dev_name)
4698{
4699 free(req->header.dev_name);
4700 req->header._present.dev_name_len = strlen(dev_name);
4701 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
4702 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
4703 req->header.dev_name[req->header._present.dev_name_len] = 0;
4704}
4705static inline void
4706ethtool_pse_set_req_set_header_flags(struct ethtool_pse_set_req *req,
4707 __u32 flags)
4708{
4709 req->_present.header = 1;
4710 req->header._present.flags = 1;
4711 req->header.flags = flags;
4712}
4713static inline void
4714ethtool_pse_set_req_set_admin_state(struct ethtool_pse_set_req *req,
4715 __u32 admin_state)
4716{
4717 req->_present.admin_state = 1;
4718 req->admin_state = admin_state;
4719}
4720static inline void
4721ethtool_pse_set_req_set_admin_control(struct ethtool_pse_set_req *req,
4722 __u32 admin_control)
4723{
4724 req->_present.admin_control = 1;
4725 req->admin_control = admin_control;
4726}
4727static inline void
4728ethtool_pse_set_req_set_pw_d_status(struct ethtool_pse_set_req *req,
4729 __u32 pw_d_status)
4730{
4731 req->_present.pw_d_status = 1;
4732 req->pw_d_status = pw_d_status;
4733}
4734
4735/*
4736 * Set Power Sourcing Equipment params.
4737 */
4738int ethtool_pse_set(struct ynl_sock *ys, struct ethtool_pse_set_req *req);
4739
4740/* ============== ETHTOOL_MSG_RSS_GET ============== */
4741/* ETHTOOL_MSG_RSS_GET - do */
4742struct ethtool_rss_get_req {
4743 struct {
4744 __u32 header:1;
4745 } _present;
4746
4747 struct ethtool_header header;
4748};
4749
4750static inline struct ethtool_rss_get_req *ethtool_rss_get_req_alloc(void)
4751{
4752 return calloc(1, sizeof(struct ethtool_rss_get_req));
4753}
4754void ethtool_rss_get_req_free(struct ethtool_rss_get_req *req);
4755
4756static inline void
4757ethtool_rss_get_req_set_header_dev_index(struct ethtool_rss_get_req *req,
4758 __u32 dev_index)
4759{
4760 req->_present.header = 1;
4761 req->header._present.dev_index = 1;
4762 req->header.dev_index = dev_index;
4763}
4764static inline void
4765ethtool_rss_get_req_set_header_dev_name(struct ethtool_rss_get_req *req,
4766 const char *dev_name)
4767{
4768 free(req->header.dev_name);
4769 req->header._present.dev_name_len = strlen(dev_name);
4770 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
4771 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
4772 req->header.dev_name[req->header._present.dev_name_len] = 0;
4773}
4774static inline void
4775ethtool_rss_get_req_set_header_flags(struct ethtool_rss_get_req *req,
4776 __u32 flags)
4777{
4778 req->_present.header = 1;
4779 req->header._present.flags = 1;
4780 req->header.flags = flags;
4781}
4782
4783struct ethtool_rss_get_rsp {
4784 struct {
4785 __u32 header:1;
4786 __u32 context:1;
4787 __u32 hfunc:1;
4788 __u32 indir_len;
4789 __u32 hkey_len;
4790 } _present;
4791
4792 struct ethtool_header header;
4793 __u32 context;
4794 __u32 hfunc;
4795 void *indir;
4796 void *hkey;
4797};
4798
4799void ethtool_rss_get_rsp_free(struct ethtool_rss_get_rsp *rsp);
4800
4801/*
4802 * Get RSS params.
4803 */
4804struct ethtool_rss_get_rsp *
4805ethtool_rss_get(struct ynl_sock *ys, struct ethtool_rss_get_req *req);
4806
4807/* ETHTOOL_MSG_RSS_GET - dump */
4808struct ethtool_rss_get_req_dump {
4809 struct {
4810 __u32 header:1;
4811 } _present;
4812
4813 struct ethtool_header header;
4814};
4815
4816static inline struct ethtool_rss_get_req_dump *
4817ethtool_rss_get_req_dump_alloc(void)
4818{
4819 return calloc(1, sizeof(struct ethtool_rss_get_req_dump));
4820}
4821void ethtool_rss_get_req_dump_free(struct ethtool_rss_get_req_dump *req);
4822
4823static inline void
4824ethtool_rss_get_req_dump_set_header_dev_index(struct ethtool_rss_get_req_dump *req,
4825 __u32 dev_index)
4826{
4827 req->_present.header = 1;
4828 req->header._present.dev_index = 1;
4829 req->header.dev_index = dev_index;
4830}
4831static inline void
4832ethtool_rss_get_req_dump_set_header_dev_name(struct ethtool_rss_get_req_dump *req,
4833 const char *dev_name)
4834{
4835 free(req->header.dev_name);
4836 req->header._present.dev_name_len = strlen(dev_name);
4837 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
4838 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
4839 req->header.dev_name[req->header._present.dev_name_len] = 0;
4840}
4841static inline void
4842ethtool_rss_get_req_dump_set_header_flags(struct ethtool_rss_get_req_dump *req,
4843 __u32 flags)
4844{
4845 req->_present.header = 1;
4846 req->header._present.flags = 1;
4847 req->header.flags = flags;
4848}
4849
4850struct ethtool_rss_get_list {
4851 struct ethtool_rss_get_list *next;
4852 struct ethtool_rss_get_rsp obj __attribute__ ((aligned (8)));
4853};
4854
4855void ethtool_rss_get_list_free(struct ethtool_rss_get_list *rsp);
4856
4857struct ethtool_rss_get_list *
4858ethtool_rss_get_dump(struct ynl_sock *ys, struct ethtool_rss_get_req_dump *req);
4859
4860/* ============== ETHTOOL_MSG_PLCA_GET_CFG ============== */
4861/* ETHTOOL_MSG_PLCA_GET_CFG - do */
4862struct ethtool_plca_get_cfg_req {
4863 struct {
4864 __u32 header:1;
4865 } _present;
4866
4867 struct ethtool_header header;
4868};
4869
4870static inline struct ethtool_plca_get_cfg_req *
4871ethtool_plca_get_cfg_req_alloc(void)
4872{
4873 return calloc(1, sizeof(struct ethtool_plca_get_cfg_req));
4874}
4875void ethtool_plca_get_cfg_req_free(struct ethtool_plca_get_cfg_req *req);
4876
4877static inline void
4878ethtool_plca_get_cfg_req_set_header_dev_index(struct ethtool_plca_get_cfg_req *req,
4879 __u32 dev_index)
4880{
4881 req->_present.header = 1;
4882 req->header._present.dev_index = 1;
4883 req->header.dev_index = dev_index;
4884}
4885static inline void
4886ethtool_plca_get_cfg_req_set_header_dev_name(struct ethtool_plca_get_cfg_req *req,
4887 const char *dev_name)
4888{
4889 free(req->header.dev_name);
4890 req->header._present.dev_name_len = strlen(dev_name);
4891 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
4892 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
4893 req->header.dev_name[req->header._present.dev_name_len] = 0;
4894}
4895static inline void
4896ethtool_plca_get_cfg_req_set_header_flags(struct ethtool_plca_get_cfg_req *req,
4897 __u32 flags)
4898{
4899 req->_present.header = 1;
4900 req->header._present.flags = 1;
4901 req->header.flags = flags;
4902}
4903
4904struct ethtool_plca_get_cfg_rsp {
4905 struct {
4906 __u32 header:1;
4907 __u32 version:1;
4908 __u32 enabled:1;
4909 __u32 status:1;
4910 __u32 node_cnt:1;
4911 __u32 node_id:1;
4912 __u32 to_tmr:1;
4913 __u32 burst_cnt:1;
4914 __u32 burst_tmr:1;
4915 } _present;
4916
4917 struct ethtool_header header;
4918 __u16 version;
4919 __u8 enabled;
4920 __u8 status;
4921 __u32 node_cnt;
4922 __u32 node_id;
4923 __u32 to_tmr;
4924 __u32 burst_cnt;
4925 __u32 burst_tmr;
4926};
4927
4928void ethtool_plca_get_cfg_rsp_free(struct ethtool_plca_get_cfg_rsp *rsp);
4929
4930/*
4931 * Get PLCA params.
4932 */
4933struct ethtool_plca_get_cfg_rsp *
4934ethtool_plca_get_cfg(struct ynl_sock *ys, struct ethtool_plca_get_cfg_req *req);
4935
4936/* ETHTOOL_MSG_PLCA_GET_CFG - dump */
4937struct ethtool_plca_get_cfg_req_dump {
4938 struct {
4939 __u32 header:1;
4940 } _present;
4941
4942 struct ethtool_header header;
4943};
4944
4945static inline struct ethtool_plca_get_cfg_req_dump *
4946ethtool_plca_get_cfg_req_dump_alloc(void)
4947{
4948 return calloc(1, sizeof(struct ethtool_plca_get_cfg_req_dump));
4949}
4950void
4951ethtool_plca_get_cfg_req_dump_free(struct ethtool_plca_get_cfg_req_dump *req);
4952
4953static inline void
4954ethtool_plca_get_cfg_req_dump_set_header_dev_index(struct ethtool_plca_get_cfg_req_dump *req,
4955 __u32 dev_index)
4956{
4957 req->_present.header = 1;
4958 req->header._present.dev_index = 1;
4959 req->header.dev_index = dev_index;
4960}
4961static inline void
4962ethtool_plca_get_cfg_req_dump_set_header_dev_name(struct ethtool_plca_get_cfg_req_dump *req,
4963 const char *dev_name)
4964{
4965 free(req->header.dev_name);
4966 req->header._present.dev_name_len = strlen(dev_name);
4967 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
4968 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
4969 req->header.dev_name[req->header._present.dev_name_len] = 0;
4970}
4971static inline void
4972ethtool_plca_get_cfg_req_dump_set_header_flags(struct ethtool_plca_get_cfg_req_dump *req,
4973 __u32 flags)
4974{
4975 req->_present.header = 1;
4976 req->header._present.flags = 1;
4977 req->header.flags = flags;
4978}
4979
4980struct ethtool_plca_get_cfg_list {
4981 struct ethtool_plca_get_cfg_list *next;
4982 struct ethtool_plca_get_cfg_rsp obj __attribute__ ((aligned (8)));
4983};
4984
4985void ethtool_plca_get_cfg_list_free(struct ethtool_plca_get_cfg_list *rsp);
4986
4987struct ethtool_plca_get_cfg_list *
4988ethtool_plca_get_cfg_dump(struct ynl_sock *ys,
4989 struct ethtool_plca_get_cfg_req_dump *req);
4990
4991/* ETHTOOL_MSG_PLCA_GET_CFG - notify */
4992struct ethtool_plca_get_cfg_ntf {
4993 __u16 family;
4994 __u8 cmd;
4995 struct ynl_ntf_base_type *next;
4996 void (*free)(struct ethtool_plca_get_cfg_ntf *ntf);
4997 struct ethtool_plca_get_cfg_rsp obj __attribute__ ((aligned (8)));
4998};
4999
5000void ethtool_plca_get_cfg_ntf_free(struct ethtool_plca_get_cfg_ntf *rsp);
5001
5002/* ============== ETHTOOL_MSG_PLCA_SET_CFG ============== */
5003/* ETHTOOL_MSG_PLCA_SET_CFG - do */
5004struct ethtool_plca_set_cfg_req {
5005 struct {
5006 __u32 header:1;
5007 __u32 version:1;
5008 __u32 enabled:1;
5009 __u32 status:1;
5010 __u32 node_cnt:1;
5011 __u32 node_id:1;
5012 __u32 to_tmr:1;
5013 __u32 burst_cnt:1;
5014 __u32 burst_tmr:1;
5015 } _present;
5016
5017 struct ethtool_header header;
5018 __u16 version;
5019 __u8 enabled;
5020 __u8 status;
5021 __u32 node_cnt;
5022 __u32 node_id;
5023 __u32 to_tmr;
5024 __u32 burst_cnt;
5025 __u32 burst_tmr;
5026};
5027
5028static inline struct ethtool_plca_set_cfg_req *
5029ethtool_plca_set_cfg_req_alloc(void)
5030{
5031 return calloc(1, sizeof(struct ethtool_plca_set_cfg_req));
5032}
5033void ethtool_plca_set_cfg_req_free(struct ethtool_plca_set_cfg_req *req);
5034
5035static inline void
5036ethtool_plca_set_cfg_req_set_header_dev_index(struct ethtool_plca_set_cfg_req *req,
5037 __u32 dev_index)
5038{
5039 req->_present.header = 1;
5040 req->header._present.dev_index = 1;
5041 req->header.dev_index = dev_index;
5042}
5043static inline void
5044ethtool_plca_set_cfg_req_set_header_dev_name(struct ethtool_plca_set_cfg_req *req,
5045 const char *dev_name)
5046{
5047 free(req->header.dev_name);
5048 req->header._present.dev_name_len = strlen(dev_name);
5049 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
5050 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
5051 req->header.dev_name[req->header._present.dev_name_len] = 0;
5052}
5053static inline void
5054ethtool_plca_set_cfg_req_set_header_flags(struct ethtool_plca_set_cfg_req *req,
5055 __u32 flags)
5056{
5057 req->_present.header = 1;
5058 req->header._present.flags = 1;
5059 req->header.flags = flags;
5060}
5061static inline void
5062ethtool_plca_set_cfg_req_set_version(struct ethtool_plca_set_cfg_req *req,
5063 __u16 version)
5064{
5065 req->_present.version = 1;
5066 req->version = version;
5067}
5068static inline void
5069ethtool_plca_set_cfg_req_set_enabled(struct ethtool_plca_set_cfg_req *req,
5070 __u8 enabled)
5071{
5072 req->_present.enabled = 1;
5073 req->enabled = enabled;
5074}
5075static inline void
5076ethtool_plca_set_cfg_req_set_status(struct ethtool_plca_set_cfg_req *req,
5077 __u8 status)
5078{
5079 req->_present.status = 1;
5080 req->status = status;
5081}
5082static inline void
5083ethtool_plca_set_cfg_req_set_node_cnt(struct ethtool_plca_set_cfg_req *req,
5084 __u32 node_cnt)
5085{
5086 req->_present.node_cnt = 1;
5087 req->node_cnt = node_cnt;
5088}
5089static inline void
5090ethtool_plca_set_cfg_req_set_node_id(struct ethtool_plca_set_cfg_req *req,
5091 __u32 node_id)
5092{
5093 req->_present.node_id = 1;
5094 req->node_id = node_id;
5095}
5096static inline void
5097ethtool_plca_set_cfg_req_set_to_tmr(struct ethtool_plca_set_cfg_req *req,
5098 __u32 to_tmr)
5099{
5100 req->_present.to_tmr = 1;
5101 req->to_tmr = to_tmr;
5102}
5103static inline void
5104ethtool_plca_set_cfg_req_set_burst_cnt(struct ethtool_plca_set_cfg_req *req,
5105 __u32 burst_cnt)
5106{
5107 req->_present.burst_cnt = 1;
5108 req->burst_cnt = burst_cnt;
5109}
5110static inline void
5111ethtool_plca_set_cfg_req_set_burst_tmr(struct ethtool_plca_set_cfg_req *req,
5112 __u32 burst_tmr)
5113{
5114 req->_present.burst_tmr = 1;
5115 req->burst_tmr = burst_tmr;
5116}
5117
5118/*
5119 * Set PLCA params.
5120 */
5121int ethtool_plca_set_cfg(struct ynl_sock *ys,
5122 struct ethtool_plca_set_cfg_req *req);
5123
5124/* ============== ETHTOOL_MSG_PLCA_GET_STATUS ============== */
5125/* ETHTOOL_MSG_PLCA_GET_STATUS - do */
5126struct ethtool_plca_get_status_req {
5127 struct {
5128 __u32 header:1;
5129 } _present;
5130
5131 struct ethtool_header header;
5132};
5133
5134static inline struct ethtool_plca_get_status_req *
5135ethtool_plca_get_status_req_alloc(void)
5136{
5137 return calloc(1, sizeof(struct ethtool_plca_get_status_req));
5138}
5139void ethtool_plca_get_status_req_free(struct ethtool_plca_get_status_req *req);
5140
5141static inline void
5142ethtool_plca_get_status_req_set_header_dev_index(struct ethtool_plca_get_status_req *req,
5143 __u32 dev_index)
5144{
5145 req->_present.header = 1;
5146 req->header._present.dev_index = 1;
5147 req->header.dev_index = dev_index;
5148}
5149static inline void
5150ethtool_plca_get_status_req_set_header_dev_name(struct ethtool_plca_get_status_req *req,
5151 const char *dev_name)
5152{
5153 free(req->header.dev_name);
5154 req->header._present.dev_name_len = strlen(dev_name);
5155 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
5156 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
5157 req->header.dev_name[req->header._present.dev_name_len] = 0;
5158}
5159static inline void
5160ethtool_plca_get_status_req_set_header_flags(struct ethtool_plca_get_status_req *req,
5161 __u32 flags)
5162{
5163 req->_present.header = 1;
5164 req->header._present.flags = 1;
5165 req->header.flags = flags;
5166}
5167
5168struct ethtool_plca_get_status_rsp {
5169 struct {
5170 __u32 header:1;
5171 __u32 version:1;
5172 __u32 enabled:1;
5173 __u32 status:1;
5174 __u32 node_cnt:1;
5175 __u32 node_id:1;
5176 __u32 to_tmr:1;
5177 __u32 burst_cnt:1;
5178 __u32 burst_tmr:1;
5179 } _present;
5180
5181 struct ethtool_header header;
5182 __u16 version;
5183 __u8 enabled;
5184 __u8 status;
5185 __u32 node_cnt;
5186 __u32 node_id;
5187 __u32 to_tmr;
5188 __u32 burst_cnt;
5189 __u32 burst_tmr;
5190};
5191
5192void ethtool_plca_get_status_rsp_free(struct ethtool_plca_get_status_rsp *rsp);
5193
5194/*
5195 * Get PLCA status params.
5196 */
5197struct ethtool_plca_get_status_rsp *
5198ethtool_plca_get_status(struct ynl_sock *ys,
5199 struct ethtool_plca_get_status_req *req);
5200
5201/* ETHTOOL_MSG_PLCA_GET_STATUS - dump */
5202struct ethtool_plca_get_status_req_dump {
5203 struct {
5204 __u32 header:1;
5205 } _present;
5206
5207 struct ethtool_header header;
5208};
5209
5210static inline struct ethtool_plca_get_status_req_dump *
5211ethtool_plca_get_status_req_dump_alloc(void)
5212{
5213 return calloc(1, sizeof(struct ethtool_plca_get_status_req_dump));
5214}
5215void
5216ethtool_plca_get_status_req_dump_free(struct ethtool_plca_get_status_req_dump *req);
5217
5218static inline void
5219ethtool_plca_get_status_req_dump_set_header_dev_index(struct ethtool_plca_get_status_req_dump *req,
5220 __u32 dev_index)
5221{
5222 req->_present.header = 1;
5223 req->header._present.dev_index = 1;
5224 req->header.dev_index = dev_index;
5225}
5226static inline void
5227ethtool_plca_get_status_req_dump_set_header_dev_name(struct ethtool_plca_get_status_req_dump *req,
5228 const char *dev_name)
5229{
5230 free(req->header.dev_name);
5231 req->header._present.dev_name_len = strlen(dev_name);
5232 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
5233 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
5234 req->header.dev_name[req->header._present.dev_name_len] = 0;
5235}
5236static inline void
5237ethtool_plca_get_status_req_dump_set_header_flags(struct ethtool_plca_get_status_req_dump *req,
5238 __u32 flags)
5239{
5240 req->_present.header = 1;
5241 req->header._present.flags = 1;
5242 req->header.flags = flags;
5243}
5244
5245struct ethtool_plca_get_status_list {
5246 struct ethtool_plca_get_status_list *next;
5247 struct ethtool_plca_get_status_rsp obj __attribute__ ((aligned (8)));
5248};
5249
5250void
5251ethtool_plca_get_status_list_free(struct ethtool_plca_get_status_list *rsp);
5252
5253struct ethtool_plca_get_status_list *
5254ethtool_plca_get_status_dump(struct ynl_sock *ys,
5255 struct ethtool_plca_get_status_req_dump *req);
5256
5257/* ============== ETHTOOL_MSG_MM_GET ============== */
5258/* ETHTOOL_MSG_MM_GET - do */
5259struct ethtool_mm_get_req {
5260 struct {
5261 __u32 header:1;
5262 } _present;
5263
5264 struct ethtool_header header;
5265};
5266
5267static inline struct ethtool_mm_get_req *ethtool_mm_get_req_alloc(void)
5268{
5269 return calloc(1, sizeof(struct ethtool_mm_get_req));
5270}
5271void ethtool_mm_get_req_free(struct ethtool_mm_get_req *req);
5272
5273static inline void
5274ethtool_mm_get_req_set_header_dev_index(struct ethtool_mm_get_req *req,
5275 __u32 dev_index)
5276{
5277 req->_present.header = 1;
5278 req->header._present.dev_index = 1;
5279 req->header.dev_index = dev_index;
5280}
5281static inline void
5282ethtool_mm_get_req_set_header_dev_name(struct ethtool_mm_get_req *req,
5283 const char *dev_name)
5284{
5285 free(req->header.dev_name);
5286 req->header._present.dev_name_len = strlen(dev_name);
5287 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
5288 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
5289 req->header.dev_name[req->header._present.dev_name_len] = 0;
5290}
5291static inline void
5292ethtool_mm_get_req_set_header_flags(struct ethtool_mm_get_req *req,
5293 __u32 flags)
5294{
5295 req->_present.header = 1;
5296 req->header._present.flags = 1;
5297 req->header.flags = flags;
5298}
5299
5300struct ethtool_mm_get_rsp {
5301 struct {
5302 __u32 header:1;
5303 __u32 pmac_enabled:1;
5304 __u32 tx_enabled:1;
5305 __u32 tx_active:1;
5306 __u32 tx_min_frag_size:1;
5307 __u32 rx_min_frag_size:1;
5308 __u32 verify_enabled:1;
5309 __u32 verify_time:1;
5310 __u32 max_verify_time:1;
5311 __u32 stats:1;
5312 } _present;
5313
5314 struct ethtool_header header;
5315 __u8 pmac_enabled;
5316 __u8 tx_enabled;
5317 __u8 tx_active;
5318 __u32 tx_min_frag_size;
5319 __u32 rx_min_frag_size;
5320 __u8 verify_enabled;
5321 __u32 verify_time;
5322 __u32 max_verify_time;
5323 struct ethtool_mm_stat stats;
5324};
5325
5326void ethtool_mm_get_rsp_free(struct ethtool_mm_get_rsp *rsp);
5327
5328/*
5329 * Get MAC Merge configuration and state
5330 */
5331struct ethtool_mm_get_rsp *
5332ethtool_mm_get(struct ynl_sock *ys, struct ethtool_mm_get_req *req);
5333
5334/* ETHTOOL_MSG_MM_GET - dump */
5335struct ethtool_mm_get_req_dump {
5336 struct {
5337 __u32 header:1;
5338 } _present;
5339
5340 struct ethtool_header header;
5341};
5342
5343static inline struct ethtool_mm_get_req_dump *
5344ethtool_mm_get_req_dump_alloc(void)
5345{
5346 return calloc(1, sizeof(struct ethtool_mm_get_req_dump));
5347}
5348void ethtool_mm_get_req_dump_free(struct ethtool_mm_get_req_dump *req);
5349
5350static inline void
5351ethtool_mm_get_req_dump_set_header_dev_index(struct ethtool_mm_get_req_dump *req,
5352 __u32 dev_index)
5353{
5354 req->_present.header = 1;
5355 req->header._present.dev_index = 1;
5356 req->header.dev_index = dev_index;
5357}
5358static inline void
5359ethtool_mm_get_req_dump_set_header_dev_name(struct ethtool_mm_get_req_dump *req,
5360 const char *dev_name)
5361{
5362 free(req->header.dev_name);
5363 req->header._present.dev_name_len = strlen(dev_name);
5364 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
5365 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
5366 req->header.dev_name[req->header._present.dev_name_len] = 0;
5367}
5368static inline void
5369ethtool_mm_get_req_dump_set_header_flags(struct ethtool_mm_get_req_dump *req,
5370 __u32 flags)
5371{
5372 req->_present.header = 1;
5373 req->header._present.flags = 1;
5374 req->header.flags = flags;
5375}
5376
5377struct ethtool_mm_get_list {
5378 struct ethtool_mm_get_list *next;
5379 struct ethtool_mm_get_rsp obj __attribute__ ((aligned (8)));
5380};
5381
5382void ethtool_mm_get_list_free(struct ethtool_mm_get_list *rsp);
5383
5384struct ethtool_mm_get_list *
5385ethtool_mm_get_dump(struct ynl_sock *ys, struct ethtool_mm_get_req_dump *req);
5386
5387/* ETHTOOL_MSG_MM_GET - notify */
5388struct ethtool_mm_get_ntf {
5389 __u16 family;
5390 __u8 cmd;
5391 struct ynl_ntf_base_type *next;
5392 void (*free)(struct ethtool_mm_get_ntf *ntf);
5393 struct ethtool_mm_get_rsp obj __attribute__ ((aligned (8)));
5394};
5395
5396void ethtool_mm_get_ntf_free(struct ethtool_mm_get_ntf *rsp);
5397
5398/* ============== ETHTOOL_MSG_MM_SET ============== */
5399/* ETHTOOL_MSG_MM_SET - do */
5400struct ethtool_mm_set_req {
5401 struct {
5402 __u32 header:1;
5403 __u32 verify_enabled:1;
5404 __u32 verify_time:1;
5405 __u32 tx_enabled:1;
5406 __u32 pmac_enabled:1;
5407 __u32 tx_min_frag_size:1;
5408 } _present;
5409
5410 struct ethtool_header header;
5411 __u8 verify_enabled;
5412 __u32 verify_time;
5413 __u8 tx_enabled;
5414 __u8 pmac_enabled;
5415 __u32 tx_min_frag_size;
5416};
5417
5418static inline struct ethtool_mm_set_req *ethtool_mm_set_req_alloc(void)
5419{
5420 return calloc(1, sizeof(struct ethtool_mm_set_req));
5421}
5422void ethtool_mm_set_req_free(struct ethtool_mm_set_req *req);
5423
5424static inline void
5425ethtool_mm_set_req_set_header_dev_index(struct ethtool_mm_set_req *req,
5426 __u32 dev_index)
5427{
5428 req->_present.header = 1;
5429 req->header._present.dev_index = 1;
5430 req->header.dev_index = dev_index;
5431}
5432static inline void
5433ethtool_mm_set_req_set_header_dev_name(struct ethtool_mm_set_req *req,
5434 const char *dev_name)
5435{
5436 free(req->header.dev_name);
5437 req->header._present.dev_name_len = strlen(dev_name);
5438 req->header.dev_name = malloc(req->header._present.dev_name_len + 1);
5439 memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len);
5440 req->header.dev_name[req->header._present.dev_name_len] = 0;
5441}
5442static inline void
5443ethtool_mm_set_req_set_header_flags(struct ethtool_mm_set_req *req,
5444 __u32 flags)
5445{
5446 req->_present.header = 1;
5447 req->header._present.flags = 1;
5448 req->header.flags = flags;
5449}
5450static inline void
5451ethtool_mm_set_req_set_verify_enabled(struct ethtool_mm_set_req *req,
5452 __u8 verify_enabled)
5453{
5454 req->_present.verify_enabled = 1;
5455 req->verify_enabled = verify_enabled;
5456}
5457static inline void
5458ethtool_mm_set_req_set_verify_time(struct ethtool_mm_set_req *req,
5459 __u32 verify_time)
5460{
5461 req->_present.verify_time = 1;
5462 req->verify_time = verify_time;
5463}
5464static inline void
5465ethtool_mm_set_req_set_tx_enabled(struct ethtool_mm_set_req *req,
5466 __u8 tx_enabled)
5467{
5468 req->_present.tx_enabled = 1;
5469 req->tx_enabled = tx_enabled;
5470}
5471static inline void
5472ethtool_mm_set_req_set_pmac_enabled(struct ethtool_mm_set_req *req,
5473 __u8 pmac_enabled)
5474{
5475 req->_present.pmac_enabled = 1;
5476 req->pmac_enabled = pmac_enabled;
5477}
5478static inline void
5479ethtool_mm_set_req_set_tx_min_frag_size(struct ethtool_mm_set_req *req,
5480 __u32 tx_min_frag_size)
5481{
5482 req->_present.tx_min_frag_size = 1;
5483 req->tx_min_frag_size = tx_min_frag_size;
5484}
5485
5486/*
5487 * Set MAC Merge configuration
5488 */
5489int ethtool_mm_set(struct ynl_sock *ys, struct ethtool_mm_set_req *req);
5490
5491/* ETHTOOL_MSG_CABLE_TEST_NTF - event */
5492struct ethtool_cable_test_ntf_rsp {
5493 struct {
5494 __u32 header:1;
5495 __u32 status:1;
5496 } _present;
5497
5498 struct ethtool_header header;
5499 __u8 status;
5500};
5501
5502struct ethtool_cable_test_ntf {
5503 __u16 family;
5504 __u8 cmd;
5505 struct ynl_ntf_base_type *next;
5506 void (*free)(struct ethtool_cable_test_ntf *ntf);
5507 struct ethtool_cable_test_ntf_rsp obj __attribute__ ((aligned (8)));
5508};
5509
5510void ethtool_cable_test_ntf_free(struct ethtool_cable_test_ntf *rsp);
5511
5512/* ETHTOOL_MSG_CABLE_TEST_TDR_NTF - event */
5513struct ethtool_cable_test_tdr_ntf_rsp {
5514 struct {
5515 __u32 header:1;
5516 __u32 status:1;
5517 __u32 nest:1;
5518 } _present;
5519
5520 struct ethtool_header header;
5521 __u8 status;
5522 struct ethtool_cable_nest nest;
5523};
5524
5525struct ethtool_cable_test_tdr_ntf {
5526 __u16 family;
5527 __u8 cmd;
5528 struct ynl_ntf_base_type *next;
5529 void (*free)(struct ethtool_cable_test_tdr_ntf *ntf);
5530 struct ethtool_cable_test_tdr_ntf_rsp obj __attribute__ ((aligned (8)));
5531};
5532
5533void ethtool_cable_test_tdr_ntf_free(struct ethtool_cable_test_tdr_ntf *rsp);
5534
5535#endif /* _LINUX_ETHTOOL_GEN_H */