void main(void)
{
struct device *gpiob;
printk("Press the user defined button on the board\n");
gpiob = device_get_binding(PORT);
if (!gpiob) {
printk("error\n");
return;
}
gpio_pin_configure(gpiob, PIN,
GPIO_DIR_IN | GPIO_INT | PULL_UP | EDGE);
gpio_init_callback(&gpio_cb, button_pressed, BIT(PIN));
gpio_add_callback(gpiob, &gpio_cb);
gpio_pin_enable_callback(gpiob, PIN);
while (1) {
u32_t val = 0;
gpio_pin_read(gpiob, PIN, &val);
k_sleep(SLEEP_TIME);
}
}
void main(void)
{
uint32_t timer_data[2] = {0, 0};
struct device *aon_gpio;
struct nano_timer timer;
nano_timer_init(&timer, timer_data);
aon_gpio = device_get_binding("GPIO_AON_0");
if (!aon_gpio) {
printf("aon_gpio device not found.\n");
return;
}
ipm = device_get_binding("bmi160_ipm");
if (!ipm) {
printf("ipm device not found.\n");
return;
}
gpio_init_callback(&cb, aon_gpio_callback, BIT(BMI160_INTERRUPT_PIN));
gpio_add_callback(aon_gpio, &cb);
gpio_pin_configure(aon_gpio, BMI160_INTERRUPT_PIN,
GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE |
GPIO_INT_ACTIVE_LOW | GPIO_INT_DEBOUNCE);
gpio_pin_enable_callback(aon_gpio, BMI160_INTERRUPT_PIN);
while (1) {
nano_task_timer_start(&timer, SLEEPTIME);
nano_task_timer_test(&timer, TICKS_UNLIMITED);
}
}
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;
}
void main(void)
{
struct nano_timer timer;
void *timer_data[1];
struct device *gpio_dev;
int ret;
int toggle = 1;
nano_timer_init(&timer, timer_data);
gpio_dev = device_get_binding(GPIO_DRV_NAME);
if (!gpio_dev) {
printk("Cannot find %s!\n", GPIO_DRV_NAME);
}
/* Setup GPIO output */
ret = gpio_pin_configure(gpio_dev, GPIO_OUT_PIN, (GPIO_DIR_OUT));
if (ret) {
printk("Error configuring " GPIO_NAME "%d!\n", GPIO_OUT_PIN);
}
/* Setup GPIO input, and triggers on rising edge. */
ret = gpio_pin_configure(gpio_dev, GPIO_INT_PIN,
(GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE
| GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE));
if (ret) {
printk("Error configuring " GPIO_NAME "%d!\n", GPIO_INT_PIN);
}
gpio_init_callback(&gpio_cb, gpio_callback, BIT(GPIO_INT_PIN));
ret = gpio_add_callback(gpio_dev, &gpio_cb);
if (ret) {
printk("Cannot setup callback!\n");
}
ret = gpio_pin_enable_callback(gpio_dev, GPIO_INT_PIN);
if (ret) {
printk("Error enabling callback!\n");
}
while (1) {
printk("Toggling " GPIO_NAME "%d\n", GPIO_OUT_PIN);
ret = gpio_pin_write(gpio_dev, GPIO_OUT_PIN, toggle);
if (ret) {
printk("Error set " GPIO_NAME "%d!\n", GPIO_OUT_PIN);
}
if (toggle) {
toggle = 0;
} else {
toggle = 1;
}
nano_timer_start(&timer, SLEEPTICKS);
nano_timer_test(&timer, TICKS_UNLIMITED);
}
}
static void init_callback(struct device *dev)
{
gpio_pin_disable_callback(dev, PIN_IN);
gpio_pin_disable_callback(dev, PIN_OUT);
/* 1. set PIN_OUT */
gpio_pin_configure(dev, PIN_OUT, GPIO_DIR_OUT);
gpio_pin_write(dev, PIN_OUT, 0);
/* 2. configure PIN_IN callback and trigger condition */
gpio_pin_configure(dev, PIN_IN,
GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | \
GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE);
gpio_init_callback(&cb_data[0].gpio_cb, callback_1, BIT(PIN_IN));
gpio_add_callback(dev, &cb_data[0].gpio_cb);
gpio_init_callback(&cb_data[1].gpio_cb, callback_2, BIT(PIN_IN));
gpio_add_callback(dev, &cb_data[1].gpio_cb);
}
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;
}
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 attachInterrupt(uint32_t pin, void(*callback)(void), uint32_t mode)
{
struct device *gpiob;
int gpio_mode;
switch(mode)
{
case LOW:
gpio_mode = GPIO_DIR_IN | GPIO_INT
| GPIO_INT_LEVEL | GPIO_INT_ACTIVE_LOW
| PULL_UP;
break;
case HIGH:
gpio_mode = GPIO_DIR_IN | GPIO_INT
| GPIO_INT_LEVEL | GPIO_INT_ACTIVE_HIGH
| PULL_UP;
break;
case CHANGE:
gpio_mode = GPIO_DIR_IN | GPIO_INT
| GPIO_INT_DOUBLE_EDGE | GPIO_INT_ACTIVE_LOW
| GPIO_INT_ACTIVE_HIGH | PULL_UP;
break;
case FALLING:
gpio_mode = GPIO_DIR_IN | GPIO_INT
| GPIO_INT_EDGE | GPIO_INT_ACTIVE_LOW
| PULL_UP;
break;
case RISING:
gpio_mode = GPIO_DIR_IN | GPIO_INT
| GPIO_INT_EDGE | GPIO_INT_ACTIVE_HIGH
| PULL_UP;
break;
default:
gpio_mode = GPIO_DIR_IN | GPIO_INT
| GPIO_INT_DOUBLE_EDGE | GPIO_INT_ACTIVE_LOW
| GPIO_INT_ACTIVE_HIGH | PULL_UP;
}
gpiob = device_get_binding(PORT);
gpio_pin_configure(gpiob, zephyrDescription[pin].zephyrPin1, gpio_mode);
gpio_init_callback(&gpio_cb, callback, BIT(zephyrDescription[pin].zephyrPin1));
gpio_add_callback(gpiob, &gpio_cb);
gpio_pin_enable_callback(gpiob, zephyrDescription[pin].zephyrPin1);
}
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;
}
int tmp007_init_interrupt(struct device *dev)
{
struct tmp007_data *drv_data = dev->driver_data;
int rc;
rc = tmp007_reg_update(drv_data, TMP007_REG_CONFIG,
TMP007_ALERT_EN_BIT, TMP007_ALERT_EN_BIT);
if (rc != 0) {
SYS_LOG_DBG("Failed to enable interrupt pin!");
return -EIO;
}
/* setup gpio interrupt */
drv_data->gpio = device_get_binding(CONFIG_TMP007_GPIO_DEV_NAME);
if (drv_data->gpio == NULL) {
SYS_LOG_DBG("Failed to get pointer to %s device!",
CONFIG_TMP007_GPIO_DEV_NAME);
return -EINVAL;
}
gpio_pin_configure(drv_data->gpio, CONFIG_TMP007_GPIO_PIN_NUM,
GPIO_DIR_IN | GPIO_INT | GPIO_INT_LEVEL |
GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE);
gpio_init_callback(&drv_data->gpio_cb,
tmp007_gpio_callback,
BIT(CONFIG_TMP007_GPIO_PIN_NUM));
rc = gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb);
if (rc != 0) {
SYS_LOG_DBG("Failed to set gpio callback!");
return -EIO;
}
#if defined(CONFIG_TMP007_TRIGGER_OWN_FIBER)
nano_sem_init(&drv_data->gpio_sem);
fiber_start(drv_data->fiber_stack, CONFIG_TMP007_FIBER_STACK_SIZE,
(nano_fiber_entry_t)tmp007_fiber, POINTER_TO_INT(dev),
0, CONFIG_TMP007_FIBER_PRIORITY, 0);
#elif defined(CONFIG_TMP007_TRIGGER_GLOBAL_FIBER)
drv_data->work.handler = tmp007_fiber_cb;
drv_data->work.arg = dev;
#endif
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;
}
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;
}
static int apds9960_init_interrupt(struct device *dev)
{
struct apds9960_data *drv_data = dev->driver_data;
/* setup gpio interrupt */
drv_data->gpio = device_get_binding(DT_AVAGO_APDS9960_0_INT_GPIOS_CONTROLLER);
if (drv_data->gpio == NULL) {
LOG_ERR("Failed to get pointer to %s device!",
DT_AVAGO_APDS9960_0_INT_GPIOS_CONTROLLER);
return -EINVAL;
}
gpio_pin_configure(drv_data->gpio, DT_AVAGO_APDS9960_0_INT_GPIOS_PIN,
GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE |
GPIO_INT_ACTIVE_LOW | GPIO_INT_DEBOUNCE |
GPIO_PUD_PULL_UP);
gpio_init_callback(&drv_data->gpio_cb,
apds9960_gpio_callback,
BIT(DT_AVAGO_APDS9960_0_INT_GPIOS_PIN));
if (gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb) < 0) {
LOG_DBG("Failed to set gpio callback!");
return -EIO;
}
#ifdef CONFIG_APDS9960_TRIGGER
drv_data->work.handler = apds9960_work_cb;
drv_data->dev = dev;
if (i2c_reg_update_byte(drv_data->i2c, APDS9960_I2C_ADDRESS,
APDS9960_ENABLE_REG,
APDS9960_ENABLE_PON,
APDS9960_ENABLE_PON)) {
LOG_ERR("Power on bit not set.");
return -EIO;
}
#else
k_sem_init(&drv_data->data_sem, 0, UINT_MAX);
#endif
return 0;
}
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;
}
int sx9500_setup_interrupt(struct device *dev)
{
struct sx9500_data *data = dev->driver_data;
struct device *gpio;
#ifdef CONFIG_SX9500_TRIGGER_OWN_THREAD
k_sem_init(&data->sem, 0, UINT_MAX);
#else
data->work.handler = sx9500_work_cb;
data->dev = dev;
#endif
gpio = device_get_binding(CONFIG_SX9500_GPIO_CONTROLLER);
if (!gpio) {
SYS_LOG_DBG("sx9500: gpio controller %s not found",
CONFIG_SX9500_GPIO_CONTROLLER);
return -EINVAL;
}
gpio_pin_configure(gpio, CONFIG_SX9500_GPIO_PIN,
GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE |
GPIO_INT_ACTIVE_LOW | GPIO_INT_DEBOUNCE);
gpio_init_callback(&data->gpio_cb,
sx9500_gpio_cb,
BIT(CONFIG_SX9500_GPIO_PIN));
gpio_add_callback(gpio, &data->gpio_cb);
gpio_pin_enable_callback(gpio, CONFIG_SX9500_GPIO_PIN);
#ifdef CONFIG_SX9500_TRIGGER_OWN_THREAD
k_thread_spawn(sx9500_thread_stack, CONFIG_SX9500_THREAD_STACK_SIZE,
sx9500_thread_main, POINTER_TO_INT(dev), 0, NULL,
K_PRIO_COOP(CONFIG_SX9500_THREAD_PRIORITY), 0, 0);
#endif
return 0;
}
void main(void)
{
struct device *gpiob;
gpiob = device_get_binding(PORT);
gpio_pin_configure(gpiob, PIN,
GPIO_DIR_IN | GPIO_INT
| EDGE
| PULL_UP);
gpio_init_callback(&gpio_cb, button_pressed, BIT(PIN));
gpio_add_callback(gpiob, &gpio_cb);
gpio_pin_enable_callback(gpiob, PIN);
while (1) {
int val = 0;
gpio_pin_read(gpiob, PIN, &val);
PRINT("GPIO val: %d\n", val);
task_sleep(MSEC(500));
}
}
int bma280_init_interrupt(struct device *dev)
{
struct bma280_data *drv_data = dev->driver_data;
int rc;
/* set latched interrupts */
rc = i2c_reg_write_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_RST_LATCH,
BMA280_BIT_INT_LATCH_RESET |
BMA280_INT_MODE_LATCH);
if (rc != 0) {
SYS_LOG_DBG("Could not set latched interrupts");
return -EIO;
}
/* setup data ready gpio interrupt */
drv_data->gpio = device_get_binding(CONFIG_BMA280_GPIO_DEV_NAME);
if (drv_data->gpio == NULL) {
SYS_LOG_DBG("Cannot get pointer to %s device",
CONFIG_BMA280_GPIO_DEV_NAME);
return -EINVAL;
}
gpio_pin_configure(drv_data->gpio, CONFIG_BMA280_GPIO_PIN_NUM,
GPIO_DIR_IN | GPIO_INT | GPIO_INT_LEVEL |
GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE);
gpio_init_callback(&drv_data->gpio_cb,
bma280_gpio_callback,
BIT(CONFIG_BMA280_GPIO_PIN_NUM));
rc = gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb);
if (rc != 0) {
SYS_LOG_DBG("Could not set gpio callback");
return -EIO;
}
/* map data ready interrupt to INT1 */
rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_MAP_1,
BMA280_INT_MAP_1_BIT_DATA,
BMA280_INT_MAP_1_BIT_DATA);
if (rc != 0) {
SYS_LOG_DBG("Could not map data ready interrupt pin");
return -EIO;
}
/* map any-motion interrupt to INT1 */
rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_MAP_0,
BMA280_INT_MAP_0_BIT_SLOPE,
BMA280_INT_MAP_0_BIT_SLOPE);
if (rc != 0) {
SYS_LOG_DBG("Could not map any-motion interrupt pin");
return -EIO;
}
/* disable data ready interrupt */
rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_EN_1,
BMA280_BIT_DATA_EN, 0);
if (rc != 0) {
SYS_LOG_DBG("Could not disable data ready interrupt");
return -EIO;
}
/* disable any-motion interrupt */
rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_EN_0,
BMA280_SLOPE_EN_XYZ, 0);
if (rc != 0) {
SYS_LOG_DBG("Could not disable data ready interrupt");
return -EIO;
}
#if defined(CONFIG_BMA280_TRIGGER_OWN_FIBER)
nano_sem_init(&drv_data->gpio_sem);
fiber_start(drv_data->fiber_stack, CONFIG_BMA280_FIBER_STACK_SIZE,
(nano_fiber_entry_t)bma280_fiber, POINTER_TO_INT(dev),
0, CONFIG_BMA280_FIBER_PRIORITY, 0);
#elif defined(CONFIG_BMA280_TRIGGER_GLOBAL_FIBER)
drv_data->work.handler = bma280_fiber_cb;
drv_data->work.arg = dev;
#endif
gpio_pin_enable_callback(drv_data->gpio, CONFIG_BMA280_GPIO_PIN_NUM);
return 0;
}
static int test_gpio(u32_t pin, u32_t func)
{
u32_t function;
struct gpio_callback gpio_cb;
struct device *pinmux = device_get_binding(PINMUX_NAME);
if (!pinmux) {
TC_PRINT("Cannot get PINMUX\n");
return TC_FAIL;
}
struct device *gpio_dev = device_get_binding(GPIO_DEV_NAME);
if (!gpio_dev) {
TC_PRINT("Cannot get GPIO device\n");
return TC_FAIL;
}
cb_triggered = false;
/* 1. Configure PIN_OUT and set init voltage */
if (gpio_pin_configure(gpio_dev, GPIO_OUT, GPIO_DIR_OUT)) {
TC_PRINT("PIN_OUT configure fail\n");
return TC_FAIL;
}
if (gpio_pin_write(gpio_dev, GPIO_OUT, 0)) {
TC_PRINT("Set PIN_OUT init LOW fail\n");
return TC_FAIL;
}
/* 2. Configure PIN_IN and set callback */
if (gpio_pin_configure(gpio_dev, GPIO_IN,
GPIO_DIR_IN | GPIO_INT | GPIO_INT_DEBOUNCE |
GPIO_INT_LEVEL | GPIO_INT_ACTIVE_HIGH)) {
TC_PRINT("PIN_IN configure fail\n");
return TC_FAIL;
}
gpio_init_callback(&gpio_cb, callback, BIT(GPIO_IN));
if (gpio_add_callback(gpio_dev, &gpio_cb)) {
TC_PRINT("Set PIN_IN callback fail\n");
return TC_FAIL;
}
gpio_pin_enable_callback(gpio_dev, GPIO_IN);
/* 3. Verify pinmux_pin_set() */
if (pinmux_pin_set(pinmux, pin, func)) {
TC_PRINT("Fail to set pin func, %u : %u\n", pin, func);
return TC_FAIL;
}
/* 4. Verify pinmux_pin_get() */
if (pinmux_pin_get(pinmux, pin, &function)) {
TC_PRINT("Fail to get pin func\n");
return TC_FAIL;
}
/* 5. Verify the setting works */
if (function != func) {
TC_PRINT("Error. PINMUX get doesn't match PINMUX set\n");
return TC_FAIL;
}
/* 6. Set PIN_OUT HIGH and verify pin func works */
if (gpio_pin_write(gpio_dev, GPIO_OUT, 1)) {
TC_PRINT("Set PIN_OUT HIGH fail\n");
return TC_FAIL;
}
k_sleep(1000);
if (cb_triggered) {
TC_PRINT("GPIO callback is triggered\n");
return TC_PASS;
} else {
TC_PRINT("GPIO callback is not triggered\n");
return TC_FAIL;
}
}
