rt-thread/bsp/CME_M7/StdPeriph_Driver/inc/cmem7_eth.h

/**
    *****************************************************************************
    * @file     cmem7_eth.h
    *
    * @brief    CMEM7 ethernet header file
    *
    *
    * @version  V1.0
    * @date     3. September 2013
    *
    * @note
    *
    *****************************************************************************
    * @attention
    *
    * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
    * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
    * TIME. AS A RESULT, CAPITAL-MICRO SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
    * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
    * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
    * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
    *
    * <h2><center>&copy; COPYRIGHT 2013 Capital-micro </center></h2>
    *****************************************************************************
    */

#ifndef __CMEM7_ETH_H
#define __CMEM7_ETH_H

#ifdef __cplusplus
 extern "C" {
#endif

#include "cmem7.h"
#include "cmem7_conf.h"

/** @defgroup ETH_SPEED
  * @{
  */
#define ETH_SPEED_10M               0x0
#define ETH_SPEED_100M              0x1
#define ETH_SPEED_1000M             0x2

#define IS_ETH_SPEED(SPEED)             (((SPEED) == ETH_SPEED_10M)  || \
                                     ((SPEED) == ETH_SPEED_100M) || \
                                                                         ((SPEED) == ETH_SPEED_1000M))
/**
  * @}
  */

/** @defgroup ETH_DUPLEX
  * @{
  */
#define ETH_DUPLEX_HALF             0x0
#define ETH_DUPLEX_FULL             0x1

#define IS_ETH_DUPLEX(DUPLEX)           (((DUPLEX) == ETH_DUPLEX_HALF) || \
                                                                         ((DUPLEX) == ETH_DUPLEX_FULL))
/**
  * @}
  */

/** @defgroup ETH_INT
  * @{
  */
#define ETH_INT_TX_COMPLETE_FRAME       0x0001
#define ETH_INT_TX_STOP             0x0002
#define ETH_INT_TX_BUF_UNAVAI       0x0004
#define ETH_INT_RX_OVERFLOW                 0x0010
#define ETH_INT_TX_UNDERFLOW                0x0020
#define ETH_INT_RX_COMPLETE_FRAME   0x0040
#define ETH_INT_RX_BUF_UNAVAI       0x0080
#define ETH_INT_RX_STOP             0x0100
#define ETH_INT_BUS_FATAL_ERROR     0x2000
#define ETH_INT_ALL                 (ETH_INT_TX_COMPLETE_FRAME | \
                                     ETH_INT_TX_STOP           | \
                                                                         ETH_INT_TX_BUF_UNAVAI     | \
                                                                         ETH_INT_RX_OVERFLOW       | \
                                                                         ETH_INT_TX_UNDERFLOW      | \
                                                                         ETH_INT_RX_COMPLETE_FRAME | \
                                                                         ETH_INT_RX_BUF_UNAVAI     | \
                                                                         ETH_INT_RX_STOP           | \
                                                                         ETH_INT_BUS_FATAL_ERROR)

#define IS_ETH_INT(INT)             (((INT) != 0) && (((INT) & ~ETH_INT_ALL) == 0))
/**
  * @}
  */
/**
  * @brief  EFUSE receive filter structure
    */
typedef struct
{
    BOOL ETH_BroadcastFilterEnable;   /*!< Broadcast is dropped or passed                                       */
    BOOL ETH_OwnFilterEnable;           /*!< source address filter is on or off                                 */
    BOOL ETH_SelfDrop;                          /*!< Only own address is dropped or passed                              */
    BOOL ETH_SourceFilterEnable;        /*!< source address filter is on or off                                 */
    BOOL ETH_SourceDrop;                      /*!< Only specific source address is dropped or passed    */
    uint8_t ETH_SourceMacAddr[6];     /*!< Source MAC address                                   */
} ETH_FrameFilter;

/**
  * @brief  Ethernet initialization structure
    */
