pm: rename PM_DEVICE_STATE_SUSPEND to PM_DEVICE_STATE_SUSPENDED

gmarull · nashif · commit d41dadc569e1 · 2021-08-04T08:23:01.000-04:00
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 &lt;gerard.marull@nordicsemi.no&gt;
diff --git a/doc/reference/power_management/index.rst b/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`
 
diff --git a/drivers/ethernet/eth_mcux.c b/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);
diff --git a/drivers/flash/spi_flash_at45.c b/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,
diff --git a/drivers/flash/spi_nor.c b/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
diff --git a/drivers/gpio/gpio_dw.c b/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);
diff --git a/drivers/gpio/gpio_stm32.c b/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);
 	}
 
diff --git a/drivers/i2c/i2c_nrfx_twi.c b/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;
diff --git a/drivers/i2c/i2c_nrfx_twim.c b/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;
diff --git a/drivers/interrupt_controller/intc_arcv2_irq_unit.c b/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);
diff --git a/drivers/interrupt_controller/intc_ioapic.c b/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;
diff --git a/drivers/interrupt_controller/intc_loapic.c b/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);
diff --git a/drivers/modem/modem_receiver.c b/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;
 }
diff --git a/drivers/pwm/pwm_nrfx.c b/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;
diff --git a/drivers/sensor/bmp388/bmp388.c b/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 {
diff --git a/drivers/sensor/fdc2x1x/fdc2x1x.c b/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) {
diff --git a/drivers/sensor/sgp40/sgp40.c b/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.");
diff --git a/drivers/serial/uart_npcx.c b/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.
diff --git a/drivers/spi/spi_nrfx_spi.c b/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;
diff --git a/drivers/spi/spi_nrfx_spim.c b/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;
diff --git a/include/pm/device.h b/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).
 	 *
diff --git a/samples/boards/nrf/system_off/src/main.c b/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);
 
diff --git 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 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;
diff --git a/samples/sensor/apds9960/src/main.c b/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));
diff --git a/samples/sensor/fdc2x1x/src/main.c b/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);
 
diff --git a/subsys/net/ip/net_shell.c b/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: ");
 
diff --git a/subsys/pm/device.c b/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;
 		}
diff --git a/subsys/pm/device_runtime.c b/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);
diff --git a/tests/drivers/uart/uart_pm/src/main.c b/tests/drivers/uart/uart_pm/src/main.c
diff --git a/tests/kernel/device/src/main.c b/tests/kernel/device/src/main.c
diff --git a/tests/net/pm/src/main.c b/tests/net/pm/src/main.c
diff --git a/tests/subsys/pm/device_runtime/src/main.c b/tests/subsys/pm/device_runtime/src/main.c
diff --git a/tests/subsys/pm/power_mgmt/src/main.c b/tests/subsys/pm/power_mgmt/src/main.c

Original file line number	Diff line number	Diff line change
`@@ -197,7 +197,7 @@ static int eth_mcux_device_pm_control(const struct device *dev,`
`197`	`197`	`goto out;`
`198`	`198`	`}`
`199`	`199`
`200`		`- if (state == PM_DEVICE_STATE_SUSPEND) {`
	`200`	`+ if (state == PM_DEVICE_STATE_SUSPENDED) {`
`201`	`201`	`LOG_DBG("Suspending");`
`202`	`202`
`203`	`203`	`ret = net_if_suspend(eth_ctx->iface);`
Original file line number	Diff line number	Diff line change
`@@ -446,7 +446,7 @@ static int gpio_dw_device_ctrl(const struct device *port,`
`446`	`446`	`{`
`447`	`447`	`int ret = 0;`
`448`	`448`
`449`		`- if (state == PM_DEVICE_STATE_SUSPEND) {`
	`449`	`+ if (state == PM_DEVICE_STATE_SUSPENDED) {`
`450`	`450`	`ret = gpio_dw_suspend_port(port);`
`451`	`451`	`} else if (state == PM_DEVICE_STATE_ACTIVE) {`
`452`	`452`	`ret = gpio_dw_resume_from_suspend_port(port);`
Original file line number	Diff line number	Diff line change
`@@ -581,7 +581,7 @@ static int gpio_stm32_set_power_state(const struct device *dev,`
`581`	`581`
`582`	`582`	`if (state == PM_DEVICE_STATE_ACTIVE) {`
`583`	`583`	`ret = gpio_stm32_clock_request(dev, true);`
`584`		`- } else if (state == PM_DEVICE_STATE_SUSPEND) {`
	`584`	`+ } else if (state == PM_DEVICE_STATE_SUSPENDED) {`
`585`	`585`	`ret = gpio_stm32_clock_request(dev, false);`
`586`	`586`	`}`
`587`	`587`
Original file line number	Diff line number	Diff line change
`@@ -230,7 +230,7 @@ static int twi_nrfx_pm_control(const struct device *dev,`
`230`	`230`	`}`
`231`	`231`	`break;`
`232`	`232`
`233`		`- case PM_DEVICE_STATE_SUSPEND:`
	`233`	`+ case PM_DEVICE_STATE_SUSPENDED:`
`234`	`234`	`case PM_DEVICE_STATE_OFF:`
`235`	`235`	`nrfx_twi_uninit(&get_dev_config(dev)->twi);`
`236`	`236`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -268,7 +268,7 @@ static int twim_nrfx_pm_control(const struct device *dev,`
`268`	`268`	`}`
`269`	`269`	`break;`
`270`	`270`
`271`		`- case PM_DEVICE_STATE_SUSPEND:`
	`271`	`+ case PM_DEVICE_STATE_SUSPENDED:`
`272`	`272`	`case PM_DEVICE_STATE_OFF:`
`273`	`273`	`nrfx_twim_uninit(&get_dev_config(dev)->twim);`
`274`	`274`	`break;`