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 
15 struct ynl_sock;
16 
17 extern const struct ynl_family ynl_ethtool_family;
18 
19 /* Enums */
20 const char *ethtool_op_str(int op);
21 const char *ethtool_udp_tunnel_type_str(int value);
22 const char *ethtool_stringset_str(enum ethtool_stringset value);
23 
24 /* Common nested types */
25 struct 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 
37 struct 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 
47 struct 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 
61 struct 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 
73 struct 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 
91 struct ethtool_cable_result {
92 	struct {
93 		__u32 pair:1;
94 		__u32 code:1;
95 	} _present;
96 
97 	__u8 pair;
98 	__u8 code;
99 };
100 
101 struct 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 
111 struct 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 
122 struct 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 
132 struct ethtool_string {
133 	struct {
134 		__u32 index:1;
135 		__u32 value_len;
136 	} _present;
137 
138 	__u32 index;
139 	char *value;
140 };
141 
142 struct 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 
152 struct ethtool_bitset_bits {
153 	unsigned int n_bit;
154 	struct ethtool_bitset_bit *bit;
155 };
156 
157 struct ethtool_strings {
158 	unsigned int n_string;
159 	struct ethtool_string *string;
160 };
161 
162 struct 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 
173 struct 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 
185 struct 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 
197 struct ethtool_stringsets {
198 	unsigned int n_stringset;
199 	struct ethtool_stringset_ *stringset;
200 };
201 
202 struct 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 */
212 struct 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 
223 static inline struct ethtool_strset_get_req *ethtool_strset_get_req_alloc(void)
224 {
225 	return calloc(1, sizeof(struct ethtool_strset_get_req));
226 }
227 void ethtool_strset_get_req_free(struct ethtool_strset_get_req *req);
228 
229 static inline void
230 ethtool_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 }
237 static inline void
238 ethtool_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 }
247 static inline void
248 ethtool_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 }
255 static 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 }
264 static inline void
265 ethtool_strset_get_req_set_counts_only(struct ethtool_strset_get_req *req)
266 {
267 	req->_present.counts_only = 1;
268 }
269 
270 struct 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 
280 void ethtool_strset_get_rsp_free(struct ethtool_strset_get_rsp *rsp);
281 
282 /*
283  * Get string set from the kernel.
284  */
285 struct ethtool_strset_get_rsp *
286 ethtool_strset_get(struct ynl_sock *ys, struct ethtool_strset_get_req *req);
287 
288 /* ETHTOOL_MSG_STRSET_GET - dump */
289 struct 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 
300 static inline struct ethtool_strset_get_req_dump *
301 ethtool_strset_get_req_dump_alloc(void)
302 {
303 	return calloc(1, sizeof(struct ethtool_strset_get_req_dump));
304 }
305 void ethtool_strset_get_req_dump_free(struct ethtool_strset_get_req_dump *req);
306 
307 static inline void
308 ethtool_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 }
315 static inline void
316 ethtool_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 }
325 static inline void
326 ethtool_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 }
333 static 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 }
342 static inline void
343 ethtool_strset_get_req_dump_set_counts_only(struct ethtool_strset_get_req_dump *req)
344 {
345 	req->_present.counts_only = 1;
346 }
347 
348 struct ethtool_strset_get_list {
349 	struct ethtool_strset_get_list *next;
350 	struct ethtool_strset_get_rsp obj __attribute__ ((aligned (8)));
351 };
352 
353 void ethtool_strset_get_list_free(struct ethtool_strset_get_list *rsp);
354 
355 struct ethtool_strset_get_list *
356 ethtool_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 */
361 struct ethtool_linkinfo_get_req {
362 	struct {
363 		__u32 header:1;
364 	} _present;
365 
366 	struct ethtool_header header;
367 };
368 
369 static inline struct ethtool_linkinfo_get_req *
370 ethtool_linkinfo_get_req_alloc(void)
371 {
372 	return calloc(1, sizeof(struct ethtool_linkinfo_get_req));
373 }
374 void ethtool_linkinfo_get_req_free(struct ethtool_linkinfo_get_req *req);
375 
376 static inline void
377 ethtool_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 }
384 static inline void
385 ethtool_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 }
394 static inline void
395 ethtool_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 
403 struct 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 
421 void ethtool_linkinfo_get_rsp_free(struct ethtool_linkinfo_get_rsp *rsp);
422 
423 /*
424  * Get link info.
425  */
426 struct ethtool_linkinfo_get_rsp *
427 ethtool_linkinfo_get(struct ynl_sock *ys, struct ethtool_linkinfo_get_req *req);
428 
429 /* ETHTOOL_MSG_LINKINFO_GET - dump */
430 struct ethtool_linkinfo_get_req_dump {
431 	struct {
432 		__u32 header:1;
433 	} _present;
434 
435 	struct ethtool_header header;
436 };
437 
438 static inline struct ethtool_linkinfo_get_req_dump *
439 ethtool_linkinfo_get_req_dump_alloc(void)
440 {
441 	return calloc(1, sizeof(struct ethtool_linkinfo_get_req_dump));
442 }
443 void
444 ethtool_linkinfo_get_req_dump_free(struct ethtool_linkinfo_get_req_dump *req);
445 
446 static inline void
447 ethtool_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 }
454 static inline void
455 ethtool_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 }
464 static inline void
465 ethtool_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 
473 struct ethtool_linkinfo_get_list {
474 	struct ethtool_linkinfo_get_list *next;
475 	struct ethtool_linkinfo_get_rsp obj __attribute__ ((aligned (8)));
476 };
477 
478 void ethtool_linkinfo_get_list_free(struct ethtool_linkinfo_get_list *rsp);
479 
480 struct ethtool_linkinfo_get_list *
481 ethtool_linkinfo_get_dump(struct ynl_sock *ys,
482 			  struct ethtool_linkinfo_get_req_dump *req);
483 
484 /* ETHTOOL_MSG_LINKINFO_GET - notify */
485 struct 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 
493 void ethtool_linkinfo_get_ntf_free(struct ethtool_linkinfo_get_ntf *rsp);
494 
495 /* ============== ETHTOOL_MSG_LINKINFO_SET ============== */
496 /* ETHTOOL_MSG_LINKINFO_SET - do */
497 struct 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 
515 static inline struct ethtool_linkinfo_set_req *
516 ethtool_linkinfo_set_req_alloc(void)
517 {
518 	return calloc(1, sizeof(struct ethtool_linkinfo_set_req));
519 }
520 void ethtool_linkinfo_set_req_free(struct ethtool_linkinfo_set_req *req);
521 
522 static inline void
523 ethtool_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 }
530 static inline void
531 ethtool_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 }
540 static inline void
541 ethtool_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 }
548 static inline void
549 ethtool_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 }
555 static inline void
556 ethtool_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 }
562 static inline void
563 ethtool_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 }
569 static inline void
570 ethtool_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 }
576 static inline void
577 ethtool_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  */
587 int 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 */
592 struct ethtool_linkmodes_get_req {
593 	struct {
594 		__u32 header:1;
595 	} _present;
596 
597 	struct ethtool_header header;
598 };
599 
600 static inline struct ethtool_linkmodes_get_req *
601 ethtool_linkmodes_get_req_alloc(void)
602 {
603 	return calloc(1, sizeof(struct ethtool_linkmodes_get_req));
604 }
605 void ethtool_linkmodes_get_req_free(struct ethtool_linkmodes_get_req *req);
606 
607 static inline void
608 ethtool_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 }
615 static inline void
616 ethtool_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 }
625 static inline void
626 ethtool_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 
634 struct 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 
660 void ethtool_linkmodes_get_rsp_free(struct ethtool_linkmodes_get_rsp *rsp);
661 
662 /*
663  * Get link modes.
664  */
665 struct ethtool_linkmodes_get_rsp *
666 ethtool_linkmodes_get(struct ynl_sock *ys,
667 		      struct ethtool_linkmodes_get_req *req);
668 
669 /* ETHTOOL_MSG_LINKMODES_GET - dump */
670 struct ethtool_linkmodes_get_req_dump {
671 	struct {
672 		__u32 header:1;
673 	} _present;
674 
675 	struct ethtool_header header;
676 };
677 
678 static inline struct ethtool_linkmodes_get_req_dump *
679 ethtool_linkmodes_get_req_dump_alloc(void)
680 {
681 	return calloc(1, sizeof(struct ethtool_linkmodes_get_req_dump));
682 }
683 void
684 ethtool_linkmodes_get_req_dump_free(struct ethtool_linkmodes_get_req_dump *req);
685 
686 static inline void
687 ethtool_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 }
694 static inline void
695 ethtool_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 }
704 static inline void
705 ethtool_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 
713 struct ethtool_linkmodes_get_list {
714 	struct ethtool_linkmodes_get_list *next;
715 	struct ethtool_linkmodes_get_rsp obj __attribute__ ((aligned (8)));
716 };
717 
718 void ethtool_linkmodes_get_list_free(struct ethtool_linkmodes_get_list *rsp);
719 
720 struct ethtool_linkmodes_get_list *
721 ethtool_linkmodes_get_dump(struct ynl_sock *ys,
722 			   struct ethtool_linkmodes_get_req_dump *req);
723 
724 /* ETHTOOL_MSG_LINKMODES_GET - notify */
725 struct 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 
733 void ethtool_linkmodes_get_ntf_free(struct ethtool_linkmodes_get_ntf *rsp);
734 
735 /* ============== ETHTOOL_MSG_LINKMODES_SET ============== */
736 /* ETHTOOL_MSG_LINKMODES_SET - do */
737 struct 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 
763 static inline struct ethtool_linkmodes_set_req *
764 ethtool_linkmodes_set_req_alloc(void)
765 {
766 	return calloc(1, sizeof(struct ethtool_linkmodes_set_req));
767 }
768 void ethtool_linkmodes_set_req_free(struct ethtool_linkmodes_set_req *req);
769 
770 static inline void
771 ethtool_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 }
778 static inline void
779 ethtool_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 }
788 static inline void
789 ethtool_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 }
796 static inline void
797 ethtool_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 }
803 static inline void
804 ethtool_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 }
809 static inline void
810 ethtool_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 }
817 static 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 }
826 static inline void
827 ethtool_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 }
832 static inline void
833 ethtool_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 }
840 static 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 }
849 static inline void
850 ethtool_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 }
856 static inline void
857 ethtool_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 }
863 static inline void
864 ethtool_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 }
870 static inline void
871 ethtool_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 }
877 static inline void
878 ethtool_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 }
884 static inline void
885 ethtool_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  */
895 int 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 */
900 struct ethtool_linkstate_get_req {
901 	struct {
902 		__u32 header:1;
903 	} _present;
904 
905 	struct ethtool_header header;
906 };
907 
908 static inline struct ethtool_linkstate_get_req *
909 ethtool_linkstate_get_req_alloc(void)
910 {
911 	return calloc(1, sizeof(struct ethtool_linkstate_get_req));
912 }
913 void ethtool_linkstate_get_req_free(struct ethtool_linkstate_get_req *req);
914 
915 static inline void
916 ethtool_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 }
923 static inline void
924 ethtool_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 }
933 static inline void
934 ethtool_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 
942 struct 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 
962 void ethtool_linkstate_get_rsp_free(struct ethtool_linkstate_get_rsp *rsp);
963 
964 /*
965  * Get link state.
966  */
967 struct ethtool_linkstate_get_rsp *
968 ethtool_linkstate_get(struct ynl_sock *ys,
969 		      struct ethtool_linkstate_get_req *req);
970 
971 /* ETHTOOL_MSG_LINKSTATE_GET - dump */
972 struct ethtool_linkstate_get_req_dump {
973 	struct {
974 		__u32 header:1;
975 	} _present;
976 
977 	struct ethtool_header header;
978 };
979 
980 static inline struct ethtool_linkstate_get_req_dump *
981 ethtool_linkstate_get_req_dump_alloc(void)
982 {
983 	return calloc(1, sizeof(struct ethtool_linkstate_get_req_dump));
984 }
985 void
986 ethtool_linkstate_get_req_dump_free(struct ethtool_linkstate_get_req_dump *req);
987 
988 static inline void
989 ethtool_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 }
996 static inline void
997 ethtool_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 }
1006 static inline void
1007 ethtool_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 
1015 struct ethtool_linkstate_get_list {
1016 	struct ethtool_linkstate_get_list *next;
1017 	struct ethtool_linkstate_get_rsp obj __attribute__ ((aligned (8)));
1018 };
1019 
1020 void ethtool_linkstate_get_list_free(struct ethtool_linkstate_get_list *rsp);
1021 
1022 struct ethtool_linkstate_get_list *
1023 ethtool_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 */
1028 struct ethtool_debug_get_req {
1029 	struct {
1030 		__u32 header:1;
1031 	} _present;
1032 
1033 	struct ethtool_header header;
1034 };
1035 
1036 static inline struct ethtool_debug_get_req *ethtool_debug_get_req_alloc(void)
1037 {
1038 	return calloc(1, sizeof(struct ethtool_debug_get_req));
1039 }
1040 void ethtool_debug_get_req_free(struct ethtool_debug_get_req *req);
1041 
1042 static inline void
1043 ethtool_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 }
1050 static inline void
1051 ethtool_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 }
1060 static inline void
1061 ethtool_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 
1069 struct 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 
1079 void ethtool_debug_get_rsp_free(struct ethtool_debug_get_rsp *rsp);
1080 
1081 /*
1082  * Get debug message mask.
1083  */
1084 struct ethtool_debug_get_rsp *
1085 ethtool_debug_get(struct ynl_sock *ys, struct ethtool_debug_get_req *req);
1086 
1087 /* ETHTOOL_MSG_DEBUG_GET - dump */
1088 struct ethtool_debug_get_req_dump {
1089 	struct {
1090 		__u32 header:1;
1091 	} _present;
1092 
1093 	struct ethtool_header header;
1094 };
1095 
1096 static inline struct ethtool_debug_get_req_dump *
1097 ethtool_debug_get_req_dump_alloc(void)
1098 {
1099 	return calloc(1, sizeof(struct ethtool_debug_get_req_dump));
1100 }
1101 void ethtool_debug_get_req_dump_free(struct ethtool_debug_get_req_dump *req);
1102 
1103 static inline void
1104 ethtool_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 }
1111 static inline void
1112 ethtool_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 }
1121 static inline void
1122 ethtool_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 
1130 struct ethtool_debug_get_list {
1131 	struct ethtool_debug_get_list *next;
1132 	struct ethtool_debug_get_rsp obj __attribute__ ((aligned (8)));
1133 };
1134 
1135 void ethtool_debug_get_list_free(struct ethtool_debug_get_list *rsp);
1136 
1137 struct ethtool_debug_get_list *
1138 ethtool_debug_get_dump(struct ynl_sock *ys,
1139 		       struct ethtool_debug_get_req_dump *req);
1140 
1141 /* ETHTOOL_MSG_DEBUG_GET - notify */
1142 struct 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 
1150 void ethtool_debug_get_ntf_free(struct ethtool_debug_get_ntf *rsp);
1151 
1152 /* ============== ETHTOOL_MSG_DEBUG_SET ============== */
1153 /* ETHTOOL_MSG_DEBUG_SET - do */
1154 struct 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 
1164 static inline struct ethtool_debug_set_req *ethtool_debug_set_req_alloc(void)
1165 {
1166 	return calloc(1, sizeof(struct ethtool_debug_set_req));
1167 }
1168 void ethtool_debug_set_req_free(struct ethtool_debug_set_req *req);
1169 
1170 static inline void
1171 ethtool_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 }
1178 static inline void
1179 ethtool_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 }
1188 static inline void
1189 ethtool_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 }
1196 static inline void
1197 ethtool_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 }
1202 static inline void
1203 ethtool_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 }
1210 static 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  */
1223 int 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 */
1227 struct ethtool_wol_get_req {
1228 	struct {
1229 		__u32 header:1;
1230 	} _present;
1231 
1232 	struct ethtool_header header;
1233 };
1234 
1235 static inline struct ethtool_wol_get_req *ethtool_wol_get_req_alloc(void)
1236 {
1237 	return calloc(1, sizeof(struct ethtool_wol_get_req));
1238 }
1239 void ethtool_wol_get_req_free(struct ethtool_wol_get_req *req);
1240 
1241 static inline void
1242 ethtool_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 }
1249 static inline void
1250 ethtool_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 }
1259 static inline void
1260 ethtool_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 
1268 struct 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 
1280 void ethtool_wol_get_rsp_free(struct ethtool_wol_get_rsp *rsp);
1281 
1282 /*
1283  * Get WOL params.
1284  */
1285 struct ethtool_wol_get_rsp *
1286 ethtool_wol_get(struct ynl_sock *ys, struct ethtool_wol_get_req *req);
1287 
1288 /* ETHTOOL_MSG_WOL_GET - dump */
1289 struct ethtool_wol_get_req_dump {
1290 	struct {
1291 		__u32 header:1;
1292 	} _present;
1293 
1294 	struct ethtool_header header;
1295 };
1296 
1297 static inline struct ethtool_wol_get_req_dump *
1298 ethtool_wol_get_req_dump_alloc(void)
1299 {
1300 	return calloc(1, sizeof(struct ethtool_wol_get_req_dump));
1301 }
1302 void ethtool_wol_get_req_dump_free(struct ethtool_wol_get_req_dump *req);
1303 
1304 static inline void
1305 ethtool_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 }
1312 static inline void
1313 ethtool_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 }
1322 static inline void
1323 ethtool_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 
1331 struct ethtool_wol_get_list {
1332 	struct ethtool_wol_get_list *next;
1333 	struct ethtool_wol_get_rsp obj __attribute__ ((aligned (8)));
1334 };
1335 
1336 void ethtool_wol_get_list_free(struct ethtool_wol_get_list *rsp);
1337 
1338 struct ethtool_wol_get_list *
1339 ethtool_wol_get_dump(struct ynl_sock *ys, struct ethtool_wol_get_req_dump *req);
1340 
1341 /* ETHTOOL_MSG_WOL_GET - notify */
1342 struct 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 
1350 void ethtool_wol_get_ntf_free(struct ethtool_wol_get_ntf *rsp);
1351 
1352 /* ============== ETHTOOL_MSG_WOL_SET ============== */
1353 /* ETHTOOL_MSG_WOL_SET - do */
1354 struct 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 
1366 static inline struct ethtool_wol_set_req *ethtool_wol_set_req_alloc(void)
1367 {
1368 	return calloc(1, sizeof(struct ethtool_wol_set_req));
1369 }
1370 void ethtool_wol_set_req_free(struct ethtool_wol_set_req *req);
1371 
1372 static inline void
1373 ethtool_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 }
1380 static inline void
1381 ethtool_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 }
1390 static inline void
1391 ethtool_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 }
1398 static inline void
1399 ethtool_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 }
1404 static inline void
1405 ethtool_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 }
1411 static 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 }
1420 static inline void
1421 ethtool_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  */
1433 int 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 */
1437 struct ethtool_features_get_req {
1438 	struct {
1439 		__u32 header:1;
1440 	} _present;
1441 
1442 	struct ethtool_header header;
1443 };
1444 
1445 static inline struct ethtool_features_get_req *
1446 ethtool_features_get_req_alloc(void)
1447 {
1448 	return calloc(1, sizeof(struct ethtool_features_get_req));
1449 }
1450 void ethtool_features_get_req_free(struct ethtool_features_get_req *req);
1451 
1452 static inline void
1453 ethtool_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 }
1460 static inline void
1461 ethtool_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 }
1470 static inline void
1471 ethtool_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 
1479 struct 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 
1495 void ethtool_features_get_rsp_free(struct ethtool_features_get_rsp *rsp);
1496 
1497 /*
1498  * Get features.
1499  */
1500 struct ethtool_features_get_rsp *
1501 ethtool_features_get(struct ynl_sock *ys, struct ethtool_features_get_req *req);
1502 
1503 /* ETHTOOL_MSG_FEATURES_GET - dump */
1504 struct ethtool_features_get_req_dump {
1505 	struct {
1506 		__u32 header:1;
1507 	} _present;
1508 
1509 	struct ethtool_header header;
1510 };
1511 
1512 static inline struct ethtool_features_get_req_dump *
1513 ethtool_features_get_req_dump_alloc(void)
1514 {
1515 	return calloc(1, sizeof(struct ethtool_features_get_req_dump));
1516 }
1517 void
1518 ethtool_features_get_req_dump_free(struct ethtool_features_get_req_dump *req);
1519 
1520 static inline void
1521 ethtool_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 }
1528 static inline void
1529 ethtool_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 }
1538 static inline void
1539 ethtool_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 
1547 struct ethtool_features_get_list {
1548 	struct ethtool_features_get_list *next;
1549 	struct ethtool_features_get_rsp obj __attribute__ ((aligned (8)));
1550 };
1551 
1552 void ethtool_features_get_list_free(struct ethtool_features_get_list *rsp);
1553 
1554 struct ethtool_features_get_list *
1555 ethtool_features_get_dump(struct ynl_sock *ys,
1556 			  struct ethtool_features_get_req_dump *req);
1557 
1558 /* ETHTOOL_MSG_FEATURES_GET - notify */
1559 struct 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 
1567 void ethtool_features_get_ntf_free(struct ethtool_features_get_ntf *rsp);
1568 
1569 /* ============== ETHTOOL_MSG_FEATURES_SET ============== */
1570 /* ETHTOOL_MSG_FEATURES_SET - do */
1571 struct 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 
1587 static inline struct ethtool_features_set_req *
1588 ethtool_features_set_req_alloc(void)
1589 {
1590 	return calloc(1, sizeof(struct ethtool_features_set_req));
1591 }
1592 void ethtool_features_set_req_free(struct ethtool_features_set_req *req);
1593 
1594 static inline void
1595 ethtool_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 }
1602 static inline void
1603 ethtool_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 }
1612 static inline void
1613 ethtool_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 }
1620 static inline void
1621 ethtool_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 }
1626 static inline void
1627 ethtool_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 }
1634 static 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 }
1643 static inline void
1644 ethtool_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 }
1649 static inline void
1650 ethtool_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 }
1657 static 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 }
1666 static inline void
1667 ethtool_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 }
1672 static inline void
1673 ethtool_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 }
1680 static 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 }
1689 static inline void
1690 ethtool_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 }
1695 static inline void
1696 ethtool_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 }
1703 static 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 
1713 struct 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 
1729 void ethtool_features_set_rsp_free(struct ethtool_features_set_rsp *rsp);
1730 
1731 /*
1732  * Set features.
1733  */
1734 struct ethtool_features_set_rsp *
1735 ethtool_features_set(struct ynl_sock *ys, struct ethtool_features_set_req *req);
1736 
1737 /* ============== ETHTOOL_MSG_PRIVFLAGS_GET ============== */
1738 /* ETHTOOL_MSG_PRIVFLAGS_GET - do */
1739 struct ethtool_privflags_get_req {
1740 	struct {
1741 		__u32 header:1;
1742 	} _present;
1743 
1744 	struct ethtool_header header;
1745 };
1746 
1747 static inline struct ethtool_privflags_get_req *
1748 ethtool_privflags_get_req_alloc(void)
1749 {
1750 	return calloc(1, sizeof(struct ethtool_privflags_get_req));
1751 }
1752 void ethtool_privflags_get_req_free(struct ethtool_privflags_get_req *req);
1753 
1754 static inline void
1755 ethtool_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 }
1762 static inline void
1763 ethtool_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 }
1772 static inline void
1773 ethtool_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 
1781 struct 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 
1791 void ethtool_privflags_get_rsp_free(struct ethtool_privflags_get_rsp *rsp);
1792 
1793 /*
1794  * Get device private flags.
1795  */
1796 struct ethtool_privflags_get_rsp *
1797 ethtool_privflags_get(struct ynl_sock *ys,
1798 		      struct ethtool_privflags_get_req *req);
1799 
1800 /* ETHTOOL_MSG_PRIVFLAGS_GET - dump */
1801 struct ethtool_privflags_get_req_dump {
1802 	struct {
1803 		__u32 header:1;
1804 	} _present;
1805 
1806 	struct ethtool_header header;
1807 };
1808 
1809 static inline struct ethtool_privflags_get_req_dump *
1810 ethtool_privflags_get_req_dump_alloc(void)
1811 {
1812 	return calloc(1, sizeof(struct ethtool_privflags_get_req_dump));
1813 }
1814 void
1815 ethtool_privflags_get_req_dump_free(struct ethtool_privflags_get_req_dump *req);
1816 
1817 static inline void
1818 ethtool_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 }
1825 static inline void
1826 ethtool_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 }
1835 static inline void
1836 ethtool_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 
1844 struct ethtool_privflags_get_list {
1845 	struct ethtool_privflags_get_list *next;
1846 	struct ethtool_privflags_get_rsp obj __attribute__ ((aligned (8)));
1847 };
1848 
1849 void ethtool_privflags_get_list_free(struct ethtool_privflags_get_list *rsp);
1850 
1851 struct ethtool_privflags_get_list *
1852 ethtool_privflags_get_dump(struct ynl_sock *ys,
1853 			   struct ethtool_privflags_get_req_dump *req);
1854 
1855 /* ETHTOOL_MSG_PRIVFLAGS_GET - notify */
1856 struct 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 
1864 void ethtool_privflags_get_ntf_free(struct ethtool_privflags_get_ntf *rsp);
1865 
1866 /* ============== ETHTOOL_MSG_PRIVFLAGS_SET ============== */
1867 /* ETHTOOL_MSG_PRIVFLAGS_SET - do */
1868 struct 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 
1878 static inline struct ethtool_privflags_set_req *
1879 ethtool_privflags_set_req_alloc(void)
1880 {
1881 	return calloc(1, sizeof(struct ethtool_privflags_set_req));
1882 }
1883 void ethtool_privflags_set_req_free(struct ethtool_privflags_set_req *req);
1884 
1885 static inline void
1886 ethtool_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 }
1893 static inline void
1894 ethtool_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 }
1903 static inline void
1904 ethtool_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 }
1911 static inline void
1912 ethtool_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 }
1917 static inline void
1918 ethtool_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 }
1925 static 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  */
1938 int 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 */
1943 struct ethtool_rings_get_req {
1944 	struct {
1945 		__u32 header:1;
1946 	} _present;
1947 
1948 	struct ethtool_header header;
1949 };
1950 
1951 static inline struct ethtool_rings_get_req *ethtool_rings_get_req_alloc(void)
1952 {
1953 	return calloc(1, sizeof(struct ethtool_rings_get_req));
1954 }
1955 void ethtool_rings_get_req_free(struct ethtool_rings_get_req *req);
1956 
1957 static inline void
1958 ethtool_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 }
1965 static inline void
1966 ethtool_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 }
1975 static inline void
1976 ethtool_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 
1984 struct 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 
2022 void ethtool_rings_get_rsp_free(struct ethtool_rings_get_rsp *rsp);
2023 
2024 /*
2025  * Get ring params.
2026  */
2027 struct ethtool_rings_get_rsp *
2028 ethtool_rings_get(struct ynl_sock *ys, struct ethtool_rings_get_req *req);
2029 
2030 /* ETHTOOL_MSG_RINGS_GET - dump */
2031 struct ethtool_rings_get_req_dump {
2032 	struct {
2033 		__u32 header:1;
2034 	} _present;
2035 
2036 	struct ethtool_header header;
2037 };
2038 
2039 static inline struct ethtool_rings_get_req_dump *
2040 ethtool_rings_get_req_dump_alloc(void)
2041 {
2042 	return calloc(1, sizeof(struct ethtool_rings_get_req_dump));
2043 }
2044 void ethtool_rings_get_req_dump_free(struct ethtool_rings_get_req_dump *req);
2045 
2046 static inline void
2047 ethtool_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 }
2054 static inline void
2055 ethtool_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 }
2064 static inline void
2065 ethtool_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 
2073 struct ethtool_rings_get_list {
2074 	struct ethtool_rings_get_list *next;
2075 	struct ethtool_rings_get_rsp obj __attribute__ ((aligned (8)));
2076 };
2077 
2078 void ethtool_rings_get_list_free(struct ethtool_rings_get_list *rsp);
2079 
2080 struct ethtool_rings_get_list *
2081 ethtool_rings_get_dump(struct ynl_sock *ys,
2082 		       struct ethtool_rings_get_req_dump *req);
2083 
2084 /* ETHTOOL_MSG_RINGS_GET - notify */
2085 struct 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 
2093 void ethtool_rings_get_ntf_free(struct ethtool_rings_get_ntf *rsp);
2094 
2095 /* ============== ETHTOOL_MSG_RINGS_SET ============== */
2096 /* ETHTOOL_MSG_RINGS_SET - do */
2097 struct 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 
2135 static inline struct ethtool_rings_set_req *ethtool_rings_set_req_alloc(void)
2136 {
2137 	return calloc(1, sizeof(struct ethtool_rings_set_req));
2138 }
2139 void ethtool_rings_set_req_free(struct ethtool_rings_set_req *req);
2140 
2141 static inline void
2142 ethtool_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 }
2149 static inline void
2150 ethtool_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 }
2159 static inline void
2160 ethtool_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 }
2167 static inline void
2168 ethtool_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 }
2174 static inline void
2175 ethtool_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 }
2181 static inline void
2182 ethtool_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 }
2188 static inline void
2189 ethtool_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 }
2195 static inline void
2196 ethtool_rings_set_req_set_rx(struct ethtool_rings_set_req *req, __u32 rx)
2197 {
2198 	req->_present.rx = 1;
2199 	req->rx = rx;
2200 }
2201 static inline void
2202 ethtool_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 }
2208 static inline void
2209 ethtool_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 }
2215 static inline void
2216 ethtool_rings_set_req_set_tx(struct ethtool_rings_set_req *req, __u32 tx)
2217 {
2218 	req->_present.tx = 1;
2219 	req->tx = tx;
2220 }
2221 static inline void
2222 ethtool_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 }
2228 static inline void
2229 ethtool_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 }
2235 static inline void
2236 ethtool_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 }
2242 static inline void
2243 ethtool_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 }
2249 static inline void
2250 ethtool_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 }
2256 static inline void
2257 ethtool_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 }
2263 static inline void
2264 ethtool_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  */
2274 int 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 */
2278 struct ethtool_channels_get_req {
2279 	struct {
2280 		__u32 header:1;
2281 	} _present;
2282 
2283 	struct ethtool_header header;
2284 };
2285 
2286 static inline struct ethtool_channels_get_req *
2287 ethtool_channels_get_req_alloc(void)
2288 {
2289 	return calloc(1, sizeof(struct ethtool_channels_get_req));
2290 }
2291 void ethtool_channels_get_req_free(struct ethtool_channels_get_req *req);
2292 
2293 static inline void
2294 ethtool_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 }
2301 static inline void
2302 ethtool_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 }
2311 static inline void
2312 ethtool_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 
2320 struct 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 
2344 void ethtool_channels_get_rsp_free(struct ethtool_channels_get_rsp *rsp);
2345 
2346 /*
2347  * Get channel params.
2348  */
2349 struct ethtool_channels_get_rsp *
2350 ethtool_channels_get(struct ynl_sock *ys, struct ethtool_channels_get_req *req);
2351 
2352 /* ETHTOOL_MSG_CHANNELS_GET - dump */
2353 struct ethtool_channels_get_req_dump {
2354 	struct {
2355 		__u32 header:1;
2356 	} _present;
2357 
2358 	struct ethtool_header header;
2359 };
2360 
2361 static inline struct ethtool_channels_get_req_dump *
2362 ethtool_channels_get_req_dump_alloc(void)
2363 {
2364 	return calloc(1, sizeof(struct ethtool_channels_get_req_dump));
2365 }
2366 void
2367 ethtool_channels_get_req_dump_free(struct ethtool_channels_get_req_dump *req);
2368 
2369 static inline void
2370 ethtool_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 }
2377 static inline void
2378 ethtool_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 }
2387 static inline void
2388 ethtool_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 
2396 struct ethtool_channels_get_list {
2397 	struct ethtool_channels_get_list *next;
2398 	struct ethtool_channels_get_rsp obj __attribute__ ((aligned (8)));
2399 };
2400 
2401 void ethtool_channels_get_list_free(struct ethtool_channels_get_list *rsp);
2402 
2403 struct ethtool_channels_get_list *
2404 ethtool_channels_get_dump(struct ynl_sock *ys,
2405 			  struct ethtool_channels_get_req_dump *req);
2406 
2407 /* ETHTOOL_MSG_CHANNELS_GET - notify */
2408 struct 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 
2416 void ethtool_channels_get_ntf_free(struct ethtool_channels_get_ntf *rsp);
2417 
2418 /* ============== ETHTOOL_MSG_CHANNELS_SET ============== */
2419 /* ETHTOOL_MSG_CHANNELS_SET - do */
2420 struct 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 
2444 static inline struct ethtool_channels_set_req *
2445 ethtool_channels_set_req_alloc(void)
2446 {
2447 	return calloc(1, sizeof(struct ethtool_channels_set_req));
2448 }
2449 void ethtool_channels_set_req_free(struct ethtool_channels_set_req *req);
2450 
2451 static inline void
2452 ethtool_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 }
2459 static inline void
2460 ethtool_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 }
2469 static inline void
2470 ethtool_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 }
2477 static inline void
2478 ethtool_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 }
2484 static inline void
2485 ethtool_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 }
2491 static inline void
2492 ethtool_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 }
2498 static inline void
2499 ethtool_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 }
2505 static inline void
2506 ethtool_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 }
2512 static inline void
2513 ethtool_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 }
2519 static inline void
2520 ethtool_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 }
2526 static inline void
2527 ethtool_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  */
2537 int 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 */
2542 struct ethtool_coalesce_get_req {
2543 	struct {
2544 		__u32 header:1;
2545 	} _present;
2546 
2547 	struct ethtool_header header;
2548 };
2549 
2550 static inline struct ethtool_coalesce_get_req *
2551 ethtool_coalesce_get_req_alloc(void)
2552 {
2553 	return calloc(1, sizeof(struct ethtool_coalesce_get_req));
2554 }
2555 void ethtool_coalesce_get_req_free(struct ethtool_coalesce_get_req *req);
2556 
2557 static inline void
2558 ethtool_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 }
2565 static inline void
2566 ethtool_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 }
2575 static inline void
2576 ethtool_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 
2584 struct 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 
2646 void ethtool_coalesce_get_rsp_free(struct ethtool_coalesce_get_rsp *rsp);
2647 
2648 /*
2649  * Get coalesce params.
2650  */
2651 struct ethtool_coalesce_get_rsp *
2652 ethtool_coalesce_get(struct ynl_sock *ys, struct ethtool_coalesce_get_req *req);
2653 
2654 /* ETHTOOL_MSG_COALESCE_GET - dump */
2655 struct ethtool_coalesce_get_req_dump {
2656 	struct {
2657 		__u32 header:1;
2658 	} _present;
2659 
2660 	struct ethtool_header header;
2661 };
2662 
2663 static inline struct ethtool_coalesce_get_req_dump *
2664 ethtool_coalesce_get_req_dump_alloc(void)
2665 {
2666 	return calloc(1, sizeof(struct ethtool_coalesce_get_req_dump));
2667 }
2668 void
2669 ethtool_coalesce_get_req_dump_free(struct ethtool_coalesce_get_req_dump *req);
2670 
2671 static inline void
2672 ethtool_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 }
2679 static inline void
2680 ethtool_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 }
2689 static inline void
2690 ethtool_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 
2698 struct ethtool_coalesce_get_list {
2699 	struct ethtool_coalesce_get_list *next;
2700 	struct ethtool_coalesce_get_rsp obj __attribute__ ((aligned (8)));
2701 };
2702 
2703 void ethtool_coalesce_get_list_free(struct ethtool_coalesce_get_list *rsp);
2704 
2705 struct ethtool_coalesce_get_list *
2706 ethtool_coalesce_get_dump(struct ynl_sock *ys,
2707 			  struct ethtool_coalesce_get_req_dump *req);
2708 
2709 /* ETHTOOL_MSG_COALESCE_GET - notify */
2710 struct 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 
2718 void ethtool_coalesce_get_ntf_free(struct ethtool_coalesce_get_ntf *rsp);
2719 
2720 /* ============== ETHTOOL_MSG_COALESCE_SET ============== */
2721 /* ETHTOOL_MSG_COALESCE_SET - do */
2722 struct 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 
2784 static inline struct ethtool_coalesce_set_req *
2785 ethtool_coalesce_set_req_alloc(void)
2786 {
2787 	return calloc(1, sizeof(struct ethtool_coalesce_set_req));
2788 }
2789 void ethtool_coalesce_set_req_free(struct ethtool_coalesce_set_req *req);
2790 
2791 static inline void
2792 ethtool_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 }
2799 static inline void
2800 ethtool_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 }
2809 static inline void
2810 ethtool_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 }
2817 static inline void
2818 ethtool_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 }
2824 static inline void
2825 ethtool_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 }
2831 static inline void
2832 ethtool_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 }
2838 static inline void
2839 ethtool_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 }
2845 static inline void
2846 ethtool_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 }
2852 static inline void
2853 ethtool_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 }
2859 static inline void
2860 ethtool_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 }
2866 static inline void
2867 ethtool_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 }
2873 static inline void
2874 ethtool_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 }
2880 static inline void
2881 ethtool_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 }
2887 static inline void
2888 ethtool_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 }
2894 static inline void
2895 ethtool_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 }
2901 static inline void
2902 ethtool_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 }
2908 static inline void
2909 ethtool_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 }
2915 static inline void
2916 ethtool_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 }
2922 static inline void
2923 ethtool_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 }
2929 static inline void
2930 ethtool_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 }
2936 static inline void
2937 ethtool_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 }
2943 static inline void
2944 ethtool_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 }
2950 static inline void
2951 ethtool_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 }
2957 static inline void
2958 ethtool_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 }
2964 static inline void
2965 ethtool_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 }
2971 static inline void
2972 ethtool_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 }
2978 static inline void
2979 ethtool_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 }
2985 static inline void
2986 ethtool_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 }
2992 static inline void
2993 ethtool_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 }
2999 static inline void
3000 ethtool_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  */
3010 int 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 */
3015 struct ethtool_pause_get_req {
3016 	struct {
3017 		__u32 header:1;
3018 	} _present;
3019 
3020 	struct ethtool_header header;
3021 };
3022 
3023 static inline struct ethtool_pause_get_req *ethtool_pause_get_req_alloc(void)
3024 {
3025 	return calloc(1, sizeof(struct ethtool_pause_get_req));
3026 }
3027 void ethtool_pause_get_req_free(struct ethtool_pause_get_req *req);
3028 
3029 static inline void
3030 ethtool_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 }
3037 static inline void
3038 ethtool_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 }
3047 static inline void
3048 ethtool_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 
3056 struct 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 
3074 void ethtool_pause_get_rsp_free(struct ethtool_pause_get_rsp *rsp);
3075 
3076 /*
3077  * Get pause params.
3078  */
3079 struct ethtool_pause_get_rsp *
3080 ethtool_pause_get(struct ynl_sock *ys, struct ethtool_pause_get_req *req);
3081 
3082 /* ETHTOOL_MSG_PAUSE_GET - dump */
3083 struct ethtool_pause_get_req_dump {
3084 	struct {
3085 		__u32 header:1;
3086 	} _present;
3087 
3088 	struct ethtool_header header;
3089 };
3090 
3091 static inline struct ethtool_pause_get_req_dump *
3092 ethtool_pause_get_req_dump_alloc(void)
3093 {
3094 	return calloc(1, sizeof(struct ethtool_pause_get_req_dump));
3095 }
3096 void ethtool_pause_get_req_dump_free(struct ethtool_pause_get_req_dump *req);
3097 
3098 static inline void
3099 ethtool_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 }
3106 static inline void
3107 ethtool_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 }
3116 static inline void
3117 ethtool_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 
3125 struct ethtool_pause_get_list {
3126 	struct ethtool_pause_get_list *next;
3127 	struct ethtool_pause_get_rsp obj __attribute__ ((aligned (8)));
3128 };
3129 
3130 void ethtool_pause_get_list_free(struct ethtool_pause_get_list *rsp);
3131 
3132 struct ethtool_pause_get_list *
3133 ethtool_pause_get_dump(struct ynl_sock *ys,
3134 		       struct ethtool_pause_get_req_dump *req);
3135 
3136 /* ETHTOOL_MSG_PAUSE_GET - notify */
3137 struct 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 
3145 void ethtool_pause_get_ntf_free(struct ethtool_pause_get_ntf *rsp);
3146 
3147 /* ============== ETHTOOL_MSG_PAUSE_SET ============== */
3148 /* ETHTOOL_MSG_PAUSE_SET - do */
3149 struct 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 
3167 static inline struct ethtool_pause_set_req *ethtool_pause_set_req_alloc(void)
3168 {
3169 	return calloc(1, sizeof(struct ethtool_pause_set_req));
3170 }
3171 void ethtool_pause_set_req_free(struct ethtool_pause_set_req *req);
3172 
3173 static inline void
3174 ethtool_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 }
3181 static inline void
3182 ethtool_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 }
3191 static inline void
3192 ethtool_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 }
3199 static inline void
3200 ethtool_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 }
3206 static inline void
3207 ethtool_pause_set_req_set_rx(struct ethtool_pause_set_req *req, __u8 rx)
3208 {
3209 	req->_present.rx = 1;
3210 	req->rx = rx;
3211 }
3212 static inline void
3213 ethtool_pause_set_req_set_tx(struct ethtool_pause_set_req *req, __u8 tx)
3214 {
3215 	req->_present.tx = 1;
3216 	req->tx = tx;
3217 }
3218 static inline void
3219 ethtool_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 }
3226 static inline void
3227 ethtool_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 }
3234 static inline void
3235 ethtool_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  */
3245 int 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 */
3249 struct ethtool_eee_get_req {
3250 	struct {
3251 		__u32 header:1;
3252 	} _present;
3253 
3254 	struct ethtool_header header;
3255 };
3256 
3257 static inline struct ethtool_eee_get_req *ethtool_eee_get_req_alloc(void)
3258 {
3259 	return calloc(1, sizeof(struct ethtool_eee_get_req));
3260 }
3261 void ethtool_eee_get_req_free(struct ethtool_eee_get_req *req);
3262 
3263 static inline void
3264 ethtool_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 }
3271 static inline void
3272 ethtool_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 }
3281 static inline void
3282 ethtool_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 
3290 struct 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 
3310 void ethtool_eee_get_rsp_free(struct ethtool_eee_get_rsp *rsp);
3311 
3312 /*
3313  * Get eee params.
3314  */
3315 struct ethtool_eee_get_rsp *
3316 ethtool_eee_get(struct ynl_sock *ys, struct ethtool_eee_get_req *req);
3317 
3318 /* ETHTOOL_MSG_EEE_GET - dump */
3319 struct ethtool_eee_get_req_dump {
3320 	struct {
3321 		__u32 header:1;
3322 	} _present;
3323 
3324 	struct ethtool_header header;
3325 };
3326 
3327 static inline struct ethtool_eee_get_req_dump *
3328 ethtool_eee_get_req_dump_alloc(void)
3329 {
3330 	return calloc(1, sizeof(struct ethtool_eee_get_req_dump));
3331 }
3332 void ethtool_eee_get_req_dump_free(struct ethtool_eee_get_req_dump *req);
3333 
3334 static inline void
3335 ethtool_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 }
3342 static inline void
3343 ethtool_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 }
3352 static inline void
3353 ethtool_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 
3361 struct ethtool_eee_get_list {
3362 	struct ethtool_eee_get_list *next;
3363 	struct ethtool_eee_get_rsp obj __attribute__ ((aligned (8)));
3364 };
3365 
3366 void ethtool_eee_get_list_free(struct ethtool_eee_get_list *rsp);
3367 
3368 struct ethtool_eee_get_list *
3369 ethtool_eee_get_dump(struct ynl_sock *ys, struct ethtool_eee_get_req_dump *req);
3370 
3371 /* ETHTOOL_MSG_EEE_GET - notify */
3372 struct 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 
3380 void ethtool_eee_get_ntf_free(struct ethtool_eee_get_ntf *rsp);
3381 
3382 /* ============== ETHTOOL_MSG_EEE_SET ============== */
3383 /* ETHTOOL_MSG_EEE_SET - do */
3384 struct 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 
3404 static inline struct ethtool_eee_set_req *ethtool_eee_set_req_alloc(void)
3405 {
3406 	return calloc(1, sizeof(struct ethtool_eee_set_req));
3407 }
3408 void ethtool_eee_set_req_free(struct ethtool_eee_set_req *req);
3409 
3410 static inline void
3411 ethtool_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 }
3418 static inline void
3419 ethtool_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 }
3428 static inline void
3429 ethtool_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 }
3436 static inline void
3437 ethtool_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 }
3442 static inline void
3443 ethtool_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 }
3450 static 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 }
3459 static inline void
3460 ethtool_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 }
3465 static inline void
3466 ethtool_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 }
3473 static 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 }
3482 static inline void
3483 ethtool_eee_set_req_set_active(struct ethtool_eee_set_req *req, __u8 active)
3484 {
3485 	req->_present.active = 1;
3486 	req->active = active;
3487 }
3488 static inline void
3489 ethtool_eee_set_req_set_enabled(struct ethtool_eee_set_req *req, __u8 enabled)
3490 {
3491 	req->_present.enabled = 1;
3492 	req->enabled = enabled;
3493 }
3494 static inline void
3495 ethtool_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 }
3501 static inline void
3502 ethtool_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  */
3512 int 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 */
3516 struct ethtool_tsinfo_get_req {
3517 	struct {
3518 		__u32 header:1;
3519 	} _present;
3520 
3521 	struct ethtool_header header;
3522 };
3523 
3524 static inline struct ethtool_tsinfo_get_req *ethtool_tsinfo_get_req_alloc(void)
3525 {
3526 	return calloc(1, sizeof(struct ethtool_tsinfo_get_req));
3527 }
3528 void ethtool_tsinfo_get_req_free(struct ethtool_tsinfo_get_req *req);
3529 
3530 static inline void
3531 ethtool_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 }
3538 static inline void
3539 ethtool_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 }
3548 static inline void
3549 ethtool_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 
3557 struct 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 
3573 void ethtool_tsinfo_get_rsp_free(struct ethtool_tsinfo_get_rsp *rsp);
3574 
3575 /*
3576  * Get tsinfo params.
3577  */
3578 struct ethtool_tsinfo_get_rsp *
3579 ethtool_tsinfo_get(struct ynl_sock *ys, struct ethtool_tsinfo_get_req *req);
3580 
3581 /* ETHTOOL_MSG_TSINFO_GET - dump */
3582 struct ethtool_tsinfo_get_req_dump {
3583 	struct {
3584 		__u32 header:1;
3585 	} _present;
3586 
3587 	struct ethtool_header header;
3588 };
3589 
3590 static inline struct ethtool_tsinfo_get_req_dump *
3591 ethtool_tsinfo_get_req_dump_alloc(void)
3592 {
3593 	return calloc(1, sizeof(struct ethtool_tsinfo_get_req_dump));
3594 }
3595 void ethtool_tsinfo_get_req_dump_free(struct ethtool_tsinfo_get_req_dump *req);
3596 
3597 static inline void
3598 ethtool_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 }
3605 static inline void
3606 ethtool_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 }
3615 static inline void
3616 ethtool_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 
3624 struct ethtool_tsinfo_get_list {
3625 	struct ethtool_tsinfo_get_list *next;
3626 	struct ethtool_tsinfo_get_rsp obj __attribute__ ((aligned (8)));
3627 };
3628 
3629 void ethtool_tsinfo_get_list_free(struct ethtool_tsinfo_get_list *rsp);
3630 
3631 struct ethtool_tsinfo_get_list *
3632 ethtool_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 */
3637 struct ethtool_cable_test_act_req {
3638 	struct {
3639 		__u32 header:1;
3640 	} _present;
3641 
3642 	struct ethtool_header header;
3643 };
3644 
3645 static inline struct ethtool_cable_test_act_req *
3646 ethtool_cable_test_act_req_alloc(void)
3647 {
3648 	return calloc(1, sizeof(struct ethtool_cable_test_act_req));
3649 }
3650 void ethtool_cable_test_act_req_free(struct ethtool_cable_test_act_req *req);
3651 
3652 static inline void
3653 ethtool_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 }
3660 static inline void
3661 ethtool_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 }
3670 static inline void
3671 ethtool_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  */
3682 int 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 */
3687 struct ethtool_cable_test_tdr_act_req {
3688 	struct {
3689 		__u32 header:1;
3690 	} _present;
3691 
3692 	struct ethtool_header header;
3693 };
3694 
3695 static inline struct ethtool_cable_test_tdr_act_req *
3696 ethtool_cable_test_tdr_act_req_alloc(void)
3697 {
3698 	return calloc(1, sizeof(struct ethtool_cable_test_tdr_act_req));
3699 }
3700 void
3701 ethtool_cable_test_tdr_act_req_free(struct ethtool_cable_test_tdr_act_req *req);
3702 
3703 static inline void
3704 ethtool_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 }
3711 static inline void
3712 ethtool_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 }
3721 static inline void
3722 ethtool_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  */
3733 int 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 */
3738 struct ethtool_tunnel_info_get_req {
3739 	struct {
3740 		__u32 header:1;
3741 	} _present;
3742 
3743 	struct ethtool_header header;
3744 };
3745 
3746 static inline struct ethtool_tunnel_info_get_req *
3747 ethtool_tunnel_info_get_req_alloc(void)
3748 {
3749 	return calloc(1, sizeof(struct ethtool_tunnel_info_get_req));
3750 }
3751 void ethtool_tunnel_info_get_req_free(struct ethtool_tunnel_info_get_req *req);
3752 
3753 static inline void
3754 ethtool_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 }
3761 static inline void
3762 ethtool_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 }
3771 static inline void
3772 ethtool_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 
3780 struct 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 
3790 void ethtool_tunnel_info_get_rsp_free(struct ethtool_tunnel_info_get_rsp *rsp);
3791 
3792 /*
3793  * Get tsinfo params.
3794  */
3795 struct ethtool_tunnel_info_get_rsp *
3796 ethtool_tunnel_info_get(struct ynl_sock *ys,
3797 			struct ethtool_tunnel_info_get_req *req);
3798 
3799 /* ETHTOOL_MSG_TUNNEL_INFO_GET - dump */
3800 struct ethtool_tunnel_info_get_req_dump {
3801 	struct {
3802 		__u32 header:1;
3803 	} _present;
3804 
3805 	struct ethtool_header header;
3806 };
3807 
3808 static inline struct ethtool_tunnel_info_get_req_dump *
3809 ethtool_tunnel_info_get_req_dump_alloc(void)
3810 {
3811 	return calloc(1, sizeof(struct ethtool_tunnel_info_get_req_dump));
3812 }
3813 void
3814 ethtool_tunnel_info_get_req_dump_free(struct ethtool_tunnel_info_get_req_dump *req);
3815 
3816 static inline void
3817 ethtool_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 }
3824 static inline void
3825 ethtool_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 }
3834 static inline void
3835 ethtool_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 
3843 struct 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 
3848 void
3849 ethtool_tunnel_info_get_list_free(struct ethtool_tunnel_info_get_list *rsp);
3850 
3851 struct ethtool_tunnel_info_get_list *
3852 ethtool_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 */
3857 struct ethtool_fec_get_req {
3858 	struct {
3859 		__u32 header:1;
3860 	} _present;
3861 
3862 	struct ethtool_header header;
3863 };
3864 
3865 static inline struct ethtool_fec_get_req *ethtool_fec_get_req_alloc(void)
3866 {
3867 	return calloc(1, sizeof(struct ethtool_fec_get_req));
3868 }
3869 void ethtool_fec_get_req_free(struct ethtool_fec_get_req *req);
3870 
3871 static inline void
3872 ethtool_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 }
3879 static inline void
3880 ethtool_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 }
3889 static inline void
3890 ethtool_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 
3898 struct 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 
3914 void ethtool_fec_get_rsp_free(struct ethtool_fec_get_rsp *rsp);
3915 
3916 /*
3917  * Get FEC params.
3918  */
3919 struct ethtool_fec_get_rsp *
3920 ethtool_fec_get(struct ynl_sock *ys, struct ethtool_fec_get_req *req);
3921 
3922 /* ETHTOOL_MSG_FEC_GET - dump */
3923 struct ethtool_fec_get_req_dump {
3924 	struct {
3925 		__u32 header:1;
3926 	} _present;
3927 
3928 	struct ethtool_header header;
3929 };
3930 
3931 static inline struct ethtool_fec_get_req_dump *
3932 ethtool_fec_get_req_dump_alloc(void)
3933 {
3934 	return calloc(1, sizeof(struct ethtool_fec_get_req_dump));
3935 }
3936 void ethtool_fec_get_req_dump_free(struct ethtool_fec_get_req_dump *req);
3937 
3938 static inline void
3939 ethtool_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 }
3946 static inline void
3947 ethtool_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 }
3956 static inline void
3957 ethtool_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 
3965 struct ethtool_fec_get_list {
3966 	struct ethtool_fec_get_list *next;
3967 	struct ethtool_fec_get_rsp obj __attribute__ ((aligned (8)));
3968 };
3969 
3970 void ethtool_fec_get_list_free(struct ethtool_fec_get_list *rsp);
3971 
3972 struct ethtool_fec_get_list *
3973 ethtool_fec_get_dump(struct ynl_sock *ys, struct ethtool_fec_get_req_dump *req);
3974 
3975 /* ETHTOOL_MSG_FEC_GET - notify */
3976 struct 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 
3984 void ethtool_fec_get_ntf_free(struct ethtool_fec_get_ntf *rsp);
3985 
3986 /* ============== ETHTOOL_MSG_FEC_SET ============== */
3987 /* ETHTOOL_MSG_FEC_SET - do */
3988 struct 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 
4004 static inline struct ethtool_fec_set_req *ethtool_fec_set_req_alloc(void)
4005 {
4006 	return calloc(1, sizeof(struct ethtool_fec_set_req));
4007 }
4008 void ethtool_fec_set_req_free(struct ethtool_fec_set_req *req);
4009 
4010 static inline void
4011 ethtool_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 }
4018 static inline void
4019 ethtool_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 }
4028 static inline void
4029 ethtool_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 }
4036 static inline void
4037 ethtool_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 }
4042 static inline void
4043 ethtool_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 }
4049 static 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 }
4058 static inline void
4059 ethtool_fec_set_req_set_auto_(struct ethtool_fec_set_req *req, __u8 auto_)
4060 {
4061 	req->_present.auto_ = 1;
4062 	req->auto_ = auto_;
4063 }
4064 static inline void
4065 ethtool_fec_set_req_set_active(struct ethtool_fec_set_req *req, __u32 active)
4066 {
4067 	req->_present.active = 1;
4068 	req->active = active;
4069 }
4070 static inline void
4071 ethtool_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 }
4079 static inline void
4080 ethtool_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 }
4088 static inline void
4089 ethtool_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  */
4101 int 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 */
4105 struct ethtool_module_eeprom_get_req {
4106 	struct {
4107 		__u32 header:1;
4108 	} _present;
4109 
4110 	struct ethtool_header header;
4111 };
4112 
4113 static inline struct ethtool_module_eeprom_get_req *
4114 ethtool_module_eeprom_get_req_alloc(void)
4115 {
4116 	return calloc(1, sizeof(struct ethtool_module_eeprom_get_req));
4117 }
4118 void
4119 ethtool_module_eeprom_get_req_free(struct ethtool_module_eeprom_get_req *req);
4120 
4121 static inline void
4122 ethtool_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 }
4129 static inline void
4130 ethtool_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 }
4139 static inline void
4140 ethtool_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 
4148 struct 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 
4168 void
4169 ethtool_module_eeprom_get_rsp_free(struct ethtool_module_eeprom_get_rsp *rsp);
4170 
4171 /*
4172  * Get module EEPROM params.
4173  */
4174 struct ethtool_module_eeprom_get_rsp *
4175 ethtool_module_eeprom_get(struct ynl_sock *ys,
4176 			  struct ethtool_module_eeprom_get_req *req);
4177 
4178 /* ETHTOOL_MSG_MODULE_EEPROM_GET - dump */
4179 struct ethtool_module_eeprom_get_req_dump {
4180 	struct {
4181 		__u32 header:1;
4182 	} _present;
4183 
4184 	struct ethtool_header header;
4185 };
4186 
4187 static inline struct ethtool_module_eeprom_get_req_dump *
4188 ethtool_module_eeprom_get_req_dump_alloc(void)
4189 {
4190 	return calloc(1, sizeof(struct ethtool_module_eeprom_get_req_dump));
4191 }
4192 void
4193 ethtool_module_eeprom_get_req_dump_free(struct ethtool_module_eeprom_get_req_dump *req);
4194 
4195 static inline void
4196 ethtool_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 }
4203 static inline void
4204 ethtool_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 }
4213 static inline void
4214 ethtool_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 
4222 struct 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 
4227 void
4228 ethtool_module_eeprom_get_list_free(struct ethtool_module_eeprom_get_list *rsp);
4229 
4230 struct ethtool_module_eeprom_get_list *
4231 ethtool_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 */
4236 struct ethtool_phc_vclocks_get_req {
4237 	struct {
4238 		__u32 header:1;
4239 	} _present;
4240 
4241 	struct ethtool_header header;
4242 };
4243 
4244 static inline struct ethtool_phc_vclocks_get_req *
4245 ethtool_phc_vclocks_get_req_alloc(void)
4246 {
4247 	return calloc(1, sizeof(struct ethtool_phc_vclocks_get_req));
4248 }
4249 void ethtool_phc_vclocks_get_req_free(struct ethtool_phc_vclocks_get_req *req);
4250 
4251 static inline void
4252 ethtool_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 }
4259 static inline void
4260 ethtool_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 }
4269 static inline void
4270 ethtool_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 
4278 struct 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 
4288 void ethtool_phc_vclocks_get_rsp_free(struct ethtool_phc_vclocks_get_rsp *rsp);
4289 
4290 /*
4291  * Get PHC VCLOCKs.
4292  */
4293 struct ethtool_phc_vclocks_get_rsp *
4294 ethtool_phc_vclocks_get(struct ynl_sock *ys,
4295 			struct ethtool_phc_vclocks_get_req *req);
4296 
4297 /* ETHTOOL_MSG_PHC_VCLOCKS_GET - dump */
4298 struct ethtool_phc_vclocks_get_req_dump {
4299 	struct {
4300 		__u32 header:1;
4301 	} _present;
4302 
4303 	struct ethtool_header header;
4304 };
4305 
4306 static inline struct ethtool_phc_vclocks_get_req_dump *
4307 ethtool_phc_vclocks_get_req_dump_alloc(void)
4308 {
4309 	return calloc(1, sizeof(struct ethtool_phc_vclocks_get_req_dump));
4310 }
4311 void
4312 ethtool_phc_vclocks_get_req_dump_free(struct ethtool_phc_vclocks_get_req_dump *req);
4313 
4314 static inline void
4315 ethtool_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 }
4322 static inline void
4323 ethtool_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 }
4332 static inline void
4333 ethtool_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 
4341 struct 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 
4346 void
4347 ethtool_phc_vclocks_get_list_free(struct ethtool_phc_vclocks_get_list *rsp);
4348 
4349 struct ethtool_phc_vclocks_get_list *
4350 ethtool_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 */
4355 struct ethtool_module_get_req {
4356 	struct {
4357 		__u32 header:1;
4358 	} _present;
4359 
4360 	struct ethtool_header header;
4361 };
4362 
4363 static inline struct ethtool_module_get_req *ethtool_module_get_req_alloc(void)
4364 {
4365 	return calloc(1, sizeof(struct ethtool_module_get_req));
4366 }
4367 void ethtool_module_get_req_free(struct ethtool_module_get_req *req);
4368 
4369 static inline void
4370 ethtool_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 }
4377 static inline void
4378 ethtool_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 }
4387 static inline void
4388 ethtool_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 
4396 struct 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 
4408 void ethtool_module_get_rsp_free(struct ethtool_module_get_rsp *rsp);
4409 
4410 /*
4411  * Get module params.
4412  */
4413 struct ethtool_module_get_rsp *
4414 ethtool_module_get(struct ynl_sock *ys, struct ethtool_module_get_req *req);
4415 
4416 /* ETHTOOL_MSG_MODULE_GET - dump */
4417 struct ethtool_module_get_req_dump {
4418 	struct {
4419 		__u32 header:1;
4420 	} _present;
4421 
4422 	struct ethtool_header header;
4423 };
4424 
4425 static inline struct ethtool_module_get_req_dump *
4426 ethtool_module_get_req_dump_alloc(void)
4427 {
4428 	return calloc(1, sizeof(struct ethtool_module_get_req_dump));
4429 }
4430 void ethtool_module_get_req_dump_free(struct ethtool_module_get_req_dump *req);
4431 
4432 static inline void
4433 ethtool_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 }
4440 static inline void
4441 ethtool_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 }
4450 static inline void
4451 ethtool_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 
4459 struct ethtool_module_get_list {
4460 	struct ethtool_module_get_list *next;
4461 	struct ethtool_module_get_rsp obj __attribute__ ((aligned (8)));
4462 };
4463 
4464 void ethtool_module_get_list_free(struct ethtool_module_get_list *rsp);
4465 
4466 struct ethtool_module_get_list *
4467 ethtool_module_get_dump(struct ynl_sock *ys,
4468 			struct ethtool_module_get_req_dump *req);
4469 
4470 /* ETHTOOL_MSG_MODULE_GET - notify */
4471 struct 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 
4479 void ethtool_module_get_ntf_free(struct ethtool_module_get_ntf *rsp);
4480 
4481 /* ============== ETHTOOL_MSG_MODULE_SET ============== */
4482 /* ETHTOOL_MSG_MODULE_SET - do */
4483 struct 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 
4495 static inline struct ethtool_module_set_req *ethtool_module_set_req_alloc(void)
4496 {
4497 	return calloc(1, sizeof(struct ethtool_module_set_req));
4498 }
4499 void ethtool_module_set_req_free(struct ethtool_module_set_req *req);
4500 
4501 static inline void
4502 ethtool_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 }
4509 static inline void
4510 ethtool_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 }
4519 static inline void
4520 ethtool_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 }
4527 static inline void
4528 ethtool_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 }
4534 static inline void
4535 ethtool_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  */
4545 int 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 */
4549 struct ethtool_pse_get_req {
4550 	struct {
4551 		__u32 header:1;
4552 	} _present;
4553 
4554 	struct ethtool_header header;
4555 };
4556 
4557 static inline struct ethtool_pse_get_req *ethtool_pse_get_req_alloc(void)
4558 {
4559 	return calloc(1, sizeof(struct ethtool_pse_get_req));
4560 }
4561 void ethtool_pse_get_req_free(struct ethtool_pse_get_req *req);
4562 
4563 static inline void
4564 ethtool_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 }
4571 static inline void
4572 ethtool_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 }
4581 static inline void
4582 ethtool_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 
4590 struct 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 
4604 void ethtool_pse_get_rsp_free(struct ethtool_pse_get_rsp *rsp);
4605 
4606 /*
4607  * Get Power Sourcing Equipment params.
4608  */
4609 struct ethtool_pse_get_rsp *
4610 ethtool_pse_get(struct ynl_sock *ys, struct ethtool_pse_get_req *req);
4611 
4612 /* ETHTOOL_MSG_PSE_GET - dump */
4613 struct ethtool_pse_get_req_dump {
4614 	struct {
4615 		__u32 header:1;
4616 	} _present;
4617 
4618 	struct ethtool_header header;
4619 };
4620 
4621 static inline struct ethtool_pse_get_req_dump *
4622 ethtool_pse_get_req_dump_alloc(void)
4623 {
4624 	return calloc(1, sizeof(struct ethtool_pse_get_req_dump));
4625 }
4626 void ethtool_pse_get_req_dump_free(struct ethtool_pse_get_req_dump *req);
4627 
4628 static inline void
4629 ethtool_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 }
4636 static inline void
4637 ethtool_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 }
4646 static inline void
4647 ethtool_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 
4655 struct ethtool_pse_get_list {
4656 	struct ethtool_pse_get_list *next;
4657 	struct ethtool_pse_get_rsp obj __attribute__ ((aligned (8)));
4658 };
4659 
4660 void ethtool_pse_get_list_free(struct ethtool_pse_get_list *rsp);
4661 
4662 struct ethtool_pse_get_list *
4663 ethtool_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 */
4667 struct 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 
4681 static inline struct ethtool_pse_set_req *ethtool_pse_set_req_alloc(void)
4682 {
4683 	return calloc(1, sizeof(struct ethtool_pse_set_req));
4684 }
4685 void ethtool_pse_set_req_free(struct ethtool_pse_set_req *req);
4686 
4687 static inline void
4688 ethtool_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 }
4695 static inline void
4696 ethtool_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 }
4705 static inline void
4706 ethtool_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 }
4713 static inline void
4714 ethtool_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 }
4720 static inline void
4721 ethtool_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 }
4727 static inline void
4728 ethtool_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  */
4738 int 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 */
4742 struct ethtool_rss_get_req {
4743 	struct {
4744 		__u32 header:1;
4745 	} _present;
4746 
4747 	struct ethtool_header header;
4748 };
4749 
4750 static inline struct ethtool_rss_get_req *ethtool_rss_get_req_alloc(void)
4751 {
4752 	return calloc(1, sizeof(struct ethtool_rss_get_req));
4753 }
4754 void ethtool_rss_get_req_free(struct ethtool_rss_get_req *req);
4755 
4756 static inline void
4757 ethtool_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 }
4764 static inline void
4765 ethtool_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 }
4774 static inline void
4775 ethtool_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 
4783 struct 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 
4799 void ethtool_rss_get_rsp_free(struct ethtool_rss_get_rsp *rsp);
4800 
4801 /*
4802  * Get RSS params.
4803  */
4804 struct ethtool_rss_get_rsp *
4805 ethtool_rss_get(struct ynl_sock *ys, struct ethtool_rss_get_req *req);
4806 
4807 /* ETHTOOL_MSG_RSS_GET - dump */
4808 struct ethtool_rss_get_req_dump {
4809 	struct {
4810 		__u32 header:1;
4811 	} _present;
4812 
4813 	struct ethtool_header header;
4814 };
4815 
4816 static inline struct ethtool_rss_get_req_dump *
4817 ethtool_rss_get_req_dump_alloc(void)
4818 {
4819 	return calloc(1, sizeof(struct ethtool_rss_get_req_dump));
4820 }
4821 void ethtool_rss_get_req_dump_free(struct ethtool_rss_get_req_dump *req);
4822 
4823 static inline void
4824 ethtool_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 }
4831 static inline void
4832 ethtool_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 }
4841 static inline void
4842 ethtool_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 
4850 struct ethtool_rss_get_list {
4851 	struct ethtool_rss_get_list *next;
4852 	struct ethtool_rss_get_rsp obj __attribute__ ((aligned (8)));
4853 };
4854 
4855 void ethtool_rss_get_list_free(struct ethtool_rss_get_list *rsp);
4856 
4857 struct ethtool_rss_get_list *
4858 ethtool_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 */
4862 struct ethtool_plca_get_cfg_req {
4863 	struct {
4864 		__u32 header:1;
4865 	} _present;
4866 
4867 	struct ethtool_header header;
4868 };
4869 
4870 static inline struct ethtool_plca_get_cfg_req *
4871 ethtool_plca_get_cfg_req_alloc(void)
4872 {
4873 	return calloc(1, sizeof(struct ethtool_plca_get_cfg_req));
4874 }
4875 void ethtool_plca_get_cfg_req_free(struct ethtool_plca_get_cfg_req *req);
4876 
4877 static inline void
4878 ethtool_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 }
4885 static inline void
4886 ethtool_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 }
4895 static inline void
4896 ethtool_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 
4904 struct 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 
4928 void ethtool_plca_get_cfg_rsp_free(struct ethtool_plca_get_cfg_rsp *rsp);
4929 
4930 /*
4931  * Get PLCA params.
4932  */
4933 struct ethtool_plca_get_cfg_rsp *
4934 ethtool_plca_get_cfg(struct ynl_sock *ys, struct ethtool_plca_get_cfg_req *req);
4935 
4936 /* ETHTOOL_MSG_PLCA_GET_CFG - dump */
4937 struct ethtool_plca_get_cfg_req_dump {
4938 	struct {
4939 		__u32 header:1;
4940 	} _present;
4941 
4942 	struct ethtool_header header;
4943 };
4944 
4945 static inline struct ethtool_plca_get_cfg_req_dump *
4946 ethtool_plca_get_cfg_req_dump_alloc(void)
4947 {
4948 	return calloc(1, sizeof(struct ethtool_plca_get_cfg_req_dump));
4949 }
4950 void
4951 ethtool_plca_get_cfg_req_dump_free(struct ethtool_plca_get_cfg_req_dump *req);
4952 
4953 static inline void
4954 ethtool_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 }
4961 static inline void
4962 ethtool_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 }
4971 static inline void
4972 ethtool_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 
4980 struct 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 
4985 void ethtool_plca_get_cfg_list_free(struct ethtool_plca_get_cfg_list *rsp);
4986 
4987 struct ethtool_plca_get_cfg_list *
4988 ethtool_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 */
4992 struct 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 
5000 void 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 */
5004 struct 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 
5028 static inline struct ethtool_plca_set_cfg_req *
5029 ethtool_plca_set_cfg_req_alloc(void)
5030 {
5031 	return calloc(1, sizeof(struct ethtool_plca_set_cfg_req));
5032 }
5033 void ethtool_plca_set_cfg_req_free(struct ethtool_plca_set_cfg_req *req);
5034 
5035 static inline void
5036 ethtool_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 }
5043 static inline void
5044 ethtool_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 }
5053 static inline void
5054 ethtool_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 }
5061 static inline void
5062 ethtool_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 }
5068 static inline void
5069 ethtool_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 }
5075 static inline void
5076 ethtool_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 }
5082 static inline void
5083 ethtool_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 }
5089 static inline void
5090 ethtool_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 }
5096 static inline void
5097 ethtool_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 }
5103 static inline void
5104 ethtool_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 }
5110 static inline void
5111 ethtool_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  */
5121 int 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 */
5126 struct ethtool_plca_get_status_req {
5127 	struct {
5128 		__u32 header:1;
5129 	} _present;
5130 
5131 	struct ethtool_header header;
5132 };
5133 
5134 static inline struct ethtool_plca_get_status_req *
5135 ethtool_plca_get_status_req_alloc(void)
5136 {
5137 	return calloc(1, sizeof(struct ethtool_plca_get_status_req));
5138 }
5139 void ethtool_plca_get_status_req_free(struct ethtool_plca_get_status_req *req);
5140 
5141 static inline void
5142 ethtool_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 }
5149 static inline void
5150 ethtool_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 }
5159 static inline void
5160 ethtool_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 
5168 struct 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 
5192 void ethtool_plca_get_status_rsp_free(struct ethtool_plca_get_status_rsp *rsp);
5193 
5194 /*
5195  * Get PLCA status params.
5196  */
5197 struct ethtool_plca_get_status_rsp *
5198 ethtool_plca_get_status(struct ynl_sock *ys,
5199 			struct ethtool_plca_get_status_req *req);
5200 
5201 /* ETHTOOL_MSG_PLCA_GET_STATUS - dump */
5202 struct ethtool_plca_get_status_req_dump {
5203 	struct {
5204 		__u32 header:1;
5205 	} _present;
5206 
5207 	struct ethtool_header header;
5208 };
5209 
5210 static inline struct ethtool_plca_get_status_req_dump *
5211 ethtool_plca_get_status_req_dump_alloc(void)
5212 {
5213 	return calloc(1, sizeof(struct ethtool_plca_get_status_req_dump));
5214 }
5215 void
5216 ethtool_plca_get_status_req_dump_free(struct ethtool_plca_get_status_req_dump *req);
5217 
5218 static inline void
5219 ethtool_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 }
5226 static inline void
5227 ethtool_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 }
5236 static inline void
5237 ethtool_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 
5245 struct 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 
5250 void
5251 ethtool_plca_get_status_list_free(struct ethtool_plca_get_status_list *rsp);
5252 
5253 struct ethtool_plca_get_status_list *
5254 ethtool_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 */
5259 struct ethtool_mm_get_req {
5260 	struct {
5261 		__u32 header:1;
5262 	} _present;
5263 
5264 	struct ethtool_header header;
5265 };
5266 
5267 static inline struct ethtool_mm_get_req *ethtool_mm_get_req_alloc(void)
5268 {
5269 	return calloc(1, sizeof(struct ethtool_mm_get_req));
5270 }
5271 void ethtool_mm_get_req_free(struct ethtool_mm_get_req *req);
5272 
5273 static inline void
5274 ethtool_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 }
5281 static inline void
5282 ethtool_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 }
5291 static inline void
5292 ethtool_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 
5300 struct 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 
5326 void ethtool_mm_get_rsp_free(struct ethtool_mm_get_rsp *rsp);
5327 
5328 /*
5329  * Get MAC Merge configuration and state
5330  */
5331 struct ethtool_mm_get_rsp *
5332 ethtool_mm_get(struct ynl_sock *ys, struct ethtool_mm_get_req *req);
5333 
5334 /* ETHTOOL_MSG_MM_GET - dump */
5335 struct ethtool_mm_get_req_dump {
5336 	struct {
5337 		__u32 header:1;
5338 	} _present;
5339 
5340 	struct ethtool_header header;
5341 };
5342 
5343 static inline struct ethtool_mm_get_req_dump *
5344 ethtool_mm_get_req_dump_alloc(void)
5345 {
5346 	return calloc(1, sizeof(struct ethtool_mm_get_req_dump));
5347 }
5348 void ethtool_mm_get_req_dump_free(struct ethtool_mm_get_req_dump *req);
5349 
5350 static inline void
5351 ethtool_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 }
5358 static inline void
5359 ethtool_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 }
5368 static inline void
5369 ethtool_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 
5377 struct ethtool_mm_get_list {
5378 	struct ethtool_mm_get_list *next;
5379 	struct ethtool_mm_get_rsp obj __attribute__ ((aligned (8)));
5380 };
5381 
5382 void ethtool_mm_get_list_free(struct ethtool_mm_get_list *rsp);
5383 
5384 struct ethtool_mm_get_list *
5385 ethtool_mm_get_dump(struct ynl_sock *ys, struct ethtool_mm_get_req_dump *req);
5386 
5387 /* ETHTOOL_MSG_MM_GET - notify */
5388 struct 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 
5396 void ethtool_mm_get_ntf_free(struct ethtool_mm_get_ntf *rsp);
5397 
5398 /* ============== ETHTOOL_MSG_MM_SET ============== */
5399 /* ETHTOOL_MSG_MM_SET - do */
5400 struct 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 
5418 static inline struct ethtool_mm_set_req *ethtool_mm_set_req_alloc(void)
5419 {
5420 	return calloc(1, sizeof(struct ethtool_mm_set_req));
5421 }
5422 void ethtool_mm_set_req_free(struct ethtool_mm_set_req *req);
5423 
5424 static inline void
5425 ethtool_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 }
5432 static inline void
5433 ethtool_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 }
5442 static inline void
5443 ethtool_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 }
5450 static inline void
5451 ethtool_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 }
5457 static inline void
5458 ethtool_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 }
5464 static inline void
5465 ethtool_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 }
5471 static inline void
5472 ethtool_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 }
5478 static inline void
5479 ethtool_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  */
5489 int ethtool_mm_set(struct ynl_sock *ys, struct ethtool_mm_set_req *req);
5490 
5491 /* ETHTOOL_MSG_CABLE_TEST_NTF - event */
5492 struct 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 
5502 struct 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 
5510 void ethtool_cable_test_ntf_free(struct ethtool_cable_test_ntf *rsp);
5511 
5512 /* ETHTOOL_MSG_CABLE_TEST_TDR_NTF - event */
5513 struct 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 
5525 struct 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 
5533 void ethtool_cable_test_tdr_ntf_free(struct ethtool_cable_test_tdr_ntf *rsp);
5534 
5535 #endif /* _LINUX_ETHTOOL_GEN_H */
5536