ethernet.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2016 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_ETHERNET_H_
#define ZEPHYR_INCLUDE_NET_ETHERNET_H_
 
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <stdbool.h>
#include <zephyr/sys/atomic.h>
 
#include <zephyr/net/net_ip.h>
#include <zephyr/net/net_pkt.h>
#include <zephyr/net/lldp.h>
#include <zephyr/sys/util.h>
#include <zephyr/net/net_if.h>
#include <zephyr/net/ethernet_vlan.h>
#include <zephyr/net/ptp_time.h>
 
#if defined(CONFIG_NET_DSA)
#include <zephyr/net/dsa.h>
#endif
 
#if defined(CONFIG_NET_ETHERNET_BRIDGE)
#include <zephyr/net/ethernet_bridge.h>
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define NET_ETH_ADDR_LEN 6U 
struct net_eth_addr {
 uint8_t addr[NET_ETH_ADDR_LEN]; 
};
 
#define NET_ETH_HDR(pkt) ((struct net_eth_hdr *)net_pkt_data(pkt))
 
#define NET_ETH_PTYPE_CAN 0x000C /* CAN: Controller Area Network */
#define NET_ETH_PTYPE_CANFD 0x000D /* CANFD: CAN flexible data rate*/
#define NET_ETH_PTYPE_HDLC 0x0019 /* HDLC frames (like in PPP) */
#define NET_ETH_PTYPE_ARP 0x0806
#define NET_ETH_PTYPE_IP 0x0800
#define NET_ETH_PTYPE_TSN 0x22f0 /* TSN (IEEE 1722) packet */
#define NET_ETH_PTYPE_IPV6 0x86dd
#define NET_ETH_PTYPE_VLAN 0x8100
#define NET_ETH_PTYPE_PTP 0x88f7
#define NET_ETH_PTYPE_LLDP 0x88cc
#define NET_ETH_PTYPE_ALL 0x0003 /* from linux/if_ether.h */
#define NET_ETH_PTYPE_ECAT 0x88a4
#define NET_ETH_PTYPE_EAPOL 0x888e
#define NET_ETH_PTYPE_IEEE802154 0x00F6 /* from linux/if_ether.h: IEEE802.15.4 frame */
 
#if !defined(ETH_P_ALL)
#define ETH_P_ALL NET_ETH_PTYPE_ALL
#endif
#if !defined(ETH_P_IP)
#define ETH_P_IP NET_ETH_PTYPE_IP
#endif
#if !defined(ETH_P_ARP)
#define ETH_P_ARP NET_ETH_PTYPE_ARP
#endif
#if !defined(ETH_P_IPV6)
#define ETH_P_IPV6 NET_ETH_PTYPE_IPV6
#endif
#if !defined(ETH_P_8021Q)
#define ETH_P_8021Q NET_ETH_PTYPE_VLAN
#endif
#if !defined(ETH_P_TSN)
#define ETH_P_TSN NET_ETH_PTYPE_TSN
#endif
#if !defined(ETH_P_ECAT)
#define ETH_P_ECAT NET_ETH_PTYPE_ECAT
#endif
#if !defined(ETH_P_IEEE802154)
#define ETH_P_IEEE802154 NET_ETH_PTYPE_IEEE802154
#endif
#if !defined(ETH_P_CAN)
#define ETH_P_CAN NET_ETH_PTYPE_CAN
#endif
#if !defined(ETH_P_CANFD)
#define ETH_P_CANFD NET_ETH_PTYPE_CANFD
#endif
#if !defined(ETH_P_HDLC)
#define ETH_P_HDLC NET_ETH_PTYPE_HDLC
#endif
 
#define NET_ETH_MINIMAL_FRAME_SIZE 60 
#define NET_ETH_MTU 1500 
#if defined(CONFIG_NET_VLAN)
#define _NET_ETH_MAX_HDR_SIZE (sizeof(struct net_eth_vlan_hdr))
#else
#define _NET_ETH_MAX_HDR_SIZE (sizeof(struct net_eth_hdr))
#endif
 
#define _NET_ETH_MAX_FRAME_SIZE (NET_ETH_MTU + _NET_ETH_MAX_HDR_SIZE)
/*
 * Extend the max frame size for DSA (KSZ8794) by one byte (to 1519) to
 * store tail tag.
 */
