rt-thread-official/bsp/nuvoton/libraries/n9h30/rtt_port/drv_adc.c

/**************************************************************************//**
* @copyright (C) 2020 Nuvoton Technology Corp. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date            Author       Notes
* 2020-12-12      Wayne        First version
*
******************************************************************************/

#include <rtconfig.h>

#if defined(BSP_USING_ADC)

#include <rtdevice.h>
#include "NuMicro.h"
#include "drv_sys.h"
#include "nu_bitutil.h"
#include "drv_adc.h"

/* Private define ---------------------------------------------------------------*/
#define DEF_ADC_TOUCH_SMPL_TICK  40
#define TOUCH_MQ_LENGTH      64

/* Private Typedef --------------------------------------------------------------*/
struct nu_adc
{
    struct rt_adc_device dev;
    char *name;
    ADC_T *base;
    uint32_t bReset;
    IRQn_Type irqn;
    E_SYS_IPRST rstidx;
    E_SYS_IPCLK clkidx;
    uint32_t chn_mask;
    rt_sem_t m_psSem;

#if defined(BSP_USING_ADC_TOUCH)
    rt_touch_t psRtTouch;
    rt_timer_t psRtTouchMenuTimer;
    rt_mq_t m_pmqTouchXYZ;
#endif

    nu_adc_cb m_isr[eAdc_ISR_CNT];
    nu_adc_cb m_wkisr[eAdc_WKISR_CNT];
};
typedef struct nu_adc *nu_adc_t;

#if defined(BSP_USING_ADC_TOUCH)
struct nu_adc_touch_data
{
    uint32_t    u32X;
    uint32_t    u32Y;
    uint32_t    u32Z0;
    uint32_t    u32Z1;
};
typedef struct nu_adc_touch_data *nu_adc_touch_data_t;
#endif

/* Private functions ------------------------------------------------------------*/
static rt_err_t nu_adc_enabled(struct rt_adc_device *device, rt_uint32_t channel, rt_bool_t enabled);
static rt_err_t nu_adc_convert(struct rt_adc_device *device, rt_uint32_t channel, rt_uint32_t *value);
static rt_err_t _nu_adc_control(rt_device_t dev, int cmd, void *args);

/* Public functions ------------------------------------------------------------*/
int rt_hw_adc_init(void);

/* Private variables ------------------------------------------------------------*/

static struct nu_adc g_sNuADC =
{
    .name = "adc",
    .base = (ADC_T *)ADC_BA,
    .bReset = 1,
    .irqn = IRQ_ADC,
    .rstidx = ADCRST,
    .clkidx = ADCCKEN,
    .chn_mask = 0
};

static void nu_adc_isr(int vector, void *param)
{
    volatile rt_int32_t isr, wkisr;
    nu_adc_t psNuAdc = (nu_adc_t)param;
    rt_int32_t irqidx;
    ADC_T  *adc = psNuAdc->base;

    //rt_kprintf("[%s %d] CTL: %08x CONF:%08x IER:%08x ISR:%08x\n", __func__, __LINE__, adc->CTL, adc->CONF, adc->IER, adc->ISR);

    isr = adc->ISR;
    wkisr = adc->WKISR;

    adc->ISR = isr;

    while ((irqidx = nu_ctz(isr)) < eAdc_ISR_CNT)
    {
        uint32_t u32IsrBitMask =  1 << irqidx ;

        if (psNuAdc->m_isr[irqidx].cbfunc != RT_NULL)
        {
            // rt_kprintf("[%s] %d %x\n", __func__, irqidx, psNuAdc->m_isr[irqidx].cbfunc);
            psNuAdc->m_isr[irqidx].cbfunc(isr, psNuAdc->m_isr[irqidx].private_data);
        }

        /* Clear sent bit */
        isr &= ~(u32IsrBitMask);
    } //while

    while ((irqidx = nu_ctz(wkisr)) < eAdc_WKISR_CNT)
    {
        uint32_t u32IsrBitMask = 1 << irqidx ;

        if (psNuAdc->m_wkisr[irqidx].cbfunc != RT_NULL)
        {
            psNuAdc->m_wkisr[irqidx].cbfunc(wkisr, psNuAdc->m_wkisr[irqidx].private_data);
        }

        wkisr &= ~(u32IsrBitMask);
    } //while
}


