static void tpstest_initTask(void *data) {
struct spi *spi;
struct spi_opt opt = {
.lsb = false,
.cpol = false,
.cpha = true,
.cs = 0,
.csLowInactive = false,
.gpio = SPI_OPT_GPIO_DIS,
.size = 8,
.wdelay = 0,
.cs_hold = 54,
.cs_delay = 54,
.bautrate = 500000
};
struct spi_slave *slave;
spi = spi_init(0, SPI_3WIRE_CS, NULL);
CONFIG_ASSERT(spi != NULL);
slave = spiSlave_init(spi, &opt);
CONFIG_ASSERT(slave != NULL);
tps = tps_init(slave, 100 / portTICK_PERIOD_MS);
CONFIG_ASSERT(tps != NULL);
adc = adc_init(1, 12, 4125000);
CONFIG_ASSERT(adc != NULL);
OS_CREATE_TASK(tpstest_task, "TPS Task", 512, NULL, 1, tpsTask);
vTaskSuspend(NULL);
}
OS_DEFINE_TASK(tpsInitTask, 512);
int32_t tpstest_init() {
OS_CREATE_TASK(tpstest_initTask, "TPS Init Task", 512, NULL, 4, tpsInitTask);
return 0;
}
void mailbox_test() {
BaseType_t ret;
rx = mailbox_init(MAILBOX0_ID);
CONFIG_ASSERT(rx != NULL);
tx = mailbox_init(MAILBOX0_ID);
CONFIG_ASSERT(tx != NULL);
ret = OS_CREATE_TASK(mailbox_testTask, "Mailbox Test Task", 512, NULL, 1, task);
CONFIG_ASSERT(ret == pdPASS);
}
void sdtest_init() {
BaseType_t ret;
struct sd_setting setting = {
.clock = 400000,
.wide = SD_BusWide_1b,
.mode = SD_SD,
};
sd = sd_init(SDIO_ID, &setting);
CONFIG_ASSERT(sd != NULL);
ret = OS_CREATE_TASK(sdtest_task, "SD Test Task", 512, NULL, 1, sdTask);
CONFIG_ASSERT(ret == pdPASS);
}
int32_t adctest_init() {
struct adc *adc = adc_init(0, 12, 4125000);
/*struct adc *adc = adc_init(1, 12, 40000000);*/ /* DIV = 1 */
/*struct adc *adc = adc_init(1, 12, 13200000);*/ /* DIV = 5 ~ 4 */
/*struct adc *adc = adc_init(1, 12, 9428571);*/ /* DIV = 7 ~ 8 */
/*struct adc *adc = adc_init(1, 12, 6000000);*/ /* DIV = 11 ~ 8 */
/*struct adc *adc = adc_init(1, 12, 4400000);*/ /* DIV = 15 ~ 16 */
CONFIG_ASSERT(adc != NULL);
OS_CREATE_TASK(adctestTask, "ADC Test Task", 512, adc, 1, adcTask);
return 0;
}
void boardtest_init() {
int32_t ret;
int32_t i;
struct gpio *gpio = gpio_init(GPIO_ID);
CONFIG_ASSERT(gpio != NULL);
for (i = 0; i < ARRAY_SIZE(pinIds); i++) {
printf("pinID: %s 0x%lx\n", pinIds[i].name, pinIds[i].pinID);
pins[i] = gpioPin_init(gpio, pinIds[i].pinID, GPIO_OUTPUT, GPIO_PULL_UP);
CONFIG_ASSERT(pins[i] != NULL);
}
for (i = 0; i < ARRAY_SIZE(buttonIDs); i++) {
buttons[i] = gpioPin_init(gpio, buttonIDs[i].pinID, GPIO_INPUT, GPIO_OPEN);
CONFIG_ASSERT(buttons[i] != NULL);
ret = gpioPin_setCallback(buttons[i], buttonHandler, NULL, GPIO_RISING);
CONFIG_ASSERT(ret >= 0);
ret = gpioPin_enableInterrupt(buttons[i]);
CONFIG_ASSERT(ret >= 0);
}
ret = OS_CREATE_TASK(boardtest_task, "Board test task", 512, NULL, 1, boardTask);
CONFIG_ASSERT(ret == pdPASS);
}
void spitest_init() {
#if 1
struct spi *spi;
static struct spi_slave *slave[3];
struct spi_opt opt = {
.lsb = false,
.cpol = false,
.cpha = false,
.cs = 0,
.csLowInactive = false,
.gpio = SPI_OPT_GPIO_DIS,
.size = 8,
.wdelay = 0,
.cs_hold = 8,
.cs_delay = 500,
.bautrate = 500000,
};
spi = spi_init(1, SPI_3WIRE_CS, NULL);
CONFIG_ASSERT(spi != NULL);
slave[0] = spiSlave_init(spi, &opt);
CONFIG_ASSERT(slave[0] != NULL);
opt.cs_hold = 6;
opt.cs_delay = 8;
opt.cs = 1;
slave[1] = spiSlave_init(spi, &opt);
CONFIG_ASSERT(slave[1] != NULL);
opt.cs = 2;
slave[2] = spiSlave_init(spi, &opt);
CONFIG_ASSERT(slave[2] != NULL);
#else
struct spi *spi;
static struct spi_slave *slave[3];
struct spi_ops ops = {
.lsb = false,
.cpol = false,
.cpha = false,
.cs = SPI_OPT_CS_DIS,
.csLowInactive = false,
.gpio = PTD5,
.size = 8,
.wdelay = 0,
.cs_hold = 8,
.cs_delay = 500,
.bautrate = 500000,
};
spi = spi_init(1);
CONFIG_ASSERT(spi != NULL);
ops.cpol = false;
ops.cpha = false;
ops.gpio = PTD5; /* CS 0 */
slave[0] = spi_slave(spi, &ops);
CONFIG_ASSERT(slave[0] != NULL);
ops.cpol = false;
ops.cpha = false;
ops.cs_hold = 6;
ops.cs_delay = 8;
ops.gpio = PTD4; /* CS 1 */
slave[1] = spi_slave(spi, &ops);
CONFIG_ASSERT(slave[1] != NULL);
ops.cpol = false;
ops.cpha = false;
ops.gpio = PTD3; /* CS 2 */
slave[2] = spi_slave(spi, &ops);
CONFIG_ASSERT(slave[2] != NULL);
#endif
OS_CREATE_TASK(spiTask, "SPI Test Task", 512, slave, 1, taskSPI);
}
void bt_fw_create_stack_tasks( void )
{
/* Create HCI Transport Driver Tasks */
BT_FW_TASKS_PRIORITY task_priority ;
task_priority = HCI_TD_TASK_PRI ;
if(OS_CREATE_TASK(&hci_td_task_handle, HCI_TD_TASK_NAME,
(UCHAR)task_priority,
(OS_TASK_FUNCTION) hci_td_process_signal,
HCI_TD_TASK_Q_SIZE, HCI_TD_TASK_BUSY_PERIOD )
!= BT_ERROR_OK )
{
BT_FW_ERR(CREATION_OF_HCI_COMMAND_TASK_FAILED,0,0);
return;
}
/* Creating HCI command task */
task_priority = HCI_CMD_TASK_PRI ;
if(OS_CREATE_TASK(&hci_command_task_handle, HCI_CMD_TASK_NAME,
(UCHAR)task_priority, (OS_TASK_FUNCTION) HCI_Command_Task,
HCI_CMD_TASK_Q_SIZE, HCI_CMD_TASK_BUSY_PERIOD )
!= BT_ERROR_OK )
{
BT_FW_ERR(CREATION_OF_HCI_COMMAND_TASK_FAILED,0,0);
return;
}
/* Creating HCI event task */
task_priority = HCI_EVENT_TASK_PRI ;
if(OS_CREATE_TASK(&hci_event_task_handle, HCI_EVENT_TASK_NAME,
(UCHAR)task_priority,(OS_TASK_FUNCTION) HCI_Event_Task,
HCI_EVENT_TASK_Q_SIZE, HCI_EVENT_TASK_BUSY_PERIOD )
!= BT_ERROR_OK)
{
BT_FW_ERR(CREATION_OF_HCI_COMMAND_TASK_FAILED,0,0);
return;
}
/*
* Create LMP Tasks
*/
/* Creating LMP task */
task_priority = LMP_TASK_PRI ;
if(OS_CREATE_TASK( &lmp_task_handle, LMP_TASK_NAME,
(UINT8)task_priority, (OS_TASK_FUNCTION) LMP_Task,
LMP_TASK_Q_SIZE, LMP_TASK_BUSY_PERIOD ) != BT_ERROR_OK)
{
BT_FW_ERR(CREATION_OF_LMP_TASK_FAILED,0,0);
return;
}
/*
* Create LC Tasks
*/
/* Creating LC TX task */
task_priority = LC_TX_TASK_PRI ;
if(OS_CREATE_TASK(&lc_tx_task_handle,LC_TX_TASK_NAME,
(UCHAR)task_priority,
(OS_TASK_FUNCTION) lc_tx_task,
(UINT32)LC_TX_TASK_Q_SIZE,
(UINT16)LC_TX_TASK_BUSY_PERIOD) != BT_ERROR_OK)
{
/* For the time being keep it HCI_log only */
BT_FW_ERR(CREATION_OF_LC_TX_TASK_FAILED,0,0);
return ;
}
/* Creating LC RX task */
task_priority = LC_RX_TASK_PRI;
if(OS_CREATE_TASK( &lc_rx_task_handle, LC_RX_TASK_NAME,
(UINT8)task_priority,
(OS_TASK_FUNCTION)lc_rx_task,
LC_RX_TASK_Q_SIZE,
LC_RX_TASK_BUSY_PERIOD) != BT_ERROR_OK)
{
/* For the time being keep it HCI_log only */
BT_FW_ERR(CREATION_OF_LC_RX_TASK_FAILED,0,0);
return ;
}
#ifdef COMPILE_AFH_HOP_KERNEL
task_priority = CH_AS_TASK_PRI ;
if(OS_CREATE_TASK( &hci_ch_as_task_handle, LMP_CH_TASK_NAME,
(UINT8)task_priority,
(OS_TASK_FUNCTION)hci_ch_as_task,
CH_AS_TASK_Q_SIZE,
CH_AS_TASK_BUSY_PERIOD) != BT_ERROR_OK)
{
/* For the time being keep it HCI_log only */
BT_FW_ERR(CREATION_OF_CH_AS_TASK_FAILED,0,0);
return ;
}
#endif
return;
}
