michaelh/zephyr
1
0
Fork 0
Code Releases Activity

pm: device: remove usage of local states

Browse source 
The device PM subsystem already holds the device state, so there is no
need to keep duplicates inside the device. The pm_device_state_get has
been refactored to just return the device state. Note that this is still
not safe, but the same applied to the previous implementation. This
problem will be addressed later.

Signed-off-by: Gerard Marull-Paretas <gerard.marull@nordicsemi.no>
This commit is contained in:
Gerard Marull-Paretas 2021-06-04 17:41:39 +02:00 • committed by Anas Nashif
commit c2cf1ad203
48 changed files with 198 additions and 715 deletions
Download patch file Download diff file Expand all files Collapse all files

15
drivers/display/display_st7735r.c
View file

@ -63,9 +63,6 @@ struct st7735r_data {
const struct device *reset_dev;
uint16_t x_offset;
uint16_t y_offset;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
};
static void st7735r_set_lcd_margins(struct st7735r_data *data,
@ -462,10 +459,6 @@ static int st7735r_init(const struct device *dev)
}
}
#ifdef CONFIG_PM_DEVICE
data->pm_state = PM_DEVICE_STATE_ACTIVE;
#endif
data->cmd_data_dev = device_get_binding(config->cmd_data.name);
if (data->cmd_data_dev == NULL) {
LOG_ERR("Could not get GPIO port for cmd/DATA port");
@ -519,22 +512,14 @@ static int st7735r_pm_control(const struct device *dev, uint32_t ctrl_command,
if (ret < 0) {
return ret;
}
data->pm_state = PM_DEVICE_STATE_ACTIVE;
} else {
ret = st7735r_enter_sleep(data);
if (ret < 0) {
return ret;
}
data->pm_state = PM_DEVICE_STATE_LOW_POWER;
}
break;
case PM_DEVICE_STATE_GET:
*state = data->pm_state;
break;
default:
ret = -EINVAL;
}

12
drivers/display/display_st7789v.c
View file

