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 <ti/csl/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_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_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_ */