enet_ioctl.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_IOCTL_H_
#define ENET_IOCTL_H_
 
/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */
 
#include <stdint.h>
#include <stdbool.h>
#include <enet_cfg.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ========================================================================== */
/*                                 Macros                                     */
/* ========================================================================== */
 
#define ENET_IOCTL_TYPE_OFFSET                (24U)
 
#define ENET_IOCTL_PER_OFFSET                 (16U)
 
#define ENET_IOCTL_MAJOR_OFFSET               (8U)
 
#define ENET_IOCTL_MINOR_OFFSET               (0U)
 
#define ENET_IOCTL_GET_TYPE(x)                ((x) & 0xFF000000U)
 
#define ENET_IOCTL_GET_PER(x)                 ((x) & 0x00FF0000U)
 
#define ENET_IOCTL_GET_MAJ(x)                 ((x) & 0x0000FF00U)
 
#define ENET_IOCTL_GET_MIN(x)                 ((x) & 0x000000FFU)
 
#define ENET_IOCTL_TYPE(x)                    ((x) << ENET_IOCTL_TYPE_OFFSET)
 
#define ENET_IOCTL_PER(x)                     ((x) << ENET_IOCTL_PER_OFFSET)
 
#define ENET_IOCTL_MAJ(x)                     ((x) << ENET_IOCTL_MAJOR_OFFSET)
 
#define ENET_IOCTL_MIN(x)                     ((x) << ENET_IOCTL_MINOR_OFFSET)
 
#define ENET_IOCTL_SET_NO_ARGS(prms) \
    {                                \
        (prms)->inArgs      = NULL;  \
        (prms)->inArgsSize  = 0U;    \
        (prms)->outArgs     = NULL;  \
        (prms)->outArgsSize = 0U;    \
    }
 
#define ENET_IOCTL_SET_IN_ARGS(prms, in)     \
    {                                        \
        (prms)->inArgs      = (in);          \
        (prms)->inArgsSize  = sizeof(*(in)); \
        (prms)->outArgs     = NULL;          \
        (prms)->outArgsSize = 0U;            \
    }
 
#define ENET_IOCTL_SET_OUT_ARGS(prms, out)    \
    {                                         \
        (prms)->inArgs      = NULL;           \
        (prms)->inArgsSize  = 0U;             \
        (prms)->outArgs     = (out);          \
        (prms)->outArgsSize = sizeof(*(out)); \
    }
 
#define ENET_IOCTL_SET_INOUT_ARGS(prms, in, out) \
    {                                            \
        (prms)->inArgs      = (in);              \
        (prms)->inArgsSize  = sizeof(*(in));     \
        (prms)->outArgs     = (out);             \
        (prms)->outArgsSize = sizeof(*(out));    \
    }
 
#define ENET_IOCTL_VALID_PRMS(cmdId, inSize, outSize)       \
    [ENET_IOCTL_GET_MIN(cmdId)] =                           \
    {                                                       \
        .cmd         = (cmdId),                             \
        .inArgsSize  = (inSize),                            \
        .outArgsSize = (outSize),                           \
    }
 
 
#define ENET_IOCTL(hEnet, coreId, ioctlCmd, prms, status)                         \
    do {                                                                          \
        extern int32_t Enet_ioctl(Enet_Handle enetHandle,                         \
                   uint32_t ioctlCoreId,                                          \
                   uint32_t cmd,                                                  \
                   Enet_IoctlPrms *ioctlPrms);                                    \
                                                                                  \
        extern int32_t Enet_ioctl_register_##ioctlCmd(Enet_Handle enetHandle,     \
                                                      uint32_t ioctlCoreId);      \
                                                                                  \
        status = Enet_ioctl_register_##ioctlCmd(hEnet, coreId);                   \
        if (ENET_SOK == status)                                                   \
        {                                                                         \
            status = Enet_ioctl(hEnet, coreId, ioctlCmd, prms);                   \
        }                                                                         \
    } while (0)
 
 
/* ========================================================================== */
/*                         Structures and Enums                               */
/* ========================================================================== */
 
enum Enet_IoctlType_e
{
    ENET_IOCTL_TYPE_PUBLIC  = ENET_IOCTL_TYPE(1U),
 
    ENET_IOCTL_TYPE_PRIVATE = ENET_IOCTL_TYPE(2U),
};
 
enum Enet_IoctlPer_e
{
    ENET_IOCTL_PER_GENERIC = ENET_IOCTL_PER(0U),
 
    ENET_IOCTL_PER_CPSW = ENET_IOCTL_PER(1U),
 
    ENET_IOCTL_PER_ICSSG = ENET_IOCTL_PER(2U),
 
    ENET_IOCTL_PER_GMAC = ENET_IOCTL_PER(3U),
};
 
