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/clock.h>
#include <zephyr/sys/util.h>
#include <zephyr/net/net_if.h>
#include <zephyr/net/ethernet_vlan.h>
#include <zephyr/net/ptp_time.h>
#include <zephyr/net/virtual.h>
#include <zephyr/random/random.h>
 
#if defined(CONFIG_NVMEM)
#include <zephyr/nvmem.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))
 
/* clang-format off */
/* zephyr-keep-sorted-start */
#define NET_ETH_PTYPE_ALL               0x0003 /* from linux/if_ether.h */
#define NET_ETH_PTYPE_ARP               0x0806
#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_EAPOL             0x888e
#define NET_ETH_PTYPE_ECAT              0x88a4
#define NET_ETH_PTYPE_HDLC              0x0019 /* HDLC frames (like in PPP) */
#define NET_ETH_PTYPE_IEEE802154        0x00F6 /* from linux/if_ether.h: IEEE802.15.4 frame */
#define NET_ETH_PTYPE_IP                0x0800
#define NET_ETH_PTYPE_IPV6              0x86dd
#define NET_ETH_PTYPE_LLDP              0x88cc
#define NET_ETH_PTYPE_OAM               0x8902
#define NET_ETH_PTYPE_PTP               0x88f7
#define NET_ETH_PTYPE_TSN               0x22f0 /* TSN (IEEE 1722) packet */
#define NET_ETH_PTYPE_VLAN              0x8100
/* zephyr-keep-sorted-stop */
/* clang-format on */
 
/* zephyr-keep-sorted-start re(^#define) */
#if !defined(ETH_P_8021Q)
#define ETH_P_8021Q     NET_ETH_PTYPE_VLAN
#endif
#if !defined(ETH_P_ALL)
#define ETH_P_ALL       NET_ETH_PTYPE_ALL
#endif
#if !defined(ETH_P_ARP)
#define ETH_P_ARP       NET_ETH_PTYPE_ARP
#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_EAPOL)
#define ETH_P_EAPOL     NET_ETH_PTYPE_EAPOL
#endif
#if !defined(ETH_P_ECAT)
#define ETH_P_ECAT      NET_ETH_PTYPE_ECAT
#endif
#if !defined(ETH_P_HDLC)
#define ETH_P_HDLC      NET_ETH_PTYPE_HDLC
#endif
#if !defined(ETH_P_IEEE802154)
#define ETH_P_IEEE802154 NET_ETH_PTYPE_IEEE802154
#endif
#if !defined(ETH_P_IP)
#define ETH_P_IP        NET_ETH_PTYPE_IP
#endif
#if !defined(ETH_P_IPV6)
#define ETH_P_IPV6      NET_ETH_PTYPE_IPV6
#endif
#if !defined(ETH_P_TSN)
#define ETH_P_TSN       NET_ETH_PTYPE_TSN
#endif
/* zephyr-keep-sorted-stop */

 
#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)
 
#if defined(CONFIG_DSA_TAG_SIZE)
#define DSA_TAG_SIZE CONFIG_DSA_TAG_SIZE
#else
#define DSA_TAG_SIZE 0
#endif
 
#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)
 
#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_LINK_10BASE            = BIT(3),

        ETHERNET_LINK_100BASE           = BIT(4),

        ETHERNET_LINK_1000BASE          = BIT(5),

        ETHERNET_LINK_2500BASE          = BIT(6),

        ETHERNET_LINK_5000BASE          = BIT(7),

        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_USER_PORT          = BIT(15),

        ETHERNET_DSA_CONDUIT_PORT       = BIT(16),

        ETHERNET_QBV                    = BIT(17),

        ETHERNET_QBU                    = BIT(18),

        ETHERNET_TXTIME                 = BIT(19),

        ETHERNET_TXINJECTION_MODE       = BIT(20),
};

 
enum dsa_port_type {
        NON_DSA_PORT,
        DSA_CONDUIT_PORT,
        DSA_USER_PORT,
        DSA_CPU_PORT,
        DSA_PORT,
};
 
