From 2c7b763e47aeb0445b2ec52eb2abf4649d0d9bf9 Mon Sep 17 00:00:00 2001 From: Gerard Marull-Paretas Date: Mon, 3 May 2021 17:36:10 +0200 Subject: [PATCH] pm: replace DEVICE_PM_* states with PM_DEVICE_* Prefix device PM states with PM. Signed-off-by: Gerard Marull-Paretas --- doc/reference/power_management/index.rst | 16 +++--- drivers/display/display_st7735r.c | 12 ++-- drivers/display/display_st7789v.c | 12 ++-- drivers/entropy/entropy_cc13xx_cc26xx.c | 16 +++--- drivers/ethernet/eth_mcux.c | 6 +- drivers/flash/spi_flash_at45.c | 14 ++--- drivers/flash/spi_nor.c | 6 +- drivers/gpio/gpio_dw.c | 14 ++--- drivers/i2c/i2c_cc13xx_cc26xx.c | 16 +++--- drivers/i2c/i2c_nrfx_twi.c | 16 +++--- drivers/i2c/i2c_nrfx_twim.c | 16 +++--- .../intc_arcv2_irq_unit.c | 14 ++--- drivers/interrupt_controller/intc_ioapic.c | 14 ++--- drivers/interrupt_controller/intc_loapic.c | 14 ++--- drivers/led/led_pwm.c | 6 +- drivers/modem/hl7800.c | 4 +- drivers/modem/modem_receiver.c | 8 +-- drivers/pwm/pwm_nrfx.c | 18 +++--- drivers/sensor/apds9960/apds9960.c | 8 +-- drivers/sensor/bme280/bme280.c | 12 ++-- drivers/sensor/bmp388/bmp388.c | 16 +++--- drivers/sensor/bmp388/bmp388_trigger.c | 2 +- drivers/sensor/fdc2x1x/fdc2x1x.c | 30 +++++----- drivers/sensor/fdc2x1x/fdc2x1x_trigger.c | 2 +- drivers/sensor/lis2mdl/lis2mdl.c | 16 +++--- drivers/sensor/qdec_nrfx/qdec_nrfx.c | 12 ++-- drivers/sensor/vcnl4040/vcnl4040.c | 8 +-- drivers/serial/uart_cc13xx_cc26xx.c | 16 +++--- drivers/serial/uart_npcx.c | 8 +-- drivers/serial/uart_nrfx_uart.c | 14 ++--- drivers/serial/uart_nrfx_uarte.c | 18 +++--- drivers/serial/uart_stm32.c | 8 +-- drivers/spi/spi_cc13xx_cc26xx.c | 16 +++--- drivers/spi/spi_nrfx_spi.c | 16 +++--- drivers/spi/spi_nrfx_spim.c | 18 +++--- include/device.h | 4 +- include/pm/device.h | 26 ++++----- kernel/device.c | 8 +-- samples/boards/nrf/system_off/src/main.c | 8 +-- samples/drivers/spi_flash_at45/src/main.c | 2 +- samples/sensor/apds9960/src/main.c | 4 +- samples/sensor/fdc2x1x/src/main.c | 16 +++--- .../subsys/pm/device_pm/src/dummy_driver.c | 14 ++--- .../subsys/pm/device_pm/src/dummy_parent.c | 12 ++-- subsys/net/ip/net_shell.c | 4 +- subsys/pm/device.c | 18 +++--- subsys/pm/device_pm.c | 56 +++++++++---------- subsys/shell/modules/device_service.c | 2 +- tests/kernel/device/src/main.c | 12 ++-- tests/net/pm/src/main.c | 14 ++--- tests/subsys/pm/power_mgmt/src/dummy_driver.c | 10 ++-- tests/subsys/pm/power_mgmt/src/main.c | 10 ++-- 52 files changed, 331 insertions(+), 331 deletions(-) diff --git a/doc/reference/power_management/index.rst b/doc/reference/power_management/index.rst index 3325458f040..706b0e86a13 100644 --- a/doc/reference/power_management/index.rst +++ b/doc/reference/power_management/index.rst @@ -215,20 +215,20 @@ registers, clocks, memory etc. The four device power states: -:code:`DEVICE_PM_ACTIVE_STATE` +:code:`PM_DEVICE_ACTIVE_STATE` Normal operation of the device. All device context is retained. -:code:`DEVICE_PM_LOW_POWER_STATE` +:code:`PM_DEVICE_LOW_POWER_STATE` Device context is preserved by the HW and need not be restored by the driver. -:code:`DEVICE_PM_SUSPEND_STATE` +:code:`PM_DEVICE_SUSPEND_STATE` Most device context is lost by the hardware. Device drivers must save and restore or reinitialize any context lost by the hardware. -:code:`DEVICE_PM_OFF_STATE` +:code:`PM_DEVICE_OFF_STATE` Power has been fully removed from the device. The device context is lost when this state is entered. Need to reinitialize the device when powering @@ -241,8 +241,8 @@ Zephyr RTOS power management subsystem provides a control function interface to device drivers to indicate power management operations to perform. The supported PM control commands are: -* DEVICE_PM_SET_POWER_STATE -* DEVICE_PM_GET_POWER_STATE +* PM_DEVICE_SET_POWER_STATE +* PM_DEVICE_GET_POWER_STATE Each device driver defines: @@ -298,7 +298,7 @@ Device Set Power State int device_set_power_state(const struct device *dev, uint32_t device_power_state, device_pm_cb cb, void *arg); Calls the :c:func:`device_pm_control()` handler function implemented by the -device driver with DEVICE_PM_SET_POWER_STATE command. +device driver with PM_DEVICE_SET_POWER_STATE command. Device Get Power State ---------------------- @@ -308,7 +308,7 @@ Device Get Power State int device_get_power_state(const struct device *dev, uint32_t * device_power_state); Calls the :c:func:`device_pm_control()` handler function implemented by the -device driver with DEVICE_PM_GET_POWER_STATE command. +device driver with PM_DEVICE_GET_POWER_STATE command. Busy Status Indication ====================== diff --git a/drivers/display/display_st7735r.c b/drivers/display/display_st7735r.c index a273ed92b4e..c1747081a1f 100644 --- a/drivers/display/display_st7735r.c +++ b/drivers/display/display_st7735r.c @@ -476,7 +476,7 @@ static int st7735r_init(const struct device *dev) } #ifdef CONFIG_DEVICE_POWER_MANAGEMENT - data->pm_state = DEVICE_PM_ACTIVE_STATE; + data->pm_state = PM_DEVICE_ACTIVE_STATE; #endif data->cmd_data_dev = device_get_binding(config->cmd_data.name); @@ -526,24 +526,24 @@ static int st7735r_pm_control(const struct device *dev, uint32_t ctrl_command, struct st7735r_data *data = (struct st7735r_data *)dev->data; switch (ctrl_command) { - case DEVICE_PM_SET_POWER_STATE: - if (*((uint32_t *)context) == DEVICE_PM_ACTIVE_STATE) { + case PM_DEVICE_SET_POWER_STATE: + if (*((uint32_t *)context) == PM_DEVICE_ACTIVE_STATE) { ret = st7735r_exit_sleep(data); if (ret < 0) { return ret; } - data->pm_state = DEVICE_PM_ACTIVE_STATE; + data->pm_state = PM_DEVICE_ACTIVE_STATE; } else { ret = st7735r_enter_sleep(data); if (ret < 0) { return ret; } - data->pm_state = DEVICE_PM_LOW_POWER_STATE; + data->pm_state = PM_DEVICE_LOW_POWER_STATE; } break; - case DEVICE_PM_GET_POWER_STATE: + case PM_DEVICE_GET_POWER_STATE: *((uint32_t *)context) = data->pm_state; break; diff --git a/drivers/display/display_st7789v.c b/drivers/display/display_st7789v.c index aea617d06a3..a27c4060a9c 100644 --- a/drivers/display/display_st7789v.c +++ b/drivers/display/display_st7789v.c @@ -376,7 +376,7 @@ static int st7789v_init(const struct device *dev) #endif #ifdef CONFIG_PM_DEVICE - data->pm_state = DEVICE_PM_ACTIVE_STATE; + data->pm_state = PM_DEVICE_ACTIVE_STATE; #endif data->cmd_data_gpio = device_get_binding( @@ -415,18 +415,18 @@ static int st7789v_pm_control(const struct device *dev, uint32_t ctrl_command, struct st7789v_data *data = (struct st7789v_data *)dev->data; switch (ctrl_command) { - case DEVICE_PM_SET_POWER_STATE: - if (*((uint32_t *)context) == DEVICE_PM_ACTIVE_STATE) { + case PM_DEVICE_SET_POWER_STATE: + if (*((uint32_t *)context) == PM_DEVICE_ACTIVE_STATE) { st7789v_exit_sleep(data); - data->pm_state = DEVICE_PM_ACTIVE_STATE; + data->pm_state = PM_DEVICE_ACTIVE_STATE; ret = 0; } else { st7789v_enter_sleep(data); - data->pm_state = DEVICE_PM_LOW_POWER_STATE; + data->pm_state = PM_DEVICE_LOW_POWER_STATE; ret = 0; } break; - case DEVICE_PM_GET_POWER_STATE: + case PM_DEVICE_GET_POWER_STATE: *((uint32_t *)context) = data->pm_state; break; default: diff --git a/drivers/entropy/entropy_cc13xx_cc26xx.c b/drivers/entropy/entropy_cc13xx_cc26xx.c index 6160e9d2e29..ec7c7e8b4c6 100644 --- a/drivers/entropy/entropy_cc13xx_cc26xx.c +++ b/drivers/entropy/entropy_cc13xx_cc26xx.c @@ -272,16 +272,16 @@ 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; - if ((new_state == DEVICE_PM_ACTIVE_STATE) && + if ((new_state == PM_DEVICE_ACTIVE_STATE) && (new_state != data->pm_state)) { Power_setDependency(PowerCC26XX_PERIPH_TRNG); start_trng(data); } else { - __ASSERT_NO_MSG(new_state == DEVICE_PM_LOW_POWER_STATE || - new_state == DEVICE_PM_SUSPEND_STATE || - new_state == DEVICE_PM_OFF_STATE); + __ASSERT_NO_MSG(new_state == PM_DEVICE_LOW_POWER_STATE || + new_state == PM_DEVICE_SUSPEND_STATE || + new_state == PM_DEVICE_OFF_STATE); - if (data->pm_state == DEVICE_PM_ACTIVE_STATE) { + if (data->pm_state == PM_DEVICE_ACTIVE_STATE) { stop_trng(data); Power_releaseDependency(PowerCC26XX_PERIPH_TRNG); } @@ -299,7 +299,7 @@ static int entropy_cc13xx_cc26xx_pm_control(const struct device *dev, struct entropy_cc13xx_cc26xx_data *data = get_dev_data(dev); int ret = 0; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t new_state = *((const uint32_t *)context); if (new_state != data->pm_state) { @@ -307,7 +307,7 @@ static int entropy_cc13xx_cc26xx_pm_control(const struct device *dev, new_state); } } else { - __ASSERT_NO_MSG(ctrl_command == DEVICE_PM_GET_POWER_STATE); + __ASSERT_NO_MSG(ctrl_command == PM_DEVICE_GET_POWER_STATE); *((uint32_t *)context) = data->pm_state; } @@ -324,7 +324,7 @@ 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 = DEVICE_PM_ACTIVE_STATE; + get_dev_data(dev)->pm_state = PM_DEVICE_ACTIVE_STATE; #endif /* Initialize driver data */ diff --git a/drivers/ethernet/eth_mcux.c b/drivers/ethernet/eth_mcux.c index 65435e83318..b0821e1f653 100644 --- a/drivers/ethernet/eth_mcux.c +++ b/drivers/ethernet/eth_mcux.c @@ -198,8 +198,8 @@ static int eth_mcux_device_pm_control(const struct device *dev, goto out; } - if (command == DEVICE_PM_SET_POWER_STATE) { - if (*(uint32_t *)context == DEVICE_PM_SUSPEND_STATE) { + if (command == PM_DEVICE_SET_POWER_STATE) { + if (*(uint32_t *)context == PM_DEVICE_SUSPEND_STATE) { LOG_DBG("Suspending"); ret = net_if_suspend(eth_ctx->iface); @@ -214,7 +214,7 @@ static int eth_mcux_device_pm_control(const struct device *dev, ENET_Deinit(eth_ctx->base); clock_control_off(eth_ctx->clock_dev, (clock_control_subsys_t)eth_ctx->clock); - } else if (*(uint32_t *)context == DEVICE_PM_ACTIVE_STATE) { + } else if (*(uint32_t *)context == PM_DEVICE_ACTIVE_STATE) { LOG_DBG("Resuming"); clock_control_on(eth_ctx->clock_dev, diff --git a/drivers/flash/spi_flash_at45.c b/drivers/flash/spi_flash_at45.c index 0a246d4a2c1..3aa62707194 100644 --- a/drivers/flash/spi_flash_at45.c +++ b/drivers/flash/spi_flash_at45.c @@ -576,21 +576,21 @@ static int spi_flash_at45_pm_control(const struct device *dev, const struct spi_flash_at45_config *dev_config = get_dev_config(dev); int err = 0; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t new_state = *((const uint32_t *)context); if (new_state != dev_data->pm_state) { switch (new_state) { - case DEVICE_PM_ACTIVE_STATE: + case PM_DEVICE_ACTIVE_STATE: acquire(dev); power_down_op(dev, CMD_EXIT_DPD, dev_config->t_exit_dpd); release(dev); break; - case DEVICE_PM_LOW_POWER_STATE: - case DEVICE_PM_SUSPEND_STATE: - case DEVICE_PM_OFF_STATE: + case PM_DEVICE_LOW_POWER_STATE: + case PM_DEVICE_SUSPEND_STATE: + case PM_DEVICE_OFF_STATE: acquire(dev); power_down_op(dev, dev_config->use_udpd ? CMD_ENTER_UDPD @@ -606,7 +606,7 @@ static int spi_flash_at45_pm_control(const struct device *dev, dev_data->pm_state = new_state; } } else { - __ASSERT_NO_MSG(ctrl_command == DEVICE_PM_GET_POWER_STATE); + __ASSERT_NO_MSG(ctrl_command == PM_DEVICE_GET_POWER_STATE); *((uint32_t *)context) = dev_data->pm_state; } @@ -647,7 +647,7 @@ 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 = DEVICE_PM_ACTIVE_STATE)) \ + .pm_state = PM_DEVICE_ACTIVE_STATE)) \ }; \ static const struct spi_flash_at45_config inst_##idx##_config = { \ .spi_bus = DT_INST_BUS_LABEL(idx), \ diff --git a/drivers/flash/spi_nor.c b/drivers/flash/spi_nor.c index aebfb64f67b..81d3a0029b4 100644 --- a/drivers/flash/spi_nor.c +++ b/drivers/flash/spi_nor.c @@ -37,9 +37,9 @@ LOG_MODULE_REGISTER(spi_nor, CONFIG_FLASH_LOG_LEVEL); * Kconfig option. * * When mapped to the Zephyr Device Power Management states: - * * DEVICE_PM_ACTIVE_STATE covers both active and standby modes; - * * DEVICE_PM_LOW_POWER_STATE, DEVICE_PM_SUSPEND_STATE, and - * DEVICE_PM_OFF_STATE all correspond to deep-power-down mode. + * * PM_DEVICE_ACTIVE_STATE covers both active and standby modes; + * * PM_DEVICE_LOW_POWER_STATE, PM_DEVICE_SUSPEND_STATE, and + * PM_DEVICE_OFF_STATE all correspond to deep-power-down mode. */ #define SPI_NOR_MAX_ADDR_WIDTH 4 diff --git a/drivers/gpio/gpio_dw.c b/drivers/gpio/gpio_dw.c index 0acea7731e4..3fda8fcb3fc 100644 --- a/drivers/gpio/gpio_dw.c +++ b/drivers/gpio/gpio_dw.c @@ -443,7 +443,7 @@ static uint32_t gpio_dw_get_power_state(const struct device *port) static inline int gpio_dw_suspend_port(const struct device *port) { gpio_dw_clock_off(port); - gpio_dw_set_power_state(port, DEVICE_PM_SUSPEND_STATE); + gpio_dw_set_power_state(port, PM_DEVICE_SUSPEND_STATE); return 0; } @@ -451,7 +451,7 @@ static inline int gpio_dw_suspend_port(const struct device *port) static inline int gpio_dw_resume_from_suspend_port(const struct device *port) { gpio_dw_clock_on(port); - gpio_dw_set_power_state(port, DEVICE_PM_ACTIVE_STATE); + gpio_dw_set_power_state(port, PM_DEVICE_ACTIVE_STATE); return 0; } @@ -465,13 +465,13 @@ static int gpio_dw_device_ctrl(const struct device *port, { int ret = 0; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { - if (*((uint32_t *)context) == DEVICE_PM_SUSPEND_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { + if (*((uint32_t *)context) == PM_DEVICE_SUSPEND_STATE) { ret = gpio_dw_suspend_port(port); - } else if (*((uint32_t *)context) == DEVICE_PM_ACTIVE_STATE) { + } else if (*((uint32_t *)context) == PM_DEVICE_ACTIVE_STATE) { ret = gpio_dw_resume_from_suspend_port(port); } - } else if (ctrl_command == DEVICE_PM_GET_POWER_STATE) { + } else if (ctrl_command == PM_DEVICE_GET_POWER_STATE) { *((uint32_t *)context) = gpio_dw_get_power_state(port); } @@ -544,7 +544,7 @@ static int gpio_dw_initialize(const struct device *port) config->config_func(port); } - gpio_dw_set_power_state(port, DEVICE_PM_ACTIVE_STATE); + gpio_dw_set_power_state(port, PM_DEVICE_ACTIVE_STATE); return 0; } diff --git a/drivers/i2c/i2c_cc13xx_cc26xx.c b/drivers/i2c/i2c_cc13xx_cc26xx.c index 98f59d465bb..c4815e70035 100644 --- a/drivers/i2c/i2c_cc13xx_cc26xx.c +++ b/drivers/i2c/i2c_cc13xx_cc26xx.c @@ -333,7 +333,7 @@ static int i2c_cc13xx_cc26xx_set_power_state(const struct device *dev, { int ret = 0; - if ((new_state == DEVICE_PM_ACTIVE_STATE) && + if ((new_state == PM_DEVICE_ACTIVE_STATE) && (new_state != get_dev_data(dev)->pm_state)) { Power_setDependency(PowerCC26XX_PERIPH_I2C0); IOCPinTypeI2c(get_dev_config(dev)->base, @@ -346,11 +346,11 @@ static int i2c_cc13xx_cc26xx_set_power_state(const struct device *dev, get_dev_data(dev)->pm_state = new_state; } } else { - __ASSERT_NO_MSG(new_state == DEVICE_PM_LOW_POWER_STATE || - new_state == DEVICE_PM_SUSPEND_STATE || - new_state == DEVICE_PM_OFF_STATE); + __ASSERT_NO_MSG(new_state == PM_DEVICE_LOW_POWER_STATE || + new_state == PM_DEVICE_SUSPEND_STATE || + new_state == PM_DEVICE_OFF_STATE); - if (get_dev_data(dev)->pm_state == DEVICE_PM_ACTIVE_STATE) { + if (get_dev_data(dev)->pm_state == PM_DEVICE_ACTIVE_STATE) { I2CMasterIntDisable(get_dev_config(dev)->base); I2CMasterDisable(get_dev_config(dev)->base); /* Reset pin type to default GPIO configuration */ @@ -373,7 +373,7 @@ static int i2c_cc13xx_cc26xx_pm_control(const struct device *dev, { int ret = 0; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t new_state = *((const uint32_t *)context); if (new_state != get_dev_data(dev)->pm_state) { @@ -381,7 +381,7 @@ static int i2c_cc13xx_cc26xx_pm_control(const struct device *dev, new_state); } } else { - __ASSERT_NO_MSG(ctrl_command == DEVICE_PM_GET_POWER_STATE); + __ASSERT_NO_MSG(ctrl_command == PM_DEVICE_GET_POWER_STATE); *((uint32_t *)context) = get_dev_data(dev)->pm_state; } @@ -399,7 +399,7 @@ static int i2c_cc13xx_cc26xx_init(const struct device *dev) int err; #ifdef CONFIG_PM_DEVICE - get_dev_data(dev)->pm_state = DEVICE_PM_ACTIVE_STATE; + get_dev_data(dev)->pm_state = PM_DEVICE_ACTIVE_STATE; #endif #ifdef CONFIG_PM diff --git a/drivers/i2c/i2c_nrfx_twi.c b/drivers/i2c/i2c_nrfx_twi.c index ae8b0a72b94..11f2e09b72c 100644 --- a/drivers/i2c/i2c_nrfx_twi.c +++ b/drivers/i2c/i2c_nrfx_twi.c @@ -206,7 +206,7 @@ static int init_twi(const struct device *dev) return -EBUSY; } #ifdef CONFIG_PM_DEVICE - get_dev_data(dev)->pm_state = DEVICE_PM_ACTIVE_STATE; + get_dev_data(dev)->pm_state = PM_DEVICE_ACTIVE_STATE; #endif return 0; @@ -220,12 +220,12 @@ static int twi_nrfx_pm_control(const struct device *dev, int ret = 0; uint32_t pm_current_state = get_dev_data(dev)->pm_state; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t new_state = *((const uint32_t *)context); if (new_state != pm_current_state) { switch (new_state) { - case DEVICE_PM_ACTIVE_STATE: + case PM_DEVICE_ACTIVE_STATE: init_twi(dev); if (get_dev_data(dev)->dev_config) { i2c_nrfx_twi_configure( @@ -234,10 +234,10 @@ static int twi_nrfx_pm_control(const struct device *dev, } break; - case DEVICE_PM_LOW_POWER_STATE: - case DEVICE_PM_SUSPEND_STATE: - case DEVICE_PM_OFF_STATE: - if (pm_current_state == DEVICE_PM_ACTIVE_STATE) { + case PM_DEVICE_LOW_POWER_STATE: + case PM_DEVICE_SUSPEND_STATE: + case PM_DEVICE_OFF_STATE: + if (pm_current_state == PM_DEVICE_ACTIVE_STATE) { nrfx_twi_uninit(&get_dev_config(dev)->twi); } break; @@ -250,7 +250,7 @@ static int twi_nrfx_pm_control(const struct device *dev, } } } else { - __ASSERT_NO_MSG(ctrl_command == DEVICE_PM_GET_POWER_STATE); + __ASSERT_NO_MSG(ctrl_command == PM_DEVICE_GET_POWER_STATE); *((uint32_t *)context) = get_dev_data(dev)->pm_state; } diff --git a/drivers/i2c/i2c_nrfx_twim.c b/drivers/i2c/i2c_nrfx_twim.c index 1c869915d07..a519664caf7 100644 --- a/drivers/i2c/i2c_nrfx_twim.c +++ b/drivers/i2c/i2c_nrfx_twim.c @@ -256,7 +256,7 @@ static int init_twim(const struct device *dev) } #ifdef CONFIG_PM_DEVICE - get_dev_data(dev)->pm_state = DEVICE_PM_ACTIVE_STATE; + get_dev_data(dev)->pm_state = PM_DEVICE_ACTIVE_STATE; #endif return 0; @@ -270,12 +270,12 @@ static int twim_nrfx_pm_control(const struct device *dev, int ret = 0; uint32_t pm_current_state = get_dev_data(dev)->pm_state; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t new_state = *((const uint32_t *)context); if (new_state != pm_current_state) { switch (new_state) { - case DEVICE_PM_ACTIVE_STATE: + case PM_DEVICE_ACTIVE_STATE: init_twim(dev); if (get_dev_data(dev)->dev_config) { i2c_nrfx_twim_configure( @@ -284,10 +284,10 @@ static int twim_nrfx_pm_control(const struct device *dev, } break; - case DEVICE_PM_LOW_POWER_STATE: - case DEVICE_PM_SUSPEND_STATE: - case DEVICE_PM_OFF_STATE: - if (pm_current_state != DEVICE_PM_ACTIVE_STATE) { + case PM_DEVICE_LOW_POWER_STATE: + case PM_DEVICE_SUSPEND_STATE: + case PM_DEVICE_OFF_STATE: + if (pm_current_state != PM_DEVICE_ACTIVE_STATE) { break; } nrfx_twim_uninit(&get_dev_config(dev)->twim); @@ -301,7 +301,7 @@ static int twim_nrfx_pm_control(const struct device *dev, } } } else { - __ASSERT_NO_MSG(ctrl_command == DEVICE_PM_GET_POWER_STATE); + __ASSERT_NO_MSG(ctrl_command == PM_DEVICE_GET_POWER_STATE); *((uint32_t *)context) = get_dev_data(dev)->pm_state; } diff --git a/drivers/interrupt_controller/intc_arcv2_irq_unit.c b/drivers/interrupt_controller/intc_arcv2_irq_unit.c index 191a0df3b48..83b41dd26b4 100644 --- a/drivers/interrupt_controller/intc_arcv2_irq_unit.c +++ b/drivers/interrupt_controller/intc_arcv2_irq_unit.c @@ -32,7 +32,7 @@ extern void *_VectorTable; #define _ARC_V2_IRQ_VECT_BASE _ARC_V2_IRQ_VECT_BASE_S #endif -static uint32_t _arc_v2_irq_unit_device_power_state = DEVICE_PM_ACTIVE_STATE; +static uint32_t _arc_v2_irq_unit_device_power_state = PM_DEVICE_ACTIVE_STATE; struct arc_v2_irq_unit_ctx { uint32_t irq_ctrl; /* Interrupt Context Saving Control Register. */ uint32_t irq_vect_base; /* Interrupt Vector Base. */ @@ -120,7 +120,7 @@ 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 = DEVICE_PM_SUSPEND_STATE; + _arc_v2_irq_unit_device_power_state = PM_DEVICE_SUSPEND_STATE; return 0; } @@ -166,7 +166,7 @@ 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 = DEVICE_PM_ACTIVE_STATE; + _arc_v2_irq_unit_device_power_state = PM_DEVICE_ACTIVE_STATE; return 0; } @@ -198,13 +198,13 @@ static int arc_v2_irq_unit_device_ctrl(const struct device *dev, int ret = 0; unsigned int key = arch_irq_lock(); - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { - if (*((uint32_t *)context) == DEVICE_PM_SUSPEND_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { + if (*((uint32_t *)context) == PM_DEVICE_SUSPEND_STATE) { ret = arc_v2_irq_unit_suspend(dev); - } else if (*((uint32_t *)context) == DEVICE_PM_ACTIVE_STATE) { + } else if (*((uint32_t *)context) == PM_DEVICE_ACTIVE_STATE) { ret = arc_v2_irq_unit_resume(dev); } - } else if (ctrl_command == DEVICE_PM_GET_POWER_STATE) { + } else if (ctrl_command == PM_DEVICE_GET_POWER_STATE) { *((uint32_t *)context) = arc_v2_irq_unit_get_state(dev); } diff --git a/drivers/interrupt_controller/intc_ioapic.c b/drivers/interrupt_controller/intc_ioapic.c index f1163737741..2411dd3f610 100644 --- a/drivers/interrupt_controller/intc_ioapic.c +++ b/drivers/interrupt_controller/intc_ioapic.c @@ -104,7 +104,7 @@ static uint32_t ioapic_rtes; #define SUSPEND_BITS_REQD (ROUND_UP((256 * BITS_PER_IRQ), 32)) uint32_t ioapic_suspend_buf[SUSPEND_BITS_REQD / 32] = {0}; -static uint32_t ioapic_device_power_state = DEVICE_PM_ACTIVE_STATE; +static uint32_t ioapic_device_power_state = PM_DEVICE_ACTIVE_STATE; #endif @@ -265,7 +265,7 @@ int ioapic_suspend(const struct device *port) store_flags(irq, rte_lo); } } - ioapic_device_power_state = DEVICE_PM_SUSPEND_STATE; + ioapic_device_power_state = PM_DEVICE_SUSPEND_STATE; return 0; } @@ -295,7 +295,7 @@ int ioapic_resume_from_suspend(const struct device *port) ioApicRedSetHi(irq, DEFAULT_RTE_DEST); ioApicRedSetLo(irq, rteValue); } - ioapic_device_power_state = DEVICE_PM_ACTIVE_STATE; + ioapic_device_power_state = PM_DEVICE_ACTIVE_STATE; return 0; } @@ -309,13 +309,13 @@ static int ioapic_device_ctrl(const struct device *dev, { int ret = 0; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { - if (*((uint32_t *)context) == DEVICE_PM_SUSPEND_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { + if (*((uint32_t *)context) == PM_DEVICE_SUSPEND_STATE) { ret = ioapic_suspend(dev); - } else if (*((uint32_t *)context) == DEVICE_PM_ACTIVE_STATE) { + } else if (*((uint32_t *)context) == PM_DEVICE_ACTIVE_STATE) { ret = ioapic_resume_from_suspend(dev); } - } else if (ctrl_command == DEVICE_PM_GET_POWER_STATE) { + } else if (ctrl_command == PM_DEVICE_GET_POWER_STATE) { *((uint32_t *)context) = ioapic_device_power_state; } diff --git a/drivers/interrupt_controller/intc_loapic.c b/drivers/interrupt_controller/intc_loapic.c index 142d9426679..c261495f8ef 100644 --- a/drivers/interrupt_controller/intc_loapic.c +++ b/drivers/interrupt_controller/intc_loapic.c @@ -63,7 +63,7 @@ #ifdef CONFIG_PM_DEVICE #include uint32_t loapic_suspend_buf[LOPIC_SUSPEND_BITS_REQD / 32] = {0}; -static uint32_t loapic_device_power_state = DEVICE_PM_ACTIVE_STATE; +static uint32_t loapic_device_power_state = PM_DEVICE_ACTIVE_STATE; #endif #ifdef DEVICE_MMIO_IS_IN_RAM @@ -364,7 +364,7 @@ static int loapic_suspend(const struct device *port) } } } - loapic_device_power_state = DEVICE_PM_SUSPEND_STATE; + loapic_device_power_state = PM_DEVICE_SUSPEND_STATE; return 0; } @@ -393,7 +393,7 @@ int loapic_resume(const struct device *port) } } } - loapic_device_power_state = DEVICE_PM_ACTIVE_STATE; + loapic_device_power_state = PM_DEVICE_ACTIVE_STATE; return 0; } @@ -408,13 +408,13 @@ static int loapic_device_ctrl(const struct device *port, { int ret = 0; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { - if (*((uint32_t *)context) == DEVICE_PM_SUSPEND_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { + if (*((uint32_t *)context) == PM_DEVICE_SUSPEND_STATE) { ret = loapic_suspend(port); - } else if (*((uint32_t *)context) == DEVICE_PM_ACTIVE_STATE) { + } else if (*((uint32_t *)context) == PM_DEVICE_ACTIVE_STATE) { ret = loapic_resume(port); } - } else if (ctrl_command == DEVICE_PM_GET_POWER_STATE) { + } else if (ctrl_command == PM_DEVICE_GET_POWER_STATE) { *((uint32_t *)context) = loapic_device_power_state; } diff --git a/drivers/led/led_pwm.c b/drivers/led/led_pwm.c index a68da35420d..9d46fa192db 100644 --- a/drivers/led/led_pwm.c +++ b/drivers/led/led_pwm.c @@ -120,7 +120,7 @@ static int led_pwm_init(const struct device *dev) #ifdef CONFIG_PM_DEVICE struct led_pwm_data *data = DEV_DATA(dev); - data->pm_state = DEVICE_PM_ACTIVE_STATE; + data->pm_state = PM_DEVICE_ACTIVE_STATE; #endif return 0; @@ -181,11 +181,11 @@ static int led_pwm_pm_control(const struct device *dev, uint32_t ctrl_command, int err; switch (ctrl_command) { - case DEVICE_PM_GET_POWER_STATE: + case PM_DEVICE_GET_POWER_STATE: err = led_pwm_pm_get_state(dev, context); break; - case DEVICE_PM_SET_POWER_STATE: + case PM_DEVICE_SET_POWER_STATE: err = led_pwm_pm_set_state(dev, *((uint32_t *)context)); break; diff --git a/drivers/modem/hl7800.c b/drivers/modem/hl7800.c index 9ceccf18cde..fe99ebf3289 100644 --- a/drivers/modem/hl7800.c +++ b/drivers/modem/hl7800.c @@ -3490,7 +3490,7 @@ static void shutdown_uart(void) HL7800_IO_DBG_LOG("Power OFF the UART"); uart_irq_rx_disable(ictx.mdm_ctx.uart_dev); rc = device_set_power_state(ictx.mdm_ctx.uart_dev, - DEVICE_PM_OFF_STATE, NULL, NULL); + PM_DEVICE_OFF_STATE, NULL, NULL); if (rc) { LOG_ERR("Error disabling UART peripheral (%d)", rc); } @@ -3507,7 +3507,7 @@ static void power_on_uart(void) if (!ictx.uart_on) { HL7800_IO_DBG_LOG("Power ON the UART"); rc = device_set_power_state(ictx.mdm_ctx.uart_dev, - DEVICE_PM_ACTIVE_STATE, NULL, NULL); + PM_DEVICE_ACTIVE_STATE, NULL, NULL); if (rc) { LOG_ERR("Error enabling UART peripheral (%d)", rc); } diff --git a/drivers/modem/modem_receiver.c b/drivers/modem/modem_receiver.c index 9f4a54d9400..67006779d51 100644 --- a/drivers/modem/modem_receiver.c +++ b/drivers/modem/modem_receiver.c @@ -198,16 +198,16 @@ int mdm_receiver_send(struct mdm_receiver_context *ctx, int mdm_receiver_sleep(struct mdm_receiver_context *ctx) { uart_irq_rx_disable(ctx->uart_dev); -#ifdef DEVICE_PM_LOW_POWER_STATE - device_set_power_state(ctx->uart_dev, DEVICE_PM_LOW_POWER_STATE, NULL, NULL); +#ifdef PM_DEVICE_LOW_POWER_STATE + device_set_power_state(ctx->uart_dev, PM_DEVICE_LOW_POWER_STATE, NULL, NULL); #endif return 0; } int mdm_receiver_wake(struct mdm_receiver_context *ctx) { -#ifdef DEVICE_PM_LOW_POWER_STATE - device_set_power_state(ctx->uart_dev, DEVICE_PM_ACTIVE_STATE, NULL, NULL); +#ifdef PM_DEVICE_LOW_POWER_STATE + device_set_power_state(ctx->uart_dev, PM_DEVICE_ACTIVE_STATE, NULL, NULL); #endif uart_irq_rx_enable(ctx->uart_dev); diff --git a/drivers/pwm/pwm_nrfx.c b/drivers/pwm/pwm_nrfx.c index 7e0a8177ae3..00718055e6c 100644 --- a/drivers/pwm/pwm_nrfx.c +++ b/drivers/pwm/pwm_nrfx.c @@ -297,14 +297,14 @@ static int pwm_nrfx_set_power_state(uint32_t new_state, int err = 0; switch (new_state) { - case DEVICE_PM_ACTIVE_STATE: + case PM_DEVICE_ACTIVE_STATE: err = pwm_nrfx_init(dev); break; - case DEVICE_PM_LOW_POWER_STATE: - case DEVICE_PM_SUSPEND_STATE: - case DEVICE_PM_FORCE_SUSPEND_STATE: - case DEVICE_PM_OFF_STATE: - if (current_state == DEVICE_PM_ACTIVE_STATE) { + case PM_DEVICE_LOW_POWER_STATE: + case PM_DEVICE_SUSPEND_STATE: + case PM_DEVICE_FORCE_SUSPEND_STATE: + case PM_DEVICE_OFF_STATE: + if (current_state == PM_DEVICE_ACTIVE_STATE) { pwm_nrfx_uninit(dev); } break; @@ -322,7 +322,7 @@ static int pwm_nrfx_pm_control(const struct device *dev, { int err = 0; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t new_state = *((const uint32_t *)context); if (new_state != (*current_state)) { @@ -334,7 +334,7 @@ static int pwm_nrfx_pm_control(const struct device *dev, } } } else { - __ASSERT_NO_MSG(ctrl_command == DEVICE_PM_GET_POWER_STATE); + __ASSERT_NO_MSG(ctrl_command == PM_DEVICE_GET_POWER_STATE); *((uint32_t *)context) = (*current_state); } @@ -348,7 +348,7 @@ static int pwm_nrfx_pm_control(const struct device *dev, device_pm_cb cb, \ void *arg) \ { \ - static uint32_t current_state = DEVICE_PM_ACTIVE_STATE; \ + static uint32_t current_state = PM_DEVICE_ACTIVE_STATE; \ int ret = 0; \ ret = pwm_nrfx_pm_control(dev, ctrl_command, context, \ ¤t_state); \ diff --git a/drivers/sensor/apds9960/apds9960.c b/drivers/sensor/apds9960/apds9960.c index 2b22f5d4c58..4c4ad9d24f0 100644 --- a/drivers/sensor/apds9960/apds9960.c +++ b/drivers/sensor/apds9960/apds9960.c @@ -416,10 +416,10 @@ static int apds9960_device_ctrl(const struct device *dev, struct apds9960_data *data = dev->data; int ret = 0; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t device_pm_state = *(uint32_t *)context; - if (device_pm_state == DEVICE_PM_ACTIVE_STATE) { + if (device_pm_state == PM_DEVICE_ACTIVE_STATE) { if (i2c_reg_update_byte(data->i2c, config->i2c_address, APDS9960_ENABLE_REG, APDS9960_ENABLE_PON, @@ -441,8 +441,8 @@ static int apds9960_device_ctrl(const struct device *dev, } } - } else if (ctrl_command == DEVICE_PM_GET_POWER_STATE) { - *((uint32_t *)context) = DEVICE_PM_ACTIVE_STATE; + } else if (ctrl_command == PM_DEVICE_GET_POWER_STATE) { + *((uint32_t *)context) = PM_DEVICE_ACTIVE_STATE; } if (cb) { diff --git a/drivers/sensor/bme280/bme280.c b/drivers/sensor/bme280/bme280.c index 13573c305d7..399cd3b4555 100644 --- a/drivers/sensor/bme280/bme280.c +++ b/drivers/sensor/bme280/bme280.c @@ -183,7 +183,7 @@ static int bme280_sample_fetch(const struct device *dev, #ifdef CONFIG_PM_DEVICE /* Do not allow sample fetching from OFF state */ - if (data->pm_state == DEVICE_PM_OFF_STATE) + if (data->pm_state == PM_DEVICE_OFF_STATE) return -EIO; #endif @@ -383,7 +383,7 @@ static int bme280_chip_init(const struct device *dev) #ifdef CONFIG_PM_DEVICE /* Set power state to ACTIVE */ - data->pm_state = DEVICE_PM_ACTIVE_STATE; + data->pm_state = PM_DEVICE_ACTIVE_STATE; #endif LOG_DBG("\"%s\" OK", dev->name); return 0; @@ -398,19 +398,19 @@ int bme280_pm_ctrl(const struct device *dev, uint32_t ctrl_command, int ret = 0; /* Set power state */ - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t new_pm_state = *((const uint32_t *)context); if (new_pm_state != data->pm_state) { /* Switching from OFF to any */ - if (data->pm_state == DEVICE_PM_OFF_STATE) { + if (data->pm_state == PM_DEVICE_OFF_STATE) { /* Re-initialize the chip */ ret = bme280_chip_init(dev); } /* Switching to OFF from any */ - else if (new_pm_state == DEVICE_PM_OFF_STATE) { + else if (new_pm_state == PM_DEVICE_OFF_STATE) { /* Put the chip into sleep mode */ ret = bme280_reg_write(dev, @@ -429,7 +429,7 @@ int bme280_pm_ctrl(const struct device *dev, uint32_t ctrl_command, } /* Get power state */ else { - __ASSERT_NO_MSG(ctrl_command == DEVICE_PM_GET_POWER_STATE); + __ASSERT_NO_MSG(ctrl_command == PM_DEVICE_GET_POWER_STATE); *((uint32_t *)context) = data->pm_state; } diff --git a/drivers/sensor/bmp388/bmp388.c b/drivers/sensor/bmp388/bmp388.c index a3b3b76af89..463c9cfaaa3 100644 --- a/drivers/sensor/bmp388/bmp388.c +++ b/drivers/sensor/bmp388/bmp388.c @@ -313,7 +313,7 @@ static int bmp388_attr_set(const struct device *dev, #ifdef CONFIG_DEVICE_POWER_MANAGEMENT struct bmp388_data *data = DEV_DATA(dev); - if (data->device_power_state != DEVICE_PM_ACTIVE_STATE) { + if (data->device_power_state != PM_DEVICE_ACTIVE_STATE) { return -EBUSY; } #endif @@ -348,7 +348,7 @@ static int bmp388_sample_fetch(const struct device *dev, __ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL); #ifdef CONFIG_DEVICE_POWER_MANAGEMENT - if (bmp388->device_power_state != DEVICE_PM_ACTIVE_STATE) { + if (bmp388->device_power_state != PM_DEVICE_ACTIVE_STATE) { return -EBUSY; } #endif @@ -557,10 +557,10 @@ static int bmp388_set_power_state(const struct device *dev, return 0; } - if (power_state == DEVICE_PM_ACTIVE_STATE) { + if (power_state == PM_DEVICE_ACTIVE_STATE) { reg_val = BMP388_PWR_CTRL_MODE_NORMAL; - } else if ((power_state == DEVICE_PM_SUSPEND_STATE) || - (power_state == DEVICE_PM_OFF_STATE)) { + } else if ((power_state == PM_DEVICE_SUSPEND_STATE) || + (power_state == PM_DEVICE_OFF_STATE)) { reg_val = BMP388_PWR_CTRL_MODE_SLEEP; } else { return 0; @@ -595,9 +595,9 @@ static int bmp388_device_ctrl( { int ret = 0; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { ret = bmp388_set_power_state(dev, *((uint32_t *)context)); - } else if (ctrl_command == DEVICE_PM_GET_POWER_STATE) { + } else if (ctrl_command == PM_DEVICE_GET_POWER_STATE) { *((uint32_t *)context) = bmp388_get_power_state(dev); } @@ -672,7 +672,7 @@ static int bmp388_init(const struct device *dev) } #ifdef CONFIG_DEVICE_POWER_MANAGEMENT - bmp388->device_power_state = DEVICE_PM_ACTIVE_STATE; + bmp388->device_power_state = PM_DEVICE_ACTIVE_STATE; #endif /* Read calibration data */ diff --git a/drivers/sensor/bmp388/bmp388_trigger.c b/drivers/sensor/bmp388/bmp388_trigger.c index b261b14f30e..b61a2df813c 100644 --- a/drivers/sensor/bmp388/bmp388_trigger.c +++ b/drivers/sensor/bmp388/bmp388_trigger.c @@ -92,7 +92,7 @@ int bmp388_trigger_set( struct bmp388_data *data = DEV_DATA(dev); #ifdef CONFIG_DEVICE_POWER_MANAGEMENT - if (data->device_power_state != DEVICE_PM_ACTIVE_STATE) { + if (data->device_power_state != PM_DEVICE_ACTIVE_STATE) { return -EBUSY; } #endif diff --git a/drivers/sensor/fdc2x1x/fdc2x1x.c b/drivers/sensor/fdc2x1x/fdc2x1x.c index 720fcedf2f2..8584bfdd274 100644 --- a/drivers/sensor/fdc2x1x/fdc2x1x.c +++ b/drivers/sensor/fdc2x1x/fdc2x1x.c @@ -424,7 +424,7 @@ static int fdc2x1x_reset(const struct device *dev) #ifdef CONFIG_PM_DEVICE struct fdc2x1x_data *data = dev->data; - data->pm_state = DEVICE_PM_LOW_POWER_STATE; + data->pm_state = PM_DEVICE_LOW_POWER_STATE; #endif return ret; @@ -496,8 +496,8 @@ static int fdc2x1x_set_pm_state(const struct device *dev, const struct fdc2x1x_config *cfg = dev->config; switch (pm_state) { - case DEVICE_PM_ACTIVE_STATE: - if (data->pm_state == DEVICE_PM_OFF_STATE) { + case PM_DEVICE_ACTIVE_STATE: + if (data->pm_state == PM_DEVICE_OFF_STATE) { ret = fdc2x1x_set_shutdown(dev, false); if (ret) { return ret; @@ -508,11 +508,11 @@ static int fdc2x1x_set_pm_state(const struct device *dev, if (ret) { return ret; } - data->pm_state = DEVICE_PM_ACTIVE_STATE; + data->pm_state = PM_DEVICE_ACTIVE_STATE; break; - case DEVICE_PM_LOW_POWER_STATE: - if (data->pm_state == DEVICE_PM_OFF_STATE) { + case PM_DEVICE_LOW_POWER_STATE: + if (data->pm_state == PM_DEVICE_OFF_STATE) { ret = fdc2x1x_set_shutdown(dev, false); if (ret) { return ret; @@ -522,13 +522,13 @@ static int fdc2x1x_set_pm_state(const struct device *dev, if (ret) { return ret; } - data->pm_state = DEVICE_PM_LOW_POWER_STATE; + data->pm_state = PM_DEVICE_LOW_POWER_STATE; break; - case DEVICE_PM_OFF_STATE: + case PM_DEVICE_OFF_STATE: if (cfg->sd_gpio->name) { ret = fdc2x1x_set_shutdown(dev, true); - data->pm_state = DEVICE_PM_OFF_STATE; + data->pm_state = PM_DEVICE_OFF_STATE; } else { LOG_ERR("SD pin not defined"); ret = -EINVAL; @@ -549,13 +549,13 @@ static int fdc2x1x_device_pm_ctrl(const struct device *dev, uint32_t new_state; int ret = 0; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { new_state = *(uint32_t *)context; if (new_state != data->pm_state) { switch (new_state) { - case DEVICE_PM_ACTIVE_STATE: - case DEVICE_PM_LOW_POWER_STATE: - case DEVICE_PM_OFF_STATE: + case PM_DEVICE_ACTIVE_STATE: + case PM_DEVICE_LOW_POWER_STATE: + case PM_DEVICE_OFF_STATE: ret = fdc2x1x_set_pm_state(dev, new_state); break; default: @@ -563,7 +563,7 @@ static int fdc2x1x_device_pm_ctrl(const struct device *dev, ret = -EINVAL; } } - } else if (ctrl_command == DEVICE_PM_GET_POWER_STATE) { + } else if (ctrl_command == PM_DEVICE_GET_POWER_STATE) { *((uint32_t *)context) = data->pm_state; } @@ -655,7 +655,7 @@ static int fdc2x1x_sample_fetch(const struct device *dev, #ifdef CONFIG_PM_DEVICE struct fdc2x1x_data *data = dev->data; - if (data->pm_state != DEVICE_PM_ACTIVE_STATE) { + if (data->pm_state != PM_DEVICE_ACTIVE_STATE) { LOG_ERR("Sample fetch failed, device is not in active mode"); return -ENXIO; } diff --git a/drivers/sensor/fdc2x1x/fdc2x1x_trigger.c b/drivers/sensor/fdc2x1x/fdc2x1x_trigger.c index b5db5f43864..16a62c0ab1d 100644 --- a/drivers/sensor/fdc2x1x/fdc2x1x_trigger.c +++ b/drivers/sensor/fdc2x1x/fdc2x1x_trigger.c @@ -25,7 +25,7 @@ static void fdc2x1x_thread_cb(const struct device *dev) #ifdef CONFIG_PM_DEVICE /* INTB asserts after exiting shutdown mode. Drop this interrupt */ - if (drv_data->pm_state == DEVICE_PM_OFF_STATE) { + if (drv_data->pm_state == PM_DEVICE_OFF_STATE) { return; } #endif diff --git a/drivers/sensor/lis2mdl/lis2mdl.c b/drivers/sensor/lis2mdl/lis2mdl.c index cbf781ce239..299adf9e941 100644 --- a/drivers/sensor/lis2mdl/lis2mdl.c +++ b/drivers/sensor/lis2mdl/lis2mdl.c @@ -470,7 +470,7 @@ static int lis2mdl_init(const struct device *dev) } #ifdef CONFIG_PM_DEVICE - lis2mdl->power_state = DEVICE_PM_ACTIVE_STATE; + lis2mdl->power_state = PM_DEVICE_ACTIVE_STATE; #endif #ifdef CONFIG_LIS2MDL_TRIGGER @@ -490,7 +490,7 @@ static int lis2mdl_set_power_state(struct lis2mdl_data *lis2mdl, { int status = 0; - if (new_state == DEVICE_PM_ACTIVE_STATE) { + if (new_state == PM_DEVICE_ACTIVE_STATE) { if (config->single_mode) { status = lis2mdl_operating_mode_set(lis2mdl->ctx, LIS2MDL_SINGLE_TRIGGER); @@ -501,12 +501,12 @@ static int lis2mdl_set_power_state(struct lis2mdl_data *lis2mdl, if (status) { LOG_ERR("Power up failed"); } - lis2mdl->power_state = DEVICE_PM_ACTIVE_STATE; + lis2mdl->power_state = PM_DEVICE_ACTIVE_STATE; LOG_DBG("State changed to active"); } else { - __ASSERT_NO_MSG(new_state == DEVICE_PM_LOW_POWER_STATE || - new_state == DEVICE_PM_SUSPEND_STATE || - new_state == DEVICE_PM_OFF_STATE); + __ASSERT_NO_MSG(new_state == PM_DEVICE_LOW_POWER_STATE || + new_state == PM_DEVICE_SUSPEND_STATE || + new_state == PM_DEVICE_OFF_STATE); status = lis2mdl_operating_mode_set(lis2mdl->ctx, LIS2MDL_POWER_DOWN); if (status) { @@ -529,14 +529,14 @@ static int lis2mdl_pm_control(const struct device *dev, uint32_t ctrl_command, uint32_t new_state; switch (ctrl_command) { - case DEVICE_PM_SET_POWER_STATE: + case PM_DEVICE_SET_POWER_STATE: new_state = *((const uint32_t *)context); if (new_state != current_state) { status = lis2mdl_set_power_state(lis2mdl, config, new_state); } break; - case DEVICE_PM_GET_POWER_STATE: + case PM_DEVICE_GET_POWER_STATE: *((uint32_t *)context) = current_state; break; default: diff --git a/drivers/sensor/qdec_nrfx/qdec_nrfx.c b/drivers/sensor/qdec_nrfx/qdec_nrfx.c index 0c25b0a2579..8cb335ef970 100644 --- a/drivers/sensor/qdec_nrfx/qdec_nrfx.c +++ b/drivers/sensor/qdec_nrfx/qdec_nrfx.c @@ -209,7 +209,7 @@ static int qdec_nrfx_init(const struct device *dev) #ifdef CONFIG_PM_DEVICE struct qdec_nrfx_data *data = &qdec_nrfx_data; - data->pm_state = DEVICE_PM_ACTIVE_STATE; + data->pm_state = PM_DEVICE_ACTIVE_STATE; #endif return 0; @@ -242,18 +242,18 @@ static int qdec_nrfx_pm_set_state(struct qdec_nrfx_data *data, return 0; } - if (old_state == DEVICE_PM_ACTIVE_STATE) { + if (old_state == PM_DEVICE_ACTIVE_STATE) { /* device must be suspended */ nrfx_qdec_disable(); qdec_nrfx_gpio_ctrl(false); } - if (new_state == DEVICE_PM_OFF_STATE) { + if (new_state == PM_DEVICE_OFF_STATE) { /* device must be uninitialized */ nrfx_qdec_uninit(); } - if (new_state == DEVICE_PM_ACTIVE_STATE) { + if (new_state == PM_DEVICE_ACTIVE_STATE) { qdec_nrfx_gpio_ctrl(true); nrfx_qdec_enable(); } @@ -276,11 +276,11 @@ static int qdec_nrfx_pm_control(const struct device *dev, LOG_DBG(""); switch (ctrl_command) { - case DEVICE_PM_GET_POWER_STATE: + case PM_DEVICE_GET_POWER_STATE: err = qdec_nrfx_pm_get_state(data, context); break; - case DEVICE_PM_SET_POWER_STATE: + case PM_DEVICE_SET_POWER_STATE: err = qdec_nrfx_pm_set_state(data, *((uint32_t *)context)); break; diff --git a/drivers/sensor/vcnl4040/vcnl4040.c b/drivers/sensor/vcnl4040/vcnl4040.c index 3aa2e156090..4fab74ca66f 100644 --- a/drivers/sensor/vcnl4040/vcnl4040.c +++ b/drivers/sensor/vcnl4040/vcnl4040.c @@ -224,7 +224,7 @@ static int vcnl4040_device_ctrl(const struct device *dev, { int ret = 0; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t device_pm_state = *(uint32_t *)context; uint16_t ps_conf; @@ -238,7 +238,7 @@ static int vcnl4040_device_ctrl(const struct device *dev, if (ret < 0) return ret; #endif - if (device_pm_state == DEVICE_PM_ACTIVE_STATE) { + if (device_pm_state == PM_DEVICE_ACTIVE_STATE) { /* Clear proximity shutdown */ ps_conf &= ~VCNL4040_PS_SD_MASK; @@ -274,8 +274,8 @@ static int vcnl4040_device_ctrl(const struct device *dev, #endif } - } else if (ctrl_command == DEVICE_PM_GET_POWER_STATE) { - *((uint32_t *)context) = DEVICE_PM_ACTIVE_STATE; + } else if (ctrl_command == PM_DEVICE_GET_POWER_STATE) { + *((uint32_t *)context) = PM_DEVICE_ACTIVE_STATE; } if (cb) { diff --git a/drivers/serial/uart_cc13xx_cc26xx.c b/drivers/serial/uart_cc13xx_cc26xx.c index c7bbcf2a44b..4da884cc8f8 100644 --- a/drivers/serial/uart_cc13xx_cc26xx.c +++ b/drivers/serial/uart_cc13xx_cc26xx.c @@ -402,7 +402,7 @@ static int uart_cc13xx_cc26xx_set_power_state(const struct device *dev, { int ret = 0; - if ((new_state == DEVICE_PM_ACTIVE_STATE) && + if ((new_state == PM_DEVICE_ACTIVE_STATE) && (new_state != get_dev_data(dev)->pm_state)) { if (get_dev_conf(dev)->regs == DT_INST_REG_ADDR(0)) { @@ -417,11 +417,11 @@ static int uart_cc13xx_cc26xx_set_power_state(const struct device *dev, get_dev_data(dev)->pm_state = new_state; } } else { - __ASSERT_NO_MSG(new_state == DEVICE_PM_LOW_POWER_STATE || - new_state == DEVICE_PM_SUSPEND_STATE || - new_state == DEVICE_PM_OFF_STATE); + __ASSERT_NO_MSG(new_state == PM_DEVICE_LOW_POWER_STATE || + new_state == PM_DEVICE_SUSPEND_STATE || + new_state == PM_DEVICE_OFF_STATE); - if (get_dev_data(dev)->pm_state == DEVICE_PM_ACTIVE_STATE) { + if (get_dev_data(dev)->pm_state == PM_DEVICE_ACTIVE_STATE) { UARTDisable(get_dev_conf(dev)->regs); /* * Release power dependency - i.e. potentially power @@ -449,7 +449,7 @@ static int uart_cc13xx_cc26xx_pm_control(const struct device *dev, { int ret = 0; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t new_state = *((const uint32_t *)context); if (new_state != get_dev_data(dev)->pm_state) { @@ -457,7 +457,7 @@ static int uart_cc13xx_cc26xx_pm_control(const struct device *dev, new_state); } } else { - __ASSERT_NO_MSG(ctrl_command == DEVICE_PM_GET_POWER_STATE); + __ASSERT_NO_MSG(ctrl_command == PM_DEVICE_GET_POWER_STATE); *((uint32_t *)context) = get_dev_data(dev)->pm_state; } @@ -581,7 +581,7 @@ static const struct uart_driver_api uart_cc13xx_cc26xx_driver_api = { #define UART_CC13XX_CC26XX_INIT_PM_STATE \ do { \ - get_dev_data(dev)->pm_state = DEVICE_PM_ACTIVE_STATE; \ + get_dev_data(dev)->pm_state = PM_DEVICE_ACTIVE_STATE; \ } while (0) #else #define UART_CC13XX_CC26XX_INIT_PM_STATE diff --git a/drivers/serial/uart_npcx.c b/drivers/serial/uart_npcx.c index e44c1e2d5cb..7b7c3a5d3dd 100644 --- a/drivers/serial/uart_npcx.c +++ b/drivers/serial/uart_npcx.c @@ -432,8 +432,8 @@ static inline int uart_npcx_set_power_state(const struct device *dev, struct uart_npcx_data *const data = DRV_DATA(dev); /* If next device power state is LOW or SUSPEND power state */ - if (next_state == DEVICE_PM_LOW_POWER_STATE || - next_state == DEVICE_PM_SUSPEND_STATE) { + if (next_state == PM_DEVICE_LOW_POWER_STATE || + next_state == PM_DEVICE_SUSPEND_STATE) { /* * If uart device is busy with transmitting, the driver will * stay in while loop and wait for the transaction is completed. @@ -454,10 +454,10 @@ static int uart_npcx_pm_control(const struct device *dev, uint32_t ctrl_command, int ret = 0; switch (ctrl_command) { - case DEVICE_PM_SET_POWER_STATE: + case PM_DEVICE_SET_POWER_STATE: ret = uart_npcx_set_power_state(dev, *((uint32_t *)context)); break; - case DEVICE_PM_GET_POWER_STATE: + case PM_DEVICE_GET_POWER_STATE: ret = uart_npcx_get_power_state(dev, (uint32_t *)context); break; default: diff --git a/drivers/serial/uart_nrfx_uart.c b/drivers/serial/uart_nrfx_uart.c index c4b43df03f6..2a2d32dce98 100644 --- a/drivers/serial/uart_nrfx_uart.c +++ b/drivers/serial/uart_nrfx_uart.c @@ -1140,7 +1140,7 @@ static void uart_nrfx_pins_enable(const struct device *dev, bool enable) static void uart_nrfx_set_power_state(const struct device *dev, uint32_t new_state) { - if (new_state == DEVICE_PM_ACTIVE_STATE) { + if (new_state == PM_DEVICE_ACTIVE_STATE) { uart_nrfx_pins_enable(dev, true); nrf_uart_enable(uart0_addr); if (RX_PIN_USED) { @@ -1148,9 +1148,9 @@ static void uart_nrfx_set_power_state(const struct device *dev, NRF_UART_TASK_STARTRX); } } else { - __ASSERT_NO_MSG(new_state == DEVICE_PM_LOW_POWER_STATE || - new_state == DEVICE_PM_SUSPEND_STATE || - new_state == DEVICE_PM_OFF_STATE); + __ASSERT_NO_MSG(new_state == PM_DEVICE_LOW_POWER_STATE || + new_state == PM_DEVICE_SUSPEND_STATE || + new_state == PM_DEVICE_OFF_STATE); nrf_uart_disable(uart0_addr); uart_nrfx_pins_enable(dev, false); } @@ -1160,9 +1160,9 @@ static int uart_nrfx_pm_control(const struct device *dev, uint32_t ctrl_command, void *context, device_pm_cb cb, void *arg) { - static uint32_t current_state = DEVICE_PM_ACTIVE_STATE; + static uint32_t current_state = PM_DEVICE_ACTIVE_STATE; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t new_state = *((const uint32_t *)context); if (new_state != current_state) { @@ -1170,7 +1170,7 @@ static int uart_nrfx_pm_control(const struct device *dev, current_state = new_state; } } else { - __ASSERT_NO_MSG(ctrl_command == DEVICE_PM_GET_POWER_STATE); + __ASSERT_NO_MSG(ctrl_command == PM_DEVICE_GET_POWER_STATE); *((uint32_t *)context) = current_state; } diff --git a/drivers/serial/uart_nrfx_uarte.c b/drivers/serial/uart_nrfx_uarte.c index 14ac2a75e57..6cc6d193e34 100644 --- a/drivers/serial/uart_nrfx_uarte.c +++ b/drivers/serial/uart_nrfx_uarte.c @@ -1376,7 +1376,7 @@ static void uarte_nrfx_poll_out(const struct device *dev, unsigned char c) int key; #ifdef CONFIG_PM_DEVICE - if (data->pm_state != DEVICE_PM_ACTIVE_STATE) { + if (data->pm_state != PM_DEVICE_ACTIVE_STATE) { return; } #endif @@ -1669,7 +1669,7 @@ static int uarte_instance_init(const struct device *dev, } #ifdef CONFIG_PM_DEVICE - data->pm_state = DEVICE_PM_ACTIVE_STATE; + data->pm_state = PM_DEVICE_ACTIVE_STATE; #endif if (get_dev_config(dev)->flags & UARTE_CFG_FLAG_PPI_ENDTX) { @@ -1773,7 +1773,7 @@ static void uarte_nrfx_set_power_state(const struct device *dev, NRF_UARTE_Type *uarte = get_uarte_instance(dev); struct uarte_nrfx_data *data = get_dev_data(dev); - if (new_state == DEVICE_PM_ACTIVE_STATE) { + if (new_state == PM_DEVICE_ACTIVE_STATE) { uarte_nrfx_pins_enable(dev, true); nrf_uarte_enable(uarte); @@ -1801,14 +1801,14 @@ static void uarte_nrfx_set_power_state(const struct device *dev, #endif } } else { - __ASSERT_NO_MSG(new_state == DEVICE_PM_LOW_POWER_STATE || - new_state == DEVICE_PM_SUSPEND_STATE || - new_state == DEVICE_PM_OFF_STATE); + __ASSERT_NO_MSG(new_state == PM_DEVICE_LOW_POWER_STATE || + new_state == PM_DEVICE_SUSPEND_STATE || + new_state == PM_DEVICE_OFF_STATE); /* if pm is already not active, driver will stay indefinitely * in while loop waiting for event NRF_UARTE_EVENT_RXTO */ - if (data->pm_state != DEVICE_PM_ACTIVE_STATE) { + if (data->pm_state != PM_DEVICE_ACTIVE_STATE) { return; } @@ -1867,14 +1867,14 @@ static int uarte_nrfx_pm_control(const struct device *dev, { struct uarte_nrfx_data *data = get_dev_data(dev); - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t new_state = *((const uint32_t *)context); if (new_state != data->pm_state) { uarte_nrfx_set_power_state(dev, new_state); } } else { - __ASSERT_NO_MSG(ctrl_command == DEVICE_PM_GET_POWER_STATE); + __ASSERT_NO_MSG(ctrl_command == PM_DEVICE_GET_POWER_STATE); *((uint32_t *)context) = data->pm_state; } diff --git a/drivers/serial/uart_stm32.c b/drivers/serial/uart_stm32.c index 3a423e483f3..c9c97a634fb 100644 --- a/drivers/serial/uart_stm32.c +++ b/drivers/serial/uart_stm32.c @@ -1410,7 +1410,7 @@ static int uart_stm32_init(const struct device *dev) config->uconf.irq_config_func(dev); #endif #ifdef CONFIG_PM_DEVICE - data->pm_state = DEVICE_PM_ACTIVE_STATE; + data->pm_state = PM_DEVICE_ACTIVE_STATE; #endif /* CONFIG_PM_DEVICE */ #ifdef CONFIG_UART_ASYNC_API @@ -1428,7 +1428,7 @@ static int uart_stm32_set_power_state(const struct device *dev, struct uart_stm32_data *data = DEV_DATA(dev); /* setting a low power mode */ - if (new_state != DEVICE_PM_ACTIVE_STATE) { + if (new_state != PM_DEVICE_ACTIVE_STATE) { #ifdef USART_ISR_BUSY /* Make sure that no USART transfer is on-going */ while (LL_USART_IsActiveFlag_BUSY(UartInstance) == 1) { @@ -1466,14 +1466,14 @@ static int uart_stm32_pm_control(const struct device *dev, { struct uart_stm32_data *data = DEV_DATA(dev); - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t new_state = *((const uint32_t *)context); if (new_state != data->pm_state) { uart_stm32_set_power_state(dev, new_state); } } else { - __ASSERT_NO_MSG(ctrl_command == DEVICE_PM_GET_POWER_STATE); + __ASSERT_NO_MSG(ctrl_command == PM_DEVICE_GET_POWER_STATE); *((uint32_t *)context) = data->pm_state; } diff --git a/drivers/spi/spi_cc13xx_cc26xx.c b/drivers/spi/spi_cc13xx_cc26xx.c index c322576cf89..77c8abf18a4 100644 --- a/drivers/spi/spi_cc13xx_cc26xx.c +++ b/drivers/spi/spi_cc13xx_cc26xx.c @@ -215,7 +215,7 @@ static int spi_cc13xx_cc26xx_set_power_state(const struct device *dev, { int ret = 0; - if ((new_state == DEVICE_PM_ACTIVE_STATE) && + if ((new_state == PM_DEVICE_ACTIVE_STATE) && (new_state != get_dev_data(dev)->pm_state)) { if (get_dev_config(dev)->base == DT_INST_REG_ADDR(0)) { @@ -225,11 +225,11 @@ static int spi_cc13xx_cc26xx_set_power_state(const struct device *dev, } get_dev_data(dev)->pm_state = new_state; } else { - __ASSERT_NO_MSG(new_state == DEVICE_PM_LOW_POWER_STATE || - new_state == DEVICE_PM_SUSPEND_STATE || - new_state == DEVICE_PM_OFF_STATE); + __ASSERT_NO_MSG(new_state == PM_DEVICE_LOW_POWER_STATE || + new_state == PM_DEVICE_SUSPEND_STATE || + new_state == PM_DEVICE_OFF_STATE); - if (get_dev_data(dev)->pm_state == DEVICE_PM_ACTIVE_STATE) { + if (get_dev_data(dev)->pm_state == PM_DEVICE_ACTIVE_STATE) { SSIDisable(get_dev_config(dev)->base); /* * Release power dependency @@ -256,7 +256,7 @@ static int spi_cc13xx_cc26xx_pm_control(const struct device *dev, { int ret = 0; - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t new_state = *((const uint32_t *)context); if (new_state != get_dev_data(dev)->pm_state) { @@ -264,7 +264,7 @@ static int spi_cc13xx_cc26xx_pm_control(const struct device *dev, new_state); } } else { - __ASSERT_NO_MSG(ctrl_command == DEVICE_PM_GET_POWER_STATE); + __ASSERT_NO_MSG(ctrl_command == PM_DEVICE_GET_POWER_STATE); *((uint32_t *)context) = get_dev_data(dev)->pm_state; } @@ -338,7 +338,7 @@ static const struct spi_driver_api spi_cc13xx_cc26xx_driver_api = { #ifdef CONFIG_PM_DEVICE #define SPI_CC13XX_CC26XX_INIT_PM_STATE \ do { \ - get_dev_data(dev)->pm_state = DEVICE_PM_ACTIVE_STATE; \ + get_dev_data(dev)->pm_state = PM_DEVICE_ACTIVE_STATE; \ } while (0) #else #define SPI_CC13XX_CC26XX_INIT_PM_STATE diff --git a/drivers/spi/spi_nrfx_spi.c b/drivers/spi/spi_nrfx_spi.c index 1e6c77090bc..6ed42a5a391 100644 --- a/drivers/spi/spi_nrfx_spi.c +++ b/drivers/spi/spi_nrfx_spi.c @@ -277,7 +277,7 @@ static int init_spi(const struct device *dev) } #ifdef CONFIG_PM_DEVICE - dev_data->pm_state = DEVICE_PM_ACTIVE_STATE; + dev_data->pm_state = PM_DEVICE_ACTIVE_STATE; #endif return 0; @@ -292,21 +292,21 @@ static int spi_nrfx_pm_control(const struct device *dev, struct spi_nrfx_data *data = get_dev_data(dev); const struct spi_nrfx_config *config = get_dev_config(dev); - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t new_state = *((const uint32_t *)context); if (new_state != data->pm_state) { switch (new_state) { - case DEVICE_PM_ACTIVE_STATE: + case PM_DEVICE_ACTIVE_STATE: ret = init_spi(dev); /* Force reconfiguration before next transfer */ data->ctx.config = NULL; break; - case DEVICE_PM_LOW_POWER_STATE: - case DEVICE_PM_SUSPEND_STATE: - case DEVICE_PM_OFF_STATE: - if (data->pm_state == DEVICE_PM_ACTIVE_STATE) { + case PM_DEVICE_LOW_POWER_STATE: + case PM_DEVICE_SUSPEND_STATE: + case PM_DEVICE_OFF_STATE: + if (data->pm_state == PM_DEVICE_ACTIVE_STATE) { nrfx_spi_uninit(&config->spi); } break; @@ -319,7 +319,7 @@ static int spi_nrfx_pm_control(const struct device *dev, } } } else { - __ASSERT_NO_MSG(ctrl_command == DEVICE_PM_GET_POWER_STATE); + __ASSERT_NO_MSG(ctrl_command == PM_DEVICE_GET_POWER_STATE); *((uint32_t *)context) = data->pm_state; } diff --git a/drivers/spi/spi_nrfx_spim.c b/drivers/spi/spi_nrfx_spim.c index 6bb4ad7dcae..676178cddc4 100644 --- a/drivers/spi/spi_nrfx_spim.c +++ b/drivers/spi/spi_nrfx_spim.c @@ -324,8 +324,8 @@ static int init_spim(const struct device *dev) } #ifdef CONFIG_PM_DEVICE - data->pm_state = DEVICE_PM_ACTIVE_STATE; - get_dev_data(dev)->pm_state = DEVICE_PM_ACTIVE_STATE; + data->pm_state = PM_DEVICE_ACTIVE_STATE; + get_dev_data(dev)->pm_state = PM_DEVICE_ACTIVE_STATE; #endif return 0; @@ -340,21 +340,21 @@ static int spim_nrfx_pm_control(const struct device *dev, struct spi_nrfx_data *data = get_dev_data(dev); const struct spi_nrfx_config *config = get_dev_config(dev); - if (ctrl_command == DEVICE_PM_SET_POWER_STATE) { + if (ctrl_command == PM_DEVICE_SET_POWER_STATE) { uint32_t new_state = *((const uint32_t *)context); if (new_state != data->pm_state) { switch (new_state) { - case DEVICE_PM_ACTIVE_STATE: + case PM_DEVICE_ACTIVE_STATE: ret = init_spim(dev); /* Force reconfiguration before next transfer */ data->ctx.config = NULL; break; - case DEVICE_PM_LOW_POWER_STATE: - case DEVICE_PM_SUSPEND_STATE: - case DEVICE_PM_OFF_STATE: - if (data->pm_state == DEVICE_PM_ACTIVE_STATE) { + case PM_DEVICE_LOW_POWER_STATE: + case PM_DEVICE_SUSPEND_STATE: + case PM_DEVICE_OFF_STATE: + if (data->pm_state == PM_DEVICE_ACTIVE_STATE) { nrfx_spim_uninit(&config->spim); } break; @@ -367,7 +367,7 @@ static int spim_nrfx_pm_control(const struct device *dev, } } } else { - __ASSERT_NO_MSG(ctrl_command == DEVICE_PM_GET_POWER_STATE); + __ASSERT_NO_MSG(ctrl_command == PM_DEVICE_GET_POWER_STATE); *((uint32_t *)context) = data->pm_state; } diff --git a/include/device.h b/include/device.h index 9d5a6860754..bc5bca208c5 100644 --- a/include/device.h +++ b/include/device.h @@ -663,7 +663,7 @@ static inline int device_set_power_state(const struct device *dev, return -ENOSYS; } - return dev->device_pm_control(dev, DEVICE_PM_SET_POWER_STATE, + return dev->device_pm_control(dev, PM_DEVICE_SET_POWER_STATE, &device_power_state, cb, arg); } @@ -687,7 +687,7 @@ static inline int device_get_power_state(const struct device *dev, return -ENOSYS; } - return dev->device_pm_control(dev, DEVICE_PM_GET_POWER_STATE, + return dev->device_pm_control(dev, PM_DEVICE_GET_POWER_STATE, device_power_state, NULL, NULL); } diff --git a/include/pm/device.h b/include/pm/device.h index 2886d3db586..4b04906ce0b 100644 --- a/include/pm/device.h +++ b/include/pm/device.h @@ -24,24 +24,24 @@ extern "C" { struct device; -/** @def DEVICE_PM_ACTIVE_STATE +/** @def PM_DEVICE_ACTIVE_STATE * * @brief device is in ACTIVE power state * * @details Normal operation of the device. All device context is retained. */ -#define DEVICE_PM_ACTIVE_STATE 1 +#define PM_DEVICE_ACTIVE_STATE 1 -/** @def DEVICE_PM_LOW_POWER_STATE +/** @def PM_DEVICE_LOW_POWER_STATE * * @brief device is in LOW power state * * @details Device context is preserved by the HW and need not be * restored by the driver. */ -#define DEVICE_PM_LOW_POWER_STATE 2 +#define PM_DEVICE_LOW_POWER_STATE 2 -/** @def DEVICE_PM_SUSPEND_STATE +/** @def PM_DEVICE_SUSPEND_STATE * * @brief device is in SUSPEND power state * @@ -49,9 +49,9 @@ struct device; * Device drivers must save and restore or reinitialize any context * lost by the hardware */ -#define DEVICE_PM_SUSPEND_STATE 3 +#define PM_DEVICE_SUSPEND_STATE 3 -/** @def DEVICE_PM_FORCE_SUSPEND_STATE +/** @def PM_DEVICE_FORCE_SUSPEND_STATE * * @brief device is in force SUSPEND power state * @@ -61,9 +61,9 @@ struct device; * Most device context is lost by the hardware. Device drivers must * save and restore or reinitialize any context lost by the hardware. */ -#define DEVICE_PM_FORCE_SUSPEND_STATE 4 +#define PM_DEVICE_FORCE_SUSPEND_STATE 4 -/** @def DEVICE_PM_OFF_STATE +/** @def PM_DEVICE_OFF_STATE * * @brief device is in OFF power state * @@ -71,11 +71,11 @@ struct device; * The device context is lost when this state is entered, so the OS * software will reinitialize the device when powering it back on */ -#define DEVICE_PM_OFF_STATE 5 +#define PM_DEVICE_OFF_STATE 5 /* Constants defining support device power commands */ -#define DEVICE_PM_SET_POWER_STATE 1 -#define DEVICE_PM_GET_POWER_STATE 2 +#define PM_DEVICE_SET_POWER_STATE 1 +#define PM_DEVICE_GET_POWER_STATE 2 typedef void (*device_pm_cb)(const struct device *dev, int status, void *context, void *arg); @@ -108,7 +108,7 @@ struct device_pm { /** Bit position in device_pm::atomic_flags that records whether the * device is busy. */ -#define DEVICE_PM_ATOMIC_FLAGS_BUSY_BIT 0 +#define PM_DEVICE_ATOMIC_FLAGS_BUSY_BIT 0 /** * @brief Get name of device PM state diff --git a/kernel/device.c b/kernel/device.c index 94f7f82a16d..5a9280e0935 100644 --- a/kernel/device.c +++ b/kernel/device.c @@ -199,7 +199,7 @@ int device_any_busy_check(void) while (dev < __device_end) { if (atomic_test_bit(&dev->pm->atomic_flags, - DEVICE_PM_ATOMIC_FLAGS_BUSY_BIT)) { + PM_DEVICE_ATOMIC_FLAGS_BUSY_BIT)) { return -EBUSY; } ++dev; @@ -211,7 +211,7 @@ int device_any_busy_check(void) int device_busy_check(const struct device *dev) { if (atomic_test_bit(&dev->pm->atomic_flags, - DEVICE_PM_ATOMIC_FLAGS_BUSY_BIT)) { + PM_DEVICE_ATOMIC_FLAGS_BUSY_BIT)) { return -EBUSY; } return 0; @@ -223,7 +223,7 @@ void device_busy_set(const struct device *dev) { #ifdef CONFIG_PM_DEVICE atomic_set_bit(&dev->pm->atomic_flags, - DEVICE_PM_ATOMIC_FLAGS_BUSY_BIT); + PM_DEVICE_ATOMIC_FLAGS_BUSY_BIT); #else ARG_UNUSED(dev); #endif @@ -233,7 +233,7 @@ void device_busy_clear(const struct device *dev) { #ifdef CONFIG_PM_DEVICE atomic_clear_bit(&dev->pm->atomic_flags, - DEVICE_PM_ATOMIC_FLAGS_BUSY_BIT); + PM_DEVICE_ATOMIC_FLAGS_BUSY_BIT); #else ARG_UNUSED(dev); #endif diff --git a/samples/boards/nrf/system_off/src/main.c b/samples/boards/nrf/system_off/src/main.c index 052f02f47d3..1e2ad572be6 100644 --- a/samples/boards/nrf/system_off/src/main.c +++ b/samples/boards/nrf/system_off/src/main.c @@ -66,17 +66,17 @@ void main(void) k_busy_wait(BUSY_WAIT_S * USEC_PER_SEC); printk("Busy-wait %u s with UART off\n", BUSY_WAIT_S); - rc = device_set_power_state(cons, DEVICE_PM_LOW_POWER_STATE, NULL, NULL); + rc = device_set_power_state(cons, PM_DEVICE_LOW_POWER_STATE, NULL, NULL); k_busy_wait(BUSY_WAIT_S * USEC_PER_SEC); - rc = device_set_power_state(cons, DEVICE_PM_ACTIVE_STATE, NULL, NULL); + rc = device_set_power_state(cons, PM_DEVICE_ACTIVE_STATE, NULL, NULL); printk("Sleep %u s\n", SLEEP_S); k_sleep(K_SECONDS(SLEEP_S)); printk("Sleep %u s with UART off\n", SLEEP_S); - rc = device_set_power_state(cons, DEVICE_PM_LOW_POWER_STATE, NULL, NULL); + rc = device_set_power_state(cons, PM_DEVICE_LOW_POWER_STATE, NULL, NULL); k_sleep(K_SECONDS(SLEEP_S)); - rc = device_set_power_state(cons, DEVICE_PM_ACTIVE_STATE, NULL, NULL); + rc = device_set_power_state(cons, PM_DEVICE_ACTIVE_STATE, NULL, NULL); printk("Entering system off; press BUTTON1 to restart\n"); diff --git a/samples/drivers/spi_flash_at45/src/main.c b/samples/drivers/spi_flash_at45/src/main.c index 750b16f5cfa..b7336c9d5d2 100644 --- a/samples/drivers/spi_flash_at45/src/main.c +++ b/samples/drivers/spi_flash_at45/src/main.c @@ -151,7 +151,7 @@ void main(void) #if IS_ENABLED(CONFIG_PM_DEVICE) printk("Putting the flash device into low power state... "); - err = device_set_power_state(flash_dev, DEVICE_PM_LOW_POWER_STATE, + err = device_set_power_state(flash_dev, PM_DEVICE_LOW_POWER_STATE, NULL, NULL); if (err != 0) { printk("FAILED\n"); diff --git a/samples/sensor/apds9960/src/main.c b/samples/sensor/apds9960/src/main.c index 6223826e811..3b5e754e6d8 100644 --- a/samples/sensor/apds9960/src/main.c +++ b/samples/sensor/apds9960/src/main.c @@ -79,11 +79,11 @@ void main(void) #ifdef CONFIG_PM_DEVICE uint32_t p_state; - p_state = DEVICE_PM_LOW_POWER_STATE; + p_state = PM_DEVICE_LOW_POWER_STATE; device_set_power_state(dev, p_state, NULL, NULL); printk("set low power state for 2s\n"); k_sleep(K_MSEC(2000)); - p_state = DEVICE_PM_ACTIVE_STATE; + p_state = PM_DEVICE_ACTIVE_STATE; device_set_power_state(dev, p_state, NULL, NULL); #endif } diff --git a/samples/sensor/fdc2x1x/src/main.c b/samples/sensor/fdc2x1x/src/main.c index b1449ce0b9f..b664f82bf84 100644 --- a/samples/sensor/fdc2x1x/src/main.c +++ b/samples/sensor/fdc2x1x/src/main.c @@ -43,13 +43,13 @@ static void pm_cb(const struct device *dev, ARG_UNUSED(arg); switch (*(uint32_t *)context) { - case DEVICE_PM_ACTIVE_STATE: + case PM_DEVICE_ACTIVE_STATE: printk("Enter ACTIVE_STATE "); break; - case DEVICE_PM_LOW_POWER_STATE: + case PM_DEVICE_LOW_POWER_STATE: printk("Enter LOW_POWER_STATE "); break; - case DEVICE_PM_OFF_STATE: + case PM_DEVICE_OFF_STATE: printk("Enter OFF_STATE "); break; } @@ -97,13 +97,13 @@ void main(void) /* Testing the power modes */ uint32_t p_state; - p_state = DEVICE_PM_LOW_POWER_STATE; + p_state = PM_DEVICE_LOW_POWER_STATE; device_set_power_state(dev, p_state, pm_cb, NULL); - p_state = DEVICE_PM_OFF_STATE; + p_state = PM_DEVICE_OFF_STATE; device_set_power_state(dev, p_state, pm_cb, NULL); - p_state = DEVICE_PM_ACTIVE_STATE; + p_state = PM_DEVICE_ACTIVE_STATE; device_set_power_state(dev, p_state, pm_cb, NULL); #endif @@ -132,10 +132,10 @@ void main(void) #ifdef CONFIG_PM_DEVICE - p_state = DEVICE_PM_OFF_STATE; + p_state = PM_DEVICE_OFF_STATE; device_set_power_state(dev, p_state, pm_cb, NULL); k_sleep(K_MSEC(2000)); - p_state = DEVICE_PM_ACTIVE_STATE; + p_state = PM_DEVICE_ACTIVE_STATE; device_set_power_state(dev, p_state, pm_cb, NULL); #elif CONFIG_FDC2X1X_TRIGGER_NONE k_sleep(K_MSEC(100)); diff --git a/samples/subsys/pm/device_pm/src/dummy_driver.c b/samples/subsys/pm/device_pm/src/dummy_driver.c index b142090f5b0..398189ba081 100644 --- a/samples/subsys/pm/device_pm/src/dummy_driver.c +++ b/samples/subsys/pm/device_pm/src/dummy_driver.c @@ -41,7 +41,7 @@ static int dummy_open(const struct device *dev) async_evt.state = K_POLL_STATE_NOT_READY; k_poll_signal_reset(&dev->pm->signal); - if (result == DEVICE_PM_ACTIVE_STATE) { + if (result == PM_DEVICE_ACTIVE_STATE) { printk("Dummy device resumed\n"); ret = 0; } else { @@ -101,7 +101,7 @@ static uint32_t dummy_get_power_state(const struct device *dev) static int dummy_suspend(const struct device *dev) { printk("child suspending..\n"); - device_power_state = DEVICE_PM_SUSPEND_STATE; + device_power_state = PM_DEVICE_SUSPEND_STATE; return 0; } @@ -109,7 +109,7 @@ static int dummy_suspend(const struct device *dev) static int dummy_resume_from_suspend(const struct device *dev) { printk("child resuming..\n"); - device_power_state = DEVICE_PM_ACTIVE_STATE; + device_power_state = PM_DEVICE_ACTIVE_STATE; return 0; } @@ -121,14 +121,14 @@ static int dummy_device_pm_ctrl(const struct device *dev, int ret = 0; switch (ctrl_command) { - case DEVICE_PM_SET_POWER_STATE: - if (*((uint32_t *)context) == DEVICE_PM_ACTIVE_STATE) { + case PM_DEVICE_SET_POWER_STATE: + if (*((uint32_t *)context) == PM_DEVICE_ACTIVE_STATE) { ret = dummy_resume_from_suspend(dev); } else { ret = dummy_suspend(dev); } break; - case DEVICE_PM_GET_POWER_STATE: + case PM_DEVICE_GET_POWER_STATE: *((uint32_t *)context) = dummy_get_power_state(dev); break; default: @@ -156,7 +156,7 @@ int dummy_init(const struct device *dev) } pm_device_enable(dev); - device_power_state = DEVICE_PM_ACTIVE_STATE; + device_power_state = PM_DEVICE_ACTIVE_STATE; k_poll_event_init(&async_evt, K_POLL_TYPE_SIGNAL, K_POLL_MODE_NOTIFY_ONLY, &dev->pm->signal); diff --git a/samples/subsys/pm/device_pm/src/dummy_parent.c b/samples/subsys/pm/device_pm/src/dummy_parent.c index 2a4ea286155..729b96ee215 100644 --- a/samples/subsys/pm/device_pm/src/dummy_parent.c +++ b/samples/subsys/pm/device_pm/src/dummy_parent.c @@ -32,7 +32,7 @@ static uint32_t dummy_get_power_state(const struct device *dev) static int dummy_suspend(const struct device *dev) { printk("parent suspending..\n"); - parent_power_state = DEVICE_PM_SUSPEND_STATE; + parent_power_state = PM_DEVICE_SUSPEND_STATE; return 0; } @@ -40,7 +40,7 @@ static int dummy_suspend(const struct device *dev) static int dummy_resume_from_suspend(const struct device *dev) { printk("parent resuming..\n"); - parent_power_state = DEVICE_PM_ACTIVE_STATE; + parent_power_state = PM_DEVICE_ACTIVE_STATE; return 0; } @@ -52,14 +52,14 @@ static int dummy_parent_pm_ctrl(const struct device *dev, int ret = 0; switch (ctrl_command) { - case DEVICE_PM_SET_POWER_STATE: - if (*((uint32_t *)context) == DEVICE_PM_ACTIVE_STATE) { + case PM_DEVICE_SET_POWER_STATE: + if (*((uint32_t *)context) == PM_DEVICE_ACTIVE_STATE) { ret = dummy_resume_from_suspend(dev); } else { ret = dummy_suspend(dev); } break; - case DEVICE_PM_GET_POWER_STATE: + case PM_DEVICE_GET_POWER_STATE: *((uint32_t *)context) = dummy_get_power_state(dev); break; default: @@ -78,7 +78,7 @@ static const struct dummy_parent_api funcs = { int dummy_parent_init(const struct device *dev) { pm_device_enable(dev); - parent_power_state = DEVICE_PM_ACTIVE_STATE; + parent_power_state = PM_DEVICE_ACTIVE_STATE; return 0; } diff --git a/subsys/net/ip/net_shell.c b/subsys/net/ip/net_shell.c index bf4bca9ab37..1ab1ce618e4 100644 --- a/subsys/net/ip/net_shell.c +++ b/subsys/net/ip/net_shell.c @@ -5529,7 +5529,7 @@ static int cmd_net_suspend(const struct shell *shell, size_t argc, dev = net_if_get_device(iface); - ret = device_set_power_state(dev, DEVICE_PM_SUSPEND_STATE, + ret = device_set_power_state(dev, PM_DEVICE_SUSPEND_STATE, NULL, NULL); if (ret != 0) { PR_INFO("Iface could not be suspended: "); @@ -5574,7 +5574,7 @@ static int cmd_net_resume(const struct shell *shell, size_t argc, dev = net_if_get_device(iface); - ret = device_set_power_state(dev, DEVICE_PM_ACTIVE_STATE, + ret = device_set_power_state(dev, PM_DEVICE_ACTIVE_STATE, NULL, NULL); if (ret != 0) { PR_INFO("Iface could not be resumed\n"); diff --git a/subsys/pm/device.c b/subsys/pm/device.c index 82efd31e029..9fbb4de8801 100644 --- a/subsys/pm/device.c +++ b/subsys/pm/device.c @@ -87,17 +87,17 @@ static int _pm_devices(uint32_t state) int pm_suspend_devices(void) { - return _pm_devices(DEVICE_PM_SUSPEND_STATE); + return _pm_devices(PM_DEVICE_SUSPEND_STATE); } int pm_low_power_devices(void) { - return _pm_devices(DEVICE_PM_LOW_POWER_STATE); + return _pm_devices(PM_DEVICE_LOW_POWER_STATE); } int pm_force_suspend_devices(void) { - return _pm_devices(DEVICE_PM_FORCE_SUSPEND_STATE); + return _pm_devices(PM_DEVICE_FORCE_SUSPEND_STATE); } void pm_resume_devices(void) @@ -109,7 +109,7 @@ void pm_resume_devices(void) device_idx_t idx = pm_devices[pmi]; device_set_power_state(&all_devices[idx], - DEVICE_PM_ACTIVE_STATE, + PM_DEVICE_ACTIVE_STATE, NULL, NULL); ++pmi; } @@ -168,15 +168,15 @@ void pm_create_device_list(void) const char *device_pm_state_str(uint32_t state) { switch (state) { - case DEVICE_PM_ACTIVE_STATE: + case PM_DEVICE_ACTIVE_STATE: return "active"; - case DEVICE_PM_LOW_POWER_STATE: + case PM_DEVICE_LOW_POWER_STATE: return "low power"; - case DEVICE_PM_SUSPEND_STATE: + case PM_DEVICE_SUSPEND_STATE: return "suspend"; - case DEVICE_PM_FORCE_SUSPEND_STATE: + case PM_DEVICE_FORCE_SUSPEND_STATE: return "force suspend"; - case DEVICE_PM_OFF_STATE: + case PM_DEVICE_OFF_STATE: return "off"; default: return ""; diff --git a/subsys/pm/device_pm.c b/subsys/pm/device_pm.c index 8898a4bd955..2f31f6d7819 100644 --- a/subsys/pm/device_pm.c +++ b/subsys/pm/device_pm.c @@ -16,15 +16,15 @@ LOG_MODULE_DECLARE(power); /* Device PM states */ enum device_pm_state { - DEVICE_PM_STATE_ACTIVE = 1, - DEVICE_PM_STATE_SUSPENDED, - DEVICE_PM_STATE_SUSPENDING, - DEVICE_PM_STATE_RESUMING, + PM_DEVICE_STATE_ACTIVE = 1, + PM_DEVICE_STATE_SUSPENDED, + PM_DEVICE_STATE_SUSPENDING, + PM_DEVICE_STATE_RESUMING, }; /* Device PM request type */ -#define DEVICE_PM_SYNC (0 << 0) -#define DEVICE_PM_ASYNC (1 << 0) +#define PM_DEVICE_SYNC (0 << 0) +#define PM_DEVICE_ASYNC (1 << 0) static void device_pm_callback(const struct device *dev, int retval, void *context, void *arg) @@ -32,12 +32,12 @@ static void device_pm_callback(const struct device *dev, __ASSERT(retval == 0, "Device set power state failed"); /* Set the fsm_state */ - if (*((uint32_t *)context) == DEVICE_PM_ACTIVE_STATE) { + if (*((uint32_t *)context) == PM_DEVICE_ACTIVE_STATE) { atomic_set(&dev->pm->fsm_state, - DEVICE_PM_STATE_ACTIVE); + PM_DEVICE_STATE_ACTIVE); } else { atomic_set(&dev->pm->fsm_state, - DEVICE_PM_STATE_SUSPENDED); + PM_DEVICE_STATE_SUSPENDED); } k_work_submit(&dev->pm->work); @@ -52,34 +52,34 @@ static void pm_work_handler(struct k_work *work) uint8_t pm_state; switch (atomic_get(&dev->pm->fsm_state)) { - case DEVICE_PM_STATE_ACTIVE: + case PM_DEVICE_STATE_ACTIVE: if ((atomic_get(&dev->pm->usage) == 0) && dev->pm->enable) { atomic_set(&dev->pm->fsm_state, - DEVICE_PM_STATE_SUSPENDING); + PM_DEVICE_STATE_SUSPENDING); ret = device_set_power_state(dev, - DEVICE_PM_SUSPEND_STATE, + PM_DEVICE_SUSPEND_STATE, device_pm_callback, NULL); } else { - pm_state = DEVICE_PM_ACTIVE_STATE; + pm_state = PM_DEVICE_ACTIVE_STATE; goto fsm_out; } break; - case DEVICE_PM_STATE_SUSPENDED: + case PM_DEVICE_STATE_SUSPENDED: if ((atomic_get(&dev->pm->usage) > 0) || !dev->pm->enable) { atomic_set(&dev->pm->fsm_state, - DEVICE_PM_STATE_RESUMING); + PM_DEVICE_STATE_RESUMING); ret = device_set_power_state(dev, - DEVICE_PM_ACTIVE_STATE, + PM_DEVICE_ACTIVE_STATE, device_pm_callback, NULL); } else { - pm_state = DEVICE_PM_SUSPEND_STATE; + pm_state = PM_DEVICE_SUSPEND_STATE; goto fsm_out; } break; - case DEVICE_PM_STATE_SUSPENDING: - case DEVICE_PM_STATE_RESUMING: + case PM_DEVICE_STATE_SUSPENDING: + case PM_DEVICE_STATE_RESUMING: /* Do nothing: We are waiting for device_pm_callback() */ break; default: @@ -99,11 +99,11 @@ static int pm_device_request(const struct device *dev, { int result, signaled = 0; - __ASSERT((target_state == DEVICE_PM_ACTIVE_STATE) || - (target_state == DEVICE_PM_SUSPEND_STATE), + __ASSERT((target_state == PM_DEVICE_ACTIVE_STATE) || + (target_state == PM_DEVICE_SUSPEND_STATE), "Invalid device PM state requested"); - if (target_state == DEVICE_PM_ACTIVE_STATE) { + if (target_state == PM_DEVICE_ACTIVE_STATE) { if (atomic_inc(&dev->pm->usage) < 0) { return 0; } @@ -116,7 +116,7 @@ static int pm_device_request(const struct device *dev, k_work_submit(&dev->pm->work); /* Return in case of Async request */ - if (pm_flags & DEVICE_PM_ASYNC) { + if (pm_flags & PM_DEVICE_ASYNC) { return 0; } @@ -137,23 +137,23 @@ static int pm_device_request(const struct device *dev, int pm_device_get(const struct device *dev) { return pm_device_request(dev, - DEVICE_PM_ACTIVE_STATE, DEVICE_PM_ASYNC); + PM_DEVICE_ACTIVE_STATE, PM_DEVICE_ASYNC); } int pm_device_get_sync(const struct device *dev) { - return pm_device_request(dev, DEVICE_PM_ACTIVE_STATE, 0); + return pm_device_request(dev, PM_DEVICE_ACTIVE_STATE, 0); } int pm_device_put(const struct device *dev) { return pm_device_request(dev, - DEVICE_PM_SUSPEND_STATE, DEVICE_PM_ASYNC); + PM_DEVICE_SUSPEND_STATE, PM_DEVICE_ASYNC); } int pm_device_put_sync(const struct device *dev) { - return pm_device_request(dev, DEVICE_PM_SUSPEND_STATE, 0); + return pm_device_request(dev, PM_DEVICE_SUSPEND_STATE, 0); } void pm_device_enable(const struct device *dev) @@ -168,7 +168,7 @@ void pm_device_enable(const struct device *dev) if (!dev->pm->dev) { dev->pm->dev = dev; atomic_set(&dev->pm->fsm_state, - DEVICE_PM_STATE_SUSPENDED); + PM_DEVICE_STATE_SUSPENDED); k_work_init(&dev->pm->work, pm_work_handler); } else { k_work_submit(&dev->pm->work); diff --git a/subsys/shell/modules/device_service.c b/subsys/shell/modules/device_service.c index 90de6ef032a..4262bb9b078 100644 --- a/subsys/shell/modules/device_service.c +++ b/subsys/shell/modules/device_service.c @@ -146,7 +146,7 @@ static int cmd_device_list(const struct shell *shell, state = "DISABLED"; } else { #ifdef CONFIG_PM_DEVICE - uint32_t st = DEVICE_PM_ACTIVE_STATE; + uint32_t st = PM_DEVICE_ACTIVE_STATE; int err = device_get_power_state(dev, &st); if (!err) { diff --git a/tests/kernel/device/src/main.c b/tests/kernel/device/src/main.c index b1fb2c139fc..648422d904a 100644 --- a/tests/kernel/device/src/main.c +++ b/tests/kernel/device/src/main.c @@ -316,8 +316,8 @@ void test_dummy_device_pm(void) test_build_suspend_device_list(); - /* Set device state to DEVICE_PM_ACTIVE_STATE */ - ret = device_set_power_state(dev, DEVICE_PM_ACTIVE_STATE, NULL, NULL); + /* Set device state to PM_DEVICE_ACTIVE_STATE */ + ret = device_set_power_state(dev, PM_DEVICE_ACTIVE_STATE, NULL, NULL); if (ret == -ENOSYS) { TC_PRINT("Power management not supported on device"); ztest_test_skip(); @@ -330,19 +330,19 @@ void test_dummy_device_pm(void) ret = device_get_power_state(dev, &device_power_state); zassert_true((ret == 0), "Unable to get active state to device"); - zassert_true((device_power_state == DEVICE_PM_ACTIVE_STATE), + zassert_true((device_power_state == PM_DEVICE_ACTIVE_STATE), "Error power status"); - /* Set device state to DEVICE_PM_FORCE_SUSPEND_STATE */ + /* Set device state to PM_DEVICE_FORCE_SUSPEND_STATE */ ret = device_set_power_state(dev, - DEVICE_PM_FORCE_SUSPEND_STATE, NULL, NULL); + PM_DEVICE_FORCE_SUSPEND_STATE, NULL, NULL); zassert_true((ret == 0), "Unable to force suspend device"); ret = device_get_power_state(dev, &device_power_state); zassert_true((ret == 0), "Unable to get suspend state to device"); - zassert_true((device_power_state == DEVICE_PM_ACTIVE_STATE), + zassert_true((device_power_state == PM_DEVICE_ACTIVE_STATE), "Error power status"); } #else diff --git a/tests/net/pm/src/main.c b/tests/net/pm/src/main.c index 045395f4d2d..2d9ff59c98e 100644 --- a/tests/net/pm/src/main.c +++ b/tests/net/pm/src/main.c @@ -27,13 +27,13 @@ static int fake_dev_pm_control(const struct device *dev, uint32_t command, struct fake_dev_context *ctx = dev->data; int ret = 0; - if (command == DEVICE_PM_SET_POWER_STATE) { - if (*(uint32_t *)context == DEVICE_PM_SUSPEND_STATE) { + if (command == PM_DEVICE_SET_POWER_STATE) { + if (*(uint32_t *)context == PM_DEVICE_SUSPEND_STATE) { ret = net_if_suspend(ctx->iface); if (ret == -EBUSY) { goto out; } - } else if (*(uint32_t *)context == DEVICE_PM_ACTIVE_STATE) { + } else if (*(uint32_t *)context == PM_DEVICE_ACTIVE_STATE) { ret = net_if_resume(ctx->iface); } } else { @@ -149,14 +149,14 @@ void test_pm(void) */ k_yield(); - ret = device_set_power_state(dev, DEVICE_PM_SUSPEND_STATE, + ret = device_set_power_state(dev, PM_DEVICE_SUSPEND_STATE, NULL, NULL); zassert_true(ret == 0, "Could not set state"); zassert_true(net_if_is_suspended(iface), "net iface is not suspended"); /* Let's try to suspend it again, it should fail relevantly */ - ret = device_set_power_state(dev, DEVICE_PM_SUSPEND_STATE, + ret = device_set_power_state(dev, PM_DEVICE_SUSPEND_STATE, NULL, NULL); zassert_true(ret == -EALREADY, "Could change state"); @@ -167,13 +167,13 @@ void test_pm(void) (struct sockaddr *)&addr4, sizeof(struct sockaddr_in)); zassert_true(ret < 0, "Could send data"); - ret = device_set_power_state(dev, DEVICE_PM_ACTIVE_STATE, + ret = device_set_power_state(dev, PM_DEVICE_ACTIVE_STATE, NULL, NULL); zassert_true(ret == 0, "Could not set state"); zassert_false(net_if_is_suspended(iface), "net iface is suspended"); - ret = device_set_power_state(dev, DEVICE_PM_ACTIVE_STATE, + ret = device_set_power_state(dev, PM_DEVICE_ACTIVE_STATE, NULL, NULL); zassert_true(ret == -EALREADY, "Could change state"); diff --git a/tests/subsys/pm/power_mgmt/src/dummy_driver.c b/tests/subsys/pm/power_mgmt/src/dummy_driver.c index b4af9b29e59..789eb24e38b 100644 --- a/tests/subsys/pm/power_mgmt/src/dummy_driver.c +++ b/tests/subsys/pm/power_mgmt/src/dummy_driver.c @@ -28,13 +28,13 @@ static uint32_t dummy_get_power_state(const struct device *dev) static int dummy_suspend(const struct device *dev) { - device_power_state = DEVICE_PM_SUSPEND_STATE; + device_power_state = PM_DEVICE_SUSPEND_STATE; return 0; } static int dummy_resume_from_suspend(const struct device *dev) { - device_power_state = DEVICE_PM_ACTIVE_STATE; + device_power_state = PM_DEVICE_ACTIVE_STATE; return 0; } @@ -45,14 +45,14 @@ static int dummy_device_pm_ctrl(const struct device *dev, int ret = 0; switch (ctrl_command) { - case DEVICE_PM_SET_POWER_STATE: - if (*((uint32_t *)context) == DEVICE_PM_ACTIVE_STATE) { + case PM_DEVICE_SET_POWER_STATE: + if (*((uint32_t *)context) == PM_DEVICE_ACTIVE_STATE) { ret = dummy_resume_from_suspend(dev); } else { ret = dummy_suspend(dev); } break; - case DEVICE_PM_GET_POWER_STATE: + case PM_DEVICE_GET_POWER_STATE: *((uint32_t *)context) = dummy_get_power_state(dev); break; default: diff --git a/tests/subsys/pm/power_mgmt/src/main.c b/tests/subsys/pm/power_mgmt/src/main.c index 29eb5035363..851842c250f 100644 --- a/tests/subsys/pm/power_mgmt/src/main.c +++ b/tests/subsys/pm/power_mgmt/src/main.c @@ -42,7 +42,7 @@ __weak void pm_power_state_set(struct pm_state_info info) uint32_t device_power_state; /* at this point, devices have been deactivated */ device_get_power_state(dev, &device_power_state); - zassert_false(device_power_state == DEVICE_PM_ACTIVE_STATE, NULL); + zassert_false(device_power_state == PM_DEVICE_ACTIVE_STATE, NULL); /* this function is called when system entering low power state, so * parameter state should not be PM_STATE_ACTIVE @@ -95,7 +95,7 @@ static void notify_pm_state_entry(enum pm_state state) /* at this point, devices should not be active */ device_get_power_state(dev, &device_power_state); - zassert_false(device_power_state == DEVICE_PM_ACTIVE_STATE, NULL); + zassert_false(device_power_state == PM_DEVICE_ACTIVE_STATE, NULL); set_pm = true; notify_app_exit = true; } @@ -113,7 +113,7 @@ static void notify_pm_state_exit(enum pm_state state) /* at this point, devices are active again*/ device_get_power_state(dev, &device_power_state); - zassert_equal(device_power_state, DEVICE_PM_ACTIVE_STATE, NULL); + zassert_equal(device_power_state, PM_DEVICE_ACTIVE_STATE, NULL); leave_idle = true; } @@ -180,11 +180,11 @@ void test_power_state_notification(void) uint32_t device_power_state; device_get_power_state(dev, &device_power_state); - zassert_equal(device_power_state, DEVICE_PM_ACTIVE_STATE, NULL); + zassert_equal(device_power_state, PM_DEVICE_ACTIVE_STATE, NULL); api->close(dev); device_get_power_state(dev, &device_power_state); - zassert_equal(device_power_state, DEVICE_PM_SUSPEND_STATE, NULL); + zassert_equal(device_power_state, PM_DEVICE_SUSPEND_STATE, NULL); /* reopen device as it will be closed in teardown */ api->open(dev); }