zara
/
zephyr
mirror of https://github.com/zephyrproject-rtos/zephyr
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

drivers: npm13xx: rename npm1300 to npm13xx 

Rename npm1300 to npm13xx in function names, documentation, etc. where
applicable for all the npm13xx drivers

Signed-off-by: Sergei Ovchinnikov <sergei.ovchinnikov@nordicsemi.no>
pull/92045/head
Sergei Ovchinnikov 2 months ago committed by Fabio Baltieri
parent
fb007db50a
commit
89b8383633
25 changed files with 616 additions and 617 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      boards/nordic/nrf9131ek/nrf9131ek_nrf9131_ns_defconfig
  2. 2
      drivers/gpio/CMakeLists.txt
  3. 14
      drivers/gpio/Kconfig.npm13xx
  4. 150
      drivers/gpio/gpio_npm13xx.c
  5. 2
      drivers/led/CMakeLists.txt
  6. 6
      drivers/led/Kconfig.npm13xx
  7. 54
      drivers/led/led_npm13xx.c
  8. 2
      drivers/mfd/CMakeLists.txt
  9. 14
      drivers/mfd/Kconfig.npm13xx
  10. 126
      drivers/mfd/mfd_npm13xx.c
  11. 2
      drivers/regulator/CMakeLists.txt
  12. 22
      drivers/regulator/Kconfig.npm13xx
  13. 376
      drivers/regulator/regulator_npm13xx.c
  14. 2
      drivers/sensor/nordic/CMakeLists.txt
  15. 6
      drivers/sensor/nordic/npm13xx_charger/Kconfig
  16. 158
      drivers/sensor/nordic/npm13xx_charger/npm13xx_charger.c
  17. 2
      drivers/watchdog/CMakeLists.txt
  18. 16
      drivers/watchdog/Kconfig.npm13xx
  19. 72
      drivers/watchdog/wdt_npm13xx.c
  20. 94
      include/zephyr/drivers/mfd/npm13xx.h
  21. 26
      include/zephyr/drivers/sensor/npm13xx_charger.h
  22. 44
      include/zephyr/dt-bindings/gpio/nordic-npm13xx-gpio.h
  23. 26
      include/zephyr/dt-bindings/regulator/npm13xx.h
  24. 4
      samples/shields/npm1300_ek/nrf52dk_nrf52832.overlay
  25. 12
      samples/shields/npm1300_ek/src/main.c

1
boards/nordic/nrf9131ek/nrf9131ek_nrf9131_ns_defconfig
Unescape View File

@ -26,4 +26,3 @@ CONFIG_UART_CONSOLE=y @@ -26,4 +26,3 @@ CONFIG_UART_CONSOLE=y
CONFIG_I2C=y
CONFIG_REGULATOR=y
CONFIG_SENSOR=y
CONFIG_NPM1300_CHARGER=y

2
drivers/gpio/CMakeLists.txt
Unescape View File

@ -67,7 +67,7 @@ zephyr_library_sources_ifdef(CONFIG_GPIO_NCT38XX gpio_nct38xx_port.c) @@ -67,7 +67,7 @@ zephyr_library_sources_ifdef(CONFIG_GPIO_NCT38XX gpio_nct38xx_port.c)
zephyr_library_sources_ifdef(CONFIG_GPIO_NCT38XX_ALERT gpio_nct38xx_alert.c)
zephyr_library_sources_ifdef(CONFIG_GPIO_NEORV32 gpio_neorv32.c)
zephyr_library_sources_ifdef(CONFIG_GPIO_NPCX gpio_npcx.c)
zephyr_library_sources_ifdef(CONFIG_GPIO_NPM1300 gpio_npm13xx.c)
zephyr_library_sources_ifdef(CONFIG_GPIO_NPM13XX gpio_npm13xx.c)
zephyr_library_sources_ifdef(CONFIG_GPIO_NPM2100 gpio_npm2100.c)
zephyr_library_sources_ifdef(CONFIG_GPIO_NPM6001 gpio_npm6001.c)
zephyr_library_sources_ifdef(CONFIG_GPIO_NRFX gpio_nrfx.c)

14
drivers/gpio/Kconfig.npm13xx
Unescape View File

@ -1,19 +1,19 @@ @@ -1,19 +1,19 @@
# Copyright (c) 2023 Nordic Semiconductor ASA
# SPDX-License-Identifier: Apache-2.0
config GPIO_NPM1300
bool "nPM1300 GPIO driver"
config GPIO_NPM13XX
bool "nPM13xx GPIO driver"
default y
depends on DT_HAS_NORDIC_NPM1300_GPIO_ENABLED
select I2C
select MFD
help
Enable the nPM1300 GPIO driver.
Enable the nPM13xx GPIO driver.
config GPIO_NPM1300_INIT_PRIORITY
int "nPM1300 GPIO driver initialization priority"
depends on GPIO_NPM1300
config GPIO_NPM13XX_INIT_PRIORITY
int "nPM13xx GPIO driver initialization priority"
depends on GPIO_NPM13XX
default 85
help
Initialization priority for the nPM1300 GPIO driver. It must be
Initialization priority for the nPM13xx GPIO driver. It must be
greater than the I2C controller init priority.

150
drivers/gpio/gpio_npm13xx.c
Unescape View File