#if defined(CONFIG_NET_DSA)
#define NET_ETH_MAX_FRAME_SIZE (_NET_ETH_MAX_FRAME_SIZE + DSA_TAG_SIZE)
#define NET_ETH_MAX_HDR_SIZE (_NET_ETH_MAX_HDR_SIZE + DSA_TAG_SIZE)
#else
#define NET_ETH_MAX_FRAME_SIZE (_NET_ETH_MAX_FRAME_SIZE)
#define NET_ETH_MAX_HDR_SIZE (_NET_ETH_MAX_HDR_SIZE)
#endif
 
#define NET_ETH_VLAN_HDR_SIZE 4
 
enum ethernet_hw_caps {
 ETHERNET_HW_TX_CHKSUM_OFFLOAD = BIT(0),
 
 ETHERNET_HW_RX_CHKSUM_OFFLOAD = BIT(1),
 
 ETHERNET_HW_VLAN = BIT(2),
 
 ETHERNET_AUTO_NEGOTIATION_SET = BIT(3),
 
 ETHERNET_LINK_10BASE_T = BIT(4),
 
 ETHERNET_LINK_100BASE_T = BIT(5),
 
 ETHERNET_LINK_1000BASE_T = BIT(6),
 
 ETHERNET_DUPLEX_SET = BIT(7),
 
 ETHERNET_PTP = BIT(8),
 
 ETHERNET_QAV = BIT(9),
 
 ETHERNET_PROMISC_MODE = BIT(10),
 
 ETHERNET_PRIORITY_QUEUES = BIT(11),
 
 ETHERNET_HW_FILTERING = BIT(12),
 
 ETHERNET_LLDP = BIT(13),
 
 ETHERNET_HW_VLAN_TAG_STRIP = BIT(14),
 
 ETHERNET_DSA_SLAVE_PORT = BIT(15),
 
 ETHERNET_DSA_MASTER_PORT = BIT(16),
 
 ETHERNET_QBV = BIT(17),
 
 ETHERNET_QBU = BIT(18),
 
 ETHERNET_TXTIME = BIT(19),
 
 ETHERNET_TXINJECTION_MODE = BIT(20),
};
 
enum ethernet_config_type {
 ETHERNET_CONFIG_TYPE_AUTO_NEG,
 ETHERNET_CONFIG_TYPE_LINK,
 ETHERNET_CONFIG_TYPE_DUPLEX,
 ETHERNET_CONFIG_TYPE_MAC_ADDRESS,
 ETHERNET_CONFIG_TYPE_QAV_PARAM,
 ETHERNET_CONFIG_TYPE_QBV_PARAM,
 ETHERNET_CONFIG_TYPE_QBU_PARAM,
 ETHERNET_CONFIG_TYPE_TXTIME_PARAM,
 ETHERNET_CONFIG_TYPE_PROMISC_MODE,
 ETHERNET_CONFIG_TYPE_PRIORITY_QUEUES_NUM,
 ETHERNET_CONFIG_TYPE_FILTER,
 ETHERNET_CONFIG_TYPE_PORTS_NUM,
 ETHERNET_CONFIG_TYPE_T1S_PARAM,
 ETHERNET_CONFIG_TYPE_TXINJECTION_MODE,
};
 
enum ethernet_qav_param_type {
 ETHERNET_QAV_PARAM_TYPE_DELTA_BANDWIDTH,
 ETHERNET_QAV_PARAM_TYPE_IDLE_SLOPE,
 ETHERNET_QAV_PARAM_TYPE_OPER_IDLE_SLOPE,
 ETHERNET_QAV_PARAM_TYPE_TRAFFIC_CLASS,
 ETHERNET_QAV_PARAM_TYPE_STATUS,
};
 
enum ethernet_t1s_param_type {
 ETHERNET_T1S_PARAM_TYPE_PLCA_CONFIG,
};
 
struct ethernet_t1s_param {
 enum ethernet_t1s_param_type type;
 union {
 struct {
 bool enable;
 uint8_t node_id;
 uint8_t node_count;
 uint8_t burst_count;
 uint8_t burst_timer;
 uint8_t to_timer;
 } plca;
 };
};
 
struct ethernet_qav_param {
 int queue_id;
 enum ethernet_qav_param_type type;
 union {
 bool enabled;
 unsigned int delta_bandwidth;
 unsigned int idle_slope;
 unsigned int oper_idle_slope;
 unsigned int traffic_class;
 };
};
 
enum ethernet_qbv_param_type {
 ETHERNET_QBV_PARAM_TYPE_STATUS,
 ETHERNET_QBV_PARAM_TYPE_GATE_CONTROL_LIST,
 ETHERNET_QBV_PARAM_TYPE_GATE_CONTROL_LIST_LEN,
 ETHERNET_QBV_PARAM_TYPE_TIME,
};
 