typedef struct
{
    BOOL ETH_LinkUp;                   /*!< If ETH is linked up and it can be retrieved from PHY */
    uint8_t ETH_Speed;                 /*!< speed of ETH, refer as @ref ETH_SPEED                */
    uint8_t ETH_Duplex;                /*!< duplex mode of ETH, refer as @ref ETH_DUPLEX                 */
    BOOL ETH_RxEn;                     /*!< Rx enable                                            */
    BOOL ETH_TxEn;                     /*!< Tx enable                                            */
    BOOL ETH_ChecksumOffload;          /*!< Checksum offload enable                              */
    BOOL ETH_JumboFrame;               /*!< Jumbo Frame Enable                                   */
    uint8_t ETH_MacAddr[6];            /*!< MAC address                                          */
    ETH_FrameFilter *ETH_Filter;       /*!< Received frame address filter, receive all if null   */
} ETH_InitTypeDef;

/**
  * @brief  Ethernet Tx descriptor structure
    */
typedef struct {
    union {
    uint32_t  TX0;

        struct {
            uint32_t                                :  1;
            uint32_t UNDERFLOW_ERR  :  1;    /*!< [OUT] Underflow error                                                     */
            uint32_t                                :  1;
            uint32_t COLLISION_CNT  :  4;        /*!< [OUT] Collision count                                       */
            uint32_t                                :  1;
            uint32_t EX_COLLISION   :  1;        /*!< [OUT] Excessive collision error                         */
            uint32_t LATE_COLLISION :  1;        /*!< [OUT] Late collision error                              */
            uint32_t NO_CARRIER     :  1;        /*!< [OUT] No carrier error                                    */
            uint32_t LOSS_CARRIER   :  1;        /*!< [OUT] loss of carrier error                           */
            uint32_t PAYLOAD_ERR        :  1;        /*!< [OUT] IP payload error                                    */
            uint32_t                                :  2;
            uint32_t ERR_SUM                :  1;        /*!< [OUT] Error summary                                           */
            uint32_t HEADER_ERR         :  1;        /*!< [OUT] IP header error                                         */
            uint32_t                                :  8;
            uint32_t TTSE           :  1;    /*!< enables IEEE1588 hardware timestamping in first segment */
            uint32_t                                :  2;
            uint32_t FS             :  1;    /*!< first segment flag                                    */
            uint32_t LS             :  1;    /*!< last segment flag                                     */
            uint32_t                                :  2;
        } TX0_b;
    } TX_0;

    union {
    uint32_t  TX1;

        struct {
            uint32_t SIZE                       : 13;       /*!< buffer size                                       */
            uint32_t                : 19;
        } TX1_b;
    } TX_1;

    uint32_t bufAddr;                                           /*!< address of buffer                                           */
    uint32_t nextDescAddr;                              /*!< address of next descriptor                          */
  uint64_t reserved;
    uint64_t timeStamp;                                     /*!< time stamp while last segment                     */
} ETH_TX_DESC;

/**
  * @brief  Ethernet Rx descriptor structure
    */
typedef struct {
    union {
    uint32_t  RX0;

        struct {
            uint32_t                                :  1;
            uint32_t CRC_ERR        :  1;    /*!< [OUT] CRC error while last segment                        */
            uint32_t                                :  5;
            uint32_t TTSE           :  1;    /*!< timestamp available while last segment                */
            uint32_t LS             :  1;    /*!< [OUT] last segment flag                               */
            uint32_t FS             :  1;    /*!< [OUT] first segment flag                              */
            uint32_t                                :  1;
            uint32_t OVERFLOW_ERR   :  1;    /*!< [OUT] FIFO overflow while last segment                */
            uint32_t LENGTH_ERR     :  1;    /*!< [OUT] length error while last segment                 */
            uint32_t                                :  2;
            uint32_t ERR_SUM        :  1;    /*!< [OUT] Error summary while last segment                */
            uint32_t FL             : 14;    /*!< [OUT] frame length while last segment                 */
            uint32_t                    :  2;
        } RX0_b;
    } RX_0;

    union {
    uint32_t  RX1;

        struct {
            uint32_t SIZE                       : 13;       /*!< buffer size                                       */
            uint32_t                : 19;
        } RX1_b;
    } RX_1;

    uint32_t bufAddr;                                           /*!< buffer address                                    */
    uint32_t nextDescAddr;                              /*!< address of next descriptor                        */
  uint64_t reserved;
    uint64_t timeStamp;                                     /*!< time stamp while the last segment                 */
} ETH_RX_DESC;