#define DEF_ADC_SRC_CLOCK_DIV  (12000 / 1000)
static rt_err_t _nu_adc_init(rt_device_t dev)
{
    nu_adc_t psNuAdc = (nu_adc_t)dev;

    /* Set ADC Engine Clock */
    outpw(REG_CLK_DIVCTL7, inpw(REG_CLK_DIVCTL7) & ~((0x3 << 19) | (0x7 << 16) | (0xFFul << 24)));
    outpw(REG_CLK_DIVCTL7, (0 << 19) | (0 << 16) | ((DEF_ADC_SRC_CLOCK_DIV - 1) << 24));

    /* Install interrupt service routine */
    rt_hw_interrupt_install(psNuAdc->irqn, nu_adc_isr, (void *)psNuAdc, psNuAdc->name);

    return RT_EOK;
}

#define ADC_TOUCH_Z0_ACTIVE 20
static int32_t AdcMenuStartCallback(uint32_t status, uint32_t userData)
{
    nu_adc_t psNuAdc = (nu_adc_t)userData;

#if defined(BSP_USING_ADC_TOUCH)
    ADC_T  *adc = psNuAdc->base;
    static struct nu_adc_touch_data point;
    static rt_bool_t bDrop = RT_FALSE;
    static uint32_t u32LastZ0 = 0xffffu;

    if (psNuAdc->psRtTouch != RT_NULL)
    {
        point.u32X = ADC_GET_CONVERSION_XDATA(adc);
        point.u32Y = ADC_GET_CONVERSION_YDATA(adc);

        point.u32Z0 = ADC_GET_CONVERSION_Z1DATA(adc);
        point.u32Z1 = ADC_GET_CONVERSION_Z2DATA(adc);

        //rt_kprintf("x=%d y=%d z0=%d z1=%d\n", point.u32X, point.u32Y, point.u32Z0, point.u32Z1);
        /* Trigger next or not. */
        if (point.u32Z0 < ADC_TOUCH_Z0_ACTIVE)
        {
            /* Stop sampling procedure. */
            rt_timer_stop(g_sNuADC.psRtTouchMenuTimer);

            /* Re-start pendown detection */
            nu_adc_touch_detect(RT_TRUE);

            psNuAdc->bReset = 1;

            bDrop = RT_TRUE;
        }
        else
        {
            bDrop = RT_FALSE;
        }

        /* Notify upper layer. */
        if ((!bDrop || (u32LastZ0 > ADC_TOUCH_Z0_ACTIVE)) && rt_mq_send(psNuAdc->m_pmqTouchXYZ, (const void *)&point, sizeof(struct nu_adc_touch_data)) == RT_EOK)
        {
            rt_hw_touch_isr(psNuAdc->psRtTouch);
        }

        u32LastZ0 = point.u32Z0;
    }
    else
#endif
    {
        rt_err_t result = rt_sem_release(psNuAdc->m_psSem);
        RT_ASSERT(result == RT_EOK);
    }

    return 0;
}

#if defined(BSP_USING_ADC_TOUCH)

static void nu_adc_touch_antiglitch(ADC_T  *adc)
{
    int count = 10;
    do
    {
        rt_hw_us_delay(1000); // 1ms
        ADC_CLR_INT_FLAG(adc, adc->ISR);
        if (adc->ISR == 0)
            break;
    }
    while (count-- > 0);
}

void nu_adc_touch_detect(rt_bool_t bStartDetect)
{
    nu_adc_t psNuAdc = (nu_adc_t)&g_sNuADC;
    ADC_T  *adc = psNuAdc->base;

    /* Disable interrupt */
    rt_hw_interrupt_mask(psNuAdc->irqn);

    ADC_POWER_DOWN(adc);

    /* Disable interrupt */
    ADC_DISABLE_INT(adc, ADC_IER_PEDEIEN_Msk | ADC_IER_MIEN_Msk);
    nu_adc_touch_antiglitch(adc);

    if (bStartDetect == RT_TRUE)
    {
        /* Switch to PenDown detection mode */
        ADC_DETECT_PD_MODE(adc);
        nu_adc_touch_antiglitch(adc);

        /* Enable interrupt */
        ADC_ENABLE_INT(adc, ADC_IER_PEDEIEN_Msk);
    }
    else
    {
        /* Switch to XY coordination converting mode */
        ADC_CONVERT_XY_MODE(adc);
        nu_adc_touch_antiglitch(adc);

        /* Enable interrupt */
        ADC_ENABLE_INT(adc, ADC_IER_MIEN_Msk);
    }

    ADC_POWER_ON(adc);

    /* Enable interrupt */
    rt_hw_interrupt_umask(psNuAdc->irqn);
}

