vsf_template_eth.h

Go to the documentation of this file.

/*****************************************************************************
 *   Copyright(C)2009-2022 by VSF Team                                       *
 *                                                                           *
 *  Licensed under the Apache License, Version 2.0 (the "License");          *
 *  you may not use this file except in compliance with the License.         *
 *  You may obtain a copy of the License at                                  *
 *                                                                           *
 *     http://www.apache.org/licenses/LICENSE-2.0                            *
 *                                                                           *
 *  Unless required by applicable law or agreed to in writing, software      *
 *  distributed under the License is distributed on an "AS IS" BASIS,        *
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
 *  See the License for the specific language governing permissions and      *
 *  limitations under the License.                                           *
 *                                                                           *
 ****************************************************************************/
 
#ifndef __VSF_TEMPLATE_ETH_H__
#define __VSF_TEMPLATE_ETH_H__
 
/*============================ INCLUDES ======================================*/
 
#include "./vsf_template_hal_driver.h"
#include "hal/arch/vsf_arch.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*============================ ETHROS ========================================*/
 
#ifndef VSF_ETH_CFG_MULTI_CLASS
#   define VSF_ETH_CFG_MULTI_CLASS                      ENABLED
#endif
#ifndef VSF_ETH_CFG_MULTI_PHY_CLASS
#   define VSF_ETH_CFG_MULTI_PHY_CLASS                  ENABLED
#endif
 
#if defined(VSF_HW_ETH_COUNT) && !defined(VSF_HW_ETH_MASK)
#   define VSF_HW_ETH_MASK                              VSF_HAL_COUNT_TO_MASK(VSF_HW_ETH_COUNT)
#endif
 
#if defined(VSF_HW_ETH_MASK) && !defined(VSF_HW_ETH_COUNT)
#   define VSF_HW_ETH_COUNT                             VSF_HAL_MASK_TO_COUNT(VSF_HW_ETH_MASK)
#endif
 
#ifndef VSF_ETH_CFG_PREFIX
#   if (VSF_ETH_CFG_MULTI_CLASS == DISABLED) && defined(VSF_HW_ETH_COUNT) && (VSF_HW_ETH_COUNT != 0)
#       define VSF_ETH_CFG_PREFIX                       vsf_hw
#   else
#       define VSF_ETH_CFG_PREFIX                       vsf
#   endif
#endif
 
#ifndef VSF_ETH_CFG_FUNCTION_RENAME
#   define VSF_ETH_CFG_FUNCTION_RENAME                  ENABLED
#endif
 
#ifndef VSF_ETH_CFG_REIMPLEMENT_TYPE_PHY_MODE
#   define VSF_ETH_CFG_REIMPLEMENT_TYPE_PHY_MODE            DISABLED
#endif
 
#ifndef VSF_ETH_CFG_REIMPLEMENT_TYPE_MODE
#   define VSF_ETH_CFG_REIMPLEMENT_TYPE_MODE                DISABLED
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_CFG == DISABLED
#    define VSF_ETH_CFG_REIMPLEMENT_TYPE_CFG DISABLED
#endif
 
#ifndef VSF_ETH_CFG_REIMPLEMENT_TYPE_STATUS
#   define VSF_ETH_CFG_REIMPLEMENT_TYPE_STATUS    DISABLED
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_CAPABILITY == DISABLED
#    define VSF_ETH_CFG_REIMPLEMENT_TYPE_CAPABILITY DISABLED
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_BUF_MODE == DISABLED
#    define VSF_ETH_CFG_REIMPLEMENT_TYPE_BUF_MODE DISABLED
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_BUF_DESC == DISABLED
#   define VSF_ETH_CFG_REIMPLEMENT_TYPE_BUF_DESC DISABLED
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_SEND_BUF_DESC == DISABLED
#   define VSF_ETH_CFG_REIMPLEMENT_TYPE_SEND_BUF_DESC DISABLED
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_RECV_BUF_DESC == DISABLED
#   define VSF_ETH_CFG_REIMPLEMENT_TYPE_RECV_BUF_DESC DISABLED
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_SG_BUF_DESC == DISABLED
#    define VSF_ETH_CFG_REIMPLEMENT_TYPE_SG_BUF_DESC DISABLED
#endif
 
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_IRQ_MASK == DISABLED
#    define VSF_ETH_CFG_REIMPLEMENT_TYPE_IRQ_MASK DISABLED
#endif
 