/**
  * @brief  Read data from phy chip
    * @param[in] phyAddr Address of phy chip
    * @param[in] phyReg Address of phy's register to be read
  * @retval uint32_t value of phy's register
    */
uint32_t ETH_PhyRead(uint32_t phyAddr, uint32_t phyReg);

/**
  * @brief  Write data to phy chip
    * @param[in] phyAddr Address of phy chip
    * @param[in] phyReg Address of phy's register to be written
    * @param[in] data Data to be written
  * @retval None
    */
void ETH_PhyWrite(uint32_t phyAddr, uint32_t phyReg, uint32_t data);
/**
  * @brief  Fills each ETH_InitStruct member with its default value.
  * @param ETH_InitStruct: pointer to a ETH_InitTypeDef structure
  *   which will be initialized.
  * @retval : None
  */
void ETH_StructInit(ETH_InitTypeDef* init);
/**
  * @brief  Ethernet initialization
  * @note   This function should be called at first before any other interfaces.
    * @param[in] init A pointer to structure ETH_InitTypeDef
  * @retval BOOL The bit indicates if ethernet is initialized successfully
    */
BOOL ETH_Init(ETH_InitTypeDef *init);

/**
  * @brief  Enable or disable ethernet interrupt.
    * @param[in] Int interrupt mask bits, which can be the combination of @ref ETH_INT
    * @param[in] Enable The bit indicates if specific interrupts are enable or not
  * @retval None
    */
void ETH_ITConfig(uint32_t Int, BOOL enable);

/**
  * @brief  Check specific interrupts are set or not
    * @param[in] Int interrupt mask bits, which can be the combination of @ref ETH_INT
  * @retval BOOL The bit indicates if specific interrupts are set or not
    */
BOOL ETH_GetITStatus(uint32_t Int);

/**
  * @brief  Clear specific interrupts
    * @param[in] Int interrupt mask bits, which can be the combination of @ref ETH_INT
  * @retval None
    */
void ETH_ClearITPendingBit(uint32_t Int);

/**
  * @brief  Get ethernte MAC address
    * @param[in] mac A user-allocated buffer to fetch MAC to be read, 6 bytes.
    * @retval None
    */
void ETH_GetMacAddr(uint8_t *mac);

/**
  * @brief  Set ethernet transmission descriptor ring
    * @note     Make sure that memory occupied by descriptors should be in physical
    *                   memory and keep valid before ethernet transmission is finished.
    * @param[in] ring A pointer to header of ETH_TX_DESC ring, whose last node
    *                   has a 'nextDescAddr' pointed to first node.
  * @retval BOOL The bit indicates if valid ring is set
    */
BOOL ETH_SetTxDescRing(ETH_TX_DESC *ring);

/**
  * @brief  Start ethernet transmission
    * @param    None
  * @retval None
    */
void ETH_StartTx(void);

/**
  * @brief  Stop ethernet transmission
    * @param    None
  * @retval None
    */
void ETH_StopTx(void);

/**
  * @brief  Resume ethernet transmission\n
    *               While ethernet doesn't have enough buffer to transmit data, it will
    *                   pause and inform users by interrupt 'ETH_INT_TX_BUF_UNAVAI'. Users
    *                   must call this function to start ethernet again after new buffer
    *                   prepared.
    * @param    None
  * @retval None
    */
void ETH_ResumeTx(void);

/**
  * @brief  Get free transmission descriptor\n
    * @param    None
  * @retval ETH_TX_DESC* A pointer of free transmission descriptor,
    *                   NULL if no free descriptor
    */
