enet_types.h

Go to the documentation of this file.

/*
 *  Copyright (c) Texas Instruments Incorporated 2020
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef ENET_TYPES_H_
#define ENET_TYPES_H_
 
/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */
 
#include <stdint.h>
#include <stdbool.h>
#include <drivers/hw_include/csl_types.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ========================================================================== */
/*                                 Macros                                     */
/* ========================================================================== */
 
/* Enet driver error codes are same as CSL's to maintain consistency */
 
#define ENET_SOK                              (CSL_PASS)
 
#define ENET_SINPROGRESS                      (1)
 
#define ENET_EFAIL                            (CSL_EFAIL)
 
#define ENET_EBADARGS                         (CSL_EBADARGS)
 
#define ENET_EINVALIDPARAMS                   (CSL_EINVALID_PARAMS)
 
#define ENET_ETIMEOUT                         (CSL_ETIMEOUT)
 
#define ENET_EALLOC                           (CSL_EALLOC)
 
#define ENET_EUNEXPECTED                      (CSL_EALLOC - 1)
 
#define ENET_EBUSY                            (CSL_EALLOC - 2)
 
#define ENET_EALREADYOPEN                     (CSL_EALLOC - 3)
 
#define ENET_EPERM                            (CSL_EALLOC - 4)
 
#define ENET_ENOTSUPPORTED                    (CSL_EALLOC - 5)
 
#define ENET_ENOTFOUND                        (CSL_EALLOC - 6)
 
#define ENET_EUNKNOWNIOCTL                    (CSL_EALLOC - 7)
 
#define ENET_EMALFORMEDIOCTL                  (CSL_EALLOC - 8)
 
#define ENET_ARRAYSIZE(x)                     (sizeof(x) / sizeof(x[0]))
 
#define ENET_BIT(n)                           (1U << (n))
 
#define ENET_GET_BIT(val, n)                  (((val) & ENET_BIT(n)) >> (n))
 
#define ENET_IS_BIT_SET(val, n)               (((val) & ENET_BIT(n)) != 0U)
 
#define ENET_NOT_ZERO(val)                    ((uint32_t)0U != (uint32_t)(val))
 
