| /* |
| * Copyright (c) 2022 Nordic Semiconductor ASA |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #define DT_DRV_COMPAT nordic_npm6001_regulator |
| |
| #include <errno.h> |
| |
| #include <zephyr/drivers/i2c.h> |
| #include <zephyr/drivers/regulator.h> |
| #include <zephyr/dt-bindings/regulator/npm6001.h> |
| #include <zephyr/sys/__assert.h> |
| #include <zephyr/sys/linear_range.h> |
| #include <zephyr/sys/util.h> |
| |
| /* nPM6001 voltage sources */ |
| enum npm6001_sources { |
| NPM6001_SOURCE_BUCK0, |
| NPM6001_SOURCE_BUCK1, |
| NPM6001_SOURCE_BUCK2, |
| NPM6001_SOURCE_BUCK3, |
| NPM6001_SOURCE_LDO0, |
| NPM6001_SOURCE_LDO1, |
| }; |
| |
| /* nPM6001 regulator related registers */ |
| #define NPM6001_TASKS_START_BUCK3 0x02U |
| #define NPM6001_TASKS_START_LDO0 0x03U |
| #define NPM6001_TASKS_START_LDO1 0x04U |
| #define NPM6001_TASKS_STOP_BUCK3 0x08U |
| #define NPM6001_TASKS_STOP_LDO0 0x09U |
| #define NPM6001_TASKS_STOP_LDO1 0x0AU |
| #define NPM6001_TASKS_UPDATE_VOUTPWM 0x0EU |
| #define NPM6001_EVENTS_THWARN 0x1EU |
| #define NPM6001_EVENTS_BUCK0OC 0x1FU |
| #define NPM6001_EVENTS_BUCK1OC 0x20U |
| #define NPM6001_EVENTS_BUCK2OC 0x21U |
| #define NPM6001_EVENTS_BUCK3OC 0x22U |
| #define NPM6001_BUCK0VOUTULP 0x3AU |
| #define NPM6001_BUCK1VOUTULP 0x3CU |
| #define NPM6001_BUCK2VOUTULP 0x40U |
| #define NPM6001_BUCK3SELDAC 0x44U |
| #define NPM6001_BUCK3VOUT 0x45U |
| #define NPM6001_LDO0VOUT 0x46U |
| #define NPM6001_BUCK0CONFPWMMODE 0x4AU |
| #define NPM6001_BUCK1CONFPWMMODE 0x4BU |
| #define NPM6001_BUCK2CONFPWMMODE 0x4CU |
| #define NPM6001_BUCK3CONFPWMMODE 0x4DU |
| #define NPM6001_BUCKMODEPADCONF 0x4EU |
| #define NPM6001_PADDRIVESTRENGTH 0x53U |
| #define NPM6001_OVERRIDEPWRUPBUCK 0xABU |
| |
| /* nPM6001 LDO0VOUT values */ |
| #define NPM6001_LDO0VOUT_SET1V8 0x06U |
| #define NPM6001_LDO0VOUT_SET2V1 0x0BU |
| #define NPM6001_LDO0VOUT_SET2V41 0x10U |
| #define NPM6001_LDO0VOUT_SET2V7 0x15U |
| #define NPM6001_LDO0VOUT_SET3V0 0x1AU |
| #define NPM6001_LDO0VOUT_SET3V3 0x1EU |
| |
| /* nPM6001 BUCKXCONFPWMMODE fields */ |
| #define NPM6001_BUCKXCONFPWMMODE_SETFORCEPWM_MSK 0x8U |
| #define NPM6001_BUCKXCONFPWMMODE_SETFORCEPWM_POS 3 |
| #define NPM6001_BUCKXCONFPWMMODE_SETFORCEPWM \ |
| BIT(NPM6001_BUCKXCONFPWMMODE_SETFORCEPWM_POS) |
| |
| #define NPM6001_BUCKMODEPADCONF_BUCKMODE0PADTYPE_CMOS BIT(0) |
| #define NPM6001_BUCKMODEPADCONF_BUCKMODE1PADTYPE_CMOS BIT(1) |
| #define NPM6001_BUCKMODEPADCONF_BUCKMODE2PADTYPE_CMOS BIT(2) |
| #define NPM6001_BUCKMODEPADCONF_BUCKMODE0PULLD_ENABLED BIT(4) |
| #define NPM6001_BUCKMODEPADCONF_BUCKMODE1PULLD_ENABLED BIT(5) |
| #define NPM6001_BUCKMODEPADCONF_BUCKMODE2PULLD_ENABLED BIT(6) |
| |
| /* nPM6001 PADDRIVESTRENGTH fields */ |
| #define NPM6001_PADDRIVESTRENGTH_READY_HIGH BIT(2) |
| #define NPM6001_PADDRIVESTRENGTH_NINT_HIGH BIT(3) |
| #define NPM6001_PADDRIVESTRENGTH_SDA_HIGH BIT(5) |
| |
| /* nPM6001 OVERRIDEPWRUPBUCK fields */ |
| #define NPM6001_OVERRIDEPWRUPBUCK_BUCK1DISABLE_MSK 0x22U |
| #define NPM6001_OVERRIDEPWRUPBUCK_BUCK2DISABLE_MSK 0x44U |
| #define NPM6001_OVERRIDEPWRUPBUCK_BUCK1DISABLE BIT(1) |
| #define NPM6001_OVERRIDEPWRUPBUCK_BUCK2DISABLE BIT(2) |
| |
| struct regulator_npm6001_pconfig { |
| struct i2c_dt_spec i2c; |
| uint8_t buck_pad_val; |
| uint8_t pad_val; |
| }; |
| |
| struct regulator_npm6001_config { |
| struct regulator_common_config common; |
| const struct device *p; |
| uint8_t source; |
| }; |
| |
| struct regulator_npm6001_data { |
| struct regulator_common_data data; |
| }; |
| |
| struct regulator_npm6001_vmap { |
| uint8_t reg_val; |
| int32_t volt_uv; |
| }; |
| |
| static const struct linear_range buck0_range = |
| LINEAR_RANGE_INIT(1800000, 100000U, 0x0U, 0xFU); |
| |
| static const struct linear_range buck1_range = |
| LINEAR_RANGE_INIT(700000, 50000U, 0x0U, 0xEU); |
| |
| static const struct linear_range buck2_range = |
| LINEAR_RANGE_INIT(1200000, 50000U, 0xAU, 0xEU); |
| |
| static const struct linear_range buck3_range = |
| LINEAR_RANGE_INIT(500000, 25000U, 0x0U, 0x70U); |
| |
| static const struct regulator_npm6001_vmap ldo0_voltages[] = { |
| { NPM6001_LDO0VOUT_SET1V8, 1800000 }, |
| { NPM6001_LDO0VOUT_SET2V1, 2100000 }, |
| { NPM6001_LDO0VOUT_SET2V41, 2410000 }, |
| { NPM6001_LDO0VOUT_SET2V7, 2700000 }, |
| { NPM6001_LDO0VOUT_SET3V0, 3000000 }, |
| { NPM6001_LDO0VOUT_SET3V3, 3300000 }, |
| }; |
| |
| static int regulator_npm6001_ldo0_list_voltage(const struct device *dev, |
| unsigned int idx, |
| int32_t *volt_uv) |
| { |
| if (idx >= ARRAY_SIZE(ldo0_voltages)) { |
| return -EINVAL; |
| } |
| |
| *volt_uv = ldo0_voltages[idx].volt_uv; |
| |
| return 0; |
| } |
| |
| static int regulator_npm6001_buck012_set_voltage( |
| const struct device *dev, int32_t min_uv, int32_t max_uv, |
| const struct linear_range *range, uint8_t vout_reg, uint8_t conf_reg) |
| { |
| const struct regulator_npm6001_config *config = dev->config; |
| const struct regulator_npm6001_pconfig *pconfig = config->p->config; |
| uint8_t conf, buf[3]; |
| uint16_t idx; |
| int ret; |
| |
| ret = linear_range_get_win_index(range, min_uv, max_uv, &idx); |
| if (ret == -EINVAL) { |
| return ret; |
| } |
| |
| /* force PWM mode when updating voltage */ |
| ret = i2c_reg_read_byte_dt(&pconfig->i2c, conf_reg, &conf); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| if ((conf & NPM6001_BUCKXCONFPWMMODE_SETFORCEPWM) == 0U) { |
| ret = i2c_reg_write_byte_dt( |
| &pconfig->i2c, conf_reg, |
| conf | NPM6001_BUCKXCONFPWMMODE_SETFORCEPWM); |
| if (ret < 0) { |
| return ret; |
| } |
| } |
| |
| /* write voltage in both ULP/PWM registers */ |
| buf[0] = vout_reg; |
| buf[1] = (uint8_t)idx; |
| buf[2] = (uint8_t)idx; |
| |
| ret = i2c_write_dt(&pconfig->i2c, buf, sizeof(buf)); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| ret = i2c_reg_write_byte_dt(&pconfig->i2c, NPM6001_TASKS_UPDATE_VOUTPWM, |
| 1U); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| /* restore HYS mode if enabled before */ |
| if ((conf & NPM6001_BUCKXCONFPWMMODE_SETFORCEPWM) == 0U) { |
| ret = i2c_reg_write_byte_dt(&pconfig->i2c, conf_reg, conf); |
| if (ret < 0) { |
| return ret; |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int regulator_npm6001_buck3_set_voltage(const struct device *dev, |
| int32_t min_uv, int32_t max_uv) |
| { |
| const struct regulator_npm6001_config *config = dev->config; |
| const struct regulator_npm6001_pconfig *pconfig = config->p->config; |
| uint16_t idx; |
| uint8_t conf; |
| int ret; |
| |
| ret = linear_range_get_win_index(&buck3_range, min_uv, max_uv, &idx); |
| if (ret == -EINVAL) { |
| return ret; |
| } |
| |
| /* force PWM mode when updating voltage */ |
| ret = i2c_reg_read_byte_dt(&pconfig->i2c, NPM6001_BUCK3CONFPWMMODE, |
| &conf); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| if ((conf & NPM6001_BUCKXCONFPWMMODE_SETFORCEPWM) == 0U) { |
| ret = i2c_reg_write_byte_dt( |
| &pconfig->i2c, NPM6001_BUCK3CONFPWMMODE, |
| conf | NPM6001_BUCKXCONFPWMMODE_SETFORCEPWM); |
| if (ret < 0) { |
| return ret; |
| } |
| } |
| |
| ret = i2c_reg_write_byte_dt(&pconfig->i2c, NPM6001_BUCK3VOUT, |
| (uint8_t)idx); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| /* restore HYS mode if enabled before */ |
| if ((conf & NPM6001_BUCKXCONFPWMMODE_SETFORCEPWM) == 0U) { |
| ret = i2c_reg_write_byte_dt(&pconfig->i2c, |
| NPM6001_BUCK3CONFPWMMODE, conf); |
| if (ret < 0) { |
| return ret; |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int regulator_npm6001_ldo0_set_voltage(const struct device *dev, |
| int32_t min_uv, int32_t max_uv) |
| { |
| const struct regulator_npm6001_config *config = dev->config; |
| const struct regulator_npm6001_pconfig *pconfig = config->p->config; |
| uint8_t val; |
| size_t i; |
| |
| for (i = 0U; i < ARRAY_SIZE(ldo0_voltages); i++) { |
| if ((min_uv <= ldo0_voltages[i].volt_uv) && |
| (max_uv >= ldo0_voltages[i].volt_uv)) { |
| val = ldo0_voltages[i].reg_val; |
| break; |
| } |
| } |
| |
| if (i == ARRAY_SIZE(ldo0_voltages)) { |
| return -EINVAL; |
| } |
| |
| return i2c_reg_write_byte_dt(&pconfig->i2c, NPM6001_LDO0VOUT, val); |
| } |
| |
| static int |
| regulator_npm6001_buck0123_get_voltage(const struct device *dev, |
| const struct linear_range *range, |
| uint8_t vout_reg, int32_t *volt_uv) |
| { |
| const struct regulator_npm6001_config *config = dev->config; |
| const struct regulator_npm6001_pconfig *pconfig = config->p->config; |
| uint8_t idx; |
| int ret; |
| |
| ret = i2c_reg_read_byte_dt(&pconfig->i2c, vout_reg, &idx); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| return linear_range_get_value(range, idx, volt_uv); |
| } |
| |
| static int regulator_npm6001_ldo0_get_voltage(const struct device *dev, |
| int32_t *volt_uv) |
| { |
| const struct regulator_npm6001_config *config = dev->config; |
| const struct regulator_npm6001_pconfig *pconfig = config->p->config; |
| uint8_t val; |
| int ret; |
| |
| ret = i2c_reg_read_byte_dt(&pconfig->i2c, NPM6001_LDO0VOUT, &val); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| for (size_t i = 0U; i < ARRAY_SIZE(ldo0_voltages); i++) { |
| if (val == ldo0_voltages[i].reg_val) { |
| *volt_uv = ldo0_voltages[i].volt_uv; |
| return 0; |
| } |
| } |
| |
| __ASSERT(NULL, "Unexpected voltage"); |
| |
| return -EINVAL; |
| } |
| |
| static unsigned int regulator_npm6001_count_voltages(const struct device *dev) |
| { |
| const struct regulator_npm6001_config *config = dev->config; |
| |
| switch (config->source) { |
| case NPM6001_SOURCE_BUCK0: |
| return linear_range_values_count(&buck0_range); |
| case NPM6001_SOURCE_BUCK1: |
| return linear_range_values_count(&buck1_range); |
| case NPM6001_SOURCE_BUCK2: |
| return linear_range_values_count(&buck2_range); |
| case NPM6001_SOURCE_BUCK3: |
| return linear_range_values_count(&buck3_range); |
| case NPM6001_SOURCE_LDO0: |
| return 6U; |
| case NPM6001_SOURCE_LDO1: |
| return 1U; |
| default: |
| __ASSERT(NULL, "Unexpected source"); |
| } |
| |
| return 0; |
| } |
| |
| static int regulator_npm6001_list_voltage(const struct device *dev, |
| unsigned int idx, int32_t *volt_uv) |
| { |
| const struct regulator_npm6001_config *config = dev->config; |
| |
| switch (config->source) { |
| case NPM6001_SOURCE_BUCK0: |
| return linear_range_get_value(&buck0_range, idx, volt_uv); |
| case NPM6001_SOURCE_BUCK1: |
| return linear_range_get_value(&buck1_range, idx, volt_uv); |
| case NPM6001_SOURCE_BUCK2: |
| return linear_range_get_value( |
| &buck2_range, idx + buck2_range.min_idx, volt_uv); |
| case NPM6001_SOURCE_BUCK3: |
| return linear_range_get_value(&buck3_range, idx, volt_uv); |
| case NPM6001_SOURCE_LDO0: |
| return regulator_npm6001_ldo0_list_voltage(dev, idx, volt_uv); |
| case NPM6001_SOURCE_LDO1: |
| *volt_uv = 1800000; |
| break; |
| default: |
| __ASSERT(NULL, "Unexpected source"); |
| } |
| |
| return 0; |
| } |
| |
| static int regulator_npm6001_set_voltage(const struct device *dev, |
| int32_t min_uv, int32_t max_uv) |
| { |
| const struct regulator_npm6001_config *config = dev->config; |
| |
| switch (config->source) { |
| case NPM6001_SOURCE_BUCK0: |
| return regulator_npm6001_buck012_set_voltage( |
| dev, min_uv, max_uv, &buck0_range, NPM6001_BUCK0VOUTULP, |
| NPM6001_BUCK0CONFPWMMODE); |
| case NPM6001_SOURCE_BUCK1: |
| return regulator_npm6001_buck012_set_voltage( |
| dev, min_uv, max_uv, &buck1_range, NPM6001_BUCK1VOUTULP, |
| NPM6001_BUCK1CONFPWMMODE); |
| case NPM6001_SOURCE_BUCK2: |
| return regulator_npm6001_buck012_set_voltage( |
| dev, min_uv, max_uv, &buck2_range, NPM6001_BUCK2VOUTULP, |
| NPM6001_BUCK2CONFPWMMODE); |
| case NPM6001_SOURCE_BUCK3: |
| return regulator_npm6001_buck3_set_voltage(dev, min_uv, max_uv); |
| case NPM6001_SOURCE_LDO0: |
| return regulator_npm6001_ldo0_set_voltage(dev, min_uv, max_uv); |
| case NPM6001_SOURCE_LDO1: |
| if ((min_uv != 1800000) && (max_uv != 1800000)) { |
| return -EINVAL; |
| } |
| break; |
| default: |
| __ASSERT(NULL, "Unexpected source"); |
| } |
| |
| return 0; |
| } |
| |
| static int regulator_npm6001_get_voltage(const struct device *dev, |
| int32_t *volt_uv) |
| { |
| const struct regulator_npm6001_config *config = dev->config; |
| |
| switch (config->source) { |
| case NPM6001_SOURCE_BUCK0: |
| return regulator_npm6001_buck0123_get_voltage( |
| dev, &buck0_range, NPM6001_BUCK0VOUTULP, volt_uv); |
| case NPM6001_SOURCE_BUCK1: |
| return regulator_npm6001_buck0123_get_voltage( |
| dev, &buck1_range, NPM6001_BUCK1VOUTULP, volt_uv); |
| case NPM6001_SOURCE_BUCK2: |
| return regulator_npm6001_buck0123_get_voltage( |
| dev, &buck2_range, NPM6001_BUCK2VOUTULP, volt_uv); |
| case NPM6001_SOURCE_BUCK3: |
| return regulator_npm6001_buck0123_get_voltage( |
| dev, &buck3_range, NPM6001_BUCK3VOUT, volt_uv); |
| case NPM6001_SOURCE_LDO0: |
| return regulator_npm6001_ldo0_get_voltage(dev, volt_uv); |
| case NPM6001_SOURCE_LDO1: |
| *volt_uv = 1800000U; |
| break; |
| default: |
| __ASSERT(NULL, "Unexpected source"); |
| } |
| |
| return 0; |
| } |
| |
| static int regulator_npm6001_set_mode(const struct device *dev, |
| regulator_mode_t mode) |
| { |
| const struct regulator_npm6001_config *config = dev->config; |
| const struct regulator_npm6001_pconfig *pconfig = config->p->config; |
| uint8_t conf_reg; |
| |
| if (mode > NPM6001_MODE_PWM) { |
| return -ENOTSUP; |
| } |
| |
| switch (config->source) { |
| case NPM6001_SOURCE_BUCK0: |
| conf_reg = NPM6001_BUCK0CONFPWMMODE; |
| break; |
| case NPM6001_SOURCE_BUCK1: |
| conf_reg = NPM6001_BUCK1CONFPWMMODE; |
| break; |
| case NPM6001_SOURCE_BUCK2: |
| conf_reg = NPM6001_BUCK2CONFPWMMODE; |
| break; |
| case NPM6001_SOURCE_BUCK3: |
| conf_reg = NPM6001_BUCK3CONFPWMMODE; |
| break; |
| default: |
| return -ENOTSUP; |
| } |
| |
| return i2c_reg_update_byte_dt( |
| &pconfig->i2c, conf_reg, |
| NPM6001_BUCKXCONFPWMMODE_SETFORCEPWM_MSK, |
| mode << NPM6001_BUCKXCONFPWMMODE_SETFORCEPWM_POS); |
| } |
| |
| static int regulator_npm6001_get_mode(const struct device *dev, |
| regulator_mode_t *mode) |
| { |
| const struct regulator_npm6001_config *config = dev->config; |
| const struct regulator_npm6001_pconfig *pconfig = config->p->config; |
| uint8_t conf_reg, conf; |
| int ret; |
| |
| switch (config->source) { |
| case NPM6001_SOURCE_BUCK0: |
| conf_reg = NPM6001_BUCK0CONFPWMMODE; |
| break; |
| case NPM6001_SOURCE_BUCK1: |
| conf_reg = NPM6001_BUCK1CONFPWMMODE; |
| break; |
| case NPM6001_SOURCE_BUCK2: |
| conf_reg = NPM6001_BUCK2CONFPWMMODE; |
| break; |
| case NPM6001_SOURCE_BUCK3: |
| conf_reg = NPM6001_BUCK3CONFPWMMODE; |
| break; |
| default: |
| return -ENOTSUP; |
| } |
| |
| ret = i2c_reg_read_byte_dt(&pconfig->i2c, conf_reg, &conf); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| *mode = (conf & NPM6001_BUCKXCONFPWMMODE_SETFORCEPWM_MSK) >> |
| NPM6001_BUCKXCONFPWMMODE_SETFORCEPWM_POS; |
| |
| return 0; |
| } |
| |
| static int regulator_npm6001_enable(const struct device *dev) |
| { |
| const struct regulator_npm6001_config *config = dev->config; |
| const struct regulator_npm6001_pconfig *pconfig = config->p->config; |
| |
| switch (config->source) { |
| case NPM6001_SOURCE_BUCK1: |
| return i2c_reg_update_byte_dt( |
| &pconfig->i2c, NPM6001_OVERRIDEPWRUPBUCK, |
| NPM6001_OVERRIDEPWRUPBUCK_BUCK1DISABLE_MSK, 0U); |
| case NPM6001_SOURCE_BUCK2: |
| return i2c_reg_update_byte_dt( |
| &pconfig->i2c, NPM6001_OVERRIDEPWRUPBUCK, |
| NPM6001_OVERRIDEPWRUPBUCK_BUCK2DISABLE_MSK, 0U); |
| case NPM6001_SOURCE_BUCK3: |
| return i2c_reg_write_byte_dt(&pconfig->i2c, |
| NPM6001_TASKS_START_BUCK3, 1U); |
| case NPM6001_SOURCE_LDO0: |
| return i2c_reg_write_byte_dt(&pconfig->i2c, |
| NPM6001_TASKS_START_LDO0, 1U); |
| case NPM6001_SOURCE_LDO1: |
| return i2c_reg_write_byte_dt(&pconfig->i2c, |
| NPM6001_TASKS_START_LDO1, 1U); |
| default: |
| return 0; |
| } |
| } |
| |
| static int regulator_npm6001_disable(const struct device *dev) |
| { |
| const struct regulator_npm6001_config *config = dev->config; |
| const struct regulator_npm6001_pconfig *pconfig = config->p->config; |
| |
| switch (config->source) { |
| case NPM6001_SOURCE_BUCK1: |
| return i2c_reg_update_byte_dt( |
| &pconfig->i2c, NPM6001_OVERRIDEPWRUPBUCK, |
| NPM6001_OVERRIDEPWRUPBUCK_BUCK1DISABLE_MSK, |
| NPM6001_OVERRIDEPWRUPBUCK_BUCK1DISABLE); |
| case NPM6001_SOURCE_BUCK2: |
| return i2c_reg_update_byte_dt( |
| &pconfig->i2c, NPM6001_OVERRIDEPWRUPBUCK, |
| NPM6001_OVERRIDEPWRUPBUCK_BUCK2DISABLE_MSK, |
| NPM6001_OVERRIDEPWRUPBUCK_BUCK2DISABLE); |
| case NPM6001_SOURCE_BUCK3: |
| return i2c_reg_write_byte_dt(&pconfig->i2c, |
| NPM6001_TASKS_STOP_BUCK3, 1U); |
| case NPM6001_SOURCE_LDO0: |
| return i2c_reg_write_byte_dt(&pconfig->i2c, |
| NPM6001_TASKS_STOP_LDO0, 1U); |
| case NPM6001_SOURCE_LDO1: |
| return i2c_reg_write_byte_dt(&pconfig->i2c, |
| NPM6001_TASKS_STOP_LDO1, 1U); |
| default: |
| return 0; |
| } |
| } |
| |
| static int regulator_npm6001_get_error_flags(const struct device *dev, |
| regulator_error_flags_t *flags) |
| { |
| const struct regulator_npm6001_config *config = dev->config; |
| const struct regulator_npm6001_pconfig *pconfig = config->p->config; |
| uint8_t oc_reg, val; |
| int ret; |
| |
| *flags = 0U; |
| |
| /* read thermal warning */ |
| ret = i2c_reg_read_byte_dt(&pconfig->i2c, NPM6001_EVENTS_THWARN, &val); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| if (val != 0U) { |
| /* clear thermal warning */ |
| ret = i2c_reg_write_byte_dt(&pconfig->i2c, |
| NPM6001_EVENTS_THWARN, 0U); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| *flags |= REGULATOR_ERROR_OVER_TEMP; |
| } |
| |
| /* read overcurrent event */ |
| switch (config->source) { |
| case NPM6001_SOURCE_BUCK0: |
| oc_reg = NPM6001_EVENTS_BUCK0OC; |
| break; |
| case NPM6001_SOURCE_BUCK1: |
| oc_reg = NPM6001_EVENTS_BUCK1OC; |
| break; |
| case NPM6001_SOURCE_BUCK2: |
| oc_reg = NPM6001_EVENTS_BUCK2OC; |
| break; |
| case NPM6001_SOURCE_BUCK3: |
| oc_reg = NPM6001_EVENTS_BUCK3OC; |
| break; |
| default: |
| return 0; |
| } |
| |
| ret = i2c_reg_read_byte_dt(&pconfig->i2c, oc_reg, &val); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| if (val != 0U) { |
| /* clear overcurrent event */ |
| ret = i2c_reg_write_byte_dt(&pconfig->i2c, oc_reg, 0U); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| *flags |= REGULATOR_ERROR_OVER_CURRENT; |
| } |
| |
| return 0; |
| } |
| |
| static int regulator_npm6001_init(const struct device *dev) |
| { |
| const struct regulator_npm6001_config *config = dev->config; |
| bool is_enabled; |
| |
| regulator_common_data_init(dev); |
| |
| if (!device_is_ready(config->p)) { |
| return -ENODEV; |
| } |
| |
| /* BUCK1/2 are ON by default */ |
| is_enabled = (config->source == NPM6001_SOURCE_BUCK1) || |
| (config->source == NPM6001_SOURCE_BUCK2); |
| |
| return regulator_common_init(dev, is_enabled); |
| } |
| |
| static int regulator_npm6001_common_init(const struct device *dev) |
| { |
| const struct regulator_npm6001_pconfig *config = dev->config; |
| int ret; |
| |
| if (!device_is_ready(config->i2c.bus)) { |
| return -ENODEV; |
| } |
| |
| /* always select BUCK3 DAC (does not increase power consumption) */ |
| ret = i2c_reg_write_byte_dt(&config->i2c, NPM6001_BUCK3SELDAC, 1U); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| /* configure pad properties */ |
| ret = i2c_reg_write_byte_dt(&config->i2c, NPM6001_BUCKMODEPADCONF, |
| config->buck_pad_val); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| ret = i2c_reg_write_byte_dt(&config->i2c, NPM6001_PADDRIVESTRENGTH, |
| config->pad_val); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| return 0; |
| } |
| |
| static const struct regulator_driver_api api = { |
| .enable = regulator_npm6001_enable, |
| .disable = regulator_npm6001_disable, |
| .count_voltages = regulator_npm6001_count_voltages, |
| .list_voltage = regulator_npm6001_list_voltage, |
| .set_voltage = regulator_npm6001_set_voltage, |
| .get_voltage = regulator_npm6001_get_voltage, |
| .set_mode = regulator_npm6001_set_mode, |
| .get_mode = regulator_npm6001_get_mode, |
| .get_error_flags = regulator_npm6001_get_error_flags, |
| }; |
| |
| #define REGULATOR_NPM6001_DEFINE(node_id, id, _source, parent) \ |
| static struct regulator_npm6001_data data_##id; \ |
| \ |
| static const struct regulator_npm6001_config config_##id = { \ |
| .common = REGULATOR_DT_COMMON_CONFIG_INIT(node_id), \ |
| .p = parent, \ |
| .source = _source, \ |
| }; \ |
| \ |
| DEVICE_DT_DEFINE(node_id, regulator_npm6001_init, NULL, &data_##id, \ |
| &config_##id, POST_KERNEL, \ |
| CONFIG_REGULATOR_NPM6001_INIT_PRIORITY, &api); |
| |
| #define REGULATOR_NPM6001_DEFINE_COND(inst, child, source, parent) \ |
| COND_CODE_1(DT_NODE_EXISTS(DT_INST_CHILD(inst, child)), \ |
| (REGULATOR_NPM6001_DEFINE(DT_INST_CHILD(inst, child), \ |
| child##inst, source, parent)), \ |
| ()) |
| |
| #define REGULATOR_NPM6001_DEFINE_ALL(inst) \ |
| static const struct regulator_npm6001_pconfig config_##inst = { \ |
| .i2c = I2C_DT_SPEC_GET(DT_INST_PARENT(inst)), \ |
| .buck_pad_val = \ |
| ((DT_INST_ENUM_IDX(inst, \ |
| nordic_buck_mode0_input_type) * \ |
| NPM6001_BUCKMODEPADCONF_BUCKMODE0PADTYPE_CMOS) | \ |
| (DT_INST_ENUM_IDX(inst, \ |
| nordic_buck_mode1_input_type) * \ |
| NPM6001_BUCKMODEPADCONF_BUCKMODE1PADTYPE_CMOS) | \ |
| (DT_INST_ENUM_IDX(inst, \ |
| nordic_buck_mode2_input_type) * \ |
| NPM6001_BUCKMODEPADCONF_BUCKMODE2PADTYPE_CMOS) | \ |
| (DT_INST_PROP(inst, nordic_buck_mode0_pull_down) * \ |
| NPM6001_BUCKMODEPADCONF_BUCKMODE0PULLD_ENABLED) | \ |
| (DT_INST_PROP(inst, nordic_buck_mode1_pull_down) * \ |
| NPM6001_BUCKMODEPADCONF_BUCKMODE1PULLD_ENABLED) | \ |
| (DT_INST_PROP(inst, nordic_buck_mode2_pull_down) * \ |
| NPM6001_BUCKMODEPADCONF_BUCKMODE2PULLD_ENABLED)), \ |
| .pad_val = ((DT_INST_PROP(inst, nordic_ready_high_drive) * \ |
| NPM6001_PADDRIVESTRENGTH_READY_HIGH) | \ |
| (DT_INST_PROP(inst, nordic_nint_high_drive) * \ |
| NPM6001_PADDRIVESTRENGTH_NINT_HIGH) | \ |
| (DT_INST_PROP(inst, nordic_sda_high_drive) * \ |
| NPM6001_PADDRIVESTRENGTH_SDA_HIGH)), \ |
| }; \ |
| \ |
| DEVICE_DT_INST_DEFINE(inst, regulator_npm6001_common_init, NULL, NULL, \ |
| &config_##inst, POST_KERNEL, \ |
| CONFIG_REGULATOR_NPM6001_COMMON_INIT_PRIORITY, \ |
| NULL); \ |
| \ |
| REGULATOR_NPM6001_DEFINE_COND(inst, buck0, NPM6001_SOURCE_BUCK0, \ |
| DEVICE_DT_INST_GET(inst)) \ |
| REGULATOR_NPM6001_DEFINE_COND(inst, buck1, NPM6001_SOURCE_BUCK1, \ |
| DEVICE_DT_INST_GET(inst)) \ |
| REGULATOR_NPM6001_DEFINE_COND(inst, buck2, NPM6001_SOURCE_BUCK2, \ |
| DEVICE_DT_INST_GET(inst)) \ |
| REGULATOR_NPM6001_DEFINE_COND(inst, buck3, NPM6001_SOURCE_BUCK3, \ |
| DEVICE_DT_INST_GET(inst)) \ |
| REGULATOR_NPM6001_DEFINE_COND(inst, ldo0, NPM6001_SOURCE_LDO0, \ |
| DEVICE_DT_INST_GET(inst)) \ |
| REGULATOR_NPM6001_DEFINE_COND(inst, ldo1, NPM6001_SOURCE_LDO1, \ |
| DEVICE_DT_INST_GET(inst)) |
| |
| DT_INST_FOREACH_STATUS_OKAY(REGULATOR_NPM6001_DEFINE_ALL) |
