pm: rename PM_DEVICE_STATE_SUSPEND to PM_DEVICE_STATE_SUSPENDED

The verb tense for the suspended state was not consistent with other
states. The likely reason: state was being used as a command/action.

Signed-off-by: Gerard Marull-Paretas <[email protected]>

Author: gmarull

doc/reference/power_management/index.rst

@@ -248,20 +248,20 @@ The four device power states:
 
    Device context is preserved by the HW and need not be restored by the driver.
 
-:code:`PM_DEVICE_STATE_SUSPEND`
+:code:`PM_DEVICE_STATE_SUSPENDED`
 
    Most device context is lost by the hardware. Device drivers must save and
    restore or reinitialize any context lost by the hardware.
 
 :code:`PM_DEVICE_STATE_SUSPENDING`
 
    Device is currently transitioning from :c:macro:`PM_DEVICE_STATE_ACTIVE` to
-   :c:macro:`PM_DEVICE_STATE_SUSPEND`.
+   :c:macro:`PM_DEVICE_STATE_SUSPENDED`.
 
 :code:`PM_DEVICE_STATE_RESUMING`
 
-   Device is currently transitioning from :c:macro:`PM_DEVICE_STATE_SUSPEND` to
-   :c:macro:`PM_DEVICE_STATE_ACTIVE`.
+   Device is currently transitioning from :c:macro:`PM_DEVICE_STATE_SUSPENDED`
+   to :c:macro:`PM_DEVICE_STATE_ACTIVE`.
 
 :code:`PM_DEVICE_STATE_OFF`
 

drivers/ethernet/eth_mcux.c

@@ -197,7 +197,7 @@ static int eth_mcux_device_pm_control(const struct device *dev,
 		goto out;
 	}
 
