/*
 * Copyright (c) 2019-2020 Arm Limited
 *
 * 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.
 */

#include "Driver_SSE300_PPC.h"

#include "Driver_Common.h"
#include "RTE_Device.h"
#include "cmsis.h"
#include "cmsis_driver_config.h"
#include "ppc_sse300_drv.h"

/* Driver version */
#define ARM_PPC_DRV_VERSION ARM_DRIVER_VERSION_MAJOR_MINOR(1, 0)

/* Driver Version */
static const ARM_DRIVER_VERSION DriverVersion = { ARM_PPC_API_VERSION, ARM_PPC_DRV_VERSION };

ARM_DRIVER_VERSION PPC_SSE300_GetVersion(void)
{
    return DriverVersion;
}

typedef struct _SSE300_PPC_Resources
{
    struct ppc_sse300_dev_t * dev; /* PPC device structure */
} SSE300_PPC_Resources;

#if (RTE_PPC_SSE300_MAIN0)

static SSE300_PPC_Resources MAIN0_PPC_DEV = {
    .dev = &PPC_SSE300_MAIN0_DEV,
};

/* MAIN0 PPC Driver wrapper functions */
static int32_t PPC_SSE300_MAIN0_Initialize(void)
{
    ppc_sse300_init(MAIN0_PPC_DEV.dev);

    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_MAIN0_Uninitialize(void)
{
    /* Nothing to do */
    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_MAIN0_ConfigPrivilege(uint32_t periph, PPC_SSE300_SecAttr sec_attr, PPC_SSE300_PrivAttr priv_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_privilege(MAIN0_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr,
                                      (enum ppc_sse300_priv_attr_t) priv_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_MAIN0_IsPeriphPrivOnly(uint32_t periph)
{
    return ppc_sse300_is_periph_priv_only(MAIN0_PPC_DEV.dev, periph);
}

/* Secure only functions */
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))

static int32_t PPC_SSE300_MAIN0_ConfigSecurity(uint32_t periph, PPC_SSE300_SecAttr sec_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_security(MAIN0_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_MAIN0_IsPeriphSecure(uint32_t periph)
{
    return ppc_sse300_is_periph_secure(MAIN0_PPC_DEV.dev, periph);
}

static int32_t PPC_SSE300_MAIN0_EnableInterrupt(void)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_irq_enable(MAIN0_PPC_DEV.dev);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static void PPC_SSE300_MAIN0_DisableInterrupt(void)
{
    ppc_sse300_irq_disable(MAIN0_PPC_DEV.dev);
}

static void PPC_SSE300_MAIN0_ClearInterrupt(void)
{
    ppc_sse300_clear_irq(MAIN0_PPC_DEV.dev);
}

static bool PPC_SSE300_MAIN0_InterruptState(void)
{
    return ppc_sse300_irq_state(MAIN0_PPC_DEV.dev);
}

#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */

/* PPC SSE-300 MAIN0 Driver CMSIS access structure */
DRIVER_PPC_SSE300 Driver_PPC_SSE300_MAIN0 = { .GetVersion       = PPC_SSE300_GetVersion,
                                              .Initialize       = PPC_SSE300_MAIN0_Initialize,
                                              .Uninitialize     = PPC_SSE300_MAIN0_Uninitialize,
                                              .ConfigPrivilege  = PPC_SSE300_MAIN0_ConfigPrivilege,
                                              .IsPeriphPrivOnly = PPC_SSE300_MAIN0_IsPeriphPrivOnly,
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))
                                              .ConfigSecurity   = PPC_SSE300_MAIN0_ConfigSecurity,
                                              .IsPeriphSecure   = PPC_SSE300_MAIN0_IsPeriphSecure,
                                              .EnableInterrupt  = PPC_SSE300_MAIN0_EnableInterrupt,
                                              .DisableInterrupt = PPC_SSE300_MAIN0_DisableInterrupt,
                                              .ClearInterrupt   = PPC_SSE300_MAIN0_ClearInterrupt,
                                              .InterruptState   = PPC_SSE300_MAIN0_InterruptState
#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */
};
#endif /* RTE_PPC_SSE300_MAIN0 */

#if (RTE_PPC_SSE300_MAIN_EXP0)

static SSE300_PPC_Resources MAIN_EXP0_PPC_DEV = {
    .dev = &PPC_SSE300_MAIN_EXP0_DEV,
};

/* MAIN PPCEXP0 Driver wrapper functions */
static int32_t PPC_SSE300_MAIN_EXP0_Initialize(void)
{
    ppc_sse300_init(MAIN_EXP0_PPC_DEV.dev);

    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_MAIN_EXP0_Uninitialize(void)
{
    /* Nothing to do */
    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_MAIN_EXP0_ConfigPrivilege(uint32_t periph, PPC_SSE300_SecAttr sec_attr, PPC_SSE300_PrivAttr priv_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_privilege(MAIN_EXP0_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr,
                                      (enum ppc_sse300_priv_attr_t) priv_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_MAIN_EXP0_IsPeriphPrivOnly(uint32_t periph)
{
    return ppc_sse300_is_periph_priv_only(MAIN_EXP0_PPC_DEV.dev, periph);
}

/* Secure only functions */
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))

static int32_t PPC_SSE300_MAIN_EXP0_ConfigSecurity(uint32_t periph, PPC_SSE300_SecAttr sec_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_security(MAIN_EXP0_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_MAIN_EXP0_IsPeriphSecure(uint32_t periph)
{
    return ppc_sse300_is_periph_secure(MAIN_EXP0_PPC_DEV.dev, periph);
}

static int32_t PPC_SSE300_MAIN_EXP0_EnableInterrupt(void)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_irq_enable(MAIN_EXP0_PPC_DEV.dev);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static void PPC_SSE300_MAIN_EXP0_DisableInterrupt(void)
{
    ppc_sse300_irq_disable(MAIN_EXP0_PPC_DEV.dev);
}

static void PPC_SSE300_MAIN_EXP0_ClearInterrupt(void)
{
    ppc_sse300_clear_irq(MAIN_EXP0_PPC_DEV.dev);
}

static bool PPC_SSE300_MAIN_EXP0_InterruptState(void)
{
    return ppc_sse300_irq_state(MAIN_EXP0_PPC_DEV.dev);
}

#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */

/* PPC SSE-300 MAIN EXP0 Driver CMSIS access structure */
DRIVER_PPC_SSE300 Driver_PPC_SSE300_MAIN_EXP0 = { .GetVersion       = PPC_SSE300_GetVersion,
                                                  .Initialize       = PPC_SSE300_MAIN_EXP0_Initialize,
                                                  .Uninitialize     = PPC_SSE300_MAIN_EXP0_Uninitialize,
                                                  .ConfigPrivilege  = PPC_SSE300_MAIN_EXP0_ConfigPrivilege,
                                                  .IsPeriphPrivOnly = PPC_SSE300_MAIN_EXP0_IsPeriphPrivOnly,
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))
                                                  .ConfigSecurity   = PPC_SSE300_MAIN_EXP0_ConfigSecurity,
                                                  .IsPeriphSecure   = PPC_SSE300_MAIN_EXP0_IsPeriphSecure,
                                                  .EnableInterrupt  = PPC_SSE300_MAIN_EXP0_EnableInterrupt,
                                                  .DisableInterrupt = PPC_SSE300_MAIN_EXP0_DisableInterrupt,
                                                  .ClearInterrupt   = PPC_SSE300_MAIN_EXP0_ClearInterrupt,
                                                  .InterruptState   = PPC_SSE300_MAIN_EXP0_InterruptState
#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */
};
#endif /* RTE_PPC_SSE300_MAIN_EXP0 */

#if (RTE_PPC_SSE300_MAIN_EXP1)

static SSE300_PPC_Resources MAIN_EXP1_PPC_DEV = {
    .dev = &PPC_SSE300_MAIN_EXP1_DEV,
};

/* MAIN PPCEXP1 Driver wrapper functions */
static int32_t PPC_SSE300_MAIN_EXP1_Initialize(void)
{
    ppc_sse300_init(MAIN_EXP1_PPC_DEV.dev);

    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_MAIN_EXP1_Uninitialize(void)
{
    /* Nothing to do */
    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_MAIN_EXP1_ConfigPrivilege(uint32_t periph, PPC_SSE300_SecAttr sec_attr, PPC_SSE300_PrivAttr priv_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_privilege(MAIN_EXP1_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr,
                                      (enum ppc_sse300_priv_attr_t) priv_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_MAIN_EXP1_IsPeriphPrivOnly(uint32_t periph)
{
    return ppc_sse300_is_periph_priv_only(MAIN_EXP1_PPC_DEV.dev, periph);
}

/* Secure only functions */
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))

static int32_t PPC_SSE300_MAIN_EXP1_ConfigSecurity(uint32_t periph, PPC_SSE300_SecAttr sec_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_security(MAIN_EXP1_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_MAIN_EXP1_IsPeriphSecure(uint32_t periph)
{
    return ppc_sse300_is_periph_secure(MAIN_EXP1_PPC_DEV.dev, periph);
}

static int32_t PPC_SSE300_MAIN_EXP1_EnableInterrupt(void)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_irq_enable(MAIN_EXP1_PPC_DEV.dev);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static void PPC_SSE300_MAIN_EXP1_DisableInterrupt(void)
{
    ppc_sse300_irq_disable(MAIN_EXP1_PPC_DEV.dev);
}

static void PPC_SSE300_MAIN_EXP1_ClearInterrupt(void)
{
    ppc_sse300_clear_irq(MAIN_EXP1_PPC_DEV.dev);
}

static bool PPC_SSE300_MAIN_EXP1_InterruptState(void)
{
    return ppc_sse300_irq_state(MAIN_EXP1_PPC_DEV.dev);
}

#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */

/* PPC SSE-300 MAIN EXP1 Driver CMSIS access structure */
DRIVER_PPC_SSE300 Driver_PPC_SSE300_MAIN_EXP1 = { .GetVersion       = PPC_SSE300_GetVersion,
                                                  .Initialize       = PPC_SSE300_MAIN_EXP1_Initialize,
                                                  .Uninitialize     = PPC_SSE300_MAIN_EXP1_Uninitialize,
                                                  .ConfigPrivilege  = PPC_SSE300_MAIN_EXP1_ConfigPrivilege,
                                                  .IsPeriphPrivOnly = PPC_SSE300_MAIN_EXP1_IsPeriphPrivOnly,
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))
                                                  .ConfigSecurity   = PPC_SSE300_MAIN_EXP1_ConfigSecurity,
                                                  .IsPeriphSecure   = PPC_SSE300_MAIN_EXP1_IsPeriphSecure,
                                                  .EnableInterrupt  = PPC_SSE300_MAIN_EXP1_EnableInterrupt,
                                                  .DisableInterrupt = PPC_SSE300_MAIN_EXP1_DisableInterrupt,
                                                  .ClearInterrupt   = PPC_SSE300_MAIN_EXP1_ClearInterrupt,
                                                  .InterruptState   = PPC_SSE300_MAIN_EXP1_InterruptState
#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */
};
#endif /* RTE_PPC_SSE300_MAIN_EXP1 */

#if (RTE_PPC_SSE300_MAIN_EXP2)

static SSE300_PPC_Resources MAIN_EXP2_PPC_DEV = {
    .dev = &PPC_SSE300_MAIN_EXP2_DEV,
};

/* MAIN PPCEXP2 Driver wrapper functions */
static int32_t PPC_SSE300_MAIN_EXP2_Initialize(void)
{
    ppc_sse300_init(MAIN_EXP2_PPC_DEV.dev);

    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_MAIN_EXP2_Uninitialize(void)
{
    /* Nothing to do */
    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_MAIN_EXP2_ConfigPrivilege(uint32_t periph, PPC_SSE300_SecAttr sec_attr, PPC_SSE300_PrivAttr priv_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_privilege(MAIN_EXP2_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr,
                                      (enum ppc_sse300_priv_attr_t) priv_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_MAIN_EXP2_IsPeriphPrivOnly(uint32_t periph)
{
    return ppc_sse300_is_periph_priv_only(MAIN_EXP2_PPC_DEV.dev, periph);
}

/* Secure only functions */
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))

static int32_t PPC_SSE300_MAIN_EXP2_ConfigSecurity(uint32_t periph, PPC_SSE300_SecAttr sec_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_security(MAIN_EXP2_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_MAIN_EXP2_IsPeriphSecure(uint32_t periph)
{
    return ppc_sse300_is_periph_secure(MAIN_EXP2_PPC_DEV.dev, periph);
}

static int32_t PPC_SSE300_MAIN_EXP2_EnableInterrupt(void)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_irq_enable(MAIN_EXP2_PPC_DEV.dev);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static void PPC_SSE300_MAIN_EXP2_DisableInterrupt(void)
{
    ppc_sse300_irq_disable(MAIN_EXP2_PPC_DEV.dev);
}

static void PPC_SSE300_MAIN_EXP2_ClearInterrupt(void)
{
    ppc_sse300_clear_irq(MAIN_EXP2_PPC_DEV.dev);
}

static bool PPC_SSE300_MAIN_EXP2_InterruptState(void)
{
    return ppc_sse300_irq_state(MAIN_EXP2_PPC_DEV.dev);
}

#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */

/* PPC SSE-300 MAIN EXP2 Driver CMSIS access structure */
DRIVER_PPC_SSE300 Driver_PPC_SSE300_MAIN_EXP2 = { .GetVersion       = PPC_SSE300_GetVersion,
                                                  .Initialize       = PPC_SSE300_MAIN_EXP2_Initialize,
                                                  .Uninitialize     = PPC_SSE300_MAIN_EXP2_Uninitialize,
                                                  .ConfigPrivilege  = PPC_SSE300_MAIN_EXP2_ConfigPrivilege,
                                                  .IsPeriphPrivOnly = PPC_SSE300_MAIN_EXP2_IsPeriphPrivOnly,
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))
                                                  .ConfigSecurity   = PPC_SSE300_MAIN_EXP2_ConfigSecurity,
                                                  .IsPeriphSecure   = PPC_SSE300_MAIN_EXP2_IsPeriphSecure,
                                                  .EnableInterrupt  = PPC_SSE300_MAIN_EXP2_EnableInterrupt,
                                                  .DisableInterrupt = PPC_SSE300_MAIN_EXP2_DisableInterrupt,
                                                  .ClearInterrupt   = PPC_SSE300_MAIN_EXP2_ClearInterrupt,
                                                  .InterruptState   = PPC_SSE300_MAIN_EXP2_InterruptState
#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */
};
#endif /* RTE_PPC_SSE300_MAIN_EXP2 */

#if (RTE_PPC_SSE300_MAIN_EXP3)

static SSE300_PPC_Resources MAIN_EXP3_PPC_DEV = {
    .dev = &PPC_SSE300_MAIN_EXP3_DEV,
};

/* MAIN PPCEXP3 Driver wrapper functions */
static int32_t PPC_SSE300_MAIN_EXP3_Initialize(void)
{
    ppc_sse300_init(MAIN_EXP3_PPC_DEV.dev);

    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_MAIN_EXP3_Uninitialize(void)
{
    /* Nothing to do */
    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_MAIN_EXP3_ConfigPrivilege(uint32_t periph, PPC_SSE300_SecAttr sec_attr, PPC_SSE300_PrivAttr priv_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_privilege(MAIN_EXP3_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr,
                                      (enum ppc_sse300_priv_attr_t) priv_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_MAIN_EXP3_IsPeriphPrivOnly(uint32_t periph)
{
    return ppc_sse300_is_periph_priv_only(MAIN_EXP3_PPC_DEV.dev, periph);
}

/* Secure only functions */
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))

static int32_t PPC_SSE300_MAIN_EXP3_ConfigSecurity(uint32_t periph, PPC_SSE300_SecAttr sec_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_security(MAIN_EXP3_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_MAIN_EXP3_IsPeriphSecure(uint32_t periph)
{
    return ppc_sse300_is_periph_secure(MAIN_EXP3_PPC_DEV.dev, periph);
}

static int32_t PPC_SSE300_MAIN_EXP3_EnableInterrupt(void)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_irq_enable(MAIN_EXP3_PPC_DEV.dev);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static void PPC_SSE300_MAIN_EXP3_DisableInterrupt(void)
{
    ppc_sse300_irq_disable(MAIN_EXP3_PPC_DEV.dev);
}

static void PPC_SSE300_MAIN_EXP3_ClearInterrupt(void)
{
    ppc_sse300_clear_irq(MAIN_EXP3_PPC_DEV.dev);
}

static bool PPC_SSE300_MAIN_EXP3_InterruptState(void)
{
    return ppc_sse300_irq_state(MAIN_EXP3_PPC_DEV.dev);
}

#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */

/* PPC SSE-300 MAIN EXP3 Driver CMSIS access structure */
DRIVER_PPC_SSE300 Driver_PPC_SSE300_MAIN_EXP3 = { .GetVersion       = PPC_SSE300_GetVersion,
                                                  .Initialize       = PPC_SSE300_MAIN_EXP3_Initialize,
                                                  .Uninitialize     = PPC_SSE300_MAIN_EXP3_Uninitialize,
                                                  .ConfigPrivilege  = PPC_SSE300_MAIN_EXP3_ConfigPrivilege,
                                                  .IsPeriphPrivOnly = PPC_SSE300_MAIN_EXP3_IsPeriphPrivOnly,
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))
                                                  .ConfigSecurity   = PPC_SSE300_MAIN_EXP3_ConfigSecurity,
                                                  .IsPeriphSecure   = PPC_SSE300_MAIN_EXP3_IsPeriphSecure,
                                                  .EnableInterrupt  = PPC_SSE300_MAIN_EXP3_EnableInterrupt,
                                                  .DisableInterrupt = PPC_SSE300_MAIN_EXP3_DisableInterrupt,
                                                  .ClearInterrupt   = PPC_SSE300_MAIN_EXP3_ClearInterrupt,
                                                  .InterruptState   = PPC_SSE300_MAIN_EXP3_InterruptState
#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */
};
#endif /* RTE_PPC_SSE300_MAIN_EXP3 */

#if (RTE_PPC_SSE300_PERIPH0)

static SSE300_PPC_Resources PERIPH0_PPC_DEV = {
    .dev = &PPC_SSE300_PERIPH0_DEV,
};

/* PERIPH0 Driver wrapper functions */
static int32_t PPC_SSE300_PERIPH0_Initialize(void)
{
    ppc_sse300_init(PERIPH0_PPC_DEV.dev);

    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_PERIPH0_Uninitialize(void)
{
    /* Nothing to do */
    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_PERIPH0_ConfigPrivilege(uint32_t periph, PPC_SSE300_SecAttr sec_attr, PPC_SSE300_PrivAttr priv_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_privilege(PERIPH0_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr,
                                      (enum ppc_sse300_priv_attr_t) priv_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_PERIPH0_IsPeriphPrivOnly(uint32_t periph)
{
    return ppc_sse300_is_periph_priv_only(PERIPH0_PPC_DEV.dev, periph);
}

/* Secure only functions */
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))

static int32_t PPC_SSE300_PERIPH0_ConfigSecurity(uint32_t periph, PPC_SSE300_SecAttr sec_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_security(PERIPH0_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_PERIPH0_IsPeriphSecure(uint32_t periph)
{
    return ppc_sse300_is_periph_secure(PERIPH0_PPC_DEV.dev, periph);
}

static int32_t PPC_SSE300_PERIPH0_EnableInterrupt(void)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_irq_enable(PERIPH0_PPC_DEV.dev);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static void PPC_SSE300_PERIPH0_DisableInterrupt(void)
{
    ppc_sse300_irq_disable(PERIPH0_PPC_DEV.dev);
}

static void PPC_SSE300_PERIPH0_ClearInterrupt(void)
{
    ppc_sse300_clear_irq(PERIPH0_PPC_DEV.dev);
}

static bool PPC_SSE300_PERIPH0_InterruptState(void)
{
    return ppc_sse300_irq_state(PERIPH0_PPC_DEV.dev);
}

#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */

/* PPC SSE-300 PERIPH0 Driver CMSIS access structure */
DRIVER_PPC_SSE300 Driver_PPC_SSE300_PERIPH0 = { .GetVersion       = PPC_SSE300_GetVersion,
                                                .Initialize       = PPC_SSE300_PERIPH0_Initialize,
                                                .Uninitialize     = PPC_SSE300_PERIPH0_Uninitialize,
                                                .ConfigPrivilege  = PPC_SSE300_PERIPH0_ConfigPrivilege,
                                                .IsPeriphPrivOnly = PPC_SSE300_PERIPH0_IsPeriphPrivOnly,
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))
                                                .ConfigSecurity   = PPC_SSE300_PERIPH0_ConfigSecurity,
                                                .IsPeriphSecure   = PPC_SSE300_PERIPH0_IsPeriphSecure,
                                                .EnableInterrupt  = PPC_SSE300_PERIPH0_EnableInterrupt,
                                                .DisableInterrupt = PPC_SSE300_PERIPH0_DisableInterrupt,
                                                .ClearInterrupt   = PPC_SSE300_PERIPH0_ClearInterrupt,
                                                .InterruptState   = PPC_SSE300_PERIPH0_InterruptState
#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */
};
#endif /* RTE_PPC_SSE300_PERIPH0 */

#if (RTE_PPC_SSE300_PERIPH1)

static SSE300_PPC_Resources PERIPH1_PPC_DEV = {
    .dev = &PPC_SSE300_PERIPH1_DEV,
};

/* PERIPH1 Driver wrapper functions */
static int32_t PPC_SSE300_PERIPH1_Initialize(void)
{
    ppc_sse300_init(PERIPH1_PPC_DEV.dev);

    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_PERIPH1_Uninitialize(void)
{
    /* Nothing to do */
    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_PERIPH1_ConfigPrivilege(uint32_t periph, PPC_SSE300_SecAttr sec_attr, PPC_SSE300_PrivAttr priv_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_privilege(PERIPH1_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr,
                                      (enum ppc_sse300_priv_attr_t) priv_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_PERIPH1_IsPeriphPrivOnly(uint32_t periph)
{
    return ppc_sse300_is_periph_priv_only(PERIPH1_PPC_DEV.dev, periph);
}

/* Secure only functions */
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))

static int32_t PPC_SSE300_PERIPH1_ConfigSecurity(uint32_t periph, PPC_SSE300_SecAttr sec_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_security(PERIPH1_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_PERIPH1_IsPeriphSecure(uint32_t periph)
{
    return ppc_sse300_is_periph_secure(PERIPH1_PPC_DEV.dev, periph);
}

static int32_t PPC_SSE300_PERIPH1_EnableInterrupt(void)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_irq_enable(PERIPH1_PPC_DEV.dev);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static void PPC_SSE300_PERIPH1_DisableInterrupt(void)
{
    ppc_sse300_irq_disable(PERIPH1_PPC_DEV.dev);
}

static void PPC_SSE300_PERIPH1_ClearInterrupt(void)
{
    ppc_sse300_clear_irq(PERIPH1_PPC_DEV.dev);
}

static bool PPC_SSE300_PERIPH1_InterruptState(void)
{
    return ppc_sse300_irq_state(PERIPH1_PPC_DEV.dev);
}

#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */

/* PPC SSE-300 PERIPH1 Driver CMSIS access structure */
DRIVER_PPC_SSE300 Driver_PPC_SSE300_PERIPH1 = { .GetVersion       = PPC_SSE300_GetVersion,
                                                .Initialize       = PPC_SSE300_PERIPH1_Initialize,
                                                .Uninitialize     = PPC_SSE300_PERIPH1_Uninitialize,
                                                .ConfigPrivilege  = PPC_SSE300_PERIPH1_ConfigPrivilege,
                                                .IsPeriphPrivOnly = PPC_SSE300_PERIPH1_IsPeriphPrivOnly,
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))
                                                .ConfigSecurity   = PPC_SSE300_PERIPH1_ConfigSecurity,
                                                .IsPeriphSecure   = PPC_SSE300_PERIPH1_IsPeriphSecure,
                                                .EnableInterrupt  = PPC_SSE300_PERIPH1_EnableInterrupt,
                                                .DisableInterrupt = PPC_SSE300_PERIPH1_DisableInterrupt,
                                                .ClearInterrupt   = PPC_SSE300_PERIPH1_ClearInterrupt,
                                                .InterruptState   = PPC_SSE300_PERIPH1_InterruptState
#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */
};
#endif /* RTE_PPC_SSE300_PERIPH1 */

#if (RTE_PPC_SSE300_PERIPH_EXP0)

static SSE300_PPC_Resources PERIPH_EXP0_PPC_DEV = {
    .dev = &PPC_SSE300_PERIPH_EXP0_DEV,
};

/* PERIPH PPCEXP0 Driver wrapper functions */
static int32_t PPC_SSE300_PERIPH_EXP0_Initialize(void)
{
    ppc_sse300_init(PERIPH_EXP0_PPC_DEV.dev);

    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_PERIPH_EXP0_Uninitialize(void)
{
    /* Nothing to do */
    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_PERIPH_EXP0_ConfigPrivilege(uint32_t periph, PPC_SSE300_SecAttr sec_attr, PPC_SSE300_PrivAttr priv_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_privilege(PERIPH_EXP0_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr,
                                      (enum ppc_sse300_priv_attr_t) priv_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_PERIPH_EXP0_IsPeriphPrivOnly(uint32_t periph)
{
    return ppc_sse300_is_periph_priv_only(PERIPH_EXP0_PPC_DEV.dev, periph);
}

/* Secure only functions */
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))

static int32_t PPC_SSE300_PERIPH_EXP0_ConfigSecurity(uint32_t periph, PPC_SSE300_SecAttr sec_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_security(PERIPH_EXP0_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_PERIPH_EXP0_IsPeriphSecure(uint32_t periph)
{
    return ppc_sse300_is_periph_secure(PERIPH_EXP0_PPC_DEV.dev, periph);
}

static int32_t PPC_SSE300_PERIPH_EXP0_EnableInterrupt(void)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_irq_enable(PERIPH_EXP0_PPC_DEV.dev);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static void PPC_SSE300_PERIPH_EXP0_DisableInterrupt(void)
{
    ppc_sse300_irq_disable(PERIPH_EXP0_PPC_DEV.dev);
}

static void PPC_SSE300_PERIPH_EXP0_ClearInterrupt(void)
{
    ppc_sse300_clear_irq(PERIPH_EXP0_PPC_DEV.dev);
}

static bool PPC_SSE300_PERIPH_EXP0_InterruptState(void)
{
    return ppc_sse300_irq_state(PERIPH_EXP0_PPC_DEV.dev);
}

#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */

/* PPC SSE-300 PERIPH EXP0 Driver CMSIS access structure */
DRIVER_PPC_SSE300 Driver_PPC_SSE300_PERIPH_EXP0 = { .GetVersion       = PPC_SSE300_GetVersion,
                                                    .Initialize       = PPC_SSE300_PERIPH_EXP0_Initialize,
                                                    .Uninitialize     = PPC_SSE300_PERIPH_EXP0_Uninitialize,
                                                    .ConfigPrivilege  = PPC_SSE300_PERIPH_EXP0_ConfigPrivilege,
                                                    .IsPeriphPrivOnly = PPC_SSE300_PERIPH_EXP0_IsPeriphPrivOnly,
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))
                                                    .ConfigSecurity   = PPC_SSE300_PERIPH_EXP0_ConfigSecurity,
                                                    .IsPeriphSecure   = PPC_SSE300_PERIPH_EXP0_IsPeriphSecure,
                                                    .EnableInterrupt  = PPC_SSE300_PERIPH_EXP0_EnableInterrupt,
                                                    .DisableInterrupt = PPC_SSE300_PERIPH_EXP0_DisableInterrupt,
                                                    .ClearInterrupt   = PPC_SSE300_PERIPH_EXP0_ClearInterrupt,
                                                    .InterruptState   = PPC_SSE300_PERIPH_EXP0_InterruptState
#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */
};
#endif /* RTE_PPC_SSE300_PERIPH_EXP0 */

#if (RTE_PPC_SSE300_PERIPH_EXP1)

static SSE300_PPC_Resources PERIPH_EXP1_PPC_DEV = {
    .dev = &PPC_SSE300_PERIPH_EXP1_DEV,
};

/* PERIPH PPCEXP1 Driver wrapper functions */
static int32_t PPC_SSE300_PERIPH_EXP1_Initialize(void)
{
    ppc_sse300_init(PERIPH_EXP1_PPC_DEV.dev);

    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_PERIPH_EXP1_Uninitialize(void)
{
    /* Nothing to do */
    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_PERIPH_EXP1_ConfigPrivilege(uint32_t periph, PPC_SSE300_SecAttr sec_attr, PPC_SSE300_PrivAttr priv_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_privilege(PERIPH_EXP1_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr,
                                      (enum ppc_sse300_priv_attr_t) priv_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_PERIPH_EXP1_IsPeriphPrivOnly(uint32_t periph)
{
    return ppc_sse300_is_periph_priv_only(PERIPH_EXP1_PPC_DEV.dev, periph);
}

/* Secure only functions */
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))

static int32_t PPC_SSE300_PERIPH_EXP1_ConfigSecurity(uint32_t periph, PPC_SSE300_SecAttr sec_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_security(PERIPH_EXP1_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_PERIPH_EXP1_IsPeriphSecure(uint32_t periph)
{
    return ppc_sse300_is_periph_secure(PERIPH_EXP1_PPC_DEV.dev, periph);
}

static int32_t PPC_SSE300_PERIPH_EXP1_EnableInterrupt(void)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_irq_enable(PERIPH_EXP1_PPC_DEV.dev);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static void PPC_SSE300_PERIPH_EXP1_DisableInterrupt(void)
{
    ppc_sse300_irq_disable(PERIPH_EXP1_PPC_DEV.dev);
}

static void PPC_SSE300_PERIPH_EXP1_ClearInterrupt(void)
{
    ppc_sse300_clear_irq(PERIPH_EXP1_PPC_DEV.dev);
}

static bool PPC_SSE300_PERIPH_EXP1_InterruptState(void)
{
    return ppc_sse300_irq_state(PERIPH_EXP1_PPC_DEV.dev);
}

#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */

/* PPC SSE-300 PERIPH EXP1 Driver CMSIS access structure */
DRIVER_PPC_SSE300 Driver_PPC_SSE300_PERIPH_EXP1 = { .GetVersion       = PPC_SSE300_GetVersion,
                                                    .Initialize       = PPC_SSE300_PERIPH_EXP1_Initialize,
                                                    .Uninitialize     = PPC_SSE300_PERIPH_EXP1_Uninitialize,
                                                    .ConfigPrivilege  = PPC_SSE300_PERIPH_EXP1_ConfigPrivilege,
                                                    .IsPeriphPrivOnly = PPC_SSE300_PERIPH_EXP1_IsPeriphPrivOnly,
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))
                                                    .ConfigSecurity   = PPC_SSE300_PERIPH_EXP1_ConfigSecurity,
                                                    .IsPeriphSecure   = PPC_SSE300_PERIPH_EXP1_IsPeriphSecure,
                                                    .EnableInterrupt  = PPC_SSE300_PERIPH_EXP1_EnableInterrupt,
                                                    .DisableInterrupt = PPC_SSE300_PERIPH_EXP1_DisableInterrupt,
                                                    .ClearInterrupt   = PPC_SSE300_PERIPH_EXP1_ClearInterrupt,
                                                    .InterruptState   = PPC_SSE300_PERIPH_EXP1_InterruptState
#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */
};
#endif /* RTE_PPC_SSE300_PERIPH_EXP1 */

#if (RTE_PPC_SSE300_PERIPH_EXP2)

static SSE300_PPC_Resources PERIPH_EXP2_PPC_DEV = {
    .dev = &PPC_SSE300_PERIPH_EXP2_DEV,
};

/* PERIPH PPCEXP2 Driver wrapper functions */
static int32_t PPC_SSE300_PERIPH_EXP2_Initialize(void)
{
    ppc_sse300_init(PERIPH_EXP2_PPC_DEV.dev);

    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_PERIPH_EXP2_Uninitialize(void)
{
    /* Nothing to do */
    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_PERIPH_EXP2_ConfigPrivilege(uint32_t periph, PPC_SSE300_SecAttr sec_attr, PPC_SSE300_PrivAttr priv_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_privilege(PERIPH_EXP2_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr,
                                      (enum ppc_sse300_priv_attr_t) priv_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_PERIPH_EXP2_IsPeriphPrivOnly(uint32_t periph)
{
    return ppc_sse300_is_periph_priv_only(PERIPH_EXP2_PPC_DEV.dev, periph);
}

/* Secure only functions */
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))

static int32_t PPC_SSE300_PERIPH_EXP2_ConfigSecurity(uint32_t periph, PPC_SSE300_SecAttr sec_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_security(PERIPH_EXP2_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_PERIPH_EXP2_IsPeriphSecure(uint32_t periph)
{
    return ppc_sse300_is_periph_secure(PERIPH_EXP2_PPC_DEV.dev, periph);
}

static int32_t PPC_SSE300_PERIPH_EXP2_EnableInterrupt(void)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_irq_enable(PERIPH_EXP2_PPC_DEV.dev);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static void PPC_SSE300_PERIPH_EXP2_DisableInterrupt(void)
{
    ppc_sse300_irq_disable(PERIPH_EXP2_PPC_DEV.dev);
}

static void PPC_SSE300_PERIPH_EXP2_ClearInterrupt(void)
{
    ppc_sse300_clear_irq(PERIPH_EXP2_PPC_DEV.dev);
}

static bool PPC_SSE300_PERIPH_EXP2_InterruptState(void)
{
    return ppc_sse300_irq_state(PERIPH_EXP2_PPC_DEV.dev);
}

#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */

/* PPC SSE-300 PERIPH EXP2 Driver CMSIS access structure */
DRIVER_PPC_SSE300 Driver_PPC_SSE300_PERIPH_EXP2 = { .GetVersion       = PPC_SSE300_GetVersion,
                                                    .Initialize       = PPC_SSE300_PERIPH_EXP2_Initialize,
                                                    .Uninitialize     = PPC_SSE300_PERIPH_EXP2_Uninitialize,
                                                    .ConfigPrivilege  = PPC_SSE300_PERIPH_EXP2_ConfigPrivilege,
                                                    .IsPeriphPrivOnly = PPC_SSE300_PERIPH_EXP2_IsPeriphPrivOnly,
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))
                                                    .ConfigSecurity   = PPC_SSE300_PERIPH_EXP2_ConfigSecurity,
                                                    .IsPeriphSecure   = PPC_SSE300_PERIPH_EXP2_IsPeriphSecure,
                                                    .EnableInterrupt  = PPC_SSE300_PERIPH_EXP2_EnableInterrupt,
                                                    .DisableInterrupt = PPC_SSE300_PERIPH_EXP2_DisableInterrupt,
                                                    .ClearInterrupt   = PPC_SSE300_PERIPH_EXP2_ClearInterrupt,
                                                    .InterruptState   = PPC_SSE300_PERIPH_EXP2_InterruptState
#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */
};
#endif /* RTE_PPC_SSE300_PERIPH_EXP2 */

#if (RTE_PPC_SSE300_PERIPH_EXP3)

static SSE300_PPC_Resources PERIPH_EXP3_PPC_DEV = {
    .dev = &PPC_SSE300_PERIPH_EXP3_DEV,
};

/* PERIPH PPCEXP3 Driver wrapper functions */
static int32_t PPC_SSE300_PERIPH_EXP3_Initialize(void)
{
    ppc_sse300_init(PERIPH_EXP3_PPC_DEV.dev);

    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_PERIPH_EXP3_Uninitialize(void)
{
    /* Nothing to do */
    return ARM_DRIVER_OK;
}

static int32_t PPC_SSE300_PERIPH_EXP3_ConfigPrivilege(uint32_t periph, PPC_SSE300_SecAttr sec_attr, PPC_SSE300_PrivAttr priv_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_privilege(PERIPH_EXP3_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr,
                                      (enum ppc_sse300_priv_attr_t) priv_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_PERIPH_EXP3_IsPeriphPrivOnly(uint32_t periph)
{
    return ppc_sse300_is_periph_priv_only(PERIPH_EXP3_PPC_DEV.dev, periph);
}

/* Secure only functions */
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))

static int32_t PPC_SSE300_PERIPH_EXP3_ConfigSecurity(uint32_t periph, PPC_SSE300_SecAttr sec_attr)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_config_security(PERIPH_EXP3_PPC_DEV.dev, periph, (enum ppc_sse300_sec_attr_t) sec_attr);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static bool PPC_SSE300_PERIPH_EXP3_IsPeriphSecure(uint32_t periph)
{
    return ppc_sse300_is_periph_secure(PERIPH_EXP3_PPC_DEV.dev, periph);
}

static int32_t PPC_SSE300_PERIPH_EXP3_EnableInterrupt(void)
{
    enum ppc_sse300_error_t ret;

    ret = ppc_sse300_irq_enable(PERIPH_EXP3_PPC_DEV.dev);

    if (ret != PPC_SSE300_ERR_NONE)
    {
        return ARM_DRIVER_ERROR;
    }

    return ARM_DRIVER_OK;
}

static void PPC_SSE300_PERIPH_EXP3_DisableInterrupt(void)
{
    ppc_sse300_irq_disable(PERIPH_EXP3_PPC_DEV.dev);
}

static void PPC_SSE300_PERIPH_EXP3_ClearInterrupt(void)
{
    ppc_sse300_clear_irq(PERIPH_EXP3_PPC_DEV.dev);
}

static bool PPC_SSE300_PERIPH_EXP3_InterruptState(void)
{
    return ppc_sse300_irq_state(PERIPH_EXP3_PPC_DEV.dev);
}

#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */

/* PPC SSE-300 PERIPH EXP3 Driver CMSIS access structure */
DRIVER_PPC_SSE300 Driver_PPC_SSE300_PERIPH_EXP3 = { .GetVersion       = PPC_SSE300_GetVersion,
                                                    .Initialize       = PPC_SSE300_PERIPH_EXP3_Initialize,
                                                    .Uninitialize     = PPC_SSE300_PERIPH_EXP3_Uninitialize,
                                                    .ConfigPrivilege  = PPC_SSE300_PERIPH_EXP3_ConfigPrivilege,
                                                    .IsPeriphPrivOnly = PPC_SSE300_PERIPH_EXP3_IsPeriphPrivOnly,
#if (defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U))
                                                    .ConfigSecurity   = PPC_SSE300_PERIPH_EXP3_ConfigSecurity,
                                                    .IsPeriphSecure   = PPC_SSE300_PERIPH_EXP3_IsPeriphSecure,
                                                    .EnableInterrupt  = PPC_SSE300_PERIPH_EXP3_EnableInterrupt,
                                                    .DisableInterrupt = PPC_SSE300_PERIPH_EXP3_DisableInterrupt,
                                                    .ClearInterrupt   = PPC_SSE300_PERIPH_EXP3_ClearInterrupt,
                                                    .InterruptState   = PPC_SSE300_PERIPH_EXP3_InterruptState
#endif /* (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)) */
};
#endif /* RTE_PPC_SSE300_PERIPH_EXP3 */