enum ethernet_qbv_state_type {
 ETHERNET_QBV_STATE_TYPE_ADMIN,
 ETHERNET_QBV_STATE_TYPE_OPER,
};
 
enum ethernet_gate_state_operation {
 ETHERNET_SET_GATE_STATE,
 ETHERNET_SET_AND_HOLD_MAC_STATE,
 ETHERNET_SET_AND_RELEASE_MAC_STATE,
};
 
struct ethernet_qbv_param {
 int port_id;
 enum ethernet_qbv_param_type type;
 enum ethernet_qbv_state_type state;
 union {
 bool enabled;
 
 struct {
 bool gate_status[NET_TC_TX_COUNT];
 
 enum ethernet_gate_state_operation operation;
 
 uint32_t time_interval;
 
 uint16_t row;
 } gate_control;
 
 uint32_t gate_control_list_len;
 
 struct {
 struct net_ptp_extended_time base_time;
 
 struct net_ptp_time cycle_time;
 
 uint32_t extension_time;
 };
 };
};
 
enum ethernet_qbu_param_type {
 ETHERNET_QBU_PARAM_TYPE_STATUS,
 ETHERNET_QBU_PARAM_TYPE_RELEASE_ADVANCE,
 ETHERNET_QBU_PARAM_TYPE_HOLD_ADVANCE,
 ETHERNET_QBU_PARAM_TYPE_PREEMPTION_STATUS_TABLE,
 
 /* Some preemption settings are from Qbr spec. */
 ETHERNET_QBR_PARAM_TYPE_LINK_PARTNER_STATUS,
 ETHERNET_QBR_PARAM_TYPE_ADDITIONAL_FRAGMENT_SIZE,
};
 
enum ethernet_qbu_preempt_status {
 ETHERNET_QBU_STATUS_EXPRESS,
 ETHERNET_QBU_STATUS_PREEMPTABLE
} __packed;
 
struct ethernet_qbu_param {
 int port_id;
 enum ethernet_qbu_param_type type;
 union {
 uint32_t hold_advance;
 
 uint32_t release_advance;
 
 enum ethernet_qbu_preempt_status
 frame_preempt_statuses[NET_TC_TX_COUNT];
 
 bool enabled;
 
 bool link_partner_status;
 
 uint8_t additional_fragment_size : 2;
 };
};
 
enum ethernet_filter_type {
 ETHERNET_FILTER_TYPE_SRC_MAC_ADDRESS,
 ETHERNET_FILTER_TYPE_DST_MAC_ADDRESS,
};
 
enum ethernet_if_types {
 L2_ETH_IF_TYPE_ETHERNET,
 
 L2_ETH_IF_TYPE_WIFI,
} __packed;
 
struct ethernet_filter {
 enum ethernet_filter_type type;
 struct net_eth_addr mac_address;
 bool set;
};
 
enum ethernet_txtime_param_type {
 ETHERNET_TXTIME_PARAM_TYPE_ENABLE_QUEUES,
};
 
struct ethernet_txtime_param {
 enum ethernet_txtime_param_type type;
 int queue_id;
 bool enable_txtime;
};
 
struct ethernet_config {
 union {
 bool auto_negotiation;
 bool full_duplex;
 bool promisc_mode;
 bool txinjection_mode;
 
 struct {
 bool link_10bt;
 bool link_100bt;
 bool link_1000bt;
 } l;
 
 struct net_eth_addr mac_address;
 
 struct ethernet_t1s_param t1s_param;
 struct ethernet_qav_param qav_param;
 struct ethernet_qbv_param qbv_param;
 struct ethernet_qbu_param qbu_param;
 struct ethernet_txtime_param txtime_param;
 
 int priority_queues_num;
 int ports_num;
 
 struct ethernet_filter filter;
 };
};
 
struct ethernet_api {
 struct net_if_api iface_api;
 
#if defined(CONFIG_NET_STATISTICS_ETHERNET)
 struct net_stats_eth *(*get_stats)(const struct device *dev);
#endif
 
 int (*start)(const struct device *dev);
 
 int (*stop)(const struct device *dev);
 
 enum ethernet_hw_caps (*get_capabilities)(const struct device *dev);
 
 int (*set_config)(const struct device *dev,
 enum ethernet_config_type type,
 const struct ethernet_config *config);
 