static int32_t PenDownCallback(uint32_t status, uint32_t userData)
{
    nu_adc_t psNuAdc = (nu_adc_t)userData;
    return rt_timer_start(psNuAdc->psRtTouchMenuTimer);
}

int32_t nu_adc_touch_read_xyz(uint32_t *bufX, uint32_t *bufY, uint32_t *bufZ0, uint32_t *bufZ1, int32_t dataCnt)
{
    int i;
    struct nu_adc_touch_data value;

    for (i = 0 ; i < dataCnt; i++)
    {
        if (rt_mq_recv(g_sNuADC.m_pmqTouchXYZ, (void *)&value, sizeof(struct nu_adc_touch_data), 0) == -RT_ETIMEOUT)
            break;

        bufX[i]  = value.u32X;
        bufY[i]  = value.u32Y;
        bufZ0[i] = value.u32Z0;
        bufZ1[i] = value.u32Z1;
    }
    return i;
}

rt_err_t nu_adc_touch_enable(rt_touch_t psRtTouch)
{
    nu_adc_t psNuAdc = (nu_adc_t)&g_sNuADC;
    nu_adc_cb sNuAdcCb;
    ADC_T  *adc = psNuAdc->base;

    adc->CONF = 0x0;

    rt_adc_enable((rt_adc_device_t)psNuAdc, 4);  //Channel number 4
    rt_adc_enable((rt_adc_device_t)psNuAdc, 5);  //Channel number 5
    rt_adc_enable((rt_adc_device_t)psNuAdc, 6);  //Channel number 6
    rt_adc_enable((rt_adc_device_t)psNuAdc, 7);  //Channel number 7

    /* Register touch device. */
    psNuAdc->psRtTouch = psRtTouch;

    /* Register PenDown callback. */
    sNuAdcCb.cbfunc = PenDownCallback;
    sNuAdcCb.private_data = (rt_uint32_t)psNuAdc;
    rt_memcpy(&psNuAdc->m_isr[eAdc_PEDEF], &sNuAdcCb, sizeof(nu_adc_cb));

    nu_adc_touch_detect(RT_TRUE);

    return RT_EOK;
}

rt_err_t nu_adc_touch_disable(void)
{
    nu_adc_t psNuAdc = (nu_adc_t)&g_sNuADC;

    nu_adc_touch_detect(RT_FALSE);

    _nu_adc_control((rt_device_t)psNuAdc, T_OFF, RT_NULL);
    _nu_adc_control((rt_device_t)psNuAdc, Z_OFF, RT_NULL);
    _nu_adc_control((rt_device_t)psNuAdc, PEDEF_OFF, RT_NULL);

    rt_adc_disable((rt_adc_device_t)psNuAdc, 4);  //Channel number 4
    rt_adc_disable((rt_adc_device_t)psNuAdc, 5);  //Channel number 5
    rt_adc_disable((rt_adc_device_t)psNuAdc, 6);  //Channel number 6
    rt_adc_disable((rt_adc_device_t)psNuAdc, 7);  //Channel number 7

    return RT_EOK;
}

static void nu_adc_touch_smpl(void *p)
{
    nu_adc_t psNuAdc = (nu_adc_t)p;
    if (psNuAdc->bReset)
    {
        psNuAdc->bReset = 0;
        nu_adc_touch_detect(RT_FALSE);
    }

    /* Start conversion */
    ADC_START_CONV(psNuAdc->base);
}
#endif

