static void h5_init(void)
{
BT_DBG("");
h5.link_state = UNINIT;
h5.rx_state = START;
h5.tx_win = 4;
/* TX thread */
k_fifo_init(&h5.tx_queue);
k_thread_create(&tx_thread_data, tx_stack,
K_THREAD_STACK_SIZEOF(tx_stack),
(k_thread_entry_t)tx_thread, NULL, NULL, NULL,
K_PRIO_COOP(CONFIG_BT_HCI_TX_PRIO),
0, K_NO_WAIT);
k_fifo_init(&h5.rx_queue);
k_thread_create(&rx_thread_data, rx_stack,
K_THREAD_STACK_SIZEOF(rx_stack),
(k_thread_entry_t)rx_thread, NULL, NULL, NULL,
K_PRIO_COOP(CONFIG_BT_RX_PRIO),
0, K_NO_WAIT);
/* Unack queue */
k_fifo_init(&h5.unack_queue);
/* Init delayed work */
k_delayed_work_init(&ack_work, ack_timeout);
k_delayed_work_init(&retx_work, retx_timeout);
}
void test_priority_preemptible(void)
{
int old_prio = k_thread_priority_get(k_current_get());
/* set current thread to a non-negative priority */
last_prio = 2;
k_thread_priority_set(k_current_get(), last_prio);
int spawn_prio = last_prio - 1;
k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
thread_entry, NULL, NULL, NULL,
spawn_prio, 0, 0);
/* checkpoint: thread is preempted by higher thread */
zassert_true(last_prio == spawn_prio, NULL);
k_sleep(100);
k_thread_abort(tid);
spawn_prio = last_prio + 1;
tid = k_thread_create(&tdata, tstack, STACK_SIZE,
thread_entry, NULL, NULL, NULL,
spawn_prio, 0, 0);
/* checkpoint: thread is not preempted by lower thread */
zassert_false(last_prio == spawn_prio, NULL);
k_thread_abort(tid);
/* restore environment */
k_thread_priority_set(k_current_get(), old_prio);
}
void main(void)
{
int status = TC_FAIL;
u32_t start_tick;
u32_t end_tick;
TC_START("Test kernel Sleep and Wakeup APIs\n");
test_objects_init();
test_thread_id = k_thread_create(&test_thread_data, test_thread_stack,
THREAD_STACK,
(k_thread_entry_t) test_thread,
0, 0, NULL, TEST_THREAD_PRIORITY,
0, 0);
TC_PRINT("Test thread started: id = %p\n", test_thread_id);
helper_thread_id = k_thread_create(&helper_thread_data,
helper_thread_stack, THREAD_STACK,
(k_thread_entry_t) helper_thread,
0, 0, NULL, HELPER_THREAD_PRIORITY,
0, 0);
TC_PRINT("Helper thread started: id = %p\n", helper_thread_id);
/* Activate test_thread */
k_sem_give(&test_thread_sem);
/* Wait for test_thread to activate us */
k_sem_take(&task_sem, K_FOREVER);
/* Wake the test fiber */
k_wakeup(test_thread_id);
if (test_failure) {
goto done_tests;
}
TC_PRINT("Testing kernel k_sleep()\n");
align_to_tick_boundary();
start_tick = k_uptime_get_32();
/* FIXME: one tick less to account for
* one extra tick for _TICK_ALIGN in k_sleep*/
k_sleep(ONE_SECOND - TICKS_PER_MS);
end_tick = k_uptime_get_32();
if (!sleep_time_valid(start_tick, end_tick, ONE_SECOND)) {
TC_ERROR("k_sleep() slept for %d ticks, not %d\n",
end_tick - start_tick, ONE_SECOND);
goto done_tests;
}
status = TC_PASS;
done_tests:
TC_END_REPORT(status);
}
static int h4_open(void)
{
BT_DBG("");
uart_irq_rx_disable(h4_dev);
uart_irq_tx_disable(h4_dev);
#if defined(CONFIG_BT_NRF51_PM)
if (nrf51_init(h4_dev) < 0) {
return -EIO;
}
#else
h4_discard(h4_dev, 32);
#endif
uart_irq_callback_set(h4_dev, bt_uart_isr);
k_thread_create(&rx_thread_data, rx_thread_stack,
K_THREAD_STACK_SIZEOF(rx_thread_stack),
rx_thread, NULL, NULL, NULL,
K_PRIO_COOP(CONFIG_BT_RX_PRIO),
0, K_NO_WAIT);
return 0;
}
void main(void)
{
int err;
init_app();
err = bt_enable(NULL);
if (err) {
printk("Bluetooth init failed (err %d)\n", err);
return;
}
printk("Bluetooth initialized\n");
ipss_init();
err = ipss_advertise();
if (err) {
printk("Advertising failed to start (err %d)\n", err);
return;
}
printk("Advertising successfully started\n");
k_thread_create(&thread_data, thread_stack, STACKSIZE,
(k_thread_entry_t)listen,
NULL, NULL, NULL, K_PRIO_COOP(7), 0, 0);
}
static int nrf5_init(struct device *dev)
{
const struct nrf5_802154_config *nrf5_radio_cfg = NRF5_802154_CFG(dev);
struct nrf5_802154_data *nrf5_radio = NRF5_802154_DATA(dev);
struct device *clk_m16;
k_sem_init(&nrf5_radio->rx_wait, 0, 1);
k_sem_init(&nrf5_radio->tx_wait, 0, 1);
k_sem_init(&nrf5_radio->cca_wait, 0, 1);
clk_m16 = device_get_binding(CONFIG_CLOCK_CONTROL_NRF5_M16SRC_DRV_NAME);
if (!clk_m16) {
return -ENODEV;
}
clock_control_on(clk_m16, NULL);
nrf_drv_radio802154_init();
nrf5_radio_cfg->irq_config_func(dev);
k_thread_create(&nrf5_radio->rx_thread, nrf5_radio->rx_stack,
CONFIG_IEEE802154_NRF5_RX_STACK_SIZE,
nrf5_rx_thread, dev, NULL, NULL,
K_PRIO_COOP(2), 0, 0);
SYS_LOG_INF("nRF5 802154 radio initialized");
return 0;
}
static void threads_suspend_resume(int prio)
{
int old_prio = k_thread_priority_get(k_current_get());
/* set current thread */
last_prio = prio;
k_thread_priority_set(k_current_get(), last_prio);
/* create thread with lower priority */
int create_prio = last_prio + 1;
k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
thread_entry, NULL, NULL, NULL,
create_prio, 0, 0);
/* checkpoint: suspend current thread */
k_thread_suspend(tid);
k_sleep(100);
/* checkpoint: created thread shouldn't be executed after suspend */
zassert_false(last_prio == create_prio, NULL);
k_thread_resume(tid);
k_sleep(100);
/* checkpoint: created thread should be executed after resume */
zassert_true(last_prio == create_prio, NULL);
k_thread_abort(tid);
/* restore environment */
k_thread_priority_set(k_current_get(), old_prio);
}
static int start_https(struct http_client_ctx *ctx)
{
struct k_sem startup_sync;
/* Start the thread that handles HTTPS traffic. */
if (ctx->https.tid) {
return -EALREADY;
}
NET_DBG("Starting HTTPS thread for %p", ctx);
k_sem_init(&startup_sync, 0, 1);
ctx->https.tid = k_thread_create(&ctx->https.thread,
ctx->https.stack,
ctx->https.stack_size,
(k_thread_entry_t)https_handler,
ctx, &startup_sync, 0,
K_PRIO_COOP(7), 0, 0);
/* Wait until we know that the HTTPS thread startup was ok */
if (k_sem_take(&startup_sync, HTTPS_STARTUP_TIMEOUT) < 0) {
https_shutdown(ctx);
return -ECANCELED;
}
NET_DBG("HTTPS thread %p started for %p", ctx->https.tid, ctx);
return 0;
}
int bmg160_trigger_init(struct device *dev)
{
const struct bmg160_device_config *cfg = dev->config->config_info;
struct bmg160_device_data *bmg160 = dev->driver_data;
/* set INT1 pin to: push-pull, active low */
if (bmg160_write_byte(dev, BMG160_REG_INT_EN1, 0) < 0) {
SYS_LOG_DBG("Failed to select interrupt pins type.");
return -EIO;
}
/* set interrupt mode to non-latched */
if (bmg160_write_byte(dev, BMG160_REG_INT_RST_LATCH, 0) < 0) {
SYS_LOG_DBG("Failed to set the interrupt mode.");
return -EIO;
}
/* map anymotion and high rate interrupts to INT1 pin */
if (bmg160_write_byte(dev, BMG160_REG_INT_MAP0,
BMG160_INT1_ANY | BMG160_INT1_HIGH) < 0) {
SYS_LOG_DBG("Unable to map interrupts.");
return -EIO;
}
/* map data ready, FIFO and FastOffset interrupts to INT1 pin */
if (bmg160_write_byte(dev, BMG160_REG_INT_MAP1,
BMG160_INT1_DATA | BMG160_INT1_FIFO |
BMG160_INT1_FAST_OFFSET) < 0) {
SYS_LOG_DBG("Unable to map interrupts.");
return -EIO;
}
bmg160->gpio = device_get_binding((char *)cfg->gpio_port);
if (!bmg160->gpio) {
SYS_LOG_DBG("Gpio controller %s not found", cfg->gpio_port);
return -EINVAL;
}
#if defined(CONFIG_BMG160_TRIGGER_OWN_THREAD)
k_sem_init(&bmg160->trig_sem, 0, UINT_MAX);
k_thread_create(&bmg160_thread, bmg160_thread_stack,
CONFIG_BMG160_THREAD_STACK_SIZE, bmg160_thread_main,
dev, NULL, NULL, K_PRIO_COOP(10), 0, 0);
#elif defined(CONFIG_BMG160_TRIGGER_GLOBAL_THREAD)
bmg160->work.handler = bmg160_work_cb;
bmg160->dev = dev;
#endif
gpio_pin_configure(bmg160->gpio, cfg->int_pin,
GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE |
GPIO_INT_ACTIVE_LOW | GPIO_INT_DEBOUNCE);
gpio_init_callback(&bmg160->gpio_cb, bmg160_gpio_callback,
BIT(cfg->int_pin));
gpio_add_callback(bmg160->gpio, &bmg160->gpio_cb);
gpio_pin_enable_callback(bmg160->gpio, cfg->int_pin);
return 0;
}
/*
* SimpleLink does not have an init hook, so we export this function to
* be called early during system initialization.
*/
static int dpl_zephyr_init(struct device *port)
{
(void)k_thread_create(&spawn_task_data, spawn_task_stack,
SPAWN_TASK_STACKSIZE, spawn_task,
NULL, NULL, NULL,
SPAWN_TASK_PRIORITY, 0, K_NO_WAIT);
return 0;
}
static void create_rx_handler(struct eth_context *ctx)
{
k_thread_create(&rx_thread_data, eth_rx_stack,
K_THREAD_STACK_SIZEOF(eth_rx_stack),
(k_thread_entry_t)eth_rx,
ctx, NULL, NULL, K_PRIO_COOP(14),
0, K_NO_WAIT);
}
static void init_rx_queue(void)
{
k_fifo_init(&rx_queue);
k_thread_create(&rx_thread_data, rx_stack,
K_THREAD_STACK_SIZEOF(rx_stack),
(k_thread_entry_t)rx_thread,
NULL, NULL, NULL, K_PRIO_COOP(8), 0, K_NO_WAIT);
}
static int lwm2m_rd_client_init(struct device *dev)
{
k_thread_create(&lwm2m_rd_client_thread_data,
&lwm2m_rd_client_thread_stack[0],
K_THREAD_STACK_SIZEOF(lwm2m_rd_client_thread_stack),
(k_thread_entry_t) lwm2m_rd_client_service,
NULL, NULL, NULL, K_PRIO_COOP(7), 0, K_NO_WAIT);
SYS_LOG_DBG("LWM2M RD client thread started");
return 0;
}
static void init_tx_queue(void)
{
k_sem_init(&tx_sem, 0, UINT_MAX);
k_fifo_init(&tx_queue);
k_thread_create(&tx_thread_data, tx_stack,
K_THREAD_STACK_SIZEOF(tx_stack),
(k_thread_entry_t)tx_thread,
NULL, NULL, NULL, K_PRIO_COOP(8), 0, K_NO_WAIT);
}
static void tsema_thread_thread(struct k_sem *psem)
{
/**TESTPOINT: thread-thread sync via sema*/
k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
tThread_entry, psem, NULL, NULL,
K_PRIO_PREEMPT(0), 0, 0);
zassert_false(k_sem_take(psem, K_FOREVER), NULL);
/*clean the spawn thread avoid side effect in next TC*/
k_thread_abort(tid);
}
void test_threads_abort_self(void)
{
execute_flag = 0;
k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
thread_entry_abort, NULL, NULL, NULL,
0, 0, 0);
k_sleep(100);
/**TESTPOINT: spawned thread executed but abort itself*/
zassert_true(execute_flag == 1, NULL);
k_thread_abort(tid);
}
void main(void)
{
if (init_app() != 0) {
printk("Cannot initialize network\n");
return;
}
k_thread_create(&thread_data, stack, STACK_SIZE,
(k_thread_entry_t) dtls_server,
NULL, NULL, NULL, K_PRIO_COOP(7), 0, 0);
}
int lsm6dsl_init_interrupt(struct device *dev)
{
struct lsm6dsl_data *drv_data = dev->driver_data;
/* setup data ready gpio interrupt */
drv_data->gpio = device_get_binding(CONFIG_LSM6DSL_GPIO_DEV_NAME);
if (drv_data->gpio == NULL) {
SYS_LOG_ERR("Cannot get pointer to %s device.",
CONFIG_LSM6DSL_GPIO_DEV_NAME);
return -EINVAL;
}
gpio_pin_configure(drv_data->gpio, CONFIG_LSM6DSL_GPIO_PIN_NUM,
GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE |
GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE);
gpio_init_callback(&drv_data->gpio_cb,
lsm6dsl_gpio_callback,
BIT(CONFIG_LSM6DSL_GPIO_PIN_NUM));
if (gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb) < 0) {
SYS_LOG_ERR("Could not set gpio callback.");
return -EIO;
}
/* enable data-ready interrupt */
if (drv_data->hw_tf->update_reg(drv_data,
LSM6DSL_REG_INT1_CTRL,
LSM6DSL_SHIFT_INT1_CTRL_DRDY_XL |
LSM6DSL_SHIFT_INT1_CTRL_DRDY_G,
(1 << LSM6DSL_SHIFT_INT1_CTRL_DRDY_XL) |
(1 << LSM6DSL_SHIFT_INT1_CTRL_DRDY_G)) < 0) {
SYS_LOG_ERR("Could not enable data-ready interrupt.");
return -EIO;
}
#if defined(CONFIG_LSM6DSL_TRIGGER_OWN_THREAD)
k_sem_init(&drv_data->gpio_sem, 0, UINT_MAX);
k_thread_create(&drv_data->thread, drv_data->thread_stack,
CONFIG_LSM6DSL_THREAD_STACK_SIZE,
(k_thread_entry_t)lsm6dsl_thread, dev,
0, NULL, K_PRIO_COOP(CONFIG_LSM6DSL_THREAD_PRIORITY),
0, 0);
#elif defined(CONFIG_LSM6DSL_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = lsm6dsl_work_cb;
drv_data->dev = dev;
#endif
gpio_pin_enable_callback(drv_data->gpio, CONFIG_LSM6DSL_GPIO_PIN_NUM);
return 0;
}
void test_pipe_get_put(void)
{
/**TESTPOINT: test API sequence: [get, put]*/
k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
tThread_block_put, &kpipe, NULL, NULL,
K_PRIO_PREEMPT(0), 0, 0);
/*get will be executed previor to put*/
tpipe_get(&kpipe);
k_sem_take(&end_sema, K_FOREVER);
k_thread_abort(tid);
}
int lis2dw12_init_interrupt(struct device *dev)
{
struct lis2dw12_data *lis2dw12 = dev->driver_data;
const struct lis2dw12_device_config *cfg = dev->config->config_info;
int ret;
/* setup data ready gpio interrupt (INT1 or INT2) */
lis2dw12->gpio = device_get_binding(cfg->int_gpio_port);
if (lis2dw12->gpio == NULL) {
LOG_DBG("Cannot get pointer to %s device",
cfg->int_gpio_port);
return -EINVAL;
}
#if defined(CONFIG_LIS2DW12_TRIGGER_OWN_THREAD)
k_sem_init(&lis2dw12->gpio_sem, 0, UINT_MAX);
k_thread_create(&lis2dw12->thread, lis2dw12->thread_stack,
CONFIG_LIS2DW12_THREAD_STACK_SIZE,
(k_thread_entry_t)lis2dw12_thread, dev,
0, NULL, K_PRIO_COOP(CONFIG_LIS2DW12_THREAD_PRIORITY),
0, 0);
#elif defined(CONFIG_LIS2DW12_TRIGGER_GLOBAL_THREAD)
lis2dw12->work.handler = lis2dw12_work_cb;
lis2dw12->dev = dev;
#endif /* CONFIG_LIS2DW12_TRIGGER_OWN_THREAD */
ret = gpio_pin_configure(lis2dw12->gpio, cfg->int_gpio_pin,
GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE |
GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE);
if (ret < 0) {
LOG_DBG("Could not configure gpio");
return ret;
}
gpio_init_callback(&lis2dw12->gpio_cb,
lis2dw12_gpio_callback,
BIT(cfg->int_gpio_pin));
if (gpio_add_callback(lis2dw12->gpio, &lis2dw12->gpio_cb) < 0) {
LOG_DBG("Could not set gpio callback");
return -EIO;
}
/* enable interrupt on int1/int2 in pulse mode */
if (lis2dw12->hw_tf->update_reg(lis2dw12, LIS2DW12_CTRL3_ADDR,
LIS2DW12_LIR_MASK, LIS2DW12_DIS_BIT)) {
return -EIO;
}
return gpio_pin_enable_callback(lis2dw12->gpio, cfg->int_gpio_pin);
}
void test_pipe_block_put(void)
{
/**TESTPOINT: test k_pipe_block_put without semaphore*/
k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
tThread_block_put, &kpipe, NULL, NULL,
K_PRIO_PREEMPT(0), 0, 0);
k_sleep(10);
tpipe_get(&kpipe);
k_sem_take(&end_sema, K_FOREVER);
k_thread_abort(tid);
}
void test_threads_abort_others(void)
{
execute_flag = 0;
k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
thread_entry, NULL, NULL, NULL,
0, 0, 0);
k_thread_abort(tid);
k_sleep(100);
/**TESTPOINT: check not-started thread is aborted*/
zassert_true(execute_flag == 0, NULL);
tid = k_thread_create(&tdata, tstack, STACK_SIZE,
thread_entry, NULL, NULL, NULL,
0, 0, 0);
k_sleep(50);
k_thread_abort(tid);
/**TESTPOINT: check running thread is aborted*/
zassert_true(execute_flag == 1, NULL);
k_sleep(1000);
zassert_true(execute_flag == 1, NULL);
}
int mpu6050_init_interrupt(struct device *dev)
{
struct mpu6050_data *drv_data = dev->driver_data;
/* setup data ready gpio interrupt */
drv_data->gpio = device_get_binding(CONFIG_MPU6050_GPIO_DEV_NAME);
if (drv_data->gpio == NULL) {
SYS_LOG_ERR("Failed to get pointer to %s device",
CONFIG_MPU6050_GPIO_DEV_NAME);
return -EINVAL;
}
gpio_pin_configure(drv_data->gpio, CONFIG_MPU6050_GPIO_PIN_NUM,
GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE |
GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE);
gpio_init_callback(&drv_data->gpio_cb,
mpu6050_gpio_callback,
BIT(CONFIG_MPU6050_GPIO_PIN_NUM));
if (gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb) < 0) {
SYS_LOG_ERR("Failed to set gpio callback");
return -EIO;
}
/* enable data ready interrupt */
if (i2c_reg_write_byte(drv_data->i2c, CONFIG_MPU6050_I2C_ADDR,
MPU6050_REG_INT_EN, MPU6050_DRDY_EN) < 0) {
SYS_LOG_ERR("Failed to enable data ready interrupt.");
return -EIO;
}
#if defined(CONFIG_MPU6050_TRIGGER_OWN_THREAD)
k_sem_init(&drv_data->gpio_sem, 0, UINT_MAX);
k_thread_create(&drv_data->thread, drv_data->thread_stack,
CONFIG_MPU6050_THREAD_STACK_SIZE,
(k_thread_entry_t)mpu6050_thread, dev,
0, NULL, K_PRIO_COOP(CONFIG_MPU6050_THREAD_PRIORITY),
0, 0);
#elif defined(CONFIG_MPU6050_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = mpu6050_work_cb;
drv_data->dev = dev;
#endif
gpio_pin_enable_callback(drv_data->gpio, CONFIG_MPU6050_GPIO_PIN_NUM);
return 0;
}
void test_pipe_block_put_sema(void)
{
struct k_sem sync_sema;
k_sem_init(&sync_sema, 0, 1);
/**TESTPOINT: test k_pipe_block_put with semaphore*/
k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
tThread_block_put, &pipe, &sync_sema, NULL,
K_PRIO_PREEMPT(0), 0, 0);
k_sleep(10);
tpipe_get(&pipe);
k_sem_take(&end_sema, K_FOREVER);
k_thread_abort(tid);
}
static void tmutex_test_lock(struct k_mutex *pmutex,
void (*entry_fn)(void *, void *, void *))
{
k_mutex_init(pmutex);
k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
entry_fn, pmutex, NULL, NULL,
K_PRIO_PREEMPT(0), 0, 0);
k_mutex_lock(pmutex, K_FOREVER);
TC_PRINT("access resource from main thread\n");
/* wait for spawn thread to take action */
k_sleep(TIMEOUT);
/* teardown */
k_thread_abort(tid);
}
int eswifi_spi_init(struct eswifi_dev *eswifi)
{
struct eswifi_spi_data *spi = &eswifi_spi0; /* Static instance */
/* SPI DEV */
spi->spi_dev = device_get_binding(DT_INVENTEK_ESWIFI_ESWIFI0_BUS_NAME);
if (!spi->spi_dev) {
LOG_ERR("Failed to initialize SPI driver");
return -ENODEV;
}
/* SPI DATA READY PIN */
spi->dr.dev = device_get_binding(
DT_INVENTEK_ESWIFI_ESWIFI0_DATA_GPIOS_CONTROLLER);
if (!spi->dr.dev) {
LOG_ERR("Failed to initialize GPIO driver: %s",
DT_INVENTEK_ESWIFI_ESWIFI0_DATA_GPIOS_CONTROLLER);
return -ENODEV;
}
spi->dr.pin = DT_INVENTEK_ESWIFI_ESWIFI0_DATA_GPIOS_PIN;
gpio_pin_configure(spi->dr.dev, spi->dr.pin, GPIO_DIR_IN);
/* SPI CONFIG/CS */
spi->spi_cfg.frequency = DT_INVENTEK_ESWIFI_ESWIFI0_SPI_MAX_FREQUENCY;
spi->spi_cfg.operation = (SPI_OP_MODE_MASTER | SPI_TRANSFER_MSB |
SPI_WORD_SET(16) | SPI_LINES_SINGLE |
SPI_HOLD_ON_CS | SPI_LOCK_ON);
spi->spi_cfg.slave = DT_INVENTEK_ESWIFI_ESWIFI0_BASE_ADDRESS;
spi->spi_cs.gpio_dev =
device_get_binding(DT_INVENTEK_ESWIFI_ESWIFI0_CS_GPIO_CONTROLLER);
spi->spi_cs.gpio_pin = DT_INVENTEK_ESWIFI_ESWIFI0_CS_GPIO_PIN;
spi->spi_cs.delay = 1000;
spi->spi_cfg.cs = &spi->spi_cs;
eswifi->bus_data = spi;
LOG_DBG("success");
k_thread_create(&spi->poll_thread, eswifi_spi_poll_stack,
ESWIFI_SPI_THREAD_STACK_SIZE,
(k_thread_entry_t)eswifi_spi_poll_thread, eswifi, NULL,
NULL, K_PRIO_COOP(CONFIG_WIFI_ESWIFI_THREAD_PRIO), 0,
K_NO_WAIT);
return 0;
}
static void tpipe_thread_thread(struct k_pipe *ppipe)
{
k_sem_init(&end_sema, 0, 1);
/**TESTPOINT: thread-thread data passing via pipe*/
k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
tThread_entry, ppipe, NULL, NULL,
K_PRIO_PREEMPT(0), 0, 0);
tpipe_put(ppipe);
k_sem_take(&end_sema, K_FOREVER);
k_sem_take(&end_sema, K_FOREVER);
tpipe_get(ppipe);
/* clear the spawned thread avoid side effect */
k_thread_abort(tid);
}
void tester_init(void)
{
int i;
for (i = 0; i < CMD_QUEUED; i++) {
k_fifo_put(&avail_queue, &cmd_buf[i * BTP_MTU]);
}
k_thread_create(&cmd_thread, stack, STACKSIZE, cmd_handler,
NULL, NULL, NULL, K_PRIO_COOP(7), 0, K_NO_WAIT);
uart_pipe_register(k_fifo_get(&avail_queue, K_NO_WAIT),
BTP_MTU, recv_cb);
tester_send(BTP_SERVICE_ID_CORE, CORE_EV_IUT_READY, BTP_INDEX_NONE,
NULL, 0);
}
/*test cases*/
void test_threads_cancel_undelayed(void)
{
int cur_prio = k_thread_priority_get(k_current_get());
/* spawn thread with lower priority */
int spawn_prio = cur_prio + 1;
k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
thread_entry, NULL, NULL, NULL,
spawn_prio, 0, 0);
/**TESTPOINT: check cancel retcode when thread is not delayed*/
int cancel_ret = k_thread_cancel(tid);
zassert_equal(cancel_ret, -EINVAL, NULL);
k_thread_abort(tid);
}
int bmi160_trigger_mode_init(struct device *dev)
{
struct bmi160_device_data *bmi160 = dev->driver_data;
const struct bmi160_device_config *cfg = dev->config->config_info;
bmi160->gpio = device_get_binding((char *)cfg->gpio_port);
if (!bmi160->gpio) {
LOG_DBG("Gpio controller %s not found.", cfg->gpio_port);
return -EINVAL;
}
#if defined(CONFIG_BMI160_TRIGGER_OWN_THREAD)
k_sem_init(&bmi160->sem, 0, UINT_MAX);
k_thread_create(&bmi160_thread, bmi160_thread_stack,
CONFIG_BMI160_THREAD_STACK_SIZE,
bmi160_thread_main, dev, NULL, NULL,
K_PRIO_COOP(CONFIG_BMI160_THREAD_PRIORITY), 0, 0);
#elif defined(CONFIG_BMI160_TRIGGER_GLOBAL_THREAD)
bmi160->work.handler = bmi160_work_handler;
bmi160->dev = dev;
#endif
/* map all interrupts to INT1 pin */
if (bmi160_word_write(dev, BMI160_REG_INT_MAP0, 0xf0ff) < 0) {
LOG_DBG("Failed to map interrupts.");
return -EIO;
}
gpio_pin_configure(bmi160->gpio, cfg->int_pin,
GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE |
GPIO_INT_ACTIVE_LOW | GPIO_INT_DEBOUNCE);
gpio_init_callback(&bmi160->gpio_cb,
bmi160_gpio_callback,
BIT(cfg->int_pin));
gpio_add_callback(bmi160->gpio, &bmi160->gpio_cb);
gpio_pin_enable_callback(bmi160->gpio, cfg->int_pin);
return bmi160_byte_write(dev, BMI160_REG_INT_OUT_CTRL,
BMI160_INT1_OUT_EN | BMI160_INT1_EDGE_CTRL);
}