#ifndef VSF_ETH_CFG_INHERIT_HAL_CAPABILITY
#   define VSF_ETH_CFG_INHERIT_HAL_CAPABILITY            ENABLED
#endif
 
/*============================ ETHROFIED FUNCTIONS ===========================*/
 
#define VSF_ETH_APIS(__prefix_name) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            eth, init,                   VSF_MCONNECT(__prefix_name, _t) *eth_ptr, vsf_eth_cfg_t *cfg_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, void,                 eth, fini,                   VSF_MCONNECT(__prefix_name, _t) *eth_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            eth, get_configuration,      VSF_MCONNECT(__prefix_name, _t) *eth_ptr, vsf_eth_cfg_t *cfg_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, fsm_rt_t,             eth, enable,                 VSF_MCONNECT(__prefix_name, _t) *eth_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, fsm_rt_t,             eth, disable,                VSF_MCONNECT(__prefix_name, _t) *eth_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, void,                 eth, irq_enable,             VSF_MCONNECT(__prefix_name, _t) *eth_ptr, vsf_eth_irq_mask_t irq_mask) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, void,                 eth, irq_disable,            VSF_MCONNECT(__prefix_name, _t) *eth_ptr, vsf_eth_irq_mask_t irq_mask) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            eth, send_request,           VSF_MCONNECT(__prefix_name, _t) *eth_ptr, vsf_eth_send_buf_desc_t *buf_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            eth, recv_request,           VSF_MCONNECT(__prefix_name, _t) *eth_ptr, vsf_eth_recv_buf_desc_t *buf_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            eth, send_sg_request,        VSF_MCONNECT(__prefix_name, _t) *eth_ptr, vsf_eth_send_sg_buf_desc_t *buf_ptr, uint32_t sg_count) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            eth, recv_sg_request,        VSF_MCONNECT(__prefix_name, _t) *eth_ptr, vsf_eth_recv_sg_buf_desc_t *buf_ptr, uint32_t sg_count) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            eth, ctrl,                   VSF_MCONNECT(__prefix_name, _t) *eth_ptr, vsf_eth_ctrl_t ctrl, void *param) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_eth_status_t,     eth, status,                 VSF_MCONNECT(__prefix_name, _t) *eth_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_eth_capability_t, eth, capability,             VSF_MCONNECT(__prefix_name, _t) *eth_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            eth, phy_set_mode,     VSF_MCONNECT(__prefix_name, _t) *eth_ptr, vsf_eth_phy_mode_t phy_mode) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            eth, phy_get_link_status,    VSF_MCONNECT(__prefix_name, _t) *eth_ptr, vsf_eth_phy_mode_t *phy_mode_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            eth, phy_read_reg,           VSF_MCONNECT(__prefix_name, _t) *eth_ptr, uint16_t reg_addr, uint32_t *value_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            eth, phy_write_reg,          VSF_MCONNECT(__prefix_name, _t) *eth_ptr, uint16_t reg_addr, uint32_t value)
 
 
/*============================ TYPES =========================================*/
 
 
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_PHY_MODE == DISABLED
typedef enum vsf_eth_phy_mode_t {
    VSF_ETH_PHY_MODE_SPEED_10M        = 1 << 0, 
    VSF_ETH_PHY_MODE_SPEED_100M       = 1 << 1, 
    VSF_ETH_PHY_MODE_SPEED_1000M      = 1 << 2, 
 
    VSF_ETH_PHY_MODE_DUPLEX_HALF      = 1 << 3, 
    VSF_ETH_PHY_MODE_DUPLEX_FULL      = 1 << 4, 
 
    VSF_ETH_PHY_MODE_LINK_UP          = 1 << 5, 
 
    //VSF_ETH_PHY_MODE_LINK_DOWN        = 1 << 6,
} vsf_eth_phy_mode_t;
#endif
 
 
enum {
#ifndef VSF_ETH_PHY_MODE_SPEED_MASK
    VSF_ETH_PHY_MODE_SPEED_MASK     = VSF_ETH_PHY_MODE_SPEED_10M | VSF_ETH_PHY_MODE_SPEED_100M | VSF_ETH_PHY_MODE_SPEED_1000M,
#endif
 
#ifndef VSF_ETH_PHY_MODE_DUPLEX_MASK
    VSF_ETH_PHY_MODE_DUPLEX_MASK    = VSF_ETH_PHY_MODE_DUPLEX_HALF | VSF_ETH_PHY_MODE_DUPLEX_FULL,
#endif
 
#ifndef VSF_ETH_PHY_MODE_ALL_BITS_MASK
    VSF_ETH_PHY_MODE_ALL_BITS_MASK  = VSF_ETH_PHY_MODE_SPEED_MASK | VSF_ETH_PHY_MODE_DUPLEX_MASK,
#endif
};
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_MODE == DISABLED
typedef enum vsf_eth_mode_t {
    VSF_ETH_MODE_TX_CHECKSUM_OFFLOAD = 1 << 5, 
    VSF_ETH_MODE_RX_CHECKSUM_OFFLOAD = 1 << 6, 
 
    /* The following modes are optional and can be enabled by removing the comments.
     * These modes depend on hardware support and might not be available on all hardware.
     */
 
    /* Address Filtering Options
     * ------------------------- */
    /*
    // \~english Enable filtering of unicast frames not addressed to this station
    // \~chinese 启用单播帧过滤，丢弃不是发往本站的单播帧
    VSF_ETH_MODE_UNICAST_FILTER       = 1 << 7,
 
    // \~english Enable filtering of multicast frames according to a filter table
    // \~chinese 启用多播帧过滤，根据过滤表过滤多播帧
    VSF_ETH_MODE_MULTICAST_FILTER     = 1 << 8,
 
    // \~english Enable filtering of broadcast frames
    // \~chinese 启用广播帧过滤，可选择是否接收广播帧
    VSF_ETH_MODE_BROADCAST_FILTER     = 1 << 9,
    */
 
    /* VLAN Support Options
     * --------------------
     * VLAN (Virtual LAN) allows network segmentation at Layer 2
     */
    /*
    // \~english Enable adding VLAN tags to outgoing frames
    // \~chinese 启用VLAN标签，向外发送的帧添加VLAN标签
    VSF_ETH_MODE_VLAN_TAGGING         = 1 << 10,
 
    // \~english Enable filtering frames based on VLAN ID
    // \~chinese 启用VLAN标签过滤，根据VLAN ID过滤接收的帧
    VSF_ETH_MODE_VLAN_FILTERING       = 1 << 11,
 
    // \~english Remove VLAN tags from received frames before passing to upper layer
    // \~chinese 启用VLAN标签剥离，在传递给上层前移除接收帧中的VLAN标签
    VSF_ETH_MODE_VLAN_STRIPPING       = 1 << 12,
 
    // \~english Insert VLAN tags into outgoing frames that don't have them
    // \~chinese 启用VLAN标签插入，向没有VLAN标签的外发帧插入标签
    VSF_ETH_MODE_VLAN_INSERTION       = 1 << 13,
    */
 
    /* Special Frame Handling
     * --------------------- */
    /*
    // \~english Support for frames larger than 1518 bytes (up to 9000 bytes typically)
    // \~chinese 支持巨型帧，允许处理大于1518字节的帧(通常最大可达9000字节)
    VSF_ETH_MODE_JUMBO_FRAME          = 1 << 14,
 
    // \~english Support IEEE 802.3x flow control mechanism to prevent buffer overflow
    // \~chinese 支持IEEE 802.3x流控制机制，防止缓冲区溢出
    VSF_ETH_MODE_FLOW_CONTROL         = 1 << 15,
 
    // \~english Support for pause frames which temporarily pause transmission
    // \~chinese 支持暂停帧，可临时暂停传输以控制数据流
    VSF_ETH_MODE_PAUSE_FRAME          = 1 << 16,
    */
 
    /* QoS and Traffic Management
     * ------------------------- */
    /*
    // \~english Support for multiple priority queues for traffic handling
    // \~chinese 支持优先级队列，根据优先级处理不同流量
    VSF_ETH_MODE_PRIORITY_QUEUE       = 1 << 17,
 
    // \~english Quality of Service support for traffic differentiation
    // \~chinese 服务质量支持，区分处理不同类型的流量
    VSF_ETH_MODE_QOS                  = 1 << 18,
    */
 
    /* Time Synchronization
     * ------------------- */
    /*
    // \~english Support for Precision Time Protocol timestamp for accurate timing
    // \~chinese 支持精确时间协议时间戳，用于精确计时
    VSF_ETH_MODE_PTP_TIMESTAMP        = 1 << 19,
    */
 
    /* Advanced Hardware Acceleration
     * ----------------------------- */
    /*
    // \~english TCP Segmentation Offload - hardware handles TCP segmentation
    // \~chinese TCP分段卸载 - 硬件处理TCP分段，减轻CPU负担
    VSF_ETH_MODE_TCP_SEGMENTATION     = 1 << 20,
 
    // \~english Large Receive Offload - hardware combines received TCP segments
    // \~chinese 大型接收卸载 - 硬件合并接收到的TCP分段，减少处理开销
    VSF_ETH_MODE_LARGE_RECEIVE        = 1 << 21,
    */
 
    /* These are examples of how to implement optional features.
     * Hardware drivers can define and implement these as needed.
     * For each enabled feature, corresponding MASK definitions should be added.
     */
} vsf_eth_mode_t;
#endif
 