enum ethernet_config_type {
        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_TXINJECTION_MODE,
        ETHERNET_CONFIG_TYPE_RX_CHECKSUM_SUPPORT,
        ETHERNET_CONFIG_TYPE_TX_CHECKSUM_SUPPORT,
        ETHERNET_CONFIG_TYPE_EXTRA_TX_PKT_HEADROOM,
};
 
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,
};


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;
};

 
/* How many L2 multicast addresses one interface can track. The build system
 * sums up what the subsystems asked for and gives the result here, the
 * Kconfig value is only the floor and is used if the header is compiled
 * outside of a Zephyr build.
 */
#ifndef NET_ETH_MCAST_FILTER_COUNT
#define NET_ETH_MCAST_FILTER_COUNT CONFIG_NET_L2_ETHERNET_MCAST_FILTER_COUNT
#endif
 
/* The L2 multicast addresses are tracked only if something joins the groups,
 * either the IP level, a packet socket, or other parts of the system.
 */
#if defined(CONFIG_NET_L2_ETHERNET) && !defined(CONFIG_NET_RAW_MODE) && \
        (NET_ETH_MCAST_FILTER_COUNT > 0)
#define NET_ETH_MCAST_FILTER_SUPPORTED 1
#endif


struct net_eth_mcast_addr {
        struct net_eth_addr addr;

        atomic_t atomic_ref;

        uint8_t is_used : 1;
 
        uint8_t _unused : 7;
};

 
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;
};

enum ethernet_checksum_support {
        ETHERNET_CHECKSUM_SUPPORT_NONE                  = NET_IF_CHECKSUM_NONE_BIT,
        ETHERNET_CHECKSUM_SUPPORT_IPV4_HEADER           = NET_IF_CHECKSUM_IPV4_HEADER_BIT,
        ETHERNET_CHECKSUM_SUPPORT_IPV4_ICMP             = NET_IF_CHECKSUM_IPV4_ICMP_BIT,
        ETHERNET_CHECKSUM_SUPPORT_IPV6_HEADER           = NET_IF_CHECKSUM_IPV6_HEADER_BIT,
        ETHERNET_CHECKSUM_SUPPORT_IPV6_ICMP             = NET_IF_CHECKSUM_IPV6_ICMP_BIT,
        ETHERNET_CHECKSUM_SUPPORT_TCP                   = NET_IF_CHECKSUM_TCP_BIT,
        ETHERNET_CHECKSUM_SUPPORT_UDP                   = NET_IF_CHECKSUM_UDP_BIT,
};

 
struct ethernet_config {
        union {
                bool promisc_mode;
                bool txinjection_mode;
 
                struct net_eth_addr mac_address;
 
                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;
 
                enum ethernet_checksum_support chksum_support;
 
                struct ethernet_filter filter;
 
                uint16_t extra_tx_pkt_headroom;
        } ;
};


enum ethernet_stats_type {
        ETHERNET_STATS_TYPE_COMMON = BIT(0),
        ETHERNET_STATS_TYPE_VENDOR = BIT(1),
        ETHERNET_STATS_TYPE_ALL = 0xFFFFFFFFU,
};

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, struct net_if *iface);

        struct net_stats_eth *(*get_stats_type)(const struct device *dev,
                                                 struct net_if *iface,
                                                 uint32_t type);
#endif

        int (*start)(const struct device *dev, struct net_if *iface);

        int (*stop)(const struct device *dev, struct net_if *iface);

        enum ethernet_hw_caps (*get_capabilities)(const struct device *dev, struct net_if *iface);

        int (*set_config)(const struct device *dev,
                          struct net_if *iface,
                          enum ethernet_config_type type,
                          const struct ethernet_config *config);

        int (*get_config)(const struct device *dev,
                          struct net_if *iface,
                          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, struct net_if *iface);
#endif /* CONFIG_PTP_CLOCK */

        const struct device *(*get_phy)(const struct device *dev, struct net_if *iface);

        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
#define NET_VLAN_MAX_COUNT 0
#endif


struct ethernet_lldp {
        sys_snode_t node;

        const struct net_lldpdu *lldpdu;

        const uint8_t *optional_du;

        size_t optional_len;

        k_timepoint_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 net_if *bridge;
#endif

        struct k_work carrier_work;