 int (*get_config)(const struct device *dev,
 enum ethernet_config_type type,
 struct ethernet_config *config);
 
#if defined(CONFIG_NET_VLAN)
 int (*vlan_setup)(const struct device *dev, struct net_if *iface,
 uint16_t tag, bool enable);
#endif /* CONFIG_NET_VLAN */
 
#if defined(CONFIG_PTP_CLOCK)
 const struct device *(*get_ptp_clock)(const struct device *dev);
#endif /* CONFIG_PTP_CLOCK */
 
 int (*send)(const struct device *dev, struct net_pkt *pkt);
};
 
/* Make sure that the network interface API is properly setup inside
 * Ethernet API struct (it is the first one).
 */
BUILD_ASSERT(offsetof(struct ethernet_api, iface_api) == 0);
 
struct net_eth_hdr {
 struct net_eth_addr dst;
 struct net_eth_addr src;
 uint16_t type;
} __packed;
 
struct ethernet_vlan {
 struct net_if *iface;
 
 uint16_t tag;
};
 
#if defined(CONFIG_NET_VLAN_COUNT)
#define NET_VLAN_MAX_COUNT CONFIG_NET_VLAN_COUNT
#else
/* Even thou there are no VLAN support, the minimum count must be set to 1.
 */
#define NET_VLAN_MAX_COUNT 1
#endif
 
struct ethernet_lldp {
 sys_snode_t node;
 
 const struct net_lldpdu *lldpdu;
 
 const uint8_t *optional_du;
 
 size_t optional_len;
 
 struct net_if *iface;
 
 int64_t tx_timer_start;
 
 uint32_t tx_timer_timeout;
 
 net_lldp_recv_cb_t cb;
};
 
enum ethernet_flags {
 ETH_CARRIER_UP,
};
 
struct ethernet_context {
 atomic_t flags;
 
#if defined(CONFIG_NET_ETHERNET_BRIDGE)
 struct eth_bridge_iface_context bridge;
#endif
 
 struct k_work carrier_work;
 
 struct net_if *iface;
 
#if defined(CONFIG_NET_LLDP)
 struct ethernet_lldp lldp[NET_VLAN_MAX_COUNT];
#endif
 
 enum net_l2_flags ethernet_l2_flags;
 
#if defined(CONFIG_NET_L2_PTP)
 int port;
#endif
 
#if defined(CONFIG_NET_DSA)
 dsa_net_recv_cb_t dsa_recv_cb;
 
 uint8_t dsa_port_idx;
 
 struct dsa_context *dsa_ctx;
 
 dsa_send_t dsa_send;
#endif
 
 bool is_net_carrier_up : 1;
 
 bool is_init : 1;
 
 enum ethernet_if_types eth_if_type;
};
 
void ethernet_init(struct net_if *iface);
 
#define ETHERNET_L2_CTX_TYPE struct ethernet_context
 
/* Separate header for VLAN as some of device interfaces might not
 * support VLAN.
 */
struct net_eth_vlan_hdr {
 struct net_eth_addr dst;
 struct net_eth_addr src;
 struct {
 uint16_t tpid; /* tag protocol id */
 uint16_t tci; /* tag control info */
 } vlan;
 uint16_t type;
} __packed;
 
static inline bool net_eth_is_addr_broadcast(struct net_eth_addr *addr)
{
 if (addr->addr[0] == 0xff &&
 addr->addr[1] == 0xff &&
 addr->addr[2] == 0xff &&
 addr->addr[3] == 0xff &&
 addr->addr[4] == 0xff &&
 addr->addr[5] == 0xff) {
 return true;
 }
 
 return false;
}
 
static inline bool net_eth_is_addr_unspecified(struct net_eth_addr *addr)
{
 if (addr->addr[0] == 0x00 &&
 addr->addr[1] == 0x00 &&
 addr->addr[2] == 0x00 &&
 addr->addr[3] == 0x00 &&
 addr->addr[4] == 0x00 &&
 addr->addr[5] == 0x00) {
 return true;
 }
 
 return false;
}
 
static inline bool net_eth_is_addr_multicast(struct net_eth_addr *addr)
{
#if defined(CONFIG_NET_IPV6)
 if (addr->addr[0] == 0x33 &&
 addr->addr[1] == 0x33) {
 return true;
 }
#endif
 
#if defined(CONFIG_NET_IPV4)
 if (addr->addr[0] == 0x01 &&
 addr->addr[1] == 0x00 &&
 addr->addr[2] == 0x5e) {
 return true;
 }
#endif
 
 return false;
}
 