@ -14,10 +14,10 @@ @@ -14,10 +14,10 @@
#include <zephyr/kernel.h>
#include <zephyr/sys/util_macro.h>
/* nPM1300 GPIO base address */
/* nPM13xx GPIO base address */
#define NPM_GPIO_BASE 0x06U
/* nPM1300 GPIO registers offsets */
/* nPM13xx GPIO registers offsets */
#define NPM_GPIO_OFFSET_MODE 0x00U
#define NPM_GPIO_OFFSET_DRIVE 0x05U
#define NPM_GPIO_OFFSET_PULLUP 0x0AU
@ -26,36 +26,36 @@ @@ -26,36 +26,36 @@
#define NPM_GPIO_OFFSET_DEBOUNCE 0x19U
#define NPM_GPIO_OFFSET_STATUS 0x1EU
/* nPM1300 Channel counts */
#define NPM1300_GPIO_PINS 5U
#define NPM1300_GPIO_GPIINPUT 0
#define NPM1300_GPIO_GPILOGIC1 1
#define NPM1300_GPIO_GPILOGIC0 2
#define NPM1300_GPIO_GPIEVENTRISE 3
#define NPM1300_GPIO_GPIEVENTFALL 4
#define NPM1300_GPIO_GPOIRQ 5
#define NPM1300_GPIO_GPORESET 6
#define NPM1300_GPIO_GPOPWRLOSSWARN 7
#define NPM1300_GPIO_GPOLOGIC1 8
#define NPM1300_GPIO_GPOLOGIC0 9
struct gpio_npm1300_config {
/* nPM13xx Channel counts */
#define NPM13XX_GPIO_PINS 5U
#define NPM13XX_GPIO_GPIINPUT 0
#define NPM13XX_GPIO_GPILOGIC1 1
#define NPM13XX_GPIO_GPILOGIC0 2
#define NPM13XX_GPIO_GPIEVENTRISE 3
#define NPM13XX_GPIO_GPIEVENTFALL 4
#define NPM13XX_GPIO_GPOIRQ 5
#define NPM13XX_GPIO_GPORESET 6
#define NPM13XX_GPIO_GPOPWRLOSSWARN 7
#define NPM13XX_GPIO_GPOLOGIC1 8
#define NPM13XX_GPIO_GPOLOGIC0 9
struct gpio_npm13xx_config {
struct gpio_driver_config common;
const struct device *mfd;
};
struct gpio_npm1300_data {
struct gpio_npm13xx_data {
struct gpio_driver_data common;
};
static int gpio_npm1300_port_get_raw(const struct device *dev, uint32_t *value)
static int gpio_npm13xx_port_get_raw(const struct device *dev, uint32_t *value)
{
const struct gpio_npm1300_config *config = dev->config;
const struct gpio_npm13xx_config *config = dev->config;
int ret;
uint8_t data;
ret = mfd_npm1300_reg_read(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_STATUS, &data);
ret = mfd_npm13xx_reg_read(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_STATUS, &data);
if (ret < 0) {
return ret;
@ -66,22 +66,22 @@ static int gpio_npm1300_port_get_raw(const struct device *dev, uint32_t *value) @@ -66,22 +66,22 @@ static int gpio_npm1300_port_get_raw(const struct device *dev, uint32_t *value)
return 0;
}
static int gpio_npm1300_port_set_masked_raw(const struct device *dev, gpio_port_pins_t mask,
static int gpio_npm13xx_port_set_masked_raw(const struct device *dev, gpio_port_pins_t mask,
gpio_port_value_t value)
{
const struct gpio_npm1300_config *config = dev->config;
const struct gpio_npm13xx_config *config = dev->config;
int ret = 0;
for (size_t idx = 0; idx < NPM1300_GPIO_PINS; idx++) {
for (size_t idx = 0; idx < NPM13XX_GPIO_PINS; idx++) {
if ((mask & BIT(idx)) != 0U) {
if ((value & BIT(idx)) != 0U) {
ret = mfd_npm1300_reg_write(config->mfd, NPM_GPIO_BASE,
ret = mfd_npm13xx_reg_write(config->mfd, NPM_GPIO_BASE,
NPM_GPIO_OFFSET_MODE + idx,
NPM1300_GPIO_GPOLOGIC1);
NPM13XX_GPIO_GPOLOGIC1);
} else {
ret = mfd_npm1300_reg_write(config->mfd, NPM_GPIO_BASE,
ret = mfd_npm13xx_reg_write(config->mfd, NPM_GPIO_BASE,
NPM_GPIO_OFFSET_MODE + idx,
NPM1300_GPIO_GPOLOGIC0);
NPM13XX_GPIO_GPOLOGIC0);
}
if (ret != 0U) {
return ret;
@ -92,53 +92,53 @@ static int gpio_npm1300_port_set_masked_raw(const struct device *dev, gpio_port_ @@ -92,53 +92,53 @@ static int gpio_npm1300_port_set_masked_raw(const struct device *dev, gpio_port_
return ret;
}
static int gpio_npm1300_port_set_bits_raw(const struct device *dev, gpio_port_pins_t pins)
static int gpio_npm13xx_port_set_bits_raw(const struct device *dev, gpio_port_pins_t pins)
{
return gpio_npm1300_port_set_masked_raw(dev, pins, pins);
return gpio_npm13xx_port_set_masked_raw(dev, pins, pins);
}
static int gpio_npm1300_port_clear_bits_raw(const struct device *dev, gpio_port_pins_t pins)
static int gpio_npm13xx_port_clear_bits_raw(const struct device *dev, gpio_port_pins_t pins)
{
return gpio_npm1300_port_set_masked_raw(dev, pins, 0U);
return gpio_npm13xx_port_set_masked_raw(dev, pins, 0U);
}
static inline int gpio_npm1300_configure(const struct device *dev, gpio_pin_t pin,
static inline int gpio_npm13xx_configure(const struct device *dev, gpio_pin_t pin,
gpio_flags_t flags)
{
const struct gpio_npm1300_config *config = dev->config;
const struct gpio_npm13xx_config *config = dev->config;
int ret = 0;
if (k_is_in_isr()) {
return -EWOULDBLOCK;
}
if (pin >= NPM1300_GPIO_PINS) {
if (pin >= NPM13XX_GPIO_PINS) {
return -EINVAL;
}
/* Configure mode */
if ((flags & GPIO_INPUT) != 0U) {
if (flags & GPIO_ACTIVE_LOW) {
ret = mfd_npm1300_reg_write(config->mfd, NPM_GPIO_BASE,
ret = mfd_npm13xx_reg_write(config->mfd, NPM_GPIO_BASE,
NPM_GPIO_OFFSET_MODE + pin,
NPM1300_GPIO_GPIEVENTFALL);
NPM13XX_GPIO_GPIEVENTFALL);
} else {
ret = mfd_npm1300_reg_write(config->mfd, NPM_GPIO_BASE,
ret = mfd_npm13xx_reg_write(config->mfd, NPM_GPIO_BASE,
NPM_GPIO_OFFSET_MODE + pin,
NPM1300_GPIO_GPIEVENTRISE);
NPM13XX_GPIO_GPIEVENTRISE);
}
} else if ((flags & NPM1300_GPIO_WDT_RESET_ON) != 0U) {
ret = mfd_npm1300_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_MODE + pin,
NPM1300_GPIO_GPORESET);
} else if ((flags & NPM1300_GPIO_PWRLOSSWARN_ON) != 0U) {
ret = mfd_npm1300_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_MODE + pin,
NPM1300_GPIO_GPOPWRLOSSWARN);
} else if ((flags & NPM13XX_GPIO_WDT_RESET_ON) != 0U) {
ret = mfd_npm13xx_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_MODE + pin,
NPM13XX_GPIO_GPORESET);
} else if ((flags & NPM13XX_GPIO_PWRLOSSWARN_ON) != 0U) {
ret = mfd_npm13xx_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_MODE + pin,
NPM13XX_GPIO_GPOPWRLOSSWARN);
} else if ((flags & GPIO_OUTPUT_INIT_HIGH) != 0U) {
ret = mfd_npm1300_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_MODE + pin,
NPM1300_GPIO_GPOLOGIC1);
ret = mfd_npm13xx_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_MODE + pin,
NPM13XX_GPIO_GPOLOGIC1);
} else if ((flags & GPIO_OUTPUT) != 0U) {
ret = mfd_npm1300_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_MODE + pin,
NPM1300_GPIO_GPOLOGIC0);
ret = mfd_npm13xx_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_MODE + pin,
NPM13XX_GPIO_GPOLOGIC0);
}
if (ret < 0) {
@ -146,64 +146,64 @@ static inline int gpio_npm1300_configure(const struct device *dev, gpio_pin_t pi @@ -146,64 +146,64 @@ static inline int gpio_npm1300_configure(const struct device *dev, gpio_pin_t pi
}
/* Configure open drain */
ret = mfd_npm1300_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_OPENDRAIN + pin,
ret = mfd_npm13xx_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_OPENDRAIN + pin,
!!(flags & GPIO_SINGLE_ENDED));
if (ret < 0) {
return ret;
}
/* Configure pulls */
ret = mfd_npm1300_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_PULLUP + pin,
ret = mfd_npm13xx_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_PULLUP + pin,
!!(flags & GPIO_PULL_UP));
if (ret < 0) {
return ret;
}
ret = mfd_npm1300_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_PULLDOWN + pin,
ret = mfd_npm13xx_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_PULLDOWN + pin,
!!(flags & GPIO_PULL_DOWN));
if (ret < 0) {
return ret;
}
/* Configure drive strength and debounce */
ret = mfd_npm1300_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_DRIVE + pin,
!!(flags & NPM1300_GPIO_DRIVE_6MA));
ret = mfd_npm13xx_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_DRIVE + pin,
!!(flags & NPM13XX_GPIO_DRIVE_6MA));
if (ret < 0) {
return ret;
}
ret = mfd_npm1300_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_DEBOUNCE + pin,
!!(flags & NPM1300_GPIO_DEBOUNCE_ON));
ret = mfd_npm13xx_reg_write(config->mfd, NPM_GPIO_BASE, NPM_GPIO_OFFSET_DEBOUNCE + pin,
!!(flags & NPM13XX_GPIO_DEBOUNCE_ON));
return ret;
}
static int gpio_npm1300_port_toggle_bits(const struct device *dev, gpio_port_pins_t pins)
static int gpio_npm13xx_port_toggle_bits(const struct device *dev, gpio_port_pins_t pins)
{
int ret;
uint32_t value;
ret = gpio_npm1300_port_get_raw(dev, &value);
ret = gpio_npm13xx_port_get_raw(dev, &value);
if (ret < 0) {
return ret;
}
return gpio_npm1300_port_set_masked_raw(dev, pins, ~value);
return gpio_npm13xx_port_set_masked_raw(dev, pins, ~value);
}
static DEVICE_API(gpio, gpio_npm1300_api) = {
.pin_configure = gpio_npm1300_configure,
.port_get_raw = gpio_npm1300_port_get_raw,
.port_set_masked_raw = gpio_npm1300_port_set_masked_raw,
.port_set_bits_raw = gpio_npm1300_port_set_bits_raw,
.port_clear_bits_raw = gpio_npm1300_port_clear_bits_raw,
.port_toggle_bits = gpio_npm1300_port_toggle_bits,
static DEVICE_API(gpio, gpio_npm13xx_api) = {
.pin_configure = gpio_npm13xx_configure,
.port_get_raw = gpio_npm13xx_port_get_raw,
.port_set_masked_raw = gpio_npm13xx_port_set_masked_raw,
.port_set_bits_raw = gpio_npm13xx_port_set_bits_raw,
.port_clear_bits_raw = gpio_npm13xx_port_clear_bits_raw,
.port_toggle_bits = gpio_npm13xx_port_toggle_bits,
};
static int gpio_npm1300_init(const struct device *dev)
static int gpio_npm13xx_init(const struct device *dev)
{
const struct gpio_npm1300_config *config = dev->config;
const struct gpio_npm13xx_config *config = dev->config;
if (!device_is_ready(config->mfd)) {
return -ENODEV;
@ -212,18 +212,18 @@ static int gpio_npm1300_init(const struct device *dev) @@ -212,18 +212,18 @@ static int gpio_npm1300_init(const struct device *dev)
return 0;
}
#define GPIO_NPM1300_DEFINE(n) \
static const struct gpio_npm1300_config gpio_npm1300_config##n = { \
#define GPIO_NPM13XX_DEFINE(n) \
static const struct gpio_npm13xx_config gpio_npm13xx_config##n = { \
.common = \
{ \
.port_pin_mask = GPIO_PORT_PIN_MASK_FROM_DT_INST(n), \
}, \
.mfd = DEVICE_DT_GET(DT_INST_PARENT(n))}; \
\
static struct gpio_npm1300_data gpio_npm1300_data##n; \
static struct gpio_npm13xx_data gpio_npm13xx_data##n; \
\
DEVICE_DT_INST_DEFINE(n, gpio_npm1300_init, NULL, &gpio_npm1300_data##n, \
&gpio_npm1300_config##n, POST_KERNEL, \
CONFIG_GPIO_NPM1300_INIT_PRIORITY, &gpio_npm1300_api);
DEVICE_DT_INST_DEFINE(n, gpio_npm13xx_init, NULL, &gpio_npm13xx_data##n, \
&gpio_npm13xx_config##n, POST_KERNEL, \
CONFIG_GPIO_NPM13XX_INIT_PRIORITY, &gpio_npm13xx_api);
DT_INST_FOREACH_STATUS_OKAY(GPIO_NPM1300_DEFINE)
DT_INST_FOREACH_STATUS_OKAY(GPIO_NPM13XX_DEFINE)

2
drivers/led/CMakeLists.txt
Unescape View File

@ -12,7 +12,7 @@ zephyr_library_sources_ifdef(CONFIG_IS31FL3733 is31fl3733.c) @@ -12,7 +12,7 @@ zephyr_library_sources_ifdef(CONFIG_IS31FL3733 is31fl3733.c)
zephyr_library_sources_ifdef(CONFIG_LED_AXP192_AXP2101 led_axp192.c)
zephyr_library_sources_ifdef(CONFIG_LED_DAC led_dac.c)
zephyr_library_sources_ifdef(CONFIG_LED_GPIO led_gpio.c)
zephyr_library_sources_ifdef(CONFIG_LED_NPM1300 led_npm13xx.c)
zephyr_library_sources_ifdef(CONFIG_LED_NPM13XX led_npm13xx.c)
zephyr_library_sources_ifdef(CONFIG_LED_PWM led_pwm.c)
zephyr_library_sources_ifdef(CONFIG_LED_XEC led_mchp_xec.c)
zephyr_library_sources_ifdef(CONFIG_LP3943 lp3943.c)

6
drivers/led/Kconfig.npm13xx
Unescape View File

@ -1,11 +1,11 @@ @@ -1,11 +1,11 @@
# Copyright (c) 2023 Nordic Semiconductor ASA
# SPDX-License-Identifier: Apache-2.0
config LED_NPM1300
bool "nPM1300 LED driver"
config LED_NPM13XX
bool "nPM13xx LED driver"
default y
depends on DT_HAS_NORDIC_NPM1300_LED_ENABLED
select I2C
select MFD
help
Enable the nPM1300 LED driver.
Enable the nPM13xx LED driver.

54
drivers/led/led_npm13xx.c
Unescape View File

@ -11,30 +11,30 @@ @@ -11,30 +11,30 @@
#include <zephyr/drivers/led.h>
#include <zephyr/drivers/mfd/npm13xx.h>
/* nPM1300 LED base address */
/* nPM13xx LED base address */
#define NPM_LED_BASE 0x0AU
/* nPM1300 LED register offsets */
/* nPM13xx LED register offsets */
#define NPM_LED_OFFSET_MODE 0x00U
#define NPM_LED_OFFSET_SET 0x03U
#define NPM_LED_OFFSET_CLR 0x04U
/* nPM1300 Channel counts */
#define NPM1300_LED_PINS 3U
/* nPM13xx Channel counts */
#define NPM13XX_LED_PINS 3U
/* nPM1300 LED modes */
/* nPM13xx LED modes */
#define NPM_LED_HOST 2U
struct led_npm1300_config {
struct led_npm13xx_config {
const struct device *mfd;
uint8_t mode[NPM1300_LED_PINS];
uint8_t mode[NPM13XX_LED_PINS];
};
static int led_npm1300_on(const struct device *dev, uint32_t led)
static int led_npm13xx_on(const struct device *dev, uint32_t led)
{
const struct led_npm1300_config *config = dev->config;
const struct led_npm13xx_config *config = dev->config;
if (led >= NPM1300_LED_PINS) {
if (led >= NPM13XX_LED_PINS) {
return -EINVAL;
}
@ -42,15 +42,15 @@ static int led_npm1300_on(const struct device *dev, uint32_t led) @@ -42,15 +42,15 @@ static int led_npm1300_on(const struct device *dev, uint32_t led)
return -EPERM;
}
return mfd_npm1300_reg_write(config->mfd, NPM_LED_BASE, NPM_LED_OFFSET_SET + (led * 2U),
return mfd_npm13xx_reg_write(config->mfd, NPM_LED_BASE, NPM_LED_OFFSET_SET + (led * 2U),
1U);
}
static int led_npm1300_off(const struct device *dev, uint32_t led)
static int led_npm13xx_off(const struct device *dev, uint32_t led)
{
const struct led_npm1300_config *config = dev->config;
const struct led_npm13xx_config *config = dev->config;
if (led >= NPM1300_LED_PINS) {
if (led >= NPM13XX_LED_PINS) {
return -EINVAL;
}
@ -58,25 +58,25 @@ static int led_npm1300_off(const struct device *dev, uint32_t led) @@ -58,25 +58,25 @@ static int led_npm1300_off(const struct device *dev, uint32_t led)
return -EPERM;
}
return mfd_npm1300_reg_write(config->mfd, NPM_LED_BASE, NPM_LED_OFFSET_CLR + (led * 2U),
return mfd_npm13xx_reg_write(config->mfd, NPM_LED_BASE, NPM_LED_OFFSET_CLR + (led * 2U),
1U);
}
static DEVICE_API(led, led_npm1300_api) = {
.on = led_npm1300_on,
.off = led_npm1300_off,
static DEVICE_API(led, led_npm13xx_api) = {
.on = led_npm13xx_on,
.off = led_npm13xx_off,
};
static int led_npm1300_init(const struct device *dev)
static int led_npm13xx_init(const struct device *dev)
{
const struct led_npm1300_config *config = dev->config;
const struct led_npm13xx_config *config = dev->config;
if (!device_is_ready(config->mfd)) {
return -ENODEV;
}
for (uint8_t led = 0U; led < NPM1300_LED_PINS; led++) {
int ret = mfd_npm1300_reg_write(config->mfd, NPM_LED_BASE,
for (uint8_t led = 0U; led < NPM13XX_LED_PINS; led++) {
int ret = mfd_npm13xx_reg_write(config->mfd, NPM_LED_BASE,
NPM_LED_OFFSET_MODE + led, config->mode[led]);
if (ret < 0) {
@ -87,14 +87,14 @@ static int led_npm1300_init(const struct device *dev) @@ -87,14 +87,14 @@ static int led_npm1300_init(const struct device *dev)
return 0;
}
#define LED_NPM1300_DEFINE(n) \
static const struct led_npm1300_config led_npm1300_config##n = { \
#define LED_NPM13XX_DEFINE(n) \
static const struct led_npm13xx_config led_npm13xx_config##n = { \
.mfd = DEVICE_DT_GET(DT_INST_PARENT(n)), \
.mode = {DT_INST_ENUM_IDX(n, nordic_led0_mode), \
DT_INST_ENUM_IDX(n, nordic_led1_mode), \
DT_INST_ENUM_IDX(n, nordic_led2_mode)}}; \
\
DEVICE_DT_INST_DEFINE(n, &led_npm1300_init, NULL, NULL, &led_npm1300_config##n, \
POST_KERNEL, CONFIG_LED_INIT_PRIORITY, &led_npm1300_api);
DEVICE_DT_INST_DEFINE(n, &led_npm13xx_init, NULL, NULL, &led_npm13xx_config##n, \
POST_KERNEL, CONFIG_LED_INIT_PRIORITY, &led_npm13xx_api);
DT_INST_FOREACH_STATUS_OKAY(LED_NPM1300_DEFINE)
DT_INST_FOREACH_STATUS_OKAY(LED_NPM13XX_DEFINE)

2
drivers/mfd/CMakeLists.txt
Unescape View File

@ -6,7 +6,7 @@ zephyr_library() @@ -6,7 +6,7 @@ zephyr_library()
zephyr_library_sources_ifdef(CONFIG_MFD_ADP5585 mfd_adp5585.c)
zephyr_library_sources_ifdef(CONFIG_MFD_MAX20335 mfd_max20335.c)
zephyr_library_sources_ifdef(CONFIG_MFD_NCT38XX mfd_nct38xx.c)
zephyr_library_sources_ifdef(CONFIG_MFD_NPM1300 mfd_npm13xx.c)
zephyr_library_sources_ifdef(CONFIG_MFD_NPM13XX mfd_npm13xx.c)
zephyr_library_sources_ifdef(CONFIG_MFD_NPM2100 mfd_npm2100.c)
zephyr_library_sources_ifdef(CONFIG_MFD_NPM6001 mfd_npm6001.c)
zephyr_library_sources_ifdef(CONFIG_MFD_AXP192_AXP2101 mfd_axp192.c)

14
drivers/mfd/Kconfig.npm13xx
Unescape View File

@ -1,17 +1,17 @@ @@ -1,17 +1,17 @@
# Copyright (c) 2023 Nordic Semiconductor ASA
# SPDX-License-Identifier: Apache-2.0
config MFD_NPM1300
bool "nPM1300 PMIC multi-function device driver"
config MFD_NPM13XX
bool "nPM13xx PMIC multi-function device driver"
default y
depends on DT_HAS_NORDIC_NPM1300_ENABLED
select I2C
help
Enable the Nordic nPM1300 PMIC multi-function device driver
Enable the Nordic nPM13xx PMIC multi-function device driver
config MFD_NPM1300_INIT_PRIORITY
int "nPM1300 MFD initialization priority"
config MFD_NPM13XX_INIT_PRIORITY
int "nPM13xx MFD initialization priority"
default MFD_INIT_PRIORITY
depends on MFD_NPM1300
depends on MFD_NPM13XX
help
Multi-function device initialization priority for nPM1300.
Multi-function device initialization priority for nPM13xx.

126
drivers/mfd/mfd_npm13xx.c
Unescape View File

@ -42,7 +42,7 @@ @@ -42,7 +42,7 @@
#define GPIO_MODE_GPOIRQ 5
struct mfd_npm1300_config {
struct mfd_npm13xx_config {
struct i2c_dt_spec i2c;
struct gpio_dt_spec host_int_gpios;
uint8_t pmic_int_pin;
@ -50,7 +50,7 @@ struct mfd_npm1300_config { @@ -50,7 +50,7 @@ struct mfd_npm1300_config {
uint8_t lp_reset;
};
struct mfd_npm1300_data {
struct mfd_npm13xx_data {
struct k_mutex mutex;
const struct device *dev;
struct gpio_callback gpio_cb;
@ -63,51 +63,51 @@ struct event_reg_t { @@ -63,51 +63,51 @@ struct event_reg_t {
uint8_t mask;
};
static const struct event_reg_t event_reg[NPM1300_EVENT_MAX] = {
[NPM1300_EVENT_CHG_COMPLETED] = {0x0AU, 0x10U},
[NPM1300_EVENT_CHG_ERROR] = {0x0AU, 0x20U},
[NPM1300_EVENT_BATTERY_DETECTED] = {0x0EU, 0x01U},
[NPM1300_EVENT_BATTERY_REMOVED] = {0x0EU, 0x02U},
[NPM1300_EVENT_SHIPHOLD_PRESS] = {0x12U, 0x01U},
[NPM1300_EVENT_SHIPHOLD_RELEASE] = {0x12U, 0x02U},
[NPM1300_EVENT_WATCHDOG_WARN] = {0x12U, 0x08U},
[NPM1300_EVENT_VBUS_DETECTED] = {0x16U, 0x01U},
[NPM1300_EVENT_VBUS_REMOVED] = {0x16U, 0x02U},
[NPM1300_EVENT_GPIO0_EDGE] = {0x22U, 0x01U},
[NPM1300_EVENT_GPIO1_EDGE] = {0x22U, 0x02U},
[NPM1300_EVENT_GPIO2_EDGE] = {0x22U, 0x04U},
[NPM1300_EVENT_GPIO3_EDGE] = {0x22U, 0x08U},
[NPM1300_EVENT_GPIO4_EDGE] = {0x22U, 0x10U},
static const struct event_reg_t event_reg[NPM13XX_EVENT_MAX] = {
[NPM13XX_EVENT_CHG_COMPLETED] = {0x0AU, 0x10U},
[NPM13XX_EVENT_CHG_ERROR] = {0x0AU, 0x20U},
[NPM13XX_EVENT_BATTERY_DETECTED] = {0x0EU, 0x01U},
[NPM13XX_EVENT_BATTERY_REMOVED] = {0x0EU, 0x02U},
[NPM13XX_EVENT_SHIPHOLD_PRESS] = {0x12U, 0x01U},
[NPM13XX_EVENT_SHIPHOLD_RELEASE] = {0x12U, 0x02U},
[NPM13XX_EVENT_WATCHDOG_WARN] = {0x12U, 0x08U},
[NPM13XX_EVENT_VBUS_DETECTED] = {0x16U, 0x01U},
[NPM13XX_EVENT_VBUS_REMOVED] = {0x16U, 0x02U},
[NPM13XX_EVENT_GPIO0_EDGE] = {0x22U, 0x01U},
[NPM13XX_EVENT_GPIO1_EDGE] = {0x22U, 0x02U},
[NPM13XX_EVENT_GPIO2_EDGE] = {0x22U, 0x04U},
[NPM13XX_EVENT_GPIO3_EDGE] = {0x22U, 0x08U},
[NPM13XX_EVENT_GPIO4_EDGE] = {0x22U, 0x10U},
};
static void gpio_callback(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
{
struct mfd_npm1300_data *data = CONTAINER_OF(cb, struct mfd_npm1300_data, gpio_cb);
struct mfd_npm13xx_data *data = CONTAINER_OF(cb, struct mfd_npm13xx_data, gpio_cb);
k_work_submit(&data->work);
}
static void work_callback(struct k_work *work)
{
struct mfd_npm1300_data *data = CONTAINER_OF(work, struct mfd_npm1300_data, work);
const struct mfd_npm1300_config *config = data->dev->config;
struct mfd_npm13xx_data *data = CONTAINER_OF(work, struct mfd_npm13xx_data, work);
const struct mfd_npm13xx_config *config = data->dev->config;
uint8_t buf[MAIN_SIZE];
int ret;
/* Read all MAIN registers into temporary buffer */
ret = mfd_npm1300_reg_read_burst(data->dev, MAIN_BASE, 0U, buf, sizeof(buf));
ret = mfd_npm13xx_reg_read_burst(data->dev, MAIN_BASE, 0U, buf, sizeof(buf));
if (ret < 0) {
k_work_submit(&data->work);
return;
}
for (int i = 0; i < NPM1300_EVENT_MAX; i++) {
for (int i = 0; i < NPM13XX_EVENT_MAX; i++) {
int offset = event_reg[i].offset + MAIN_OFFSET_CLR;
if ((buf[offset] & event_reg[i].mask) != 0U) {
gpio_fire_callbacks(&data->callbacks, data->dev, BIT(i));
ret = mfd_npm1300_reg_write(data->dev, MAIN_BASE, offset,
ret = mfd_npm13xx_reg_write(data->dev, MAIN_BASE, offset,
event_reg[i].mask);
if (ret < 0) {
k_work_submit(&data->work);
@ -122,10 +122,10 @@ static void work_callback(struct k_work *work) @@ -122,10 +122,10 @@ static void work_callback(struct k_work *work)
}
}
static int mfd_npm1300_init(const struct device *dev)
static int mfd_npm13xx_init(const struct device *dev)
{
const struct mfd_npm1300_config *config = dev->config;
struct mfd_npm1300_data *mfd_data = dev->data;
const struct mfd_npm13xx_config *config = dev->config;
struct mfd_npm13xx_data *mfd_data = dev->data;
int ret;
if (!i2c_is_ready_dt(&config->i2c)) {
@ -138,7 +138,7 @@ static int mfd_npm1300_init(const struct device *dev) @@ -138,7 +138,7 @@ static int mfd_npm1300_init(const struct device *dev)
if (config->host_int_gpios.port != NULL) {
/* Set specified PMIC pin to be interrupt output */
ret = mfd_npm1300_reg_write(dev, GPIO_BASE, GPIO_OFFSET_MODE + config->pmic_int_pin,
ret = mfd_npm13xx_reg_write(dev, GPIO_BASE, GPIO_OFFSET_MODE + config->pmic_int_pin,
GPIO_MODE_GPOIRQ);
if (ret < 0) {
return ret;
@ -171,64 +171,64 @@ static int mfd_npm1300_init(const struct device *dev) @@ -171,64 +171,64 @@ static int mfd_npm1300_init(const struct device *dev)
}
}
ret = mfd_npm1300_reg_write(dev, SHIP_BASE, SHIP_OFFSET_CONFIG, config->active_time);
ret = mfd_npm13xx_reg_write(dev, SHIP_BASE, SHIP_OFFSET_CONFIG, config->active_time);
if (ret < 0) {
return ret;
}
ret = mfd_npm1300_reg_write(dev, SHIP_BASE, SHIP_OFFSET_LPCONFIG, config->lp_reset);
ret = mfd_npm13xx_reg_write(dev, SHIP_BASE, SHIP_OFFSET_LPCONFIG, config->lp_reset);
if (ret < 0) {
return ret;
}
return mfd_npm1300_reg_write(dev, SHIP_BASE, SHIP_OFFSET_CFGSTROBE, 1U);
return mfd_npm13xx_reg_write(dev, SHIP_BASE, SHIP_OFFSET_CFGSTROBE, 1U);
}
int mfd_npm1300_reg_read_burst(const struct device *dev, uint8_t base, uint8_t offset, void *data,
int mfd_npm13xx_reg_read_burst(const struct device *dev, uint8_t base, uint8_t offset, void *data,
size_t len)
{
const struct mfd_npm1300_config *config = dev->config;
const struct mfd_npm13xx_config *config = dev->config;
uint8_t buff[] = {base, offset};
return i2c_write_read_dt(&config->i2c, buff, sizeof(buff), data, len);
}
int mfd_npm1300_reg_read(const struct device *dev, uint8_t base, uint8_t offset, uint8_t *data)
int mfd_npm13xx_reg_read(const struct device *dev, uint8_t base, uint8_t offset, uint8_t *data)
{
return mfd_npm1300_reg_read_burst(dev, base, offset, data, 1U);
return mfd_npm13xx_reg_read_burst(dev, base, offset, data, 1U);
}
int mfd_npm1300_reg_write(const struct device *dev, uint8_t base, uint8_t offset, uint8_t data)
int mfd_npm13xx_reg_write(const struct device *dev, uint8_t base, uint8_t offset, uint8_t data)
{
const struct mfd_npm1300_config *config = dev->config;
const struct mfd_npm13xx_config *config = dev->config;
uint8_t buff[] = {base, offset, data};
return i2c_write_dt(&config->i2c, buff, sizeof(buff));
}
int mfd_npm1300_reg_write2(const struct device *dev, uint8_t base, uint8_t offset, uint8_t data1,
int mfd_npm13xx_reg_write2(const struct device *dev, uint8_t base, uint8_t offset, uint8_t data1,
uint8_t data2)
{
const struct mfd_npm1300_config *config = dev->config;
const struct mfd_npm13xx_config *config = dev->config;
uint8_t buff[] = {base, offset, data1, data2};
return i2c_write_dt(&config->i2c, buff, sizeof(buff));
}
int mfd_npm1300_reg_update(const struct device *dev, uint8_t base, uint8_t offset, uint8_t data,
int mfd_npm13xx_reg_update(const struct device *dev, uint8_t base, uint8_t offset, uint8_t data,
uint8_t mask)
{
struct mfd_npm1300_data *mfd_data = dev->data;
struct mfd_npm13xx_data *mfd_data = dev->data;
uint8_t reg;
int ret;
k_mutex_lock(&mfd_data->mutex, K_FOREVER);
ret = mfd_npm1300_reg_read(dev, base, offset, &reg);
ret = mfd_npm13xx_reg_read(dev, base, offset, &reg);
if (ret == 0) {
reg = (reg & ~mask) | (data & mask);
ret = mfd_npm1300_reg_write(dev, base, offset, reg);
ret = mfd_npm13xx_reg_write(dev, base, offset, reg);
}
k_mutex_unlock(&mfd_data->mutex);
@ -236,9 +236,9 @@ int mfd_npm1300_reg_update(const struct device *dev, uint8_t base, uint8_t offse @@ -236,9 +236,9 @@ int mfd_npm1300_reg_update(const struct device *dev, uint8_t base, uint8_t offse
return ret;
}
int mfd_npm1300_set_timer(const struct device *dev, uint32_t time_ms)
int mfd_npm13xx_set_timer(const struct device *dev, uint32_t time_ms)
{
const struct mfd_npm1300_config *config = dev->config;
const struct mfd_npm13xx_config *config = dev->config;
uint8_t buff[5] = {TIME_BASE, TIME_OFFSET_TIMER};
uint32_t ticks = time_ms / TIMER_PRESCALER_MS;
@ -254,34 +254,34 @@ int mfd_npm1300_set_timer(const struct device *dev, uint32_t time_ms) @@ -254,34 +254,34 @@ int mfd_npm1300_set_timer(const struct device *dev, uint32_t time_ms)
return ret;
}
return mfd_npm1300_reg_write(dev, TIME_BASE, TIME_OFFSET_LOAD, 1U);
return mfd_npm13xx_reg_write(dev, TIME_BASE, TIME_OFFSET_LOAD, 1U);
}
int mfd_npm1300_reset(const struct device *dev)
int mfd_npm13xx_reset(const struct device *dev)
{
return mfd_npm1300_reg_write(dev, MAIN_BASE, MAIN_OFFSET_RESET, 1U);
return mfd_npm13xx_reg_write(dev, MAIN_BASE, MAIN_OFFSET_RESET, 1U);
}
int mfd_npm1300_hibernate(const struct device *dev, uint32_t time_ms)
int mfd_npm13xx_hibernate(const struct device *dev, uint32_t time_ms)
{
int ret = mfd_npm1300_set_timer(dev, time_ms);
int ret = mfd_npm13xx_set_timer(dev, time_ms);
if (ret != 0) {
return ret;
}
return mfd_npm1300_reg_write(dev, SHIP_BASE, SHIP_OFFSET_HIBERNATE, 1U);
return mfd_npm13xx_reg_write(dev, SHIP_BASE, SHIP_OFFSET_HIBERNATE, 1U);
}
int mfd_npm1300_add_callback(const struct device *dev, struct gpio_callback *callback)
int mfd_npm13xx_add_callback(const struct device *dev, struct gpio_callback *callback)
{
struct mfd_npm1300_data *data = dev->data;
struct mfd_npm13xx_data *data = dev->data;
/* Enable interrupts for specified events */
for (int i = 0; i < NPM1300_EVENT_MAX; i++) {
for (int i = 0; i < NPM13XX_EVENT_MAX; i++) {
if ((callback->pin_mask & BIT(i)) != 0U) {
/* Clear pending interrupt */
int ret = mfd_npm1300_reg_write(data->dev, MAIN_BASE,
int ret = mfd_npm13xx_reg_write(data->dev, MAIN_BASE,
event_reg[i].offset + MAIN_OFFSET_CLR,
event_reg[i].mask);
@ -289,7 +289,7 @@ int mfd_npm1300_add_callback(const struct device *dev, struct gpio_callback *cal @@ -289,7 +289,7 @@ int mfd_npm1300_add_callback(const struct device *dev, struct gpio_callback *cal
return ret;
}
ret = mfd_npm1300_reg_write(data->dev, MAIN_BASE,
ret = mfd_npm13xx_reg_write(data->dev, MAIN_BASE,
event_reg[i].offset + MAIN_OFFSET_INTENSET,
event_reg[i].mask);
if (ret < 0) {
@ -301,17 +301,17 @@ int mfd_npm1300_add_callback(const struct device *dev, struct gpio_callback *cal @@ -301,17 +301,17 @@ int mfd_npm1300_add_callback(const struct device *dev, struct gpio_callback *cal
return gpio_manage_callback(&data->callbacks, callback, true);
}
int mfd_npm1300_remove_callback(const struct device *dev, struct gpio_callback *callback)
int mfd_npm13xx_remove_callback(const struct device *dev, struct gpio_callback *callback)
{
struct mfd_npm1300_data *data = dev->data;
struct mfd_npm13xx_data *data = dev->data;
return gpio_manage_callback(&data->callbacks, callback, false);
}
#define MFD_NPM1300_DEFINE(inst) \
static struct mfd_npm1300_data data_##inst; \
#define MFD_NPM13XX_DEFINE(inst) \
static struct mfd_npm13xx_data data_##inst; \
\
static const struct mfd_npm1300_config config##inst = { \
static const struct mfd_npm13xx_config config##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
.host_int_gpios = GPIO_DT_SPEC_INST_GET_OR(inst, host_int_gpios, {0}), \
.pmic_int_pin = DT_INST_PROP_OR(inst, pmic_int_pin, 0), \
@ -319,7 +319,7 @@ int mfd_npm1300_remove_callback(const struct device *dev, struct gpio_callback * @@ -319,7 +319,7 @@ int mfd_npm1300_remove_callback(const struct device *dev, struct gpio_callback *
.lp_reset = DT_INST_ENUM_IDX_OR(inst, long_press_reset, 0), \
}; \
\
DEVICE_DT_INST_DEFINE(inst, mfd_npm1300_init, NULL, &data_##inst, &config##inst, \
POST_KERNEL, CONFIG_MFD_NPM1300_INIT_PRIORITY, NULL);
DEVICE_DT_INST_DEFINE(inst, mfd_npm13xx_init, NULL, &data_##inst, &config##inst, \
POST_KERNEL, CONFIG_MFD_NPM13XX_INIT_PRIORITY, NULL);
DT_INST_FOREACH_STATUS_OKAY(MFD_NPM1300_DEFINE)
DT_INST_FOREACH_STATUS_OKAY(MFD_NPM13XX_DEFINE)

2
drivers/regulator/CMakeLists.txt
Unescape View File

@ -13,7 +13,7 @@ zephyr_library_sources_ifdef(CONFIG_REGULATOR_FIXED regulator_fixed.c) @@ -13,7 +13,7 @@ zephyr_library_sources_ifdef(CONFIG_REGULATOR_FIXED regulator_fixed.c)
zephyr_library_sources_ifdef(CONFIG_REGULATOR_GPIO regulator_gpio.c)
zephyr_library_sources_ifdef(CONFIG_REGULATOR_MAX20335 regulator_max20335.c)
zephyr_library_sources_ifdef(CONFIG_REGULATOR_NPM1100 regulator_npm1100.c)
zephyr_library_sources_ifdef(CONFIG_REGULATOR_NPM1300 regulator_npm13xx.c)
zephyr_library_sources_ifdef(CONFIG_REGULATOR_NPM13XX regulator_npm13xx.c)
zephyr_library_sources_ifdef(CONFIG_REGULATOR_NPM2100 regulator_npm2100.c)
zephyr_library_sources_ifdef(CONFIG_REGULATOR_NPM6001 regulator_npm6001.c)
zephyr_library_sources_ifdef(CONFIG_REGULATOR_PCA9420 regulator_pca9420.c)

22
drivers/regulator/Kconfig.npm13xx
Unescape View File

@ -1,29 +1,29 @@ @@ -1,29 +1,29 @@
# Copyright (c) 2023 Nordic Semiconductor ASA
# SPDX-License-Identifier: Apache-2.0
config REGULATOR_NPM1300
bool "nPM1300 PMIC regulator driver"
config REGULATOR_NPM13XX
bool "nPM13xx PMIC regulator driver"
default y
depends on DT_HAS_NORDIC_NPM1300_REGULATOR_ENABLED
select I2C
select MFD
help
Enable the Nordic nPM1300 PMIC regulator driver
Enable the Nordic nPM13xx PMIC regulator driver
if REGULATOR_NPM1300
if REGULATOR_NPM13XX
config REGULATOR_NPM1300_COMMON_INIT_PRIORITY
int "nPM1300 regulator driver init priority (common part)"
config REGULATOR_NPM13XX_COMMON_INIT_PRIORITY
int "nPM13xx regulator driver init priority (common part)"
default 85
help
Init priority for the Nordic nPM1300 regulator driver (common part).
Init priority for the Nordic nPM13xx regulator driver (common part).
It must be greater than I2C init priority.
config REGULATOR_NPM1300_INIT_PRIORITY
int "nPM1300 regulator driver init priority"
config REGULATOR_NPM13XX_INIT_PRIORITY
int "nPM13xx regulator driver init priority"
default 86
help
Init priority for the Nordic nPM1300 regulator driver. It must be
greater than REGULATOR_NPM1300_COMMON_INIT_PRIORITY.
Init priority for the Nordic nPM13xx regulator driver. It must be
greater than REGULATOR_NPM13XX_COMMON_INIT_PRIORITY.
endif

376
drivers/regulator/regulator_npm13xx.c
Unescape View File

@ -15,27 +15,27 @@ @@ -15,27 +15,27 @@
#include <zephyr/sys/linear_range.h>
#include <zephyr/sys/util.h>
/* nPM1300 voltage sources */
enum npm1300_sources {
NPM1300_SOURCE_BUCK1,
NPM1300_SOURCE_BUCK2,
NPM1300_SOURCE_LDO1,
NPM1300_SOURCE_LDO2,
/* nPM13xx voltage sources */
enum npm13xx_sources {
NPM13XX_SOURCE_BUCK1,
NPM13XX_SOURCE_BUCK2,
NPM13XX_SOURCE_LDO1,
NPM13XX_SOURCE_LDO2,
};
/* nPM1300 gpio control channels */
enum npm1300_gpio_type {
NPM1300_GPIO_TYPE_ENABLE,
NPM1300_GPIO_TYPE_RETENTION,
NPM1300_GPIO_TYPE_PWM
/* nPM13xx gpio control channels */
enum npm13xx_gpio_type {
NPM13XX_GPIO_TYPE_ENABLE,
NPM13XX_GPIO_TYPE_RETENTION,
NPM13XX_GPIO_TYPE_PWM
};
/* nPM1300 regulator base addresses */
/* nPM13xx regulator base addresses */
#define BUCK_BASE 0x04U
#define LDSW_BASE 0x08U
#define SHIP_BASE 0x0BU
/* nPM1300 regulator register offsets */
/* nPM13xx regulator register offsets */
#define BUCK_OFFSET_EN_SET 0x00U
#define BUCK_OFFSET_EN_CLR 0x01U
#define BUCK_OFFSET_PWM_SET 0x04U
@ -50,7 +50,7 @@ enum npm1300_gpio_type { @@ -50,7 +50,7 @@ enum npm1300_gpio_type {
#define BUCK_OFFSET_CTRL0 0x15U
#define BUCK_OFFSET_STATUS 0x34U
/* nPM1300 ldsw register offsets */
/* nPM13xx ldsw register offsets */
#define LDSW_OFFSET_EN_SET 0x00U
#define LDSW_OFFSET_EN_CLR 0x01U
#define LDSW_OFFSET_STATUS 0x04U
@ -59,7 +59,7 @@ enum npm1300_gpio_type { @@ -59,7 +59,7 @@ enum npm1300_gpio_type {
#define LDSW_OFFSET_LDOSEL 0x08U
#define LDSW_OFFSET_VOUTSEL 0x0CU
/* nPM1300 ship register offsets */
/* nPM13xx ship register offsets */
#define SHIP_OFFSET_SHIP 0x02U
#define BUCK1_ON_MASK 0x04U
@ -77,62 +77,62 @@ enum npm1300_gpio_type { @@ -77,62 +77,62 @@ enum npm1300_gpio_type {
#define LDSW2_SOFTSTART_SHIFT 4U
#define LDSW2_ACTIVE_DISCHARGE_MASK BIT(7)
#define NPM1300_GPIO_UNUSED UINT8_MAX
#define NPM13XX_GPIO_UNUSED UINT8_MAX
struct npm1300_gpio_info {
struct npm13xx_gpio_info {
uint8_t pin;
bool invert;
};
struct regulator_npm1300_pconfig {
struct regulator_npm13xx_pconfig {
const struct device *mfd;
struct gpio_dt_spec dvs_state_pins[5];
};
struct regulator_npm1300_config {
struct regulator_npm13xx_config {
struct regulator_common_config common;
const struct device *mfd;
uint8_t source;
int32_t retention_uv;
struct npm1300_gpio_info enable_gpios;
struct npm1300_gpio_info retention_gpios;
struct npm1300_gpio_info pwm_gpios;
struct npm13xx_gpio_info enable_gpios;
struct npm13xx_gpio_info retention_gpios;
struct npm13xx_gpio_info pwm_gpios;
uint8_t soft_start;
bool active_discharge;
bool ldo_disable_workaround;
};
struct regulator_npm1300_data {
struct regulator_npm13xx_data {
struct regulator_common_data data;
};
/* Linear range for output voltage, common for all bucks and LDOs on this device */
static const struct linear_range buckldo_range = LINEAR_RANGE_INIT(1000000, 100000, 0U, 23U);
unsigned int regulator_npm1300_count_voltages(const struct device *dev)
unsigned int regulator_npm13xx_count_voltages(const struct device *dev)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
switch (config->source) {
case NPM1300_SOURCE_BUCK1:
case NPM1300_SOURCE_BUCK2:
case NPM1300_SOURCE_LDO1:
case NPM1300_SOURCE_LDO2:
case NPM13XX_SOURCE_BUCK1:
case NPM13XX_SOURCE_BUCK2:
case NPM13XX_SOURCE_LDO1:
case NPM13XX_SOURCE_LDO2:
return linear_range_values_count(&buckldo_range);
default:
return 0;
}
}
int regulator_npm1300_list_voltage(const struct device *dev, unsigned int idx, int32_t *volt_uv)
int regulator_npm13xx_list_voltage(const struct device *dev, unsigned int idx, int32_t *volt_uv)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
switch (config->source) {
case NPM1300_SOURCE_BUCK1:
case NPM1300_SOURCE_BUCK2:
case NPM1300_SOURCE_LDO1:
case NPM1300_SOURCE_LDO2:
case NPM13XX_SOURCE_BUCK1:
case NPM13XX_SOURCE_BUCK2:
case NPM13XX_SOURCE_LDO1:
case NPM13XX_SOURCE_LDO2:
return linear_range_get_value(&buckldo_range, idx, volt_uv);
default:
return -EINVAL;
@ -141,16 +141,16 @@ int regulator_npm1300_list_voltage(const struct device *dev, unsigned int idx, i @@ -141,16 +141,16 @@ int regulator_npm1300_list_voltage(const struct device *dev, unsigned int idx, i
static int retention_set_voltage(const struct device *dev, int32_t retention_uv)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
uint16_t idx;
uint8_t chan;
int ret;
switch (config->source) {
case NPM1300_SOURCE_BUCK1:
case NPM13XX_SOURCE_BUCK1:
chan = 0U;
break;
case NPM1300_SOURCE_BUCK2:
case NPM13XX_SOURCE_BUCK2:
chan = 1U;
break;
default:
@ -163,17 +163,17 @@ static int retention_set_voltage(const struct device *dev, int32_t retention_uv) @@ -163,17 +163,17 @@ static int retention_set_voltage(const struct device *dev, int32_t retention_uv)
return ret;
}
return mfd_npm1300_reg_write(config->mfd, BUCK_BASE, BUCK_OFFSET_VOUT_RET + (chan * 2U),
return mfd_npm13xx_reg_write(config->mfd, BUCK_BASE, BUCK_OFFSET_VOUT_RET + (chan * 2U),
idx);
}
static int buck_get_voltage_index(const struct device *dev, uint8_t chan, uint8_t *idx)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
uint8_t sel;
int ret;
ret = mfd_npm1300_reg_read(config->mfd, BUCK_BASE, BUCK_OFFSET_SW_CTRL, &sel);
ret = mfd_npm13xx_reg_read(config->mfd, BUCK_BASE, BUCK_OFFSET_SW_CTRL, &sel);
if (ret < 0) {
return ret;
@ -181,17 +181,17 @@ static int buck_get_voltage_index(const struct device *dev, uint8_t chan, uint8_ @@ -181,17 +181,17 @@ static int buck_get_voltage_index(const struct device *dev, uint8_t chan, uint8_
if ((sel >> chan) & 1U) {
/* SW control */
return mfd_npm1300_reg_read(config->mfd, BUCK_BASE,
return mfd_npm13xx_reg_read(config->mfd, BUCK_BASE,
BUCK_OFFSET_VOUT_NORM + (chan * 2U), idx);
}
/* VSET pin control */
return mfd_npm1300_reg_read(config->mfd, BUCK_BASE, BUCK_OFFSET_VOUT_STAT + chan, idx);
return mfd_npm13xx_reg_read(config->mfd, BUCK_BASE, BUCK_OFFSET_VOUT_STAT + chan, idx);
}
static int buck_set_voltage(const struct device *dev, uint8_t chan, int32_t min_uv, int32_t max_uv)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
uint8_t mask;
uint8_t curr_idx;
uint16_t idx;
@ -210,7 +210,7 @@ static int buck_set_voltage(const struct device *dev, uint8_t chan, int32_t min_ @@ -210,7 +210,7 @@ static int buck_set_voltage(const struct device *dev, uint8_t chan, int32_t min_
return ret;
}
ret = mfd_npm1300_reg_write(config->mfd, BUCK_BASE, BUCK_OFFSET_VOUT_NORM + (chan * 2U),
ret = mfd_npm13xx_reg_write(config->mfd, BUCK_BASE, BUCK_OFFSET_VOUT_NORM + (chan * 2U),
idx);
if (ret < 0) {
@ -219,12 +219,12 @@ static int buck_set_voltage(const struct device *dev, uint8_t chan, int32_t min_ @@ -219,12 +219,12 @@ static int buck_set_voltage(const struct device *dev, uint8_t chan, int32_t min_
/* Enable SW control of buck output */
mask = BIT(chan);
return mfd_npm1300_reg_update(config->mfd, BUCK_BASE, BUCK_OFFSET_SW_CTRL, mask, mask);
return mfd_npm13xx_reg_update(config->mfd, BUCK_BASE, BUCK_OFFSET_SW_CTRL, mask, mask);
}
static int ldo_set_voltage(const struct device *dev, uint8_t chan, int32_t min_uv, int32_t max_uv)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
uint16_t idx;
int ret;
@ -234,21 +234,21 @@ static int ldo_set_voltage(const struct device *dev, uint8_t chan, int32_t min_u @@ -234,21 +234,21 @@ static int ldo_set_voltage(const struct device *dev, uint8_t chan, int32_t min_u
return ret;
}
return mfd_npm1300_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_VOUTSEL + chan, idx);
return mfd_npm13xx_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_VOUTSEL + chan, idx);
}
int regulator_npm1300_set_voltage(const struct device *dev, int32_t min_uv, int32_t max_uv)
int regulator_npm13xx_set_voltage(const struct device *dev, int32_t min_uv, int32_t max_uv)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
switch (config->source) {
case NPM1300_SOURCE_BUCK1:
case NPM13XX_SOURCE_BUCK1:
return buck_set_voltage(dev, 0, min_uv, max_uv);
case NPM1300_SOURCE_BUCK2:
case NPM13XX_SOURCE_BUCK2:
return buck_set_voltage(dev, 1, min_uv, max_uv);
case NPM1300_SOURCE_LDO1:
case NPM13XX_SOURCE_LDO1:
return ldo_set_voltage(dev, 0, min_uv, max_uv);
case NPM1300_SOURCE_LDO2:
case NPM13XX_SOURCE_LDO2:
return ldo_set_voltage(dev, 1, min_uv, max_uv);
default:
return -ENODEV;
@ -271,11 +271,11 @@ static int buck_get_voltage(const struct device *dev, uint8_t chan, int32_t *vol @@ -271,11 +271,11 @@ static int buck_get_voltage(const struct device *dev, uint8_t chan, int32_t *vol
static int ldo_get_voltage(const struct device *dev, uint8_t chan, int32_t *volt_uv)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
uint8_t idx;
int ret;
ret = mfd_npm1300_reg_read(config->mfd, LDSW_BASE, LDSW_OFFSET_VOUTSEL + chan, &idx);
ret = mfd_npm13xx_reg_read(config->mfd, LDSW_BASE, LDSW_OFFSET_VOUTSEL + chan, &idx);
if (ret < 0) {
return ret;
@ -284,18 +284,18 @@ static int ldo_get_voltage(const struct device *dev, uint8_t chan, int32_t *volt @@ -284,18 +284,18 @@ static int ldo_get_voltage(const struct device *dev, uint8_t chan, int32_t *volt
return linear_range_get_value(&buckldo_range, idx, volt_uv);
}
int regulator_npm1300_get_voltage(const struct device *dev, int32_t *volt_uv)
int regulator_npm13xx_get_voltage(const struct device *dev, int32_t *volt_uv)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
switch (config->source) {
case NPM1300_SOURCE_BUCK1:
case NPM13XX_SOURCE_BUCK1:
return buck_get_voltage(dev, 0, volt_uv);
case NPM1300_SOURCE_BUCK2:
case NPM13XX_SOURCE_BUCK2:
return buck_get_voltage(dev, 1, volt_uv);
case NPM1300_SOURCE_LDO1:
case NPM13XX_SOURCE_LDO1:
return ldo_get_voltage(dev, 0, volt_uv);
case NPM1300_SOURCE_LDO2:
case NPM13XX_SOURCE_LDO2:
return ldo_get_voltage(dev, 1, volt_uv);
default:
return -ENODEV;
@ -304,22 +304,22 @@ int regulator_npm1300_get_voltage(const struct device *dev, int32_t *volt_uv) @@ -304,22 +304,22 @@ int regulator_npm1300_get_voltage(const struct device *dev, int32_t *volt_uv)
static int set_buck_mode(const struct device *dev, uint8_t chan, regulator_mode_t mode)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
uint8_t pfm_mask = BIT(chan);
uint8_t pfm_data;
uint8_t pwm_reg;
int ret;
switch (mode) {
case NPM1300_BUCK_MODE_PWM:
case NPM13XX_BUCK_MODE_PWM:
pfm_data = 0U;
pwm_reg = BUCK_OFFSET_PWM_SET;
break;
case NPM1300_BUCK_MODE_AUTO:
case NPM13XX_BUCK_MODE_AUTO:
pfm_data = 0U;
pwm_reg = BUCK_OFFSET_PWM_CLR;
break;
case NPM1300_BUCK_MODE_PFM:
case NPM13XX_BUCK_MODE_PFM:
pfm_data = pfm_mask;
pwm_reg = BUCK_OFFSET_PWM_CLR;
break;
@ -327,61 +327,61 @@ static int set_buck_mode(const struct device *dev, uint8_t chan, regulator_mode_ @@ -327,61 +327,61 @@ static int set_buck_mode(const struct device *dev, uint8_t chan, regulator_mode_
return -ENOTSUP;
}
ret = mfd_npm1300_reg_update(config->mfd, BUCK_BASE, BUCK_OFFSET_CTRL0, pfm_data, pfm_mask);
ret = mfd_npm13xx_reg_update(config->mfd, BUCK_BASE, BUCK_OFFSET_CTRL0, pfm_data, pfm_mask);
if (ret < 0) {
return ret;
}
return mfd_npm1300_reg_write(config->mfd, BUCK_BASE, pwm_reg + (chan * 2U), 1U);
return mfd_npm13xx_reg_write(config->mfd, BUCK_BASE, pwm_reg + (chan * 2U), 1U);
}
static int set_ldsw_mode(const struct device *dev, uint8_t chan, regulator_mode_t mode)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
switch (mode) {
case NPM1300_LDSW_MODE_LDO:
return mfd_npm1300_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_LDOSEL + chan, 1U);
case NPM1300_LDSW_MODE_LDSW:
return mfd_npm1300_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_LDOSEL + chan, 0U);
case NPM13XX_LDSW_MODE_LDO:
return mfd_npm13xx_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_LDOSEL + chan, 1U);
case NPM13XX_LDSW_MODE_LDSW:
return mfd_npm13xx_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_LDOSEL + chan, 0U);
default:
return -ENOTSUP;
}
}
int regulator_npm1300_set_mode(const struct device *dev, regulator_mode_t mode)
int regulator_npm13xx_set_mode(const struct device *dev, regulator_mode_t mode)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
switch (config->source) {
case NPM1300_SOURCE_BUCK1:
case NPM13XX_SOURCE_BUCK1:
return set_buck_mode(dev, 0, mode);
case NPM1300_SOURCE_BUCK2:
case NPM13XX_SOURCE_BUCK2:
return set_buck_mode(dev, 1, mode);
case NPM1300_SOURCE_LDO1:
case NPM13XX_SOURCE_LDO1:
return set_ldsw_mode(dev, 0, mode);
case NPM1300_SOURCE_LDO2:
case NPM13XX_SOURCE_LDO2:
return set_ldsw_mode(dev, 1, mode);
default:
return -ENOTSUP;
}
}
int regulator_npm1300_enable(const struct device *dev)
int regulator_npm13xx_enable(const struct device *dev)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
int ret;
switch (config->source) {
case NPM1300_SOURCE_BUCK1:
return mfd_npm1300_reg_write(config->mfd, BUCK_BASE, BUCK_OFFSET_EN_SET, 1U);
case NPM1300_SOURCE_BUCK2:
return mfd_npm1300_reg_write(config->mfd, BUCK_BASE, BUCK_OFFSET_EN_SET + 2U, 1U);
case NPM1300_SOURCE_LDO1:
ret = mfd_npm1300_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_EN_SET, 1U);
case NPM13XX_SOURCE_BUCK1:
return mfd_npm13xx_reg_write(config->mfd, BUCK_BASE, BUCK_OFFSET_EN_SET, 1U);
case NPM13XX_SOURCE_BUCK2:
return mfd_npm13xx_reg_write(config->mfd, BUCK_BASE, BUCK_OFFSET_EN_SET + 2U, 1U);
case NPM13XX_SOURCE_LDO1:
ret = mfd_npm13xx_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_EN_SET, 1U);
break;
case NPM1300_SOURCE_LDO2:
ret = mfd_npm1300_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_EN_SET + 2U, 1U);
case NPM13XX_SOURCE_LDO2:
ret = mfd_npm13xx_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_EN_SET + 2U, 1U);
break;
default:
return 0;
@ -395,35 +395,35 @@ int regulator_npm1300_enable(const struct device *dev) @@ -395,35 +395,35 @@ int regulator_npm1300_enable(const struct device *dev)
uint8_t unused;
k_msleep(2);
return mfd_npm1300_reg_read(config->mfd, LDSW_BASE, LDSW_OFFSET_STATUS, &unused);
return mfd_npm13xx_reg_read(config->mfd, LDSW_BASE, LDSW_OFFSET_STATUS, &unused);
}
return ret;
}
int regulator_npm1300_disable(const struct device *dev)
int regulator_npm13xx_disable(const struct device *dev)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
switch (config->source) {
case NPM1300_SOURCE_BUCK1:
return mfd_npm1300_reg_write(config->mfd, BUCK_BASE, BUCK_OFFSET_EN_CLR, 1U);
case NPM1300_SOURCE_BUCK2:
return mfd_npm1300_reg_write(config->mfd, BUCK_BASE, BUCK_OFFSET_EN_CLR + 2U, 1U);
case NPM1300_SOURCE_LDO1:
return mfd_npm1300_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_EN_CLR, 1U);
case NPM1300_SOURCE_LDO2:
return mfd_npm1300_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_EN_CLR + 2U, 1U);
case NPM13XX_SOURCE_BUCK1:
return mfd_npm13xx_reg_write(config->mfd, BUCK_BASE, BUCK_OFFSET_EN_CLR, 1U);
case NPM13XX_SOURCE_BUCK2:
return mfd_npm13xx_reg_write(config->mfd, BUCK_BASE, BUCK_OFFSET_EN_CLR + 2U, 1U);
case NPM13XX_SOURCE_LDO1:
return mfd_npm13xx_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_EN_CLR, 1U);
case NPM13XX_SOURCE_LDO2:
return mfd_npm13xx_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_EN_CLR + 2U, 1U);
default:
return 0;
}
}
static int regulator_npm1300_set_buck_pin_ctrl(const struct device *dev, uint8_t chan,
const struct npm1300_gpio_info *pin_info,
enum npm1300_gpio_type type)
static int regulator_npm13xx_set_buck_pin_ctrl(const struct device *dev, uint8_t chan,
const struct npm13xx_gpio_info *pin_info,
enum npm13xx_gpio_type type)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
uint8_t inv = pin_info->invert ? 1 : 0;
uint8_t ctrl;
uint8_t mask;
@ -444,63 +444,63 @@ static int regulator_npm1300_set_buck_pin_ctrl(const struct device *dev, uint8_t @@ -444,63 +444,63 @@ static int regulator_npm1300_set_buck_pin_ctrl(const struct device *dev, uint8_t
}
switch (type) {
case NPM1300_GPIO_TYPE_ENABLE:
return mfd_npm1300_reg_update(config->mfd, BUCK_BASE, BUCK_OFFSET_EN_CTRL, ctrl,
case NPM13XX_GPIO_TYPE_ENABLE:
return mfd_npm13xx_reg_update(config->mfd, BUCK_BASE, BUCK_OFFSET_EN_CTRL, ctrl,
mask);
case NPM1300_GPIO_TYPE_PWM:
return mfd_npm1300_reg_update(config->mfd, BUCK_BASE, BUCK_OFFSET_PWM_CTRL, ctrl,
case NPM13XX_GPIO_TYPE_PWM:
return mfd_npm13xx_reg_update(config->mfd, BUCK_BASE, BUCK_OFFSET_PWM_CTRL, ctrl,
mask);
case NPM1300_GPIO_TYPE_RETENTION:
return mfd_npm1300_reg_update(config->mfd, BUCK_BASE, BUCK_OFFSET_VRET_CTRL, ctrl,
case NPM13XX_GPIO_TYPE_RETENTION:
return mfd_npm13xx_reg_update(config->mfd, BUCK_BASE, BUCK_OFFSET_VRET_CTRL, ctrl,
mask);
default:
return -ENOTSUP;
}
}
static int regulator_npm1300_set_ldsw_pin_ctrl(const struct device *dev, uint8_t chan,
const struct npm1300_gpio_info *pin_info,
enum npm1300_gpio_type type)
static int regulator_npm13xx_set_ldsw_pin_ctrl(const struct device *dev, uint8_t chan,
const struct npm13xx_gpio_info *pin_info,
enum npm13xx_gpio_type type)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
uint8_t inv = pin_info->invert ? 1 : 0;
uint8_t ctrl;
if (type != NPM1300_GPIO_TYPE_ENABLE) {
if (type != NPM13XX_GPIO_TYPE_ENABLE) {
return -ENOTSUP;
}
ctrl = (pin_info->pin + 1U) | (inv << 3U);
return mfd_npm1300_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_GPISEL + chan, ctrl);
return mfd_npm13xx_reg_write(config->mfd, LDSW_BASE, LDSW_OFFSET_GPISEL + chan, ctrl);
}
int regulator_npm1300_set_pin_ctrl(const struct device *dev, const struct npm1300_gpio_info *info,
enum npm1300_gpio_type type)
int regulator_npm13xx_set_pin_ctrl(const struct device *dev, const struct npm13xx_gpio_info *info,
enum npm13xx_gpio_type type)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
if (info->pin == NPM1300_GPIO_UNUSED) {
if (info->pin == NPM13XX_GPIO_UNUSED) {
return 0;
}
switch (config->source) {
case NPM1300_SOURCE_BUCK1:
return regulator_npm1300_set_buck_pin_ctrl(dev, 0, info, type);
case NPM1300_SOURCE_BUCK2:
return regulator_npm1300_set_buck_pin_ctrl(dev, 1, info, type);
case NPM1300_SOURCE_LDO1:
return regulator_npm1300_set_ldsw_pin_ctrl(dev, 0, info, type);
case NPM1300_SOURCE_LDO2:
return regulator_npm1300_set_ldsw_pin_ctrl(dev, 1, info, type);
case NPM13XX_SOURCE_BUCK1:
return regulator_npm13xx_set_buck_pin_ctrl(dev, 0, info, type);
case NPM13XX_SOURCE_BUCK2:
return regulator_npm13xx_set_buck_pin_ctrl(dev, 1, info, type);
case NPM13XX_SOURCE_LDO1:
return regulator_npm13xx_set_ldsw_pin_ctrl(dev, 0, info, type);
case NPM13XX_SOURCE_LDO2:
return regulator_npm13xx_set_ldsw_pin_ctrl(dev, 1, info, type);
default:
return -ENODEV;
}
}
int regulator_npm1300_dvs_state_set(const struct device *dev, regulator_dvs_state_t state)
int regulator_npm13xx_dvs_state_set(const struct device *dev, regulator_dvs_state_t state)
{
const struct regulator_npm1300_pconfig *pconfig = dev->config;
const struct regulator_npm13xx_pconfig *pconfig = dev->config;
const struct gpio_dt_spec *spec;
int ret;
@ -519,21 +519,21 @@ int regulator_npm1300_dvs_state_set(const struct device *dev, regulator_dvs_stat @@ -519,21 +519,21 @@ int regulator_npm1300_dvs_state_set(const struct device *dev, regulator_dvs_stat
return 0;
}
int regulator_npm1300_ship_mode(const struct device *dev)
int regulator_npm13xx_ship_mode(const struct device *dev)
{
const struct regulator_npm1300_pconfig *pconfig = dev->config;
const struct regulator_npm13xx_pconfig *pconfig = dev->config;
return mfd_npm1300_reg_write(pconfig->mfd, SHIP_BASE, SHIP_OFFSET_SHIP, 1U);
return mfd_npm13xx_reg_write(pconfig->mfd, SHIP_BASE, SHIP_OFFSET_SHIP, 1U);
}
static DEVICE_API(regulator_parent, parent_api) = {
.dvs_state_set = regulator_npm1300_dvs_state_set,
.ship_mode = regulator_npm1300_ship_mode,
.dvs_state_set = regulator_npm13xx_dvs_state_set,
.ship_mode = regulator_npm13xx_ship_mode,
};
int regulator_npm1300_common_init(const struct device *dev)
int regulator_npm13xx_common_init(const struct device *dev)
{
const struct regulator_npm1300_pconfig *pconfig = dev->config;
const struct regulator_npm13xx_pconfig *pconfig = dev->config;
const struct gpio_dt_spec *spec;
int ret;
@ -558,10 +558,10 @@ int regulator_npm1300_common_init(const struct device *dev) @@ -558,10 +558,10 @@ int regulator_npm1300_common_init(const struct device *dev)
static int get_enabled_reg(const struct device *dev, uint8_t base, uint8_t offset, uint8_t mask,
bool *enabled)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
uint8_t data;
int ret = mfd_npm1300_reg_read(config->mfd, base, offset, &data);
int ret = mfd_npm13xx_reg_read(config->mfd, base, offset, &data);
if (ret < 0) {
return ret;
@ -574,16 +574,16 @@ static int get_enabled_reg(const struct device *dev, uint8_t base, uint8_t offse @@ -574,16 +574,16 @@ static int get_enabled_reg(const struct device *dev, uint8_t base, uint8_t offse
static int get_enabled(const struct device *dev, bool *enabled)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
switch (config->source) {
case NPM1300_SOURCE_BUCK1:
case NPM13XX_SOURCE_BUCK1:
return get_enabled_reg(dev, BUCK_BASE, BUCK_OFFSET_STATUS, BUCK1_ON_MASK, enabled);
case NPM1300_SOURCE_BUCK2:
case NPM13XX_SOURCE_BUCK2:
return get_enabled_reg(dev, BUCK_BASE, BUCK_OFFSET_STATUS, BUCK2_ON_MASK, enabled);
case NPM1300_SOURCE_LDO1:
case NPM13XX_SOURCE_LDO1:
return get_enabled_reg(dev, LDSW_BASE, LDSW_OFFSET_STATUS, LDSW1_ON_MASK, enabled);
case NPM1300_SOURCE_LDO2:
case NPM13XX_SOURCE_LDO2:
return get_enabled_reg(dev, LDSW_BASE, LDSW_OFFSET_STATUS, LDSW2_ON_MASK, enabled);
default:
return -ENODEV;
@ -592,15 +592,15 @@ static int get_enabled(const struct device *dev, bool *enabled) @@ -592,15 +592,15 @@ static int get_enabled(const struct device *dev, bool *enabled)
static int soft_start_set(const struct device *dev, uint8_t soft_start)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
switch (config->source) {
case NPM1300_SOURCE_LDO1:
return mfd_npm1300_reg_update(config->mfd, LDSW_BASE, LDSW_OFFSET_CONFIG,
case NPM13XX_SOURCE_LDO1:
return mfd_npm13xx_reg_update(config->mfd, LDSW_BASE, LDSW_OFFSET_CONFIG,
soft_start << LDSW1_SOFTSTART_SHIFT,
LDSW1_SOFTSTART_MASK);
case NPM1300_SOURCE_LDO2:
return mfd_npm1300_reg_update(config->mfd, LDSW_BASE, LDSW_OFFSET_CONFIG,
case NPM13XX_SOURCE_LDO2:
return mfd_npm13xx_reg_update(config->mfd, LDSW_BASE, LDSW_OFFSET_CONFIG,
soft_start << LDSW2_SOFTSTART_SHIFT,
LDSW2_SOFTSTART_MASK);
default:
@ -610,23 +610,23 @@ static int soft_start_set(const struct device *dev, uint8_t soft_start) @@ -610,23 +610,23 @@ static int soft_start_set(const struct device *dev, uint8_t soft_start)
static int active_discharge_set(const struct device *dev, bool enabled)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
switch (config->source) {
case NPM1300_SOURCE_BUCK1:
return mfd_npm1300_reg_update(config->mfd, BUCK_BASE, BUCK_OFFSET_CTRL0,
case NPM13XX_SOURCE_BUCK1:
return mfd_npm13xx_reg_update(config->mfd, BUCK_BASE, BUCK_OFFSET_CTRL0,
enabled ? BUCK1_EN_PULLDOWN_MASK : 0,
BUCK1_EN_PULLDOWN_MASK);
case NPM1300_SOURCE_BUCK2:
return mfd_npm1300_reg_update(config->mfd, BUCK_BASE, BUCK_OFFSET_CTRL0,
case NPM13XX_SOURCE_BUCK2:
return mfd_npm13xx_reg_update(config->mfd, BUCK_BASE, BUCK_OFFSET_CTRL0,
enabled ? BUCK2_EN_PULLDOWN_MASK : 0,
BUCK2_EN_PULLDOWN_MASK);
case NPM1300_SOURCE_LDO1:
return mfd_npm1300_reg_update(config->mfd, LDSW_BASE, LDSW_OFFSET_CONFIG,
case NPM13XX_SOURCE_LDO1:
return mfd_npm13xx_reg_update(config->mfd, LDSW_BASE, LDSW_OFFSET_CONFIG,
enabled ? LDSW1_ACTIVE_DISCHARGE_MASK : 0,
LDSW1_ACTIVE_DISCHARGE_MASK);
case NPM1300_SOURCE_LDO2:
return mfd_npm1300_reg_update(config->mfd, LDSW_BASE, LDSW_OFFSET_CONFIG,
case NPM13XX_SOURCE_LDO2:
return mfd_npm13xx_reg_update(config->mfd, LDSW_BASE, LDSW_OFFSET_CONFIG,
enabled ? LDSW2_ACTIVE_DISCHARGE_MASK : 0,
LDSW2_ACTIVE_DISCHARGE_MASK);
default:
@ -634,9 +634,9 @@ static int active_discharge_set(const struct device *dev, bool enabled) @@ -634,9 +634,9 @@ static int active_discharge_set(const struct device *dev, bool enabled)
}
}
int regulator_npm1300_init(const struct device *dev)
int regulator_npm13xx_init(const struct device *dev)
{
const struct regulator_npm1300_config *config = dev->config;
const struct regulator_npm13xx_config *config = dev->config;
bool enabled;
int ret = 0;
@ -677,18 +677,18 @@ int regulator_npm1300_init(const struct device *dev) @@ -677,18 +677,18 @@ int regulator_npm1300_init(const struct device *dev)
}
/* Configure GPIO pin control */
ret = regulator_npm1300_set_pin_ctrl(dev, &config->enable_gpios, NPM1300_GPIO_TYPE_ENABLE);
ret = regulator_npm13xx_set_pin_ctrl(dev, &config->enable_gpios, NPM13XX_GPIO_TYPE_ENABLE);
if (ret != 0) {
return ret;
}
ret = regulator_npm1300_set_pin_ctrl(dev, &config->retention_gpios,
NPM1300_GPIO_TYPE_RETENTION);
ret = regulator_npm13xx_set_pin_ctrl(dev, &config->retention_gpios,
NPM13XX_GPIO_TYPE_RETENTION);
if (ret != 0) {
return ret;
}
ret = regulator_npm1300_set_pin_ctrl(dev, &config->pwm_gpios, NPM1300_GPIO_TYPE_PWM);
ret = regulator_npm13xx_set_pin_ctrl(dev, &config->pwm_gpios, NPM13XX_GPIO_TYPE_PWM);
if (ret != 0) {
return ret;
}
@ -697,28 +697,28 @@ int regulator_npm1300_init(const struct device *dev) @@ -697,28 +697,28 @@ int regulator_npm1300_init(const struct device *dev)
}
static DEVICE_API(regulator, api) = {
.enable = regulator_npm1300_enable,
.disable = regulator_npm1300_disable,
.count_voltages = regulator_npm1300_count_voltages,
.list_voltage = regulator_npm1300_list_voltage,
.set_voltage = regulator_npm1300_set_voltage,
.get_voltage = regulator_npm1300_get_voltage,
.set_mode = regulator_npm1300_set_mode,
.enable = regulator_npm13xx_enable,
.disable = regulator_npm13xx_disable,
.count_voltages = regulator_npm13xx_count_voltages,
.list_voltage = regulator_npm13xx_list_voltage,
.set_voltage = regulator_npm13xx_set_voltage,
.get_voltage = regulator_npm13xx_get_voltage,
.set_mode = regulator_npm13xx_set_mode,
};
#define GPIO_CONFIG_DEFINE(node_id, prop) \
COND_CODE_1(DT_NODE_HAS_PROP(node_id, prop), \
({DT_PROP_BY_IDX(node_id, prop, 0), \
!!(DT_PROP_BY_IDX(node_id, prop, 1) & GPIO_ACTIVE_LOW)}), \
({NPM1300_GPIO_UNUSED, false}))
({NPM13XX_GPIO_UNUSED, false}))
#define REGULATOR_NPM1300_DEFINE(node_id, id, _source) \
#define REGULATOR_NPM13XX_DEFINE(node_id, id, _source) \
BUILD_ASSERT(DT_PROP_LEN_OR(node_id, enable_gpio_config, 2) == 2); \
BUILD_ASSERT(DT_PROP_LEN_OR(node_id, retention_gpio_config, 2) == 2); \
BUILD_ASSERT(DT_PROP_LEN_OR(node_id, pwm_gpio_config, 2) == 2); \
static struct regulator_npm1300_data data_##id; \
static struct regulator_npm13xx_data data_##id; \
\
static const struct regulator_npm1300_config config_##id = { \
static const struct regulator_npm13xx_config config_##id = { \
.common = REGULATOR_DT_COMMON_CONFIG_INIT(node_id), \
.mfd = DEVICE_DT_GET(DT_GPARENT(node_id)), \
.source = _source, \
@ -730,16 +730,16 @@ static DEVICE_API(regulator, api) = { @@ -730,16 +730,16 @@ static DEVICE_API(regulator, api) = {
.active_discharge = DT_PROP(node_id, active_discharge), \
.ldo_disable_workaround = DT_PROP(node_id, nordic_anomaly38_disable_workaround)}; \
\
DEVICE_DT_DEFINE(node_id, regulator_npm1300_init, NULL, &data_##id, &config_##id, \
POST_KERNEL, CONFIG_REGULATOR_NPM1300_INIT_PRIORITY, &api);
DEVICE_DT_DEFINE(node_id, regulator_npm13xx_init, NULL, &data_##id, &config_##id, \
POST_KERNEL, CONFIG_REGULATOR_NPM13XX_INIT_PRIORITY, &api);
#define REGULATOR_NPM1300_DEFINE_COND(inst, child, source) \
#define REGULATOR_NPM13XX_DEFINE_COND(inst, child, source) \
COND_CODE_1(DT_NODE_EXISTS(DT_INST_CHILD(inst, child)), \
(REGULATOR_NPM1300_DEFINE(DT_INST_CHILD(inst, child), child##inst, source)), \
(REGULATOR_NPM13XX_DEFINE(DT_INST_CHILD(inst, child), child##inst, source)), \
())
#define REGULATOR_NPM1300_DEFINE_ALL(inst) \
static const struct regulator_npm1300_pconfig config_##inst = { \
#define REGULATOR_NPM13XX_DEFINE_ALL(inst) \
static const struct regulator_npm13xx_pconfig config_##inst = { \
.mfd = DEVICE_DT_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}), \
@ -747,13 +747,13 @@ static DEVICE_API(regulator, api) = { @@ -747,13 +747,13 @@ static DEVICE_API(regulator, api) = {
GPIO_DT_SPEC_INST_GET_BY_IDX_OR(inst, dvs_gpios, 3, {0}), \
GPIO_DT_SPEC_INST_GET_BY_IDX_OR(inst, dvs_gpios, 4, {0})}}; \
\
DEVICE_DT_INST_DEFINE(inst, regulator_npm1300_common_init, NULL, NULL, &config_##inst, \
POST_KERNEL, CONFIG_REGULATOR_NPM1300_COMMON_INIT_PRIORITY, \
DEVICE_DT_INST_DEFINE(inst, regulator_npm13xx_common_init, NULL, NULL, &config_##inst, \
POST_KERNEL, CONFIG_REGULATOR_NPM13XX_COMMON_INIT_PRIORITY, \
&parent_api); \
\
REGULATOR_NPM1300_DEFINE_COND(inst, buck1, NPM1300_SOURCE_BUCK1) \
REGULATOR_NPM1300_DEFINE_COND(inst, buck2, NPM1300_SOURCE_BUCK2) \
REGULATOR_NPM1300_DEFINE_COND(inst, ldo1, NPM1300_SOURCE_LDO1) \
REGULATOR_NPM1300_DEFINE_COND(inst, ldo2, NPM1300_SOURCE_LDO2)
REGULATOR_NPM13XX_DEFINE_COND(inst, buck1, NPM13XX_SOURCE_BUCK1) \
REGULATOR_NPM13XX_DEFINE_COND(inst, buck2, NPM13XX_SOURCE_BUCK2) \
REGULATOR_NPM13XX_DEFINE_COND(inst, ldo1, NPM13XX_SOURCE_LDO1) \
REGULATOR_NPM13XX_DEFINE_COND(inst, ldo2, NPM13XX_SOURCE_LDO2)
DT_INST_FOREACH_STATUS_OKAY(REGULATOR_NPM1300_DEFINE_ALL)
DT_INST_FOREACH_STATUS_OKAY(REGULATOR_NPM13XX_DEFINE_ALL)

2
drivers/sensor/nordic/CMakeLists.txt
Unescape View File

@ -3,7 +3,7 @@ @@ -3,7 +3,7 @@
# zephyr-keep-sorted-start
add_subdirectory(temp)
add_subdirectory_ifdef(CONFIG_NPM1300_CHARGER npm13xx_charger)
add_subdirectory_ifdef(CONFIG_NPM13XX_CHARGER npm13xx_charger)
add_subdirectory_ifdef(CONFIG_NPM2100_VBAT npm2100_vbat)
add_subdirectory_ifdef(CONFIG_QDEC_NRFX qdec_nrfx)
# zephyr-keep-sorted-stop

6
drivers/sensor/nordic/npm13xx_charger/Kconfig
Unescape View File

@ -2,12 +2,12 @@ @@ -2,12 +2,12 @@
#
# SPDX-License-Identifier: Apache-2.0
config NPM1300_CHARGER
bool "NPM1300 Charger"
config NPM13XX_CHARGER
bool "nPM13xx Charger"
default y
depends on DT_HAS_NORDIC_NPM1300_CHARGER_ENABLED
select I2C
select MFD
select REQUIRES_FULL_LIBC
help
Enable NPM1300 charger driver.
Enable nPM13xx charger driver.

158
drivers/sensor/nordic/npm13xx_charger/npm13xx_charger.c
Unescape View File

@ -12,7 +12,7 @@ @@ -12,7 +12,7 @@
#include <zephyr/sys/linear_range.h>
#include <zephyr/drivers/sensor/npm13xx_charger.h>
struct npm1300_charger_config {
struct npm13xx_charger_config {
const struct device *mfd;
int32_t term_microvolt;
int32_t term_warm_microvolt;
@ -32,7 +32,7 @@ struct npm1300_charger_config { @@ -32,7 +32,7 @@ struct npm1300_charger_config {
bool disable_recharge;
};
struct npm1300_charger_data {
struct npm13xx_charger_data {
uint16_t voltage;
uint16_t current;
uint16_t temp;
@ -43,12 +43,12 @@ struct npm1300_charger_data { @@ -43,12 +43,12 @@ struct npm1300_charger_data {
uint8_t vbus_stat;
};
/* nPM1300 base addresses */
/* nPM13xx base addresses */
#define CHGR_BASE 0x03U
#define ADC_BASE 0x05U
#define VBUS_BASE 0x02U
/* nPM1300 charger register offsets */
/* nPM13xx charger register offsets */
#define CHGR_OFFSET_ERR_CLR 0x00U
#define CHGR_OFFSET_EN_SET 0x04U
#define CHGR_OFFSET_EN_CLR 0x05U
@ -65,7 +65,7 @@ struct npm1300_charger_data { @@ -65,7 +65,7 @@ struct npm1300_charger_data {
#define CHGR_OFFSET_ERR_REASON 0x36U
#define CHGR_OFFSET_VBATLOW_EN 0x50U
/* nPM1300 ADC register offsets */
/* nPM13xx ADC register offsets */
#define ADC_OFFSET_TASK_VBAT 0x00U
#define ADC_OFFSET_TASK_TEMP 0x01U
#define ADC_OFFSET_TASK_DIE 0x02U
@ -75,7 +75,7 @@ struct npm1300_charger_data { @@ -75,7 +75,7 @@ struct npm1300_charger_data {
#define ADC_OFFSET_RESULTS 0x10U
#define ADC_OFFSET_IBAT_EN 0x24U
/* nPM1300 VBUS register offsets */
/* nPM13xx VBUS register offsets */
#define VBUS_OFFSET_ILIMUPDATE 0x00U
#define VBUS_OFFSET_ILIM 0x01U
#define VBUS_OFFSET_ILIMSTARTUP 0x02U
@ -149,7 +149,7 @@ static const uint16_t discharge_limits[] = {84U, 415U}; @@ -149,7 +149,7 @@ static const uint16_t discharge_limits[] = {84U, 415U};
/* Linear range for vbusin current limit */
static const struct linear_range vbus_current_range = LINEAR_RANGE_INIT(100000, 100000, 1U, 15U);
static void calc_temp(const struct npm1300_charger_config *const config, uint16_t code,
static void calc_temp(const struct npm13xx_charger_config *const config, uint16_t code,
struct sensor_value *valp)
{
/* Ref: PS v1.2 Section 7.1.4: Battery temperature (Kelvin) */
@ -161,7 +161,7 @@ static void calc_temp(const struct npm1300_charger_config *const config, uint16_ @@ -161,7 +161,7 @@ static void calc_temp(const struct npm1300_charger_config *const config, uint16_
(void)sensor_value_from_float(valp, temp);
}
static void calc_dietemp(const struct npm1300_charger_config *const config, uint16_t code,
static void calc_dietemp(const struct npm13xx_charger_config *const config, uint16_t code,
struct sensor_value *valp)
{
/* Ref: PS v1.2 Section 7.1.4: Die temperature (Celsius) */
@ -171,7 +171,7 @@ static void calc_dietemp(const struct npm1300_charger_config *const config, uint @@ -171,7 +171,7 @@ static void calc_dietemp(const struct npm1300_charger_config *const config, uint
(void)sensor_value_from_milli(valp, temp);
}
static uint32_t calc_ntc_res(const struct npm1300_charger_config *const config, int32_t temp_mdegc)
static uint32_t calc_ntc_res(const struct npm13xx_charger_config *const config, int32_t temp_mdegc)
{
float inv_t0 = 1.f / 298.15f;
float temp = (float)temp_mdegc / 1000.f;
@ -187,8 +187,8 @@ static uint16_t adc_get_res(uint8_t msb, uint8_t lsb, uint16_t lsb_shift) @@ -187,8 +187,8 @@ static uint16_t adc_get_res(uint8_t msb, uint8_t lsb, uint16_t lsb_shift)
return ((uint16_t)msb << ADC_MSB_SHIFT) | ((lsb >> lsb_shift) & ADC_LSB_MASK);
}
static void calc_current(const struct npm1300_charger_config *const config,
struct npm1300_charger_data *const data, struct sensor_value *valp)
static void calc_current(const struct npm13xx_charger_config *const config,
struct npm13xx_charger_data *const data, struct sensor_value *valp)
{
int32_t full_scale_ua;
int32_t current_ua;
@ -232,11 +232,11 @@ static void calc_current(const struct npm1300_charger_config *const config, @@ -232,11 +232,11 @@ static void calc_current(const struct npm1300_charger_config *const config,
(void)sensor_value_from_micro(valp, current_ua);
}
int npm1300_charger_channel_get(const struct device *dev, enum sensor_channel chan,
int npm13xx_charger_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *valp)
{
const struct npm1300_charger_config *const config = dev->config;
struct npm1300_charger_data *const data = dev->data;
const struct npm13xx_charger_config *const config = dev->config;
struct npm13xx_charger_data *const data = dev->data;
switch ((uint32_t)chan) {
case SENSOR_CHAN_GAUGE_VOLTAGE:
@ -251,11 +251,11 @@ int npm1300_charger_channel_get(const struct device *dev, enum sensor_channel ch @@ -251,11 +251,11 @@ int npm1300_charger_channel_get(const struct device *dev, enum sensor_channel ch
case SENSOR_CHAN_GAUGE_AVG_CURRENT:
calc_current(config, data, valp);
break;
case SENSOR_CHAN_NPM1300_CHARGER_STATUS:
case SENSOR_CHAN_NPM13XX_CHARGER_STATUS:
valp->val1 = data->status;
valp->val2 = 0;
break;
case SENSOR_CHAN_NPM1300_CHARGER_ERROR:
case SENSOR_CHAN_NPM13XX_CHARGER_ERROR:
valp->val1 = data->error;
valp->val2 = 0;
break;
@ -268,7 +268,7 @@ int npm1300_charger_channel_get(const struct device *dev, enum sensor_channel ch @@ -268,7 +268,7 @@ int npm1300_charger_channel_get(const struct device *dev, enum sensor_channel ch
case SENSOR_CHAN_DIE_TEMP:
calc_dietemp(config, data->dietemp, valp);
break;
case SENSOR_CHAN_NPM1300_CHARGER_VBUS_STATUS:
case SENSOR_CHAN_NPM13XX_CHARGER_VBUS_STATUS:
valp->val1 = data->vbus_stat;
valp->val2 = 0;
break;
@ -279,26 +279,26 @@ int npm1300_charger_channel_get(const struct device *dev, enum sensor_channel ch @@ -279,26 +279,26 @@ int npm1300_charger_channel_get(const struct device *dev, enum sensor_channel ch
return 0;
}
int npm1300_charger_sample_fetch(const struct device *dev, enum sensor_channel chan)
int npm13xx_charger_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
const struct npm1300_charger_config *const config = dev->config;
struct npm1300_charger_data *data = dev->data;
const struct npm13xx_charger_config *const config = dev->config;
struct npm13xx_charger_data *data = dev->data;
struct adc_results_t results;
int ret;
/* Read charge status and error reason */
ret = mfd_npm1300_reg_read(config->mfd, CHGR_BASE, CHGR_OFFSET_CHG_STAT, &data->status);
ret = mfd_npm13xx_reg_read(config->mfd, CHGR_BASE, CHGR_OFFSET_CHG_STAT, &data->status);
if (ret != 0) {
return ret;
}
ret = mfd_npm1300_reg_read(config->mfd, CHGR_BASE, CHGR_OFFSET_ERR_REASON, &data->error);
ret = mfd_npm13xx_reg_read(config->mfd, CHGR_BASE, CHGR_OFFSET_ERR_REASON, &data->error);
if (ret != 0) {
return ret;
}
/* Read adc results */
ret = mfd_npm1300_reg_read_burst(config->mfd, ADC_BASE, ADC_OFFSET_RESULTS, &results,
ret = mfd_npm13xx_reg_read_burst(config->mfd, ADC_BASE, ADC_OFFSET_RESULTS, &results,
sizeof(results));
if (ret != 0) {
return ret;
@ -311,19 +311,19 @@ int npm1300_charger_sample_fetch(const struct device *dev, enum sensor_channel c @@ -311,19 +311,19 @@ int npm1300_charger_sample_fetch(const struct device *dev, enum sensor_channel c
data->ibat_stat = results.ibat_stat;
/* Trigger ntc and die temperature measurements */
ret = mfd_npm1300_reg_write2(config->mfd, ADC_BASE, ADC_OFFSET_TASK_TEMP, 1U, 1U);
ret = mfd_npm13xx_reg_write2(config->mfd, ADC_BASE, ADC_OFFSET_TASK_TEMP, 1U, 1U);
if (ret != 0) {
return ret;
}
/* Trigger current and voltage measurement */
ret = mfd_npm1300_reg_write(config->mfd, ADC_BASE, ADC_OFFSET_TASK_VBAT, 1U);
ret = mfd_npm13xx_reg_write(config->mfd, ADC_BASE, ADC_OFFSET_TASK_VBAT, 1U);
if (ret != 0) {
return ret;
}
/* Read vbus status */
ret = mfd_npm1300_reg_read(config->mfd, VBUS_BASE, VBUS_OFFSET_STATUS, &data->vbus_stat);
ret = mfd_npm13xx_reg_read(config->mfd, VBUS_BASE, VBUS_OFFSET_STATUS, &data->vbus_stat);
if (ret != 0) {
return ret;
}
@ -331,7 +331,7 @@ int npm1300_charger_sample_fetch(const struct device *dev, enum sensor_channel c @@ -331,7 +331,7 @@ int npm1300_charger_sample_fetch(const struct device *dev, enum sensor_channel c
return ret;
}
static int set_ntc_thresholds(const struct npm1300_charger_config *const config)
static int set_ntc_thresholds(const struct npm13xx_charger_config *const config)
{
for (uint8_t idx = 0U; idx < 4U; idx++) {
if (config->temp_thresholds[idx] < INT32_MAX) {
@ -340,7 +340,7 @@ static int set_ntc_thresholds(const struct npm1300_charger_config *const config) @@ -340,7 +340,7 @@ static int set_ntc_thresholds(const struct npm1300_charger_config *const config)
/* Ref: Datasheet Figure 14: Equation for battery temperature */
uint16_t code = (1024 * res) / (res + config->thermistor_ohms);
int ret = mfd_npm1300_reg_write2(
int ret = mfd_npm13xx_reg_write2(
config->mfd, CHGR_BASE, CHGR_OFFSET_NTC_TEMPS + (idx * 2U),
code >> NTCTEMP_MSB_SHIFT, code & NTCTEMP_LSB_MASK);
@ -353,7 +353,7 @@ static int set_ntc_thresholds(const struct npm1300_charger_config *const config) @@ -353,7 +353,7 @@ static int set_ntc_thresholds(const struct npm1300_charger_config *const config)
return 0;
}
static int set_dietemp_thresholds(const struct npm1300_charger_config *const config)
static int set_dietemp_thresholds(const struct npm13xx_charger_config *const config)
{
for (uint8_t idx = 0U; idx < 2U; idx++) {
if (config->dietemp_thresholds[idx] < INT32_MAX) {
@ -363,7 +363,7 @@ static int set_dietemp_thresholds(const struct npm1300_charger_config *const con @@ -363,7 +363,7 @@ static int set_dietemp_thresholds(const struct npm1300_charger_config *const con
DIETEMP_FACTOR_DIV;
uint16_t code = DIV_ROUND_CLOSEST(numerator, DIETEMP_FACTOR_MUL);
int ret = mfd_npm1300_reg_write2(
int ret = mfd_npm13xx_reg_write2(
config->mfd, CHGR_BASE, CHGR_OFFSET_DIE_TEMPS + (idx * 2U),
code >> DIETEMP_MSB_SHIFT, code & DIETEMP_LSB_MASK);
@ -376,10 +376,10 @@ static int set_dietemp_thresholds(const struct npm1300_charger_config *const con @@ -376,10 +376,10 @@ static int set_dietemp_thresholds(const struct npm1300_charger_config *const con
return 0;
}
static int npm1300_charger_attr_get(const struct device *dev, enum sensor_channel chan,
static int npm13xx_charger_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
const struct npm1300_charger_config *const config = dev->config;
const struct npm13xx_charger_config *const config = dev->config;
uint8_t data;
int ret;
@ -389,7 +389,7 @@ static int npm1300_charger_attr_get(const struct device *dev, enum sensor_channe @@ -389,7 +389,7 @@ static int npm1300_charger_attr_get(const struct device *dev, enum sensor_channe
return -ENOTSUP;
}
ret = mfd_npm1300_reg_read(config->mfd, CHGR_BASE, CHGR_OFFSET_EN_SET, &data);
ret = mfd_npm13xx_reg_read(config->mfd, CHGR_BASE, CHGR_OFFSET_EN_SET, &data);
if (ret == 0) {
val->val1 = data;
val->val2 = 0U;
@ -401,7 +401,7 @@ static int npm1300_charger_attr_get(const struct device *dev, enum sensor_channe @@ -401,7 +401,7 @@ static int npm1300_charger_attr_get(const struct device *dev, enum sensor_channe
return -ENOTSUP;
}
ret = mfd_npm1300_reg_read(config->mfd, VBUS_BASE, VBUS_OFFSET_DETECT, &data);
ret = mfd_npm13xx_reg_read(config->mfd, VBUS_BASE, VBUS_OFFSET_DETECT, &data);
if (ret < 0) {
return ret;
}
@ -418,29 +418,29 @@ static int npm1300_charger_attr_get(const struct device *dev, enum sensor_channe @@ -418,29 +418,29 @@ static int npm1300_charger_attr_get(const struct device *dev, enum sensor_channe
return 0;
case SENSOR_CHAN_NPM1300_CHARGER_VBUS_STATUS:
ret = mfd_npm1300_reg_read(config->mfd, VBUS_BASE, VBUS_OFFSET_STATUS, &data);
case SENSOR_CHAN_NPM13XX_CHARGER_VBUS_STATUS:
ret = mfd_npm13xx_reg_read(config->mfd, VBUS_BASE, VBUS_OFFSET_STATUS, &data);
if (ret < 0) {
return ret;
}
switch ((enum sensor_attribute_npm1300_charger)attr) {
case SENSOR_ATTR_NPM1300_CHARGER_VBUS_PRESENT:
switch ((enum sensor_attribute_npm13xx_charger)attr) {
case SENSOR_ATTR_NPM13XX_CHARGER_VBUS_PRESENT:
val->val1 = (data & STATUS_PRESENT_MASK) != 0;
break;
case SENSOR_ATTR_NPM1300_CHARGER_VBUS_CUR_LIMIT:
case SENSOR_ATTR_NPM13XX_CHARGER_VBUS_CUR_LIMIT:
val->val1 = (data & STATUS_CUR_LIMIT_MASK) != 0;
break;
case SENSOR_ATTR_NPM1300_CHARGER_VBUS_OVERVLT_PROT:
case SENSOR_ATTR_NPM13XX_CHARGER_VBUS_OVERVLT_PROT:
val->val1 = (data & STATUS_OVERVLT_PROT_MASK) != 0;
break;
case SENSOR_ATTR_NPM1300_CHARGER_VBUS_UNDERVLT:
case SENSOR_ATTR_NPM13XX_CHARGER_VBUS_UNDERVLT:
val->val1 = (data & STATUS_UNDERVLT_MASK) != 0;
break;
case SENSOR_ATTR_NPM1300_CHARGER_VBUS_SUSPENDED:
case SENSOR_ATTR_NPM13XX_CHARGER_VBUS_SUSPENDED:
val->val1 = (data & STATUS_SUSPENDED_MASK) != 0;
break;
case SENSOR_ATTR_NPM1300_CHARGER_VBUS_BUSOUT:
case SENSOR_ATTR_NPM13XX_CHARGER_VBUS_BUSOUT:
val->val1 = (data & STATUS_BUSOUT_MASK) != 0;
break;
default:
@ -454,10 +454,10 @@ static int npm1300_charger_attr_get(const struct device *dev, enum sensor_channe @@ -454,10 +454,10 @@ static int npm1300_charger_attr_get(const struct device *dev, enum sensor_channe
}
}
static int npm1300_charger_attr_set(const struct device *dev, enum sensor_channel chan,
static int npm13xx_charger_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
const struct npm1300_charger_config *const config = dev->config;
const struct npm13xx_charger_config *const config = dev->config;
int ret;
if (attr != SENSOR_ATTR_CONFIGURATION) {
@ -468,16 +468,16 @@ static int npm1300_charger_attr_set(const struct device *dev, enum sensor_channe @@ -468,16 +468,16 @@ static int npm1300_charger_attr_set(const struct device *dev, enum sensor_channe
case SENSOR_CHAN_GAUGE_DESIRED_CHARGING_CURRENT:
if (val->val1 == 0) {
/* Disable charging */
return mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_EN_CLR,
return mfd_npm13xx_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_EN_CLR,
1U);
}
/* Clear any errors and enable charging */
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_ERR_CLR, 1U);
ret = mfd_npm13xx_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_ERR_CLR, 1U);
if (ret != 0) {
return ret;
}
return mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_EN_SET, 1U);
return mfd_npm13xx_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_EN_SET, 1U);
case SENSOR_CHAN_CURRENT:
/* Set vbus current limit */
@ -490,22 +490,22 @@ static int npm1300_charger_attr_set(const struct device *dev, enum sensor_channe @@ -490,22 +490,22 @@ static int npm1300_charger_attr_set(const struct device *dev, enum sensor_channe
return ret;
}
ret = mfd_npm1300_reg_write(config->mfd, VBUS_BASE, VBUS_OFFSET_ILIM, idx);
ret = mfd_npm13xx_reg_write(config->mfd, VBUS_BASE, VBUS_OFFSET_ILIM, idx);
if (ret != 0) {
return ret;
}
/* Switch to new current limit, this will be reset automatically on USB removal */
return mfd_npm1300_reg_write(config->mfd, VBUS_BASE, VBUS_OFFSET_ILIMUPDATE, 1U);
return mfd_npm13xx_reg_write(config->mfd, VBUS_BASE, VBUS_OFFSET_ILIMUPDATE, 1U);
default:
return -ENOTSUP;
}
}
int npm1300_charger_init(const struct device *dev)
int npm13xx_charger_init(const struct device *dev)
{
const struct npm1300_charger_config *const config = dev->config;
const struct npm13xx_charger_config *const config = dev->config;
uint16_t idx;
uint8_t byte = 0U;
int ret;
@ -515,7 +515,7 @@ int npm1300_charger_init(const struct device *dev) @@ -515,7 +515,7 @@ int npm1300_charger_init(const struct device *dev)
}
/* Configure temperature thresholds */
ret = mfd_npm1300_reg_write(config->mfd, ADC_BASE, ADC_OFFSET_NTCR_SEL,
ret = mfd_npm13xx_reg_write(config->mfd, ADC_BASE, ADC_OFFSET_NTCR_SEL,
config->thermistor_idx);
if (ret != 0) {
return ret;
@ -538,7 +538,7 @@ int npm1300_charger_init(const struct device *dev) @@ -538,7 +538,7 @@ int npm1300_charger_init(const struct device *dev)
if (ret == -EINVAL) {
return ret;
}
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_VTERM, idx);
ret = mfd_npm13xx_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_VTERM, idx);
if (ret != 0) {
return ret;
}
@ -550,7 +550,7 @@ int npm1300_charger_init(const struct device *dev) @@ -550,7 +550,7 @@ int npm1300_charger_init(const struct device *dev)
return ret;
}
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_VTERM_R, idx);
ret = mfd_npm13xx_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_VTERM_R, idx);
if (ret != 0) {
return ret;
}
@ -563,13 +563,13 @@ int npm1300_charger_init(const struct device *dev) @@ -563,13 +563,13 @@ int npm1300_charger_init(const struct device *dev)
return ret;
}
ret = mfd_npm1300_reg_write2(config->mfd, CHGR_BASE, CHGR_OFFSET_ISET, idx / 2U, idx & 1U);
ret = mfd_npm13xx_reg_write2(config->mfd, CHGR_BASE, CHGR_OFFSET_ISET, idx / 2U, idx & 1U);
if (ret != 0) {
return ret;
}
/* Set discharge limit */
ret = mfd_npm1300_reg_write2(config->mfd, CHGR_BASE, CHGR_OFFSET_ISET_DISCHG,
ret = mfd_npm13xx_reg_write2(config->mfd, CHGR_BASE, CHGR_OFFSET_ISET_DISCHG,
discharge_limits[config->dischg_limit_idx] / 2U,
discharge_limits[config->dischg_limit_idx] & 1U);
if (ret != 0) {
@ -582,52 +582,52 @@ int npm1300_charger_init(const struct device *dev) @@ -582,52 +582,52 @@ int npm1300_charger_init(const struct device *dev)
if (ret == -EINVAL) {
return ret;
}
ret = mfd_npm1300_reg_write(config->mfd, VBUS_BASE, VBUS_OFFSET_ILIMSTARTUP, idx);
ret = mfd_npm13xx_reg_write(config->mfd, VBUS_BASE, VBUS_OFFSET_ILIMSTARTUP, idx);
if (ret != 0) {
return ret;
}
/* Configure trickle voltage threshold */
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_TRICKLE_SEL,
ret = mfd_npm13xx_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_TRICKLE_SEL,
config->trickle_sel);
if (ret != 0) {
return ret;
}
/* Configure termination current */
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_ITERM_SEL,
ret = mfd_npm13xx_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_ITERM_SEL,
config->iterm_sel);
if (ret != 0) {
return ret;
}
/* Enable current measurement */
ret = mfd_npm1300_reg_write(config->mfd, ADC_BASE, ADC_OFFSET_IBAT_EN, 1U);
ret = mfd_npm13xx_reg_write(config->mfd, ADC_BASE, ADC_OFFSET_IBAT_EN, 1U);
if (ret != 0) {
return ret;
}
/* Trigger current and voltage measurement */
ret = mfd_npm1300_reg_write(config->mfd, ADC_BASE, ADC_OFFSET_TASK_VBAT, 1U);
ret = mfd_npm13xx_reg_write(config->mfd, ADC_BASE, ADC_OFFSET_TASK_VBAT, 1U);
if (ret != 0) {
return ret;
}
/* Trigger ntc and die temperature measurements */
ret = mfd_npm1300_reg_write2(config->mfd, ADC_BASE, ADC_OFFSET_TASK_TEMP, 1U, 1U);
ret = mfd_npm13xx_reg_write2(config->mfd, ADC_BASE, ADC_OFFSET_TASK_TEMP, 1U, 1U);
if (ret != 0) {
return ret;
}
/* Enable automatic temperature measurements during charging */
ret = mfd_npm1300_reg_write(config->mfd, ADC_BASE, ADC_OFFSET_TASK_AUTO, 1U);
ret = mfd_npm13xx_reg_write(config->mfd, ADC_BASE, ADC_OFFSET_TASK_AUTO, 1U);
if (ret != 0) {
return ret;
}
/* Enable charging at low battery if configured */
if (config->vbatlow_charge_enable) {
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_VBATLOW_EN, 1U);
ret = mfd_npm13xx_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_VBATLOW_EN, 1U);
if (ret != 0) {
return ret;
}
@ -643,14 +643,14 @@ int npm1300_charger_init(const struct device *dev) @@ -643,14 +643,14 @@ int npm1300_charger_init(const struct device *dev)
WRITE_BIT(byte, 1U, true);
}
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_DIS_SET, byte);
ret = mfd_npm13xx_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_DIS_SET, byte);
if (ret != 0) {
return ret;
}
/* Enable charging if configured */
if (config->charging_enable) {
ret = mfd_npm1300_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_EN_SET, 1U);
ret = mfd_npm13xx_reg_write(config->mfd, CHGR_BASE, CHGR_OFFSET_EN_SET, 1U);
if (ret != 0) {
return ret;
}
@ -659,19 +659,19 @@ int npm1300_charger_init(const struct device *dev) @@ -659,19 +659,19 @@ int npm1300_charger_init(const struct device *dev)
return 0;
}
static DEVICE_API(sensor, npm1300_charger_battery_driver_api) = {
.sample_fetch = npm1300_charger_sample_fetch,
.channel_get = npm1300_charger_channel_get,
.attr_set = npm1300_charger_attr_set,
.attr_get = npm1300_charger_attr_get,
static DEVICE_API(sensor, npm13xx_charger_battery_driver_api) = {
.sample_fetch = npm13xx_charger_sample_fetch,
.channel_get = npm13xx_charger_channel_get,
.attr_set = npm13xx_charger_attr_set,
.attr_get = npm13xx_charger_attr_get,
};
#define NPM1300_CHARGER_INIT(n) \
#define NPM13XX_CHARGER_INIT(n) \
BUILD_ASSERT(DT_INST_ENUM_IDX(n, dischg_limit_microamp) < ARRAY_SIZE(discharge_limits)); \
\
static struct npm1300_charger_data npm1300_charger_data_##n; \
static struct npm13xx_charger_data npm13xx_charger_data_##n; \
\
static const struct npm1300_charger_config npm1300_charger_config_##n = { \
static const struct npm13xx_charger_config npm13xx_charger_config_##n = { \
.mfd = DEVICE_DT_GET(DT_INST_PARENT(n)), \
.term_microvolt = DT_INST_PROP(n, term_microvolt), \
.term_warm_microvolt = \
@ -696,9 +696,9 @@ static DEVICE_API(sensor, npm1300_charger_battery_driver_api) = { @@ -696,9 +696,9 @@ static DEVICE_API(sensor, npm1300_charger_battery_driver_api) = {
DT_INST_PROP_OR(n, thermistor_warm_millidegrees, INT32_MAX), \
DT_INST_PROP_OR(n, thermistor_hot_millidegrees, INT32_MAX)}}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, &npm1300_charger_init, NULL, &npm1300_charger_data_##n, \
&npm1300_charger_config_##n, POST_KERNEL, \
SENSOR_DEVICE_DT_INST_DEFINE(n, &npm13xx_charger_init, NULL, &npm13xx_charger_data_##n, \
&npm13xx_charger_config_##n, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&npm1300_charger_battery_driver_api);
&npm13xx_charger_battery_driver_api);
DT_INST_FOREACH_STATUS_OKAY(NPM1300_CHARGER_INIT)
DT_INST_FOREACH_STATUS_OKAY(NPM13XX_CHARGER_INIT)

2
drivers/watchdog/CMakeLists.txt
Unescape View File

@ -28,7 +28,7 @@ zephyr_library_sources_ifdef(CONFIG_WDT_MCUX_WDOG wdt_mcux_wdog.c) @@ -28,7 +28,7 @@ zephyr_library_sources_ifdef(CONFIG_WDT_MCUX_WDOG wdt_mcux_wdog.c)
zephyr_library_sources_ifdef(CONFIG_WDT_MCUX_WDOG32 wdt_mcux_wdog32.c)
zephyr_library_sources_ifdef(CONFIG_WDT_MCUX_WWDT wdt_mcux_wwdt.c)
zephyr_library_sources_ifdef(CONFIG_WDT_NPCX wdt_npcx.c)
zephyr_library_sources_ifdef(CONFIG_WDT_NPM1300 wdt_npm13xx.c)
zephyr_library_sources_ifdef(CONFIG_WDT_NPM13XX wdt_npm13xx.c)
zephyr_library_sources_ifdef(CONFIG_WDT_NPM2100 wdt_npm2100.c)
zephyr_library_sources_ifdef(CONFIG_WDT_NPM6001 wdt_npm6001.c)
zephyr_library_sources_ifdef(CONFIG_WDT_NRFX wdt_nrfx.c)

16
drivers/watchdog/Kconfig.npm13xx
Unescape View File

@ -1,19 +1,19 @@ @@ -1,19 +1,19 @@
# Copyright (c) 2023 Nordic Semiconductor ASA
# SPDX-License-Identifier: Apache-2.0
config WDT_NPM1300
bool "nPM1300 Watchdog driver"
config WDT_NPM13XX
bool "nPM13xx Watchdog driver"
default y
depends on DT_HAS_NORDIC_NPM1300_WDT_ENABLED
select I2C
select MFD
help
Enable nPM1300 Watchdog driver
Enable nPM13xx Watchdog driver
config WDT_NPM1300_INIT_PRIORITY
int "nPM1300 Watchdog driver initialization priority"
depends on WDT_NPM1300
config WDT_NPM13XX_INIT_PRIORITY
int "nPM13xx Watchdog driver initialization priority"
depends on WDT_NPM13XX
default 85
help
Initialization priority for the nPM1300 Watchdog driver.
It must be greater than GPIO_NPM1300_INIT_PRIORITY.
Initialization priority for the nPM13xx Watchdog driver.
It must be greater than GPIO_NPM13XX_INIT_PRIORITY.

72
drivers/watchdog/wdt_npm13xx.c
Unescape View File

@ -3,7 +3,7 @@ @@ -3,7 +3,7 @@
* SPDX-License-Identifier: Apache-2.0
*/
#define DT_DRV_COMPAT nordic_npm1300_wdt
#define DT_DRV_COMPAT nordic_npm13xx_wdt
#include <errno.h>
@ -13,49 +13,49 @@ @@ -13,49 +13,49 @@
#include <zephyr/drivers/mfd/npm13xx.h>
#include <zephyr/dt-bindings/gpio/nordic-npm13xx-gpio.h>
/* nPM1300 TIMER base address */
/* nPM13xx TIMER base address */
#define TIME_BASE 0x07U
/* nPM1300 timer register offsets */
/* nPM13xx timer register offsets */
#define TIME_OFFSET_START 0x00U
#define TIME_OFFSET_STOP 0x01U
#define TIME_OFFSET_WDOG_KICK 0x04U
#define TIME_OFFSET_MODE 0x05U
/* nPM1300 timer modes */
/* nPM13xx timer modes */
#define TIME_MODE_BOOT 0x00U
#define TIME_MODE_WARN 0x01U
#define TIME_MODE_RESET 0x02U
#define TIME_MODE_GEN 0x03U
struct wdt_npm1300_config {
struct wdt_npm13xx_config {
const struct device *mfd;
struct gpio_dt_spec reset_gpios;
};
struct wdt_npm1300_data {
struct wdt_npm13xx_data {
bool timeout_valid;
};
static int wdt_npm1300_setup(const struct device *dev, uint8_t options)
static int wdt_npm13xx_setup(const struct device *dev, uint8_t options)
{
const struct wdt_npm1300_config *config = dev->config;
struct wdt_npm1300_data *data = dev->data;
const struct wdt_npm13xx_config *config = dev->config;
struct wdt_npm13xx_data *data = dev->data;
if (!data->timeout_valid) {
return -EINVAL;
}
return mfd_npm1300_reg_write(config->mfd, TIME_BASE, TIME_OFFSET_START, 1U);
return mfd_npm13xx_reg_write(config->mfd, TIME_BASE, TIME_OFFSET_START, 1U);
}
static int wdt_npm1300_disable(const struct device *dev)
static int wdt_npm13xx_disable(const struct device *dev)
{
const struct wdt_npm1300_config *config = dev->config;
struct wdt_npm1300_data *data = dev->data;
const struct wdt_npm13xx_config *config = dev->config;
struct wdt_npm13xx_data *data = dev->data;
int ret;
ret = mfd_npm1300_reg_write(config->mfd, TIME_BASE, TIME_OFFSET_STOP, 1U);
ret = mfd_npm13xx_reg_write(config->mfd, TIME_BASE, TIME_OFFSET_STOP, 1U);
if (ret < 0) {
return ret;
}
@ -65,11 +65,11 @@ static int wdt_npm1300_disable(const struct device *dev) @@ -65,11 +65,11 @@ static int wdt_npm1300_disable(const struct device *dev)
return 0;
}
static int wdt_npm1300_install_timeout(const struct device *dev,
static int wdt_npm13xx_install_timeout(const struct device *dev,
const struct wdt_timeout_cfg *timeout)
{
const struct wdt_npm1300_config *config = dev->config;
struct wdt_npm1300_data *data = dev->data;
const struct wdt_npm13xx_config *config = dev->config;
struct wdt_npm13xx_data *data = dev->data;
uint8_t mode;
int ret;
@ -81,7 +81,7 @@ static int wdt_npm1300_install_timeout(const struct device *dev, @@ -81,7 +81,7 @@ static int wdt_npm1300_install_timeout(const struct device *dev,
return -EINVAL;
}
ret = mfd_npm1300_set_timer(config->mfd, timeout->window.max);
ret = mfd_npm13xx_set_timer(config->mfd, timeout->window.max);
if (ret < 0) {
return ret;
}
@ -103,7 +103,7 @@ static int wdt_npm1300_install_timeout(const struct device *dev, @@ -103,7 +103,7 @@ static int wdt_npm1300_install_timeout(const struct device *dev,
return -EINVAL;
}
ret = mfd_npm1300_reg_write(config->mfd, TIME_BASE, TIME_OFFSET_MODE, mode);
ret = mfd_npm13xx_reg_write(config->mfd, TIME_BASE, TIME_OFFSET_MODE, mode);
if (ret < 0) {
return ret;
}
@ -113,27 +113,27 @@ static int wdt_npm1300_install_timeout(const struct device *dev, @@ -113,27 +113,27 @@ static int wdt_npm1300_install_timeout(const struct device *dev,
return 0;
}
static int wdt_npm1300_feed(const struct device *dev, int channel_id)
static int wdt_npm13xx_feed(const struct device *dev, int channel_id)
{
const struct wdt_npm1300_config *config = dev->config;
const struct wdt_npm13xx_config *config = dev->config;
if (channel_id != 0) {
return -EINVAL;
}
return mfd_npm1300_reg_write(config->mfd, TIME_BASE, TIME_OFFSET_WDOG_KICK, 1U);
return mfd_npm13xx_reg_write(config->mfd, TIME_BASE, TIME_OFFSET_WDOG_KICK, 1U);
}
static DEVICE_API(wdt, wdt_npm1300_api) = {
.setup = wdt_npm1300_setup,
.disable = wdt_npm1300_disable,
.install_timeout = wdt_npm1300_install_timeout,
.feed = wdt_npm1300_feed,
static DEVICE_API(wdt, wdt_npm13xx_api) = {
.setup = wdt_npm13xx_setup,
.disable = wdt_npm13xx_disable,
.install_timeout = wdt_npm13xx_install_timeout,
.feed = wdt_npm13xx_feed,
};
static int wdt_npm1300_init(const struct device *dev)
static int wdt_npm13xx_init(const struct device *dev)
{
const struct wdt_npm1300_config *config = dev->config;
const struct wdt_npm13xx_config *config = dev->config;
int ret;
if (!device_is_ready(config->mfd)) {
@ -145,7 +145,7 @@ static int wdt_npm1300_init(const struct device *dev) @@ -145,7 +145,7 @@ static int wdt_npm1300_init(const struct device *dev)
return -ENODEV;
}
ret = gpio_pin_configure_dt(&config->reset_gpios, NPM1300_GPIO_WDT_RESET_ON);
ret = gpio_pin_configure_dt(&config->reset_gpios, NPM13XX_GPIO_WDT_RESET_ON);
if (ret != 0) {
return ret;
}
@ -154,15 +154,15 @@ static int wdt_npm1300_init(const struct device *dev) @@ -154,15 +154,15 @@ static int wdt_npm1300_init(const struct device *dev)
return 0;
}
#define WDT_NPM1300_DEFINE(n) \
static struct wdt_npm1300_data data##n; \
#define WDT_NPM13XX_DEFINE(n) \
static struct wdt_npm13xx_data data##n; \
\
static const struct wdt_npm1300_config config##n = { \
static const struct wdt_npm13xx_config config##n = { \
.mfd = DEVICE_DT_GET(DT_INST_PARENT(n)), \
.reset_gpios = GPIO_DT_SPEC_INST_GET_OR(n, reset_gpios, {0}), \
}; \
\
DEVICE_DT_INST_DEFINE(n, &wdt_npm1300_init, NULL, &data##n, &config##n, POST_KERNEL, \
CONFIG_WDT_NPM1300_INIT_PRIORITY, &wdt_npm1300_api);
DEVICE_DT_INST_DEFINE(n, &wdt_npm13xx_init, NULL, &data##n, &config##n, POST_KERNEL, \
CONFIG_WDT_NPM13XX_INIT_PRIORITY, &wdt_npm13xx_api);
DT_INST_FOREACH_STATUS_OKAY(WDT_NPM1300_DEFINE)
DT_INST_FOREACH_STATUS_OKAY(WDT_NPM13XX_DEFINE)

94
include/zephyr/drivers/mfd/npm13xx.h
Unescape View File

@ -11,7 +11,7 @@ extern "C" { @@ -11,7 +11,7 @@ extern "C" {
#endif
/**
* @defgroup mdf_interface_npm1300 MFD NPM1300 Interface
* @defgroup mfd_interface_npm13xx MFD NPM13XX Interface
* @ingroup mfd_interfaces
* @{
*/
@ -22,28 +22,28 @@ extern "C" { @@ -22,28 +22,28 @@ extern "C" {
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
enum mfd_npm1300_event_t {
NPM1300_EVENT_CHG_COMPLETED,
NPM1300_EVENT_CHG_ERROR,
NPM1300_EVENT_BATTERY_DETECTED,
NPM1300_EVENT_BATTERY_REMOVED,
NPM1300_EVENT_SHIPHOLD_PRESS,
NPM1300_EVENT_SHIPHOLD_RELEASE,
NPM1300_EVENT_WATCHDOG_WARN,
NPM1300_EVENT_VBUS_DETECTED,
NPM1300_EVENT_VBUS_REMOVED,
NPM1300_EVENT_GPIO0_EDGE,
NPM1300_EVENT_GPIO1_EDGE,
NPM1300_EVENT_GPIO2_EDGE,
NPM1300_EVENT_GPIO3_EDGE,
NPM1300_EVENT_GPIO4_EDGE,
NPM1300_EVENT_MAX
enum mfd_npm13xx_event_t {
NPM13XX_EVENT_CHG_COMPLETED,
NPM13XX_EVENT_CHG_ERROR,
NPM13XX_EVENT_BATTERY_DETECTED,
NPM13XX_EVENT_BATTERY_REMOVED,
NPM13XX_EVENT_SHIPHOLD_PRESS,
NPM13XX_EVENT_SHIPHOLD_RELEASE,
NPM13XX_EVENT_WATCHDOG_WARN,
NPM13XX_EVENT_VBUS_DETECTED,
NPM13XX_EVENT_VBUS_REMOVED,
NPM13XX_EVENT_GPIO0_EDGE,
NPM13XX_EVENT_GPIO1_EDGE,
NPM13XX_EVENT_GPIO2_EDGE,
NPM13XX_EVENT_GPIO3_EDGE,
NPM13XX_EVENT_GPIO4_EDGE,
NPM13XX_EVENT_MAX
};
/**
* @brief Read multiple registers from npm1300
* @brief Read multiple registers from npm13xx
*
* @param dev npm1300 mfd device
* @param dev npm13xx mfd device
* @param base Register base address (bits 15..8 of 16-bit address)
* @param offset Register offset address (bits 7..0 of 16-bit address)
* @param data Pointer to buffer for received data
@ -51,37 +51,37 @@ enum mfd_npm1300_event_t { @@ -51,37 +51,37 @@ enum mfd_npm1300_event_t {
* @retval 0 If successful
* @retval -errno In case of any bus error (see i2c_write_read_dt())
*/
int mfd_npm1300_reg_read_burst(const struct device *dev, uint8_t base, uint8_t offset, void *data,
int mfd_npm13xx_reg_read_burst(const struct device *dev, uint8_t base, uint8_t offset, void *data,
size_t len);
/**
* @brief Read single register from npm1300
* @brief Read single register from npm13xx
*
* @param dev npm1300 mfd device
* @param dev npm13xx mfd device
* @param base Register base address (bits 15..8 of 16-bit address)
* @param offset Register offset address (bits 7..0 of 16-bit address)
* @param data Pointer to buffer for received data
* @retval 0 If successful
* @retval -errno In case of any bus error (see i2c_write_read_dt())
*/
int mfd_npm1300_reg_read(const struct device *dev, uint8_t base, uint8_t offset, uint8_t *data);
int mfd_npm13xx_reg_read(const struct device *dev, uint8_t base, uint8_t offset, uint8_t *data);
/**
* @brief Write single register to npm1300
* @brief Write single register to npm13xx
*
* @param dev npm1300 mfd device
* @param dev npm13xx mfd device
* @param base Register base address (bits 15..8 of 16-bit address)
* @param offset Register offset address (bits 7..0 of 16-bit address)
* @param data data to write
* @retval 0 If successful
* @retval -errno In case of any bus error (see i2c_write_dt())
*/
int mfd_npm1300_reg_write(const struct device *dev, uint8_t base, uint8_t offset, uint8_t data);
int mfd_npm13xx_reg_write(const struct device *dev, uint8_t base, uint8_t offset, uint8_t data);
/**
* @brief Write two registers to npm1300
* @brief Write two registers to npm13xx
*
* @param dev npm1300 mfd device
* @param dev npm13xx mfd device
* @param base Register base address (bits 15..8 of 16-bit address)
* @param offset Register offset address (bits 7..0 of 16-bit address)
* @param data1 first byte of data to write
@ -89,13 +89,13 @@ int mfd_npm1300_reg_write(const struct device *dev, uint8_t base, uint8_t offset @@ -89,13 +89,13 @@ int mfd_npm1300_reg_write(const struct device *dev, uint8_t base, uint8_t offset
* @retval 0 If successful
* @retval -errno In case of any bus error (see i2c_write_dt())
*/
int mfd_npm1300_reg_write2(const struct device *dev, uint8_t base, uint8_t offset, uint8_t data1,
int mfd_npm13xx_reg_write2(const struct device *dev, uint8_t base, uint8_t offset, uint8_t data1,
uint8_t data2);
/**
* @brief Update selected bits in npm1300 register
* @brief Update selected bits in npm13xx register
*
* @param dev npm1300 mfd device
* @param dev npm13xx mfd device
* @param base Register base address (bits 15..8 of 16-bit address)
* @param offset Register offset address (bits 7..0 of 16-bit address)
* @param data data to write
@ -103,59 +103,59 @@ int mfd_npm1300_reg_write2(const struct device *dev, uint8_t base, uint8_t offse @@ -103,59 +103,59 @@ int mfd_npm1300_reg_write2(const struct device *dev, uint8_t base, uint8_t offse
* @retval 0 If successful
* @retval -errno In case of any bus error (see i2c_write_read_dt(), i2c_write_dt())
*/
int mfd_npm1300_reg_update(const struct device *dev, uint8_t base, uint8_t offset, uint8_t data,
int mfd_npm13xx_reg_update(const struct device *dev, uint8_t base, uint8_t offset, uint8_t data,
uint8_t mask);
/**
* @brief Write npm1300 timer register
* @brief Write npm13xx timer register
*
* @param dev npm1300 mfd device
* @param dev npm13xx mfd device
* @param time_ms timer value in ms
* @retval 0 If successful
* @retval -EINVAL if time value is too large
* @retval -errno In case of any bus error (see i2c_write_dt())
*/
int mfd_npm1300_set_timer(const struct device *dev, uint32_t time_ms);
int mfd_npm13xx_set_timer(const struct device *dev, uint32_t time_ms);
/**
* @brief npm1300 full power reset
* @brief npm13xx full power reset
*
* @param dev npm1300 mfd device
* @param dev npm13xx mfd device
* @retval 0 If successful
* @retval -errno In case of any bus error (see i2c_write_dt())
*/
int mfd_npm1300_reset(const struct device *dev);
int mfd_npm13xx_reset(const struct device *dev);
/**
* @brief npm1300 hibernate
* @brief npm13xx hibernate
*
* Enters low power state, and wakes after specified time
*
* @param dev npm1300 mfd device
* @param dev npm13xx mfd device
* @param time_ms timer value in ms
* @retval 0 If successful
* @retval -EINVAL if time value is too large
* @retval -errno In case of any bus error (see i2c_write_dt())
*/
int mfd_npm1300_hibernate(const struct device *dev, uint32_t time_ms);
int mfd_npm13xx_hibernate(const struct device *dev, uint32_t time_ms);
/**
* @brief Add npm1300 event callback
* @brief Add npm13xx event callback
*
* @param dev npm1300 mfd device
* @param dev npm13xx mfd device
* @param callback callback
* @return 0 on success, -errno on failure
*/
int mfd_npm1300_add_callback(const struct device *dev, struct gpio_callback *callback);
int mfd_npm13xx_add_callback(const struct device *dev, struct gpio_callback *callback);
/**
* @brief Remove npm1300 event callback
* @brief Remove npm13xx event callback
*
* @param dev npm1300 mfd device
* @param dev npm13xx mfd device
* @param callback callback
* @return 0 on success, -errno on failure
*/
int mfd_npm1300_remove_callback(const struct device *dev, struct gpio_callback *callback);
int mfd_npm13xx_remove_callback(const struct device *dev, struct gpio_callback *callback);
/** @} */

26
include/zephyr/drivers/sensor/npm13xx_charger.h
Unescape View File

@ -8,21 +8,21 @@ @@ -8,21 +8,21 @@
#include <zephyr/drivers/sensor.h>
/* NPM1300 charger specific channels */
enum sensor_channel_npm1300_charger {
SENSOR_CHAN_NPM1300_CHARGER_STATUS = SENSOR_CHAN_PRIV_START,
SENSOR_CHAN_NPM1300_CHARGER_ERROR,
SENSOR_CHAN_NPM1300_CHARGER_VBUS_STATUS,
/* NPM13XX charger specific channels */
enum sensor_channel_npm13xx_charger {
SENSOR_CHAN_NPM13XX_CHARGER_STATUS = SENSOR_CHAN_PRIV_START,
SENSOR_CHAN_NPM13XX_CHARGER_ERROR,
SENSOR_CHAN_NPM13XX_CHARGER_VBUS_STATUS,
};
/* NPM1300 charger specific attributes */
enum sensor_attribute_npm1300_charger {
SENSOR_ATTR_NPM1300_CHARGER_VBUS_PRESENT = SENSOR_ATTR_PRIV_START,
SENSOR_ATTR_NPM1300_CHARGER_VBUS_CUR_LIMIT,
SENSOR_ATTR_NPM1300_CHARGER_VBUS_OVERVLT_PROT,
SENSOR_ATTR_NPM1300_CHARGER_VBUS_UNDERVLT,
SENSOR_ATTR_NPM1300_CHARGER_VBUS_SUSPENDED,
SENSOR_ATTR_NPM1300_CHARGER_VBUS_BUSOUT,
/* NPM13XX charger specific attributes */
enum sensor_attribute_npm13xx_charger {
SENSOR_ATTR_NPM13XX_CHARGER_VBUS_PRESENT = SENSOR_ATTR_PRIV_START,
SENSOR_ATTR_NPM13XX_CHARGER_VBUS_CUR_LIMIT,
SENSOR_ATTR_NPM13XX_CHARGER_VBUS_OVERVLT_PROT,
SENSOR_ATTR_NPM13XX_CHARGER_VBUS_UNDERVLT,
SENSOR_ATTR_NPM13XX_CHARGER_VBUS_SUSPENDED,
SENSOR_ATTR_NPM13XX_CHARGER_VBUS_BUSOUT,
};
#endif

44
include/zephyr/dt-bindings/gpio/nordic-npm13xx-gpio.h
Unescape View File

@ -7,8 +7,8 @@ @@ -7,8 +7,8 @@
#define ZEPHYR_INCLUDE_DT_BINDINGS_GPIO_NORDIC_NPM13XX_GPIO_H_
/**
* @brief nPM1300-specific GPIO Flags
* @defgroup gpio_interface_npm1300 nPM1300-specific GPIO Flags
* @brief nPM13xx-specific GPIO Flags
* @defgroup gpio_interface_npm13xx nPM13xx-specific GPIO Flags
*
* The drive flags are encoded in the 8 upper bits of @ref gpio_dt_flags_t as
* follows:
@ -23,74 +23,74 @@ @@ -23,74 +23,74 @@
*/
/**
* @name nPM1300 GPIO drive strength flags
* @brief nPM1300 GPIO drive strength flags
* @name nPM13xx GPIO drive strength flags
* @brief nPM13xx GPIO drive strength flags
* @{
*/
/** @cond INTERNAL_HIDDEN */
/** Drive mode field mask */
#define NPM1300_GPIO_DRIVE_MSK 0x0100U
#define NPM13XX_GPIO_DRIVE_MSK 0x0100U
/** @endcond */
/** 1mA drive */
#define NPM1300_GPIO_DRIVE_1MA (0U << 8U)
#define NPM13XX_GPIO_DRIVE_1MA (0U << 8U)
/** 6mA drive */
#define NPM1300_GPIO_DRIVE_6MA (1U << 8U)
#define NPM13XX_GPIO_DRIVE_6MA (1U << 8U)
/** @} */
/**
* @name nPM1300 GPIO debounce flags
* @brief nPM1300 GPIO debounce flags
* @name nPM13xx GPIO debounce flags
* @brief nPM13xx GPIO debounce flags
* @{
*/
/** @cond INTERNAL_HIDDEN */
/** Debounce field mask */
#define NPM1300_GPIO_DEBOUNCE_MSK 0x0200U
#define NPM13XX_GPIO_DEBOUNCE_MSK 0x0200U
/** @endcond */
/** Normal drive */
#define NPM1300_GPIO_DEBOUNCE_OFF (0U << 9U)
#define NPM13XX_GPIO_DEBOUNCE_OFF (0U << 9U)
/** High drive */
#define NPM1300_GPIO_DEBOUNCE_ON (1U << 9U)
#define NPM13XX_GPIO_DEBOUNCE_ON (1U << 9U)
/** @} */
/**
* @name nPM1300 GPIO watchdog reset flags
* @brief nPM1300 GPIO watchdog reset flags
* @name nPM13xx GPIO watchdog reset flags
* @brief nPM13xx GPIO watchdog reset flags
* @{
*/
/** @cond INTERNAL_HIDDEN */
/** watchdog reset field mask */
#define NPM1300_GPIO_WDT_RESET_MSK 0x0400U
#define NPM13XX_GPIO_WDT_RESET_MSK 0x0400U
/** @endcond */
/** Off */
#define NPM1300_GPIO_WDT_RESET_OFF (0U << 10U)
#define NPM13XX_GPIO_WDT_RESET_OFF (0U << 10U)
/** On */
#define NPM1300_GPIO_WDT_RESET_ON (1U << 10U)
#define NPM13XX_GPIO_WDT_RESET_ON (1U << 10U)
/** @} */
/**
* @name nPM1300 GPIO power loss warning flags
* @brief nPM1300 GPIO power loss warning flags
* @name nPM13xx GPIO power loss warning flags
* @brief nPM13xx GPIO power loss warning flags
* @{
*/
/** @cond INTERNAL_HIDDEN */
/** power loss warning field mask */
#define NPM1300_GPIO_PWRLOSSWARN_MSK 0x0800U
#define NPM13XX_GPIO_PWRLOSSWARN_MSK 0x0800U
/** @endcond */
/** Off */
#define NPM1300_GPIO_PWRLOSSWARN_OFF (0U << 11U)
#define NPM13XX_GPIO_PWRLOSSWARN_OFF (0U << 11U)
/** On */
#define NPM1300_GPIO_PWRLOSSWARN_ON (1U << 11U)
#define NPM13XX_GPIO_PWRLOSSWARN_ON (1U << 11U)
/** @} */

26
include/zephyr/dt-bindings/regulator/npm13xx.h
Unescape View File

@ -8,31 +8,31 @@ @@ -8,31 +8,31 @@
#define ZEPHYR_INCLUDE_DT_BINDINGS_REGULATOR_NPM13XX_H_
/**
* @defgroup regulator_npm1300 NPM1300 Devicetree helpers.
* @defgroup regulator_npm13xx nPM13xx Devicetree helpers.
* @ingroup regulator_interface
* @{
*/
/**
* @name NPM1300 Regulator modes
* @name nPM13xx Regulator modes
* @{
*/
/* Buck modes */
#define NPM1300_BUCK_MODE_AUTO 0x00U
#define NPM1300_BUCK_MODE_PWM 0x01U
#define NPM1300_BUCK_MODE_PFM 0x04U
#define NPM13XX_BUCK_MODE_AUTO 0x00U
#define NPM13XX_BUCK_MODE_PWM 0x01U
#define NPM13XX_BUCK_MODE_PFM 0x04U
/* LDSW / LDO modes */
#define NPM1300_LDSW_MODE_LDO 0x02U
#define NPM1300_LDSW_MODE_LDSW 0x03U
#define NPM13XX_LDSW_MODE_LDO 0x02U
#define NPM13XX_LDSW_MODE_LDSW 0x03U
/* GPIO control configuration */
#define NPM1300_GPIO_CHAN_NONE 0x00U
#define NPM1300_GPIO_CHAN_0 0x01U
#define NPM1300_GPIO_CHAN_1 0x02U
#define NPM1300_GPIO_CHAN_2 0x03U
#define NPM1300_GPIO_CHAN_3 0x04U
#define NPM1300_GPIO_CHAN_4 0x05U
#define NPM13XX_GPIO_CHAN_NONE 0x00U
#define NPM13XX_GPIO_CHAN_0 0x01U
#define NPM13XX_GPIO_CHAN_1 0x02U
#define NPM13XX_GPIO_CHAN_2 0x03U
#define NPM13XX_GPIO_CHAN_3 0x04U
#define NPM13XX_GPIO_CHAN_4 0x05U
/** @} */

4
samples/shields/npm1300_ek/nrf52dk_nrf52832.overlay
Unescape View File

@ -26,12 +26,12 @@ @@ -26,12 +26,12 @@
};
&npm1300_ek_ldo1 {
regulator-initial-mode = <NPM1300_LDSW_MODE_LDO>;
regulator-initial-mode = <NPM13XX_LDSW_MODE_LDO>;
enable-gpio-config = <2 GPIO_ACTIVE_LOW>;
};
&npm1300_ek_ldo2 {
regulator-initial-mode = <NPM1300_LDSW_MODE_LDSW>;
regulator-initial-mode = <NPM13XX_LDSW_MODE_LDSW>;
enable-gpio-config = <2 GPIO_ACTIVE_LOW>;
};

12
samples/shields/npm1300_ek/src/main.c
Unescape View File

@ -68,9 +68,9 @@ void configure_events(void) @@ -68,9 +68,9 @@ void configure_events(void)
/* Setup callback for shiphold button press */
static struct gpio_callback event_cb;
gpio_init_callback(&event_cb, event_callback, BIT(NPM1300_EVENT_SHIPHOLD_PRESS));
gpio_init_callback(&event_cb, event_callback, BIT(NPM13XX_EVENT_SHIPHOLD_PRESS));
mfd_npm1300_add_callback(pmic, &event_cb);
mfd_npm13xx_add_callback(pmic, &event_cb);
}
void read_sensors(void)
@ -86,11 +86,11 @@ void read_sensors(void) @@ -86,11 +86,11 @@ void read_sensors(void)
sensor_channel_get(charger, SENSOR_CHAN_GAUGE_VOLTAGE, &volt);
sensor_channel_get(charger, SENSOR_CHAN_GAUGE_AVG_CURRENT, &current);
sensor_channel_get(charger, SENSOR_CHAN_GAUGE_TEMP, &temp);
sensor_channel_get(charger, (enum sensor_channel)SENSOR_CHAN_NPM1300_CHARGER_STATUS,
sensor_channel_get(charger, (enum sensor_channel)SENSOR_CHAN_NPM13XX_CHARGER_STATUS,
&status);
sensor_channel_get(charger, (enum sensor_channel)SENSOR_CHAN_NPM1300_CHARGER_ERROR, &error);
sensor_attr_get(charger, (enum sensor_channel)SENSOR_CHAN_NPM1300_CHARGER_VBUS_STATUS,
(enum sensor_attribute)SENSOR_ATTR_NPM1300_CHARGER_VBUS_PRESENT,
sensor_channel_get(charger, (enum sensor_channel)SENSOR_CHAN_NPM13XX_CHARGER_ERROR, &error);
sensor_attr_get(charger, (enum sensor_channel)SENSOR_CHAN_NPM13XX_CHARGER_VBUS_STATUS,
(enum sensor_attribute)SENSOR_ATTR_NPM13XX_CHARGER_VBUS_PRESENT,
&vbus_present);
printk("V: %d.%03d ", volt.val1, volt.val2 / 1000);

Write Preview
Loading…
Cancel
Save