        struct net_if *iface;
 
#if defined(CONFIG_NET_LLDP)
        struct ethernet_lldp lldp;
#endif

        enum net_l2_flags ethernet_l2_flags;
 
#if defined(CONFIG_NET_GPTP)
        uint16_t gptp_port;
#endif
 
#if defined(CONFIG_NET_DSA)
        enum dsa_port_type dsa_port;

        void *dsa_switch_ctx;
#endif
 
#if defined(NET_ETH_MCAST_FILTER_SUPPORTED)
        struct net_eth_mcast_addr mcast_addrs[NET_ETH_MCAST_FILTER_COUNT];
#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_all_zeroes(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_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)
{
        return addr->addr[0] & 0x01;
}

static inline bool net_eth_is_addr_unicast(struct net_eth_addr *addr)
{
        return !net_eth_is_addr_unspecified(addr) && !net_eth_is_addr_multicast(addr);
}

static inline bool net_eth_is_addr_valid(struct net_eth_addr *addr)
{
        return !net_eth_is_addr_unspecified(addr) && !net_eth_is_addr_multicast(addr);
}

static inline bool net_eth_is_addr_lldp_multicast(struct net_eth_addr *addr)
{
        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;
        }
 
        return false;
}

static inline bool net_eth_is_addr_ptp_multicast(struct net_eth_addr *addr)
{
        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;
        }
 
        return false;
}

const struct net_eth_addr *net_eth_broadcast_addr(void);

void net_eth_ipv4_mcast_to_mac_addr(const struct net_in_addr *ipv4_addr,
                                    struct net_eth_addr *mac_addr);

void net_eth_ipv6_mcast_to_mac_addr(const struct net_in6_addr *ipv6_addr,
                                    struct net_eth_addr *mac_addr);

typedef void (*net_eth_mcast_addr_cb_t)(struct net_if *iface,
                                        const struct net_eth_mcast_addr *addr,
                                        void *user_data);
 
#if defined(NET_ETH_MCAST_FILTER_SUPPORTED) || defined(__DOXYGEN__)

int net_eth_mcast_addr_add(struct net_if *iface,
                           const struct net_eth_addr *addr);

int net_eth_mcast_addr_rm(struct net_if *iface,
                          const struct net_eth_addr *addr);

void net_eth_mcast_addr_foreach(struct net_if *iface,
                                net_eth_mcast_addr_cb_t cb,
                                void *user_data);


int net_eth_mcast_ip_addr_update(struct net_if *iface, const struct net_addr *addr, bool add);

 
#else /* NET_ETH_MCAST_FILTER_SUPPORTED */
 
static inline int net_eth_mcast_addr_add(struct net_if *iface,
                                         const struct net_eth_addr *addr)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(addr);
 
        return -ENOTSUP;
}
 
static inline int net_eth_mcast_addr_rm(struct net_if *iface,
                                        const struct net_eth_addr *addr)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(addr);
 
        return -ENOTSUP;
}
 
static inline void net_eth_mcast_addr_foreach(struct net_if *iface,
                                              net_eth_mcast_addr_cb_t cb,
                                              void *user_data)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(cb);
        ARG_UNUSED(user_data);
}
 
static inline int net_eth_mcast_ip_addr_update(struct net_if *iface __unused,
                                               const struct net_addr *addr __unused,
                                               bool add __unused)
{
        return -ENOTSUP;
}
 
#endif /* NET_ETH_MCAST_FILTER_SUPPORTED */

static inline
enum ethernet_hw_caps net_eth_get_hw_capabilities(struct net_if *iface)
{
        const struct device *dev = net_if_get_device(iface);
        const struct ethernet_api *api;
        enum ethernet_hw_caps caps = (enum ethernet_hw_caps)0;
#if defined(CONFIG_NET_DSA)
        struct ethernet_context *eth_ctx = net_if_l2_data(iface);
 
        NET_ASSERT(eth_ctx != NULL);
 
        if (eth_ctx->dsa_port == DSA_CONDUIT_PORT) {
                caps = ETHERNET_DSA_CONDUIT_PORT;
        } else if (eth_ctx->dsa_port == DSA_USER_PORT) {
                caps = ETHERNET_DSA_USER_PORT;
        }
#endif
        NET_ASSERT(dev != NULL);
 
