Unverified Commit 45d0376e authored by Mark Brown's avatar Mark Brown
Browse files

treewide: Remove redundant 

Merge series from Sakari Ailus <sakari.ailus@linux.intel.com>:

Late last year I posted a set to switch to __pm_runtime_mark_last_busy()
and gradually get rid of explicit pm_runtime_mark_last_busy() calls in
drivers, embedding them in the appropriate pm_runtime_*autosuspend*()
calls. The overall feedback I got at the time was that this is an
unnecessary intermediate step, and removing the
pm_runtime_mark_last_busy() calls can be done after adding them to the
relevant Runtime PM autosuspend related functions.
parents 51106b83 2fca7501

Documentation/power/runtime_pm.rst

+23 −27
Original line number Diff line number Diff line
@@ -154,11 +154,9 @@ suspending the device are satisfied) and to queue up a suspend request for the 
device in that case.  If there is no idle callback, or if the callback returns

0, then the PM core will attempt to carry out a runtime suspend of the device,

also respecting devices configured for autosuspend.  In essence this means a

call to pm_runtime_autosuspend() (do note that drivers needs to update the

device last busy mark, pm_runtime_mark_last_busy(), to control the delay under

this circumstance).  To prevent this (for example, if the callback routine has

started a delayed suspend), the routine must return a non-zero value.  Negative

error return codes are ignored by the PM core.

call to pm_runtime_autosuspend(). To prevent this (for example, if the callback

routine has started a delayed suspend), the routine must return a non-zero

value.  Negative error return codes are ignored by the PM core.



The helper functions provided by the PM core, described in Section 4, guarantee

that the following constraints are met with respect to runtime PM callbacks for
@@ -330,10 +328,9 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h: 
      'power.disable_depth' is different from 0



  `int pm_runtime_autosuspend(struct device *dev);`

    - same as pm_runtime_suspend() except that the autosuspend delay is taken

      `into account;` if pm_runtime_autosuspend_expiration() says the delay has

      not yet expired then an autosuspend is scheduled for the appropriate time

      and 0 is returned

    - same as pm_runtime_suspend() except that a call to

      pm_runtime_mark_last_busy() is made and an autosuspend is scheduled for

      the appropriate time and 0 is returned



  `int pm_runtime_resume(struct device *dev);`

    - execute the subsystem-level resume callback for the device; returns 0 on
@@ -357,9 +354,9 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h: 
      success or error code if the request has not been queued up



  `int pm_request_autosuspend(struct device *dev);`

    - schedule the execution of the subsystem-level suspend callback for the

      device when the autosuspend delay has expired; if the delay has already

      expired then the work item is queued up immediately

    - Call pm_runtime_mark_last_busy() and schedule the execution of the

      subsystem-level suspend callback for the device when the autosuspend delay

      expires



  `int pm_schedule_suspend(struct device *dev, unsigned int delay);`

    - schedule the execution of the subsystem-level suspend callback for the
@@ -411,8 +408,9 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h: 
      pm_request_idle(dev) and return its result



  `int pm_runtime_put_autosuspend(struct device *dev);`

    - does the same as __pm_runtime_put_autosuspend() for now, but in the

      future, will also call pm_runtime_mark_last_busy() as well, DO NOT USE!

    - set the power.last_busy field to the current time and decrement the

      device's usage counter; if the result is 0 then run

      pm_request_autosuspend(dev) and return its result



  `int __pm_runtime_put_autosuspend(struct device *dev);`

    - decrement the device's usage counter; if the result is 0 then run
@@ -427,7 +425,8 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h: 
      pm_runtime_suspend(dev) and return its result



  `int pm_runtime_put_sync_autosuspend(struct device *dev);`

    - decrement the device's usage counter; if the result is 0 then run

    - set the power.last_busy field to the current time and decrement the

      device's usage counter; if the result is 0 then run

      pm_runtime_autosuspend(dev) and return its result



  `void pm_runtime_enable(struct device *dev);`
@@ -870,11 +869,9 @@ device is automatically suspended (the subsystem or driver still has to call 
the appropriate PM routines); rather it means that runtime suspends will

automatically be delayed until the desired period of inactivity has elapsed.



Inactivity is determined based on the power.last_busy field.  Drivers should

call pm_runtime_mark_last_busy() to update this field after carrying out I/O,

typically just before calling __pm_runtime_put_autosuspend().  The desired

length of the inactivity period is a matter of policy.  Subsystems can set this

length initially by calling pm_runtime_set_autosuspend_delay(), but after device

Inactivity is determined based on the power.last_busy field. The desired length

of the inactivity period is a matter of policy.  Subsystems can set this length

initially by calling pm_runtime_set_autosuspend_delay(), but after device

registration the length should be controlled by user space, using the

/sys/devices/.../power/autosuspend_delay_ms attribute.
@@ -885,12 +882,13 @@ instead of the non-autosuspend counterparts:: 


	Instead of: pm_runtime_suspend    use: pm_runtime_autosuspend;

	Instead of: pm_schedule_suspend   use: pm_request_autosuspend;

	Instead of: pm_runtime_put        use: __pm_runtime_put_autosuspend;

	Instead of: pm_runtime_put        use: pm_runtime_put_autosuspend;

	Instead of: pm_runtime_put_sync   use: pm_runtime_put_sync_autosuspend.