enum {
#ifndef VSF_ETH_MODE_OFFLOAD_MASK
    VSF_ETH_MODE_OFFLOAD_MASK = VSF_ETH_MODE_RX_CHECKSUM_OFFLOAD | VSF_ETH_MODE_TX_CHECKSUM_OFFLOAD,
#endif
 
#ifndef VSF_ETH_MODE_ALL_BITS_MASK
    VSF_ETH_MODE_ALL_BITS_MASK = VSF_ETH_MODE_OFFLOAD_MASK,
#endif
};
 
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_IRQ_MASK == DISABLED
typedef enum vsf_eth_irq_mask_t {
    VSF_ETH_IRQ_MASK_RX_AVAILABLE    = (1 << 0), 
    VSF_ETH_IRQ_MASK_TX_COMPLETE     = (1 << 1), 
 
    VSF_ETH_IRQ_MASK_SG_RX_AVAILABLE = (1 << 2), 
    VSF_ETH_IRQ_MASK_SG_TX_COMPLETE  = (1 << 3), 
 
    VSF_ETH_IRQ_MASK_PHY_LINK_CHANGE = (1 << 4), 
 
    VSF_ETH_IRQ_MASK_ERROR           = (1 << 5), 
} vsf_eth_irq_mask_t;
#endif
 
