/* 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 */