Drivers may also continue to use the non-autosuspend helper functions; they

will behave normally, which means sometimes taking the autosuspend delay into

account (see pm_runtime_idle).

account (see pm_runtime_idle). The autosuspend variants of the functions also

call pm_runtime_mark_last_busy().



Under some circumstances a driver or subsystem may want to prevent a device

from autosuspending immediately, even though the usage counter is zero and the
@@ -922,12 +920,10 @@ Here is a schematic pseudo-code example:: 
	foo_io_completion(struct foo_priv *foo, void *req)

	{

		lock(&foo->private_lock);

		if (--foo->num_pending_requests == 0) {

			pm_runtime_mark_last_busy(&foo->dev);

			__pm_runtime_put_autosuspend(&foo->dev);

		} else {

		if (--foo->num_pending_requests == 0)

			pm_runtime_put_autosuspend(&foo->dev);

		else

			foo_process_next_request(foo);

		}

		unlock(&foo->private_lock);

		/* Send req result back to the user ... */

	}

drivers/spi/atmel-quadspi.c

+0 −5
Original line number Diff line number Diff line
@@ -965,7 +965,6 @@ static int atmel_qspi_exec_op(struct spi_mem *mem, const struct spi_mem_op *op) 
	err = aq->ops->transfer(mem, op, offset);



pm_runtime_put:

	pm_runtime_mark_last_busy(&aq->pdev->dev);

	pm_runtime_put_autosuspend(&aq->pdev->dev);

	return err;

}
@@ -1168,7 +1167,6 @@ static int atmel_qspi_setup(struct spi_device *spi) 
	aq->scr |= QSPI_SCR_SCBR(scbr);

	atmel_qspi_write(aq->scr, aq, QSPI_SCR);



	pm_runtime_mark_last_busy(ctrl->dev.parent);

	pm_runtime_put_autosuspend(ctrl->dev.parent);



	return 0;
@@ -1230,7 +1228,6 @@ static int atmel_qspi_set_cs_timing(struct spi_device *spi) 
	aq->mr |= QSPI_MR_DLYBCT(cs_hold) | QSPI_MR_DLYCS(cs_inactive);

	atmel_qspi_write(aq->mr, aq, QSPI_MR);



	pm_runtime_mark_last_busy(ctrl->dev.parent);

	pm_runtime_put_autosuspend(ctrl->dev.parent);



	return 0;
@@ -1435,7 +1432,6 @@ static int atmel_qspi_probe(struct platform_device *pdev) 
	if (err)

		return err;



	pm_runtime_mark_last_busy(&pdev->dev);

	pm_runtime_put_autosuspend(&pdev->dev);



	return 0;
@@ -1560,7 +1556,6 @@ static int __maybe_unused atmel_qspi_resume(struct device *dev) 


	atmel_qspi_write(aq->scr, aq, QSPI_SCR);



	pm_runtime_mark_last_busy(dev);

	pm_runtime_put_autosuspend(dev);



	return 0;

drivers/spi/spi-cadence-quadspi.c

+0 −2
Original line number Diff line number Diff line
@@ -1469,7 +1469,6 @@ static int cqspi_exec_mem_op(struct spi_mem *mem, const struct spi_mem_op *op) 


	ret = cqspi_mem_process(mem, op);



	pm_runtime_mark_last_busy(dev);

	pm_runtime_put_autosuspend(dev);



	if (ret)
@@ -1975,7 +1974,6 @@ static int cqspi_probe(struct platform_device *pdev) 
		goto probe_setup_failed;

	}



	pm_runtime_mark_last_busy(dev);

	pm_runtime_put_autosuspend(dev);



	return 0;

drivers/spi/spi-cadence.c

+0 −1
Original line number Diff line number Diff line
@@ -662,7 +662,6 @@ static int cdns_spi_probe(struct platform_device *pdev) 
		/* Set to default valid value */

		ctlr->max_speed_hz = xspi->clk_rate / 4;

		xspi->speed_hz = ctlr->max_speed_hz;

		pm_runtime_mark_last_busy(&pdev->dev);

		pm_runtime_put_autosuspend(&pdev->dev);

	} else {

		ctlr->mode_bits |= SPI_NO_CS;

drivers/spi/spi-fsl-espi.c

+0 −2
Original line number Diff line number Diff line
@@ -513,7 +513,6 @@ static int fsl_espi_setup(struct spi_device *spi) 


	fsl_espi_setup_transfer(spi, NULL);



	pm_runtime_mark_last_busy(espi->dev);

	pm_runtime_put_autosuspend(espi->dev);



	return 0;
@@ -726,7 +725,6 @@ static int fsl_espi_probe(struct device *dev, struct resource *mem, 


	dev_info(dev, "irq = %u\n", irq);



	pm_runtime_mark_last_busy(dev);

	pm_runtime_put_autosuspend(dev);



	return 0;