static rt_err_t _nu_adc_control(rt_device_t dev, int cmd, void *args)
{
    rt_err_t ret = -RT_EINVAL ;
    nu_adc_t psNuAdc = (nu_adc_t)dev;
    ADC_T  *adc = psNuAdc->base;

    nu_adc_cb_t psAdcCb = (nu_adc_cb_t)args;

    switch (cmd)
    {
    case START_MST:  /* Menu Start Conversion */
    {
        /* Enable interrupt */
        ADC_ENABLE_INT(adc, ADC_IER_MIEN_Msk);

        /* Start conversion */
        ADC_START_CONV(adc);

        /* Wait it done */
        ret = rt_sem_take(psNuAdc->m_psSem, RT_WAITING_FOREVER);
        RT_ASSERT(ret == RT_EOK);

        /* Get data: valid data is 12-bit */
        if (args != RT_NULL)
            *((uint32_t *)args) = ADC_GET_CONVERSION_DATA(adc, 0);
    }
    break;

    case WKT_ON: /* Enable Touch Wake Up */
    {
        if (psAdcCb)
        {
            rt_memcpy(&psNuAdc->m_wkisr[eAdc_WPEDEF], psAdcCb, sizeof(nu_adc_cb));
        }
        adc->CTL |= ADC_CTL_WKTEN_Msk;
        adc->IER |= ADC_IER_WKTIEN_Msk;

        //TODO outpw(REG_SYS_WKUPSER, inpw(REG_SYS_WKUPSER) | (1 << 26));
    }
    break;

    case WKT_OFF:  /* Disable Touch Wake Up */
    {
        adc->CTL &= ~ADC_CTL_WKTEN_Msk;
        adc->IER &= ~ADC_IER_WKTIEN_Msk;

        //TODO outpw(REG_SYS_WKUPSER, inpw(REG_SYS_WKUPSER) & ~(1 << 26));
    }
    break;

    case SWITCH_5WIRE_ON:   /* Wire Mode Switch to 5-Wire */
    {
        adc->CTL |= ADC_CTL_WMSWCH_Msk;
    }
    break;

    case SWITCH_5WIRE_OFF:  /* Wire Mode Switch to 4-Wire */
    {
        adc->CTL &= ~ADC_CTL_WMSWCH_Msk;
    }
    break;

    case T_ON:   /* Enable Touch detection function */
    {
        adc->CONF |= ADC_CONF_TEN_Msk;
    }
    break;

    case T_OFF:   /* Disable Touch detection function */
    {
        adc->CONF &= ~ADC_CONF_TEN_Msk;
    }
    break;

    case TAVG_ON:   /* Enable Touch Mean average for X and Y function */
    {
        adc->CONF |= ADC_CONF_TMAVDIS_Msk;
    }
    break;

    case TAVG_OFF:   /* Disable Touch Mean average for X and Y function */
    {
        adc->CONF &= ~ADC_CONF_TMAVDIS_Msk;
    }
    break;

    case Z_ON:   /* Enable Press measure function */
    {
        adc->CONF |= ADC_CONF_ZEN_Msk;
    }
    break;

    case Z_OFF:   /* Disable Press measure function */
    {
        adc->CONF &= ~ADC_CONF_ZEN_Msk;
#if defined(BSP_USING_ADC_TOUCH)
        rt_mq_control(psNuAdc->m_pmqTouchXYZ, RT_IPC_CMD_RESET, RT_NULL);
#endif
    }
    break;

    case TZAVG_ON:   /* Enable Pressure Mean average for Z1 and Z2 function */
    {
        adc->CONF |= ADC_CONF_ZMAVDIS_Msk;
    }
    break;

    case TZAVG_OFF:   /* Disable Pressure Mean average for Z1 and Z2 function */
    {
        adc->CONF &= ~ADC_CONF_ZMAVDIS_Msk;
    }
    break;

    case NAC_ON: /* Enable Normal AD Conversion */
    {
        adc->CONF |= (ADC_CONF_NACEN_Msk | ADC_CONF_REFSEL_AVDD33);
    }
    break;

    case NAC_OFF: /* Disable Normal AD Conversion */
    {
        adc->CONF &= ~ADC_CONF_NACEN_Msk;
    }
    break;

    case SWITCH_CH:
    {
        int chn = (int)args;
        if (chn >= ADC_CH_NUM)
        {
            return -ret;
        }
        adc->CONF &= ~ADC_CONF_CHSEL_Msk;
        adc->CONF |= (chn << ADC_CONF_CHSEL_Pos);
    }
    break;

    default:
        return -(ret);
    }

    return RT_EOK;
}

static rt_err_t _nu_adc_open(rt_device_t dev, rt_uint16_t oflag)
{
    nu_adc_t psNuAdc = (nu_adc_t)dev;
    ADC_T  *adc = psNuAdc->base;

    /* Enable ADC engine clock */
    nu_sys_ipclk_enable(psNuAdc->clkidx);

    /* Reset the ADC IP */
    nu_sys_ip_reset(psNuAdc->rstidx);

    /* Enable ADC Power */
    ADC_POWER_ON(adc);

    /* Enable ADC to high speed mode */
    adc->CONF |= ADC_CONF_SPEED_Msk;

    /* Enable interrupt */
    rt_hw_interrupt_umask(psNuAdc->irqn);

    /* Enable Normal AD Conversion */
    _nu_adc_control(dev, NAC_ON, RT_NULL);

    return RT_EOK;
}

