/** * Initialises the local interrupt pin * * @param Pointer to device structure * @param interrupt handler to setup * @param Pointer to data to pass to irq * * @return 0 on success, non-zero on failure */ static int init_intpin(struct adxl345 * adxl345, hal_gpio_irq_handler_t handler, void * arg) { struct adxl345_private_driver_data *pdd = &adxl345->pdd; hal_gpio_irq_trig_t trig; int pin = -1; int rc; int i; for (i = 0; i < MYNEWT_VAL(SENSOR_MAX_INTERRUPTS_PINS); i++){ pin = adxl345->sensor.s_itf.si_ints[i].host_pin; if (pin >= 0) { break; } } if (pin < 0) { ADXL345_LOG(ERROR, "Interrupt pin not configured\n"); return SYS_EINVAL; } pdd->int_num = i; if (adxl345->sensor.s_itf.si_ints[pdd->int_num].active) { trig = HAL_GPIO_TRIG_RISING; } else { trig = HAL_GPIO_TRIG_FALLING; } if (adxl345->sensor.s_itf.si_ints[pdd->int_num].device_pin == 1) { pdd->int_route = 0x00; } else if (adxl345->sensor.s_itf.si_ints[pdd->int_num].device_pin == 2) { pdd->int_route = 0xFF; } else { ADXL345_LOG(ERROR, "Route not configured\n"); return SYS_EINVAL; } rc = hal_gpio_irq_init(pin, handler, arg, trig, HAL_GPIO_PULL_NONE); if (rc != 0) { ADXL345_LOG(ERROR, "Failed to initialise interrupt pin %d\n", pin); return rc; } return 0; }
static int init_intpin(struct lis2dw12 * lis2dw12, hal_gpio_irq_handler_t handler, void * arg) { struct lis2dw12_private_driver_data *pdd = &lis2dw12->pdd; hal_gpio_irq_trig_t trig; int pin = -1; int rc; int i; for (i = 0; i < MYNEWT_VAL(SENSOR_MAX_INTERRUPTS_PINS); i++){ pin = lis2dw12->sensor.s_itf.si_ints[i].host_pin; if (pin >= 0) { break; } } if (pin < 0) { LIS2DW12_ERR("Interrupt pin not configured\n"); return SYS_EINVAL; } pdd->int_num = i; if (lis2dw12->sensor.s_itf.si_ints[pdd->int_num].active) { trig = HAL_GPIO_TRIG_RISING; } else { trig = HAL_GPIO_TRIG_FALLING; } rc = hal_gpio_irq_init(pin, handler, arg, trig, HAL_GPIO_PULL_NONE); if (rc != 0) { LIS2DW12_ERR("Failed to initialise interrupt pin %d\n", pin); return rc; } return 0; }
static int bq24040_configure_pin(struct bq24040_pin *pin) { if ((!pin) || (pin->bp_pin_num == -1)) { return 0; } if (pin->bp_pin_direction == HAL_GPIO_MODE_IN) { if (pin->bp_irq_trig != HAL_GPIO_TRIG_NONE) { assert(pin->bp_irq_fn != NULL); return hal_gpio_irq_init(pin->bp_pin_num, pin->bp_irq_fn, NULL, pin->bp_irq_trig, pin->bp_pull); } else { return hal_gpio_init_in(pin->bp_pin_num, pin->bp_pull); } } else if (pin->bp_pin_direction == HAL_GPIO_MODE_OUT) { return hal_gpio_init_out(pin->bp_pin_num, pin->bp_init_value); } return SYS_EINVAL; }
void SX1276IoIrqInit(DioIrqHandler **irqHandlers) { int rc; if (irqHandlers[0] != NULL) { rc = hal_gpio_irq_init(SX1276_DIO0, irqHandlers[0], NULL, HAL_GPIO_TRIG_RISING, HAL_GPIO_PULL_NONE); assert(rc == 0); hal_gpio_irq_enable(SX1276_DIO0); } if (irqHandlers[1] != NULL) { rc = hal_gpio_irq_init(SX1276_DIO1, irqHandlers[1], NULL, HAL_GPIO_TRIG_RISING, HAL_GPIO_PULL_NONE); assert(rc == 0); hal_gpio_irq_enable(SX1276_DIO1); } if (irqHandlers[2] != NULL) { rc = hal_gpio_irq_init(SX1276_DIO2, irqHandlers[2], NULL, HAL_GPIO_TRIG_RISING, HAL_GPIO_PULL_NONE); assert(rc == 0); hal_gpio_irq_enable(SX1276_DIO2); } if (irqHandlers[3] != NULL) { rc = hal_gpio_irq_init(SX1276_DIO3, irqHandlers[3], NULL, HAL_GPIO_TRIG_RISING, HAL_GPIO_PULL_NONE); assert(rc == 0); hal_gpio_irq_enable(SX1276_DIO3); } if (irqHandlers[4] != NULL) { rc = hal_gpio_irq_init(SX1276_DIO4, irqHandlers[4], NULL, HAL_GPIO_TRIG_RISING, HAL_GPIO_PULL_NONE); assert(rc == 0); hal_gpio_irq_enable(SX1276_DIO4); } if (irqHandlers[5] != NULL) { rc = hal_gpio_irq_init(SX1276_DIO5, irqHandlers[5], NULL, HAL_GPIO_TRIG_RISING, HAL_GPIO_PULL_NONE); assert(rc == 0); hal_gpio_irq_enable(SX1276_DIO5); } }
int hal_spi_config(int spi_num, struct hal_spi_settings *settings) { struct stm32_hal_spi *spi; struct stm32_hal_spi_cfg *cfg; SPI_InitTypeDef *init; GPIO_InitTypeDef gpio; uint32_t gpio_speed; IRQn_Type irq; uint32_t prescaler; int rc; int sr; __HAL_DISABLE_INTERRUPTS(sr); STM32_HAL_SPI_RESOLVE(spi_num, spi); init = &spi->handle.Init; cfg = spi->cfg; if (!spi->slave) { spi->handle.Init.NSS = SPI_NSS_HARD_OUTPUT; spi->handle.Init.Mode = SPI_MODE_MASTER; } else { spi->handle.Init.NSS = SPI_NSS_SOFT; spi->handle.Init.Mode = SPI_MODE_SLAVE; } gpio.Mode = GPIO_MODE_AF_PP; gpio.Pull = GPIO_NOPULL; /* TODO: also VERY_HIGH for STM32L1x */ if (settings->baudrate <= 2000) { gpio_speed = GPIO_SPEED_FREQ_LOW; } else if (settings->baudrate <= 12500) { gpio_speed = GPIO_SPEED_FREQ_MEDIUM; } else { gpio_speed = GPIO_SPEED_FREQ_HIGH; } /* Enable the clocks for this SPI */ switch (spi_num) { #if SPI_0_ENABLED case 0: __HAL_RCC_SPI1_CLK_ENABLE(); #if !defined(STM32F1) gpio.Alternate = GPIO_AF5_SPI1; #endif spi->handle.Instance = SPI1; break; #endif #if SPI_1_ENABLED case 1: __HAL_RCC_SPI2_CLK_ENABLE(); #if !defined(STM32F1) gpio.Alternate = GPIO_AF5_SPI2; #endif spi->handle.Instance = SPI2; break; #endif #if SPI_2_ENABLED case 2: __HAL_RCC_SPI3_CLK_ENABLE(); #if !defined(STM32F1) gpio.Alternate = GPIO_AF6_SPI3; #endif spi->handle.Instance = SPI3; break; #endif #if SPI_3_ENABLED case 3: __HAL_RCC_SPI4_CLK_ENABLE(); #if !defined(STM32F1) gpio.Alternate = GPIO_AF5_SPI4; #endif spi->handle.Instance = SPI4; break; #endif #if SPI_4_ENABLED case 4: __HAL_RCC_SPI5_CLK_ENABLE(); #if !defined(STM32F1) gpio.Alternate = GPIO_AF5_SPI5; #endif spi->handle.Instance = SPI5; break; #endif #if SPI_5_ENABLED case 5: __HAL_RCC_SPI6_CLK_ENABLE(); #if !defined(STM32F1) gpio.Alternate = GPIO_AF5_SPI6; #endif spi->handle.Instance = SPI6; break; #endif default: assert(0); rc = -1; goto err; } if (!spi->slave) { if (settings->data_mode == HAL_SPI_MODE2 || settings->data_mode == HAL_SPI_MODE3) { gpio.Pull = GPIO_PULLUP; } else { gpio.Pull = GPIO_PULLDOWN; } } /* NOTE: Errata ES0125: STM32L100x6/8/B, STM32L151x6/8/B and * STM32L152x6/8/B ultra-low-power device limitations. * * 2.6.6 - Corrupted last bit of data and or CRC, received in Master * mode with delayed SCK feedback * * This driver is always using very high speed for SCK on STM32L1x */ #if defined(STM32L152xC) if (!spi->slave) { gpio.Speed = GPIO_SPEED_FREQ_VERY_HIGH; } else { gpio.Speed = gpio_speed; } #else gpio.Speed = gpio_speed; #endif rc = hal_gpio_init_stm(cfg->sck_pin, &gpio); if (rc != 0) { goto err; } #if defined(STM32L152xC) if (!spi->slave) { gpio.Speed = gpio_speed; } #endif if (!spi->slave) { gpio.Pull = GPIO_NOPULL; } else { gpio.Mode = GPIO_MODE_AF_OD; } rc = hal_gpio_init_stm(cfg->mosi_pin, &gpio); if (rc != 0) { goto err; } if (!spi->slave) { gpio.Mode = GPIO_MODE_AF_OD; } else { gpio.Mode = GPIO_MODE_AF_PP; } rc = hal_gpio_init_stm(cfg->miso_pin, &gpio); if (rc != 0) { goto err; } switch (settings->data_mode) { case HAL_SPI_MODE0: init->CLKPolarity = SPI_POLARITY_LOW; init->CLKPhase = SPI_PHASE_1EDGE; break; case HAL_SPI_MODE1: init->CLKPolarity = SPI_POLARITY_LOW; init->CLKPhase = SPI_PHASE_2EDGE; break; case HAL_SPI_MODE2: init->CLKPolarity = SPI_POLARITY_HIGH; init->CLKPhase = SPI_PHASE_1EDGE; break; case HAL_SPI_MODE3: init->CLKPolarity = SPI_POLARITY_HIGH; init->CLKPhase = SPI_PHASE_2EDGE; break; default: rc = -1; goto err; } switch (settings->data_order) { case HAL_SPI_MSB_FIRST: init->FirstBit = SPI_FIRSTBIT_MSB; break; case HAL_SPI_LSB_FIRST: init->FirstBit = SPI_FIRSTBIT_LSB; break; default: rc = -1; goto err; } switch (settings->word_size) { case HAL_SPI_WORD_SIZE_8BIT: init->DataSize = SPI_DATASIZE_8BIT; break; case HAL_SPI_WORD_SIZE_9BIT: init->DataSize = SPI_DATASIZE_16BIT; break; default: rc = -1; goto err; } rc = stm32_spi_resolve_prescaler(spi_num, settings->baudrate * 1000, &prescaler); if (rc != 0) { goto err; } init->BaudRatePrescaler = prescaler; /* Add default values */ init->Direction = SPI_DIRECTION_2LINES; init->TIMode = SPI_TIMODE_DISABLE; init->CRCCalculation = SPI_CRCCALCULATION_DISABLE; init->CRCPolynomial = 1; #ifdef SPI_NSS_PULSE_DISABLE init->NSSPMode = SPI_NSS_PULSE_DISABLE; #endif irq = stm32_resolve_spi_irq(&spi->handle); NVIC_SetPriority(irq, cfg->irq_prio); NVIC_SetVector(irq, stm32_resolve_spi_irq_handler(&spi->handle)); NVIC_EnableIRQ(irq); /* Init, Enable */ rc = HAL_SPI_Init(&spi->handle); if (rc != 0) { goto err; } if (spi->slave) { hal_spi_slave_set_def_tx_val(spi_num, 0); rc = hal_gpio_irq_init(cfg->ss_pin, spi_ss_isr, spi, HAL_GPIO_TRIG_BOTH, HAL_GPIO_PULL_UP); spi_ss_isr(spi); } __HAL_ENABLE_INTERRUPTS(sr); return (0); err: __HAL_ENABLE_INTERRUPTS(sr); return (rc); }
int adp5061_init(struct os_dev *dev, void *arg) { struct adp5061_dev *adp5061 = (struct adp5061_dev *)dev; struct charge_control *cc; struct charge_control_itf *cci; const struct adp5061_config *cfg; uint8_t device_id; int rc; if (!dev) { rc = SYS_ENODEV; goto err; } cc = &adp5061->a_chg_ctrl; cci = (struct charge_control_itf *)arg; rc = charge_control_init(cc, dev); if (rc) { goto err; } charge_control_set_interface(cc, cci); /* Add the driver with all the supported types */ rc = charge_control_set_driver(cc, CHARGE_CONTROL_TYPE_STATUS, (struct charge_control_driver *)&g_adp5061_chg_ctrl_driver); if (rc) { goto err; } charge_control_set_type_mask(cc, CHARGE_CONTROL_TYPE_STATUS | CHARGE_CONTROL_TYPE_FAULT); cfg = &default_config; rc = adp5061_get_device_id(adp5061, &device_id); if (rc) { goto err; } /* Sanity check, device ID as specified in ADP5061 datasheet */ if (device_id != 0x19) { rc = SYS_ENODEV; goto err; } #if MYNEWT_VAL(ADP5061_INT_PIN) >= 0 hal_gpio_irq_init(MYNEWT_VAL(ADP5061_INT_PIN), adp5061_isr, adp5061, HAL_GPIO_TRIG_FALLING, HAL_GPIO_PULL_NONE); #endif rc = adp5061_set_config(adp5061, cfg); if (rc) { goto err; } rc = charge_control_mgr_register(cc); if (rc) { goto err; } #if MYNEWT_VAL(ADP5061_CLI) adp5061_shell_init(adp5061); #endif return 0; err: return rc; }