mirror of
https://gitee.com/Vancouver2017/luban-lite-t3e-pro.git
synced 2025-12-15 02:48:54 +00:00
371 lines
9.0 KiB
C
371 lines
9.0 KiB
C
/*
|
|
* Copyright (c) 2022-2023, ArtInChip Technology Co., Ltd
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Authors: matteo <duanmt@artinchip.com>
|
|
*/
|
|
|
|
#include <stdbool.h>
|
|
#include <getopt.h>
|
|
#include <string.h>
|
|
#include <drivers/adc.h>
|
|
|
|
#define LOG_TAG "GPAI"
|
|
#include "aic_core.h"
|
|
#include "aic_dma_id.h"
|
|
#include "hal_gpai.h"
|
|
|
|
#define AIC_GPAI_NAME "gpai"
|
|
|
|
struct aic_gpai_dev {
|
|
struct rt_adc_device *dev;
|
|
struct aic_gpai_ch *chan;
|
|
};
|
|
|
|
struct aic_gpai_ch aic_gpai_chs[] = {
|
|
#ifdef AIC_USING_GPAI0
|
|
{
|
|
.id = 0,
|
|
.available = 1,
|
|
#ifdef AIC_GPAI_DRV_V11
|
|
.dma_port_id = DMA_ID_GPAI0,
|
|
#endif
|
|
.obtain_data_mode = AIC_GPAI_OBTAIN_DATA_BY_DMA,
|
|
.smp_period = 1,
|
|
.mode = AIC_GPAI_MODE_PERIOD,
|
|
.fifo_depth = 64,
|
|
},
|
|
#endif
|
|
#ifdef AIC_USING_GPAI1
|
|
{
|
|
.id = 1,
|
|
.available = 1,
|
|
#ifdef AIC_GPAI_DRV_V11
|
|
.dma_port_id = DMA_ID_GPAI1,
|
|
#endif
|
|
.obtain_data_mode = AIC_GPAI_OBTAIN_DATA_BY_CPU,
|
|
.mode = AIC_GPAI_MODE_SINGLE,
|
|
.fifo_depth = 64,
|
|
},
|
|
#endif
|
|
#ifdef AIC_USING_GPAI2
|
|
{
|
|
.id = 2,
|
|
.available = 1,
|
|
#ifdef AIC_GPAI_DRV_V11
|
|
.dma_port_id = DMA_ID_GPAI2,
|
|
#endif
|
|
.obtain_data_mode = AIC_GPAI_OBTAIN_DATA_BY_CPU,
|
|
.smp_period = 1,
|
|
.mode = AIC_GPAI_MODE_PERIOD,
|
|
.fifo_depth = 8,
|
|
},
|
|
#endif
|
|
#ifdef AIC_USING_GPAI3
|
|
{
|
|
.id = 3,
|
|
.available = 1,
|
|
#ifdef AIC_GPAI_DRV_V11
|
|
.dma_port_id = DMA_ID_GPAI3,
|
|
#endif
|
|
.obtain_data_mode = AIC_GPAI_OBTAIN_DATA_BY_CPU,
|
|
.mode = AIC_GPAI_MODE_SINGLE,
|
|
.fifo_depth = 8,
|
|
},
|
|
#endif
|
|
#ifdef AIC_USING_GPAI4
|
|
{
|
|
.id = 4,
|
|
.available = 1,
|
|
#ifdef AIC_GPAI_DRV_V11
|
|
.dma_port_id = DMA_ID_GPAI4,
|
|
#endif
|
|
.obtain_data_mode = AIC_GPAI_OBTAIN_DATA_BY_CPU,
|
|
.mode = AIC_GPAI_MODE_SINGLE,
|
|
.fifo_depth = 8,
|
|
},
|
|
#endif
|
|
#ifdef AIC_USING_GPAI5
|
|
{
|
|
.id = 5,
|
|
.available = 1,
|
|
#ifdef AIC_GPAI_DRV_V11
|
|
.dma_port_id = DMA_ID_GPAI5,
|
|
#endif
|
|
.obtain_data_mode = AIC_GPAI_OBTAIN_DATA_BY_CPU,
|
|
.mode = AIC_GPAI_MODE_SINGLE,
|
|
.fifo_depth = 8,
|
|
},
|
|
#endif
|
|
#ifdef AIC_USING_GPAI6
|
|
{
|
|
.id = 6,
|
|
.available = 1,
|
|
#ifdef AIC_GPAI_DRV_V11
|
|
.dma_port_id = DMA_ID_GPAI6,
|
|
#endif
|
|
.obtain_data_mode = AIC_GPAI_OBTAIN_DATA_BY_CPU,
|
|
.mode = AIC_GPAI_MODE_SINGLE,
|
|
.fifo_depth = 8,
|
|
},
|
|
#endif
|
|
#ifdef AIC_USING_GPAI7
|
|
{
|
|
.id = 7,
|
|
.available = 1,
|
|
#ifdef AIC_GPAI_DRV_V11
|
|
.dma_port_id = DMA_ID_GPAI7,
|
|
#endif
|
|
.obtain_data_mode = AIC_GPAI_OBTAIN_DATA_BY_CPU,
|
|
.mode = AIC_GPAI_MODE_SINGLE,
|
|
.fifo_depth = 8,
|
|
},
|
|
#endif
|
|
#ifdef AIC_GPAI_DRV_V11
|
|
#ifdef AIC_USING_GPAI8
|
|
{
|
|
.id = 8,
|
|
.available = 1,
|
|
.dma_port_id = DMA_ID_GPAI8,
|
|
.obtain_data_mode = AIC_GPAI_OBTAIN_DATA_BY_CPU,
|
|
.mode = AIC_GPAI_MODE_SINGLE,
|
|
.fifo_depth = 8,
|
|
},
|
|
#endif
|
|
#ifdef AIC_USING_GPAI9
|
|
{
|
|
.id = 9,
|
|
.available = 1,
|
|
.dma_port_id = DMA_ID_GPAI9,
|
|
.obtain_data_mode = AIC_GPAI_OBTAIN_DATA_BY_CPU,
|
|
.mode = AIC_GPAI_MODE_SINGLE,
|
|
.fifo_depth = 8,
|
|
},
|
|
#endif
|
|
#ifdef AIC_USING_GPAI10
|
|
{
|
|
.id = 10,
|
|
.available = 1,
|
|
.dma_port_id = DMA_ID_GPAI10,
|
|
.obtain_data_mode = AIC_GPAI_OBTAIN_DATA_BY_CPU,
|
|
.mode = AIC_GPAI_MODE_SINGLE,
|
|
.fifo_depth = 8,
|
|
},
|
|
#endif
|
|
#ifdef AIC_USING_GPAI11
|
|
{
|
|
.id = 11,
|
|
.available = 1,
|
|
.dma_port_id = DMA_ID_GPAI11,
|
|
.obtain_data_mode = AIC_GPAI_OBTAIN_DATA_BY_CPU,
|
|
.mode = AIC_GPAI_MODE_SINGLE,
|
|
.fifo_depth = 8,
|
|
},
|
|
#endif
|
|
#endif
|
|
};
|
|
|
|
static rt_err_t drv_gpai_enabled(struct rt_adc_device *dev,
|
|
rt_uint32_t ch, rt_bool_t enabled)
|
|
{
|
|
struct aic_gpai_ch *chan = hal_gpai_ch_is_valid(ch);
|
|
|
|
hal_gpai_clk_get(chan);
|
|
if (!chan)
|
|
return -RT_EINVAL;
|
|
|
|
if (enabled) {
|
|
aich_gpai_ch_init(chan, chan->pclk_rate);
|
|
chan->irq_count = 0;
|
|
if (chan->mode == AIC_GPAI_MODE_SINGLE) {
|
|
chan->irq_count++;
|
|
chan->complete = aicos_sem_create(0);
|
|
}
|
|
} else {
|
|
aich_gpai_ch_enable(chan->id, 0);
|
|
if (chan->mode == AIC_GPAI_MODE_SINGLE) {
|
|
aicos_sem_delete(chan->complete);
|
|
chan->complete = NULL;
|
|
}
|
|
}
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
static rt_err_t drv_gpai_convert(struct rt_adc_device *dev,
|
|
rt_uint32_t ch, rt_uint32_t *value)
|
|
{
|
|
struct aic_gpai_ch *chan = hal_gpai_ch_is_valid(ch);
|
|
|
|
if (!chan)
|
|
return -RT_EINVAL;
|
|
|
|
return aich_gpai_read(chan, (u32 *)value, AIC_GPAI_TIMEOUT);
|
|
}
|
|
|
|
static rt_uint8_t drv_gpai_resolution(struct rt_adc_device *dev)
|
|
{
|
|
return 12;
|
|
}
|
|
|
|
static rt_uint32_t drv_gpai_get_irq_count(struct rt_adc_device *dev,
|
|
rt_uint32_t channel)
|
|
{
|
|
struct aic_gpai_ch *chan = hal_gpai_ch_is_valid(channel);
|
|
|
|
if (!chan || chan->obtain_data_mode == AIC_GPAI_OBTAIN_DATA_BY_DMA)
|
|
return -RT_EINVAL;
|
|
|
|
return chan->irq_count;
|
|
}
|
|
|
|
#if defined(AIC_GPAI_DRV_V11) && defined(AIC_DMA_DRV)
|
|
static rt_err_t drv_gpai_config_dma(struct rt_adc_device *dev, void *dma_info)
|
|
{
|
|
if (!dma_info)
|
|
return -RT_EINVAL;
|
|
|
|
struct aic_dma_transfer_info *chan_info;
|
|
chan_info = (struct aic_dma_transfer_info *)dma_info;
|
|
struct aic_gpai_ch *chan = hal_gpai_ch_is_valid(chan_info->chan_id);
|
|
|
|
if (!chan || chan->obtain_data_mode == AIC_GPAI_OBTAIN_DATA_BY_CPU)
|
|
return -RT_EINVAL;
|
|
|
|
chan->dma_rx_info.buf = chan_info->buf;
|
|
chan->dma_rx_info.buf_size = chan_info->buf_size;
|
|
chan->dma_rx_info.callback = chan_info->callback;
|
|
chan->dma_rx_info.callback_param = chan_info->callback_param;
|
|
hal_gpai_config_dma(chan);
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
static rt_err_t drv_gpai_get_dma_data(struct rt_adc_device *dev,
|
|
rt_uint32_t channel)
|
|
{
|
|
struct aic_gpai_ch *chan = hal_gpai_ch_is_valid(channel);
|
|
|
|
hal_gpai_start_dma(chan);
|
|
|
|
return RT_EOK;
|
|
}
|
|
#endif
|
|
|
|
static const struct rt_adc_ops aic_adc_ops =
|
|
{
|
|
.enabled = drv_gpai_enabled,
|
|
.convert = drv_gpai_convert,
|
|
#if defined(AIC_GPAI_DRV_V11) && defined(AIC_DMA_DRV)
|
|
.config_dma = drv_gpai_config_dma,
|
|
.get_dma_data = drv_gpai_get_dma_data,
|
|
#endif
|
|
.get_resolution = drv_gpai_resolution,
|
|
.get_irq_count = drv_gpai_get_irq_count,
|
|
};
|
|
|
|
static int drv_gpai_init(void)
|
|
{
|
|
struct rt_adc_device *dev = NULL;
|
|
s32 ret = 0;
|
|
|
|
if (hal_gpai_clk_init())
|
|
return -RT_ERROR;
|
|
|
|
aicos_request_irq(GPAI_IRQn, aich_gpai_isr, 0, NULL, NULL);
|
|
aich_gpai_enable(1);
|
|
hal_gpai_set_ch_num(ARRAY_SIZE(aic_gpai_chs));
|
|
|
|
dev = aicos_malloc(0, sizeof(struct rt_adc_device));
|
|
if (!dev) {
|
|
LOG_E("Failed to malloc(%d)", sizeof(struct rt_adc_device));
|
|
return -RT_ERROR;
|
|
}
|
|
memset(dev, 0, sizeof(struct rt_adc_device));
|
|
|
|
ret = rt_hw_adc_register(dev, AIC_GPAI_NAME, &aic_adc_ops, NULL);
|
|
if (ret) {
|
|
LOG_E("Failed to register ADC. ret %d", ret);
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
INIT_BOARD_EXPORT(drv_gpai_init);
|
|
|
|
#if defined(RT_USING_FINSH)
|
|
#include <finsh.h>
|
|
|
|
static void cmd_gpai_usage(char *program)
|
|
{
|
|
printf("Compile time: %s %s\n", __DATE__, __TIME__);
|
|
printf("Usage: %s [options]\n", program);
|
|
printf("\t -c, --channel\t\tSelect one channel in [0, 7], default is 0\n");
|
|
printf("\t -s, --status\t\tShow more hardware information\n");
|
|
printf("\t -h, --help \n");
|
|
printf("\n");
|
|
printf("Example: %s -c 3 -s\n", program);
|
|
}
|
|
|
|
static void cmd_gpai(int argc, char **argv)
|
|
{
|
|
u32 ch = 0;
|
|
s32 c, val = 0;
|
|
rt_err_t ret = RT_EOK;
|
|
struct rt_adc_device *dev = NULL;
|
|
struct aic_gpai_ch *chan = NULL;
|
|
bool show_status = false;
|
|
const char sopts[] = "c:sh";
|
|
const struct option lopts[] = {
|
|
{"channel", required_argument, NULL, 'c'},
|
|
{"status", no_argument, NULL, 's'},
|
|
{"help", no_argument, NULL, 'h'},
|
|
{0, 0, 0, 0}
|
|
};
|
|
|
|
optind = 0;
|
|
while ((c = getopt_long(argc, argv, sopts, lopts, NULL)) != -1) {
|
|
switch (c) {
|
|
case 'c':
|
|
ch = atoi(optarg);
|
|
if ((ch < 0) || (ch >= AIC_GPAI_CH_NUM)) {
|
|
pr_err("Invalid channel No.%s\n", optarg);
|
|
return;
|
|
}
|
|
continue;
|
|
case 's':
|
|
show_status = true;
|
|
continue;
|
|
case 'h':
|
|
default:
|
|
cmd_gpai_usage(argv[0]);
|
|
return;
|
|
}
|
|
}
|
|
|
|
chan = hal_gpai_ch_is_valid(ch);
|
|
if (!chan)
|
|
return;
|
|
|
|
if (show_status) {
|
|
aich_gpai_status_show(chan);
|
|
return;
|
|
}
|
|
|
|
dev = (struct rt_adc_device *)rt_device_find(AIC_GPAI_NAME);
|
|
if (!dev) {
|
|
LOG_E("Failed to open %s device\n", AIC_GPAI_NAME);
|
|
return;
|
|
}
|
|
ret = rt_adc_enable(dev, ch);
|
|
if (!ret) {
|
|
val = rt_adc_read(dev, ch);
|
|
printf("GPAI ch%d: %d\n", ch, val);
|
|
}
|
|
|
|
rt_adc_disable(dev, ch);
|
|
}
|
|
MSH_CMD_EXPORT_ALIAS(cmd_gpai, gpai, Read the status and data of GPAI);
|
|
|
|
#endif
|