enum {
#ifndef VSF_ETH_IRQ_MASK_ALL
    VSF_ETH_IRQ_MASK_ALL = VSF_ETH_IRQ_MASK_RX_AVAILABLE
                         | VSF_ETH_IRQ_MASK_TX_COMPLETE
                         | VSF_ETH_IRQ_MASK_SG_RX_AVAILABLE
                         | VSF_ETH_IRQ_MASK_SG_TX_COMPLETE
                         | VSF_ETH_IRQ_MASK_ERROR,
#endif
};
 
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_CFG == DISABLED
typedef struct vsf_eth_t vsf_eth_t;
 
typedef void vsf_eth_isr_handler_t(void *target_ptr, vsf_eth_t *eth_ptr,
                                    vsf_eth_irq_mask_t irq_mask);
 
typedef struct vsf_eth_isr_t {
    vsf_eth_isr_handler_t  *handler_fn; 
    void                   *target_ptr; 
    vsf_arch_prio_t         prio;        
} vsf_eth_isr_t;
 
typedef struct vsf_eth_cfg_t {
    vsf_eth_mode_t      mode;           
    vsf_eth_phy_mode_t  phy_mode;       
    uint8_t             mac_address[6]; 
    vsf_eth_isr_t       isr;            
} vsf_eth_cfg_t;
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_STATUS == DISABLED
typedef struct vsf_eth_status_t {
    union {
        inherit(vsf_peripheral_status_t)
        uint32_t value;
        struct {
            uint32_t is_rx_available         : 1; 
            uint32_t is_tx_ready             : 1; 
        };
    };
} vsf_eth_status_t;
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_CAPABILITY == DISABLED
typedef struct vsf_eth_capability_t {
#if VSF_ETH_CFG_INHERIT_HAL_CAPABILITY == ENABLED
    inherit(vsf_peripheral_capability_t)    
#endif
 
    vsf_eth_mode_t      support_modes;      
    vsf_eth_phy_mode_t  support_phy_modes;  
    vsf_eth_irq_mask_t  support_irq_mask;   
 
    union {
        uint32_t        value;
        struct {
            uint32_t    is_send_buf_releasable_immediately : 1;
 
            uint32_t    is_sg_send_buf_releasable_immediately : 1;
        };
    };
} vsf_eth_capability_t;
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_BUF_MODE == DISABLED
typedef enum vsf_eth_buf_mode_t {
    VSF_ETH_BUF_MODE_TX_CHECKSUM_OFFLOAD = 1 << 0, 
    VSF_ETH_BUF_MODE_RX_CHECKSUM_OFFLOAD = 1 << 1, 
 
    // TODO: Add more modes as needed
} vsf_eth_buf_mode_t;
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_BUF_DESC == DISABLED
typedef struct vsf_eth_buf_desc_t {
    vsf_eth_buf_mode_t mode;
    void               *payload;
    size_t             len;
} vsf_eth_buf_desc_t;
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_SEND_BUF_DESC == DISABLED
typedef vsf_eth_buf_desc_t vsf_eth_send_buf_desc_t;
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_RECV_BUF_DESC == DISABLED
typedef vsf_eth_buf_desc_t vsf_eth_recv_buf_desc_t;
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_SG_SEND_BUF == DISABLED
typedef vsf_eth_buf_desc_t vsf_eth_send_sg_buf_desc_t;
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_SG_RECV_BUF == DISABLED
typedef vsf_eth_buf_desc_t vsf_eth_recv_sg_buf_desc_t;
#endif
 
