zara
/
zephyr
mirror of https://github.com/zephyrproject-rtos/zephyr
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Primary Git Repository for the Zephyr Project. Zephyr is a new generation, scalable, optimized, secure RTOS for multiple hardware architectures.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
118623 Commits
85 Branches
204 Tags
1.7 GiB
 
 
 
 
 
 
Tree: 697d0f845d
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '697d0f845d'
${ noResults }
zephyr/drivers/regulator/regulator_npm2100.c

779 lines
22 KiB
Raw Blame History

/*
* Copyright (c) 2024 Nordic Semiconductor ASA
* SPDX-License-Identifier: Apache-2.0
*/
#define DT_DRV_COMPAT nordic_npm2100_regulator
#include <errno.h>
#include <string.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/regulator.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/dt-bindings/regulator/npm2100.h>
#include <zephyr/sys/linear_range.h>
#include <zephyr/sys/util.h>
enum npm2100_sources {
NPM2100_SOURCE_BOOST,
NPM2100_SOURCE_LDOSW,
};
#define BOOST_VOUT 0x22U
#define BOOST_VOUTSEL 0x23U
#define BOOST_OPER 0x24U
#define BOOST_LIMIT 0x26U
#define BOOST_GPIO 0x28U
#define BOOST_PIN 0x29U
#define BOOST_CTRLSET 0x2AU
#define BOOST_CTRLCLR 0x2BU
#define BOOST_IBATLIM 0x2DU
#define BOOST_VBATMINL 0x2FU
#define BOOST_VBATMINH 0x30U
#define BOOST_VOUTMIN 0x31U
#define BOOST_VOUTWRN 0x32U
#define BOOST_VOUTDPS 0x33U
#define BOOST_STATUS0 0x34U
#define BOOST_STATUS1 0x35U
#define BOOST_VSET0 0x36U
#define BOOST_VSET1 0x37U
#define LDOSW_VOUT 0x68U
#define LDOSW_ENABLE 0x69U
#define LDOSW_SEL 0x6AU
#define LDOSW_GPIO 0x6BU
#define LDOSW_STATUS 0x6EU
#define LDOSW_PRGOCP 0x6FU
#define SHIP_TASK_SHIP 0xC0U
#define RESET_ALTCONFIG 0xD6U
#define RESET_WRITESTICKY 0xDBU
#define RESET_STROBESTICKY 0xDCU
#define BOOST_OPER_MODE_MASK 0x07U
#define BOOST_OPER_MODE_AUTO 0x00U
#define BOOST_OPER_MODE_HP 0x01U
#define BOOST_OPER_MODE_LP 0x02U
#define BOOST_OPER_MODE_PASS 0x03U
#define BOOST_OPER_MODE_NOHP 0x04U
#define BOOST_OPER_DPS_MASK 0x18U
#define BOOST_OPER_DPS_DISABLE 0x00U
#define BOOST_OPER_DPS_ALLOW 0x01U
#define BOOST_OPER_DPS_ALLOWLP 0x02U
#define BOOST_OPER_DPSTIMER_MASK 0x60U
#define BOOST_PIN_FORCE_HP 0x00U
#define BOOST_PIN_FORCE_LP 0x01U
#define BOOST_PIN_FORCE_PASS 0x02U
#define BOOST_PIN_FORCE_NOHP 0x03U
#define BOOST_STATUS0_MODE_MASK 0x07U
#define BOOST_STATUS0_MODE_HP 0x00U
#define BOOST_STATUS0_MODE_LP 0x01U
#define BOOST_STATUS0_MODE_ULP 0x02U
#define BOOST_STATUS0_MODE_PT 0x03U
#define BOOST_STATUS0_MODE_DPS 0x04U
#define BOOST_STATUS1_VSET_MASK 0x40U
#define LDOSW_SEL_OPER_MASK 0x06U
#define LDOSW_SEL_OPER_AUTO 0x00U
#define LDOSW_SEL_OPER_ULP 0x02U
#define LDOSW_SEL_OPER_HP 0x04U
#define LDOSW_SEL_OPER_PIN 0x06U
#define LDOSW_GPIO_PIN_MASK 0x07U
#define LDOSW_GPIO_PINACT_MASK 0x18U
#define LDOSW_GPIO_PINACT_HP 0x00U
#define LDOSW_GPIO_PINACT_ULP 0x08U
#define LDOSW_GPIO_PININACT_OFF 0x00U
#define LDOSW_GPIO_PININACT_ULP 0x10U
#define LDOSW_STATUS_LDO 0x01U
#define LDOSW_STATUS_SW 0x02U
#define LDOSW_STATUS_HP 0x04U
#define LDOSW_STATUS_ULP 0x08U
#define LDOSW_STATUS_OCP 0x10U
#define RESET_ALTCONFIG_LDOSW_OFF 0x01U
struct regulator_npm2100_pconfig {
struct i2c_dt_spec i2c;
struct gpio_dt_spec dvs_state_pins[2];
};
struct regulator_npm2100_config {
struct regulator_common_config common;
struct i2c_dt_spec i2c;
uint8_t source;
struct gpio_dt_spec mode_gpios;
bool ldosw_wd_reset;
uint8_t dps_timer;
uint8_t dps_pulse_limit;
};
struct regulator_npm2100_data {
struct regulator_common_data data;
bool ldsw_mode;
};
static const struct linear_range boost_range = LINEAR_RANGE_INIT(1800000, 50000, 0U, 30U);
static const struct linear_range ldosw_range = LINEAR_RANGE_INIT(800000, 50000, 8U, 52U);
static const struct linear_range vset0_range = LINEAR_RANGE_INIT(1800000, 100000, 0U, 6U);
static const struct linear_range vset1_ranges[] = {LINEAR_RANGE_INIT(3000000, 0, 0U, 0U),
LINEAR_RANGE_INIT(2700000, 100000, 1U, 3U),
LINEAR_RANGE_INIT(3100000, 100000, 4U, 6U)};
static const struct linear_range boost_ocp_range = LINEAR_RANGE_INIT(0, 300000, 0U, 1U);
static const struct linear_range ldsw_ocp_ranges[] = {LINEAR_RANGE_INIT(40000, 0, 0U, 0U),
LINEAR_RANGE_INIT(70000, 5000, 1U, 3U),
LINEAR_RANGE_INIT(110000, 0, 4U, 4U)};
static const uint8_t ldo_ocp_lookup[] = {13, 7, 6, 4, 1};
static const struct linear_range ldo_ocp_ranges[] = {LINEAR_RANGE_INIT(25000, 13000, 0U, 1U),
LINEAR_RANGE_INIT(50000, 25000, 2U, 3U),
LINEAR_RANGE_INIT(150000, 0, 4U, 4U)};
static const uint8_t ldsw_ocp_lookup[] = {1, 7, 8, 9, 15};
static unsigned int regulator_npm2100_count_voltages(const struct device *dev)
{
const struct regulator_npm2100_config *config = dev->config;
switch (config->source) {
case NPM2100_SOURCE_BOOST:
return linear_range_values_count(&boost_range);
case NPM2100_SOURCE_LDOSW:
return linear_range_values_count(&ldosw_range);
default:
return 0;
}
}
static int regulator_npm2100_list_voltage(const struct device *dev, unsigned int idx,
int32_t *volt_uv)
{
const struct regulator_npm2100_config *config = dev->config;
switch (config->source) {
case NPM2100_SOURCE_BOOST:
return linear_range_get_value(&boost_range, idx, volt_uv);
case NPM2100_SOURCE_LDOSW:
return linear_range_get_value(&ldosw_range, idx, volt_uv);
default:
return -EINVAL;
}
}
static int regulator_npm2100_set_voltage(const struct device *dev, int32_t min_uv, int32_t max_uv)
{
const struct regulator_npm2100_config *config = dev->config;
uint16_t idx;
int ret;
switch (config->source) {
case NPM2100_SOURCE_BOOST:
ret = linear_range_get_win_index(&boost_range, min_uv, max_uv, &idx);
if (ret == -EINVAL) {
return ret;
}
ret = i2c_reg_write_byte_dt(&config->i2c, BOOST_VOUT, idx);
if (ret < 0) {
return ret;
}
/* Enable SW control of boost voltage */
return i2c_reg_write_byte_dt(&config->i2c, BOOST_VOUTSEL, 1U);
case NPM2100_SOURCE_LDOSW:
ret = linear_range_get_win_index(&ldosw_range, min_uv, max_uv, &idx);
if (ret == -EINVAL) {
return ret;
}
return i2c_reg_write_byte_dt(&config->i2c, LDOSW_VOUT, idx);
default:
return -ENODEV;
}
}
static int regulator_npm2100_get_voltage(const struct device *dev, int32_t *volt_uv)
{
const struct regulator_npm2100_config *config = dev->config;
uint8_t idx;
int ret;
switch (config->source) {
case NPM2100_SOURCE_BOOST:
ret = i2c_reg_read_byte_dt(&config->i2c, BOOST_VOUTSEL, &idx);
if (ret < 0) {
return ret;
}
if (idx == 1U) {
/* Voltage is selected by register value */
ret = i2c_reg_read_byte_dt(&config->i2c, BOOST_VOUT, &idx);
if (ret < 0) {
return ret;
}
return linear_range_get_value(&boost_range, idx, volt_uv);
}
/* Voltage is selected by VSET pin */
ret = i2c_reg_read_byte_dt(&config->i2c, BOOST_STATUS1, &idx);
if (ret < 0) {
return ret;
}
if ((idx & BOOST_STATUS1_VSET_MASK) == 0U) {
/* VSET low, voltage is selected by VSET0 register */
ret = i2c_reg_read_byte_dt(&config->i2c, BOOST_VSET0, &idx);
if (ret < 0) {
return ret;
}
return linear_range_get_value(&vset0_range, idx, volt_uv);
}
/* VSET high, voltage is selected by VSET1 register */
ret = i2c_reg_read_byte_dt(&config->i2c, BOOST_VSET1, &idx);
if (ret < 0) {
return ret;
}
return linear_range_group_get_value(vset1_ranges, ARRAY_SIZE(vset1_ranges), idx,
volt_uv);
case NPM2100_SOURCE_LDOSW:
ret = i2c_reg_read_byte_dt(&config->i2c, LDOSW_VOUT, &idx);
if (ret < 0) {
return ret;
}
return linear_range_get_value(&ldosw_range, idx, volt_uv);
default:
return -ENODEV;
}
}
static unsigned int regulator_npm2100_count_currents(const struct device *dev)
{
const struct regulator_npm2100_config *config = dev->config;
const struct regulator_npm2100_data *data = dev->data;
switch (config->source) {
case NPM2100_SOURCE_BOOST:
return linear_range_values_count(&boost_ocp_range);
case NPM2100_SOURCE_LDOSW:
if (data->ldsw_mode) {
return linear_range_group_values_count(ldsw_ocp_ranges,
ARRAY_SIZE(ldsw_ocp_ranges));
}
return linear_range_group_values_count(ldo_ocp_ranges, ARRAY_SIZE(ldo_ocp_ranges));
default:
return 0;
}
}
static int regulator_npm2100_list_currents(const struct device *dev, unsigned int idx,
int32_t *current_ua)
{
const struct regulator_npm2100_config *config = dev->config;
const struct regulator_npm2100_data *data = dev->data;
switch (config->source) {
case NPM2100_SOURCE_BOOST:
return linear_range_get_value(&boost_ocp_range, idx, current_ua);
case NPM2100_SOURCE_LDOSW:
if (data->ldsw_mode) {
return linear_range_group_get_value(
ldsw_ocp_ranges, ARRAY_SIZE(ldsw_ocp_ranges), idx, current_ua);
}
return linear_range_group_get_value(ldo_ocp_ranges, ARRAY_SIZE(ldo_ocp_ranges), idx,
current_ua);
default:
return -EINVAL;
}
}
static int regulator_npm2100_set_current(const struct device *dev, int32_t min_ua, int32_t max_ua)
{
const struct regulator_npm2100_config *config = dev->config;
const struct regulator_npm2100_data *data = dev->data;
uint16_t idx = 0;
uint8_t shift = 0;
int ret;
switch (config->source) {
case NPM2100_SOURCE_BOOST:
ret = linear_range_get_win_index(&boost_ocp_range, min_ua, max_ua, &idx);
if (ret == -EINVAL) {
return ret;
}
if (idx == 1) {
return i2c_reg_write_byte_dt(&config->i2c, BOOST_CTRLSET, BIT(3));
}
return i2c_reg_write_byte_dt(&config->i2c, BOOST_CTRLCLR, BIT(3));
case NPM2100_SOURCE_LDOSW:
if (data->ldsw_mode) {
ret = linear_range_group_get_win_index(
ldsw_ocp_ranges, ARRAY_SIZE(ldsw_ocp_ranges), min_ua, max_ua, &idx);
idx = ldsw_ocp_lookup[idx];
shift = 4U;
} else {
ret = linear_range_group_get_win_index(
ldo_ocp_ranges, ARRAY_SIZE(ldo_ocp_ranges), min_ua, max_ua, &idx);
idx = ldo_ocp_lookup[idx];
}
if (ret == -EINVAL) {
return ret;
}
return i2c_reg_update_byte_dt(&config->i2c, LDOSW_PRGOCP, BIT_MASK(3) << shift,
idx << shift);
default:
return -ENODEV;
}
}
static int set_boost_mode(const struct device *dev, regulator_mode_t mode)
{
const struct regulator_npm2100_config *config = dev->config;
uint8_t reg;
/* Normal mode */
switch (mode & NPM2100_REG_OPER_MASK) {
case NPM2100_REG_OPER_AUTO:
reg = BOOST_OPER_MODE_AUTO;
break;
case NPM2100_REG_OPER_HP:
reg = BOOST_OPER_MODE_HP;
break;
case NPM2100_REG_OPER_LP:
reg = BOOST_OPER_MODE_LP;
break;
case NPM2100_REG_OPER_PASS:
reg = BOOST_OPER_MODE_PASS;
break;
case NPM2100_REG_OPER_NOHP:
reg = BOOST_OPER_MODE_NOHP;
break;
default:
return -ENOTSUP;
}
/* Configure DPS mode */
if ((mode & NPM2100_REG_DPS_MASK) != 0) {
uint8_t dps_val = (mode & NPM2100_REG_DPS_MASK) == NPM2100_REG_DPS_ALLOW
? BOOST_OPER_DPS_ALLOW
: BOOST_OPER_DPS_ALLOWLP;
reg |= FIELD_PREP(BOOST_OPER_DPS_MASK, dps_val);
}
/* Update mode and dps fields, but not dpstimer */
int ret = i2c_reg_update_byte_dt(&config->i2c, BOOST_OPER,
BOOST_OPER_MODE_MASK | BOOST_OPER_DPS_MASK, reg);
if (ret < 0) {
return ret;
}
/* Forced mode */
switch (mode & NPM2100_REG_FORCE_MASK) {
case 0U:
return 0;
case NPM2100_REG_FORCE_HP:
reg = BOOST_PIN_FORCE_HP;
break;
case NPM2100_REG_FORCE_LP:
reg = BOOST_PIN_FORCE_LP;
break;
case NPM2100_REG_FORCE_PASS:
reg = BOOST_PIN_FORCE_PASS;
break;
case NPM2100_REG_FORCE_NOHP:
reg = BOOST_PIN_FORCE_NOHP;
break;
default:
return -ENOTSUP;
}
/* Forced mode is only valid when gpio is configured */
if (config->mode_gpios.port == NULL) {
return -EINVAL;
}
return i2c_reg_write_byte_dt(&config->i2c, BOOST_PIN, reg);
}
static int get_boost_mode(const struct device *dev, regulator_mode_t *mode)
{
const struct regulator_npm2100_config *config = dev->config;
uint8_t reg;
int ret;
ret = i2c_reg_read_byte_dt(&config->i2c, BOOST_STATUS0, &reg);
if (ret < 0) {
return ret;
}
switch (reg & BOOST_STATUS0_MODE_MASK) {
case BOOST_STATUS0_MODE_HP:
*mode = NPM2100_REG_OPER_HP;
break;
case BOOST_STATUS0_MODE_LP:
*mode = NPM2100_REG_OPER_LP;
break;
case BOOST_STATUS0_MODE_ULP:
*mode = NPM2100_REG_OPER_ULP;
break;
case BOOST_STATUS0_MODE_PT:
*mode = NPM2100_REG_OPER_PASS;
break;
case BOOST_STATUS0_MODE_DPS:
/* STATUS0 indicates whether DPS is enabled, regardless of ALLOW/ALLOWLP setting.
* BOOST_OPER_DPS_ALLOW chosen instead of creating new enum value.
*/
*mode = BOOST_OPER_DPS_ALLOW;
break;
default:
return -ENOTSUP;
}
return 0;
}
static int get_ldosw_mode(const struct device *dev, regulator_mode_t *mode)
{
const struct regulator_npm2100_config *config = dev->config;
uint8_t reg;
int ret;
ret = i2c_reg_read_byte_dt(&config->i2c, LDOSW_STATUS, &reg);
if (ret < 0) {
return ret;
}
*mode = 0U;
if (reg & LDOSW_STATUS_SW) {
*mode |= NPM2100_REG_LDSW_EN;
}
if (reg & LDOSW_STATUS_HP) {
*mode |= NPM2100_REG_OPER_HP;
} else if (reg & LDOSW_STATUS_ULP) {
*mode |= NPM2100_REG_OPER_ULP;
}
return 0;
}
static int set_ldosw_gpio_mode(const struct device *dev, uint8_t inact, uint8_t act, uint8_t ldsw)
{
const struct regulator_npm2100_config *config = dev->config;
int ret;
ret = i2c_reg_update_byte_dt(&config->i2c, LDOSW_GPIO, LDOSW_GPIO_PINACT_MASK, inact | act);
if (ret < 0) {
return ret;
}
/* Set operating mode to pin control */
return i2c_reg_write_byte_dt(&config->i2c, LDOSW_SEL, LDOSW_SEL_OPER_PIN | ldsw);
}
static int set_ldosw_mode(const struct device *dev, regulator_mode_t mode)
{
const struct regulator_npm2100_config *config = dev->config;
struct regulator_npm2100_data *data = dev->data;
uint8_t ldsw = mode & NPM2100_REG_LDSW_EN;
uint8_t oper = mode & NPM2100_REG_OPER_MASK;
uint8_t force = mode & NPM2100_REG_FORCE_MASK;
/* Save load switch state, needed for OCP configuration */
data->ldsw_mode = ldsw != 0;
if (force == 0U) {
/* SW control of mode */
switch (oper) {
case NPM2100_REG_OPER_AUTO:
return i2c_reg_write_byte_dt(&config->i2c, LDOSW_SEL,
LDOSW_SEL_OPER_AUTO | ldsw);
case NPM2100_REG_OPER_ULP:
return i2c_reg_write_byte_dt(&config->i2c, LDOSW_SEL,
LDOSW_SEL_OPER_ULP | ldsw);
case NPM2100_REG_OPER_HP:
return i2c_reg_write_byte_dt(&config->i2c, LDOSW_SEL,
LDOSW_SEL_OPER_HP | ldsw);
default:
return -ENOTSUP;
}
}
/* Forced mode is only valid when gpio is configured */
if (config->mode_gpios.port == NULL) {
return -EINVAL;
}
switch (oper | force) {
case NPM2100_REG_OPER_OFF | NPM2100_REG_FORCE_ULP:
return set_ldosw_gpio_mode(dev, LDOSW_GPIO_PININACT_OFF, LDOSW_GPIO_PINACT_ULP,
ldsw);
case NPM2100_REG_OPER_OFF | NPM2100_REG_FORCE_HP:
return set_ldosw_gpio_mode(dev, LDOSW_GPIO_PININACT_OFF, LDOSW_GPIO_PINACT_HP,
ldsw);
case NPM2100_REG_OPER_ULP | NPM2100_REG_FORCE_HP:
return set_ldosw_gpio_mode(dev, LDOSW_GPIO_PININACT_ULP, LDOSW_GPIO_PINACT_HP,
ldsw);
default:
return -ENOTSUP;
}
}
static int regulator_npm2100_set_mode(const struct device *dev, regulator_mode_t mode)
{
const struct regulator_npm2100_config *config = dev->config;
switch (config->source) {
case NPM2100_SOURCE_BOOST:
return set_boost_mode(dev, mode);
case NPM2100_SOURCE_LDOSW:
return set_ldosw_mode(dev, mode);
default:
return -ENOTSUP;
}
}
static int regulator_npm2100_get_mode(const struct device *dev, regulator_mode_t *mode)
{
const struct regulator_npm2100_config *config = dev->config;
switch (config->source) {
case NPM2100_SOURCE_BOOST:
return get_boost_mode(dev, mode);
case NPM2100_SOURCE_LDOSW:
return get_ldosw_mode(dev, mode);
default:
return -ENOTSUP;
}
}
static int regulator_npm2100_enable(const struct device *dev)
{
const struct regulator_npm2100_config *config = dev->config;
if (config->source != NPM2100_SOURCE_LDOSW) {
return 0;
}
return i2c_reg_write_byte_dt(&config->i2c, LDOSW_ENABLE, 1U);
}
static int regulator_npm2100_disable(const struct device *dev)
{
const struct regulator_npm2100_config *config = dev->config;
if (config->source != NPM2100_SOURCE_LDOSW) {
return 0;
}
return i2c_reg_write_byte_dt(&config->i2c, LDOSW_ENABLE, 0U);
}
static int init_pin_ctrl(const struct device *dev, const struct gpio_dt_spec *spec)
{
const struct regulator_npm2100_config *config = dev->config;
if (spec->port == NULL) {
return 0;
}
int ret = gpio_pin_configure_dt(spec, GPIO_INPUT);
if (ret != 0) {
return ret;
}
uint8_t pin = spec->pin << 1U;
uint8_t offset = ((spec->dt_flags & GPIO_ACTIVE_LOW) != 0U) ? 0U : 1U;
switch (config->source) {
case NPM2100_SOURCE_BOOST:
return i2c_reg_write_byte_dt(&config->i2c, BOOST_GPIO, pin + offset + 1U);
case NPM2100_SOURCE_LDOSW:
return i2c_reg_update_byte_dt(&config->i2c, LDOSW_GPIO, LDOSW_GPIO_PIN_MASK,
pin + offset);
default:
return -ENODEV;
}
}
static int regulator_npm2100_dvs_state_set(const struct device *dev, regulator_dvs_state_t state)
{
const struct regulator_npm2100_pconfig *pconfig = dev->config;
const struct gpio_dt_spec *spec;
int ret;
for (size_t idx = 0U; idx < 2U; idx++) {
spec = &pconfig->dvs_state_pins[idx];
if (spec->port != NULL) {
ret = gpio_pin_set_dt(spec, ((state >> idx) & 1U) != 0U);
if (ret != 0) {
return ret;
}
}
}
return 0;
}
static int regulator_npm2100_ship_mode(const struct device *dev)
{
const struct regulator_npm2100_pconfig *pconfig = dev->config;
return i2c_reg_write_byte_dt(&pconfig->i2c, SHIP_TASK_SHIP, 1U);
}
static DEVICE_API(regulator_parent, parent_api) = {
.dvs_state_set = regulator_npm2100_dvs_state_set,
.ship_mode = regulator_npm2100_ship_mode,
};
static int regulator_npm2100_common_init(const struct device *dev)
{
const struct regulator_npm2100_pconfig *pconfig = dev->config;
const struct gpio_dt_spec *spec;
int ret;
for (size_t idx = 0U; idx < 2U; idx++) {
spec = &pconfig->dvs_state_pins[idx];
if (spec->port != NULL) {
if (!gpio_is_ready_dt(spec)) {
return -ENODEV;
}
ret = gpio_pin_configure_dt(spec, GPIO_OUTPUT);
if (ret != 0) {
return ret;
}
}
}
return 0;
}
static int regulator_npm2100_init(const struct device *dev)
{
const struct regulator_npm2100_config *config = dev->config;
int ret;
if (!i2c_is_ready_dt(&config->i2c)) {
return -ENODEV;
}
/* Configure GPIO pin control */
ret = init_pin_ctrl(dev, &config->mode_gpios);
if (ret != 0) {
return ret;
}
/* BOOST is always enabled */
if (config->source == NPM2100_SOURCE_BOOST) {
ret = i2c_reg_write_byte_dt(
&config->i2c, BOOST_OPER,
FIELD_PREP(BOOST_OPER_DPSTIMER_MASK, config->dps_timer));
if (ret < 0) {
return ret;
}
ret = i2c_reg_write_byte_dt(&config->i2c, BOOST_LIMIT, config->dps_pulse_limit);
if (ret < 0) {
return ret;
}
return regulator_common_init(dev, true);
}
/* Configure LDOSW behavior during watchdog reset */
if (config->ldosw_wd_reset) {
ret = i2c_reg_write_byte_dt(&config->i2c, RESET_ALTCONFIG,
RESET_ALTCONFIG_LDOSW_OFF);
if (ret < 0) {
return ret;
}
}
/* Get enable state for LDOSW */
uint8_t enabled;
ret = i2c_reg_read_byte_dt(&config->i2c, LDOSW_ENABLE, &enabled);
if (ret < 0) {
return ret;
}
return regulator_common_init(dev, enabled != 0U);
}
static DEVICE_API(regulator, api) = {
.enable = regulator_npm2100_enable,
.disable = regulator_npm2100_disable,
.count_voltages = regulator_npm2100_count_voltages,
.list_voltage = regulator_npm2100_list_voltage,
.set_voltage = regulator_npm2100_set_voltage,
.get_voltage = regulator_npm2100_get_voltage,
.count_current_limits = regulator_npm2100_count_currents,
.list_current_limit = regulator_npm2100_list_currents,
.set_current_limit = regulator_npm2100_set_current,
.set_mode = regulator_npm2100_set_mode,
.get_mode = regulator_npm2100_get_mode};
#define REGULATOR_NPM2100_DEFINE(node_id, id, _source) \
static struct regulator_npm2100_data data_##id; \
\
static const struct regulator_npm2100_config config_##id = { \
.common = REGULATOR_DT_COMMON_CONFIG_INIT(node_id), \
.i2c = I2C_DT_SPEC_GET(DT_GPARENT(node_id)), \
.source = _source, \
.mode_gpios = GPIO_DT_SPEC_GET_OR(node_id, mode_gpios, {0}), \
.ldosw_wd_reset = DT_PROP(node_id, ldosw_wd_reset), \
.dps_timer = DT_ENUM_IDX_OR(node_id, dps_timer_us, 0), \
.dps_pulse_limit = DT_PROP_OR(node_id, dps_pulse_limit, 0)}; \
BUILD_ASSERT(DT_PROP_OR(node_id, dps_pulse_limit, 0) >= 3 || \
DT_PROP_OR(node_id, dps_pulse_limit, 0) == 0, \
"Invalid dps_pulse_limit value"); \
\
DEVICE_DT_DEFINE(node_id, regulator_npm2100_init, NULL, &data_##id, &config_##id, \
POST_KERNEL, CONFIG_REGULATOR_NPM2100_INIT_PRIORITY, &api);
#define REGULATOR_NPM2100_DEFINE_COND(inst, child, source) \
COND_CODE_1(DT_NODE_EXISTS(DT_INST_CHILD(inst, child)), \
(REGULATOR_NPM2100_DEFINE(DT_INST_CHILD(inst, child), child##inst, source)), \
())
#define REGULATOR_NPM2100_DEFINE_ALL(inst) \
static const struct regulator_npm2100_pconfig config_##inst = { \
.i2c = I2C_DT_SPEC_GET(DT_INST_PARENT(inst)), \
.dvs_state_pins = {GPIO_DT_SPEC_INST_GET_BY_IDX_OR(inst, dvs_gpios, 0, {0}), \
GPIO_DT_SPEC_INST_GET_BY_IDX_OR(inst, dvs_gpios, 1, {0})}}; \
\
DEVICE_DT_INST_DEFINE(inst, regulator_npm2100_common_init, NULL, NULL, &config_##inst, \
POST_KERNEL, CONFIG_REGULATOR_NPM2100_COMMON_INIT_PRIORITY, \
&parent_api); \
\
REGULATOR_NPM2100_DEFINE_COND(inst, boost, NPM2100_SOURCE_BOOST) \
REGULATOR_NPM2100_DEFINE_COND(inst, ldosw, NPM2100_SOURCE_LDOSW)
DT_INST_FOREACH_STATUS_OKAY(REGULATOR_NPM2100_DEFINE_ALL)