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);
}
}
////////////////////////////////////////////////////////////////////////////////////
//
// void owi_pin_configure(gpio_pin_id_t owi_pin_id)
//
// Description:
// Configures the OWI pin
//
// Parameters:
// gpio_pin_id_t owi_pin_id - ID of the OWI pin to be configured
//
// Return value:
// None
//
////////////////////////////////////////////////////////////////////////////////////
void owi_pin_configure(gpio_pin_id_t owi_pin_id)
{
gpio_pin_configure(owi_pin_id, GPIO_PIN_CONFIG_OPTION_DIR_OUTPUT | GPIO_PIN_CONFIG_OPTION_OUTPUT_VAL_CLEAR | GPIO_PIN_CONFIG_OPTION_PIN_MODE_OUTPUT_BUFFER_NORMAL_DRIVE_STRENGTH);
gpio_pin_configure(owi_pin_id, GPIO_PIN_CONFIG_OPTION_DIR_INPUT | GPIO_PIN_CONFIG_OPTION_PIN_MODE_INPUT_BUFFER_ON_PULL_UP_RESISTOR);
// The first rising edge can be interpreted by a slave as the end of a reset pulse.
// Delay for the required reset recovery time (H) to be sure that the real reset is interpreted correctly.
delay_us(OWI_DELAY_H);
}
/**
* @brief Initialize UART channel
*
* This routine is called to reset the chip in a quiescent state.
* It is assumed that this function is called only once per UART.
*
* @param dev UART device struct
*
* @return 0 on success
*/
static int uart_nrf5_init(struct device *dev)
{
volatile struct _uart *uart = UART_STRUCT(dev);
struct device *gpio_dev;
gpio_dev = device_get_binding(CONFIG_GPIO_NRF5_P0_DEV_NAME);
(void) gpio_pin_configure(gpio_dev,
CONFIG_UART_NRF5_GPIO_TX_PIN,
(GPIO_DIR_OUT | GPIO_PUD_PULL_UP));
(void) gpio_pin_configure(gpio_dev,
CONFIG_UART_NRF5_GPIO_RX_PIN,
(GPIO_DIR_IN));
uart->PSELTXD = CONFIG_UART_NRF5_GPIO_TX_PIN;
uart->PSELRXD = CONFIG_UART_NRF5_GPIO_RX_PIN;
#ifdef CONFIG_UART_NRF5_FLOW_CONTROL
(void) gpio_pin_configure(gpio_dev,
CONFIG_UART_NRF5_GPIO_RTS_PIN,
(GPIO_DIR_OUT | GPIO_PUD_PULL_UP));
(void) gpio_pin_configure(gpio_dev,
CONFIG_UART_NRF5_GPIO_CTS_PIN,
(GPIO_DIR_IN));
uart->PSELRTS = CONFIG_UART_NRF5_GPIO_RTS_PIN;
uart->PSELCTS = CONFIG_UART_NRF5_GPIO_CTS_PIN;
uart->CONFIG = (UART_CONFIG_HWFC_Enabled << UART_CONFIG_HWFC_Pos);
#endif /* CONFIG_UART_NRF5_FLOW_CONTROL */
DEV_DATA(dev)->baud_rate = CONFIG_UART_NRF5_BAUD_RATE;
DEV_CFG(dev)->sys_clk_freq = CONFIG_UART_NRF5_CLK_FREQ;
/* Set baud rate */
baudrate_set(dev, DEV_DATA(dev)->baud_rate,
DEV_CFG(dev)->sys_clk_freq);
/* Enable receiver and transmitter */
uart->ENABLE = (UART_ENABLE_ENABLE_Enabled << UART_ENABLE_ENABLE_Pos);
uart->EVENTS_TXDRDY = 0;
uart->EVENTS_RXDRDY = 0;
uart->TASKS_STARTTX = 1;
uart->TASKS_STARTRX = 1;
dev->driver_api = &uart_nrf5_driver_api;
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
DEV_CFG(dev)->irq_config_func(dev);
#endif
return 0;
}
void taskA(void)
{
int rc1;
int rc2;
gpio = device_get_binding(CONFIG_GPIO_PCAL9535A_1_DEV_NAME);
gpio_sus = device_get_binding(CONFIG_GPIO_SCH_1_DEV_NAME);
i2c = device_get_binding(CONFIG_GPIO_PCAL9535A_1_I2C_MASTER_DEV_NAME);
pinmux = device_get_binding(PINMUX_NAME);
if (!i2c) {
PRINT("I2C not found!!\n");
} else {
rc1 = i2c_configure(i2c, (I2C_SPEED_FAST << 1) | I2C_MODE_MASTER);
if (rc1 != DEV_OK) {
PRINT("I2C configuration error: %d\n", rc1);
}
}
if (!gpio) {
PRINT("GPIO not found!!\n");
} else {
rc1 = gpio_pin_configure(gpio, 6, GPIO_DIR_OUT);
rc2 = gpio_pin_configure(gpio, 8, GPIO_DIR_OUT);
if (rc1 != DEV_OK ||
rc2 != DEV_OK) {
PRINT("GPIO config error %d, %d!!\n", rc1, rc2);
}
}
if (!gpio_sus) {
PRINT("Legacy GPIO not found!!\n");
} else {
rc1 = gpio_pin_configure(gpio_sus, 5, GPIO_DIR_OUT);
if (rc1 != DEV_OK) {
PRINT("Legacy GPIO config error %d!!\n", rc1);
}
}
if (!pinmux) {
PRINT("Pinmux device not found!\n");
} else {
/*
* By default pin D13 (pin 5 on Legacy GPIO_SUS
* is configured for input. To blink it, it needs to
* be configured for output
*/
rc1 = pinmux_pin_set(pinmux, 13, PINMUX_FUNC_A);
if (rc1 != DEV_OK) {
PRINT("Pinmux config error %d!!\n", rc1);
}
}
/* taskA gives its own semaphore, allowing it to say hello right away */
task_sem_give(TASKASEM);
/* invoke routine that allows task to ping-pong hello messages with taskB */
helloLoop(__FUNCTION__, TASKASEM, TASKBSEM);
}
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);
}
}
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);
}
}
/*
* This program toggles PIN IO 8 so if you connect an LED to that pin you
* should see something.
*/
void main(void)
{
struct device *gpio_device;
struct nano_timer timer;
void *timer_data[1];
int ret;
int pin_state = 1;
nano_timer_init(&timer, timer_data);
gpio_device = device_get_binding(GPIO_DRV_NAME);
if (!gpio_device) {
return;
}
ret = gpio_pin_configure(gpio_device, GPIO_OUT_PIN, (GPIO_DIR_OUT));
if (ret) {
return;
}
while (1) {
gpio_pin_write(gpio_device, GPIO_OUT_PIN, pin_state);
pin_state = !pin_state;
nano_timer_start(&timer, SECONDS(1));
nano_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)
{
int cnt = 0;
struct device *gpiob;
gpiob = device_get_binding(PORT);
gpio_pin_configure(gpiob, LED1, GPIO_DIR_OUT);
gpio_pin_configure(gpiob, LED2, GPIO_DIR_OUT);
while (1) {
gpio_pin_write(gpiob, LED1, cnt % 2);
gpio_pin_write(gpiob, LED2, (cnt + 1) % 2);
task_sleep(SECONDS(1));
cnt++;
}
}
void main(void)
{
struct device *gpio_dev;
int ret;
int idx = 0;
int leds = 0;
gpio_dev = device_get_binding(GPIO_DRV_NAME);
if (!gpio_dev) {
printk("Cannot find %s!\n", GPIO_DRV_NAME);
return;
}
/* Setup GPIO output */
ret = gpio_pin_configure(gpio_dev, GPIO_DATA_PIN, (GPIO_DIR_OUT));
if (ret) {
printk("Error configuring " GPIO_NAME "%d!\n", GPIO_DATA_PIN);
}
ret = gpio_pin_configure(gpio_dev, GPIO_CLK_PIN, (GPIO_DIR_OUT));
if (ret) {
printk("Error configuring " GPIO_NAME "%d!\n", GPIO_CLK_PIN);
}
while (1) {
send_rgb(gpio_dev, APA102C_START_FRAME);
for (leds = 0; leds < NUM_LEDS; leds++) {
send_rgb(gpio_dev, rgb[(idx + leds) % NUM_RGB]);
}
/* If there are more LEDs linked together,
* then what NUM_LEDS is, the NUM_LEDS+1
* LED is going to be full bright.
*/
send_rgb(gpio_dev, APA102C_END_FRAME);
idx++;
if (idx >= NUM_RGB) {
idx = 0;
}
k_sleep(SLEEPTIME);
}
}
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;
}
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);
}
void ser_init(void)
{
rcnt = xcnt = rpos = xpos = 0; /* init buffers */
busy = 0;
// Setup UART pins
gpio_pin_configure(GPIO_PIN_ID_FUNC_RXD,
GPIO_PIN_CONFIG_OPTION_DIR_INPUT |
GPIO_PIN_CONFIG_OPTION_PIN_MODE_INPUT_BUFFER_ON_NO_RESISTORS);
gpio_pin_configure(GPIO_PIN_ID_FUNC_TXD,
GPIO_PIN_CONFIG_OPTION_DIR_OUTPUT |
GPIO_PIN_CONFIG_OPTION_OUTPUT_VAL_SET |
GPIO_PIN_CONFIG_OPTION_PIN_MODE_OUTPUT_BUFFER_NORMAL_DRIVE_STRENGTH);
uart_configure_8_n_1_38400();
uart_rx_disable();
interrupt_control_uart_enable();
}
static void setup_aon_gpio(void)
{
gpio_dev = device_get_binding("GPIO_1");
if (!gpio_dev) {
printk("gpio device not found.\n");
return;
}
gpio_pin_configure(gpio_dev, GPIO_INTERRUPT_PIN,
GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE |
GPIO_INT_ACTIVE_LOW | GPIO_INT_DEBOUNCE);
}
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;
}
struct cc2520_gpio_configuration *cc2520_configure_gpios(void)
{
const int flags_noint_out = GPIO_DIR_OUT;
const int flags_noint_in = GPIO_DIR_IN;
const int flags_int_in = (GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE |
GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE);
struct device *gpio;
gpio = device_get_binding(CONFIG_TI_CC2520_GPIO_1_NAME);
gpio_pin_configure(gpio, cc2520_gpios[CC2520_GPIO_IDX_VREG_EN].pin,
flags_noint_out);
gpio_pin_configure(gpio, cc2520_gpios[CC2520_GPIO_IDX_RESET].pin,
flags_noint_out);
cc2520_gpios[CC2520_GPIO_IDX_VREG_EN].dev = gpio;
cc2520_gpios[CC2520_GPIO_IDX_RESET].dev = gpio;
gpio = device_get_binding(CONFIG_TI_CC2520_GPIO_0_NAME);
gpio_pin_configure(gpio, cc2520_gpios[CC2520_GPIO_IDX_SFD].pin,
flags_int_in);
gpio_pin_configure(gpio, cc2520_gpios[CC2520_GPIO_IDX_FIFOP].pin,
flags_int_in);
gpio_pin_configure(gpio, cc2520_gpios[CC2520_GPIO_IDX_FIFO].pin,
flags_noint_in);
gpio_pin_configure(gpio, cc2520_gpios[CC2520_GPIO_IDX_CCA].pin,
flags_noint_in);
cc2520_gpios[CC2520_GPIO_IDX_FIFOP].dev = gpio;
cc2520_gpios[CC2520_GPIO_IDX_FIFO].dev = gpio;
cc2520_gpios[CC2520_GPIO_IDX_SFD].dev = gpio;
cc2520_gpios[CC2520_GPIO_IDX_CCA].dev = gpio;
return cc2520_gpios;
}
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;
}
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);
}
static struct device *gpio_cs_init(struct spi_qmsi_config *config)
{
struct device *gpio;
if (!config->cs_port)
return NULL;
gpio = device_get_binding(config->cs_port);
if (!gpio)
return NULL;
gpio_pin_configure(gpio, config->cs_pin, GPIO_DIR_OUT);
gpio_pin_write(gpio, config->cs_pin, 1);
return gpio;
}
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;
}
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 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 int dht_init(struct device *dev)
{
struct dht_data *drv_data = dev->driver_data;
drv_data->gpio = device_get_binding(CONFIG_DHT_GPIO_DEV_NAME);
if (drv_data->gpio == NULL) {
SYS_LOG_ERR("Failed to get GPIO device.");
return -EINVAL;
}
gpio_pin_configure(drv_data->gpio, CONFIG_DHT_GPIO_PIN_NUM,
GPIO_DIR_OUT);
gpio_pin_write(drv_data->gpio, CONFIG_DHT_GPIO_PIN_NUM, 1);
return 0;
}
static int pwr_ctrl_init(struct device *dev)
{
const struct pwr_ctrl_cfg *cfg = dev->config->config_info;
struct device *gpio;
gpio = device_get_binding(cfg->port);
if (!gpio) {
printk("Could not bind device \"%s\"\n", cfg->port);
return -ENODEV;
}
gpio_pin_configure(gpio, cfg->pin, GPIO_DIR_OUT);
gpio_pin_write(gpio, cfg->pin, 1);
k_sleep(1); /* Wait for the rail to come up and stabilize */
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);
}
void HAL_PCDEx_SetConnectionState(PCD_HandleTypeDef *hpcd, uint8_t state)
{
struct device *usb_disconnect;
usb_disconnect = device_get_binding(
DT_ST_STM32_USB_0_DISCONNECT_GPIOS_CONTROLLER);
gpio_pin_configure(usb_disconnect,
DT_ST_STM32_USB_0_DISCONNECT_GPIOS_PIN, GPIO_DIR_OUT);
if (state) {
gpio_pin_write(usb_disconnect,
DT_ST_STM32_USB_0_DISCONNECT_GPIOS_PIN,
DT_ST_STM32_USB_0_DISCONNECT_GPIOS_FLAGS);
} else {
gpio_pin_write(usb_disconnect,
DT_ST_STM32_USB_0_DISCONNECT_GPIOS_PIN,
!DT_ST_STM32_USB_0_DISCONNECT_GPIOS_FLAGS);
}
}
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;
}