static inline bool net_eth_is_addr_group(struct net_eth_addr *addr)
{
 return addr->addr[0] & 0x01;
}
 
static inline bool net_eth_is_addr_valid(struct net_eth_addr *addr)
{
 return !net_eth_is_addr_unspecified(addr) && !net_eth_is_addr_group(addr);
}
 
static inline bool net_eth_is_addr_lldp_multicast(struct net_eth_addr *addr)
{
#if defined(CONFIG_NET_GPTP) || defined(CONFIG_NET_LLDP)
 if (addr->addr[0] == 0x01 &&
 addr->addr[1] == 0x80 &&
 addr->addr[2] == 0xc2 &&
 addr->addr[3] == 0x00 &&
 addr->addr[4] == 0x00 &&
 addr->addr[5] == 0x0e) {
 return true;
 }
#else
 ARG_UNUSED(addr);
#endif
 
 return false;
}
 
static inline bool net_eth_is_addr_ptp_multicast(struct net_eth_addr *addr)
{
#if defined(CONFIG_NET_GPTP)
 if (addr->addr[0] == 0x01 &&
 addr->addr[1] == 0x1b &&
 addr->addr[2] == 0x19 &&
 addr->addr[3] == 0x00 &&
 addr->addr[4] == 0x00 &&
 addr->addr[5] == 0x00) {
 return true;
 }
#else
 ARG_UNUSED(addr);
#endif
 
 return false;
}
 
const struct net_eth_addr *net_eth_broadcast_addr(void);
 
void net_eth_ipv4_mcast_to_mac_addr(const struct in_addr *ipv4_addr,
 struct net_eth_addr *mac_addr);
 
void net_eth_ipv6_mcast_to_mac_addr(const struct in6_addr *ipv6_addr,
 struct net_eth_addr *mac_addr);
 
static inline
enum ethernet_hw_caps net_eth_get_hw_capabilities(struct net_if *iface)
{
 const struct ethernet_api *eth =
 (struct ethernet_api *)net_if_get_device(iface)->api;
 
 if (!eth->get_capabilities) {
 return (enum ethernet_hw_caps)0;
 }
 
 return eth->get_capabilities(net_if_get_device(iface));
}
 
#if defined(CONFIG_NET_VLAN)
int net_eth_vlan_enable(struct net_if *iface, uint16_t tag);
#else
static inline int net_eth_vlan_enable(struct net_if *iface, uint16_t tag)
{
 ARG_UNUSED(iface);
 ARG_UNUSED(tag);
 
 return -EINVAL;
}
#endif
 
#if defined(CONFIG_NET_VLAN)
int net_eth_vlan_disable(struct net_if *iface, uint16_t tag);
#else
static inline int net_eth_vlan_disable(struct net_if *iface, uint16_t tag)
{
 ARG_UNUSED(iface);
 ARG_UNUSED(tag);
 
 return -EINVAL;
}
#endif
 
#if defined(CONFIG_NET_VLAN)
uint16_t net_eth_get_vlan_tag(struct net_if *iface);
#else
static inline uint16_t net_eth_get_vlan_tag(struct net_if *iface)
{
 ARG_UNUSED(iface);
 
 return NET_VLAN_TAG_UNSPEC;
}
#endif
 
#if defined(CONFIG_NET_VLAN)
struct net_if *net_eth_get_vlan_iface(struct net_if *iface, uint16_t tag);
#else
static inline
struct net_if *net_eth_get_vlan_iface(struct net_if *iface, uint16_t tag)
{
 ARG_UNUSED(iface);
 ARG_UNUSED(tag);
 
 return NULL;
}
#endif
 
#if defined(CONFIG_NET_VLAN)
struct net_if *net_eth_get_vlan_main(struct net_if *iface);
#else
static inline
struct net_if *net_eth_get_vlan_main(struct net_if *iface)
{
 ARG_UNUSED(iface);
 
 return NULL;
}
#endif
 
#if defined(CONFIG_NET_VLAN)
bool net_eth_is_vlan_enabled(struct ethernet_context *ctx,
 struct net_if *iface);
#else
static inline bool net_eth_is_vlan_enabled(struct ethernet_context *ctx,
 struct net_if *iface)
{
 ARG_UNUSED(ctx);
 ARG_UNUSED(iface);
 
 return false;
}
#endif
 
#if defined(CONFIG_NET_VLAN)
bool net_eth_get_vlan_status(struct net_if *iface);
#else
static inline bool net_eth_get_vlan_status(struct net_if *iface)
{
 ARG_UNUSED(iface);
 
 return false;
}
#endif
 