ETH_TX_DESC *ETH_AcquireFreeTxDesc(void);

/**
  * @brief  Check if a transmission descriptor is free or not
    * @param[in] desc A pointer of a transmission descriptor
  * @retval BOOL True if the transmission descriptor is free, or flase.
    */
BOOL ETH_IsFreeTxDesc(ETH_TX_DESC *desc);

/**
  * @brief  Release a transmission descriptor to ethernet\n
    *                   After users prepared data in the buffer of a free descriptor,
    *                   They must call this function to change ownership of the
    *                   descriptor to hardware.
    * @param[in] desc A pointer of a transmission descriptor
  * @retval None
    */
void ETH_ReleaseTxDesc(ETH_TX_DESC *desc);

/**
  * @brief  Set buffer address of the specific TX descriptor
    * @param[in] desc A pointer of a transmission descriptor
  * @param[in] bufAddr buffer address to be sent
  * @retval None
    */
void ETH_SetTxDescBufAddr(ETH_TX_DESC *desc, uint32_t bufAddr);

/**
  * @brief  Get buffer address of the specific TX descriptor
    * @param[in] desc A pointer of a transmission descriptor
  * @retval uint32_t buffer address to be gotten
    */
uint32_t ETH_GetTxDescBufAddr(ETH_TX_DESC *desc);

/**
  * @brief  Set ethernet receive descriptor ring
    * @note     Make sure that memory occupied by descriptors should be in physical
    *                   memory and keep valid before ethernet receive is finished.
    * @param[in] ring A pointer to header of ETH_TX_DESC ring, whose last node
    *                   has a 'nextDescAddr' pointed to first node.
  * @retval BOOL The bit indicates if valid ring is set
    */
BOOL ETH_SetRxDescRing(ETH_RX_DESC *ring);

/**
  * @brief  Start ethernet receive
    * @param    None
  * @retval None
    */
void ETH_StartRx(void);

/**
  * @brief  Stop ethernet receive
    * @param    None
  * @retval None
    */
void ETH_StopRx(void);

/**
  * @brief  Resume ethernet receive\n
    *               While ethernet doesn't have enough buffer to receive data, it will
    *                   pause and inform users by interrupt 'ETH_INT_RX_BUF_UNAVAI'. Users
    *                   must call this function to start ethernet again after new buffer
    *                   prepared.
    * @param    None
  * @retval None
    */
void ETH_ResumeRx(void);

/**
  * @brief  Get the free descriptor which contains received data\n
    * @param    None
  * @retval ETH_RX_DESC* A pointer of free receive descriptor,
    *                   NULL if no free descriptor
    */
ETH_RX_DESC *ETH_AcquireFreeRxDesc(void);

/**
  * @brief  Check if a receive descriptor is free or not
    * @param[in] desc A pointer of a receive descriptor
  * @retval BOOL True if the receive descriptor is free, or flase.
    */
BOOL ETH_IsFreeRxDesc(ETH_RX_DESC *desc);

/**
  * @brief  Release a receive descriptor to ethernet\n
    *                   After users handled data in the buffer of a free descriptor,
    *                   They must call this function to change ownership of the
    *                   descriptor to hardware.
    * @param[in] desc A pointer of a transmission descriptor
  * @retval None
    */
void ETH_ReleaseRxDesc(ETH_RX_DESC *desc);

/**
  * @brief  Set buffer address of the specific RX descriptor
    * @param[in] desc A pointer of a receive descriptor
  * @param[in] bufAddr buffer address to be received
  * @retval None
    */
void ETH_SetRxDescBufAddr(ETH_RX_DESC *desc, uint32_t bufAddr);

/**
  * @brief  Get buffer address of the specific RX descriptor
    * @param[in] desc A pointer of a receive descriptor
  * @retval uint32_t buffer address to be gotten
    */
uint32_t ETH_GetRxDescBufAddr(ETH_RX_DESC *desc);

#ifdef __cplusplus
}
#endif

#endif /* __CMEM7_ETH_H */