        api = (const struct ethernet_api *)dev->api;
        if (api == NULL || api->get_capabilities == NULL) {
                return caps;
        }
 
        return (enum ethernet_hw_caps)(caps | api->get_capabilities(dev, iface));
}

static inline
int net_eth_get_hw_config(struct net_if *iface, enum ethernet_config_type type,
                         struct ethernet_config *config)
{
        const struct device *dev = net_if_get_device(iface);
        const struct ethernet_api *eth;
 
        NET_ASSERT(dev != NULL);
 
        eth = (const struct ethernet_api *)dev->api;
 
        NET_ASSERT(eth != NULL);
 
        if (!eth->get_config) {
                return -ENOTSUP;
        }
 
        return eth->get_config(dev, iface, type, config);
}
 

#if defined(CONFIG_NET_VLAN) && NET_VLAN_MAX_COUNT > 0
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) && NET_VLAN_MAX_COUNT > 0
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) && NET_VLAN_MAX_COUNT > 0
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) && NET_VLAN_MAX_COUNT > 0
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)
{
        /* Special case for priority tagged frames, without vlan ifaces being present */
        if (IS_ENABLED(CONFIG_NET_VLAN) && (tag == NET_VLAN_TAG_PRIORITY)) {
                return iface;
        }
 
        return NULL;
}
#endif

static inline struct net_if *net_eth_get_vlan_main(struct net_if *iface)
{
        return net_virtual_get_iface(iface);
}

#if defined(CONFIG_NET_VLAN) && NET_VLAN_MAX_COUNT > 0
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 IS_ENABLED(CONFIG_NET_VLAN);
}
#endif

#if defined(CONFIG_NET_VLAN) && NET_VLAN_MAX_COUNT > 0
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) && NET_VLAN_MAX_COUNT > 0
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, NULL,           \
                        Z_DEVICE_DT_FLAGS(node_id), 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__)

#define ETH_NET_L3_REGISTER(name, ptype, handler) \
        NET_L3_REGISTER(&NET_L2_GET_NAME(ETHERNET), name, ptype, handler)

enum net_eth_mac_type {
        NET_ETH_MAC_DEFAULT = 0,
        NET_ETH_MAC_RANDOM,
        NET_ETH_MAC_NVMEM,
        NET_ETH_MAC_STATIC,
};

struct net_eth_mac_config {
        enum net_eth_mac_type type;
        uint8_t addr[NET_ETH_ADDR_LEN];
        uint8_t addr_len;
#if defined(CONFIG_NVMEM) || defined(__DOXYGEN__)
        struct nvmem_cell cell;
#endif
};

static inline int net_eth_mac_load(const struct net_eth_mac_config *cfg, uint8_t *mac_addr)
{
        if (cfg == NULL || cfg->type == NET_ETH_MAC_DEFAULT) {
                return -ENODATA;
        }
 
        /* Copy the static part */
        memcpy(mac_addr, cfg->addr, cfg->addr_len);
 
        if (cfg->type == NET_ETH_MAC_RANDOM) {
                sys_rand_get(&mac_addr[cfg->addr_len], NET_ETH_ADDR_LEN - cfg->addr_len);
 
                /* Clear group bit, multicast (I/G) */
                mac_addr[0] &= ~0x01;
                /* Set MAC address locally administered, unicast (LAA) */
                mac_addr[0] |= 0x02;
 
                return 0;
        }
 
#if defined(CONFIG_NVMEM)
        if (cfg->type == NET_ETH_MAC_NVMEM) {
                return nvmem_cell_read(&cfg->cell, &mac_addr[cfg->addr_len], 0,
                                       NET_ETH_ADDR_LEN - cfg->addr_len);
        }
#endif
 
        if (cfg->type == NET_ETH_MAC_STATIC) {
                return 0;
        }
 
        return -ENODATA;
}

 
#if defined(CONFIG_NVMEM) || defined(__DOXYGEN__)
#define Z_NET_ETH_MAC_DEV_CONFIG_INIT_CELL(node_id)                                                \
        .cell = NVMEM_CELL_GET_BY_NAME_OR(node_id, mac_address, {0}),
