tree 721dcf8259d440bf792412ad8ccdc6ebc4e26a1c
parent 32ce3bb57b6b402de2aec1012511e7ac4e7449dc
author Théo Lebrun <theo.lebrun@bootlin.com> 1708596750 +0100
committer Mark Brown <broonie@kernel.org> 1708604708 +0000
gpgsig -----BEGIN PGP SIGNATURE-----
 
 iQEzBAABCgAdFiEEreZoqmdXGLWf4p/qJNaLcl1Uh9AFAmXXPSQACgkQJNaLcl1U
 h9C8DggAg9Rom3h6ffLTYldWYUMDaacrR7cgBA0Qy07t/xkox4K7JrvZQ+guat6K
 KRIv6N+rnuIVxY99p/7YQdc3HORsUULln9Vrp92sLpc+GeTm/lNWjTWhcid3irRW
 rOTVQActfEuhY6NdXbJfG3pveZxnYbmqh3TDB5wKKUbsCsQKotfa6CNPoPY46byo
 5ELSGDo7hTlhueb4yqwsS0DHFcQyzkH84Fw0dgI6bYCOH7D08VxXPMp9lTDJ08CO
 a2JF1VkJrZP/wTh6evdFPZlmBZLleDxg3I7jM4rvcVvRc1AaqRL+TaECOHBax6hM
 LNlc4yrmF38De4H5STApVvUiWVBAkg==
 =fLtx
 -----END PGP SIGNATURE-----

spi: cadence-qspi: remove system-wide suspend helper calls from runtime PM hooks

The ->runtime_suspend() and ->runtime_resume() callbacks are not
expected to call spi_controller_suspend() and spi_controller_resume().
Remove calls to those in the cadence-qspi driver.

Those helpers have two roles currently:
 - They stop/start the queue, including dealing with the kworker.
 - They toggle the SPI controller SPI_CONTROLLER_SUSPENDED flag. It
   requires acquiring ctlr->bus_lock_mutex.

Step one is irrelevant because cadence-qspi is not queued. Step two
however has two implications:
 - A deadlock occurs, because ->runtime_resume() is called in a context
   where the lock is already taken (in the ->exec_op() callback, where
   the usage count is incremented).
 - It would disallow all operations once the device is auto-suspended.

Here is a brief call tree highlighting the mutex deadlock:

spi_mem_exec_op()
        ...
        spi_mem_access_start()
                mutex_lock(&ctlr->bus_lock_mutex)

        cqspi_exec_mem_op()
                pm_runtime_resume_and_get()
                        cqspi_resume()
                                spi_controller_resume()
                                        mutex_lock(&ctlr->bus_lock_mutex)
                ...

        spi_mem_access_end()
                mutex_unlock(&ctlr->bus_lock_mutex)
        ...

Fixes: 0578a6dbfe75 ("spi: spi-cadence-quadspi: add runtime pm support")
Signed-off-by: Théo Lebrun <theo.lebrun@bootlin.com>
Link: https://msgid.link/r/20240222-cdns-qspi-pm-fix-v4-2-6b6af8bcbf59@bootlin.com
Signed-off-by: Mark Brown <broonie@kernel.org>
