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 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);
}
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 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;
}
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));
}
}
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;
}
}
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;
}