#else
#define Z_NET_ETH_MAC_DEV_CONFIG_INIT_CELL(node_id)
#endif
 
#define Z_NET_ETH_MAC_DT_CONFIG_INIT_RANDOM(node_id)                                               \
        {                                                                                          \
                .type = NET_ETH_MAC_RANDOM,                                                        \
                .addr = DT_PROP_OR(node_id, zephyr_mac_address_prefix, {0}),                       \
                .addr_len = DT_PROP_LEN_OR(node_id, zephyr_mac_address_prefix, 0),                 \
        }
 
#define Z_NET_ETH_MAC_DT_CONFIG_INIT_NVMEM(node_id)                                                \
        {                                                                                          \
                .type = NET_ETH_MAC_NVMEM,                                                         \
                .addr = DT_PROP_OR(node_id, zephyr_mac_address_prefix, {0}),                       \
                .addr_len = DT_PROP_LEN_OR(node_id, zephyr_mac_address_prefix, 0),                 \
                Z_NET_ETH_MAC_DEV_CONFIG_INIT_CELL(node_id)                                        \
        }
 
#define Z_NET_ETH_MAC_DT_CONFIG_INIT_STATIC(node_id)                                               \
        {                                                                                          \
                .type = NET_ETH_MAC_STATIC,                                                        \
                .addr = DT_PROP(node_id, local_mac_address),                                       \
                .addr_len = DT_PROP_LEN(node_id, local_mac_address),                               \
        }
 
#define Z_NET_ETH_MAC_DT_CONFIG_INIT_DEFAULT(node_id)                                              \
        {                                                                                          \
                .type = NET_ETH_MAC_DEFAULT,                                                       \
        }


#define NET_ETH_MAC_DT_CONFIG_INIT(node_id)                                                        \
        COND_CASE_1(DT_PROP(node_id, zephyr_random_mac_address),                                   \
                    (Z_NET_ETH_MAC_DT_CONFIG_INIT_RANDOM(node_id)),                                \
                    DT_NVMEM_CELLS_HAS_NAME(node_id, mac_address),                                 \
                    (Z_NET_ETH_MAC_DT_CONFIG_INIT_NVMEM(node_id)),                                 \
                    DT_NODE_HAS_PROP(node_id, local_mac_address),                                  \
                    (Z_NET_ETH_MAC_DT_CONFIG_INIT_STATIC(node_id)),                                \
                    (Z_NET_ETH_MAC_DT_CONFIG_INIT_DEFAULT(node_id)))

#define NET_ETH_MAC_DT_INST_CONFIG_INIT(inst)                                                      \
        NET_ETH_MAC_DT_CONFIG_INIT(DT_DRV_INST(inst))

void net_eth_carrier_set(struct net_if *iface, bool carrier_up);

static inline void net_eth_carrier_on(struct net_if *iface)
{
        net_eth_carrier_set(iface, true);
}

static inline void net_eth_carrier_off(struct net_if *iface)
{
        net_eth_carrier_set(iface, false);
}

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);

const struct device *net_eth_get_phy(struct net_if *iface);

#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);

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);
 
        NET_ASSERT(ctx != NULL);
 
        return ctx->eth_if_type == L2_ETH_IF_TYPE_WIFI;
}

static inline bool net_eth_type_is_ethernet(struct net_if *iface)
{
        const struct ethernet_context *ctx = (struct ethernet_context *)net_if_l2_data(iface);
 
        NET_ASSERT(ctx != NULL);
 
        return ctx->eth_if_type == L2_ETH_IF_TYPE_ETHERNET;
}

static inline void net_eth_set_if_type_wifi(struct net_if *iface)
{
        struct ethernet_context *ctx = (struct ethernet_context *)net_if_l2_data(iface);
 
        NET_ASSERT(ctx != NULL);
 
        ctx->eth_if_type = L2_ETH_IF_TYPE_WIFI;
}

 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/ethernet.h>
 
#endif /* ZEPHYR_INCLUDE_NET_ETHERNET_H_ */