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); }
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 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; }
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; }
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; }
static void init_tx_queue(void) { /* Transmit queue init */ k_fifo_init(&tx_queue); k_thread_spawn(tx_stack, sizeof(tx_stack), (k_thread_entry_t)tx_thread, NULL, NULL, NULL, K_PRIO_COOP(8), 0, K_NO_WAIT); }
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); rx_tid = k_thread_spawn(rx_stack, sizeof(rx_stack), (k_thread_entry_t)net_rx_thread, NULL, NULL, NULL, K_PRIO_COOP(8), K_ESSENTIAL, 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 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 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; }
void main(void) { if (init_app() != 0) { printf("Cannot initialize network\n"); return; } k_thread_spawn(stack, STACK_SIZE, (k_thread_entry_t) dtls_client, 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 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 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); }
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; }
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_spawn(tx_stack, sizeof(tx_stack), (k_thread_entry_t)tx_thread, NULL, NULL, NULL, K_PRIO_COOP(7), 0, K_NO_WAIT); k_fifo_init(&h5.rx_queue); k_thread_spawn(rx_stack, sizeof(rx_stack), (k_thread_entry_t)rx_thread, NULL, NULL, NULL, K_PRIO_COOP(7), 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); }
static void tpreempt_ctx(void *p1, void *p2, void *p3) { /** TESTPOINT: The thread's priority is in the preemptible range.*/ zassert_true(k_is_preempt_thread(), NULL); k_sched_lock(); /** TESTPOINT: The thread has locked the scheduler.*/ zassert_false(k_is_preempt_thread(), NULL); k_sched_unlock(); /** TESTPOINT: The thread has not locked the scheduler.*/ zassert_true(k_is_preempt_thread(), NULL); k_thread_priority_set(k_current_get(), K_PRIO_COOP(1)); /** TESTPOINT: The thread's priority is in the cooperative range.*/ zassert_false(k_is_preempt_thread(), NULL); k_sem_give(&end_sema); }
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; }
int hts221_init_interrupt(struct device *dev) { struct hts221_data *drv_data = dev->driver_data; /* setup data ready gpio interrupt */ drv_data->gpio = device_get_binding(CONFIG_HTS221_GPIO_DEV_NAME); if (drv_data->gpio == NULL) { SYS_LOG_ERR("Cannot get pointer to %s device.", CONFIG_HTS221_GPIO_DEV_NAME); return -EINVAL; } gpio_pin_configure(drv_data->gpio, CONFIG_HTS221_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, hts221_gpio_callback, BIT(CONFIG_HTS221_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 (i2c_reg_write_byte(drv_data->i2c, HTS221_I2C_ADDR, HTS221_REG_CTRL3, HTS221_DRDY_EN) < 0) { SYS_LOG_ERR("Could not enable data-ready interrupt."); return -EIO; } #if defined(CONFIG_HTS221_TRIGGER_OWN_THREAD) k_sem_init(&drv_data->gpio_sem, 0, UINT_MAX); k_thread_spawn(drv_data->thread_stack, CONFIG_HTS221_THREAD_STACK_SIZE, (k_thread_entry_t)hts221_thread, POINTER_TO_INT(dev), 0, NULL, K_PRIO_COOP(CONFIG_HTS221_THREAD_PRIORITY), 0, 0); #elif defined(CONFIG_HTS221_TRIGGER_GLOBAL_THREAD) drv_data->work.handler = hts221_work_cb; drv_data->dev = dev; #endif gpio_pin_enable_callback(drv_data->gpio, CONFIG_HTS221_GPIO_PIN_NUM); return 0; }
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); }
static int bt_spi_open(void) { /* Configure RST pin and hold BLE in Reset */ gpio_pin_configure(rst_dev, GPIO_RESET_PIN, GPIO_DIR_OUT | GPIO_PUD_PULL_UP); gpio_pin_write(rst_dev, GPIO_RESET_PIN, 0); spi_configure(spi_dev, &spi_conf); #if defined(CONFIG_BLUETOOTH_SPI_BLUENRG) /* Configure the CS (Chip Select) pin */ gpio_pin_configure(cs_dev, GPIO_CS_PIN, GPIO_DIR_OUT | GPIO_PUD_PULL_UP); gpio_pin_write(cs_dev, GPIO_CS_PIN, 1); #endif /* CONFIG_BLUETOOTH_SPI_BLUENRG */ /* Configure IRQ pin and the IRQ call-back/handler */ gpio_pin_configure(irq_dev, GPIO_IRQ_PIN, GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | GPIO_INT_ACTIVE_HIGH); gpio_init_callback(&gpio_cb, bt_spi_isr, BIT(GPIO_IRQ_PIN)); if (gpio_add_callback(irq_dev, &gpio_cb)) { return -EINVAL; } if (gpio_pin_enable_callback(irq_dev, GPIO_IRQ_PIN)) { return -EINVAL; } /* Start RX thread */ k_thread_spawn(rx_stack, sizeof(rx_stack), (k_thread_entry_t)bt_spi_rx_thread, NULL, NULL, NULL, K_PRIO_COOP(7), 0, K_NO_WAIT); /* Take BLE out of reset */ gpio_pin_write(rst_dev, GPIO_RESET_PIN, 1); /* Device will let us know when it's ready */ k_sem_take(&sem_initialised, K_FOREVER); return 0; }
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); }
int lis2ds12_trigger_init(struct device *dev) { struct lis2ds12_data *data = dev->driver_data; /* setup data ready gpio interrupt */ data->gpio = device_get_binding(DT_ST_LIS2DS12_0_IRQ_GPIOS_CONTROLLER); if (data->gpio == NULL) { LOG_ERR("Cannot get pointer to %s device.", DT_ST_LIS2DS12_0_IRQ_GPIOS_CONTROLLER); return -EINVAL; } gpio_pin_configure(data->gpio, DT_ST_LIS2DS12_0_IRQ_GPIOS_PIN, GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE); gpio_init_callback(&data->gpio_cb, lis2ds12_gpio_callback, BIT(DT_ST_LIS2DS12_0_IRQ_GPIOS_PIN)); if (gpio_add_callback(data->gpio, &data->gpio_cb) < 0) { LOG_ERR("Could not set gpio callback."); return -EIO; } #if defined(CONFIG_LIS2DS12_TRIGGER_OWN_THREAD) k_sem_init(&data->trig_sem, 0, UINT_MAX); k_thread_create(&data->thread, data->thread_stack, CONFIG_LIS2DS12_THREAD_STACK_SIZE, (k_thread_entry_t)lis2ds12_thread, dev, 0, NULL, K_PRIO_COOP(CONFIG_LIS2DS12_THREAD_PRIORITY), 0, 0); #elif defined(CONFIG_LIS2DS12_TRIGGER_GLOBAL_THREAD) data->work.handler = lis2ds12_work_cb; data->dev = dev; #endif gpio_pin_enable_callback(data->gpio, DT_ST_LIS2DS12_0_IRQ_GPIOS_PIN); return 0; }
void shell_init(const char *str) { k_fifo_init(&cmds_queue); k_fifo_init(&avail_queue); line_queue_init(); prompt = str ? str : ""; k_thread_create(&shell_thread, stack, STACKSIZE, shell, NULL, NULL, NULL, K_PRIO_COOP(7), 0, K_NO_WAIT); /* Register serial console handler */ #ifdef CONFIG_UART_CONSOLE uart_register_input(&avail_queue, &cmds_queue, completion); #endif #ifdef CONFIG_TELNET_CONSOLE telnet_register_input(&avail_queue, &cmds_queue, completion); #endif }
static void _gpio_sch_manage_callback(struct device *dev) { struct gpio_sch_data *gpio = dev->driver_data; /* Start the thread only when relevant */ if (!sys_slist_is_empty(&gpio->callbacks) && gpio->cb_enabled) { if (!gpio->poll) { LOG_DBG("Starting SCH GPIO polling thread"); gpio->poll = 1U; k_thread_create(&gpio->polling_thread, gpio->polling_stack, GPIO_SCH_POLLING_STACK_SIZE, (k_thread_entry_t)gpio_sch_poll_status, dev, NULL, NULL, K_PRIO_COOP(1), 0, 0); } } else { gpio->poll = 0U; } }
/*test cases*/ void test_sched_is_preempt_thread(void) { k_sem_init(&end_sema, 0, 1); /*create preempt thread*/ k_tid_t tid = k_thread_spawn(tstack, STACK_SIZE, tpreempt_ctx, NULL, NULL, NULL, K_PRIO_PREEMPT(1), 0, 0); k_sem_take(&end_sema, K_FOREVER); k_thread_abort(tid); /*create coop thread*/ tid = k_thread_spawn(tstack, STACK_SIZE, tcoop_ctx, NULL, NULL, NULL, K_PRIO_COOP(1), 0, 0); k_sem_take(&end_sema, K_FOREVER); k_thread_abort(tid); /*invoke isr*/ irq_offload(tIsr, NULL); }
int adxl372_init_interrupt(struct device *dev) { struct adxl372_data *drv_data = dev->driver_data; const struct adxl372_dev_config *cfg = dev->config->config_info; drv_data->gpio = device_get_binding(cfg->gpio_port); if (drv_data->gpio == NULL) { SYS_LOG_ERR("Failed to get pointer to %s device!", cfg->gpio_port); return -EINVAL; } gpio_pin_configure(drv_data->gpio, cfg->int_gpio, GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE); gpio_init_callback(&drv_data->gpio_cb, adxl372_gpio_callback, BIT(cfg->int_gpio)); if (gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb) < 0) { SYS_LOG_ERR("Failed to set gpio callback!"); return -EIO; } #if defined(CONFIG_ADXL372_TRIGGER_OWN_THREAD) k_sem_init(&drv_data->gpio_sem, 0, UINT_MAX); k_thread_create(&drv_data->thread, drv_data->thread_stack, CONFIG_ADXL372_THREAD_STACK_SIZE, (k_thread_entry_t)adxl372_thread, dev, 0, NULL, K_PRIO_COOP(CONFIG_ADXL372_THREAD_PRIORITY), 0, 0); #elif defined(CONFIG_ADXL372_TRIGGER_GLOBAL_THREAD) drv_data->work.handler = adxl372_work_cb; drv_data->dev = dev; #endif return 0; }
static int telnet_console_init(struct device *arg) { #ifdef CONFIG_NET_IPV4 struct sockaddr_in any_addr4 = { .sin_family = AF_INET, .sin_port = htons(TELNET_PORT), .sin_addr = INADDR_ANY_INIT }; static struct net_context *ctx4; #endif #ifdef CONFIG_NET_IPV6 struct sockaddr_in6 any_addr6 = { .sin6_family = AF_INET6, .sin6_port = htons(TELNET_PORT), .sin6_addr = IN6ADDR_ANY_INIT }; static struct net_context *ctx6; #endif #ifdef CONFIG_NET_IPV4 telnet_setup_server(&ctx4, AF_INET, (struct sockaddr *)&any_addr4, sizeof(any_addr4)); #endif #ifdef CONFIG_NET_IPV6 telnet_setup_server(&ctx6, AF_INET6, (struct sockaddr *)&any_addr6, sizeof(any_addr6)); #endif k_thread_spawn(&telnet_stack[0], TELNET_STACK_SIZE, (k_thread_entry_t)telnet_run, NULL, NULL, NULL, K_PRIO_COOP(TELNET_PRIORITY), 0, K_MSEC(10)); SYS_LOG_INF("Telnet console initialized"); return 0; }