enum Enet_IoctlMajor_e
{
    ENET_IOCTL_PER_BASE      = ENET_IOCTL_MAJ(1U),
 
    ENET_IOCTL_FDB_BASE      = ENET_IOCTL_MAJ(2U),
 
    ENET_IOCTL_TIMESYNC_BASE = ENET_IOCTL_MAJ(3U),
 
    ENET_IOCTL_HOSTPORT_BASE = ENET_IOCTL_MAJ(4U),
 
    ENET_IOCTL_MACPORT_BASE  = ENET_IOCTL_MAJ(5U),
 
    ENET_IOCTL_MDIO_BASE     = ENET_IOCTL_MAJ(6U),
 
    ENET_IOCTL_STATS_BASE    = ENET_IOCTL_MAJ(7U),
 
    ENET_IOCTL_PHY_BASE      = ENET_IOCTL_MAJ(9U),
 
    ENET_IOCTL_RM_BASE       = ENET_IOCTL_MAJ(10U),
 
    ENET_IOCTL_TAS_BASE       = ENET_IOCTL_MAJ(11U),
};
 
typedef struct Enet_IoctlPrms_s
{
    const void *inArgs;
 
    uint32_t inArgsSize;
 
    void *outArgs;
 
    uint32_t outArgsSize;
} Enet_IoctlPrms;
 
typedef struct Enet_IoctlValidate_s
{
    uint32_t cmd;
 
    uint32_t inArgsSize;
 
    uint32_t outArgsSize;
} Enet_IoctlValidate;
 
/* ========================================================================== */
/*                         Global Variables Declarations                      */
/* ========================================================================== */
 
/* None */
 
/* ========================================================================== */
/*                          Function Declarations                             */
/* ========================================================================== */
 
static inline uint32_t Enet_checkInArgs(const Enet_IoctlPrms *prms,
                                        uint32_t inArgsSize);
 
static inline uint32_t Enet_checkNoInArgs(const Enet_IoctlPrms *prms);
 
static inline uint32_t Enet_checkOutArgs(const Enet_IoctlPrms *prms,
                                         uint32_t outArgsSize);
 
static inline uint32_t Enet_checkNoOutArgs(const Enet_IoctlPrms *prms);
 
static inline uint32_t Enet_checkInOutArgs(const Enet_IoctlPrms *prms,
                                           uint32_t inArgsSize,
                                           uint32_t outArgsSize);
 
#if ENET_CFG_IS_ON(DEV_ERROR)
 
int32_t Enet_validateIoctl(uint32_t cmd,
                           const Enet_IoctlPrms *prms,
                           const Enet_IoctlValidate *validIoctls,
                           uint32_t numValidIoctls);
#endif
 
/* ========================================================================== */
/*                        Deprecated Function Declarations                    */
/* ========================================================================== */
 
/* None */
 
/* ========================================================================== */
/*                       Static Function Definitions                          */
/* ========================================================================== */
 
static inline uint32_t Enet_checkInArgs(const Enet_IoctlPrms *prms,
                                        uint32_t inArgsSize)
{
    return ((prms != NULL) &&
            (prms->inArgs != NULL) &&
            (prms->inArgsSize == inArgsSize)) ?
           ENET_SOK : ENET_EMALFORMEDIOCTL;
}
 
static inline uint32_t Enet_checkNoInArgs(const Enet_IoctlPrms *prms)
{
    return ((prms != NULL) &&
            (prms->inArgs == NULL) &&
            (prms->inArgsSize == 0U)) ?
           ENET_SOK : ENET_EMALFORMEDIOCTL;
}
 
static inline uint32_t Enet_checkOutArgs(const Enet_IoctlPrms *prms,
                                         uint32_t outArgsSize)
{
    return ((prms != NULL) &&
            (prms->outArgs != NULL) &&
            (prms->outArgsSize == outArgsSize)) ?
           ENET_SOK : ENET_EMALFORMEDIOCTL;
}
 
static inline uint32_t Enet_checkNoOutArgs(const Enet_IoctlPrms *prms)
{
    return ((prms != NULL) &&
            (prms->outArgs == NULL) &&
            (prms->outArgsSize == 0U)) ?
           ENET_SOK : ENET_EMALFORMEDIOCTL;
}
 
static inline uint32_t Enet_checkInOutArgs(const Enet_IoctlPrms *prms,
                                           uint32_t inArgsSize,
                                           uint32_t outArgsSize)
{
    return ((prms != NULL) &&
            (prms->inArgs != NULL) &&
            (prms->inArgsSize == inArgsSize) &&
            (prms->outArgs != NULL) &&
            (prms->outArgsSize == outArgsSize)) ?
           ENET_SOK : ENET_EMALFORMEDIOCTL;
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* ENET_IOCTL_H_ */