static rt_err_t _nu_adc_close(rt_device_t dev)
{
    nu_adc_t psNuAdc = (nu_adc_t)dev;
    ADC_T  *adc = psNuAdc->base;

    /* Disable Normal AD Conversion */
    _nu_adc_control(dev, NAC_OFF, RT_NULL);

    /* Disable interrupt */
    rt_hw_interrupt_mask(psNuAdc->irqn);

    /* Disable ADC Power */
    ADC_POWER_DOWN(adc);

    /* Disable ADC engine clock */
    nu_sys_ipclk_disable(psNuAdc->clkidx);

    return RT_EOK;
}

static const struct rt_adc_ops nu_adc_ops =
{
    nu_adc_enabled,
    nu_adc_convert,
};

/* nu_adc_enabled - Enable ADC clock and wait for ready */
static rt_err_t nu_adc_enabled(struct rt_adc_device *device, rt_uint32_t channel, rt_bool_t enabled)
{
    nu_adc_t psNuADC = (nu_adc_t)device;
    RT_ASSERT(device);

    if (channel >= ADC_CH_NUM)
        return -(RT_EINVAL);

    if (enabled)
    {
        psNuADC->chn_mask |= (1 << channel);
    }
    else
    {
        psNuADC->chn_mask &= ~(1 << channel);
    }

    if (psNuADC->chn_mask > 0 && ((rt_device_t)device)->ref_count == 0)
    {
        _nu_adc_open((rt_device_t)device, 0);
        ((rt_device_t)device)->ref_count = 1;
    }
    else if ((psNuADC->chn_mask == 0) && ((rt_device_t)device)->ref_count == 1)
    {
        _nu_adc_close((rt_device_t)device);
        ((rt_device_t)device)->ref_count = 0;
    }
    return RT_EOK;
}

static rt_err_t nu_adc_convert(struct rt_adc_device *device, rt_uint32_t channel, rt_uint32_t *value)
{
    rt_err_t ret = RT_EOK;

    RT_ASSERT(device);
    RT_ASSERT(value);

    if (channel >= ADC_CH_NUM)
    {
        ret = -RT_EINVAL;
        goto exit_nu_adc_convert;
    }
    else if ((ret = _nu_adc_control((rt_device_t)device, SWITCH_CH, (void *)channel)) != RT_EOK)
    {
        goto exit_nu_adc_convert;
    }
    else if ((ret = _nu_adc_control((rt_device_t)device, START_MST, (void *)value)) != RT_EOK)
    {
        goto exit_nu_adc_convert;
    }

exit_nu_adc_convert:

    return (-ret) ;
}

int rt_hw_adc_init(void)
{
    rt_err_t result = -RT_ERROR;
    rt_device_t psDev = &g_sNuADC.dev.parent;

    result = rt_hw_adc_register(&g_sNuADC.dev, g_sNuADC.name, &nu_adc_ops, &g_sNuADC);
    RT_ASSERT(result == RT_EOK);

    result = _nu_adc_init(psDev);
    RT_ASSERT(result == RT_EOK);

    g_sNuADC.m_psSem = rt_sem_create("adc_mst_sem", 0, RT_IPC_FLAG_FIFO);
    RT_ASSERT(g_sNuADC.m_psSem);

#if defined(BSP_USING_ADC_TOUCH)
    g_sNuADC.m_pmqTouchXYZ = rt_mq_create("ADC_TOUCH_XYZ", sizeof(struct nu_adc_touch_data), TOUCH_MQ_LENGTH, RT_IPC_FLAG_FIFO);
    RT_ASSERT(g_sNuADC.m_pmqTouchXYZ);

    g_sNuADC.psRtTouchMenuTimer = rt_timer_create("TOUCH_SMPL_TIMER", nu_adc_touch_smpl, (void *)&g_sNuADC, DEF_ADC_TOUCH_SMPL_TICK, RT_TIMER_FLAG_PERIODIC);
    RT_ASSERT(g_sNuADC.psRtTouchMenuTimer);
#endif

    rt_memset(&g_sNuADC.m_isr, 0, sizeof(g_sNuADC.m_isr));
    rt_memset(&g_sNuADC.m_wkisr, 0, sizeof(g_sNuADC.m_wkisr));

    g_sNuADC.m_isr[eAdc_MF].cbfunc = AdcMenuStartCallback;
    g_sNuADC.m_isr[eAdc_MF].private_data = (uint32_t)&g_sNuADC;

    return (int)result;
}
INIT_BOARD_EXPORT(rt_hw_adc_init);

#endif //#if defined(BSP_USING_ADC)