#if VSF_ETH_CFG_REIMPLEMENT_TYPE_CTRL == DISABLED
typedef enum vsf_eth_ctrl_t {
    VSF_ETH_CTRL_GET_MAC_ADDRESS, 
 
    /* IEEE 802.3 Clause 45 Configuration Commands */
    /*
    VSF_ETH_CTRL_PHY_C45_READ_REG,      //!< \~english Read PHY register using Clause 45 access (vsf_eth_phy_c45_reg_access_t *) \~chinese 使用 Clause 45 访问方式读取 PHY 寄存器 (vsf_eth_phy_c45_reg_access_t *)
    VSF_ETH_CTRL_PHY_C45_WRITE_REG,     //!< \~english Write PHY register using Clause 45 access (vsf_eth_phy_c45_reg_access_t *) \~chinese 使用 Clause 45 访问方式写入 PHY 寄存器 (vsf_eth_phy_c45_reg_access_t *)
    */
 
    /* PLCA (Physical Layer Collision Avoidance) Configuration Commands - For 10BASE-T1S Ethernet */
    /*
    VSF_ETH_CTRL_PHY_PLCA_ENABLE,       //!< \~english Enable PLCA operation (bool) \~chinese 启用 PLCA 操作 (bool)
    VSF_ETH_CTRL_PHY_PLCA_GET_STATUS,   //!< \~english Get PLCA status (bool *) \~chinese 获取 PLCA 状态 (bool *)
    VSF_ETH_CTRL_PHY_PLCA_SET_NODE_ID,  //!< \~english Set PLCA node ID (uint8_t) \~chinese 设置 PLCA 节点 ID (uint8_t)
    VSF_ETH_CTRL_PHY_PLCA_SET_NODE_COUNT, //!< \~english Set PLCA node count (uint8_t) \~chinese 设置 PLCA 节点数量 (uint8_t)
    VSF_ETH_CTRL_PHY_PLCA_SET_BURST_COUNT, //!< \~english Set PLCA burst count (uint8_t) \~chinese 设置 PLCA 突发计数 (uint8_t)
    VSF_ETH_CTRL_PHY_PLCA_SET_BURST_TIMER, //!< \~english Set PLCA burst timer (uint8_t) \~chinese 设置 PLCA 突发计时器 (uint8_t)
    */
 
    // TODO: Add more control commands as needed
} vsf_eth_ctrl_t;
#endif
 
typedef struct vsf_eth_op_t {
#undef  __VSF_HAL_TEMPLATE_API
#define __VSF_HAL_TEMPLATE_API VSF_HAL_TEMPLATE_API_FP
 
    VSF_ETH_APIS(vsf_eth)
} vsf_eth_op_t;
 
 
#if VSF_ETH_CFG_MULTI_CLASS == ENABLED
struct vsf_eth_t  {
    const vsf_eth_op_t * op;
};
#endif
 
/*============================ PROTOTYPES ====================================*/
 
extern vsf_err_t vsf_eth_init(vsf_eth_t *eth_ptr, vsf_eth_cfg_t *cfg_ptr);
 
extern void vsf_eth_fini(vsf_eth_t *eth_ptr);
 
extern vsf_err_t vsf_eth_get_configuration(vsf_eth_t *eth_ptr, vsf_eth_cfg_t *cfg_ptr);
 
extern fsm_rt_t vsf_eth_enable(vsf_eth_t *eth_ptr);
 
extern fsm_rt_t vsf_eth_disable(vsf_eth_t *eth_ptr);
 
extern void vsf_eth_isr_enable(vsf_eth_t *eth_ptr, vsf_eth_irq_mask_t isr_mask);
 
extern void vsf_eth_isr_disable(vsf_eth_t *eth_ptr, vsf_eth_irq_mask_t isr_mask);
 
