/**
* 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;
}