-	if (state == PM_DEVICE_STATE_SUSPEND) {
+	if (state == PM_DEVICE_STATE_SUSPENDED) {
 		LOG_DBG("Suspending");
 
 		ret = net_if_suspend(eth_ctx->iface);

drivers/flash/spi_flash_at45.c

@@ -636,7 +636,7 @@ static int spi_flash_at45_pm_control(const struct device *dev,
 		release(dev);
 		break;
 
-	case PM_DEVICE_STATE_SUSPEND:
+	case PM_DEVICE_STATE_SUSPENDED:
 	case PM_DEVICE_STATE_OFF:
 		acquire(dev);
 		power_down_op(dev,

drivers/flash/spi_nor.c

@@ -38,8 +38,8 @@ LOG_MODULE_REGISTER(spi_nor, CONFIG_FLASH_LOG_LEVEL);
  *
  * When mapped to the Zephyr Device Power Management states:
  * * PM_DEVICE_STATE_ACTIVE covers both active and standby modes;
- * * PM_DEVICE_STATE_SUSPEND, and PM_DEVICE_STATE_OFF all correspond
- *   to deep-power-down mode.
+ * * PM_DEVICE_STATE_SUSPENDED, and PM_DEVICE_STATE_OFF all correspond to
+ *   deep-power-down mode.
  */
 
 #define SPI_NOR_MAX_ADDR_WIDTH 4

drivers/gpio/gpio_dw.c

@@ -446,7 +446,7 @@ static int gpio_dw_device_ctrl(const struct device *port,
 {
 	int ret = 0;
 
-	if (state == PM_DEVICE_STATE_SUSPEND) {
+	if (state == PM_DEVICE_STATE_SUSPENDED) {
 		ret = gpio_dw_suspend_port(port);
 	} else if (state == PM_DEVICE_STATE_ACTIVE) {
 		ret = gpio_dw_resume_from_suspend_port(port);

drivers/gpio/gpio_stm32.c

@@ -581,7 +581,7 @@ static int gpio_stm32_set_power_state(const struct device *dev,
 
 	if (state == PM_DEVICE_STATE_ACTIVE) {
 		ret = gpio_stm32_clock_request(dev, true);
-	} else if (state == PM_DEVICE_STATE_SUSPEND) {
+	} else if (state == PM_DEVICE_STATE_SUSPENDED) {
 		ret = gpio_stm32_clock_request(dev, false);
 	}
 

drivers/i2c/i2c_nrfx_twi.c

@@ -230,7 +230,7 @@ static int twi_nrfx_pm_control(const struct device *dev,
 		}
 		break;
 
-	case PM_DEVICE_STATE_SUSPEND:
+	case PM_DEVICE_STATE_SUSPENDED:
 	case PM_DEVICE_STATE_OFF:
 		nrfx_twi_uninit(&get_dev_config(dev)->twi);
 		break;

drivers/i2c/i2c_nrfx_twim.c

@@ -268,7 +268,7 @@ static int twim_nrfx_pm_control(const struct device *dev,
 		}
 		break;
 
-	case PM_DEVICE_STATE_SUSPEND:
+	case PM_DEVICE_STATE_SUSPENDED:
 	case PM_DEVICE_STATE_OFF:
 		nrfx_twim_uninit(&get_dev_config(dev)->twim);
 		break;

drivers/interrupt_controller/intc_arcv2_irq_unit.c

@@ -180,7 +180,7 @@ static int arc_v2_irq_unit_device_ctrl(const struct device *dev,
 	int ret = 0;
 	unsigned int key = arch_irq_lock();
 
-	if (state == PM_DEVICE_STATE_SUSPEND) {
+	if (state == PM_DEVICE_STATE_SUSPENDED) {
 		ret = arc_v2_irq_unit_suspend(dev);
 	} else if (state == PM_DEVICE_STATE_ACTIVE) {
 		ret = arc_v2_irq_unit_resume(dev);

drivers/interrupt_controller/intc_ioapic.c

@@ -318,7 +318,7 @@ static int ioapic_device_ctrl(const struct device *dev,
 	case PM_DEVICE_STATE_ACTIVE:
 		ret = ioapic_resume_from_suspend(dev);
 		break;
-	case PM_DEVICE_STATE_SUSPEND:
+	case PM_DEVICE_STATE_SUSPENDED:
 	case PM_DEVICE_STATE_OFF:
 		ret = ioapic_suspend(dev);
 		break;

drivers/interrupt_controller/intc_loapic.c

@@ -413,7 +413,7 @@ static int loapic_device_ctrl(const struct device *port,
 {
 	int ret = 0;
 
-	if (state == PM_DEVICE_STATE_SUSPEND) {
+	if (state == PM_DEVICE_STATE_SUSPENDED) {
 		ret = loapic_suspend(port);
 	} else if (state == PM_DEVICE_STATE_ACTIVE) {
 		ret = loapic_resume(port);

drivers/modem/modem_receiver.c

@@ -199,7 +199,7 @@ int mdm_receiver_sleep(struct mdm_receiver_context *ctx)
 {
 	uart_irq_rx_disable(ctx->uart_dev);
 #ifdef CONFIG_PM_DEVICE
-	pm_device_state_set(ctx->uart_dev, PM_DEVICE_STATE_SUSPEND);
+	pm_device_state_set(ctx->uart_dev, PM_DEVICE_STATE_SUSPENDED);
 #endif
 	return 0;
 }

drivers/pwm/pwm_nrfx.c

@@ -301,7 +301,7 @@ static int pwm_nrfx_set_power_state(enum pm_device_state state,
 	case PM_DEVICE_STATE_ACTIVE:
 		err = pwm_nrfx_init(dev);
 		break;
-	case PM_DEVICE_STATE_SUSPEND:
+	case PM_DEVICE_STATE_SUSPENDED:
 	case PM_DEVICE_STATE_OFF:
 		pwm_nrfx_uninit(dev);
 		break;

drivers/sensor/bmp388/bmp388.c

@@ -556,7 +556,7 @@ static int bmp388_set_power_state(const struct device *dev,
 
 	if (state == PM_DEVICE_STATE_ACTIVE) {
 		reg_val = BMP388_PWR_CTRL_MODE_NORMAL;
-	} else if ((state == PM_DEVICE_STATE_SUSPEND) ||
+	} else if ((state == PM_DEVICE_STATE_SUSPENDED) ||
 		   (state == PM_DEVICE_STATE_OFF)) {
 		reg_val = BMP388_PWR_CTRL_MODE_SLEEP;
 	} else {

drivers/sensor/fdc2x1x/fdc2x1x.c

@@ -506,7 +506,7 @@ static int fdc2x1x_set_pm_state(const struct device *dev,
 		}
 
 		break;
-	case PM_DEVICE_STATE_SUSPEND:
+	case PM_DEVICE_STATE_SUSPENDED:
 		if (curr_state == PM_DEVICE_STATE_OFF) {
 			ret = fdc2x1x_set_shutdown(dev, false);
 			if (ret) {

drivers/sensor/sgp40/sgp40.c

@@ -195,7 +195,7 @@ static int sgp40_set_power_state(const struct device *dev,
 	if (power_state == PM_DEVICE_STATE_ACTIVE) {
 		/* activate the hotplate by sending a measure command */
 		cmd = SGP40_CMD_MEASURE_RAW;
-	} else if (power_state == PM_DEVICE_STATE_SUSPEND) {
+	} else if (power_state == PM_DEVICE_STATE_SUSPENDED) {
 		cmd = SGP40_CMD_HEATER_OFF;
 	} else {
 		LOG_DBG("Power state not implemented.");

drivers/serial/uart_npcx.c

@@ -442,7 +442,7 @@ static inline int uart_npcx_set_power_state(const struct device *dev,
 					    enum pm_device_state next_state)
 {
 	/* If next device power state is LOW or SUSPEND power state */
-	if (next_state == PM_DEVICE_STATE_SUSPEND) {
+	if (next_state == PM_DEVICE_STATE_SUSPENDED) {
 		/*
 		 * If uart device is busy with transmitting, the driver will
 		 * stay in while loop and wait for the transaction is completed.

drivers/spi/spi_nrfx_spi.c

@@ -291,7 +291,7 @@ static int spi_nrfx_pm_control(const struct device *dev,
 		data->ctx.config = NULL;
 		break;
 
-	case PM_DEVICE_STATE_SUSPEND:
+	case PM_DEVICE_STATE_SUSPENDED:
 	case PM_DEVICE_STATE_OFF:
 		nrfx_spi_uninit(&config->spi);
 		break;

drivers/spi/spi_nrfx_spim.c

@@ -338,7 +338,7 @@ static int spim_nrfx_pm_control(const struct device *dev,
 		data->ctx.config = NULL;
 		break;
 
-	case PM_DEVICE_STATE_SUSPEND:
+	case PM_DEVICE_STATE_SUSPENDED:
 	case PM_DEVICE_STATE_OFF:
 		nrfx_spim_uninit(&config->spim);
 		break;

include/pm/device.h

@@ -41,7 +41,7 @@ enum pm_device_state {
 	 * @note
 	 *     Device context may be lost.
 	 */
-	PM_DEVICE_STATE_SUSPEND,
+	PM_DEVICE_STATE_SUSPENDED,
 	/**
 	 * Device is suspended (forced).
 	 *

samples/boards/nrf/system_off/src/main.c

@@ -66,15 +66,15 @@ 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 = pm_device_state_set(cons, PM_DEVICE_STATE_SUSPEND);
+	rc = pm_device_state_set(cons, PM_DEVICE_STATE_SUSPENDED);
 	k_busy_wait(BUSY_WAIT_S * USEC_PER_SEC);
 	rc = pm_device_state_set(cons, PM_DEVICE_STATE_ACTIVE);
 
 	printk("Sleep %u s\n", SLEEP_S);
 	k_sleep(K_SECONDS(SLEEP_S));
 
 	printk("Sleep %u s with UART off\n", SLEEP_S);
-	rc = pm_device_state_set(cons, PM_DEVICE_STATE_SUSPEND);
+	rc = pm_device_state_set(cons, PM_DEVICE_STATE_SUSPENDED);
 	k_sleep(K_SECONDS(SLEEP_S));
 	rc = pm_device_state_set(cons, PM_DEVICE_STATE_ACTIVE);
 

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 suspended state... ");
-	err = pm_device_state_set(flash_dev, PM_DEVICE_STATE_SUSPEND);
+	err = pm_device_state_set(flash_dev, PM_DEVICE_STATE_SUSPENDED);
 	if (err != 0) {
 		printk("FAILED\n");
 		return;

samples/sensor/apds9960/src/main.c

@@ -79,7 +79,7 @@ void main(void)
 #ifdef CONFIG_PM_DEVICE
 		enum pm_device_state p_state;
 
-		p_state = PM_DEVICE_STATE_SUSPEND;
+		p_state = PM_DEVICE_STATE_SUSPENDED;
 		pm_device_state_set(dev, p_state);
 		printk("set low power state for 2s\n");
 		k_sleep(K_MSEC(2000));

samples/sensor/fdc2x1x/src/main.c

@@ -43,7 +43,7 @@ static void pm_info(enum pm_device_state state, int status)
 	case PM_DEVICE_STATE_ACTIVE:
 		printk("Enter ACTIVE_STATE ");
 		break;
-	case PM_DEVICE_STATE_SUSPEND:
+	case PM_DEVICE_STATE_SUSPENDED:
 		printk("Enter SUSPEND_STATE ");
 		break;
 	case PM_DEVICE_STATE_OFF:
@@ -95,7 +95,7 @@ void main(void)
 	enum pm_device_state p_state;
 	int ret;
 
-	p_state = PM_DEVICE_STATE_SUSPEND;
+	p_state = PM_DEVICE_STATE_SUSPENDED;
 	ret = pm_device_state_set(dev, p_state);
 	pm_info(p_state, ret);
 

subsys/net/ip/net_shell.c

@@ -5532,7 +5532,7 @@ static int cmd_net_suspend(const struct shell *shell, size_t argc,
 
 		dev = net_if_get_device(iface);
 
-		ret = pm_device_state_set(dev, PM_DEVICE_STATE_SUSPEND);
+		ret = pm_device_state_set(dev, PM_DEVICE_STATE_SUSPENDED);
 		if (ret != 0) {
 			PR_INFO("Iface could not be suspended: ");
 

subsys/pm/device.c

@@ -84,7 +84,7 @@ static int _pm_devices(uint32_t state)
 
 int pm_suspend_devices(void)
 {
-	return _pm_devices(PM_DEVICE_STATE_SUSPEND);
+	return _pm_devices(PM_DEVICE_STATE_SUSPENDED);
 }
 
 int pm_low_power_devices(void)
@@ -117,8 +117,8 @@ const char *pm_device_state_str(enum pm_device_state state)
 		return "active";
 	case PM_DEVICE_STATE_LOW_POWER:
 		return "low power";
-	case PM_DEVICE_STATE_SUSPEND:
-		return "suspend";
+	case PM_DEVICE_STATE_SUSPENDED:
+		return "suspended";
 	case PM_DEVICE_STATE_FORCE_SUSPEND:
 		return "force suspend";
 	case PM_DEVICE_STATE_OFF:
@@ -138,8 +138,8 @@ int pm_device_state_set(const struct device *dev,
 	}
 
 	switch (state) {
-	case PM_DEVICE_STATE_SUSPEND:
-		if ((dev->pm->state == PM_DEVICE_STATE_SUSPEND) ||
+	case PM_DEVICE_STATE_SUSPENDED:
+		if ((dev->pm->state == PM_DEVICE_STATE_SUSPENDED) ||
 		    (dev->pm->state == PM_DEVICE_STATE_SUSPENDING)) {
 			return -EALREADY;
 		}

subsys/pm/device_runtime.c

@@ -27,13 +27,13 @@ static void pm_device_runtime_state_set(struct pm_device *pm)
 	switch (dev->pm->state) {
 	case PM_DEVICE_STATE_ACTIVE:
 		if ((dev->pm->usage == 0) && dev->pm->enable) {
-			ret = pm_device_state_set(dev, PM_DEVICE_STATE_SUSPEND);
+			ret = pm_device_state_set(dev, PM_DEVICE_STATE_SUSPENDED);
 			if (ret == 0) {
-				dev->pm->state = PM_DEVICE_STATE_SUSPEND;
+				dev->pm->state = PM_DEVICE_STATE_SUSPENDED;
 			}
 		}
 		break;
-	case PM_DEVICE_STATE_SUSPEND:
+	case PM_DEVICE_STATE_SUSPENDED:
 		if ((dev->pm->usage > 0) || !dev->pm->enable) {
 			ret = pm_device_state_set(dev, PM_DEVICE_STATE_ACTIVE);
 			if (ret == 0) {
@@ -77,7 +77,7 @@ static int pm_device_request(const struct device *dev,
 	SYS_PORT_TRACING_FUNC_ENTER(pm, device_request, dev, target_state);
 
 	__ASSERT((target_state == PM_DEVICE_STATE_ACTIVE) ||
-			(target_state == PM_DEVICE_STATE_SUSPEND),
+			(target_state == PM_DEVICE_STATE_SUSPENDED),
 			"Invalid device PM state requested");
 
 	if (k_is_pre_kernel()) {
@@ -101,7 +101,7 @@ static int pm_device_request(const struct device *dev,
 		if (dev->pm->usage == 1) {
 			(void)pm_device_state_set(dev, PM_DEVICE_STATE_ACTIVE);
 		} else if (dev->pm->usage == 0) {
-			(void)pm_device_state_set(dev, PM_DEVICE_STATE_SUSPEND);
+			(void)pm_device_state_set(dev, PM_DEVICE_STATE_SUSPENDED);
 		}
 		goto out;
 	}
@@ -164,12 +164,12 @@ int pm_device_get_async(const struct device *dev)
 
 int pm_device_put(const struct device *dev)
 {
-	return pm_device_request(dev, PM_DEVICE_STATE_SUSPEND, 0);
+	return pm_device_request(dev, PM_DEVICE_STATE_SUSPENDED, 0);
 }
 
 int pm_device_put_async(const struct device *dev)
 {
-	return pm_device_request(dev, PM_DEVICE_STATE_SUSPEND, PM_DEVICE_ASYNC);
+	return pm_device_request(dev, PM_DEVICE_STATE_SUSPENDED, PM_DEVICE_ASYNC);
 }
 
 void pm_device_enable(const struct device *dev)
@@ -179,7 +179,7 @@ void pm_device_enable(const struct device *dev)
 		dev->pm->dev = dev;
 		if (dev->pm_control != NULL) {
 			dev->pm->enable = true;
-			dev->pm->state = PM_DEVICE_STATE_SUSPEND;
+			dev->pm->state = PM_DEVICE_STATE_SUSPENDED;
 			k_work_init_delayable(&dev->pm->work, pm_work_handler);
 		}
 		goto out;
@@ -199,7 +199,7 @@ void pm_device_enable(const struct device *dev)
 	 */
 	if (!dev->pm->dev) {
 		dev->pm->dev = dev;
-		dev->pm->state = PM_DEVICE_STATE_SUSPEND;
+		dev->pm->state = PM_DEVICE_STATE_SUSPENDED;
 		k_work_init_delayable(&dev->pm->work, pm_work_handler);
 	} else {
 		k_work_schedule(&dev->pm->work, K_NO_WAIT);