niansa-misc/linux
1
0
Fork 0
mirror of synced 2025-03-06 20:59:54 +01:00
Code Issues Projects Releases Packages Wiki Activity

spi: Fix deadlock when adding SPI controllers on SPI buses

Browse source 
Currently we have a global spi_add_lock which we take when adding new
devices so that we can check that we're not trying to reuse a chip
select that's already controlled.  This means that if the SPI device is
itself a SPI controller and triggers the instantiation of further SPI
devices we trigger a deadlock as we try to register and instantiate
those devices while in the process of doing so for the parent controller
and hence already holding the global spi_add_lock.  Since we only care
about concurrency within a single SPI bus move the lock to be per
controller, avoiding the deadlock.

This can be easily triggered in the case of spi-mux.

Reported-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
This commit is contained in:
Mark Brown 2021-10-08 14:31:57 +01:00
parent 75b3cb97eb
commit 6098475d4c
No known key found for this signature in database
GPG key ID: 24D68B725D5487D0
2 changed files with 9 additions and 11 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
drivers/spi/spi.c
View file

@ -478,12 +478,6 @@ static LIST_HEAD(spi_controller_list);
*/ */
static DEFINE_MUTEX(board_lock); static DEFINE_MUTEX(board_lock);
/*
* Prevents addition of devices with same chip select and
* addition of devices below an unregistering controller.
*/
static DEFINE_MUTEX(spi_add_lock);
/** /**
* spi_alloc_device - Allocate a new SPI device * spi_alloc_device - Allocate a new SPI device
* @ctlr: Controller to which device is connected * @ctlr: Controller to which device is connected
@ -636,9 +630,9 @@ int spi_add_device(struct spi_device *spi)
* chipselect **BEFORE** we call setup(), else we'll trash * chipselect **BEFORE** we call setup(), else we'll trash
* its configuration. Lock against concurrent add() calls. * its configuration. Lock against concurrent add() calls.
*/ */
mutex_lock(&spi_add_lock); mutex_lock(&ctlr->add_lock);
status = __spi_add_device(spi); status = __spi_add_device(spi);
mutex_unlock(&spi_add_lock); mutex_unlock(&ctlr->add_lock);
return status; return status;
} }
EXPORT_SYMBOL_GPL(spi_add_device); EXPORT_SYMBOL_GPL(spi_add_device);
@ -658,7 +652,7 @@ static int spi_add_device_locked(struct spi_device *spi)
/* Set the bus ID string */ /* Set the bus ID string */
spi_dev_set_name(spi); spi_dev_set_name(spi);
WARN_ON(!mutex_is_locked(&spi_add_lock)); WARN_ON(!mutex_is_locked(&ctlr->add_lock));
return __spi_add_device(spi); return __spi_add_device(spi);
} }
@ -2830,6 +2824,7 @@ int spi_register_controller(struct spi_controller *ctlr)
spin_lock_init(&ctlr->bus_lock_spinlock); spin_lock_init(&ctlr->bus_lock_spinlock);
mutex_init(&ctlr->bus_lock_mutex); mutex_init(&ctlr->bus_lock_mutex);
mutex_init(&ctlr->io_mutex); mutex_init(&ctlr->io_mutex);
mutex_init(&ctlr->add_lock);
ctlr->bus_lock_flag = 0; ctlr->bus_lock_flag = 0;
init_completion(&ctlr->xfer_completion); init_completion(&ctlr->xfer_completion);
if (!ctlr->max_dma_len) if (!ctlr->max_dma_len)
@ -2966,7 +2961,7 @@ void spi_unregister_controller(struct spi_controller *ctlr)
/* Prevent addition of new devices, unregister existing ones */ /* Prevent addition of new devices, unregister existing ones */
if (IS_ENABLED(CONFIG_SPI_DYNAMIC)) if (IS_ENABLED(CONFIG_SPI_DYNAMIC))
mutex_lock(&spi_add_lock); mutex_lock(&ctlr->add_lock);
device_for_each_child(&ctlr->dev, NULL, __unregister); device_for_each_child(&ctlr->dev, NULL, __unregister);
@ -2997,7 +2992,7 @@ void spi_unregister_controller(struct spi_controller *ctlr)
mutex_unlock(&board_lock); mutex_unlock(&board_lock);
if (IS_ENABLED(CONFIG_SPI_DYNAMIC)) if (IS_ENABLED(CONFIG_SPI_DYNAMIC))
mutex_unlock(&spi_add_lock); mutex_unlock(&ctlr->add_lock);
} }
EXPORT_SYMBOL_GPL(spi_unregister_controller); EXPORT_SYMBOL_GPL(spi_unregister_controller);

3
include/linux/spi/spi.h
View file

@ -531,6 +531,9 @@ struct spi_controller {
/* I/O mutex */ /* I/O mutex */
struct mutex io_mutex; struct mutex io_mutex;
/* Used to avoid adding the same CS twice */
struct mutex add_lock;
/* lock and mutex for SPI bus locking */ /* lock and mutex for SPI bus locking */
spinlock_t bus_lock_spinlock; spinlock_t bus_lock_spinlock;
struct mutex bus_lock_mutex; struct mutex bus_lock_mutex;