int lis2ds12_trigger_set(struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct lis2ds12_data *data = dev->driver_data;
u8_t buf[6];
__ASSERT_NO_MSG(trig->type == SENSOR_TRIG_DATA_READY);
gpio_pin_disable_callback(data->gpio, DT_ST_LIS2DS12_0_IRQ_GPIOS_PIN);
data->data_ready_handler = handler;
if (handler == NULL) {
LOG_WRN("lis2ds12: no handler");
return 0;
}
/* re-trigger lost interrupt */
if (data->hw_tf->read_data(data, LIS2DS12_REG_OUTX_L,
buf, sizeof(buf)) < 0) {
LOG_ERR("status reading error");
return -EIO;
}
data->data_ready_trigger = *trig;
lis2ds12_init_interrupt(dev);
gpio_pin_enable_callback(data->gpio, DT_ST_LIS2DS12_0_IRQ_GPIOS_PIN);
return 0;
}
void detachInterrupt(uint32_t pin)
{
struct device *gpiob;
gpiob = device_get_binding(PORT);
gpio_pin_disable_callback(gpiob, zephyrDescription[pin].zephyrPin1);
}
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);
}
static void tmp007_gpio_callback(struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct tmp007_data *drv_data =
CONTAINER_OF(cb, struct tmp007_data, gpio_cb);
gpio_pin_disable_callback(dev, CONFIG_TMP007_GPIO_PIN_NUM);
#if defined(CONFIG_TMP007_TRIGGER_OWN_FIBER)
nano_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_TMP007_TRIGGER_GLOBAL_FIBER)
nano_isr_fifo_put(sensor_get_work_fifo(), &drv_data->work);
#endif
}
static void apds9960_gpio_callback(struct device *dev,
struct gpio_callback *cb, u32_t pins)
{
struct apds9960_data *drv_data =
CONTAINER_OF(cb, struct apds9960_data, gpio_cb);
gpio_pin_disable_callback(dev, DT_AVAGO_APDS9960_0_INT_GPIOS_PIN);
#ifdef CONFIG_APDS9960_TRIGGER
k_work_submit(&drv_data->work);
#else
k_sem_give(&drv_data->data_sem);
#endif
}
static void adxl372_gpio_callback(struct device *dev,
struct gpio_callback *cb, u32_t pins)
{
struct adxl372_data *drv_data =
CONTAINER_OF(cb, struct adxl372_data, gpio_cb);
const struct adxl372_dev_config *cfg = dev->config->config_info;
gpio_pin_disable_callback(dev, cfg->int_gpio);
#if defined(CONFIG_ADXL372_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_ADXL372_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
static void trigger_callback(struct device *dev, int enable_cb)
{
gpio_pin_write(dev, PIN_OUT, 0);
k_sleep(100);
cb_cnt[0] = 0;
cb_cnt[1] = 0;
if (enable_cb == 1) {
gpio_pin_enable_callback(dev, PIN_IN);
} else {
gpio_pin_disable_callback(dev, PIN_IN);
}
k_sleep(100);
gpio_pin_write(dev, PIN_OUT, 1);
k_sleep(1000);
}
static void mpu6050_gpio_callback(struct device *dev,
struct gpio_callback *cb, u32_t pins)
{
struct mpu6050_data *drv_data =
CONTAINER_OF(cb, struct mpu6050_data, gpio_cb);
ARG_UNUSED(pins);
gpio_pin_disable_callback(dev, CONFIG_MPU6050_GPIO_PIN_NUM);
#if defined(CONFIG_MPU6050_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_MPU6050_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
static void lis2ds12_gpio_callback(struct device *dev,
struct gpio_callback *cb, u32_t pins)
{
struct lis2ds12_data *data =
CONTAINER_OF(cb, struct lis2ds12_data, gpio_cb);
ARG_UNUSED(pins);
gpio_pin_disable_callback(dev, DT_ST_LIS2DS12_0_IRQ_GPIOS_PIN);
#if defined(CONFIG_LIS2DS12_TRIGGER_OWN_THREAD)
k_sem_give(&data->trig_sem);
#elif defined(CONFIG_LIS2DS12_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
static void lis2dw12_gpio_callback(struct device *dev,
struct gpio_callback *cb, u32_t pins)
{
struct lis2dw12_data *lis2dw12 =
CONTAINER_OF(cb, struct lis2dw12_data, gpio_cb);
const struct lis2dw12_device_config *cfg = dev->config->config_info;
ARG_UNUSED(pins);
gpio_pin_disable_callback(dev, cfg->int_gpio_pin);
#if defined(CONFIG_LIS2DW12_TRIGGER_OWN_THREAD)
k_sem_give(&lis2dw12->gpio_sem);
#elif defined(CONFIG_LIS2DW12_TRIGGER_GLOBAL_THREAD)
k_work_submit(&lis2dw12->work);
#endif /* CONFIG_LIS2DW12_TRIGGER_OWN_THREAD */
}
int adxl372_trigger_set(struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct adxl372_data *drv_data = dev->driver_data;
const struct adxl372_dev_config *cfg = dev->config->config_info;
u8_t int_mask, int_en, status1, status2;
int ret;
gpio_pin_disable_callback(drv_data->gpio, cfg->int_gpio);
switch (trig->type) {
case SENSOR_TRIG_THRESHOLD:
drv_data->th_handler = handler;
drv_data->th_trigger = *trig;
int_mask = ADXL372_INT1_MAP_ACT_MSK |
ADXL372_INT1_MAP_INACT_MSK;
break;
case SENSOR_TRIG_DATA_READY:
drv_data->drdy_handler = handler;
drv_data->drdy_trigger = *trig;
int_mask = ADXL372_INT1_MAP_DATA_RDY_MSK;
break;
default:
SYS_LOG_ERR("Unsupported sensor trigger");
ret = -ENOTSUP;
goto out;
}
if (handler) {
int_en = int_mask;
} else {
int_en = 0;
};
ret = adxl372_reg_write_mask(dev, ADXL372_INT1_MAP, int_mask, int_en);
adxl372_get_status(dev, &status1, &status2, NULL); /* Clear status */
out:
gpio_pin_enable_callback(drv_data->gpio, cfg->int_gpio);
return ret;
}
int tmp007_trigger_set(struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct tmp007_data *drv_data = dev->driver_data;
gpio_pin_disable_callback(drv_data->gpio, CONFIG_TMP007_GPIO_PIN_NUM);
if (trig->type == SENSOR_TRIG_DATA_READY) {
drv_data->drdy_handler = handler;
drv_data->drdy_trigger = *trig;
} else if (trig->type == SENSOR_TRIG_THRESHOLD) {
drv_data->th_handler = handler;
drv_data->th_trigger = *trig;
}
gpio_pin_enable_callback(drv_data->gpio, CONFIG_TMP007_GPIO_PIN_NUM);
return 0;
}
int hts221_trigger_set(struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct hts221_data *drv_data = dev->driver_data;
__ASSERT_NO_MSG(trig->type == SENSOR_TRIG_DATA_READY);
gpio_pin_disable_callback(drv_data->gpio, CONFIG_HTS221_GPIO_PIN_NUM);
drv_data->data_ready_handler = handler;
if (handler == NULL) {
return 0;
}
drv_data->data_ready_trigger = *trig;
gpio_pin_enable_callback(drv_data->gpio, CONFIG_HTS221_GPIO_PIN_NUM);
return 0;
}
int mpu6050_trigger_set(struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct mpu6050_data *drv_data = dev->driver_data;
if (trig->type != SENSOR_TRIG_DATA_READY) {
return -ENOTSUP;
}
gpio_pin_disable_callback(drv_data->gpio, CONFIG_MPU6050_GPIO_PIN_NUM);
drv_data->data_ready_handler = handler;
if (handler == NULL) {
return 0;
}
drv_data->data_ready_trigger = *trig;
gpio_pin_enable_callback(drv_data->gpio, CONFIG_MPU6050_GPIO_PIN_NUM);
return 0;
}
static void bt_spi_rx_thread(void)
{
struct net_buf *buf;
u8_t header_master[5] = { SPI_READ, 0x00, 0x00, 0x00, 0x00 };
u8_t header_slave[5];
struct bt_hci_acl_hdr acl_hdr;
u8_t size;
memset(&txmsg, 0xFF, SPI_MAX_MSG_LEN);
while (true) {
k_sem_take(&sem_request, K_FOREVER);
/* Disable IRQ pin callback to avoid spurious IRQs */
gpio_pin_disable_callback(irq_dev, GPIO_IRQ_PIN);
k_sem_take(&sem_busy, K_FOREVER);
do {
#if defined(CONFIG_BLUETOOTH_SPI_BLUENRG)
gpio_pin_write(cs_dev, GPIO_CS_PIN, 1);
gpio_pin_write(cs_dev, GPIO_CS_PIN, 0);
#endif /* CONFIG_BLUETOOTH_SPI_BLUENRG */
spi_transceive(spi_dev,
header_master, 5, header_slave, 5);
} while (header_slave[STATUS_HEADER_TOREAD] == 0 ||
header_slave[STATUS_HEADER_TOREAD] == 0xFF);
size = header_slave[STATUS_HEADER_TOREAD];
do {
spi_transceive(spi_dev, &txmsg, size, &rxmsg, size);
} while (rxmsg[0] == 0);
gpio_pin_enable_callback(irq_dev, GPIO_IRQ_PIN);
#if defined(CONFIG_BLUETOOTH_SPI_BLUENRG)
gpio_pin_write(cs_dev, GPIO_CS_PIN, 1);
#endif /* CONFIG_BLUETOOTH_SPI_BLUENRG */
k_sem_give(&sem_busy);
spi_dump_message("RX:ed", rxmsg, size);
switch (rxmsg[PACKET_TYPE]) {
case HCI_EVT:
switch (rxmsg[EVT_HEADER_EVENT]) {
case BT_HCI_EVT_VENDOR:
/* Vendor events are currently unsupported */
bt_spi_handle_vendor_evt(rxmsg);
continue;
case BT_HCI_EVT_CMD_COMPLETE:
case BT_HCI_EVT_CMD_STATUS:
buf = bt_buf_get_cmd_complete(K_FOREVER);
break;
default:
buf = bt_buf_get_rx(K_FOREVER);
break;
}
bt_buf_set_type(buf, BT_BUF_EVT);
net_buf_add_mem(buf, &rxmsg[1],
rxmsg[EVT_HEADER_SIZE] + 2);
break;
case HCI_ACL:
buf = bt_buf_get_rx(K_FOREVER);
bt_buf_set_type(buf, BT_BUF_ACL_IN);
memcpy(&acl_hdr, &rxmsg[1], sizeof(acl_hdr));
net_buf_add_mem(buf, &acl_hdr, sizeof(acl_hdr));
net_buf_add_mem(buf, &rxmsg[5],
sys_le16_to_cpu(acl_hdr.len));
break;
default:
BT_ERR("Unknown BT buf type %d", rxmsg[0]);
continue;
}
if (rxmsg[PACKET_TYPE] == HCI_EVT &&
bt_hci_evt_is_prio(rxmsg[EVT_HEADER_EVENT])) {
bt_recv_prio(buf);
} else {
bt_recv(buf);
}
}
}