extern vsf_eth_status_t vsf_eth_status(vsf_eth_t *eth_ptr);
 
extern vsf_eth_capability_t vsf_eth_capability(vsf_eth_t *eth_ptr);
 
extern vsf_err_t vsf_eth_send_request(vsf_eth_t *eth_ptr, vsf_eth_send_buf_desc_t *buf_ptr);
 
extern vsf_err_t vsf_eth_send_sg_request(vsf_eth_t *eth_ptr, vsf_eth_send_sg_buf_desc_t *sg_ptr, uint32_t sg_count);
 
 
extern vsf_err_t vsf_eth_recv_request(vsf_eth_t *eth_ptr, vsf_eth_recv_buf_desc_t *buf_ptr);
 
extern vsf_err_t vsf_eth_recv_sg_request(vsf_eth_t *eth_ptr, vsf_eth_recv_sg_buf_desc_t *sg_ptr, uint32_t sg_count);
 
extern vsf_err_t vsf_eth_ctrl(vsf_eth_t *eth_ptr, vsf_eth_ctrl_t ctrl, void *param);
 
extern vsf_err_t vsf_eth_phy_read_reg(vsf_eth_t *eth_ptr, uint16_t reg_addr, uint32_t *value_ptr);
 
extern vsf_err_t vsf_eth_phy_write_reg(vsf_eth_t *eth_ptr, uint16_t reg_addr, uint32_t value);
 
extern vsf_err_t vsf_eth_phy_set_mode(vsf_eth_t *eth_ptr, vsf_eth_phy_mode_t mode);
extern vsf_err_t vsf_eth_phy_get_link_status(vsf_eth_t *eth_ptr, vsf_eth_phy_mode_t *phy_mode_ptr);
 
/*============================ ETHROFIED FUNCTIONS ===========================*/
 
#if VSF_ETH_CFG_FUNCTION_RENAME == ENABLED
#   define __vsf_eth_t                              VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_t)
#   define vsf_eth_init(__ETH, ...)                 VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_init)((__vsf_eth_t *)(__ETH), ##__VA_ARGS__)
#   define vsf_eth_fini(__ETH)                      VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_fini)((__vsf_eth_t *)(__ETH))
#   define vsf_eth_get_configuration(__ETH, ...)    VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_get_configuration)((__vsf_eth_t *)(__ETH), ##__VA_ARGS__)
#   define vsf_eth_enable(__ETH)                    VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_enable)((__vsf_eth_t *)(__ETH))
#   define vsf_eth_disable(__ETH)                   VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_disable)((__vsf_eth_t *)(__ETH))
#   define vsf_eth_status(__ETH)                    VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_status)((__vsf_eth_t *)(__ETH))
#   define vsf_eth_capability(__ETH)                VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_capability)((__vsf_eth_t *)(__ETH))
#   define vsf_eth_send_request(__ETH, ...)         VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_send_request)((__vsf_eth_t *)(__ETH), ##__VA_ARGS__)
#   define vsf_eth_send_sg_request(__ETH, ...)      VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_send_sg_request)((__vsf_eth_t *)(__ETH), ##__VA_ARGS__)
#   define vsf_eth_recv_request(__ETH, ...)         VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_recv_request)((__vsf_eth_t *)(__ETH), ##__VA_ARGS__)
#   define vsf_eth_recv_sg_request(__ETH, ...)      VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_recv_sg_request)((__vsf_eth_t *)(__ETH), ##__VA_ARGS__)
#   define vsf_eth_ctrl(__ETH, ...)                 VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_ctrl)((__vsf_eth_t *)(__ETH), ##__VA_ARGS__)
#   define vsf_eth_phy_read_reg(__ETH, ...)         VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_phy_read_reg)((__vsf_eth_t *)(__ETH), ##__VA_ARGS__)
#   define vsf_eth_phy_write_reg(__ETH, ...)        VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_phy_write_reg)((__vsf_eth_t *)(__ETH), ##__VA_ARGS__)
#   define vsf_eth_phy_set_mode(__ETH, ...)         VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_phy_set_mode)((__vsf_eth_t *)(__ETH), ##__VA_ARGS__)
#   define vsf_eth_phy_get_link_status(__ETH, ...)  VSF_MCONNECT(VSF_ETH_CFG_PREFIX, _eth_phy_get_link_status)((__vsf_eth_t *)(__ETH), ##__VA_ARGS__)
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif  /*__VSF_TEMPLATE_ETH_H__*/