#define ENET_FEXT(reg, PER_REG_FIELD)                                        \
    (((reg) & PER_REG_FIELD##_MASK) >> PER_REG_FIELD##_SHIFT)
 
#define ENET_FINS(reg, PER_REG_FIELD, val)                                   \
    ((reg) = ((reg) & ~PER_REG_FIELD##_MASK)                                 \
      | (((val) << PER_REG_FIELD##_SHIFT) & PER_REG_FIELD##_MASK))
 
#define ENET_DIV_ROUNDUP(val, div)            (((val) + (div) - 1) / (div))
 
#define ENET_VERSION_NONE                     (0xFFFFFFFFU)
 
#define ENET_MAC_ADDR_LEN                     (6U)
 
#define ENET_OUI_ADDR_LEN                     (3U)
 
#define ENET_IPv4_ADDR_LEN                    (4U)
 
#define ENET_IPv6_ADDR_LEN                    (16U)
 
#define ENET_PRI_NUM                          (8U)
 
#define ENET_PRI_MIN                          (0U)
 
#define ENET_PRI_MAX                          (ENET_PRI_NUM - 1U)
 
#define ENET_TOS_PRI_NUM                      (64U)
 
#define ENET_TOS_PRI_MIN                      (0U)
 
#define ENET_TOS_PRI_MAX                      (ENET_TOS_PRI_NUM - 1U)
 
#define ENET_VLAN_ID_MAX                      (4095U)
 
#define ENET_ETHERTYPE_PTP                    (0x88F7U)
 
/* ========================================================================== */
/*                         Structures and Enums                               */
/* ========================================================================== */
 
typedef enum Enet_Type_e
{
    ENET_NULL,
 
    ENET_ICSSG_DUALMAC,
 
    ENET_ICSSG_SWITCH,
 
    ENET_GMAC_3G,
 
    ENET_CPSW_2G,
 
    ENET_CPSW_3G,
 
    ENET_CPSW_5G,
 
    ENET_CPSW_9G,
 
    ENET_TYPE_COUNT,
} Enet_Type;
 
#define ENET_TYPE_NUM                         (ENET_TYPE_COUNT + 1U)
 
typedef enum Enet_Magic_e
{
    ENET_MAGIC = 0xABABABABU,
 
    ENET_NO_MAGIC = 0x0U,
} Enet_Magic;
 
typedef enum Enet_CrcType_e
{
    ENET_CRC_ETHERNET   = 0U,
 
    ENET_CRC_CASTAGNOLI,
} Enet_CrcType;
 
typedef enum Enet_Event_e
{
    ENET_EVT_NONE = 0U,
 
    ENET_EVT_ASYNC_CMD_RESP = ENET_BIT(0U),
 
    ENET_EVT_TIMESTAMP_SWPUSH = ENET_BIT(1U),
 
    ENET_EVT_TIMESTAMP_HWPUSH = ENET_BIT(2U),
 
    ENET_EVT_TIMESTAMP_ROLLOVER = ENET_BIT(3U),
 
    ENET_EVT_TIMESTAMP_HALFROLLOVER = ENET_BIT(4U),
 
    ENET_EVT_TIMESTAMP_RX = ENET_BIT(5U),
 
    ENET_EVT_TIMESTAMP_TX = ENET_BIT(6U),
 
    ENET_EVT_TIMESTAMP_COMP = ENET_BIT(7U),
 
    ENET_EVT_TIMESTAMP_HOSTTX = ENET_BIT(8U),
 
    ENET_EVT_ANY = 0xFFFFFFFFU,
} Enet_Event;
 
typedef struct Enet_Version_s
{
    uint32_t maj;
 
    uint32_t min;
 
    uint32_t rtl;
 
    uint32_t id;
 
    uint32_t other1;
 
    uint32_t other2;
} Enet_Version;
 
typedef enum Enet_Speed_e
{
    ENET_SPEED_10MBIT = 0U,
 
    ENET_SPEED_100MBIT,
 
    ENET_SPEED_1GBIT,
 
    ENET_SPEED_AUTO,
} Enet_Speed;
 
typedef enum Enet_Duplexity_e
{
    ENET_DUPLEX_HALF = 0U,
 
    ENET_DUPLEX_FULL,
 
    ENET_DUPLEX_AUTO,
} Enet_Duplexity;
 
typedef enum Enet_VlanTagType_e
{
    ENET_VLAN_TAG_TYPE_INNER = 0U,
 
    ENET_VLAN_TAG_TYPE_OUTER,
} Enet_VlanTagType;
 
typedef struct Enet_VlanTag_s
{
    uint16_t tpid;
 
    uint8_t pcp;
 
    uint8_t dei;
 
    uint16_t vlanId;
 
    Enet_VlanTagType tagType;
} Enet_VlanTag;
 
typedef enum Enet_MacPort_e
{
    ENET_MAC_PORT_FIRST = 0U,
 
    ENET_MAC_PORT_1     = ENET_MAC_PORT_FIRST,
 
    ENET_MAC_PORT_2     = 1U,
 
    ENET_MAC_PORT_3     = 2U,
 
    ENET_MAC_PORT_4     = 3U,
 
    ENET_MAC_PORT_5     = 4U,
 
    ENET_MAC_PORT_6     = 5U,
 
    ENET_MAC_PORT_7     = 6U,
 
    ENET_MAC_PORT_8     = 7U,
 
    ENET_MAC_PORT_LAST  = ENET_MAC_PORT_8,
} Enet_MacPort;
 
typedef void (*Enet_EventCallback)(Enet_Event evt,
                                   uint32_t evtNum,
                                   void *evtCbArgs,
                                   void *arg1,
                                   void *arg2);
 
#define ENET_MAC_PORT_NUM                     ((uint32_t)ENET_MAC_PORT_LAST + 1U)
 
#define ENET_MACPORT_NORM(n)                  ((n) - ENET_MAC_PORT_FIRST)
 
#define ENET_MACPORT_DENORM(n)                ((Enet_MacPort)((n) + ENET_MAC_PORT_FIRST))
 
#define ENET_MACPORT_ID(n)                    ((n) - ENET_MAC_PORT_FIRST + 1U)
 
#define ENET_MAC_PORT_INV                     ((Enet_MacPort)0xFFFFU)
 
#define ENET_TRAFFIC_CLASS_INV                ((uint32_t)0xFFFFU)
 
#define ENET_MACPORT_MASK(n)                  (ENET_BIT(ENET_MACPORT_NORM(n)))
 
/* ========================================================================== */
/*                         Global Variables Declarations                      */
/* ========================================================================== */
 
/* None */
 
/* ========================================================================== */
/*                          Function Declarations                             */
/* ========================================================================== */
 
static inline bool Enet_isCpswFamily(Enet_Type enetType);
 
static inline bool Enet_isIcssFamily(Enet_Type enetType);
 
/* ========================================================================== */
/*                        Deprecated Function Declarations                    */
/* ========================================================================== */
 
/* None */
 
/* ========================================================================== */
/*                       Static Function Definitions                          */
/* ========================================================================== */
 
static inline bool Enet_isCpswFamily(Enet_Type enetType)
{
    return ((enetType == ENET_GMAC_3G) ||
            (enetType == ENET_CPSW_2G) ||
            (enetType == ENET_CPSW_3G) ||
            (enetType == ENET_CPSW_5G) ||
            (enetType == ENET_CPSW_9G));
}
 
static inline bool Enet_isIcssFamily(Enet_Type enetType)
{
    return ((enetType == ENET_ICSSG_DUALMAC) ||
            (enetType == ENET_ICSSG_SWITCH));
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* ENET_TYPES_H_ */