#if defined(CONFIG_NET_VLAN)
bool net_eth_is_vlan_interface(struct net_if *iface);
#else
static inline bool net_eth_is_vlan_interface(struct net_if *iface)
{
 ARG_UNUSED(iface);
 
 return false;
}
#endif
 
#if !defined(CONFIG_ETH_DRIVER_RAW_MODE)
 
#define Z_ETH_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, instance, \
 init_fn, pm, data, config, prio, \
 api, mtu) \
 Z_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, instance, \
 init_fn, pm, data, config, prio, \
 api, ETHERNET_L2, \
 NET_L2_GET_CTX_TYPE(ETHERNET_L2), mtu)
 
#else /* CONFIG_ETH_DRIVER_RAW_MODE */
 
#define Z_ETH_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, instance, \
 init_fn, pm, data, config, prio, \
 api, mtu) \
 Z_DEVICE_STATE_DEFINE(dev_id); \
 Z_DEVICE_DEFINE(node_id, dev_id, name, init_fn, pm, data, \
 config, POST_KERNEL, prio, api, \
 &Z_DEVICE_STATE_NAME(dev_id));
 
#endif /* CONFIG_ETH_DRIVER_RAW_MODE */
 
#define Z_ETH_NET_DEVICE_INIT(node_id, dev_id, name, init_fn, pm, data, \
 config, prio, api, mtu) \
 Z_ETH_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, 0, \
 init_fn, pm, data, config, prio, \
 api, mtu)
 
#define ETH_NET_DEVICE_INIT(dev_id, name, init_fn, pm, data, config, \
 prio, api, mtu) \
 Z_ETH_NET_DEVICE_INIT(DT_INVALID_NODE, dev_id, name, init_fn, \
 pm, data, config, prio, api, mtu)
 
#define ETH_NET_DEVICE_INIT_INSTANCE(dev_id, name, instance, init_fn, \
 pm, data, config, prio, api, mtu) \
 Z_ETH_NET_DEVICE_INIT_INSTANCE(DT_INVALID_NODE, dev_id, name, \
 instance, init_fn, pm, data, \
 config, prio, api, mtu)
 
#define ETH_NET_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, \
 prio, api, mtu) \
 Z_ETH_NET_DEVICE_INIT(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
 DEVICE_DT_NAME(node_id), init_fn, pm, \
 data, config, prio, api, mtu)
 
#define ETH_NET_DEVICE_DT_INST_DEFINE(inst, ...) \
 ETH_NET_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
 
void net_eth_carrier_on(struct net_if *iface);
 
void net_eth_carrier_off(struct net_if *iface);
 
int net_eth_promisc_mode(struct net_if *iface, bool enable);
 
int net_eth_txinjection_mode(struct net_if *iface, bool enable);
 
int net_eth_mac_filter(struct net_if *iface, struct net_eth_addr *mac,
 enum ethernet_filter_type type, bool enable);
#if defined(CONFIG_PTP_CLOCK)
const struct device *net_eth_get_ptp_clock(struct net_if *iface);
#else
static inline const struct device *net_eth_get_ptp_clock(struct net_if *iface)
{
 ARG_UNUSED(iface);
 
 return NULL;
}
#endif
 
__syscall const struct device *net_eth_get_ptp_clock_by_index(int index);
 
#if defined(CONFIG_NET_L2_PTP)
int net_eth_get_ptp_port(struct net_if *iface);
#else
static inline int net_eth_get_ptp_port(struct net_if *iface)
{
 ARG_UNUSED(iface);
 
 return -ENODEV;
}
#endif /* CONFIG_NET_L2_PTP */
 
#if defined(CONFIG_NET_L2_PTP)
void net_eth_set_ptp_port(struct net_if *iface, int port);
#else
static inline void net_eth_set_ptp_port(struct net_if *iface, int port)
{
 ARG_UNUSED(iface);
 ARG_UNUSED(port);
}
#endif /* CONFIG_NET_L2_PTP */
 
static inline bool net_eth_type_is_wifi(struct net_if *iface)
{
 const struct ethernet_context *ctx = (struct ethernet_context *)
 net_if_l2_data(iface);
 
 return ctx->eth_if_type == L2_ETH_IF_TYPE_WIFI;
}
 
#ifdef __cplusplus
}
#endif
 
#include <syscalls/ethernet.h>
 
#endif /* ZEPHYR_INCLUDE_NET_ETHERNET_H_ */