| /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ | |
| /* Do not edit directly, auto-generated from: */ | |
| /* Documentation/netlink/specs/ethtool.yaml */ | |
| /* YNL-GEN user header */ | |
| /* YNL-ARG --user-header linux/ethtool_netlink.h --exclude-op stats-get */ | |
| #ifndef _LINUX_ETHTOOL_GEN_H | |
| #define _LINUX_ETHTOOL_GEN_H | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <linux/types.h> | |
| #include <linux/ethtool.h> | |
| struct ynl_sock; | |
| extern const struct ynl_family ynl_ethtool_family; | |
| /* Enums */ | |
| const char *ethtool_op_str(int op); | |
| const char *ethtool_udp_tunnel_type_str(int value); | |
| const char *ethtool_stringset_str(enum ethtool_stringset value); | |
| /* Common nested types */ | |
| struct ethtool_header { | |
| struct { | |
| __u32 dev_index:1; | |
| __u32 dev_name_len; | |
| __u32 flags:1; | |
| } _present; | |
| __u32 dev_index; | |
| char *dev_name; | |
| __u32 flags; | |
| }; | |
| struct ethtool_pause_stat { | |
| struct { | |
| __u32 tx_frames:1; | |
| __u32 rx_frames:1; | |
| } _present; | |
| __u64 tx_frames; | |
| __u64 rx_frames; | |
| }; | |
| struct ethtool_cable_test_tdr_cfg { | |
| struct { | |
| __u32 first:1; | |
| __u32 last:1; | |
| __u32 step:1; | |
| __u32 pair:1; | |
| } _present; | |
| __u32 first; | |
| __u32 last; | |
| __u32 step; | |
| __u8 pair; | |
| }; | |
| struct ethtool_fec_stat { | |
| struct { | |
| __u32 corrected_len; | |
| __u32 uncorr_len; | |
| __u32 corr_bits_len; | |
| } _present; | |
| void *corrected; | |
| void *uncorr; | |
| void *corr_bits; | |
| }; | |
| struct ethtool_mm_stat { | |
| struct { | |
| __u32 reassembly_errors:1; | |
| __u32 smd_errors:1; | |
| __u32 reassembly_ok:1; | |
| __u32 rx_frag_count:1; | |
| __u32 tx_frag_count:1; | |
| __u32 hold_count:1; | |
| } _present; | |
| __u64 reassembly_errors; | |
| __u64 smd_errors; | |
| __u64 reassembly_ok; | |
| __u64 rx_frag_count; | |
| __u64 tx_frag_count; | |
| __u64 hold_count; | |
| }; | |
| struct ethtool_cable_result { | |
| struct { | |
| __u32 pair:1; | |
| __u32 code:1; | |
| } _present; | |
| __u8 pair; | |
| __u8 code; | |
| }; | |
| struct ethtool_cable_fault_length { | |
| struct { | |
| __u32 pair:1; | |
| __u32 cm:1; | |
| } _present; | |
| __u8 pair; | |
| __u32 cm; | |
| }; | |
| struct ethtool_bitset_bit { | |
| struct { | |
| __u32 index:1; | |
| __u32 name_len; | |
| __u32 value:1; | |
| } _present; | |
| __u32 index; | |
| char *name; | |
| }; | |
| struct ethtool_tunnel_udp_entry { | |
| struct { | |
| __u32 port:1; | |
| __u32 type:1; | |
| } _present; | |
| __u16 port /* big-endian */; | |
| __u32 type; | |
| }; | |
| struct ethtool_string { | |
| struct { | |
| __u32 index:1; | |
| __u32 value_len; | |
| } _present; | |
| __u32 index; | |
| char *value; | |
| }; | |
| struct ethtool_cable_nest { | |
| struct { | |
| __u32 result:1; | |
| __u32 fault_length:1; | |
| } _present; | |
| struct ethtool_cable_result result; | |
| struct ethtool_cable_fault_length fault_length; | |
| }; | |
| struct ethtool_bitset_bits { | |
| unsigned int n_bit; | |
| struct ethtool_bitset_bit *bit; | |
| }; | |
| struct ethtool_strings { | |
| unsigned int n_string; | |
| struct ethtool_string *string; | |
| }; | |
| struct ethtool_bitset { | |
| struct { | |
| __u32 nomask:1; | |
| __u32 size:1; | |
| __u32 bits:1; | |
| } _present; | |
| __u32 size; | |
| struct ethtool_bitset_bits bits; | |
| }; | |
| struct ethtool_stringset_ { | |
| struct { | |
| __u32 id:1; | |
| __u32 count:1; | |
| } _present; | |
| __u32 id; | |
| __u32 count; | |
| unsigned int n_strings; | |
| struct ethtool_strings *strings; | |
| }; | |
| struct ethtool_tunnel_udp_table { | |
| struct { | |
| __u32 size:1; | |
| __u32 types:1; | |
| } _present; | |
| __u32 size; | |
| struct ethtool_bitset types; | |
| unsigned int n_entry; | |
| struct ethtool_tunnel_udp_entry *entry; | |
| }; | |
| struct ethtool_stringsets { | |
| unsigned int n_stringset; | |
| struct ethtool_stringset_ *stringset; | |
| }; | |
| struct ethtool_tunnel_udp { | |
| struct { | |
| __u32 table:1; | |
| } _present; | |
| struct ethtool_tunnel_udp_table table; | |
| }; | |
| /* ============== ETHTOOL_MSG_STRSET_GET ============== */ | |
| /* ETHTOOL_MSG_STRSET_GET - do */ | |
| struct ethtool_strset_get_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 stringsets:1; | |
| __u32 counts_only:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_stringsets stringsets; | |
| }; | |
| static inline struct ethtool_strset_get_req *ethtool_strset_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_strset_get_req)); | |
| } | |
| void ethtool_strset_get_req_free(struct ethtool_strset_get_req *req); | |
| static inline void | |
| ethtool_strset_get_req_set_header_dev_index(struct ethtool_strset_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_strset_get_req_set_header_dev_name(struct ethtool_strset_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_strset_get_req_set_header_flags(struct ethtool_strset_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| __ethtool_strset_get_req_set_stringsets_stringset(struct ethtool_strset_get_req *req, | |
| struct ethtool_stringset_ *stringset, | |
| unsigned int n_stringset) | |
| { | |
| free(req->stringsets.stringset); | |
| req->stringsets.stringset = stringset; | |
| req->stringsets.n_stringset = n_stringset; | |
| } | |
| static inline void | |
| ethtool_strset_get_req_set_counts_only(struct ethtool_strset_get_req *req) | |
| { | |
| req->_present.counts_only = 1; | |
| } | |
| struct ethtool_strset_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 stringsets:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_stringsets stringsets; | |
| }; | |
| void ethtool_strset_get_rsp_free(struct ethtool_strset_get_rsp *rsp); | |
| /* | |
| * Get string set from the kernel. | |
| */ | |
| struct ethtool_strset_get_rsp * | |
| ethtool_strset_get(struct ynl_sock *ys, struct ethtool_strset_get_req *req); | |
| /* ETHTOOL_MSG_STRSET_GET - dump */ | |
| struct ethtool_strset_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| __u32 stringsets:1; | |
| __u32 counts_only:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_stringsets stringsets; | |
| }; | |
| static inline struct ethtool_strset_get_req_dump * | |
| ethtool_strset_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_strset_get_req_dump)); | |
| } | |
| void ethtool_strset_get_req_dump_free(struct ethtool_strset_get_req_dump *req); | |
| static inline void | |
| ethtool_strset_get_req_dump_set_header_dev_index(struct ethtool_strset_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_strset_get_req_dump_set_header_dev_name(struct ethtool_strset_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_strset_get_req_dump_set_header_flags(struct ethtool_strset_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| __ethtool_strset_get_req_dump_set_stringsets_stringset(struct ethtool_strset_get_req_dump *req, | |
| struct ethtool_stringset_ *stringset, | |
| unsigned int n_stringset) | |
| { | |
| free(req->stringsets.stringset); | |
| req->stringsets.stringset = stringset; | |
| req->stringsets.n_stringset = n_stringset; | |
| } | |
| static inline void | |
| ethtool_strset_get_req_dump_set_counts_only(struct ethtool_strset_get_req_dump *req) | |
| { | |
| req->_present.counts_only = 1; | |
| } | |
| struct ethtool_strset_get_list { | |
| struct ethtool_strset_get_list *next; | |
| struct ethtool_strset_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_strset_get_list_free(struct ethtool_strset_get_list *rsp); | |
| struct ethtool_strset_get_list * | |
| ethtool_strset_get_dump(struct ynl_sock *ys, | |
| struct ethtool_strset_get_req_dump *req); | |
| /* ============== ETHTOOL_MSG_LINKINFO_GET ============== */ | |
| /* ETHTOOL_MSG_LINKINFO_GET - do */ | |
| struct ethtool_linkinfo_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_linkinfo_get_req * | |
| ethtool_linkinfo_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_linkinfo_get_req)); | |
| } | |
| void ethtool_linkinfo_get_req_free(struct ethtool_linkinfo_get_req *req); | |
| static inline void | |
| ethtool_linkinfo_get_req_set_header_dev_index(struct ethtool_linkinfo_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_linkinfo_get_req_set_header_dev_name(struct ethtool_linkinfo_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_linkinfo_get_req_set_header_flags(struct ethtool_linkinfo_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_linkinfo_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 port:1; | |
| __u32 phyaddr:1; | |
| __u32 tp_mdix:1; | |
| __u32 tp_mdix_ctrl:1; | |
| __u32 transceiver:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u8 port; | |
| __u8 phyaddr; | |
| __u8 tp_mdix; | |
| __u8 tp_mdix_ctrl; | |
| __u8 transceiver; | |
| }; | |
| void ethtool_linkinfo_get_rsp_free(struct ethtool_linkinfo_get_rsp *rsp); | |
| /* | |
| * Get link info. | |
| */ | |
| struct ethtool_linkinfo_get_rsp * | |
| ethtool_linkinfo_get(struct ynl_sock *ys, struct ethtool_linkinfo_get_req *req); | |
| /* ETHTOOL_MSG_LINKINFO_GET - dump */ | |
| struct ethtool_linkinfo_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_linkinfo_get_req_dump * | |
| ethtool_linkinfo_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_linkinfo_get_req_dump)); | |
| } | |
| void | |
| ethtool_linkinfo_get_req_dump_free(struct ethtool_linkinfo_get_req_dump *req); | |
| static inline void | |
| ethtool_linkinfo_get_req_dump_set_header_dev_index(struct ethtool_linkinfo_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_linkinfo_get_req_dump_set_header_dev_name(struct ethtool_linkinfo_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_linkinfo_get_req_dump_set_header_flags(struct ethtool_linkinfo_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_linkinfo_get_list { | |
| struct ethtool_linkinfo_get_list *next; | |
| struct ethtool_linkinfo_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_linkinfo_get_list_free(struct ethtool_linkinfo_get_list *rsp); | |
| struct ethtool_linkinfo_get_list * | |
| ethtool_linkinfo_get_dump(struct ynl_sock *ys, | |
| struct ethtool_linkinfo_get_req_dump *req); | |
| /* ETHTOOL_MSG_LINKINFO_GET - notify */ | |
| struct ethtool_linkinfo_get_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_linkinfo_get_ntf *ntf); | |
| struct ethtool_linkinfo_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_linkinfo_get_ntf_free(struct ethtool_linkinfo_get_ntf *rsp); | |
| /* ============== ETHTOOL_MSG_LINKINFO_SET ============== */ | |
| /* ETHTOOL_MSG_LINKINFO_SET - do */ | |
| struct ethtool_linkinfo_set_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 port:1; | |
| __u32 phyaddr:1; | |
| __u32 tp_mdix:1; | |
| __u32 tp_mdix_ctrl:1; | |
| __u32 transceiver:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u8 port; | |
| __u8 phyaddr; | |
| __u8 tp_mdix; | |
| __u8 tp_mdix_ctrl; | |
| __u8 transceiver; | |
| }; | |
| static inline struct ethtool_linkinfo_set_req * | |
| ethtool_linkinfo_set_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_linkinfo_set_req)); | |
| } | |
| void ethtool_linkinfo_set_req_free(struct ethtool_linkinfo_set_req *req); | |
| static inline void | |
| ethtool_linkinfo_set_req_set_header_dev_index(struct ethtool_linkinfo_set_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_linkinfo_set_req_set_header_dev_name(struct ethtool_linkinfo_set_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_linkinfo_set_req_set_header_flags(struct ethtool_linkinfo_set_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_linkinfo_set_req_set_port(struct ethtool_linkinfo_set_req *req, | |
| __u8 port) | |
| { | |
| req->_present.port = 1; | |
| req->port = port; | |
| } | |
| static inline void | |
| ethtool_linkinfo_set_req_set_phyaddr(struct ethtool_linkinfo_set_req *req, | |
| __u8 phyaddr) | |
| { | |
| req->_present.phyaddr = 1; | |
| req->phyaddr = phyaddr; | |
| } | |
| static inline void | |
| ethtool_linkinfo_set_req_set_tp_mdix(struct ethtool_linkinfo_set_req *req, | |
| __u8 tp_mdix) | |
| { | |
| req->_present.tp_mdix = 1; | |
| req->tp_mdix = tp_mdix; | |
| } | |
| static inline void | |
| ethtool_linkinfo_set_req_set_tp_mdix_ctrl(struct ethtool_linkinfo_set_req *req, | |
| __u8 tp_mdix_ctrl) | |
| { | |
| req->_present.tp_mdix_ctrl = 1; | |
| req->tp_mdix_ctrl = tp_mdix_ctrl; | |
| } | |
| static inline void | |
| ethtool_linkinfo_set_req_set_transceiver(struct ethtool_linkinfo_set_req *req, | |
| __u8 transceiver) | |
| { | |
| req->_present.transceiver = 1; | |
| req->transceiver = transceiver; | |
| } | |
| /* | |
| * Set link info. | |
| */ | |
| int ethtool_linkinfo_set(struct ynl_sock *ys, | |
| struct ethtool_linkinfo_set_req *req); | |
| /* ============== ETHTOOL_MSG_LINKMODES_GET ============== */ | |
| /* ETHTOOL_MSG_LINKMODES_GET - do */ | |
| struct ethtool_linkmodes_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_linkmodes_get_req * | |
| ethtool_linkmodes_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_linkmodes_get_req)); | |
| } | |
| void ethtool_linkmodes_get_req_free(struct ethtool_linkmodes_get_req *req); | |
| static inline void | |
| ethtool_linkmodes_get_req_set_header_dev_index(struct ethtool_linkmodes_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_linkmodes_get_req_set_header_dev_name(struct ethtool_linkmodes_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_linkmodes_get_req_set_header_flags(struct ethtool_linkmodes_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_linkmodes_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 autoneg:1; | |
| __u32 ours:1; | |
| __u32 peer:1; | |
| __u32 speed:1; | |
| __u32 duplex:1; | |
| __u32 master_slave_cfg:1; | |
| __u32 master_slave_state:1; | |
| __u32 lanes:1; | |
| __u32 rate_matching:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u8 autoneg; | |
| struct ethtool_bitset ours; | |
| struct ethtool_bitset peer; | |
| __u32 speed; | |
| __u8 duplex; | |
| __u8 master_slave_cfg; | |
| __u8 master_slave_state; | |
| __u32 lanes; | |
| __u8 rate_matching; | |
| }; | |
| void ethtool_linkmodes_get_rsp_free(struct ethtool_linkmodes_get_rsp *rsp); | |
| /* | |
| * Get link modes. | |
| */ | |
| struct ethtool_linkmodes_get_rsp * | |
| ethtool_linkmodes_get(struct ynl_sock *ys, | |
| struct ethtool_linkmodes_get_req *req); | |
| /* ETHTOOL_MSG_LINKMODES_GET - dump */ | |
| struct ethtool_linkmodes_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_linkmodes_get_req_dump * | |
| ethtool_linkmodes_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_linkmodes_get_req_dump)); | |
| } | |
| void | |
| ethtool_linkmodes_get_req_dump_free(struct ethtool_linkmodes_get_req_dump *req); | |
| static inline void | |
| ethtool_linkmodes_get_req_dump_set_header_dev_index(struct ethtool_linkmodes_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_linkmodes_get_req_dump_set_header_dev_name(struct ethtool_linkmodes_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_linkmodes_get_req_dump_set_header_flags(struct ethtool_linkmodes_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_linkmodes_get_list { | |
| struct ethtool_linkmodes_get_list *next; | |
| struct ethtool_linkmodes_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_linkmodes_get_list_free(struct ethtool_linkmodes_get_list *rsp); | |
| struct ethtool_linkmodes_get_list * | |
| ethtool_linkmodes_get_dump(struct ynl_sock *ys, | |
| struct ethtool_linkmodes_get_req_dump *req); | |
| /* ETHTOOL_MSG_LINKMODES_GET - notify */ | |
| struct ethtool_linkmodes_get_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_linkmodes_get_ntf *ntf); | |
| struct ethtool_linkmodes_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_linkmodes_get_ntf_free(struct ethtool_linkmodes_get_ntf *rsp); | |
| /* ============== ETHTOOL_MSG_LINKMODES_SET ============== */ | |
| /* ETHTOOL_MSG_LINKMODES_SET - do */ | |
| struct ethtool_linkmodes_set_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 autoneg:1; | |
| __u32 ours:1; | |
| __u32 peer:1; | |
| __u32 speed:1; | |
| __u32 duplex:1; | |
| __u32 master_slave_cfg:1; | |
| __u32 master_slave_state:1; | |
| __u32 lanes:1; | |
| __u32 rate_matching:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u8 autoneg; | |
| struct ethtool_bitset ours; | |
| struct ethtool_bitset peer; | |
| __u32 speed; | |
| __u8 duplex; | |
| __u8 master_slave_cfg; | |
| __u8 master_slave_state; | |
| __u32 lanes; | |
| __u8 rate_matching; | |
| }; | |
| static inline struct ethtool_linkmodes_set_req * | |
| ethtool_linkmodes_set_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_linkmodes_set_req)); | |
| } | |
| void ethtool_linkmodes_set_req_free(struct ethtool_linkmodes_set_req *req); | |
| static inline void | |
| ethtool_linkmodes_set_req_set_header_dev_index(struct ethtool_linkmodes_set_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_linkmodes_set_req_set_header_dev_name(struct ethtool_linkmodes_set_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_linkmodes_set_req_set_header_flags(struct ethtool_linkmodes_set_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_linkmodes_set_req_set_autoneg(struct ethtool_linkmodes_set_req *req, | |
| __u8 autoneg) | |
| { | |
| req->_present.autoneg = 1; | |
| req->autoneg = autoneg; | |
| } | |
| static inline void | |
| ethtool_linkmodes_set_req_set_ours_nomask(struct ethtool_linkmodes_set_req *req) | |
| { | |
| req->_present.ours = 1; | |
| req->ours._present.nomask = 1; | |
| } | |
| static inline void | |
| ethtool_linkmodes_set_req_set_ours_size(struct ethtool_linkmodes_set_req *req, | |
| __u32 size) | |
| { | |
| req->_present.ours = 1; | |
| req->ours._present.size = 1; | |
| req->ours.size = size; | |
| } | |
| static inline void | |
| __ethtool_linkmodes_set_req_set_ours_bits_bit(struct ethtool_linkmodes_set_req *req, | |
| struct ethtool_bitset_bit *bit, | |
| unsigned int n_bit) | |
| { | |
| free(req->ours.bits.bit); | |
| req->ours.bits.bit = bit; | |
| req->ours.bits.n_bit = n_bit; | |
| } | |
| static inline void | |
| ethtool_linkmodes_set_req_set_peer_nomask(struct ethtool_linkmodes_set_req *req) | |
| { | |
| req->_present.peer = 1; | |
| req->peer._present.nomask = 1; | |
| } | |
| static inline void | |
| ethtool_linkmodes_set_req_set_peer_size(struct ethtool_linkmodes_set_req *req, | |
| __u32 size) | |
| { | |
| req->_present.peer = 1; | |
| req->peer._present.size = 1; | |
| req->peer.size = size; | |
| } | |
| static inline void | |
| __ethtool_linkmodes_set_req_set_peer_bits_bit(struct ethtool_linkmodes_set_req *req, | |
| struct ethtool_bitset_bit *bit, | |
| unsigned int n_bit) | |
| { | |
| free(req->peer.bits.bit); | |
| req->peer.bits.bit = bit; | |
| req->peer.bits.n_bit = n_bit; | |
| } | |
| static inline void | |
| ethtool_linkmodes_set_req_set_speed(struct ethtool_linkmodes_set_req *req, | |
| __u32 speed) | |
| { | |
| req->_present.speed = 1; | |
| req->speed = speed; | |
| } | |
| static inline void | |
| ethtool_linkmodes_set_req_set_duplex(struct ethtool_linkmodes_set_req *req, | |
| __u8 duplex) | |
| { | |
| req->_present.duplex = 1; | |
| req->duplex = duplex; | |
| } | |
| static inline void | |
| ethtool_linkmodes_set_req_set_master_slave_cfg(struct ethtool_linkmodes_set_req *req, | |
| __u8 master_slave_cfg) | |
| { | |
| req->_present.master_slave_cfg = 1; | |
| req->master_slave_cfg = master_slave_cfg; | |
| } | |
| static inline void | |
| ethtool_linkmodes_set_req_set_master_slave_state(struct ethtool_linkmodes_set_req *req, | |
| __u8 master_slave_state) | |
| { | |
| req->_present.master_slave_state = 1; | |
| req->master_slave_state = master_slave_state; | |
| } | |
| static inline void | |
| ethtool_linkmodes_set_req_set_lanes(struct ethtool_linkmodes_set_req *req, | |
| __u32 lanes) | |
| { | |
| req->_present.lanes = 1; | |
| req->lanes = lanes; | |
| } | |
| static inline void | |
| ethtool_linkmodes_set_req_set_rate_matching(struct ethtool_linkmodes_set_req *req, | |
| __u8 rate_matching) | |
| { | |
| req->_present.rate_matching = 1; | |
| req->rate_matching = rate_matching; | |
| } | |
| /* | |
| * Set link modes. | |
| */ | |
| int ethtool_linkmodes_set(struct ynl_sock *ys, | |
| struct ethtool_linkmodes_set_req *req); | |
| /* ============== ETHTOOL_MSG_LINKSTATE_GET ============== */ | |
| /* ETHTOOL_MSG_LINKSTATE_GET - do */ | |
| struct ethtool_linkstate_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_linkstate_get_req * | |
| ethtool_linkstate_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_linkstate_get_req)); | |
| } | |
| void ethtool_linkstate_get_req_free(struct ethtool_linkstate_get_req *req); | |
| static inline void | |
| ethtool_linkstate_get_req_set_header_dev_index(struct ethtool_linkstate_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_linkstate_get_req_set_header_dev_name(struct ethtool_linkstate_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_linkstate_get_req_set_header_flags(struct ethtool_linkstate_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_linkstate_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 link:1; | |
| __u32 sqi:1; | |
| __u32 sqi_max:1; | |
| __u32 ext_state:1; | |
| __u32 ext_substate:1; | |
| __u32 ext_down_cnt:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u8 link; | |
| __u32 sqi; | |
| __u32 sqi_max; | |
| __u8 ext_state; | |
| __u8 ext_substate; | |
| __u32 ext_down_cnt; | |
| }; | |
| void ethtool_linkstate_get_rsp_free(struct ethtool_linkstate_get_rsp *rsp); | |
| /* | |
| * Get link state. | |
| */ | |
| struct ethtool_linkstate_get_rsp * | |
| ethtool_linkstate_get(struct ynl_sock *ys, | |
| struct ethtool_linkstate_get_req *req); | |
| /* ETHTOOL_MSG_LINKSTATE_GET - dump */ | |
| struct ethtool_linkstate_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_linkstate_get_req_dump * | |
| ethtool_linkstate_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_linkstate_get_req_dump)); | |
| } | |
| void | |
| ethtool_linkstate_get_req_dump_free(struct ethtool_linkstate_get_req_dump *req); | |
| static inline void | |
| ethtool_linkstate_get_req_dump_set_header_dev_index(struct ethtool_linkstate_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_linkstate_get_req_dump_set_header_dev_name(struct ethtool_linkstate_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_linkstate_get_req_dump_set_header_flags(struct ethtool_linkstate_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_linkstate_get_list { | |
| struct ethtool_linkstate_get_list *next; | |
| struct ethtool_linkstate_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_linkstate_get_list_free(struct ethtool_linkstate_get_list *rsp); | |
| struct ethtool_linkstate_get_list * | |
| ethtool_linkstate_get_dump(struct ynl_sock *ys, | |
| struct ethtool_linkstate_get_req_dump *req); | |
| /* ============== ETHTOOL_MSG_DEBUG_GET ============== */ | |
| /* ETHTOOL_MSG_DEBUG_GET - do */ | |
| struct ethtool_debug_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_debug_get_req *ethtool_debug_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_debug_get_req)); | |
| } | |
| void ethtool_debug_get_req_free(struct ethtool_debug_get_req *req); | |
| static inline void | |
| ethtool_debug_get_req_set_header_dev_index(struct ethtool_debug_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_debug_get_req_set_header_dev_name(struct ethtool_debug_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_debug_get_req_set_header_flags(struct ethtool_debug_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_debug_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 msgmask:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_bitset msgmask; | |
| }; | |
| void ethtool_debug_get_rsp_free(struct ethtool_debug_get_rsp *rsp); | |
| /* | |
| * Get debug message mask. | |
| */ | |
| struct ethtool_debug_get_rsp * | |
| ethtool_debug_get(struct ynl_sock *ys, struct ethtool_debug_get_req *req); | |
| /* ETHTOOL_MSG_DEBUG_GET - dump */ | |
| struct ethtool_debug_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_debug_get_req_dump * | |
| ethtool_debug_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_debug_get_req_dump)); | |
| } | |
| void ethtool_debug_get_req_dump_free(struct ethtool_debug_get_req_dump *req); | |
| static inline void | |
| ethtool_debug_get_req_dump_set_header_dev_index(struct ethtool_debug_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_debug_get_req_dump_set_header_dev_name(struct ethtool_debug_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_debug_get_req_dump_set_header_flags(struct ethtool_debug_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_debug_get_list { | |
| struct ethtool_debug_get_list *next; | |
| struct ethtool_debug_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_debug_get_list_free(struct ethtool_debug_get_list *rsp); | |
| struct ethtool_debug_get_list * | |
| ethtool_debug_get_dump(struct ynl_sock *ys, | |
| struct ethtool_debug_get_req_dump *req); | |
| /* ETHTOOL_MSG_DEBUG_GET - notify */ | |
| struct ethtool_debug_get_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_debug_get_ntf *ntf); | |
| struct ethtool_debug_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_debug_get_ntf_free(struct ethtool_debug_get_ntf *rsp); | |
| /* ============== ETHTOOL_MSG_DEBUG_SET ============== */ | |
| /* ETHTOOL_MSG_DEBUG_SET - do */ | |
| struct ethtool_debug_set_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 msgmask:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_bitset msgmask; | |
| }; | |
| static inline struct ethtool_debug_set_req *ethtool_debug_set_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_debug_set_req)); | |
| } | |
| void ethtool_debug_set_req_free(struct ethtool_debug_set_req *req); | |
| static inline void | |
| ethtool_debug_set_req_set_header_dev_index(struct ethtool_debug_set_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_debug_set_req_set_header_dev_name(struct ethtool_debug_set_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_debug_set_req_set_header_flags(struct ethtool_debug_set_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_debug_set_req_set_msgmask_nomask(struct ethtool_debug_set_req *req) | |
| { | |
| req->_present.msgmask = 1; | |
| req->msgmask._present.nomask = 1; | |
| } | |
| static inline void | |
| ethtool_debug_set_req_set_msgmask_size(struct ethtool_debug_set_req *req, | |
| __u32 size) | |
| { | |
| req->_present.msgmask = 1; | |
| req->msgmask._present.size = 1; | |
| req->msgmask.size = size; | |
| } | |
| static inline void | |
| __ethtool_debug_set_req_set_msgmask_bits_bit(struct ethtool_debug_set_req *req, | |
| struct ethtool_bitset_bit *bit, | |
| unsigned int n_bit) | |
| { | |
| free(req->msgmask.bits.bit); | |
| req->msgmask.bits.bit = bit; | |
| req->msgmask.bits.n_bit = n_bit; | |
| } | |
| /* | |
| * Set debug message mask. | |
| */ | |
| int ethtool_debug_set(struct ynl_sock *ys, struct ethtool_debug_set_req *req); | |
| /* ============== ETHTOOL_MSG_WOL_GET ============== */ | |
| /* ETHTOOL_MSG_WOL_GET - do */ | |
| struct ethtool_wol_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_wol_get_req *ethtool_wol_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_wol_get_req)); | |
| } | |
| void ethtool_wol_get_req_free(struct ethtool_wol_get_req *req); | |
| static inline void | |
| ethtool_wol_get_req_set_header_dev_index(struct ethtool_wol_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_wol_get_req_set_header_dev_name(struct ethtool_wol_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_wol_get_req_set_header_flags(struct ethtool_wol_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_wol_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 modes:1; | |
| __u32 sopass_len; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_bitset modes; | |
| void *sopass; | |
| }; | |
| void ethtool_wol_get_rsp_free(struct ethtool_wol_get_rsp *rsp); | |
| /* | |
| * Get WOL params. | |
| */ | |
| struct ethtool_wol_get_rsp * | |
| ethtool_wol_get(struct ynl_sock *ys, struct ethtool_wol_get_req *req); | |
| /* ETHTOOL_MSG_WOL_GET - dump */ | |
| struct ethtool_wol_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_wol_get_req_dump * | |
| ethtool_wol_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_wol_get_req_dump)); | |
| } | |
| void ethtool_wol_get_req_dump_free(struct ethtool_wol_get_req_dump *req); | |
| static inline void | |
| ethtool_wol_get_req_dump_set_header_dev_index(struct ethtool_wol_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_wol_get_req_dump_set_header_dev_name(struct ethtool_wol_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_wol_get_req_dump_set_header_flags(struct ethtool_wol_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_wol_get_list { | |
| struct ethtool_wol_get_list *next; | |
| struct ethtool_wol_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_wol_get_list_free(struct ethtool_wol_get_list *rsp); | |
| struct ethtool_wol_get_list * | |
| ethtool_wol_get_dump(struct ynl_sock *ys, struct ethtool_wol_get_req_dump *req); | |
| /* ETHTOOL_MSG_WOL_GET - notify */ | |
| struct ethtool_wol_get_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_wol_get_ntf *ntf); | |
| struct ethtool_wol_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_wol_get_ntf_free(struct ethtool_wol_get_ntf *rsp); | |
| /* ============== ETHTOOL_MSG_WOL_SET ============== */ | |
| /* ETHTOOL_MSG_WOL_SET - do */ | |
| struct ethtool_wol_set_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 modes:1; | |
| __u32 sopass_len; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_bitset modes; | |
| void *sopass; | |
| }; | |
| static inline struct ethtool_wol_set_req *ethtool_wol_set_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_wol_set_req)); | |
| } | |
| void ethtool_wol_set_req_free(struct ethtool_wol_set_req *req); | |
| static inline void | |
| ethtool_wol_set_req_set_header_dev_index(struct ethtool_wol_set_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_wol_set_req_set_header_dev_name(struct ethtool_wol_set_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_wol_set_req_set_header_flags(struct ethtool_wol_set_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_wol_set_req_set_modes_nomask(struct ethtool_wol_set_req *req) | |
| { | |
| req->_present.modes = 1; | |
| req->modes._present.nomask = 1; | |
| } | |
| static inline void | |
| ethtool_wol_set_req_set_modes_size(struct ethtool_wol_set_req *req, __u32 size) | |
| { | |
| req->_present.modes = 1; | |
| req->modes._present.size = 1; | |
| req->modes.size = size; | |
| } | |
| static inline void | |
| __ethtool_wol_set_req_set_modes_bits_bit(struct ethtool_wol_set_req *req, | |
| struct ethtool_bitset_bit *bit, | |
| unsigned int n_bit) | |
| { | |
| free(req->modes.bits.bit); | |
| req->modes.bits.bit = bit; | |
| req->modes.bits.n_bit = n_bit; | |
| } | |
| static inline void | |
| ethtool_wol_set_req_set_sopass(struct ethtool_wol_set_req *req, | |
| const void *sopass, size_t len) | |
| { | |
| free(req->sopass); | |
| req->_present.sopass_len = len; | |
| req->sopass = malloc(req->_present.sopass_len); | |
| memcpy(req->sopass, sopass, req->_present.sopass_len); | |
| } | |
| /* | |
| * Set WOL params. | |
| */ | |
| int ethtool_wol_set(struct ynl_sock *ys, struct ethtool_wol_set_req *req); | |
| /* ============== ETHTOOL_MSG_FEATURES_GET ============== */ | |
| /* ETHTOOL_MSG_FEATURES_GET - do */ | |
| struct ethtool_features_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_features_get_req * | |
| ethtool_features_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_features_get_req)); | |
| } | |
| void ethtool_features_get_req_free(struct ethtool_features_get_req *req); | |
| static inline void | |
| ethtool_features_get_req_set_header_dev_index(struct ethtool_features_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_features_get_req_set_header_dev_name(struct ethtool_features_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_features_get_req_set_header_flags(struct ethtool_features_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_features_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 hw:1; | |
| __u32 wanted:1; | |
| __u32 active:1; | |
| __u32 nochange:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_bitset hw; | |
| struct ethtool_bitset wanted; | |
| struct ethtool_bitset active; | |
| struct ethtool_bitset nochange; | |
| }; | |
| void ethtool_features_get_rsp_free(struct ethtool_features_get_rsp *rsp); | |
| /* | |
| * Get features. | |
| */ | |
| struct ethtool_features_get_rsp * | |
| ethtool_features_get(struct ynl_sock *ys, struct ethtool_features_get_req *req); | |
| /* ETHTOOL_MSG_FEATURES_GET - dump */ | |
| struct ethtool_features_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_features_get_req_dump * | |
| ethtool_features_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_features_get_req_dump)); | |
| } | |
| void | |
| ethtool_features_get_req_dump_free(struct ethtool_features_get_req_dump *req); | |
| static inline void | |
| ethtool_features_get_req_dump_set_header_dev_index(struct ethtool_features_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_features_get_req_dump_set_header_dev_name(struct ethtool_features_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_features_get_req_dump_set_header_flags(struct ethtool_features_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_features_get_list { | |
| struct ethtool_features_get_list *next; | |
| struct ethtool_features_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_features_get_list_free(struct ethtool_features_get_list *rsp); | |
| struct ethtool_features_get_list * | |
| ethtool_features_get_dump(struct ynl_sock *ys, | |
| struct ethtool_features_get_req_dump *req); | |
| /* ETHTOOL_MSG_FEATURES_GET - notify */ | |
| struct ethtool_features_get_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_features_get_ntf *ntf); | |
| struct ethtool_features_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_features_get_ntf_free(struct ethtool_features_get_ntf *rsp); | |
| /* ============== ETHTOOL_MSG_FEATURES_SET ============== */ | |
| /* ETHTOOL_MSG_FEATURES_SET - do */ | |
| struct ethtool_features_set_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 hw:1; | |
| __u32 wanted:1; | |
| __u32 active:1; | |
| __u32 nochange:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_bitset hw; | |
| struct ethtool_bitset wanted; | |
| struct ethtool_bitset active; | |
| struct ethtool_bitset nochange; | |
| }; | |
| static inline struct ethtool_features_set_req * | |
| ethtool_features_set_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_features_set_req)); | |
| } | |
| void ethtool_features_set_req_free(struct ethtool_features_set_req *req); | |
| static inline void | |
| ethtool_features_set_req_set_header_dev_index(struct ethtool_features_set_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_features_set_req_set_header_dev_name(struct ethtool_features_set_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_features_set_req_set_header_flags(struct ethtool_features_set_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_features_set_req_set_hw_nomask(struct ethtool_features_set_req *req) | |
| { | |
| req->_present.hw = 1; | |
| req->hw._present.nomask = 1; | |
| } | |
| static inline void | |
| ethtool_features_set_req_set_hw_size(struct ethtool_features_set_req *req, | |
| __u32 size) | |
| { | |
| req->_present.hw = 1; | |
| req->hw._present.size = 1; | |
| req->hw.size = size; | |
| } | |
| static inline void | |
| __ethtool_features_set_req_set_hw_bits_bit(struct ethtool_features_set_req *req, | |
| struct ethtool_bitset_bit *bit, | |
| unsigned int n_bit) | |
| { | |
| free(req->hw.bits.bit); | |
| req->hw.bits.bit = bit; | |
| req->hw.bits.n_bit = n_bit; | |
| } | |
| static inline void | |
| ethtool_features_set_req_set_wanted_nomask(struct ethtool_features_set_req *req) | |
| { | |
| req->_present.wanted = 1; | |
| req->wanted._present.nomask = 1; | |
| } | |
| static inline void | |
| ethtool_features_set_req_set_wanted_size(struct ethtool_features_set_req *req, | |
| __u32 size) | |
| { | |
| req->_present.wanted = 1; | |
| req->wanted._present.size = 1; | |
| req->wanted.size = size; | |
| } | |
| static inline void | |
| __ethtool_features_set_req_set_wanted_bits_bit(struct ethtool_features_set_req *req, | |
| struct ethtool_bitset_bit *bit, | |
| unsigned int n_bit) | |
| { | |
| free(req->wanted.bits.bit); | |
| req->wanted.bits.bit = bit; | |
| req->wanted.bits.n_bit = n_bit; | |
| } | |
| static inline void | |
| ethtool_features_set_req_set_active_nomask(struct ethtool_features_set_req *req) | |
| { | |
| req->_present.active = 1; | |
| req->active._present.nomask = 1; | |
| } | |
| static inline void | |
| ethtool_features_set_req_set_active_size(struct ethtool_features_set_req *req, | |
| __u32 size) | |
| { | |
| req->_present.active = 1; | |
| req->active._present.size = 1; | |
| req->active.size = size; | |
| } | |
| static inline void | |
| __ethtool_features_set_req_set_active_bits_bit(struct ethtool_features_set_req *req, | |
| struct ethtool_bitset_bit *bit, | |
| unsigned int n_bit) | |
| { | |
| free(req->active.bits.bit); | |
| req->active.bits.bit = bit; | |
| req->active.bits.n_bit = n_bit; | |
| } | |
| static inline void | |
| ethtool_features_set_req_set_nochange_nomask(struct ethtool_features_set_req *req) | |
| { | |
| req->_present.nochange = 1; | |
| req->nochange._present.nomask = 1; | |
| } | |
| static inline void | |
| ethtool_features_set_req_set_nochange_size(struct ethtool_features_set_req *req, | |
| __u32 size) | |
| { | |
| req->_present.nochange = 1; | |
| req->nochange._present.size = 1; | |
| req->nochange.size = size; | |
| } | |
| static inline void | |
| __ethtool_features_set_req_set_nochange_bits_bit(struct ethtool_features_set_req *req, | |
| struct ethtool_bitset_bit *bit, | |
| unsigned int n_bit) | |
| { | |
| free(req->nochange.bits.bit); | |
| req->nochange.bits.bit = bit; | |
| req->nochange.bits.n_bit = n_bit; | |
| } | |
| struct ethtool_features_set_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 hw:1; | |
| __u32 wanted:1; | |
| __u32 active:1; | |
| __u32 nochange:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_bitset hw; | |
| struct ethtool_bitset wanted; | |
| struct ethtool_bitset active; | |
| struct ethtool_bitset nochange; | |
| }; | |
| void ethtool_features_set_rsp_free(struct ethtool_features_set_rsp *rsp); | |
| /* | |
| * Set features. | |
| */ | |
| struct ethtool_features_set_rsp * | |
| ethtool_features_set(struct ynl_sock *ys, struct ethtool_features_set_req *req); | |
| /* ============== ETHTOOL_MSG_PRIVFLAGS_GET ============== */ | |
| /* ETHTOOL_MSG_PRIVFLAGS_GET - do */ | |
| struct ethtool_privflags_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_privflags_get_req * | |
| ethtool_privflags_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_privflags_get_req)); | |
| } | |
| void ethtool_privflags_get_req_free(struct ethtool_privflags_get_req *req); | |
| static inline void | |
| ethtool_privflags_get_req_set_header_dev_index(struct ethtool_privflags_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_privflags_get_req_set_header_dev_name(struct ethtool_privflags_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_privflags_get_req_set_header_flags(struct ethtool_privflags_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_privflags_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 flags:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_bitset flags; | |
| }; | |
| void ethtool_privflags_get_rsp_free(struct ethtool_privflags_get_rsp *rsp); | |
| /* | |
| * Get device private flags. | |
| */ | |
| struct ethtool_privflags_get_rsp * | |
| ethtool_privflags_get(struct ynl_sock *ys, | |
| struct ethtool_privflags_get_req *req); | |
| /* ETHTOOL_MSG_PRIVFLAGS_GET - dump */ | |
| struct ethtool_privflags_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_privflags_get_req_dump * | |
| ethtool_privflags_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_privflags_get_req_dump)); | |
| } | |
| void | |
| ethtool_privflags_get_req_dump_free(struct ethtool_privflags_get_req_dump *req); | |
| static inline void | |
| ethtool_privflags_get_req_dump_set_header_dev_index(struct ethtool_privflags_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_privflags_get_req_dump_set_header_dev_name(struct ethtool_privflags_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_privflags_get_req_dump_set_header_flags(struct ethtool_privflags_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_privflags_get_list { | |
| struct ethtool_privflags_get_list *next; | |
| struct ethtool_privflags_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_privflags_get_list_free(struct ethtool_privflags_get_list *rsp); | |
| struct ethtool_privflags_get_list * | |
| ethtool_privflags_get_dump(struct ynl_sock *ys, | |
| struct ethtool_privflags_get_req_dump *req); | |
| /* ETHTOOL_MSG_PRIVFLAGS_GET - notify */ | |
| struct ethtool_privflags_get_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_privflags_get_ntf *ntf); | |
| struct ethtool_privflags_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_privflags_get_ntf_free(struct ethtool_privflags_get_ntf *rsp); | |
| /* ============== ETHTOOL_MSG_PRIVFLAGS_SET ============== */ | |
| /* ETHTOOL_MSG_PRIVFLAGS_SET - do */ | |
| struct ethtool_privflags_set_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 flags:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_bitset flags; | |
| }; | |
| static inline struct ethtool_privflags_set_req * | |
| ethtool_privflags_set_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_privflags_set_req)); | |
| } | |
| void ethtool_privflags_set_req_free(struct ethtool_privflags_set_req *req); | |
| static inline void | |
| ethtool_privflags_set_req_set_header_dev_index(struct ethtool_privflags_set_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_privflags_set_req_set_header_dev_name(struct ethtool_privflags_set_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_privflags_set_req_set_header_flags(struct ethtool_privflags_set_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_privflags_set_req_set_flags_nomask(struct ethtool_privflags_set_req *req) | |
| { | |
| req->_present.flags = 1; | |
| req->flags._present.nomask = 1; | |
| } | |
| static inline void | |
| ethtool_privflags_set_req_set_flags_size(struct ethtool_privflags_set_req *req, | |
| __u32 size) | |
| { | |
| req->_present.flags = 1; | |
| req->flags._present.size = 1; | |
| req->flags.size = size; | |
| } | |
| static inline void | |
| __ethtool_privflags_set_req_set_flags_bits_bit(struct ethtool_privflags_set_req *req, | |
| struct ethtool_bitset_bit *bit, | |
| unsigned int n_bit) | |
| { | |
| free(req->flags.bits.bit); | |
| req->flags.bits.bit = bit; | |
| req->flags.bits.n_bit = n_bit; | |
| } | |
| /* | |
| * Set device private flags. | |
| */ | |
| int ethtool_privflags_set(struct ynl_sock *ys, | |
| struct ethtool_privflags_set_req *req); | |
| /* ============== ETHTOOL_MSG_RINGS_GET ============== */ | |
| /* ETHTOOL_MSG_RINGS_GET - do */ | |
| struct ethtool_rings_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_rings_get_req *ethtool_rings_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_rings_get_req)); | |
| } | |
| void ethtool_rings_get_req_free(struct ethtool_rings_get_req *req); | |
| static inline void | |
| ethtool_rings_get_req_set_header_dev_index(struct ethtool_rings_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_rings_get_req_set_header_dev_name(struct ethtool_rings_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_rings_get_req_set_header_flags(struct ethtool_rings_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_rings_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 rx_max:1; | |
| __u32 rx_mini_max:1; | |
| __u32 rx_jumbo_max:1; | |
| __u32 tx_max:1; | |
| __u32 rx:1; | |
| __u32 rx_mini:1; | |
| __u32 rx_jumbo:1; | |
| __u32 tx:1; | |
| __u32 rx_buf_len:1; | |
| __u32 tcp_data_split:1; | |
| __u32 cqe_size:1; | |
| __u32 tx_push:1; | |
| __u32 rx_push:1; | |
| __u32 tx_push_buf_len:1; | |
| __u32 tx_push_buf_len_max:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u32 rx_max; | |
| __u32 rx_mini_max; | |
| __u32 rx_jumbo_max; | |
| __u32 tx_max; | |
| __u32 rx; | |
| __u32 rx_mini; | |
| __u32 rx_jumbo; | |
| __u32 tx; | |
| __u32 rx_buf_len; | |
| __u8 tcp_data_split; | |
| __u32 cqe_size; | |
| __u8 tx_push; | |
| __u8 rx_push; | |
| __u32 tx_push_buf_len; | |
| __u32 tx_push_buf_len_max; | |
| }; | |
| void ethtool_rings_get_rsp_free(struct ethtool_rings_get_rsp *rsp); | |
| /* | |
| * Get ring params. | |
| */ | |
| struct ethtool_rings_get_rsp * | |
| ethtool_rings_get(struct ynl_sock *ys, struct ethtool_rings_get_req *req); | |
| /* ETHTOOL_MSG_RINGS_GET - dump */ | |
| struct ethtool_rings_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_rings_get_req_dump * | |
| ethtool_rings_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_rings_get_req_dump)); | |
| } | |
| void ethtool_rings_get_req_dump_free(struct ethtool_rings_get_req_dump *req); | |
| static inline void | |
| ethtool_rings_get_req_dump_set_header_dev_index(struct ethtool_rings_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_rings_get_req_dump_set_header_dev_name(struct ethtool_rings_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_rings_get_req_dump_set_header_flags(struct ethtool_rings_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_rings_get_list { | |
| struct ethtool_rings_get_list *next; | |
| struct ethtool_rings_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_rings_get_list_free(struct ethtool_rings_get_list *rsp); | |
| struct ethtool_rings_get_list * | |
| ethtool_rings_get_dump(struct ynl_sock *ys, | |
| struct ethtool_rings_get_req_dump *req); | |
| /* ETHTOOL_MSG_RINGS_GET - notify */ | |
| struct ethtool_rings_get_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_rings_get_ntf *ntf); | |
| struct ethtool_rings_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_rings_get_ntf_free(struct ethtool_rings_get_ntf *rsp); | |
| /* ============== ETHTOOL_MSG_RINGS_SET ============== */ | |
| /* ETHTOOL_MSG_RINGS_SET - do */ | |
| struct ethtool_rings_set_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 rx_max:1; | |
| __u32 rx_mini_max:1; | |
| __u32 rx_jumbo_max:1; | |
| __u32 tx_max:1; | |
| __u32 rx:1; | |
| __u32 rx_mini:1; | |
| __u32 rx_jumbo:1; | |
| __u32 tx:1; | |
| __u32 rx_buf_len:1; | |
| __u32 tcp_data_split:1; | |
| __u32 cqe_size:1; | |
| __u32 tx_push:1; | |
| __u32 rx_push:1; | |
| __u32 tx_push_buf_len:1; | |
| __u32 tx_push_buf_len_max:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u32 rx_max; | |
| __u32 rx_mini_max; | |
| __u32 rx_jumbo_max; | |
| __u32 tx_max; | |
| __u32 rx; | |
| __u32 rx_mini; | |
| __u32 rx_jumbo; | |
| __u32 tx; | |
| __u32 rx_buf_len; | |
| __u8 tcp_data_split; | |
| __u32 cqe_size; | |
| __u8 tx_push; | |
| __u8 rx_push; | |
| __u32 tx_push_buf_len; | |
| __u32 tx_push_buf_len_max; | |
| }; | |
| static inline struct ethtool_rings_set_req *ethtool_rings_set_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_rings_set_req)); | |
| } | |
| void ethtool_rings_set_req_free(struct ethtool_rings_set_req *req); | |
| static inline void | |
| ethtool_rings_set_req_set_header_dev_index(struct ethtool_rings_set_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_header_dev_name(struct ethtool_rings_set_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_header_flags(struct ethtool_rings_set_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_rx_max(struct ethtool_rings_set_req *req, | |
| __u32 rx_max) | |
| { | |
| req->_present.rx_max = 1; | |
| req->rx_max = rx_max; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_rx_mini_max(struct ethtool_rings_set_req *req, | |
| __u32 rx_mini_max) | |
| { | |
| req->_present.rx_mini_max = 1; | |
| req->rx_mini_max = rx_mini_max; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_rx_jumbo_max(struct ethtool_rings_set_req *req, | |
| __u32 rx_jumbo_max) | |
| { | |
| req->_present.rx_jumbo_max = 1; | |
| req->rx_jumbo_max = rx_jumbo_max; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_tx_max(struct ethtool_rings_set_req *req, | |
| __u32 tx_max) | |
| { | |
| req->_present.tx_max = 1; | |
| req->tx_max = tx_max; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_rx(struct ethtool_rings_set_req *req, __u32 rx) | |
| { | |
| req->_present.rx = 1; | |
| req->rx = rx; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_rx_mini(struct ethtool_rings_set_req *req, | |
| __u32 rx_mini) | |
| { | |
| req->_present.rx_mini = 1; | |
| req->rx_mini = rx_mini; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_rx_jumbo(struct ethtool_rings_set_req *req, | |
| __u32 rx_jumbo) | |
| { | |
| req->_present.rx_jumbo = 1; | |
| req->rx_jumbo = rx_jumbo; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_tx(struct ethtool_rings_set_req *req, __u32 tx) | |
| { | |
| req->_present.tx = 1; | |
| req->tx = tx; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_rx_buf_len(struct ethtool_rings_set_req *req, | |
| __u32 rx_buf_len) | |
| { | |
| req->_present.rx_buf_len = 1; | |
| req->rx_buf_len = rx_buf_len; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_tcp_data_split(struct ethtool_rings_set_req *req, | |
| __u8 tcp_data_split) | |
| { | |
| req->_present.tcp_data_split = 1; | |
| req->tcp_data_split = tcp_data_split; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_cqe_size(struct ethtool_rings_set_req *req, | |
| __u32 cqe_size) | |
| { | |
| req->_present.cqe_size = 1; | |
| req->cqe_size = cqe_size; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_tx_push(struct ethtool_rings_set_req *req, | |
| __u8 tx_push) | |
| { | |
| req->_present.tx_push = 1; | |
| req->tx_push = tx_push; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_rx_push(struct ethtool_rings_set_req *req, | |
| __u8 rx_push) | |
| { | |
| req->_present.rx_push = 1; | |
| req->rx_push = rx_push; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_tx_push_buf_len(struct ethtool_rings_set_req *req, | |
| __u32 tx_push_buf_len) | |
| { | |
| req->_present.tx_push_buf_len = 1; | |
| req->tx_push_buf_len = tx_push_buf_len; | |
| } | |
| static inline void | |
| ethtool_rings_set_req_set_tx_push_buf_len_max(struct ethtool_rings_set_req *req, | |
| __u32 tx_push_buf_len_max) | |
| { | |
| req->_present.tx_push_buf_len_max = 1; | |
| req->tx_push_buf_len_max = tx_push_buf_len_max; | |
| } | |
| /* | |
| * Set ring params. | |
| */ | |
| int ethtool_rings_set(struct ynl_sock *ys, struct ethtool_rings_set_req *req); | |
| /* ============== ETHTOOL_MSG_CHANNELS_GET ============== */ | |
| /* ETHTOOL_MSG_CHANNELS_GET - do */ | |
| struct ethtool_channels_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_channels_get_req * | |
| ethtool_channels_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_channels_get_req)); | |
| } | |
| void ethtool_channels_get_req_free(struct ethtool_channels_get_req *req); | |
| static inline void | |
| ethtool_channels_get_req_set_header_dev_index(struct ethtool_channels_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_channels_get_req_set_header_dev_name(struct ethtool_channels_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_channels_get_req_set_header_flags(struct ethtool_channels_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_channels_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 rx_max:1; | |
| __u32 tx_max:1; | |
| __u32 other_max:1; | |
| __u32 combined_max:1; | |
| __u32 rx_count:1; | |
| __u32 tx_count:1; | |
| __u32 other_count:1; | |
| __u32 combined_count:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u32 rx_max; | |
| __u32 tx_max; | |
| __u32 other_max; | |
| __u32 combined_max; | |
| __u32 rx_count; | |
| __u32 tx_count; | |
| __u32 other_count; | |
| __u32 combined_count; | |
| }; | |
| void ethtool_channels_get_rsp_free(struct ethtool_channels_get_rsp *rsp); | |
| /* | |
| * Get channel params. | |
| */ | |
| struct ethtool_channels_get_rsp * | |
| ethtool_channels_get(struct ynl_sock *ys, struct ethtool_channels_get_req *req); | |
| /* ETHTOOL_MSG_CHANNELS_GET - dump */ | |
| struct ethtool_channels_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_channels_get_req_dump * | |
| ethtool_channels_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_channels_get_req_dump)); | |
| } | |
| void | |
| ethtool_channels_get_req_dump_free(struct ethtool_channels_get_req_dump *req); | |
| static inline void | |
| ethtool_channels_get_req_dump_set_header_dev_index(struct ethtool_channels_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_channels_get_req_dump_set_header_dev_name(struct ethtool_channels_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_channels_get_req_dump_set_header_flags(struct ethtool_channels_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_channels_get_list { | |
| struct ethtool_channels_get_list *next; | |
| struct ethtool_channels_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_channels_get_list_free(struct ethtool_channels_get_list *rsp); | |
| struct ethtool_channels_get_list * | |
| ethtool_channels_get_dump(struct ynl_sock *ys, | |
| struct ethtool_channels_get_req_dump *req); | |
| /* ETHTOOL_MSG_CHANNELS_GET - notify */ | |
| struct ethtool_channels_get_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_channels_get_ntf *ntf); | |
| struct ethtool_channels_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_channels_get_ntf_free(struct ethtool_channels_get_ntf *rsp); | |
| /* ============== ETHTOOL_MSG_CHANNELS_SET ============== */ | |
| /* ETHTOOL_MSG_CHANNELS_SET - do */ | |
| struct ethtool_channels_set_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 rx_max:1; | |
| __u32 tx_max:1; | |
| __u32 other_max:1; | |
| __u32 combined_max:1; | |
| __u32 rx_count:1; | |
| __u32 tx_count:1; | |
| __u32 other_count:1; | |
| __u32 combined_count:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u32 rx_max; | |
| __u32 tx_max; | |
| __u32 other_max; | |
| __u32 combined_max; | |
| __u32 rx_count; | |
| __u32 tx_count; | |
| __u32 other_count; | |
| __u32 combined_count; | |
| }; | |
| static inline struct ethtool_channels_set_req * | |
| ethtool_channels_set_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_channels_set_req)); | |
| } | |
| void ethtool_channels_set_req_free(struct ethtool_channels_set_req *req); | |
| static inline void | |
| ethtool_channels_set_req_set_header_dev_index(struct ethtool_channels_set_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_channels_set_req_set_header_dev_name(struct ethtool_channels_set_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_channels_set_req_set_header_flags(struct ethtool_channels_set_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_channels_set_req_set_rx_max(struct ethtool_channels_set_req *req, | |
| __u32 rx_max) | |
| { | |
| req->_present.rx_max = 1; | |
| req->rx_max = rx_max; | |
| } | |
| static inline void | |
| ethtool_channels_set_req_set_tx_max(struct ethtool_channels_set_req *req, | |
| __u32 tx_max) | |
| { | |
| req->_present.tx_max = 1; | |
| req->tx_max = tx_max; | |
| } | |
| static inline void | |
| ethtool_channels_set_req_set_other_max(struct ethtool_channels_set_req *req, | |
| __u32 other_max) | |
| { | |
| req->_present.other_max = 1; | |
| req->other_max = other_max; | |
| } | |
| static inline void | |
| ethtool_channels_set_req_set_combined_max(struct ethtool_channels_set_req *req, | |
| __u32 combined_max) | |
| { | |
| req->_present.combined_max = 1; | |
| req->combined_max = combined_max; | |
| } | |
| static inline void | |
| ethtool_channels_set_req_set_rx_count(struct ethtool_channels_set_req *req, | |
| __u32 rx_count) | |
| { | |
| req->_present.rx_count = 1; | |
| req->rx_count = rx_count; | |
| } | |
| static inline void | |
| ethtool_channels_set_req_set_tx_count(struct ethtool_channels_set_req *req, | |
| __u32 tx_count) | |
| { | |
| req->_present.tx_count = 1; | |
| req->tx_count = tx_count; | |
| } | |
| static inline void | |
| ethtool_channels_set_req_set_other_count(struct ethtool_channels_set_req *req, | |
| __u32 other_count) | |
| { | |
| req->_present.other_count = 1; | |
| req->other_count = other_count; | |
| } | |
| static inline void | |
| ethtool_channels_set_req_set_combined_count(struct ethtool_channels_set_req *req, | |
| __u32 combined_count) | |
| { | |
| req->_present.combined_count = 1; | |
| req->combined_count = combined_count; | |
| } | |
| /* | |
| * Set channel params. | |
| */ | |
| int ethtool_channels_set(struct ynl_sock *ys, | |
| struct ethtool_channels_set_req *req); | |
| /* ============== ETHTOOL_MSG_COALESCE_GET ============== */ | |
| /* ETHTOOL_MSG_COALESCE_GET - do */ | |
| struct ethtool_coalesce_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_coalesce_get_req * | |
| ethtool_coalesce_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_coalesce_get_req)); | |
| } | |
| void ethtool_coalesce_get_req_free(struct ethtool_coalesce_get_req *req); | |
| static inline void | |
| ethtool_coalesce_get_req_set_header_dev_index(struct ethtool_coalesce_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_coalesce_get_req_set_header_dev_name(struct ethtool_coalesce_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_coalesce_get_req_set_header_flags(struct ethtool_coalesce_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_coalesce_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 rx_usecs:1; | |
| __u32 rx_max_frames:1; | |
| __u32 rx_usecs_irq:1; | |
| __u32 rx_max_frames_irq:1; | |
| __u32 tx_usecs:1; | |
| __u32 tx_max_frames:1; | |
| __u32 tx_usecs_irq:1; | |
| __u32 tx_max_frames_irq:1; | |
| __u32 stats_block_usecs:1; | |
| __u32 use_adaptive_rx:1; | |
| __u32 use_adaptive_tx:1; | |
| __u32 pkt_rate_low:1; | |
| __u32 rx_usecs_low:1; | |
| __u32 rx_max_frames_low:1; | |
| __u32 tx_usecs_low:1; | |
| __u32 tx_max_frames_low:1; | |
| __u32 pkt_rate_high:1; | |
| __u32 rx_usecs_high:1; | |
| __u32 rx_max_frames_high:1; | |
| __u32 tx_usecs_high:1; | |
| __u32 tx_max_frames_high:1; | |
| __u32 rate_sample_interval:1; | |
| __u32 use_cqe_mode_tx:1; | |
| __u32 use_cqe_mode_rx:1; | |
| __u32 tx_aggr_max_bytes:1; | |
| __u32 tx_aggr_max_frames:1; | |
| __u32 tx_aggr_time_usecs:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u32 rx_usecs; | |
| __u32 rx_max_frames; | |
| __u32 rx_usecs_irq; | |
| __u32 rx_max_frames_irq; | |
| __u32 tx_usecs; | |
| __u32 tx_max_frames; | |
| __u32 tx_usecs_irq; | |
| __u32 tx_max_frames_irq; | |
| __u32 stats_block_usecs; | |
| __u8 use_adaptive_rx; | |
| __u8 use_adaptive_tx; | |
| __u32 pkt_rate_low; | |
| __u32 rx_usecs_low; | |
| __u32 rx_max_frames_low; | |
| __u32 tx_usecs_low; | |
| __u32 tx_max_frames_low; | |
| __u32 pkt_rate_high; | |
| __u32 rx_usecs_high; | |
| __u32 rx_max_frames_high; | |
| __u32 tx_usecs_high; | |
| __u32 tx_max_frames_high; | |
| __u32 rate_sample_interval; | |
| __u8 use_cqe_mode_tx; | |
| __u8 use_cqe_mode_rx; | |
| __u32 tx_aggr_max_bytes; | |
| __u32 tx_aggr_max_frames; | |
| __u32 tx_aggr_time_usecs; | |
| }; | |
| void ethtool_coalesce_get_rsp_free(struct ethtool_coalesce_get_rsp *rsp); | |
| /* | |
| * Get coalesce params. | |
| */ | |
| struct ethtool_coalesce_get_rsp * | |
| ethtool_coalesce_get(struct ynl_sock *ys, struct ethtool_coalesce_get_req *req); | |
| /* ETHTOOL_MSG_COALESCE_GET - dump */ | |
| struct ethtool_coalesce_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_coalesce_get_req_dump * | |
| ethtool_coalesce_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_coalesce_get_req_dump)); | |
| } | |
| void | |
| ethtool_coalesce_get_req_dump_free(struct ethtool_coalesce_get_req_dump *req); | |
| static inline void | |
| ethtool_coalesce_get_req_dump_set_header_dev_index(struct ethtool_coalesce_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_coalesce_get_req_dump_set_header_dev_name(struct ethtool_coalesce_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_coalesce_get_req_dump_set_header_flags(struct ethtool_coalesce_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_coalesce_get_list { | |
| struct ethtool_coalesce_get_list *next; | |
| struct ethtool_coalesce_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_coalesce_get_list_free(struct ethtool_coalesce_get_list *rsp); | |
| struct ethtool_coalesce_get_list * | |
| ethtool_coalesce_get_dump(struct ynl_sock *ys, | |
| struct ethtool_coalesce_get_req_dump *req); | |
| /* ETHTOOL_MSG_COALESCE_GET - notify */ | |
| struct ethtool_coalesce_get_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_coalesce_get_ntf *ntf); | |
| struct ethtool_coalesce_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_coalesce_get_ntf_free(struct ethtool_coalesce_get_ntf *rsp); | |
| /* ============== ETHTOOL_MSG_COALESCE_SET ============== */ | |
| /* ETHTOOL_MSG_COALESCE_SET - do */ | |
| struct ethtool_coalesce_set_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 rx_usecs:1; | |
| __u32 rx_max_frames:1; | |
| __u32 rx_usecs_irq:1; | |
| __u32 rx_max_frames_irq:1; | |
| __u32 tx_usecs:1; | |
| __u32 tx_max_frames:1; | |
| __u32 tx_usecs_irq:1; | |
| __u32 tx_max_frames_irq:1; | |
| __u32 stats_block_usecs:1; | |
| __u32 use_adaptive_rx:1; | |
| __u32 use_adaptive_tx:1; | |
| __u32 pkt_rate_low:1; | |
| __u32 rx_usecs_low:1; | |
| __u32 rx_max_frames_low:1; | |
| __u32 tx_usecs_low:1; | |
| __u32 tx_max_frames_low:1; | |
| __u32 pkt_rate_high:1; | |
| __u32 rx_usecs_high:1; | |
| __u32 rx_max_frames_high:1; | |
| __u32 tx_usecs_high:1; | |
| __u32 tx_max_frames_high:1; | |
| __u32 rate_sample_interval:1; | |
| __u32 use_cqe_mode_tx:1; | |
| __u32 use_cqe_mode_rx:1; | |
| __u32 tx_aggr_max_bytes:1; | |
| __u32 tx_aggr_max_frames:1; | |
| __u32 tx_aggr_time_usecs:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u32 rx_usecs; | |
| __u32 rx_max_frames; | |
| __u32 rx_usecs_irq; | |
| __u32 rx_max_frames_irq; | |
| __u32 tx_usecs; | |
| __u32 tx_max_frames; | |
| __u32 tx_usecs_irq; | |
| __u32 tx_max_frames_irq; | |
| __u32 stats_block_usecs; | |
| __u8 use_adaptive_rx; | |
| __u8 use_adaptive_tx; | |
| __u32 pkt_rate_low; | |
| __u32 rx_usecs_low; | |
| __u32 rx_max_frames_low; | |
| __u32 tx_usecs_low; | |
| __u32 tx_max_frames_low; | |
| __u32 pkt_rate_high; | |
| __u32 rx_usecs_high; | |
| __u32 rx_max_frames_high; | |
| __u32 tx_usecs_high; | |
| __u32 tx_max_frames_high; | |
| __u32 rate_sample_interval; | |
| __u8 use_cqe_mode_tx; | |
| __u8 use_cqe_mode_rx; | |
| __u32 tx_aggr_max_bytes; | |
| __u32 tx_aggr_max_frames; | |
| __u32 tx_aggr_time_usecs; | |
| }; | |
| static inline struct ethtool_coalesce_set_req * | |
| ethtool_coalesce_set_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_coalesce_set_req)); | |
| } | |
| void ethtool_coalesce_set_req_free(struct ethtool_coalesce_set_req *req); | |
| static inline void | |
| ethtool_coalesce_set_req_set_header_dev_index(struct ethtool_coalesce_set_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_header_dev_name(struct ethtool_coalesce_set_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_header_flags(struct ethtool_coalesce_set_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_rx_usecs(struct ethtool_coalesce_set_req *req, | |
| __u32 rx_usecs) | |
| { | |
| req->_present.rx_usecs = 1; | |
| req->rx_usecs = rx_usecs; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_rx_max_frames(struct ethtool_coalesce_set_req *req, | |
| __u32 rx_max_frames) | |
| { | |
| req->_present.rx_max_frames = 1; | |
| req->rx_max_frames = rx_max_frames; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_rx_usecs_irq(struct ethtool_coalesce_set_req *req, | |
| __u32 rx_usecs_irq) | |
| { | |
| req->_present.rx_usecs_irq = 1; | |
| req->rx_usecs_irq = rx_usecs_irq; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_rx_max_frames_irq(struct ethtool_coalesce_set_req *req, | |
| __u32 rx_max_frames_irq) | |
| { | |
| req->_present.rx_max_frames_irq = 1; | |
| req->rx_max_frames_irq = rx_max_frames_irq; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_tx_usecs(struct ethtool_coalesce_set_req *req, | |
| __u32 tx_usecs) | |
| { | |
| req->_present.tx_usecs = 1; | |
| req->tx_usecs = tx_usecs; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_tx_max_frames(struct ethtool_coalesce_set_req *req, | |
| __u32 tx_max_frames) | |
| { | |
| req->_present.tx_max_frames = 1; | |
| req->tx_max_frames = tx_max_frames; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_tx_usecs_irq(struct ethtool_coalesce_set_req *req, | |
| __u32 tx_usecs_irq) | |
| { | |
| req->_present.tx_usecs_irq = 1; | |
| req->tx_usecs_irq = tx_usecs_irq; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_tx_max_frames_irq(struct ethtool_coalesce_set_req *req, | |
| __u32 tx_max_frames_irq) | |
| { | |
| req->_present.tx_max_frames_irq = 1; | |
| req->tx_max_frames_irq = tx_max_frames_irq; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_stats_block_usecs(struct ethtool_coalesce_set_req *req, | |
| __u32 stats_block_usecs) | |
| { | |
| req->_present.stats_block_usecs = 1; | |
| req->stats_block_usecs = stats_block_usecs; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_use_adaptive_rx(struct ethtool_coalesce_set_req *req, | |
| __u8 use_adaptive_rx) | |
| { | |
| req->_present.use_adaptive_rx = 1; | |
| req->use_adaptive_rx = use_adaptive_rx; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_use_adaptive_tx(struct ethtool_coalesce_set_req *req, | |
| __u8 use_adaptive_tx) | |
| { | |
| req->_present.use_adaptive_tx = 1; | |
| req->use_adaptive_tx = use_adaptive_tx; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_pkt_rate_low(struct ethtool_coalesce_set_req *req, | |
| __u32 pkt_rate_low) | |
| { | |
| req->_present.pkt_rate_low = 1; | |
| req->pkt_rate_low = pkt_rate_low; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_rx_usecs_low(struct ethtool_coalesce_set_req *req, | |
| __u32 rx_usecs_low) | |
| { | |
| req->_present.rx_usecs_low = 1; | |
| req->rx_usecs_low = rx_usecs_low; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_rx_max_frames_low(struct ethtool_coalesce_set_req *req, | |
| __u32 rx_max_frames_low) | |
| { | |
| req->_present.rx_max_frames_low = 1; | |
| req->rx_max_frames_low = rx_max_frames_low; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_tx_usecs_low(struct ethtool_coalesce_set_req *req, | |
| __u32 tx_usecs_low) | |
| { | |
| req->_present.tx_usecs_low = 1; | |
| req->tx_usecs_low = tx_usecs_low; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_tx_max_frames_low(struct ethtool_coalesce_set_req *req, | |
| __u32 tx_max_frames_low) | |
| { | |
| req->_present.tx_max_frames_low = 1; | |
| req->tx_max_frames_low = tx_max_frames_low; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_pkt_rate_high(struct ethtool_coalesce_set_req *req, | |
| __u32 pkt_rate_high) | |
| { | |
| req->_present.pkt_rate_high = 1; | |
| req->pkt_rate_high = pkt_rate_high; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_rx_usecs_high(struct ethtool_coalesce_set_req *req, | |
| __u32 rx_usecs_high) | |
| { | |
| req->_present.rx_usecs_high = 1; | |
| req->rx_usecs_high = rx_usecs_high; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_rx_max_frames_high(struct ethtool_coalesce_set_req *req, | |
| __u32 rx_max_frames_high) | |
| { | |
| req->_present.rx_max_frames_high = 1; | |
| req->rx_max_frames_high = rx_max_frames_high; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_tx_usecs_high(struct ethtool_coalesce_set_req *req, | |
| __u32 tx_usecs_high) | |
| { | |
| req->_present.tx_usecs_high = 1; | |
| req->tx_usecs_high = tx_usecs_high; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_tx_max_frames_high(struct ethtool_coalesce_set_req *req, | |
| __u32 tx_max_frames_high) | |
| { | |
| req->_present.tx_max_frames_high = 1; | |
| req->tx_max_frames_high = tx_max_frames_high; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_rate_sample_interval(struct ethtool_coalesce_set_req *req, | |
| __u32 rate_sample_interval) | |
| { | |
| req->_present.rate_sample_interval = 1; | |
| req->rate_sample_interval = rate_sample_interval; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_use_cqe_mode_tx(struct ethtool_coalesce_set_req *req, | |
| __u8 use_cqe_mode_tx) | |
| { | |
| req->_present.use_cqe_mode_tx = 1; | |
| req->use_cqe_mode_tx = use_cqe_mode_tx; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_use_cqe_mode_rx(struct ethtool_coalesce_set_req *req, | |
| __u8 use_cqe_mode_rx) | |
| { | |
| req->_present.use_cqe_mode_rx = 1; | |
| req->use_cqe_mode_rx = use_cqe_mode_rx; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_tx_aggr_max_bytes(struct ethtool_coalesce_set_req *req, | |
| __u32 tx_aggr_max_bytes) | |
| { | |
| req->_present.tx_aggr_max_bytes = 1; | |
| req->tx_aggr_max_bytes = tx_aggr_max_bytes; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_tx_aggr_max_frames(struct ethtool_coalesce_set_req *req, | |
| __u32 tx_aggr_max_frames) | |
| { | |
| req->_present.tx_aggr_max_frames = 1; | |
| req->tx_aggr_max_frames = tx_aggr_max_frames; | |
| } | |
| static inline void | |
| ethtool_coalesce_set_req_set_tx_aggr_time_usecs(struct ethtool_coalesce_set_req *req, | |
| __u32 tx_aggr_time_usecs) | |
| { | |
| req->_present.tx_aggr_time_usecs = 1; | |
| req->tx_aggr_time_usecs = tx_aggr_time_usecs; | |
| } | |
| /* | |
| * Set coalesce params. | |
| */ | |
| int ethtool_coalesce_set(struct ynl_sock *ys, | |
| struct ethtool_coalesce_set_req *req); | |
| /* ============== ETHTOOL_MSG_PAUSE_GET ============== */ | |
| /* ETHTOOL_MSG_PAUSE_GET - do */ | |
| struct ethtool_pause_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_pause_get_req *ethtool_pause_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_pause_get_req)); | |
| } | |
| void ethtool_pause_get_req_free(struct ethtool_pause_get_req *req); | |
| static inline void | |
| ethtool_pause_get_req_set_header_dev_index(struct ethtool_pause_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_pause_get_req_set_header_dev_name(struct ethtool_pause_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_pause_get_req_set_header_flags(struct ethtool_pause_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_pause_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 autoneg:1; | |
| __u32 rx:1; | |
| __u32 tx:1; | |
| __u32 stats:1; | |
| __u32 stats_src:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u8 autoneg; | |
| __u8 rx; | |
| __u8 tx; | |
| struct ethtool_pause_stat stats; | |
| __u32 stats_src; | |
| }; | |
| void ethtool_pause_get_rsp_free(struct ethtool_pause_get_rsp *rsp); | |
| /* | |
| * Get pause params. | |
| */ | |
| struct ethtool_pause_get_rsp * | |
| ethtool_pause_get(struct ynl_sock *ys, struct ethtool_pause_get_req *req); | |
| /* ETHTOOL_MSG_PAUSE_GET - dump */ | |
| struct ethtool_pause_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_pause_get_req_dump * | |
| ethtool_pause_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_pause_get_req_dump)); | |
| } | |
| void ethtool_pause_get_req_dump_free(struct ethtool_pause_get_req_dump *req); | |
| static inline void | |
| ethtool_pause_get_req_dump_set_header_dev_index(struct ethtool_pause_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_pause_get_req_dump_set_header_dev_name(struct ethtool_pause_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_pause_get_req_dump_set_header_flags(struct ethtool_pause_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_pause_get_list { | |
| struct ethtool_pause_get_list *next; | |
| struct ethtool_pause_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_pause_get_list_free(struct ethtool_pause_get_list *rsp); | |
| struct ethtool_pause_get_list * | |
| ethtool_pause_get_dump(struct ynl_sock *ys, | |
| struct ethtool_pause_get_req_dump *req); | |
| /* ETHTOOL_MSG_PAUSE_GET - notify */ | |
| struct ethtool_pause_get_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_pause_get_ntf *ntf); | |
| struct ethtool_pause_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_pause_get_ntf_free(struct ethtool_pause_get_ntf *rsp); | |
| /* ============== ETHTOOL_MSG_PAUSE_SET ============== */ | |
| /* ETHTOOL_MSG_PAUSE_SET - do */ | |
| struct ethtool_pause_set_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 autoneg:1; | |
| __u32 rx:1; | |
| __u32 tx:1; | |
| __u32 stats:1; | |
| __u32 stats_src:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u8 autoneg; | |
| __u8 rx; | |
| __u8 tx; | |
| struct ethtool_pause_stat stats; | |
| __u32 stats_src; | |
| }; | |
| static inline struct ethtool_pause_set_req *ethtool_pause_set_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_pause_set_req)); | |
| } | |
| void ethtool_pause_set_req_free(struct ethtool_pause_set_req *req); | |
| static inline void | |
| ethtool_pause_set_req_set_header_dev_index(struct ethtool_pause_set_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_pause_set_req_set_header_dev_name(struct ethtool_pause_set_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_pause_set_req_set_header_flags(struct ethtool_pause_set_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_pause_set_req_set_autoneg(struct ethtool_pause_set_req *req, | |
| __u8 autoneg) | |
| { | |
| req->_present.autoneg = 1; | |
| req->autoneg = autoneg; | |
| } | |
| static inline void | |
| ethtool_pause_set_req_set_rx(struct ethtool_pause_set_req *req, __u8 rx) | |
| { | |
| req->_present.rx = 1; | |
| req->rx = rx; | |
| } | |
| static inline void | |
| ethtool_pause_set_req_set_tx(struct ethtool_pause_set_req *req, __u8 tx) | |
| { | |
| req->_present.tx = 1; | |
| req->tx = tx; | |
| } | |
| static inline void | |
| ethtool_pause_set_req_set_stats_tx_frames(struct ethtool_pause_set_req *req, | |
| __u64 tx_frames) | |
| { | |
| req->_present.stats = 1; | |
| req->stats._present.tx_frames = 1; | |
| req->stats.tx_frames = tx_frames; | |
| } | |
| static inline void | |
| ethtool_pause_set_req_set_stats_rx_frames(struct ethtool_pause_set_req *req, | |
| __u64 rx_frames) | |
| { | |
| req->_present.stats = 1; | |
| req->stats._present.rx_frames = 1; | |
| req->stats.rx_frames = rx_frames; | |
| } | |
| static inline void | |
| ethtool_pause_set_req_set_stats_src(struct ethtool_pause_set_req *req, | |
| __u32 stats_src) | |
| { | |
| req->_present.stats_src = 1; | |
| req->stats_src = stats_src; | |
| } | |
| /* | |
| * Set pause params. | |
| */ | |
| int ethtool_pause_set(struct ynl_sock *ys, struct ethtool_pause_set_req *req); | |
| /* ============== ETHTOOL_MSG_EEE_GET ============== */ | |
| /* ETHTOOL_MSG_EEE_GET - do */ | |
| struct ethtool_eee_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_eee_get_req *ethtool_eee_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_eee_get_req)); | |
| } | |
| void ethtool_eee_get_req_free(struct ethtool_eee_get_req *req); | |
| static inline void | |
| ethtool_eee_get_req_set_header_dev_index(struct ethtool_eee_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_eee_get_req_set_header_dev_name(struct ethtool_eee_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_eee_get_req_set_header_flags(struct ethtool_eee_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_eee_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 modes_ours:1; | |
| __u32 modes_peer:1; | |
| __u32 active:1; | |
| __u32 enabled:1; | |
| __u32 tx_lpi_enabled:1; | |
| __u32 tx_lpi_timer:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_bitset modes_ours; | |
| struct ethtool_bitset modes_peer; | |
| __u8 active; | |
| __u8 enabled; | |
| __u8 tx_lpi_enabled; | |
| __u32 tx_lpi_timer; | |
| }; | |
| void ethtool_eee_get_rsp_free(struct ethtool_eee_get_rsp *rsp); | |
| /* | |
| * Get eee params. | |
| */ | |
| struct ethtool_eee_get_rsp * | |
| ethtool_eee_get(struct ynl_sock *ys, struct ethtool_eee_get_req *req); | |
| /* ETHTOOL_MSG_EEE_GET - dump */ | |
| struct ethtool_eee_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_eee_get_req_dump * | |
| ethtool_eee_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_eee_get_req_dump)); | |
| } | |
| void ethtool_eee_get_req_dump_free(struct ethtool_eee_get_req_dump *req); | |
| static inline void | |
| ethtool_eee_get_req_dump_set_header_dev_index(struct ethtool_eee_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_eee_get_req_dump_set_header_dev_name(struct ethtool_eee_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_eee_get_req_dump_set_header_flags(struct ethtool_eee_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_eee_get_list { | |
| struct ethtool_eee_get_list *next; | |
| struct ethtool_eee_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_eee_get_list_free(struct ethtool_eee_get_list *rsp); | |
| struct ethtool_eee_get_list * | |
| ethtool_eee_get_dump(struct ynl_sock *ys, struct ethtool_eee_get_req_dump *req); | |
| /* ETHTOOL_MSG_EEE_GET - notify */ | |
| struct ethtool_eee_get_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_eee_get_ntf *ntf); | |
| struct ethtool_eee_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_eee_get_ntf_free(struct ethtool_eee_get_ntf *rsp); | |
| /* ============== ETHTOOL_MSG_EEE_SET ============== */ | |
| /* ETHTOOL_MSG_EEE_SET - do */ | |
| struct ethtool_eee_set_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 modes_ours:1; | |
| __u32 modes_peer:1; | |
| __u32 active:1; | |
| __u32 enabled:1; | |
| __u32 tx_lpi_enabled:1; | |
| __u32 tx_lpi_timer:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_bitset modes_ours; | |
| struct ethtool_bitset modes_peer; | |
| __u8 active; | |
| __u8 enabled; | |
| __u8 tx_lpi_enabled; | |
| __u32 tx_lpi_timer; | |
| }; | |
| static inline struct ethtool_eee_set_req *ethtool_eee_set_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_eee_set_req)); | |
| } | |
| void ethtool_eee_set_req_free(struct ethtool_eee_set_req *req); | |
| static inline void | |
| ethtool_eee_set_req_set_header_dev_index(struct ethtool_eee_set_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_eee_set_req_set_header_dev_name(struct ethtool_eee_set_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_eee_set_req_set_header_flags(struct ethtool_eee_set_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_eee_set_req_set_modes_ours_nomask(struct ethtool_eee_set_req *req) | |
| { | |
| req->_present.modes_ours = 1; | |
| req->modes_ours._present.nomask = 1; | |
| } | |
| static inline void | |
| ethtool_eee_set_req_set_modes_ours_size(struct ethtool_eee_set_req *req, | |
| __u32 size) | |
| { | |
| req->_present.modes_ours = 1; | |
| req->modes_ours._present.size = 1; | |
| req->modes_ours.size = size; | |
| } | |
| static inline void | |
| __ethtool_eee_set_req_set_modes_ours_bits_bit(struct ethtool_eee_set_req *req, | |
| struct ethtool_bitset_bit *bit, | |
| unsigned int n_bit) | |
| { | |
| free(req->modes_ours.bits.bit); | |
| req->modes_ours.bits.bit = bit; | |
| req->modes_ours.bits.n_bit = n_bit; | |
| } | |
| static inline void | |
| ethtool_eee_set_req_set_modes_peer_nomask(struct ethtool_eee_set_req *req) | |
| { | |
| req->_present.modes_peer = 1; | |
| req->modes_peer._present.nomask = 1; | |
| } | |
| static inline void | |
| ethtool_eee_set_req_set_modes_peer_size(struct ethtool_eee_set_req *req, | |
| __u32 size) | |
| { | |
| req->_present.modes_peer = 1; | |
| req->modes_peer._present.size = 1; | |
| req->modes_peer.size = size; | |
| } | |
| static inline void | |
| __ethtool_eee_set_req_set_modes_peer_bits_bit(struct ethtool_eee_set_req *req, | |
| struct ethtool_bitset_bit *bit, | |
| unsigned int n_bit) | |
| { | |
| free(req->modes_peer.bits.bit); | |
| req->modes_peer.bits.bit = bit; | |
| req->modes_peer.bits.n_bit = n_bit; | |
| } | |
| static inline void | |
| ethtool_eee_set_req_set_active(struct ethtool_eee_set_req *req, __u8 active) | |
| { | |
| req->_present.active = 1; | |
| req->active = active; | |
| } | |
| static inline void | |
| ethtool_eee_set_req_set_enabled(struct ethtool_eee_set_req *req, __u8 enabled) | |
| { | |
| req->_present.enabled = 1; | |
| req->enabled = enabled; | |
| } | |
| static inline void | |
| ethtool_eee_set_req_set_tx_lpi_enabled(struct ethtool_eee_set_req *req, | |
| __u8 tx_lpi_enabled) | |
| { | |
| req->_present.tx_lpi_enabled = 1; | |
| req->tx_lpi_enabled = tx_lpi_enabled; | |
| } | |
| static inline void | |
| ethtool_eee_set_req_set_tx_lpi_timer(struct ethtool_eee_set_req *req, | |
| __u32 tx_lpi_timer) | |
| { | |
| req->_present.tx_lpi_timer = 1; | |
| req->tx_lpi_timer = tx_lpi_timer; | |
| } | |
| /* | |
| * Set eee params. | |
| */ | |
| int ethtool_eee_set(struct ynl_sock *ys, struct ethtool_eee_set_req *req); | |
| /* ============== ETHTOOL_MSG_TSINFO_GET ============== */ | |
| /* ETHTOOL_MSG_TSINFO_GET - do */ | |
| struct ethtool_tsinfo_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_tsinfo_get_req *ethtool_tsinfo_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_tsinfo_get_req)); | |
| } | |
| void ethtool_tsinfo_get_req_free(struct ethtool_tsinfo_get_req *req); | |
| static inline void | |
| ethtool_tsinfo_get_req_set_header_dev_index(struct ethtool_tsinfo_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_tsinfo_get_req_set_header_dev_name(struct ethtool_tsinfo_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_tsinfo_get_req_set_header_flags(struct ethtool_tsinfo_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_tsinfo_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 timestamping:1; | |
| __u32 tx_types:1; | |
| __u32 rx_filters:1; | |
| __u32 phc_index:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_bitset timestamping; | |
| struct ethtool_bitset tx_types; | |
| struct ethtool_bitset rx_filters; | |
| __u32 phc_index; | |
| }; | |
| void ethtool_tsinfo_get_rsp_free(struct ethtool_tsinfo_get_rsp *rsp); | |
| /* | |
| * Get tsinfo params. | |
| */ | |
| struct ethtool_tsinfo_get_rsp * | |
| ethtool_tsinfo_get(struct ynl_sock *ys, struct ethtool_tsinfo_get_req *req); | |
| /* ETHTOOL_MSG_TSINFO_GET - dump */ | |
| struct ethtool_tsinfo_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_tsinfo_get_req_dump * | |
| ethtool_tsinfo_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_tsinfo_get_req_dump)); | |
| } | |
| void ethtool_tsinfo_get_req_dump_free(struct ethtool_tsinfo_get_req_dump *req); | |
| static inline void | |
| ethtool_tsinfo_get_req_dump_set_header_dev_index(struct ethtool_tsinfo_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_tsinfo_get_req_dump_set_header_dev_name(struct ethtool_tsinfo_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_tsinfo_get_req_dump_set_header_flags(struct ethtool_tsinfo_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_tsinfo_get_list { | |
| struct ethtool_tsinfo_get_list *next; | |
| struct ethtool_tsinfo_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_tsinfo_get_list_free(struct ethtool_tsinfo_get_list *rsp); | |
| struct ethtool_tsinfo_get_list * | |
| ethtool_tsinfo_get_dump(struct ynl_sock *ys, | |
| struct ethtool_tsinfo_get_req_dump *req); | |
| /* ============== ETHTOOL_MSG_CABLE_TEST_ACT ============== */ | |
| /* ETHTOOL_MSG_CABLE_TEST_ACT - do */ | |
| struct ethtool_cable_test_act_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_cable_test_act_req * | |
| ethtool_cable_test_act_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_cable_test_act_req)); | |
| } | |
| void ethtool_cable_test_act_req_free(struct ethtool_cable_test_act_req *req); | |
| static inline void | |
| ethtool_cable_test_act_req_set_header_dev_index(struct ethtool_cable_test_act_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_cable_test_act_req_set_header_dev_name(struct ethtool_cable_test_act_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_cable_test_act_req_set_header_flags(struct ethtool_cable_test_act_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| /* | |
| * Cable test. | |
| */ | |
| int ethtool_cable_test_act(struct ynl_sock *ys, | |
| struct ethtool_cable_test_act_req *req); | |
| /* ============== ETHTOOL_MSG_CABLE_TEST_TDR_ACT ============== */ | |
| /* ETHTOOL_MSG_CABLE_TEST_TDR_ACT - do */ | |
| struct ethtool_cable_test_tdr_act_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_cable_test_tdr_act_req * | |
| ethtool_cable_test_tdr_act_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_cable_test_tdr_act_req)); | |
| } | |
| void | |
| ethtool_cable_test_tdr_act_req_free(struct ethtool_cable_test_tdr_act_req *req); | |
| static inline void | |
| ethtool_cable_test_tdr_act_req_set_header_dev_index(struct ethtool_cable_test_tdr_act_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_cable_test_tdr_act_req_set_header_dev_name(struct ethtool_cable_test_tdr_act_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_cable_test_tdr_act_req_set_header_flags(struct ethtool_cable_test_tdr_act_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| /* | |
| * Cable test TDR. | |
| */ | |
| int ethtool_cable_test_tdr_act(struct ynl_sock *ys, | |
| struct ethtool_cable_test_tdr_act_req *req); | |
| /* ============== ETHTOOL_MSG_TUNNEL_INFO_GET ============== */ | |
| /* ETHTOOL_MSG_TUNNEL_INFO_GET - do */ | |
| struct ethtool_tunnel_info_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_tunnel_info_get_req * | |
| ethtool_tunnel_info_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_tunnel_info_get_req)); | |
| } | |
| void ethtool_tunnel_info_get_req_free(struct ethtool_tunnel_info_get_req *req); | |
| static inline void | |
| ethtool_tunnel_info_get_req_set_header_dev_index(struct ethtool_tunnel_info_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_tunnel_info_get_req_set_header_dev_name(struct ethtool_tunnel_info_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_tunnel_info_get_req_set_header_flags(struct ethtool_tunnel_info_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_tunnel_info_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 udp_ports:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_tunnel_udp udp_ports; | |
| }; | |
| void ethtool_tunnel_info_get_rsp_free(struct ethtool_tunnel_info_get_rsp *rsp); | |
| /* | |
| * Get tsinfo params. | |
| */ | |
| struct ethtool_tunnel_info_get_rsp * | |
| ethtool_tunnel_info_get(struct ynl_sock *ys, | |
| struct ethtool_tunnel_info_get_req *req); | |
| /* ETHTOOL_MSG_TUNNEL_INFO_GET - dump */ | |
| struct ethtool_tunnel_info_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_tunnel_info_get_req_dump * | |
| ethtool_tunnel_info_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_tunnel_info_get_req_dump)); | |
| } | |
| void | |
| ethtool_tunnel_info_get_req_dump_free(struct ethtool_tunnel_info_get_req_dump *req); | |
| static inline void | |
| ethtool_tunnel_info_get_req_dump_set_header_dev_index(struct ethtool_tunnel_info_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_tunnel_info_get_req_dump_set_header_dev_name(struct ethtool_tunnel_info_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_tunnel_info_get_req_dump_set_header_flags(struct ethtool_tunnel_info_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_tunnel_info_get_list { | |
| struct ethtool_tunnel_info_get_list *next; | |
| struct ethtool_tunnel_info_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void | |
| ethtool_tunnel_info_get_list_free(struct ethtool_tunnel_info_get_list *rsp); | |
| struct ethtool_tunnel_info_get_list * | |
| ethtool_tunnel_info_get_dump(struct ynl_sock *ys, | |
| struct ethtool_tunnel_info_get_req_dump *req); | |
| /* ============== ETHTOOL_MSG_FEC_GET ============== */ | |
| /* ETHTOOL_MSG_FEC_GET - do */ | |
| struct ethtool_fec_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_fec_get_req *ethtool_fec_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_fec_get_req)); | |
| } | |
| void ethtool_fec_get_req_free(struct ethtool_fec_get_req *req); | |
| static inline void | |
| ethtool_fec_get_req_set_header_dev_index(struct ethtool_fec_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_fec_get_req_set_header_dev_name(struct ethtool_fec_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_fec_get_req_set_header_flags(struct ethtool_fec_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_fec_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 modes:1; | |
| __u32 auto_:1; | |
| __u32 active:1; | |
| __u32 stats:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_bitset modes; | |
| __u8 auto_; | |
| __u32 active; | |
| struct ethtool_fec_stat stats; | |
| }; | |
| void ethtool_fec_get_rsp_free(struct ethtool_fec_get_rsp *rsp); | |
| /* | |
| * Get FEC params. | |
| */ | |
| struct ethtool_fec_get_rsp * | |
| ethtool_fec_get(struct ynl_sock *ys, struct ethtool_fec_get_req *req); | |
| /* ETHTOOL_MSG_FEC_GET - dump */ | |
| struct ethtool_fec_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_fec_get_req_dump * | |
| ethtool_fec_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_fec_get_req_dump)); | |
| } | |
| void ethtool_fec_get_req_dump_free(struct ethtool_fec_get_req_dump *req); | |
| static inline void | |
| ethtool_fec_get_req_dump_set_header_dev_index(struct ethtool_fec_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_fec_get_req_dump_set_header_dev_name(struct ethtool_fec_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_fec_get_req_dump_set_header_flags(struct ethtool_fec_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_fec_get_list { | |
| struct ethtool_fec_get_list *next; | |
| struct ethtool_fec_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_fec_get_list_free(struct ethtool_fec_get_list *rsp); | |
| struct ethtool_fec_get_list * | |
| ethtool_fec_get_dump(struct ynl_sock *ys, struct ethtool_fec_get_req_dump *req); | |
| /* ETHTOOL_MSG_FEC_GET - notify */ | |
| struct ethtool_fec_get_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_fec_get_ntf *ntf); | |
| struct ethtool_fec_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_fec_get_ntf_free(struct ethtool_fec_get_ntf *rsp); | |
| /* ============== ETHTOOL_MSG_FEC_SET ============== */ | |
| /* ETHTOOL_MSG_FEC_SET - do */ | |
| struct ethtool_fec_set_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 modes:1; | |
| __u32 auto_:1; | |
| __u32 active:1; | |
| __u32 stats:1; | |
| } _present; | |
| struct ethtool_header header; | |
| struct ethtool_bitset modes; | |
| __u8 auto_; | |
| __u32 active; | |
| struct ethtool_fec_stat stats; | |
| }; | |
| static inline struct ethtool_fec_set_req *ethtool_fec_set_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_fec_set_req)); | |
| } | |
| void ethtool_fec_set_req_free(struct ethtool_fec_set_req *req); | |
| static inline void | |
| ethtool_fec_set_req_set_header_dev_index(struct ethtool_fec_set_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_fec_set_req_set_header_dev_name(struct ethtool_fec_set_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_fec_set_req_set_header_flags(struct ethtool_fec_set_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_fec_set_req_set_modes_nomask(struct ethtool_fec_set_req *req) | |
| { | |
| req->_present.modes = 1; | |
| req->modes._present.nomask = 1; | |
| } | |
| static inline void | |
| ethtool_fec_set_req_set_modes_size(struct ethtool_fec_set_req *req, __u32 size) | |
| { | |
| req->_present.modes = 1; | |
| req->modes._present.size = 1; | |
| req->modes.size = size; | |
| } | |
| static inline void | |
| __ethtool_fec_set_req_set_modes_bits_bit(struct ethtool_fec_set_req *req, | |
| struct ethtool_bitset_bit *bit, | |
| unsigned int n_bit) | |
| { | |
| free(req->modes.bits.bit); | |
| req->modes.bits.bit = bit; | |
| req->modes.bits.n_bit = n_bit; | |
| } | |
| static inline void | |
| ethtool_fec_set_req_set_auto_(struct ethtool_fec_set_req *req, __u8 auto_) | |
| { | |
| req->_present.auto_ = 1; | |
| req->auto_ = auto_; | |
| } | |
| static inline void | |
| ethtool_fec_set_req_set_active(struct ethtool_fec_set_req *req, __u32 active) | |
| { | |
| req->_present.active = 1; | |
| req->active = active; | |
| } | |
| static inline void | |
| ethtool_fec_set_req_set_stats_corrected(struct ethtool_fec_set_req *req, | |
| const void *corrected, size_t len) | |
| { | |
| free(req->stats.corrected); | |
| req->stats._present.corrected_len = len; | |
| req->stats.corrected = malloc(req->stats._present.corrected_len); | |
| memcpy(req->stats.corrected, corrected, req->stats._present.corrected_len); | |
| } | |
| static inline void | |
| ethtool_fec_set_req_set_stats_uncorr(struct ethtool_fec_set_req *req, | |
| const void *uncorr, size_t len) | |
| { | |
| free(req->stats.uncorr); | |
| req->stats._present.uncorr_len = len; | |
| req->stats.uncorr = malloc(req->stats._present.uncorr_len); | |
| memcpy(req->stats.uncorr, uncorr, req->stats._present.uncorr_len); | |
| } | |
| static inline void | |
| ethtool_fec_set_req_set_stats_corr_bits(struct ethtool_fec_set_req *req, | |
| const void *corr_bits, size_t len) | |
| { | |
| free(req->stats.corr_bits); | |
| req->stats._present.corr_bits_len = len; | |
| req->stats.corr_bits = malloc(req->stats._present.corr_bits_len); | |
| memcpy(req->stats.corr_bits, corr_bits, req->stats._present.corr_bits_len); | |
| } | |
| /* | |
| * Set FEC params. | |
| */ | |
| int ethtool_fec_set(struct ynl_sock *ys, struct ethtool_fec_set_req *req); | |
| /* ============== ETHTOOL_MSG_MODULE_EEPROM_GET ============== */ | |
| /* ETHTOOL_MSG_MODULE_EEPROM_GET - do */ | |
| struct ethtool_module_eeprom_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_module_eeprom_get_req * | |
| ethtool_module_eeprom_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_module_eeprom_get_req)); | |
| } | |
| void | |
| ethtool_module_eeprom_get_req_free(struct ethtool_module_eeprom_get_req *req); | |
| static inline void | |
| ethtool_module_eeprom_get_req_set_header_dev_index(struct ethtool_module_eeprom_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_module_eeprom_get_req_set_header_dev_name(struct ethtool_module_eeprom_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_module_eeprom_get_req_set_header_flags(struct ethtool_module_eeprom_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_module_eeprom_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 offset:1; | |
| __u32 length:1; | |
| __u32 page:1; | |
| __u32 bank:1; | |
| __u32 i2c_address:1; | |
| __u32 data_len; | |
| } _present; | |
| struct ethtool_header header; | |
| __u32 offset; | |
| __u32 length; | |
| __u8 page; | |
| __u8 bank; | |
| __u8 i2c_address; | |
| void *data; | |
| }; | |
| void | |
| ethtool_module_eeprom_get_rsp_free(struct ethtool_module_eeprom_get_rsp *rsp); | |
| /* | |
| * Get module EEPROM params. | |
| */ | |
| struct ethtool_module_eeprom_get_rsp * | |
| ethtool_module_eeprom_get(struct ynl_sock *ys, | |
| struct ethtool_module_eeprom_get_req *req); | |
| /* ETHTOOL_MSG_MODULE_EEPROM_GET - dump */ | |
| struct ethtool_module_eeprom_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_module_eeprom_get_req_dump * | |
| ethtool_module_eeprom_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_module_eeprom_get_req_dump)); | |
| } | |
| void | |
| ethtool_module_eeprom_get_req_dump_free(struct ethtool_module_eeprom_get_req_dump *req); | |
| static inline void | |
| ethtool_module_eeprom_get_req_dump_set_header_dev_index(struct ethtool_module_eeprom_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_module_eeprom_get_req_dump_set_header_dev_name(struct ethtool_module_eeprom_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_module_eeprom_get_req_dump_set_header_flags(struct ethtool_module_eeprom_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_module_eeprom_get_list { | |
| struct ethtool_module_eeprom_get_list *next; | |
| struct ethtool_module_eeprom_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void | |
| ethtool_module_eeprom_get_list_free(struct ethtool_module_eeprom_get_list *rsp); | |
| struct ethtool_module_eeprom_get_list * | |
| ethtool_module_eeprom_get_dump(struct ynl_sock *ys, | |
| struct ethtool_module_eeprom_get_req_dump *req); | |
| /* ============== ETHTOOL_MSG_PHC_VCLOCKS_GET ============== */ | |
| /* ETHTOOL_MSG_PHC_VCLOCKS_GET - do */ | |
| struct ethtool_phc_vclocks_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_phc_vclocks_get_req * | |
| ethtool_phc_vclocks_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_phc_vclocks_get_req)); | |
| } | |
| void ethtool_phc_vclocks_get_req_free(struct ethtool_phc_vclocks_get_req *req); | |
| static inline void | |
| ethtool_phc_vclocks_get_req_set_header_dev_index(struct ethtool_phc_vclocks_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_phc_vclocks_get_req_set_header_dev_name(struct ethtool_phc_vclocks_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_phc_vclocks_get_req_set_header_flags(struct ethtool_phc_vclocks_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_phc_vclocks_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 num:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u32 num; | |
| }; | |
| void ethtool_phc_vclocks_get_rsp_free(struct ethtool_phc_vclocks_get_rsp *rsp); | |
| /* | |
| * Get PHC VCLOCKs. | |
| */ | |
| struct ethtool_phc_vclocks_get_rsp * | |
| ethtool_phc_vclocks_get(struct ynl_sock *ys, | |
| struct ethtool_phc_vclocks_get_req *req); | |
| /* ETHTOOL_MSG_PHC_VCLOCKS_GET - dump */ | |
| struct ethtool_phc_vclocks_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_phc_vclocks_get_req_dump * | |
| ethtool_phc_vclocks_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_phc_vclocks_get_req_dump)); | |
| } | |
| void | |
| ethtool_phc_vclocks_get_req_dump_free(struct ethtool_phc_vclocks_get_req_dump *req); | |
| static inline void | |
| ethtool_phc_vclocks_get_req_dump_set_header_dev_index(struct ethtool_phc_vclocks_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_phc_vclocks_get_req_dump_set_header_dev_name(struct ethtool_phc_vclocks_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_phc_vclocks_get_req_dump_set_header_flags(struct ethtool_phc_vclocks_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_phc_vclocks_get_list { | |
| struct ethtool_phc_vclocks_get_list *next; | |
| struct ethtool_phc_vclocks_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void | |
| ethtool_phc_vclocks_get_list_free(struct ethtool_phc_vclocks_get_list *rsp); | |
| struct ethtool_phc_vclocks_get_list * | |
| ethtool_phc_vclocks_get_dump(struct ynl_sock *ys, | |
| struct ethtool_phc_vclocks_get_req_dump *req); | |
| /* ============== ETHTOOL_MSG_MODULE_GET ============== */ | |
| /* ETHTOOL_MSG_MODULE_GET - do */ | |
| struct ethtool_module_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_module_get_req *ethtool_module_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_module_get_req)); | |
| } | |
| void ethtool_module_get_req_free(struct ethtool_module_get_req *req); | |
| static inline void | |
| ethtool_module_get_req_set_header_dev_index(struct ethtool_module_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_module_get_req_set_header_dev_name(struct ethtool_module_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_module_get_req_set_header_flags(struct ethtool_module_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_module_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 power_mode_policy:1; | |
| __u32 power_mode:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u8 power_mode_policy; | |
| __u8 power_mode; | |
| }; | |
| void ethtool_module_get_rsp_free(struct ethtool_module_get_rsp *rsp); | |
| /* | |
| * Get module params. | |
| */ | |
| struct ethtool_module_get_rsp * | |
| ethtool_module_get(struct ynl_sock *ys, struct ethtool_module_get_req *req); | |
| /* ETHTOOL_MSG_MODULE_GET - dump */ | |
| struct ethtool_module_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_module_get_req_dump * | |
| ethtool_module_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_module_get_req_dump)); | |
| } | |
| void ethtool_module_get_req_dump_free(struct ethtool_module_get_req_dump *req); | |
| static inline void | |
| ethtool_module_get_req_dump_set_header_dev_index(struct ethtool_module_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_module_get_req_dump_set_header_dev_name(struct ethtool_module_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_module_get_req_dump_set_header_flags(struct ethtool_module_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_module_get_list { | |
| struct ethtool_module_get_list *next; | |
| struct ethtool_module_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_module_get_list_free(struct ethtool_module_get_list *rsp); | |
| struct ethtool_module_get_list * | |
| ethtool_module_get_dump(struct ynl_sock *ys, | |
| struct ethtool_module_get_req_dump *req); | |
| /* ETHTOOL_MSG_MODULE_GET - notify */ | |
| struct ethtool_module_get_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_module_get_ntf *ntf); | |
| struct ethtool_module_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_module_get_ntf_free(struct ethtool_module_get_ntf *rsp); | |
| /* ============== ETHTOOL_MSG_MODULE_SET ============== */ | |
| /* ETHTOOL_MSG_MODULE_SET - do */ | |
| struct ethtool_module_set_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 power_mode_policy:1; | |
| __u32 power_mode:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u8 power_mode_policy; | |
| __u8 power_mode; | |
| }; | |
| static inline struct ethtool_module_set_req *ethtool_module_set_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_module_set_req)); | |
| } | |
| void ethtool_module_set_req_free(struct ethtool_module_set_req *req); | |
| static inline void | |
| ethtool_module_set_req_set_header_dev_index(struct ethtool_module_set_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_module_set_req_set_header_dev_name(struct ethtool_module_set_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_module_set_req_set_header_flags(struct ethtool_module_set_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_module_set_req_set_power_mode_policy(struct ethtool_module_set_req *req, | |
| __u8 power_mode_policy) | |
| { | |
| req->_present.power_mode_policy = 1; | |
| req->power_mode_policy = power_mode_policy; | |
| } | |
| static inline void | |
| ethtool_module_set_req_set_power_mode(struct ethtool_module_set_req *req, | |
| __u8 power_mode) | |
| { | |
| req->_present.power_mode = 1; | |
| req->power_mode = power_mode; | |
| } | |
| /* | |
| * Set module params. | |
| */ | |
| int ethtool_module_set(struct ynl_sock *ys, struct ethtool_module_set_req *req); | |
| /* ============== ETHTOOL_MSG_PSE_GET ============== */ | |
| /* ETHTOOL_MSG_PSE_GET - do */ | |
| struct ethtool_pse_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_pse_get_req *ethtool_pse_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_pse_get_req)); | |
| } | |
| void ethtool_pse_get_req_free(struct ethtool_pse_get_req *req); | |
| static inline void | |
| ethtool_pse_get_req_set_header_dev_index(struct ethtool_pse_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_pse_get_req_set_header_dev_name(struct ethtool_pse_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_pse_get_req_set_header_flags(struct ethtool_pse_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_pse_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 admin_state:1; | |
| __u32 admin_control:1; | |
| __u32 pw_d_status:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u32 admin_state; | |
| __u32 admin_control; | |
| __u32 pw_d_status; | |
| }; | |
| void ethtool_pse_get_rsp_free(struct ethtool_pse_get_rsp *rsp); | |
| /* | |
| * Get Power Sourcing Equipment params. | |
| */ | |
| struct ethtool_pse_get_rsp * | |
| ethtool_pse_get(struct ynl_sock *ys, struct ethtool_pse_get_req *req); | |
| /* ETHTOOL_MSG_PSE_GET - dump */ | |
| struct ethtool_pse_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_pse_get_req_dump * | |
| ethtool_pse_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_pse_get_req_dump)); | |
| } | |
| void ethtool_pse_get_req_dump_free(struct ethtool_pse_get_req_dump *req); | |
| static inline void | |
| ethtool_pse_get_req_dump_set_header_dev_index(struct ethtool_pse_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_pse_get_req_dump_set_header_dev_name(struct ethtool_pse_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_pse_get_req_dump_set_header_flags(struct ethtool_pse_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_pse_get_list { | |
| struct ethtool_pse_get_list *next; | |
| struct ethtool_pse_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_pse_get_list_free(struct ethtool_pse_get_list *rsp); | |
| struct ethtool_pse_get_list * | |
| ethtool_pse_get_dump(struct ynl_sock *ys, struct ethtool_pse_get_req_dump *req); | |
| /* ============== ETHTOOL_MSG_PSE_SET ============== */ | |
| /* ETHTOOL_MSG_PSE_SET - do */ | |
| struct ethtool_pse_set_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 admin_state:1; | |
| __u32 admin_control:1; | |
| __u32 pw_d_status:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u32 admin_state; | |
| __u32 admin_control; | |
| __u32 pw_d_status; | |
| }; | |
| static inline struct ethtool_pse_set_req *ethtool_pse_set_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_pse_set_req)); | |
| } | |
| void ethtool_pse_set_req_free(struct ethtool_pse_set_req *req); | |
| static inline void | |
| ethtool_pse_set_req_set_header_dev_index(struct ethtool_pse_set_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_pse_set_req_set_header_dev_name(struct ethtool_pse_set_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_pse_set_req_set_header_flags(struct ethtool_pse_set_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_pse_set_req_set_admin_state(struct ethtool_pse_set_req *req, | |
| __u32 admin_state) | |
| { | |
| req->_present.admin_state = 1; | |
| req->admin_state = admin_state; | |
| } | |
| static inline void | |
| ethtool_pse_set_req_set_admin_control(struct ethtool_pse_set_req *req, | |
| __u32 admin_control) | |
| { | |
| req->_present.admin_control = 1; | |
| req->admin_control = admin_control; | |
| } | |
| static inline void | |
| ethtool_pse_set_req_set_pw_d_status(struct ethtool_pse_set_req *req, | |
| __u32 pw_d_status) | |
| { | |
| req->_present.pw_d_status = 1; | |
| req->pw_d_status = pw_d_status; | |
| } | |
| /* | |
| * Set Power Sourcing Equipment params. | |
| */ | |
| int ethtool_pse_set(struct ynl_sock *ys, struct ethtool_pse_set_req *req); | |
| /* ============== ETHTOOL_MSG_RSS_GET ============== */ | |
| /* ETHTOOL_MSG_RSS_GET - do */ | |
| struct ethtool_rss_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_rss_get_req *ethtool_rss_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_rss_get_req)); | |
| } | |
| void ethtool_rss_get_req_free(struct ethtool_rss_get_req *req); | |
| static inline void | |
| ethtool_rss_get_req_set_header_dev_index(struct ethtool_rss_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_rss_get_req_set_header_dev_name(struct ethtool_rss_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_rss_get_req_set_header_flags(struct ethtool_rss_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_rss_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 context:1; | |
| __u32 hfunc:1; | |
| __u32 indir_len; | |
| __u32 hkey_len; | |
| } _present; | |
| struct ethtool_header header; | |
| __u32 context; | |
| __u32 hfunc; | |
| void *indir; | |
| void *hkey; | |
| }; | |
| void ethtool_rss_get_rsp_free(struct ethtool_rss_get_rsp *rsp); | |
| /* | |
| * Get RSS params. | |
| */ | |
| struct ethtool_rss_get_rsp * | |
| ethtool_rss_get(struct ynl_sock *ys, struct ethtool_rss_get_req *req); | |
| /* ETHTOOL_MSG_RSS_GET - dump */ | |
| struct ethtool_rss_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_rss_get_req_dump * | |
| ethtool_rss_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_rss_get_req_dump)); | |
| } | |
| void ethtool_rss_get_req_dump_free(struct ethtool_rss_get_req_dump *req); | |
| static inline void | |
| ethtool_rss_get_req_dump_set_header_dev_index(struct ethtool_rss_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_rss_get_req_dump_set_header_dev_name(struct ethtool_rss_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_rss_get_req_dump_set_header_flags(struct ethtool_rss_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_rss_get_list { | |
| struct ethtool_rss_get_list *next; | |
| struct ethtool_rss_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_rss_get_list_free(struct ethtool_rss_get_list *rsp); | |
| struct ethtool_rss_get_list * | |
| ethtool_rss_get_dump(struct ynl_sock *ys, struct ethtool_rss_get_req_dump *req); | |
| /* ============== ETHTOOL_MSG_PLCA_GET_CFG ============== */ | |
| /* ETHTOOL_MSG_PLCA_GET_CFG - do */ | |
| struct ethtool_plca_get_cfg_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_plca_get_cfg_req * | |
| ethtool_plca_get_cfg_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_plca_get_cfg_req)); | |
| } | |
| void ethtool_plca_get_cfg_req_free(struct ethtool_plca_get_cfg_req *req); | |
| static inline void | |
| ethtool_plca_get_cfg_req_set_header_dev_index(struct ethtool_plca_get_cfg_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_plca_get_cfg_req_set_header_dev_name(struct ethtool_plca_get_cfg_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_plca_get_cfg_req_set_header_flags(struct ethtool_plca_get_cfg_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_plca_get_cfg_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 version:1; | |
| __u32 enabled:1; | |
| __u32 status:1; | |
| __u32 node_cnt:1; | |
| __u32 node_id:1; | |
| __u32 to_tmr:1; | |
| __u32 burst_cnt:1; | |
| __u32 burst_tmr:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u16 version; | |
| __u8 enabled; | |
| __u8 status; | |
| __u32 node_cnt; | |
| __u32 node_id; | |
| __u32 to_tmr; | |
| __u32 burst_cnt; | |
| __u32 burst_tmr; | |
| }; | |
| void ethtool_plca_get_cfg_rsp_free(struct ethtool_plca_get_cfg_rsp *rsp); | |
| /* | |
| * Get PLCA params. | |
| */ | |
| struct ethtool_plca_get_cfg_rsp * | |
| ethtool_plca_get_cfg(struct ynl_sock *ys, struct ethtool_plca_get_cfg_req *req); | |
| /* ETHTOOL_MSG_PLCA_GET_CFG - dump */ | |
| struct ethtool_plca_get_cfg_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_plca_get_cfg_req_dump * | |
| ethtool_plca_get_cfg_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_plca_get_cfg_req_dump)); | |
| } | |
| void | |
| ethtool_plca_get_cfg_req_dump_free(struct ethtool_plca_get_cfg_req_dump *req); | |
| static inline void | |
| ethtool_plca_get_cfg_req_dump_set_header_dev_index(struct ethtool_plca_get_cfg_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_plca_get_cfg_req_dump_set_header_dev_name(struct ethtool_plca_get_cfg_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_plca_get_cfg_req_dump_set_header_flags(struct ethtool_plca_get_cfg_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_plca_get_cfg_list { | |
| struct ethtool_plca_get_cfg_list *next; | |
| struct ethtool_plca_get_cfg_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_plca_get_cfg_list_free(struct ethtool_plca_get_cfg_list *rsp); | |
| struct ethtool_plca_get_cfg_list * | |
| ethtool_plca_get_cfg_dump(struct ynl_sock *ys, | |
| struct ethtool_plca_get_cfg_req_dump *req); | |
| /* ETHTOOL_MSG_PLCA_GET_CFG - notify */ | |
| struct ethtool_plca_get_cfg_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_plca_get_cfg_ntf *ntf); | |
| struct ethtool_plca_get_cfg_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_plca_get_cfg_ntf_free(struct ethtool_plca_get_cfg_ntf *rsp); | |
| /* ============== ETHTOOL_MSG_PLCA_SET_CFG ============== */ | |
| /* ETHTOOL_MSG_PLCA_SET_CFG - do */ | |
| struct ethtool_plca_set_cfg_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 version:1; | |
| __u32 enabled:1; | |
| __u32 status:1; | |
| __u32 node_cnt:1; | |
| __u32 node_id:1; | |
| __u32 to_tmr:1; | |
| __u32 burst_cnt:1; | |
| __u32 burst_tmr:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u16 version; | |
| __u8 enabled; | |
| __u8 status; | |
| __u32 node_cnt; | |
| __u32 node_id; | |
| __u32 to_tmr; | |
| __u32 burst_cnt; | |
| __u32 burst_tmr; | |
| }; | |
| static inline struct ethtool_plca_set_cfg_req * | |
| ethtool_plca_set_cfg_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_plca_set_cfg_req)); | |
| } | |
| void ethtool_plca_set_cfg_req_free(struct ethtool_plca_set_cfg_req *req); | |
| static inline void | |
| ethtool_plca_set_cfg_req_set_header_dev_index(struct ethtool_plca_set_cfg_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_plca_set_cfg_req_set_header_dev_name(struct ethtool_plca_set_cfg_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_plca_set_cfg_req_set_header_flags(struct ethtool_plca_set_cfg_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_plca_set_cfg_req_set_version(struct ethtool_plca_set_cfg_req *req, | |
| __u16 version) | |
| { | |
| req->_present.version = 1; | |
| req->version = version; | |
| } | |
| static inline void | |
| ethtool_plca_set_cfg_req_set_enabled(struct ethtool_plca_set_cfg_req *req, | |
| __u8 enabled) | |
| { | |
| req->_present.enabled = 1; | |
| req->enabled = enabled; | |
| } | |
| static inline void | |
| ethtool_plca_set_cfg_req_set_status(struct ethtool_plca_set_cfg_req *req, | |
| __u8 status) | |
| { | |
| req->_present.status = 1; | |
| req->status = status; | |
| } | |
| static inline void | |
| ethtool_plca_set_cfg_req_set_node_cnt(struct ethtool_plca_set_cfg_req *req, | |
| __u32 node_cnt) | |
| { | |
| req->_present.node_cnt = 1; | |
| req->node_cnt = node_cnt; | |
| } | |
| static inline void | |
| ethtool_plca_set_cfg_req_set_node_id(struct ethtool_plca_set_cfg_req *req, | |
| __u32 node_id) | |
| { | |
| req->_present.node_id = 1; | |
| req->node_id = node_id; | |
| } | |
| static inline void | |
| ethtool_plca_set_cfg_req_set_to_tmr(struct ethtool_plca_set_cfg_req *req, | |
| __u32 to_tmr) | |
| { | |
| req->_present.to_tmr = 1; | |
| req->to_tmr = to_tmr; | |
| } | |
| static inline void | |
| ethtool_plca_set_cfg_req_set_burst_cnt(struct ethtool_plca_set_cfg_req *req, | |
| __u32 burst_cnt) | |
| { | |
| req->_present.burst_cnt = 1; | |
| req->burst_cnt = burst_cnt; | |
| } | |
| static inline void | |
| ethtool_plca_set_cfg_req_set_burst_tmr(struct ethtool_plca_set_cfg_req *req, | |
| __u32 burst_tmr) | |
| { | |
| req->_present.burst_tmr = 1; | |
| req->burst_tmr = burst_tmr; | |
| } | |
| /* | |
| * Set PLCA params. | |
| */ | |
| int ethtool_plca_set_cfg(struct ynl_sock *ys, | |
| struct ethtool_plca_set_cfg_req *req); | |
| /* ============== ETHTOOL_MSG_PLCA_GET_STATUS ============== */ | |
| /* ETHTOOL_MSG_PLCA_GET_STATUS - do */ | |
| struct ethtool_plca_get_status_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_plca_get_status_req * | |
| ethtool_plca_get_status_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_plca_get_status_req)); | |
| } | |
| void ethtool_plca_get_status_req_free(struct ethtool_plca_get_status_req *req); | |
| static inline void | |
| ethtool_plca_get_status_req_set_header_dev_index(struct ethtool_plca_get_status_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_plca_get_status_req_set_header_dev_name(struct ethtool_plca_get_status_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_plca_get_status_req_set_header_flags(struct ethtool_plca_get_status_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_plca_get_status_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 version:1; | |
| __u32 enabled:1; | |
| __u32 status:1; | |
| __u32 node_cnt:1; | |
| __u32 node_id:1; | |
| __u32 to_tmr:1; | |
| __u32 burst_cnt:1; | |
| __u32 burst_tmr:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u16 version; | |
| __u8 enabled; | |
| __u8 status; | |
| __u32 node_cnt; | |
| __u32 node_id; | |
| __u32 to_tmr; | |
| __u32 burst_cnt; | |
| __u32 burst_tmr; | |
| }; | |
| void ethtool_plca_get_status_rsp_free(struct ethtool_plca_get_status_rsp *rsp); | |
| /* | |
| * Get PLCA status params. | |
| */ | |
| struct ethtool_plca_get_status_rsp * | |
| ethtool_plca_get_status(struct ynl_sock *ys, | |
| struct ethtool_plca_get_status_req *req); | |
| /* ETHTOOL_MSG_PLCA_GET_STATUS - dump */ | |
| struct ethtool_plca_get_status_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_plca_get_status_req_dump * | |
| ethtool_plca_get_status_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_plca_get_status_req_dump)); | |
| } | |
| void | |
| ethtool_plca_get_status_req_dump_free(struct ethtool_plca_get_status_req_dump *req); | |
| static inline void | |
| ethtool_plca_get_status_req_dump_set_header_dev_index(struct ethtool_plca_get_status_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_plca_get_status_req_dump_set_header_dev_name(struct ethtool_plca_get_status_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_plca_get_status_req_dump_set_header_flags(struct ethtool_plca_get_status_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_plca_get_status_list { | |
| struct ethtool_plca_get_status_list *next; | |
| struct ethtool_plca_get_status_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void | |
| ethtool_plca_get_status_list_free(struct ethtool_plca_get_status_list *rsp); | |
| struct ethtool_plca_get_status_list * | |
| ethtool_plca_get_status_dump(struct ynl_sock *ys, | |
| struct ethtool_plca_get_status_req_dump *req); | |
| /* ============== ETHTOOL_MSG_MM_GET ============== */ | |
| /* ETHTOOL_MSG_MM_GET - do */ | |
| struct ethtool_mm_get_req { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_mm_get_req *ethtool_mm_get_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_mm_get_req)); | |
| } | |
| void ethtool_mm_get_req_free(struct ethtool_mm_get_req *req); | |
| static inline void | |
| ethtool_mm_get_req_set_header_dev_index(struct ethtool_mm_get_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_mm_get_req_set_header_dev_name(struct ethtool_mm_get_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_mm_get_req_set_header_flags(struct ethtool_mm_get_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_mm_get_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 pmac_enabled:1; | |
| __u32 tx_enabled:1; | |
| __u32 tx_active:1; | |
| __u32 tx_min_frag_size:1; | |
| __u32 rx_min_frag_size:1; | |
| __u32 verify_enabled:1; | |
| __u32 verify_time:1; | |
| __u32 max_verify_time:1; | |
| __u32 stats:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u8 pmac_enabled; | |
| __u8 tx_enabled; | |
| __u8 tx_active; | |
| __u32 tx_min_frag_size; | |
| __u32 rx_min_frag_size; | |
| __u8 verify_enabled; | |
| __u32 verify_time; | |
| __u32 max_verify_time; | |
| struct ethtool_mm_stat stats; | |
| }; | |
| void ethtool_mm_get_rsp_free(struct ethtool_mm_get_rsp *rsp); | |
| /* | |
| * Get MAC Merge configuration and state | |
| */ | |
| struct ethtool_mm_get_rsp * | |
| ethtool_mm_get(struct ynl_sock *ys, struct ethtool_mm_get_req *req); | |
| /* ETHTOOL_MSG_MM_GET - dump */ | |
| struct ethtool_mm_get_req_dump { | |
| struct { | |
| __u32 header:1; | |
| } _present; | |
| struct ethtool_header header; | |
| }; | |
| static inline struct ethtool_mm_get_req_dump * | |
| ethtool_mm_get_req_dump_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_mm_get_req_dump)); | |
| } | |
| void ethtool_mm_get_req_dump_free(struct ethtool_mm_get_req_dump *req); | |
| static inline void | |
| ethtool_mm_get_req_dump_set_header_dev_index(struct ethtool_mm_get_req_dump *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_mm_get_req_dump_set_header_dev_name(struct ethtool_mm_get_req_dump *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_mm_get_req_dump_set_header_flags(struct ethtool_mm_get_req_dump *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| struct ethtool_mm_get_list { | |
| struct ethtool_mm_get_list *next; | |
| struct ethtool_mm_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_mm_get_list_free(struct ethtool_mm_get_list *rsp); | |
| struct ethtool_mm_get_list * | |
| ethtool_mm_get_dump(struct ynl_sock *ys, struct ethtool_mm_get_req_dump *req); | |
| /* ETHTOOL_MSG_MM_GET - notify */ | |
| struct ethtool_mm_get_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_mm_get_ntf *ntf); | |
| struct ethtool_mm_get_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_mm_get_ntf_free(struct ethtool_mm_get_ntf *rsp); | |
| /* ============== ETHTOOL_MSG_MM_SET ============== */ | |
| /* ETHTOOL_MSG_MM_SET - do */ | |
| struct ethtool_mm_set_req { | |
| struct { | |
| __u32 header:1; | |
| __u32 verify_enabled:1; | |
| __u32 verify_time:1; | |
| __u32 tx_enabled:1; | |
| __u32 pmac_enabled:1; | |
| __u32 tx_min_frag_size:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u8 verify_enabled; | |
| __u32 verify_time; | |
| __u8 tx_enabled; | |
| __u8 pmac_enabled; | |
| __u32 tx_min_frag_size; | |
| }; | |
| static inline struct ethtool_mm_set_req *ethtool_mm_set_req_alloc(void) | |
| { | |
| return calloc(1, sizeof(struct ethtool_mm_set_req)); | |
| } | |
| void ethtool_mm_set_req_free(struct ethtool_mm_set_req *req); | |
| static inline void | |
| ethtool_mm_set_req_set_header_dev_index(struct ethtool_mm_set_req *req, | |
| __u32 dev_index) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.dev_index = 1; | |
| req->header.dev_index = dev_index; | |
| } | |
| static inline void | |
| ethtool_mm_set_req_set_header_dev_name(struct ethtool_mm_set_req *req, | |
| const char *dev_name) | |
| { | |
| free(req->header.dev_name); | |
| req->header._present.dev_name_len = strlen(dev_name); | |
| req->header.dev_name = malloc(req->header._present.dev_name_len + 1); | |
| memcpy(req->header.dev_name, dev_name, req->header._present.dev_name_len); | |
| req->header.dev_name[req->header._present.dev_name_len] = 0; | |
| } | |
| static inline void | |
| ethtool_mm_set_req_set_header_flags(struct ethtool_mm_set_req *req, | |
| __u32 flags) | |
| { | |
| req->_present.header = 1; | |
| req->header._present.flags = 1; | |
| req->header.flags = flags; | |
| } | |
| static inline void | |
| ethtool_mm_set_req_set_verify_enabled(struct ethtool_mm_set_req *req, | |
| __u8 verify_enabled) | |
| { | |
| req->_present.verify_enabled = 1; | |
| req->verify_enabled = verify_enabled; | |
| } | |
| static inline void | |
| ethtool_mm_set_req_set_verify_time(struct ethtool_mm_set_req *req, | |
| __u32 verify_time) | |
| { | |
| req->_present.verify_time = 1; | |
| req->verify_time = verify_time; | |
| } | |
| static inline void | |
| ethtool_mm_set_req_set_tx_enabled(struct ethtool_mm_set_req *req, | |
| __u8 tx_enabled) | |
| { | |
| req->_present.tx_enabled = 1; | |
| req->tx_enabled = tx_enabled; | |
| } | |
| static inline void | |
| ethtool_mm_set_req_set_pmac_enabled(struct ethtool_mm_set_req *req, | |
| __u8 pmac_enabled) | |
| { | |
| req->_present.pmac_enabled = 1; | |
| req->pmac_enabled = pmac_enabled; | |
| } | |
| static inline void | |
| ethtool_mm_set_req_set_tx_min_frag_size(struct ethtool_mm_set_req *req, | |
| __u32 tx_min_frag_size) | |
| { | |
| req->_present.tx_min_frag_size = 1; | |
| req->tx_min_frag_size = tx_min_frag_size; | |
| } | |
| /* | |
| * Set MAC Merge configuration | |
| */ | |
| int ethtool_mm_set(struct ynl_sock *ys, struct ethtool_mm_set_req *req); | |
| /* ETHTOOL_MSG_CABLE_TEST_NTF - event */ | |
| struct ethtool_cable_test_ntf_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 status:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u8 status; | |
| }; | |
| struct ethtool_cable_test_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_cable_test_ntf *ntf); | |
| struct ethtool_cable_test_ntf_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_cable_test_ntf_free(struct ethtool_cable_test_ntf *rsp); | |
| /* ETHTOOL_MSG_CABLE_TEST_TDR_NTF - event */ | |
| struct ethtool_cable_test_tdr_ntf_rsp { | |
| struct { | |
| __u32 header:1; | |
| __u32 status:1; | |
| __u32 nest:1; | |
| } _present; | |
| struct ethtool_header header; | |
| __u8 status; | |
| struct ethtool_cable_nest nest; | |
| }; | |
| struct ethtool_cable_test_tdr_ntf { | |
| __u16 family; | |
| __u8 cmd; | |
| struct ynl_ntf_base_type *next; | |
| void (*free)(struct ethtool_cable_test_tdr_ntf *ntf); | |
| struct ethtool_cable_test_tdr_ntf_rsp obj __attribute__ ((aligned (8))); | |
| }; | |
| void ethtool_cable_test_tdr_ntf_free(struct ethtool_cable_test_tdr_ntf *rsp); | |
| #endif /* _LINUX_ETHTOOL_GEN_H */ |