@ -52,9 +52,6 @@ struct st7789v_data {
uint16_t width;
uint16_t x_offset;
uint16_t y_offset;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
};
#ifdef CONFIG_ST7789V_RGB565
@ -375,10 +372,6 @@ static int st7789v_init(const struct device *dev)
}
#endif
#ifdef CONFIG_PM_DEVICE
data->pm_state = PM_DEVICE_STATE_ACTIVE;
#endif
data->cmd_data_gpio = device_get_binding(
DT_INST_GPIO_LABEL(0, cmd_data_gpios));
if (data->cmd_data_gpio == NULL) {
@ -418,17 +411,12 @@ static int st7789v_pm_control(const struct device *dev, uint32_t ctrl_command,
case DEVICE_PM_SET_POWER_STATE:
if (*state == PM_DEVICE_STATE_ACTIVE) {
st7789v_exit_sleep(data);
data->pm_state = PM_DEVICE_STATE_ACTIVE;
ret = 0;
} else {
st7789v_enter_sleep(data);
data->pm_state = PM_DEVICE_STATE_LOW_POWER;
ret = 0;
}
break;
case PM_DEVICE_STATE_GET:
*state = data->pm_state;
break;
default:
ret = -EINVAL;
}

28
drivers/entropy/entropy_cc13xx_cc26xx.c
View file

@ -36,9 +36,6 @@ struct entropy_cc13xx_cc26xx_data {
Power_NotifyObj post_notify;
bool constrained;
#endif
#ifdef CONFIG_PM_DEVICE
enum device_pm_state pm_state;
#endif
};
static inline struct entropy_cc13xx_cc26xx_data *
@ -272,9 +269,11 @@ static int entropy_cc13xx_cc26xx_set_power_state(const struct device *dev,
{
struct entropy_cc13xx_cc26xx_data *data = get_dev_data(dev);
int ret = 0;
enum pm_device_state state;
if ((new_state == PM_DEVICE_STATE_ACTIVE) &&
(new_state != data->pm_state)) {
(void)pm_device_state_get(dev, &state);
if ((new_state == PM_DEVICE_STATE_ACTIVE) && (new_state != state)) {
Power_setDependency(PowerCC26XX_PERIPH_TRNG);
start_trng(data);
} else {
@ -282,12 +281,11 @@ static int entropy_cc13xx_cc26xx_set_power_state(const struct device *dev,
new_state == PM_DEVICE_STATE_SUSPEND ||
new_state == PM_DEVICE_STATE_OFF);
if (data->pm_state == PM_DEVICE_STATE_ACTIVE) {
if (state == PM_DEVICE_STATE_ACTIVE) {
stop_trng(data);
Power_releaseDependency(PowerCC26XX_PERIPH_TRNG);
}
}
data->pm_state = new_state;
return ret;
}
@ -296,19 +294,15 @@ static int entropy_cc13xx_cc26xx_pm_control(const struct device *dev,
uint32_t ctrl_command,
enum pm_device_state *state)
{
struct entropy_cc13xx_cc26xx_data *data = get_dev_data(dev);
int ret = 0;
if (ctrl_command == PM_DEVICE_STATE_SET) {
enum pm_device_state new_state = *state;
enum pm_device_state curr_state;
if (new_state != data->pm_state) {
ret = entropy_cc13xx_cc26xx_set_power_state(dev,
new_state);
(void)pm_device_state_get(dev, &curr_state);
if (*state != curr_state) {
ret = entropy_cc13xx_cc26xx_set_power_state(dev, *state);
}
} else {
__ASSERT_NO_MSG(ctrl_command == PM_DEVICE_STATE_GET);
*state = data->pm_state;
}
return ret;
@ -319,10 +313,6 @@ static int entropy_cc13xx_cc26xx_init(const struct device *dev)
{
struct entropy_cc13xx_cc26xx_data *data = get_dev_data(dev);
#ifdef CONFIG_PM_DEVICE
get_dev_data(dev)->pm_state = PM_DEVICE_STATE_ACTIVE;
#endif
/* Initialize driver data */
ring_buf_init(&data->pool, sizeof(data->data), data->data);

18
drivers/flash/spi_flash_at45.c
View file

@ -60,9 +60,6 @@ struct spi_flash_at45_data {
const struct device *spi;
struct spi_cs_control spi_cs;
struct k_sem lock;
#if IS_ENABLED(CONFIG_PM_DEVICE)
enum pm_device_state pm_state;
#endif
};
struct spi_flash_at45_config {
@ -631,15 +628,15 @@ static int spi_flash_at45_pm_control(const struct device *dev,
uint32_t ctrl_command,
enum pm_device_state *state)
{
struct spi_flash_at45_data *dev_data = get_dev_data(dev);
const struct spi_flash_at45_config *dev_config = get_dev_config(dev);
int err = 0;
if (ctrl_command == PM_DEVICE_STATE_SET) {
enum pm_device_state new_state = *state;
enum pm_device_state curr_state;
if (new_state != dev_data->pm_state) {
switch (new_state) {
(void)pm_device_state_get(dev, &curr_state);
if (*state != curr_state) {
switch (*state) {
case PM_DEVICE_STATE_ACTIVE:
acquire(dev);
power_down_op(dev, CMD_EXIT_DPD,
@ -661,12 +658,7 @@ static int spi_flash_at45_pm_control(const struct device *dev,
default:
return -ENOTSUP;
}
dev_data->pm_state = new_state;
}
} else {
__ASSERT_NO_MSG(ctrl_command == PM_DEVICE_STATE_GET);
*state = dev_data->pm_state;
}
return err;
@ -715,8 +707,6 @@ static const struct flash_driver_api spi_flash_at45_api = {
}; \
static struct spi_flash_at45_data inst_##idx##_data = { \
.lock = Z_SEM_INITIALIZER(inst_##idx##_data.lock, 1, 1), \
IF_ENABLED(CONFIG_PM_DEVICE, ( \
.pm_state = PM_DEVICE_STATE_ACTIVE)) \
}; \
INST_RESET_GPIO_SPEC(idx) \
INST_WP_GPIO_SPEC(idx) \

25
drivers/gpio/gpio_dw.c
View file

@ -425,33 +425,15 @@ static inline int gpio_dw_manage_callback(const struct device *port,
}
#ifdef CONFIG_PM_DEVICE
static void gpio_dw_set_power_state(const struct device *port,
uint32_t power_state)
{
struct gpio_dw_runtime *context = port->data;
context->device_power_state = power_state;
}
static uint32_t gpio_dw_get_power_state(const struct device *port)
{
struct gpio_dw_runtime *context = port->data;
return context->device_power_state;
}
static inline int gpio_dw_suspend_port(const struct device *port)
{
gpio_dw_clock_off(port);
gpio_dw_set_power_state(port, PM_DEVICE_STATE_SUSPEND);
return 0;
}
static inline int gpio_dw_resume_from_suspend_port(const struct device *port)
{
gpio_dw_clock_on(port);
gpio_dw_set_power_state(port, PM_DEVICE_STATE_ACTIVE);
return 0;
}
@ -471,15 +453,10 @@ static int gpio_dw_device_ctrl(const struct device *port,
} else if (*state == PM_DEVICE_STATE_ACTIVE) {
ret = gpio_dw_resume_from_suspend_port(port);
}
} else if (ctrl_command == PM_DEVICE_STATE_GET) {
*state = gpio_dw_get_power_state(port);
}
return ret;
}
#else
#define gpio_dw_set_power_state(...)
#endif
#define gpio_dw_unmask_int(...)
@ -541,8 +518,6 @@ static int gpio_dw_initialize(const struct device *port)
config->config_func(port);
}
gpio_dw_set_power_state(port, PM_DEVICE_STATE_ACTIVE);
return 0;
}

3
drivers/gpio/gpio_dw.h
View file

@ -41,9 +41,6 @@ struct gpio_dw_runtime {
const struct device *clock;
#endif
sys_slist_t callbacks;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state device_power_state;
#endif
};
#ifdef __cplusplus

35
drivers/gpio/gpio_stm32.c
View file

@ -451,9 +451,6 @@ static int gpio_stm32_port_toggle_bits(const struct device *dev,
static int gpio_stm32_config(const struct device *dev,
gpio_pin_t pin, gpio_flags_t flags)
{
#ifdef CONFIG_PM_DEVICE_RUNTIME
struct gpio_stm32_data *data = dev->data;
#endif /* CONFIG_PM_DEVICE_RUNTIME */
int err = 0;
int pincfg;
@ -466,8 +463,11 @@ static int gpio_stm32_config(const struct device *dev,
}
#ifdef CONFIG_PM_DEVICE_RUNTIME
enum pm_device_state state;
(void)pm_device_state_get(dev, &state);
/* Enable device clock before configuration (requires bank writes) */
if (data->power_state != PM_DEVICE_STATE_ACTIVE) {
if (state != PM_DEVICE_STATE_ACTIVE) {
err = pm_device_get(dev);
if (err < 0) {
return err;
@ -574,17 +574,9 @@ static const struct gpio_driver_api gpio_stm32_driver = {
};
#ifdef CONFIG_PM_DEVICE
static uint32_t gpio_stm32_get_power_state(const struct device *dev)
{
struct gpio_stm32_data *data = dev->data;
return data->power_state;
}
static int gpio_stm32_set_power_state(const struct device *dev,
enum pm_device_state new_state)
{
struct gpio_stm32_data *data = dev->data;
int ret = 0;
if (new_state == PM_DEVICE_STATE_ACTIVE) {
@ -599,8 +591,6 @@ static int gpio_stm32_set_power_state(const struct device *dev,
return ret;
}
data->power_state = new_state;
return 0;
}
@ -608,20 +598,17 @@ static int gpio_stm32_pm_device_ctrl(const struct device *dev,
uint32_t ctrl_command,
enum pm_device_state *state)
{
struct gpio_stm32_data *data = dev->data;
uint32_t new_state;
int ret = 0;
switch (ctrl_command) {
case PM_DEVICE_STATE_SET:
new_state = *state;
if (new_state != data->power_state) {
ret = gpio_stm32_set_power_state(dev, new_state);
enum pm_device_state curr_state;
(void)pm_device_state_get(dev, &curr_state);
if (*state != curr_state) {
ret = gpio_stm32_set_power_state(dev, *state);
}
break;
case PM_DEVICE_STATE_GET:
*state = gpio_stm32_get_power_state(dev);
break;
default:
ret = -EINVAL;
@ -657,14 +644,10 @@ static int gpio_stm32_init(const struct device *dev)
#endif
#ifdef CONFIG_PM_DEVICE_RUNTIME
data->power_state = PM_DEVICE_STATE_OFF;
pm_device_enable(dev);
return 0;
#else
#ifdef CONFIG_PM_DEVICE
data->power_state = PM_DEVICE_STATE_ACTIVE;
#endif
return gpio_stm32_clock_request(dev, true);
#endif
}

4
drivers/gpio/gpio_stm32.h
View file

@ -229,10 +229,6 @@ struct gpio_stm32_data {
const struct device *dev;
/* user ISR cb */
sys_slist_t cb;
#ifdef CONFIG_PM_DEVICE
/* device power state */
enum pm_device_state power_state;
#endif
};
/**

25
drivers/i2c/i2c_cc13xx_cc26xx.c
View file

@ -32,9 +32,6 @@ struct i2c_cc13xx_cc26xx_data {
Power_NotifyObj postNotify;
uint32_t dev_config;
#endif
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
};
struct i2c_cc13xx_cc26xx_config {
@ -333,9 +330,11 @@ static int i2c_cc13xx_cc26xx_set_power_state(const struct device *dev,
enum pm_device_state new_state)
{
int ret = 0;
enum pm_device_state state;
if ((new_state == PM_DEVICE_STATE_ACTIVE) &&
(new_state != get_dev_data(dev)->pm_state)) {
(void)pm_device_state_get(dev, &state);
if ((new_state == PM_DEVICE_STATE_ACTIVE) && (new_state != state) {
Power_setDependency(PowerCC26XX_PERIPH_I2C0);
IOCPinTypeI2c(get_dev_config(dev)->base,
get_dev_config(dev)->sda_pin,
@ -344,14 +343,13 @@ static int i2c_cc13xx_cc26xx_set_power_state(const struct device *dev,
get_dev_data(dev)->dev_config);
if (ret == 0) {
I2CMasterIntEnable(get_dev_config(dev)->base);
get_dev_data(dev)->pm_state = new_state;
}
} else {
__ASSERT_NO_MSG(new_state == PM_DEVICE_STATE_LOW_POWER ||
new_state == PM_DEVICE_STATE_SUSPEND ||
new_state == PM_DEVICE_STATE_OFF);
if (get_dev_data(dev)->pm_state == PM_DEVICE_STATE_ACTIVE) {
if (state == PM_DEVICE_STATE_ACTIVE) {
I2CMasterIntDisable(get_dev_config(dev)->base);
I2CMasterDisable(get_dev_config(dev)->base);
/* Reset pin type to default GPIO configuration */
@ -360,7 +358,6 @@ static int i2c_cc13xx_cc26xx_set_power_state(const struct device *dev,
IOCPortConfigureSet(get_dev_config(dev)->sda_pin,
IOC_PORT_GPIO, IOC_STD_OUTPUT);
Power_releaseDependency(PowerCC26XX_PERIPH_I2C0);
get_dev_data(dev)->pm_state = new_state;
}
}
@ -374,15 +371,13 @@ static int i2c_cc13xx_cc26xx_pm_control(const struct device *dev,
int ret = 0;
if (ctrl_command == PM_DEVICE_STATE_SET) {
enum pm_device_state new_state = *state;
enum pm_device_state curr_state;
if (new_state != get_dev_data(dev)->pm_state) {
(void)pm_device_state_get(dev, &curr_state);
if (*state != curr_state) {
ret = i2c_cc13xx_cc26xx_set_power_state(dev,
new_state);
}
} else {
__ASSERT_NO_MSG(ctrl_command == PM_DEVICE_STATE_GET);
*state = get_dev_data(dev)->pm_state;
}
return ret;
@ -394,10 +389,6 @@ static int i2c_cc13xx_cc26xx_init(const struct device *dev)
uint32_t cfg;
int err;
#ifdef CONFIG_PM_DEVICE
get_dev_data(dev)->pm_state = PM_DEVICE_STATE_ACTIVE;
#endif
#ifdef CONFIG_PM
/* Set Power dependencies & constraints */
Power_setDependency(PowerCC26XX_PERIPH_I2C0);

22
drivers/i2c/i2c_nrfx_twi.c
View file

@ -19,9 +19,6 @@ struct i2c_nrfx_twi_data {
struct k_sem completion_sync;
volatile nrfx_err_t res;
uint32_t dev_config;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
};
struct i2c_nrfx_twi_config {
@ -214,9 +211,6 @@ static int init_twi(const struct device *dev)
dev->name);
return -EBUSY;
}
#ifdef CONFIG_PM_DEVICE
get_dev_data(dev)->pm_state = PM_DEVICE_STATE_ACTIVE;
#endif
return 0;
}
@ -227,13 +221,13 @@ static int twi_nrfx_pm_control(const struct device *dev,
enum pm_device_state *state)
{
int ret = 0;
enum pm_device_state pm_current_state = get_dev_data(dev)->pm_state;
if (ctrl_command == PM_DEVICE_STATE_SET) {
enum pm_device_state new_state = *state;
enum pm_device_state curr_state;
if (new_state != pm_current_state) {
switch (new_state) {
(void)pm_device_state_get(dev, &curr_state);
if (*state != curr_state) {
switch (*state) {
case PM_DEVICE_STATE_ACTIVE:
init_twi(dev);
if (get_dev_data(dev)->dev_config) {
@ -246,7 +240,7 @@ static int twi_nrfx_pm_control(const struct device *dev,
case PM_DEVICE_STATE_LOW_POWER:
case PM_DEVICE_STATE_SUSPEND:
case PM_DEVICE_STATE_OFF:
if (pm_current_state == PM_DEVICE_STATE_ACTIVE) {
if (curr_state == PM_DEVICE_STATE_ACTIVE) {
nrfx_twi_uninit(&get_dev_config(dev)->twi);
}
break;
@ -254,13 +248,7 @@ static int twi_nrfx_pm_control(const struct device *dev,
default:
ret = -ENOTSUP;
}
if (!ret) {
get_dev_data(dev)->pm_state = new_state;
}
}
} else {
__ASSERT_NO_MSG(ctrl_command == PM_DEVICE_STATE_GET);
*state = get_dev_data(dev)->pm_state;
}
return ret;

23
drivers/i2c/i2c_nrfx_twim.c
View file

@ -22,9 +22,6 @@ struct i2c_nrfx_twim_data {
uint32_t dev_config;
uint16_t concat_buf_size;
uint8_t *concat_buf;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
};
struct i2c_nrfx_twim_config {
@ -253,10 +250,6 @@ static int init_twim(const struct device *dev)
return -EBUSY;
}
#ifdef CONFIG_PM_DEVICE
get_dev_data(dev)->pm_state = PM_DEVICE_STATE_ACTIVE;
#endif
return 0;
}
@ -266,13 +259,13 @@ static int twim_nrfx_pm_control(const struct device *dev,
enum pm_device_state *state)
{
int ret = 0;
enum pm_device_state pm_current_state = get_dev_data(dev)->pm_state;
if (ctrl_command == PM_DEVICE_STATE_SET) {
enum pm_device_state new_state = *state;
enum pm_device_state curr_state;
if (new_state != pm_current_state) {
switch (new_state) {
(void)pm_device_state_get(dev, &curr_state);
if (*state != curr_state) {
switch (*state) {
case PM_DEVICE_STATE_ACTIVE:
init_twim(dev);
if (get_dev_data(dev)->dev_config) {
@ -285,7 +278,7 @@ static int twim_nrfx_pm_control(const struct device *dev,
case PM_DEVICE_STATE_LOW_POWER:
case PM_DEVICE_STATE_SUSPEND:
case PM_DEVICE_STATE_OFF:
if (pm_current_state != PM_DEVICE_STATE_ACTIVE) {
if (curr_state != PM_DEVICE_STATE_ACTIVE) {
break;
}
nrfx_twim_uninit(&get_dev_config(dev)->twim);
@ -294,13 +287,7 @@ static int twim_nrfx_pm_control(const struct device *dev,
default:
ret = -ENOTSUP;
}
if (!ret) {
get_dev_data(dev)->pm_state = new_state;
}
}
} else {
__ASSERT_NO_MSG(ctrl_command == PM_DEVICE_STATE_GET);
*state = get_dev_data(dev)->pm_state;
}
return ret;

20
drivers/interrupt_controller/intc_arcv2_irq_unit.c
View file

@ -32,8 +32,6 @@ extern void *_VectorTable;
#define _ARC_V2_IRQ_VECT_BASE _ARC_V2_IRQ_VECT_BASE_S
#endif
static enum pm_device_state _arc_v2_irq_unit_device_power_state =
PM_DEVICE_STATE_ACTIVE;
struct arc_v2_irq_unit_ctx {
uint32_t irq_ctrl; /* Interrupt Context Saving Control Register. */
uint32_t irq_vect_base; /* Interrupt Vector Base. */
@ -121,8 +119,6 @@ static int arc_v2_irq_unit_suspend(const struct device *dev)
ctx.irq_ctrl = z_arc_v2_aux_reg_read(_ARC_V2_AUX_IRQ_CTRL);
ctx.irq_vect_base = z_arc_v2_aux_reg_read(_ARC_V2_IRQ_VECT_BASE);
_arc_v2_irq_unit_device_power_state = PM_DEVICE_STATE_SUSPEND;
return 0;
}
@ -167,23 +163,9 @@ static int arc_v2_irq_unit_resume(const struct device *dev)
#endif
z_arc_v2_aux_reg_write(_ARC_V2_IRQ_VECT_BASE, ctx.irq_vect_base);
_arc_v2_irq_unit_device_power_state = PM_DEVICE_STATE_ACTIVE;
return 0;
}
/*
* @brief Get the power state of interrupt unit
*
* @return the power state of interrupt unit
*/
static enum pm_device_state arc_v2_irq_unit_get_state(const struct device *dev)
{
ARG_UNUSED(dev);
return _arc_v2_irq_unit_device_power_state;
}
/*
* @brief Implement the driver control of interrupt unit
*
@ -205,8 +187,6 @@ static int arc_v2_irq_unit_device_ctrl(const struct device *dev,
} else if (*state == PM_DEVICE_STATE_ACTIVE) {
ret = arc_v2_irq_unit_resume(dev);
}
} else if (ctrl_command == PM_DEVICE_STATE_GET) {
*state = arc_v2_irq_unit_get_state(dev);
}
arch_irq_unlock(key);

16
drivers/interrupt_controller/intc_ioapic.c
View file

@ -105,10 +105,6 @@ static __pinned_bss uint32_t ioapic_rtes;
__pinned_bss
uint32_t ioapic_suspend_buf[SUSPEND_BITS_REQD / 32] = {0};
__pinned_data
static uint32_t ioapic_device_power_state = PM_DEVICE_STATE_ACTIVE;
#endif
static uint32_t __IoApicGet(int32_t offset);
@ -320,12 +316,14 @@ static int ioapic_device_ctrl(const struct device *dev,
int ret = 0;
if (ctrl_command == PM_DEVICE_STATE_SET) {
enum pm_device_state curr_state;
(void)pm_device_state_get(dev, &curr_state);
switch (*state) {
case PM_DEVICE_STATE_LOW_POWER:
break;
case PM_DEVICE_STATE_ACTIVE:
if (ioapic_device_power_state !=
PM_DEVICE_STATE_LOW_POWER) {
if (curr_state != PM_DEVICE_STATE_LOW_POWER) {
ret = ioapic_resume_from_suspend(dev);
}
break;
@ -337,12 +335,6 @@ static int ioapic_device_ctrl(const struct device *dev,
default:
ret = -ENOTSUP;
}
if (ret == 0) {
ioapic_device_power_state = *state;
}
} else if (ctrl_command == PM_DEVICE_STATE_GET) {
*state = ioapic_device_power_state;
}
return ret;

8
drivers/interrupt_controller/intc_loapic.c
View file

@ -64,9 +64,6 @@
#include <pm/device.h>
__pinned_bss
uint32_t loapic_suspend_buf[LOPIC_SUSPEND_BITS_REQD / 32] = {0};
__pinned_data
static uint32_t loapic_device_power_state = PM_DEVICE_STATE_ACTIVE;
#endif
#ifdef DEVICE_MMIO_IS_IN_RAM
@ -372,7 +369,7 @@ static int loapic_suspend(const struct device *port)
}
}
}
loapic_device_power_state = PM_DEVICE_STATE_SUSPEND;
return 0;
}
@ -402,7 +399,6 @@ int loapic_resume(const struct device *port)
}
}
}
loapic_device_power_state = PM_DEVICE_STATE_ACTIVE;
return 0;
}
@ -424,8 +420,6 @@ static int loapic_device_ctrl(const struct device *port,
} else if (*state == PM_DEVICE_STATE_ACTIVE) {
ret = loapic_resume(port);
}
} else if (ctrl_command == PM_DEVICE_STATE_GET) {
*state = loapic_device_power_state;
}
return ret;

52
drivers/led/led_pwm.c
View file

@ -21,7 +21,6 @@
LOG_MODULE_REGISTER(led_pwm, CONFIG_LED_LOG_LEVEL);
#define DEV_CFG(dev) ((const struct led_pwm_config *) ((dev)->config))
#define DEV_DATA(dev) ((struct led_pwm_data *) ((dev)->data))
struct led_pwm {
const struct device *dev;
@ -35,12 +34,6 @@ struct led_pwm_config {
const struct led_pwm *led;
};
struct led_pwm_data {
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
};
static int led_pwm_blink(const struct device *dev, uint32_t led,
uint32_t delay_on, uint32_t delay_off)
{
@ -117,43 +110,20 @@ static int led_pwm_init(const struct device *dev)
}
}
#ifdef CONFIG_PM_DEVICE
struct led_pwm_data *data = DEV_DATA(dev);
data->pm_state = PM_DEVICE_STATE_ACTIVE;
#endif
return 0;
}
#ifdef CONFIG_PM_DEVICE
static int led_pwm_pm_get_state(const struct device *dev,
enum pm_device_state *state)
{
struct led_pwm_data *data = DEV_DATA(dev);
unsigned int key = irq_lock();
*state = data->pm_state;
irq_unlock(key);
return 0;
}
static int led_pwm_pm_set_state(const struct device *dev,
enum pm_device_state new_state)
{
const struct led_pwm_config *config = DEV_CFG(dev);
struct led_pwm_data *data = DEV_DATA(dev);
enum pm_device_state old_state;
unsigned int key;
enum pm_device_state curr_state;
key = irq_lock();
old_state = data->pm_state;
irq_unlock(key);
(void)pm_device_state_get(dev, &curr_state);
if (old_state == new_state) {
/* leave unchanged */
if (curr_state == new_state) {
return 0;
}
@ -169,11 +139,6 @@ static int led_pwm_pm_set_state(const struct device *dev,
}
}
/* record the new state */
key = irq_lock();
data->pm_state = new_state;
irq_unlock(key);
return 0;
}
@ -183,10 +148,6 @@ static int led_pwm_pm_control(const struct device *dev, uint32_t ctrl_command,
int err;
switch (ctrl_command) {
case PM_DEVICE_STATE_GET:
err = led_pwm_pm_get_state(dev, state);
break;
case PM_DEVICE_STATE_SET:
err = led_pwm_pm_set_state(dev, *state);
break;
@ -228,11 +189,8 @@ static const struct led_pwm_config led_pwm_config_##id = { \
.led = led_pwm_##id, \
}; \
\
static struct led_pwm_data led_pwm_data_##id; \
\
DEVICE_DT_INST_DEFINE(id, &led_pwm_init, led_pwm_pm_control, \
&led_pwm_data_##id, &led_pwm_config_##id, \
POST_KERNEL, CONFIG_LED_INIT_PRIORITY, \
&led_pwm_api);
NULL, &led_pwm_config_##id, POST_KERNEL, \
CONFIG_LED_INIT_PRIORITY, &led_pwm_api);
DT_INST_FOREACH_STATUS_OKAY(LED_PWM_DEVICE)

33
drivers/pwm/pwm_nrfx.c
View file

@ -319,40 +319,29 @@ static int pwm_nrfx_set_power_state(enum pm_device_state new_state,
static int pwm_nrfx_pm_control(const struct device *dev,
uint32_t ctrl_command,
enum pm_device_state *state,
enum pm_device_state *current_state)
enum pm_device_state *state)
{
int err = 0;
if (ctrl_command == PM_DEVICE_STATE_SET) {
enum pm_device_state new_state = *state;
enum pm_device_state curr_state;
if (new_state != (*current_state)) {
err = pwm_nrfx_set_power_state(new_state,
*current_state,
(void)pm_device_state_get(dev, &curr_state);
if (*state != current_state) {
err = pwm_nrfx_set_power_state(*state, current_state,
dev);
if (!err) {
*current_state = new_state;
}
}
} else {
__ASSERT_NO_MSG(ctrl_command == PM_DEVICE_STATE_GET);
*state = *current_state;
}
return err;
}
#define PWM_NRFX_PM_CONTROL(idx) \
static int pwm_##idx##_nrfx_pm_control(const struct device *dev, \
uint32_t ctrl_command, \
enum pm_device_state *state) \
{ \
static enum pm_device_state current_state = PM_DEVICE_STATE_ACTIVE; \
int ret = 0; \
ret = pwm_nrfx_pm_control(dev, ctrl_command, state, \
&current_state); \
return ret; \
#define PWM_NRFX_PM_CONTROL(idx) \
static int pwm_##idx##_nrfx_pm_control(const struct device *dev, \
uint32_t ctrl_command, \
enum pm_device_state *state) \
{ \
return pwm_nrfx_pm_control(dev, ctrl_command, state) \
}
#else

2
drivers/sensor/apds9960/apds9960.c
View file

@ -439,8 +439,6 @@ static int apds9960_device_ctrl(const struct device *dev,
}
}
} else if (ctrl_command == PM_DEVICE_STATE_GET) {
*state = PM_DEVICE_STATE_ACTIVE;
}
return ret;

30
drivers/sensor/bme280/bme280.c
View file

@ -55,10 +55,6 @@ struct bme280_data {
int32_t t_fine;
uint8_t chip_id;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state; /* Current power state */
#endif
};
struct bme280_config {
@ -199,8 +195,10 @@ static int bme280_sample_fetch(const struct device *dev,
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
#ifdef CONFIG_PM_DEVICE
enum pm_device_state state;
(void)pm_device_state_get(dev, &state);
/* Do not allow sample fetching from OFF state */
if (data->pm_state == PM_DEVICE_STATE_OFF)
if (state == PM_DEVICE_STATE_OFF)
return -EIO;
#endif
@ -407,10 +405,6 @@ static int bme280_chip_init(const struct device *dev)
/* Wait for the sensor to be ready */
k_sleep(K_MSEC(1));
#ifdef CONFIG_PM_DEVICE
/* Set power state to ACTIVE */
data->pm_state = PM_DEVICE_STATE_ACTIVE;
#endif
LOG_DBG("\"%s\" OK", dev->name);
return 0;
}
@ -419,16 +413,17 @@ static int bme280_chip_init(const struct device *dev)
int bme280_pm_ctrl(const struct device *dev, uint32_t ctrl_command,
enum pm_device_state *state)
{
struct bme280_data *data = to_data(dev);
int ret = 0;
/* Set power state */
if (ctrl_command == PM_DEVICE_STATE_SET) {
if (*state != data->pm_state) {
enum pm_device_state curr_state;
pm_device_state_get(dev, &curr_state);
if (*state != curr_state) {
/* Switching from OFF to any */
if (data->pm_state == PM_DEVICE_STATE_OFF) {
if (curr_state == PM_DEVICE_STATE_OFF) {
/* Re-initialize the chip */
ret = bme280_chip_init(dev);
@ -445,17 +440,8 @@ int bme280_pm_ctrl(const struct device *dev, uint32_t ctrl_command,
LOG_DBG("CTRL_MEAS write failed: %d",
ret);
}
/* Store the new state */
if (!ret)
data->pm_state = *state;
}
}
/* Get power state */
else {
__ASSERT_NO_MSG(ctrl_command == PM_DEVICE_STATE_GET);
*state = data->pm_state;
}
return ret;
}

31
drivers/sensor/bmp388/bmp388.c
View file

@ -311,9 +311,10 @@ static int bmp388_attr_set(const struct device *dev,
int ret;
#ifdef CONFIG_PM_DEVICE
struct bmp388_data *data = DEV_DATA(dev);
enum pm_device_state state;
if (data->device_power_state != PM_DEVICE_STATE_ACTIVE) {
(void)pm_device_state_get(dev, &state);
if (state != PM_DEVICE_STATE_ACTIVE) {
return -EBUSY;
}
#endif
@ -348,7 +349,10 @@ static int bmp388_sample_fetch(const struct device *dev,
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
#ifdef CONFIG_PM_DEVICE
if (bmp388->device_power_state != PM_DEVICE_STATE_ACTIVE) {
enum pm_device_state state;
(void)pm_device_state_get(dev, &state);
if (state != PM_DEVICE_STATE_ACTIVE) {
return -EBUSY;
}
#endif
@ -549,10 +553,10 @@ static int bmp388_set_power_state(const struct device *dev,
enum pm_device_state power_state)
{
uint8_t reg_val;
enum pm_device_state state;
struct bmp388_data *data = DEV_DATA(dev);
if (data->device_power_state == power_state) {
(void)pm_device_state_get(dev, &state);
if (state == power_state) {
/* We are already in the desired state. */
return 0;
}
@ -574,18 +578,9 @@ static int bmp388_set_power_state(const struct device *dev,
return -EIO;
}
data->device_power_state = power_state;
return 0;
}
static uint32_t bmp388_get_power_state(const struct device *dev)
{
struct bmp388_data *ctx = DEV_DATA(dev);
return ctx->device_power_state;
}
static int bmp388_device_ctrl(
const struct device *dev,
uint32_t ctrl_command,
@ -595,8 +590,6 @@ static int bmp388_device_ctrl(
if (ctrl_command == PM_DEVICE_STATE_SET) {
ret = bmp388_set_power_state(dev, *state);
} else if (ctrl_command == PM_DEVICE_STATE_GET) {
*state = bmp388_get_power_state(dev);
}
return ret;
@ -666,10 +659,6 @@ static int bmp388_init(const struct device *dev)
return -ENODEV;
}
#ifdef CONFIG_PM_DEVICE
bmp388->device_power_state = PM_DEVICE_STATE_ACTIVE;
#endif
/* Read calibration data */
if (bmp388_get_calibration_data(dev) < 0) {
LOG_ERR("Failed to read calibration data.");

4
drivers/sensor/bmp388/bmp388.h
View file

@ -163,10 +163,6 @@ struct bmp388_data {
uint8_t osr_temp;
struct bmp388_cal_data cal;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state device_power_state;
#endif
#if defined(CONFIG_BMP388_TRIGGER)
struct gpio_callback gpio_cb;
#endif

5
drivers/sensor/bmp388/bmp388_trigger.c
View file

@ -92,7 +92,10 @@ int bmp388_trigger_set(
struct bmp388_data *data = DEV_DATA(dev);
#ifdef CONFIG_PM_DEVICE
if (data->device_power_state != PM_DEVICE_STATE_ACTIVE) {
enum pm_device_state state;
(void)pm_device_state_get(dev, &state);
if (state != PM_DEVICE_STATE_ACTIVE) {
return -EBUSY;
}
#endif

5
drivers/sensor/bq274xx/bq274xx.c
View file

@ -691,8 +691,6 @@ static int bq274xx_enter_shutdown_mode(struct bq274xx_data *data)
return status;
}
data->pm_state = PM_DEVICE_STATE_OFF;
return 0;
}
@ -756,9 +754,6 @@ static int bq274xx_pm_control(const struct device *dev, uint32_t ctrl_command,
ret = -ENOTSUP;
}
break;
case PM_DEVICE_STATE_GET:
*state = data->pm_state;
break;
default:
ret = -EINVAL;
}

3
drivers/sensor/bq274xx/bq274xx.h
View file

@ -96,9 +96,6 @@ struct bq274xx_data {
uint16_t remaining_charge_capacity;
uint16_t nom_avail_capacity;
uint16_t full_avail_capacity;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
};
struct bq274xx_config {

33
drivers/sensor/fdc2x1x/fdc2x1x.c
View file

@ -420,13 +420,6 @@ static int fdc2x1x_reset(const struct device *dev)
FDC2X1X_RESET_DEV_MSK,
FDC2X1X_RESET_DEV_SET(1));
/* device defaults to sleep mode */
#ifdef CONFIG_PM_DEVICE
struct fdc2x1x_data *data = dev->data;
data->pm_state = PM_DEVICE_STATE_LOW_POWER;
#endif
return ret;
}
@ -494,10 +487,13 @@ static int fdc2x1x_set_pm_state(const struct device *dev,
int ret;
struct fdc2x1x_data *data = dev->data;
const struct fdc2x1x_config *cfg = dev->config;
enum pm_device_state curr_state;
(void)pm_device_state_get(dev, &curr_state);
switch (pm_state) {
case PM_DEVICE_STATE_ACTIVE:
if (data->pm_state == PM_DEVICE_STATE_OFF) {
if (curr_state == PM_DEVICE_STATE_OFF) {
ret = fdc2x1x_set_shutdown(dev, false);
if (ret) {
return ret;
@ -508,11 +504,10 @@ static int fdc2x1x_set_pm_state(const struct device *dev,
if (ret) {
return ret;
}
data->pm_state = PM_DEVICE_STATE_ACTIVE;
break;
case PM_DEVICE_STATE_LOW_POWER:
if (data->pm_state == PM_DEVICE_STATE_OFF) {
if (curr_state == PM_DEVICE_STATE_OFF) {
ret = fdc2x1x_set_shutdown(dev, false);
if (ret) {
return ret;
@ -522,13 +517,11 @@ static int fdc2x1x_set_pm_state(const struct device *dev,
if (ret) {
return ret;
}
data->pm_state = PM_DEVICE_STATE_LOW_POWER;
break;
case PM_DEVICE_STATE_OFF:
if (cfg->sd_gpio->name) {
ret = fdc2x1x_set_shutdown(dev, true);
data->pm_state = PM_DEVICE_STATE_OFF;
} else {
LOG_ERR("SD pin not defined");
ret = -EINVAL;
@ -549,7 +542,10 @@ static int fdc2x1x_device_pm_ctrl(const struct device *dev,
int ret = 0;
if (ctrl_command == PM_DEVICE_STATE_SET) {
if (*state != data->pm_state) {
enum pm_device_state curr_state;
(void)pm_device_state_get(dev, &curr_state);
if (*state != curr_state) {
switch (*state) {
case PM_DEVICE_STATE_ACTIVE:
case PM_DEVICE_STATE_LOW_POWER:
@ -561,8 +557,6 @@ static int fdc2x1x_device_pm_ctrl(const struct device *dev,
ret = -EINVAL;
}
}
} else if (ctrl_command == PM_DEVICE_STATE_GET) {
*state = data->pm_state;
}
return ret;
@ -648,8 +642,10 @@ static int fdc2x1x_sample_fetch(const struct device *dev,
{
#ifdef CONFIG_PM_DEVICE
struct fdc2x1x_data *data = dev->data;
enum pm_device_state state;
if (data->pm_state != PM_DEVICE_STATE_ACTIVE) {
(void)pm_device_state_get(dev, &state);
if (state != PM_DEVICE_STATE_ACTIVE) {
LOG_ERR("Sample fetch failed, device is not in active mode");
return -ENXIO;
}
@ -984,11 +980,6 @@ static int fdc2x1x_init(const struct device *dev)
if (fdc2x1x_set_op_mode(dev, FDC2X1X_ACTIVE_MODE) < 0) {
return -EIO;
}
#ifdef CONFIG_PM_DEVICE
struct fdc2x1x_data *data = dev->data;
data->pm_state = FDC2X1X_ACTIVE_MODE;
#endif
#ifdef CONFIG_FDC2X1X_TRIGGER
if (fdc2x1x_init_interrupt(dev) < 0) {

4
drivers/sensor/fdc2x1x/fdc2x1x.h
View file

@ -149,10 +149,6 @@ enum fdc2x1x_op_mode {
struct fdc2x1x_data {
bool fdc221x;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
#ifdef CONFIG_FDC2X1X_TRIGGER
struct gpio_callback gpio_cb;
uint16_t int_config;

5
drivers/sensor/fdc2x1x/fdc2x1x_trigger.c
View file

@ -24,8 +24,11 @@ static void fdc2x1x_thread_cb(const struct device *dev)
uint16_t status;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state state;
/* INTB asserts after exiting shutdown mode. Drop this interrupt */
if (drv_data->pm_state == PM_DEVICE_STATE_OFF) {
(void)pm_device_state_get(dev, &state);
if (state == PM_DEVICE_STATE_OFF) {
return;
}
#endif

19
drivers/sensor/lis2mdl/lis2mdl.c
View file

@ -429,10 +429,6 @@ static int lis2mdl_init(const struct device *dev)
}
}
#ifdef CONFIG_PM_DEVICE
lis2mdl->power_state = PM_DEVICE_STATE_ACTIVE;
#endif
#ifdef CONFIG_LIS2MDL_TRIGGER
if (cfg->trig_enabled) {
if (lis2mdl_init_interrupt(dev) < 0) {
@ -464,7 +460,6 @@ static int lis2mdl_set_power_state(struct lis2mdl_data *lis2mdl,
if (status) {
LOG_ERR("Power up failed");
}
lis2mdl->power_state = PM_DEVICE_STATE_ACTIVE;
LOG_DBG("State changed to active");
} else {
__ASSERT_NO_MSG(new_state == PM_DEVICE_STATE_LOW_POWER ||
@ -474,7 +469,6 @@ static int lis2mdl_set_power_state(struct lis2mdl_data *lis2mdl,
if (status) {
LOG_ERR("Power down failed");
}
lis2mdl->power_state = new_state;
LOG_DBG("State changed to inactive");
}
@ -486,21 +480,18 @@ static int lis2mdl_pm_control(const struct device *dev, uint32_t ctrl_command,
{
struct lis2mdl_data *lis2mdl = dev->data;
const struct lis2mdl_config *const config = dev->config;
enum pm_device_state current_state = lis2mdl->power_state;
int status = 0;
enum pm_device_state new_state;
switch (ctrl_command) {
case PM_DEVICE_STATE_SET:
new_state = *state;
if (new_state != current_state) {
enum pm_device_state curr_state;
(void)pm_device_state_get(dev, &curr_state);
if (*state != curr_state) {
status = lis2mdl_set_power_state(lis2mdl, config,
new_state);
*state);
}
break;
case PM_DEVICE_STATE_GET:
*state = current_state;
break;
default:
LOG_ERR("Got unknown power management control command");
status = -EINVAL;

5
drivers/sensor/lis2mdl/lis2mdl.h
View file

@ -50,11 +50,6 @@ struct lis2mdl_data {
const struct device *dev;
int16_t mag[3];
int16_t temp_sample;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state power_state;
#endif
struct k_sem fetch_sem;
#ifdef CONFIG_LIS2MDL_TRIGGER

39
drivers/sensor/qdec_nrfx/qdec_nrfx.c
View file

@ -24,9 +24,6 @@ LOG_MODULE_REGISTER(qdec_nrfx, CONFIG_SENSOR_LOG_LEVEL);
struct qdec_nrfx_data {
int32_t acc;
sensor_trigger_handler_t data_ready_handler;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
};
@ -206,43 +203,24 @@ static int qdec_nrfx_init(const struct device *dev)
qdec_nrfx_gpio_ctrl(true);
nrfx_qdec_enable();
#ifdef CONFIG_PM_DEVICE
struct qdec_nrfx_data *data = &qdec_nrfx_data;
data->pm_state = PM_DEVICE_STATE_ACTIVE;
#endif
return 0;
}
#ifdef CONFIG_PM_DEVICE
static int qdec_nrfx_pm_get_state(struct qdec_nrfx_data *data,
enum pm_device_state *state)
{
unsigned int key = irq_lock();
*state = data->pm_state;
irq_unlock(key);
return 0;
}
static int qdec_nrfx_pm_set_state(struct qdec_nrfx_data *data,
enum pm_device_state new_state)
{
enum pm_device_state old_state;
unsigned int key;
enum pm_device_state curr_state;
key = irq_lock();
old_state = data->pm_state;
irq_unlock(key);
(void)pm_device_state_get(dev, &curr_state);
if (old_state == new_state) {
if (curr_state == new_state) {
/* leave unchanged */
return 0;
}
if (old_state == PM_DEVICE_STATE_ACTIVE) {
if (curr_state == PM_DEVICE_STATE_ACTIVE) {
/* device must be suspended */
nrfx_qdec_disable();
qdec_nrfx_gpio_ctrl(false);
@ -258,11 +236,6 @@ static int qdec_nrfx_pm_set_state(struct qdec_nrfx_data *data,
nrfx_qdec_enable();
}
/* record the new state */
key = irq_lock();
data->pm_state = new_state;
irq_unlock(key);
return 0;
}
@ -276,10 +249,6 @@ static int qdec_nrfx_pm_control(const struct device *dev,
LOG_DBG("");
switch (ctrl_command) {
case PM_DEVICE_STATE_GET:
err = qdec_nrfx_pm_get_state(data, state);
break;
case PM_DEVICE_STATE_SET:
err = qdec_nrfx_pm_set_state(data, *state);
break;

19
drivers/sensor/sgp40/sgp40.c
View file

@ -189,11 +189,12 @@ static int sgp40_channel_get(const struct device *dev,
static int sgp40_set_power_state(const struct device *dev,
enum pm_device_state power_state)
{
struct sgp40_data *data = dev->data;
uint16_t cmd;
int rc;
enum pm_device_state state;
if (data->pm_state == power_state) {
(void)pm_device_state_get(dev, &state);
if (state == power_state) {
LOG_DBG("Device already in requested PM_STATE.");
return 0;
}
@ -214,18 +215,6 @@ static int sgp40_set_power_state(const struct device *dev,
return rc;
}
data->pm_state = power_state;
return 0;
}
static uint32_t sgp40_get_power_state(const struct device *dev,
enum pm_device_state *state)
{
struct sgp40_data *data = dev->data;
*state = data->pm_state;
return 0;
}
@ -237,8 +226,6 @@ static int sgp40_pm_ctrl(const struct device *dev,
if (ctrl_command == PM_DEVICE_STATE_SET) {
rc = sgp40_set_power_state(dev, *state);
} else if (ctrl_command == PM_DEVICE_STATE_GET) {
rc = sgp40_get_power_state(dev, state);
}
return rc;

4
drivers/sensor/sgp40/sgp40.h
View file

@ -47,10 +47,6 @@ struct sgp40_data {
uint16_t raw_sample;
int8_t rh_param[3];
int8_t t_param[3];
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
};
#endif /* ZEPHYR_DRIVERS_SENSOR_SGP40_SGP40_H_ */

2
drivers/sensor/vcnl4040/vcnl4040.c
View file

@ -273,8 +273,6 @@ static int vcnl4040_device_ctrl(const struct device *dev,
#endif
}
} else if (ctrl_command == PM_DEVICE_STATE_GET) {
*state = PM_DEVICE_STATE_ACTIVE;
}
return ret;

35
drivers/serial/uart_cc13xx_cc26xx.c
View file

@ -36,9 +36,6 @@ struct uart_cc13xx_cc26xx_data {
bool tx_constrained;
bool rx_constrained;
#endif
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
};
static inline struct uart_cc13xx_cc26xx_data *get_dev_data(const struct device *dev)
@ -404,9 +401,11 @@ static int uart_cc13xx_cc26xx_set_power_state(const struct device *dev,
enum pm_device_state new_state)
{
int ret = 0;
enum pm_device_state state;
if ((new_state == PM_DEVICE_STATE_ACTIVE) &&
(new_state != get_dev_data(dev)->pm_state)) {
(void)pm_device_state_get(dev, &state);
if ((new_state == PM_DEVICE_STATE_ACTIVE) && (new_state != state)) {
if (get_dev_conf(dev)->regs ==
DT_INST_REG_ADDR(0)) {
Power_setDependency(PowerCC26XX_PERIPH_UART0);
@ -416,15 +415,12 @@ static int uart_cc13xx_cc26xx_set_power_state(const struct device *dev,
/* Configure and enable UART */
ret = uart_cc13xx_cc26xx_configure(dev,
&get_dev_data(dev)->uart_config);
if (ret == 0) {
get_dev_data(dev)->pm_state = new_state;
}
} else {
__ASSERT_NO_MSG(new_state == PM_DEVICE_STATE_LOW_POWER ||
new_state == PM_DEVICE_STATE_SUSPEND ||
new_state == PM_DEVICE_STATE_OFF);
if (get_dev_data(dev)->pm_state == PM_DEVICE_STATE_ACTIVE) {
if (state == PM_DEVICE_STATE_ACTIVE) {
UARTDisable(get_dev_conf(dev)->regs);
/*
* Release power dependency - i.e. potentially power
@ -438,7 +434,6 @@ static int uart_cc13xx_cc26xx_set_power_state(const struct device *dev,
Power_releaseDependency(
PowerCC26X2_PERIPH_UART1);
}
get_dev_data(dev)->pm_state = new_state;
}
}
@ -452,15 +447,12 @@ static int uart_cc13xx_cc26xx_pm_control(const struct device *dev,
int ret = 0;
if (ctrl_command == PM_DEVICE_STATE_SET) {
enum pm_device_state new_state = *state;
enum pm_device_state curr_state;
if (new_state != get_dev_data(dev)->pm_state) {
ret = uart_cc13xx_cc26xx_set_power_state(dev,
new_state);
(void)pm_device_state_get(dev, &curr_state);
if (*state != curr_state) {
ret = uart_cc13xx_cc26xx_set_power_state(dev, *state);
}
} else {
__ASSERT_NO_MSG(ctrl_command == PM_DEVICE_STATE_GET);
*state = get_dev_data(dev)->pm_state;
}
return ret;
@ -578,13 +570,6 @@ static const struct uart_driver_api uart_cc13xx_cc26xx_driver_api = {
#ifdef CONFIG_PM_DEVICE
#define UART_CC13XX_CC26XX_DEVICE_INIT(n) \
UART_CC13XX_CC26XX_DEVICE_DEFINE(n)
#define UART_CC13XX_CC26XX_INIT_PM_STATE \
do { \
get_dev_data(dev)->pm_state = PM_DEVICE_STATE_ACTIVE; \
} while (0)
#else
#define UART_CC13XX_CC26XX_INIT_PM_STATE
#endif
#define UART_CC13XX_CC26XX_INIT_FUNC(n) \
@ -592,8 +577,6 @@ static const struct uart_driver_api uart_cc13xx_cc26xx_driver_api = {
{ \
int ret; \
\
UART_CC13XX_CC26XX_INIT_PM_STATE; \
\
UART_CC13XX_CC26XX_POWER_UART(n); \
\
/* Configure IOC module to map UART signals to pins */ \

18
drivers/serial/uart_npcx.c
View file

@ -40,9 +40,6 @@ struct uart_npcx_data {
uart_irq_callback_user_data_t user_cb;
void *user_data;
#endif
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
};
/* Driver convenience defines */
@ -441,20 +438,9 @@ static inline bool uart_npcx_device_is_transmitting(const struct device *dev)
return 0;
}
static inline int uart_npcx_get_power_state(const struct device *dev,
enum pm_device_state *state)
{
const struct uart_npcx_data *const data = DRV_DATA(dev);
*state = data->pm_state;
return 0;
}
static inline int uart_npcx_set_power_state(const struct device *dev,
enum pm_device_state next_state)
{
struct uart_npcx_data *const data = DRV_DATA(dev);
/* If next device power state is LOW or SUSPEND power state */
if (next_state == PM_DEVICE_STATE_LOW_POWER ||
next_state == PM_DEVICE_STATE_SUSPEND) {
@ -467,7 +453,6 @@ static inline int uart_npcx_set_power_state(const struct device *dev,
}
}
data->pm_state = next_state;
return 0;
}
@ -481,9 +466,6 @@ static int uart_npcx_pm_control(const struct device *dev, uint32_t ctrl_command,
case PM_DEVICE_STATE_SET:
ret = uart_npcx_set_power_state(dev, *state);
break;
case PM_DEVICE_STATE_GET:
ret = uart_npcx_get_power_state(dev, state);
break;
default:
ret = -EINVAL;
}

13
drivers/serial/uart_nrfx_uart.c
View file

@ -1162,18 +1162,13 @@ static int uart_nrfx_pm_control(const struct device *dev,
uint32_t ctrl_command,
enum pm_device_state *state)
{
static enum pm_device_state current_state = PM_DEVICE_STATE_ACTIVE;
if (ctrl_command == PM_DEVICE_STATE_SET) {
enum pm_device_state new_state = *state;
enum pm_device_state current_state;
if (new_state != current_state) {
uart_nrfx_set_power_state(dev, new_state);
current_state = new_state;
(void)pm_device_state_get(dev, &current_state);
if (*state != current_state) {
uart_nrfx_set_power_state(dev, *state);
}
} else {
__ASSERT_NO_MSG(ctrl_command == PM_DEVICE_STATE_GET);
*state = current_state;
}
return 0;

35
drivers/serial/uart_nrfx_uarte.c
View file

@ -124,9 +124,6 @@ struct uarte_nrfx_data {
struct uarte_async_cb *async;
#endif
atomic_val_t poll_out_lock;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
uint8_t char_out;
uint8_t rx_data;
gppi_channel_t ppi_ch_endtx;
@ -543,7 +540,10 @@ static void tx_start(const struct device *dev, const uint8_t *buf, size_t len)
NRF_UARTE_Type *uarte = get_uarte_instance(dev);
#if CONFIG_PM_DEVICE
if (get_dev_data(dev)->pm_state != PM_DEVICE_STATE_ACTIVE) {
enum pm_device_state state;
(void)pm_device_state_get(dev, &state);
if (state != PM_DEVICE_STATE_ACTIVE) {
return;
}
#endif
@ -1700,10 +1700,6 @@ static int uarte_instance_init(const struct device *dev,
return err;
}
#ifdef CONFIG_PM_DEVICE
data->pm_state = PM_DEVICE_STATE_ACTIVE;
#endif
if (IS_ENABLED(CONFIG_UART_ENHANCED_POLL_OUT) &&
get_dev_config(dev)->flags & UARTE_CFG_FLAG_PPI_ENDTX) {
err = endtx_stoptx_ppi_init(uarte, data);
@ -1839,14 +1835,14 @@ static void uarte_nrfx_set_power_state(const struct device *dev,
enum pm_device_state new_state)
{
NRF_UARTE_Type *uarte = get_uarte_instance(dev);
#if defined(CONFIG_UART_ASYNC_API) || defined(UARTE_INTERRUPT_DRIVEN)
struct uarte_nrfx_data *data = get_dev_data(dev);
#endif
if (new_state == PM_DEVICE_STATE_ACTIVE) {
uarte_nrfx_pins_enable(dev, true);
nrf_uarte_enable(uarte);
data->pm_state = new_state;
#ifdef CONFIG_UART_ASYNC_API
if (hw_rx_counting_enabled(get_dev_data(dev))) {
nrfx_timer_enable(&get_dev_config(dev)->timer);
@ -1868,6 +1864,8 @@ static void uarte_nrfx_set_power_state(const struct device *dev,
#endif
}
} else {
enum pm_device_state state;
__ASSERT_NO_MSG(new_state == PM_DEVICE_STATE_LOW_POWER ||
new_state == PM_DEVICE_STATE_SUSPEND ||
new_state == PM_DEVICE_STATE_OFF);
@ -1875,12 +1873,11 @@ static void uarte_nrfx_set_power_state(const struct device *dev,
/* if pm is already not active, driver will stay indefinitely
* in while loop waiting for event NRF_UARTE_EVENT_RXTO
*/
if (data->pm_state != PM_DEVICE_STATE_ACTIVE) {
(void)pm_device_state_get(dev, &state);
if (state != PM_DEVICE_STATE_ACTIVE) {
return;
}
data->pm_state = new_state;
/* Disabling UART requires stopping RX, but stop RX event is
* only sent after each RX if async UART API is used.
*/
@ -1928,17 +1925,15 @@ static int uarte_nrfx_pm_control(const struct device *dev,
uint32_t ctrl_command,
enum pm_device_state *state)
{
struct uarte_nrfx_data *data = get_dev_data(dev);
enum pm_device_state curr_state;
if (ctrl_command == PM_DEVICE_STATE_SET) {
enum pm_device_state new_state = *state;
enum pm_device_state curr_state;
if (new_state != data->pm_state) {
uarte_nrfx_set_power_state(dev, new_state);
(void)pm_device_state_get(dev, &curr_state);
if (*state != curr_state) {
uarte_nrfx_set_power_state(dev, *state);
}
} else {
__ASSERT_NO_MSG(ctrl_command == PM_DEVICE_STATE_GET);
*state = data->pm_state;
}
return 0;

18
drivers/serial/uart_stm32.c
View file

@ -1413,9 +1413,6 @@ static int uart_stm32_init(const struct device *dev)
#if defined(CONFIG_UART_INTERRUPT_DRIVEN) || defined(CONFIG_UART_ASYNC_API)
config->uconf.irq_config_func(dev);
#endif
#ifdef CONFIG_PM_DEVICE
data->pm_state = PM_DEVICE_STATE_ACTIVE;
#endif /* CONFIG_PM_DEVICE */
#ifdef CONFIG_UART_ASYNC_API
return uart_stm32_async_init(dev);
@ -1429,7 +1426,6 @@ static int uart_stm32_set_power_state(const struct device *dev,
enum pm_device_state new_state)
{
USART_TypeDef *UartInstance = UART_STRUCT(dev);
struct uart_stm32_data *data = DEV_DATA(dev);
/* setting a low power mode */
if (new_state != PM_DEVICE_STATE_ACTIVE) {
@ -1449,7 +1445,7 @@ static int uart_stm32_set_power_state(const struct device *dev,
LL_USART_ClearFlag_ORE(UartInstance);
/* Leave UartInstance unchanged */
}
data->pm_state = new_state;
/* UartInstance returning to active mode has nothing special to do */
return 0;
}
@ -1467,17 +1463,13 @@ static int uart_stm32_pm_control(const struct device *dev,
uint32_t ctrl_command,
enum pm_device_state *state)
{
struct uart_stm32_data *data = DEV_DATA(dev);
if (ctrl_command == PM_DEVICE_STATE_SET) {
enum pm_device_state new_state = *state;
enum pm_device_state curr_state;
if (new_state != data->pm_state) {
uart_stm32_set_power_state(dev, new_state);
(void)pm_device_state_get(dev, &curr_state);
if (*state != curr_state) {
uart_stm32_set_power_state(dev, *state);
}
} else {
__ASSERT_NO_MSG(ctrl_command == PM_DEVICE_STATE_GET);
*state = data->pm_state;
}
return 0;

3
drivers/serial/uart_stm32.h
View file

@ -67,9 +67,6 @@ struct uart_stm32_data {
uint8_t *rx_next_buffer;
size_t rx_next_buffer_len;
#endif
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
};
#endif /* ZEPHYR_DRIVERS_SERIAL_UART_STM32_H_ */

35
drivers/spi/spi_cc13xx_cc26xx.c
View file

@ -33,9 +33,6 @@ struct spi_cc13xx_cc26xx_config {
struct spi_cc13xx_cc26xx_data {
struct spi_context ctx;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
};
#define CPU_FREQ DT_PROP(DT_PATH(cpus, cpu_0), clock_frequency)
@ -215,22 +212,23 @@ static int spi_cc13xx_cc26xx_set_power_state(const struct device *dev,
enum pm_device_state new_state)
{
int ret = 0;
enum pm_device_state state;
if ((new_state == PM_DEVICE_STATE_ACTIVE) &&
(new_state != get_dev_data(dev)->pm_state)) {
(void)pm_device_state_get(dev, &state);
if ((new_state == PM_DEVICE_STATE_ACTIVE) && (new_state != state)) {
if (get_dev_config(dev)->base ==
DT_INST_REG_ADDR(0)) {
Power_setDependency(PowerCC26XX_PERIPH_SSI0);
} else {
Power_setDependency(PowerCC26XX_PERIPH_SSI1);
}
get_dev_data(dev)->pm_state = new_state;
} else {
__ASSERT_NO_MSG(new_state == PM_DEVICE_STATE_LOW_POWER ||
new_state == PM_DEVICE_STATE_SUSPEND ||
new_state == PM_DEVICE_STATE_OFF);
if (get_dev_data(dev)->pm_state == PM_DEVICE_STATE_ACTIVE) {
if (state == PM_DEVICE_STATE_ACTIVE) {
SSIDisable(get_dev_config(dev)->base);
/*
* Release power dependency
@ -243,7 +241,6 @@ static int spi_cc13xx_cc26xx_set_power_state(const struct device *dev,
Power_releaseDependency(
PowerCC26XX_PERIPH_SSI1);
}
get_dev_data(dev)->pm_state = new_state;
}
}
@ -257,15 +254,12 @@ static int spi_cc13xx_cc26xx_pm_control(const struct device *dev,
int ret = 0;
if (ctrl_command == PM_DEVICE_STATE_SET) {
uint32_t new_state = *state;
enum pm_device_state curr_state;
if (new_state != get_dev_data(dev)->pm_state) {
ret = spi_cc13xx_cc26xx_set_power_state(dev,
new_state);
(void)pm_device_state_get(dev, &curr_state);
if (*state != curr_state) {
ret = spi_cc13xx_cc26xx_set_power_state(dev, *state);
}
} else {
__ASSERT_NO_MSG(ctrl_command == PM_DEVICE_STATE_GET);
*state = get_dev_data(dev)->pm_state;
}
return ret;
@ -331,20 +325,9 @@ static const struct spi_driver_api spi_cc13xx_cc26xx_driver_api = {
POST_KERNEL, CONFIG_SPI_INIT_PRIORITY, \
&spi_cc13xx_cc26xx_driver_api)
#ifdef CONFIG_PM_DEVICE
#define SPI_CC13XX_CC26XX_INIT_PM_STATE \
do { \
get_dev_data(dev)->pm_state = PM_DEVICE_STATE_ACTIVE; \
} while (0)
#else
#define SPI_CC13XX_CC26XX_INIT_PM_STATE
#endif
#define SPI_CC13XX_CC26XX_INIT_FUNC(n) \
static int spi_cc13xx_cc26xx_init_##n(const struct device *dev) \
{ \
SPI_CC13XX_CC26XX_INIT_PM_STATE; \
\
SPI_CC13XX_CC26XX_POWER_SPI(n); \
\
spi_context_unlock_unconditionally(&get_dev_data(dev)->ctx);\

22
drivers/spi/spi_nrfx_spi.c
View file

@ -19,9 +19,6 @@ struct spi_nrfx_data {
const struct device *dev;
size_t chunk_len;
bool busy;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
};
struct spi_nrfx_config {
@ -276,10 +273,6 @@ static int init_spi(const struct device *dev)
return -EBUSY;
}
#ifdef CONFIG_PM_DEVICE
dev_data->pm_state = PM_DEVICE_STATE_ACTIVE;
#endif
return 0;
}
@ -293,10 +286,11 @@ static int spi_nrfx_pm_control(const struct device *dev,
const struct spi_nrfx_config *config = get_dev_config(dev);
if (ctrl_command == PM_DEVICE_STATE_SET) {
enum pm_device_state new_state = *state;
enum pm_device_state curr_state;
if (new_state != data->pm_state) {
switch (new_state) {
(void)pm_device_state_get(dev, &curr_state);
if (*state != curr_state) {
switch (*state) {
case PM_DEVICE_STATE_ACTIVE:
ret = init_spi(dev);
/* Force reconfiguration before next transfer */
@ -306,7 +300,7 @@ static int spi_nrfx_pm_control(const struct device *dev,
case PM_DEVICE_STATE_LOW_POWER:
case PM_DEVICE_STATE_SUSPEND:
case PM_DEVICE_STATE_OFF:
if (data->pm_state == PM_DEVICE_STATE_ACTIVE) {
if (curr_state == PM_DEVICE_STATE_ACTIVE) {
nrfx_spi_uninit(&config->spi);
}
break;
@ -314,13 +308,7 @@ static int spi_nrfx_pm_control(const struct device *dev,
default:
ret = -ENOTSUP;
}
if (!ret) {
data->pm_state = new_state;
}
}
} else {
__ASSERT_NO_MSG(ctrl_command == PM_DEVICE_STATE_GET);
*state = data->pm_state;
}
return ret;

23
drivers/spi/spi_nrfx_spim.c
View file

@ -20,9 +20,6 @@ struct spi_nrfx_data {
const struct device *dev;
size_t chunk_len;
bool busy;
#ifdef CONFIG_PM_DEVICE
enum pm_device_state pm_state;
#endif
#if (CONFIG_SPI_NRFX_RAM_BUFFER_SIZE > 0)
uint8_t buffer[CONFIG_SPI_NRFX_RAM_BUFFER_SIZE];
#endif
@ -323,11 +320,6 @@ static int init_spim(const struct device *dev)
return -EBUSY;
}
#ifdef CONFIG_PM_DEVICE
data->pm_state = PM_DEVICE_STATE_ACTIVE;
get_dev_data(dev)->pm_state = PM_DEVICE_STATE_ACTIVE;
#endif
return 0;
}
@ -341,10 +333,11 @@ static int spim_nrfx_pm_control(const struct device *dev,
const struct spi_nrfx_config *config = get_dev_config(dev);
if (ctrl_command == PM_DEVICE_STATE_SET) {
enum pm_device_state new_state = *state;
enum pm_device_state curr_state;
if (new_state != data->pm_state) {
switch (new_state) {
(void)pm_device_state_get(dev, &curr_state);
if (*state != curr_state) {
switch (*state) {
case PM_DEVICE_STATE_ACTIVE:
ret = init_spim(dev);
/* Force reconfiguration before next transfer */
@ -354,7 +347,7 @@ static int spim_nrfx_pm_control(const struct device *dev,
case PM_DEVICE_STATE_LOW_POWER:
case PM_DEVICE_STATE_SUSPEND:
case PM_DEVICE_STATE_OFF:
if (data->pm_state == PM_DEVICE_STATE_ACTIVE) {
if (curr_state == PM_DEVICE_STATE_ACTIVE) {
nrfx_spim_uninit(&config->spim);
}
break;
@ -362,13 +355,7 @@ static int spim_nrfx_pm_control(const struct device *dev,
default:
ret = -ENOTSUP;
}
if (!ret) {
data->pm_state = new_state;
}
}
} else {
__ASSERT_NO_MSG(ctrl_command == PM_DEVICE_STATE_GET);
*state = data->pm_state;
}
return ret;

14
include/pm/device.h
View file

@ -121,20 +121,16 @@ int pm_device_state_set(const struct device *dev,
enum pm_device_state device_power_state);
/**
* @brief Call the get power state function of a device
* @brief Obtain the power state of a device.
*
* This function lets the caller know the current device
* power state at any time. This state will be one of the defined
* power states allowed for the devices in that system
*
* @param dev pointer to device structure of the driver instance.
* @param device_power_state Device power state to be filled by the device
* @param dev Device instance.
* @param state Pointer where device power state will be stored.
*
* @retval 0 If successful.
* @retval Errno Negative errno code if failure.
* @retval -ENOSYS If device does not implement power management.
*/
int pm_device_state_get(const struct device *dev,
enum pm_device_state *device_power_state);
enum pm_device_state *state);
#ifdef CONFIG_PM_DEVICE
/**

1
kernel/device.c
View file

@ -32,6 +32,7 @@ static inline void device_pm_state_init(const struct device *dev)
.usage = ATOMIC_INIT(0),
.lock = Z_MUTEX_INITIALIZER(dev->pm->lock),
.condvar = Z_CONDVAR_INITIALIZER(dev->pm->condvar),
.state = PM_DEVICE_STATE_ACTIVE,
};
#endif /* CONFIG_PM_DEVICE */
}

36
samples/subsys/pm/device_pm/src/dummy_driver.c
View file

@ -9,12 +9,12 @@
#include "dummy_parent.h"
#include "dummy_driver.h"
enum pm_device_state device_power_state;
static const struct device *parent;
static int dummy_open(const struct device *dev)
{
int ret;
enum pm_device_state state;
printk("open()\n");
@ -33,7 +33,8 @@ static int dummy_open(const struct device *dev)
(void) pm_device_wait(dev, K_FOREVER);
if (dev->pm->state == PM_DEVICE_STATE_ACTIVE) {
(void)pm_device_state_get(dev, &state);
if (state == PM_DEVICE_STATE_ACTIVE) {
printk("Dummy device resumed\n");
ret = 0;
} else {
@ -85,27 +86,6 @@ static int dummy_close(const struct device *dev)
return ret;
}
static enum pm_device_state dummy_get_power_state(const struct device *dev)
{
return device_power_state;
}
static int dummy_suspend(const struct device *dev)
{
printk("child suspending..\n");
device_power_state = PM_DEVICE_STATE_SUSPEND;
return 0;
}
static int dummy_resume_from_suspend(const struct device *dev)
{
printk("child resuming..\n");
device_power_state = PM_DEVICE_STATE_ACTIVE;
return 0;
}
static int dummy_device_pm_ctrl(const struct device *dev,
uint32_t ctrl_command,
enum pm_device_state *state)
@ -115,14 +95,13 @@ static int dummy_device_pm_ctrl(const struct device *dev,
switch (ctrl_command) {
case PM_DEVICE_STATE_SET:
if (*state == PM_DEVICE_STATE_ACTIVE) {
ret = dummy_resume_from_suspend(dev);
printk("child resuming..\n");
return 0;
} else {
ret = dummy_suspend(dev);
printk("child suspending..\n");
return 0;
}
break;
case PM_DEVICE_STATE_GET:
*state = dummy_get_power_state(dev);
break;
default:
ret = -EINVAL;
@ -146,7 +125,6 @@ int dummy_init(const struct device *dev)
}
pm_device_enable(dev);
device_power_state = PM_DEVICE_STATE_ACTIVE;
return 0;
}

32
samples/subsys/pm/device_pm/src/dummy_parent.c
View file

@ -9,7 +9,6 @@
#include "dummy_parent.h"
static uint32_t store_value;
enum pm_device_state parent_power_state;
static int dummy_transfer(const struct device *dev, uint32_t cmd,
uint32_t *val)
@ -25,27 +24,6 @@ static int dummy_transfer(const struct device *dev, uint32_t cmd,
return 0;
}
static enum pm_device_state dummy_get_power_state(const struct device *dev)
{
return parent_power_state;
}
static int dummy_suspend(const struct device *dev)
{
printk("parent suspending..\n");
parent_power_state = PM_DEVICE_STATE_SUSPEND;
return 0;
}
static int dummy_resume_from_suspend(const struct device *dev)
{
printk("parent resuming..\n");
parent_power_state = PM_DEVICE_STATE_ACTIVE;
return 0;
}
static int dummy_parent_pm_ctrl(const struct device *dev,
uint32_t ctrl_command,
enum pm_device_state *state)
@ -55,14 +33,13 @@ static int dummy_parent_pm_ctrl(const struct device *dev,
switch (ctrl_command) {
case PM_DEVICE_STATE_SET:
if (*state == PM_DEVICE_STATE_ACTIVE) {
ret = dummy_resume_from_suspend(dev);
printk("parent resuming..\n");
return 0;
} else {
ret = dummy_suspend(dev);
printk("parent suspending..\n");
return 0;
}
break;
case PM_DEVICE_STATE_GET:
*state = dummy_get_power_state(dev);
break;
default:
ret = -EINVAL;
@ -78,7 +55,6 @@ static const struct dummy_parent_api funcs = {
int dummy_parent_init(const struct device *dev)
{
pm_device_enable(dev);
parent_power_state = PM_DEVICE_STATE_ACTIVE;
return 0;
}

19
subsys/pm/device.c
View file

@ -131,23 +131,32 @@ const char *pm_device_state_str(enum pm_device_state state)
int pm_device_state_set(const struct device *dev,
enum pm_device_state device_power_state)
{
int ret;
if (dev->pm_control == NULL) {
return -ENOSYS;
}
return dev->pm_control(dev, PM_DEVICE_STATE_SET,
&device_power_state);
ret = dev->pm_control(dev, PM_DEVICE_STATE_SET, &device_power_state);
if (ret < 0) {
return ret;
}
dev->pm->state = device_power_state;
return 0;
}
int pm_device_state_get(const struct device *dev,
enum pm_device_state *device_power_state)
enum pm_device_state *state)
{
if (dev->pm_control == NULL) {
return -ENOSYS;
}
return dev->pm_control(dev, PM_DEVICE_STATE_GET,
device_power_state);
*state = dev->pm->state;
return 0;
}
bool pm_device_is_any_busy(void)

30
tests/subsys/pm/device_runtime/src/dummy_driver.c
View file

@ -9,8 +9,6 @@
#include <pm/device_runtime.h>
#include "dummy_driver.h"
static uint32_t device_power_state;
static int dummy_wait(const struct device *dev)
{
return pm_device_wait(dev, K_FOREVER);
@ -36,39 +34,15 @@ static int dummy_close_sync(const struct device *dev)
return pm_device_put(dev);
}
static uint32_t dummy_get_power_state(const struct device *dev)
{
return device_power_state;
}
static int dummy_suspend(const struct device *dev)
{
device_power_state = PM_DEVICE_STATE_SUSPEND;
return 0;
}
static int dummy_resume_from_suspend(const struct device *dev)
{
device_power_state = PM_DEVICE_STATE_ACTIVE;
return 0;
}
static int dummy_device_pm_ctrl(const struct device *dev,
uint32_t ctrl_command,
enum pm_device_state *state)
{
int ret = 0;
int ret;
switch (ctrl_command) {
case PM_DEVICE_STATE_SET:
if (*state == PM_DEVICE_STATE_ACTIVE) {
ret = dummy_resume_from_suspend(dev);
} else {
ret = dummy_suspend(dev);
}
break;
case PM_DEVICE_STATE_GET:
*state = dummy_get_power_state(dev);
ret = 0;
break;
default:
ret = -EINVAL;

30
tests/subsys/pm/power_mgmt/src/dummy_driver.c
View file

@ -9,8 +9,6 @@
#include <pm/device_runtime.h>
#include "dummy_driver.h"
static enum pm_device_state device_power_state;
static int dummy_open(const struct device *dev)
{
return pm_device_get(dev);
@ -21,39 +19,15 @@ static int dummy_close(const struct device *dev)
return pm_device_put(dev);
}
static uint32_t dummy_get_power_state(const struct device *dev)
{
return device_power_state;
}
static int dummy_suspend(const struct device *dev)
{
device_power_state = PM_DEVICE_STATE_SUSPEND;
return 0;
}
static int dummy_resume_from_suspend(const struct device *dev)
{
device_power_state = PM_DEVICE_STATE_ACTIVE;
return 0;
}
static int dummy_device_pm_ctrl(const struct device *dev,
uint32_t ctrl_command,
enum pm_device_state *state)
{
int ret = 0;
int ret;
switch (ctrl_command) {
case PM_DEVICE_STATE_SET:
if (*state == PM_DEVICE_STATE_ACTIVE) {
ret = dummy_resume_from_suspend(dev);
} else {
ret = dummy_suspend(dev);
}
break;
case PM_DEVICE_STATE_GET:
*state = dummy_get_power_state(dev);
ret = 0;
break;
default:
ret = -EINVAL;