--- /dev/null
+From cf32b71e981ca63e8f349d8585ca2a3583b556e0 Mon Sep 17 00:00:00 2001
+From: Ernst Schwab <eschwab@online.de>
+Date: Mon, 28 Jun 2010 17:49:29 -0700
+Subject: [PATCH] spi/mmc_spi: SPI bus locking API, using mutex
+
+SPI bus locking API to allow exclusive access to the SPI bus, especially, but
+not limited to, for the mmc_spi driver.
+
+Coded according to an outline from Grant Likely; here is his
+specification (accidentally swapped function names corrected):
+
+It requires 3 things to be added to struct spi_master.
+- 1 Mutex
+- 1 spin lock
+- 1 flag.
+
+The mutex protects spi_sync, and provides sleeping "for free"
+The spinlock protects the atomic spi_async call.
+The flag is set when the lock is obtained, and checked while holding
+the spinlock in spi_async(). If the flag is checked, then spi_async()
+must fail immediately.
+
+The current runtime API looks like this:
+spi_async(struct spi_device*, struct spi_message*);
+spi_sync(struct spi_device*, struct spi_message*);
+
+The API needs to be extended to this:
+spi_async(struct spi_device*, struct spi_message*)
+spi_sync(struct spi_device*, struct spi_message*)
+spi_bus_lock(struct spi_master*) /* although struct spi_device* might
+be easier */
+spi_bus_unlock(struct spi_master*)
+spi_async_locked(struct spi_device*, struct spi_message*)
+spi_sync_locked(struct spi_device*, struct spi_message*)
+
+Drivers can only call the last two if they already hold the spi_master_lock().
+
+spi_bus_lock() obtains the mutex, obtains the spin lock, sets the
+flag, and releases the spin lock before returning. It doesn't even
+need to sleep while waiting for "in-flight" spi_transactions to
+complete because its purpose is to guarantee no additional
+transactions are added. It does not guarantee that the bus is idle.
+
+spi_bus_unlock() clears the flag and releases the mutex, which will
+wake up any waiters.
+
+The difference between spi_async() and spi_async_locked() is that the
+locked version bypasses the check of the lock flag. Both versions
+need to obtain the spinlock.
+
+The difference between spi_sync() and spi_sync_locked() is that
+spi_sync() must hold the mutex while enqueuing a new transfer.
+spi_sync_locked() doesn't because the mutex is already held. Note
+however that spi_sync must *not* continue to hold the mutex while
+waiting for the transfer to complete, otherwise only one transfer
+could be queued up at a time!
+
+Almost no code needs to be written. The current spi_async() and
+spi_sync() can probably be renamed to __spi_async() and __spi_sync()
+so that spi_async(), spi_sync(), spi_async_locked() and
+spi_sync_locked() can just become wrappers around the common code.
+
+spi_sync() is protected by a mutex because it can sleep
+spi_async() needs to be protected with a flag and a spinlock because
+it can be called atomically and must not sleep
+
+Signed-off-by: Ernst Schwab <eschwab@online.de>
+[grant.likely@secretlab.ca: use spin_lock_irqsave()]
+Signed-off-by: Grant Likely <grant.likely@secretlab.ca>
+Tested-by: Matt Fleming <matt@console-pimps.org>
+Tested-by: Antonio Ospite <ospite@studenti.unina.it>
+---
+ drivers/spi/spi.c | 225 ++++++++++++++++++++++++++++++++++++++++-------
+ include/linux/spi/spi.h | 12 +++
+ 2 files changed, 204 insertions(+), 33 deletions(-)
+
+--- a/drivers/spi/spi.c
++++ b/drivers/spi/spi.c
+@@ -524,6 +524,10 @@ int spi_register_master(struct spi_maste
+ dynamic = 1;
+ }
+
++ spin_lock_init(&master->bus_lock_spinlock);
++ mutex_init(&master->bus_lock_mutex);
++ master->bus_lock_flag = 0;
++
+ /* register the device, then userspace will see it.
+ * registration fails if the bus ID is in use.
+ */
+@@ -663,6 +667,35 @@ int spi_setup(struct spi_device *spi)
+ }
+ EXPORT_SYMBOL_GPL(spi_setup);
+
++static int __spi_async(struct spi_device *spi, struct spi_message *message)
++{
++ struct spi_master *master = spi->master;
++
++ /* Half-duplex links include original MicroWire, and ones with
++ * only one data pin like SPI_3WIRE (switches direction) or where
++ * either MOSI or MISO is missing. They can also be caused by
++ * software limitations.
++ */
++ if ((master->flags & SPI_MASTER_HALF_DUPLEX)
++ || (spi->mode & SPI_3WIRE)) {
++ struct spi_transfer *xfer;
++ unsigned flags = master->flags;
++
++ list_for_each_entry(xfer, &message->transfers, transfer_list) {
++ if (xfer->rx_buf && xfer->tx_buf)
++ return -EINVAL;
++ if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
++ return -EINVAL;
++ if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
++ return -EINVAL;
++ }
++ }
++
++ message->spi = spi;
++ message->status = -EINPROGRESS;
++ return master->transfer(spi, message);
++}
++
+ /**
+ * spi_async - asynchronous SPI transfer
+ * @spi: device with which data will be exchanged
+@@ -695,33 +728,68 @@ EXPORT_SYMBOL_GPL(spi_setup);
+ int spi_async(struct spi_device *spi, struct spi_message *message)
+ {
+ struct spi_master *master = spi->master;
++ int ret;
++ unsigned long flags;
+
+- /* Half-duplex links include original MicroWire, and ones with
+- * only one data pin like SPI_3WIRE (switches direction) or where
+- * either MOSI or MISO is missing. They can also be caused by
+- * software limitations.
+- */
+- if ((master->flags & SPI_MASTER_HALF_DUPLEX)
+- || (spi->mode & SPI_3WIRE)) {
+- struct spi_transfer *xfer;
+- unsigned flags = master->flags;
++ spin_lock_irqsave(&master->bus_lock_spinlock, flags);
+
+- list_for_each_entry(xfer, &message->transfers, transfer_list) {
+- if (xfer->rx_buf && xfer->tx_buf)
+- return -EINVAL;
+- if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
+- return -EINVAL;
+- if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
+- return -EINVAL;
+- }
+- }
++ if (master->bus_lock_flag)
++ ret = -EBUSY;
++ else
++ ret = __spi_async(spi, message);
+
+- message->spi = spi;
+- message->status = -EINPROGRESS;
+- return master->transfer(spi, message);
++ spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++
++ return ret;
+ }
+ EXPORT_SYMBOL_GPL(spi_async);
+
++/**
++ * spi_async_locked - version of spi_async with exclusive bus usage
++ * @spi: device with which data will be exchanged
++ * @message: describes the data transfers, including completion callback
++ * Context: any (irqs may be blocked, etc)
++ *
++ * This call may be used in_irq and other contexts which can't sleep,
++ * as well as from task contexts which can sleep.
++ *
++ * The completion callback is invoked in a context which can't sleep.
++ * Before that invocation, the value of message->status is undefined.
++ * When the callback is issued, message->status holds either zero (to
++ * indicate complete success) or a negative error code. After that
++ * callback returns, the driver which issued the transfer request may
++ * deallocate the associated memory; it's no longer in use by any SPI
++ * core or controller driver code.
++ *
++ * Note that although all messages to a spi_device are handled in
++ * FIFO order, messages may go to different devices in other orders.
++ * Some device might be higher priority, or have various "hard" access
++ * time requirements, for example.
++ *
++ * On detection of any fault during the transfer, processing of
++ * the entire message is aborted, and the device is deselected.
++ * Until returning from the associated message completion callback,
++ * no other spi_message queued to that device will be processed.
++ * (This rule applies equally to all the synchronous transfer calls,
++ * which are wrappers around this core asynchronous primitive.)
++ */
++int spi_async_locked(struct spi_device *spi, struct spi_message *message)
++{
++ struct spi_master *master = spi->master;
++ int ret;
++ unsigned long flags;
++
++ spin_lock_irqsave(&master->bus_lock_spinlock, flags);
++
++ ret = __spi_async(spi, message);
++
++ spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++
++ return ret;
++
++}
++EXPORT_SYMBOL_GPL(spi_async_locked);
++
+
+ /*-------------------------------------------------------------------------*/
+
+@@ -735,6 +803,32 @@ static void spi_complete(void *arg)
+ complete(arg);
+ }
+
++static int __spi_sync(struct spi_device *spi, struct spi_message *message,
++ int bus_locked)
++{
++ DECLARE_COMPLETION_ONSTACK(done);
++ int status;
++ struct spi_master *master = spi->master;
++
++ message->complete = spi_complete;
++ message->context = &done;
++
++ if (!bus_locked)
++ mutex_lock(&master->bus_lock_mutex);
++
++ status = spi_async_locked(spi, message);
++
++ if (!bus_locked)
++ mutex_unlock(&master->bus_lock_mutex);
++
++ if (status == 0) {
++ wait_for_completion(&done);
++ status = message->status;
++ }
++ message->context = NULL;
++ return status;
++}
++
+ /**
+ * spi_sync - blocking/synchronous SPI data transfers
+ * @spi: device with which data will be exchanged
+@@ -758,21 +852,86 @@ static void spi_complete(void *arg)
+ */
+ int spi_sync(struct spi_device *spi, struct spi_message *message)
+ {
+- DECLARE_COMPLETION_ONSTACK(done);
+- int status;
+-
+- message->complete = spi_complete;
+- message->context = &done;
+- status = spi_async(spi, message);
+- if (status == 0) {
+- wait_for_completion(&done);
+- status = message->status;
+- }
+- message->context = NULL;
+- return status;
++ return __spi_sync(spi, message, 0);
+ }
+ EXPORT_SYMBOL_GPL(spi_sync);
+
++/**
++ * spi_sync_locked - version of spi_sync with exclusive bus usage
++ * @spi: device with which data will be exchanged
++ * @message: describes the data transfers
++ * Context: can sleep
++ *
++ * This call may only be used from a context that may sleep. The sleep
++ * is non-interruptible, and has no timeout. Low-overhead controller
++ * drivers may DMA directly into and out of the message buffers.
++ *
++ * This call should be used by drivers that require exclusive access to the
++ * SPI bus. It has to be preceeded by a spi_bus_lock call. The SPI bus must
++ * be released by a spi_bus_unlock call when the exclusive access is over.
++ *
++ * It returns zero on success, else a negative error code.
++ */
++int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
++{
++ return __spi_sync(spi, message, 1);
++}
++EXPORT_SYMBOL_GPL(spi_sync_locked);
++
++/**
++ * spi_bus_lock - obtain a lock for exclusive SPI bus usage
++ * @master: SPI bus master that should be locked for exclusive bus access
++ * Context: can sleep
++ *
++ * This call may only be used from a context that may sleep. The sleep
++ * is non-interruptible, and has no timeout.
++ *
++ * This call should be used by drivers that require exclusive access to the
++ * SPI bus. The SPI bus must be released by a spi_bus_unlock call when the
++ * exclusive access is over. Data transfer must be done by spi_sync_locked
++ * and spi_async_locked calls when the SPI bus lock is held.
++ *
++ * It returns zero on success, else a negative error code.
++ */
++int spi_bus_lock(struct spi_master *master)
++{
++ unsigned long flags;
++
++ mutex_lock(&master->bus_lock_mutex);
++
++ spin_lock_irqsave(&master->bus_lock_spinlock, flags);
++ master->bus_lock_flag = 1;
++ spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++
++ /* mutex remains locked until spi_bus_unlock is called */
++
++ return 0;
++}
++EXPORT_SYMBOL_GPL(spi_bus_lock);
++
++/**
++ * spi_bus_unlock - release the lock for exclusive SPI bus usage
++ * @master: SPI bus master that was locked for exclusive bus access
++ * Context: can sleep
++ *
++ * This call may only be used from a context that may sleep. The sleep
++ * is non-interruptible, and has no timeout.
++ *
++ * This call releases an SPI bus lock previously obtained by an spi_bus_lock
++ * call.
++ *
++ * It returns zero on success, else a negative error code.
++ */
++int spi_bus_unlock(struct spi_master *master)
++{
++ master->bus_lock_flag = 0;
++
++ mutex_unlock(&master->bus_lock_mutex);
++
++ return 0;
++}
++EXPORT_SYMBOL_GPL(spi_bus_unlock);
++
+ /* portable code must never pass more than 32 bytes */
+ #define SPI_BUFSIZ max(32,SMP_CACHE_BYTES)
+
+--- a/include/linux/spi/spi.h
++++ b/include/linux/spi/spi.h
+@@ -261,6 +261,13 @@ struct spi_master {
+ #define SPI_MASTER_NO_RX BIT(1) /* can't do buffer read */
+ #define SPI_MASTER_NO_TX BIT(2) /* can't do buffer write */
+
++ /* lock and mutex for SPI bus locking */
++ spinlock_t bus_lock_spinlock;
++ struct mutex bus_lock_mutex;
++
++ /* flag indicating that the SPI bus is locked for exclusive use */
++ bool bus_lock_flag;
++
+ /* Setup mode and clock, etc (spi driver may call many times).
+ *
+ * IMPORTANT: this may be called when transfers to another
+@@ -541,6 +548,8 @@ static inline void spi_message_free(stru
+
+ extern int spi_setup(struct spi_device *spi);
+ extern int spi_async(struct spi_device *spi, struct spi_message *message);
++extern int spi_async_locked(struct spi_device *spi,
++ struct spi_message *message);
+
+ /*---------------------------------------------------------------------------*/
+
+@@ -550,6 +559,9 @@ extern int spi_async(struct spi_device *
+ */
+
+ extern int spi_sync(struct spi_device *spi, struct spi_message *message);
++extern int spi_sync_locked(struct spi_device *spi, struct spi_message *message);
++extern int spi_bus_lock(struct spi_master *master);
++extern int spi_bus_unlock(struct spi_master *master);
+
+ /**
+ * spi_write - SPI synchronous write
--- /dev/null
+From 4751c1c74bc7b596db5de0c93be1a22a570145c0 Mon Sep 17 00:00:00 2001
+From: Ernst Schwab <eschwab@online.de>
+Date: Thu, 18 Feb 2010 12:47:46 +0100
+Subject: [PATCH] spi/mmc_spi: mmc_spi adaptations for SPI bus locking API
+
+Modification of the mmc_spi driver to use the SPI bus locking API.
+With this, the mmc_spi driver can be used together with other SPI
+devices on the same SPI bus. The exclusive access to the SPI bus is
+now managed in the SPI layer. The counting of chip selects in the probe
+function is no longer needed.
+
+Signed-off-by: Ernst Schwab <eschwab@online.de>
+Signed-off-by: Grant Likely <grant.likely@secretlab.ca>
+Tested-by: Matt Fleming <matt@console-pimps.org>
+Tested-by: Antonio Ospite <ospite@studenti.unina.it>
+---
+ drivers/mmc/host/mmc_spi.c | 59 ++++++++-----------------------------------
+ 1 files changed, 11 insertions(+), 48 deletions(-)
+
+--- a/drivers/mmc/host/mmc_spi.c
++++ b/drivers/mmc/host/mmc_spi.c
+@@ -181,7 +181,7 @@ mmc_spi_readbytes(struct mmc_spi_host *h
+ host->data_dma, sizeof(*host->data),
+ DMA_FROM_DEVICE);
+
+- status = spi_sync(host->spi, &host->readback);
++ status = spi_sync_locked(host->spi, &host->readback);
+
+ if (host->dma_dev)
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -540,7 +540,7 @@ mmc_spi_command_send(struct mmc_spi_host
+ host->data_dma, sizeof(*host->data),
+ DMA_BIDIRECTIONAL);
+ }
+- status = spi_sync(host->spi, &host->m);
++ status = spi_sync_locked(host->spi, &host->m);
+
+ if (host->dma_dev)
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -684,7 +684,7 @@ mmc_spi_writeblock(struct mmc_spi_host *
+ host->data_dma, sizeof(*scratch),
+ DMA_BIDIRECTIONAL);
+
+- status = spi_sync(spi, &host->m);
++ status = spi_sync_locked(spi, &host->m);
+
+ if (status != 0) {
+ dev_dbg(&spi->dev, "write error (%d)\n", status);
+@@ -821,7 +821,7 @@ mmc_spi_readblock(struct mmc_spi_host *h
+ DMA_FROM_DEVICE);
+ }
+
+- status = spi_sync(spi, &host->m);
++ status = spi_sync_locked(spi, &host->m);
+
+ if (host->dma_dev) {
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -1017,7 +1017,7 @@ mmc_spi_data_do(struct mmc_spi_host *hos
+ host->data_dma, sizeof(*scratch),
+ DMA_BIDIRECTIONAL);
+
+- tmp = spi_sync(spi, &host->m);
++ tmp = spi_sync_locked(spi, &host->m);
+
+ if (host->dma_dev)
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -1083,6 +1083,9 @@ static void mmc_spi_request(struct mmc_h
+ }
+ #endif
+
++ /* request exclusive bus access */
++ spi_bus_lock(host->spi->master);
++
+ /* issue command; then optionally data and stop */
+ status = mmc_spi_command_send(host, mrq, mrq->cmd, mrq->data != NULL);
+ if (status == 0 && mrq->data) {
+@@ -1093,6 +1096,9 @@ static void mmc_spi_request(struct mmc_h
+ mmc_cs_off(host);
+ }
+
++ /* release the bus */
++ spi_bus_unlock(host->spi->master);
++
+ mmc_request_done(host->mmc, mrq);
+ }
+
+@@ -1289,23 +1295,6 @@ mmc_spi_detect_irq(int irq, void *mmc)
+ return IRQ_HANDLED;
+ }
+
+-struct count_children {
+- unsigned n;
+- struct bus_type *bus;
+-};
+-
+-static int maybe_count_child(struct device *dev, void *c)
+-{
+- struct count_children *ccp = c;
+-
+- if (dev->bus == ccp->bus) {
+- if (ccp->n)
+- return -EBUSY;
+- ccp->n++;
+- }
+- return 0;
+-}
+-
+ static int mmc_spi_probe(struct spi_device *spi)
+ {
+ void *ones;
+@@ -1337,32 +1326,6 @@ static int mmc_spi_probe(struct spi_devi
+ return status;
+ }
+
+- /* We can use the bus safely iff nobody else will interfere with us.
+- * Most commands consist of one SPI message to issue a command, then
+- * several more to collect its response, then possibly more for data
+- * transfer. Clocking access to other devices during that period will
+- * corrupt the command execution.
+- *
+- * Until we have software primitives which guarantee non-interference,
+- * we'll aim for a hardware-level guarantee.
+- *
+- * REVISIT we can't guarantee another device won't be added later...
+- */
+- if (spi->master->num_chipselect > 1) {
+- struct count_children cc;
+-
+- cc.n = 0;
+- cc.bus = spi->dev.bus;
+- status = device_for_each_child(spi->dev.parent, &cc,
+- maybe_count_child);
+- if (status < 0) {
+- dev_err(&spi->dev, "can't share SPI bus\n");
+- return status;
+- }
+-
+- dev_warn(&spi->dev, "ASSUMING SPI bus stays unshared!\n");
+- }
+-
+ /* We need a supply of ones to transmit. This is the only time
+ * the CPU touches these, so cache coherency isn't a concern.
+ *
--- /dev/null
+From cf32b71e981ca63e8f349d8585ca2a3583b556e0 Mon Sep 17 00:00:00 2001
+From: Ernst Schwab <eschwab@online.de>
+Date: Mon, 28 Jun 2010 17:49:29 -0700
+Subject: [PATCH] spi/mmc_spi: SPI bus locking API, using mutex
+
+SPI bus locking API to allow exclusive access to the SPI bus, especially, but
+not limited to, for the mmc_spi driver.
+
+Coded according to an outline from Grant Likely; here is his
+specification (accidentally swapped function names corrected):
+
+It requires 3 things to be added to struct spi_master.
+- 1 Mutex
+- 1 spin lock
+- 1 flag.
+
+The mutex protects spi_sync, and provides sleeping "for free"
+The spinlock protects the atomic spi_async call.
+The flag is set when the lock is obtained, and checked while holding
+the spinlock in spi_async(). If the flag is checked, then spi_async()
+must fail immediately.
+
+The current runtime API looks like this:
+spi_async(struct spi_device*, struct spi_message*);
+spi_sync(struct spi_device*, struct spi_message*);
+
+The API needs to be extended to this:
+spi_async(struct spi_device*, struct spi_message*)
+spi_sync(struct spi_device*, struct spi_message*)
+spi_bus_lock(struct spi_master*) /* although struct spi_device* might
+be easier */
+spi_bus_unlock(struct spi_master*)
+spi_async_locked(struct spi_device*, struct spi_message*)
+spi_sync_locked(struct spi_device*, struct spi_message*)
+
+Drivers can only call the last two if they already hold the spi_master_lock().
+
+spi_bus_lock() obtains the mutex, obtains the spin lock, sets the
+flag, and releases the spin lock before returning. It doesn't even
+need to sleep while waiting for "in-flight" spi_transactions to
+complete because its purpose is to guarantee no additional
+transactions are added. It does not guarantee that the bus is idle.
+
+spi_bus_unlock() clears the flag and releases the mutex, which will
+wake up any waiters.
+
+The difference between spi_async() and spi_async_locked() is that the
+locked version bypasses the check of the lock flag. Both versions
+need to obtain the spinlock.
+
+The difference between spi_sync() and spi_sync_locked() is that
+spi_sync() must hold the mutex while enqueuing a new transfer.
+spi_sync_locked() doesn't because the mutex is already held. Note
+however that spi_sync must *not* continue to hold the mutex while
+waiting for the transfer to complete, otherwise only one transfer
+could be queued up at a time!
+
+Almost no code needs to be written. The current spi_async() and
+spi_sync() can probably be renamed to __spi_async() and __spi_sync()
+so that spi_async(), spi_sync(), spi_async_locked() and
+spi_sync_locked() can just become wrappers around the common code.
+
+spi_sync() is protected by a mutex because it can sleep
+spi_async() needs to be protected with a flag and a spinlock because
+it can be called atomically and must not sleep
+
+Signed-off-by: Ernst Schwab <eschwab@online.de>
+[grant.likely@secretlab.ca: use spin_lock_irqsave()]
+Signed-off-by: Grant Likely <grant.likely@secretlab.ca>
+Tested-by: Matt Fleming <matt@console-pimps.org>
+Tested-by: Antonio Ospite <ospite@studenti.unina.it>
+---
+ drivers/spi/spi.c | 225 ++++++++++++++++++++++++++++++++++++++++-------
+ include/linux/spi/spi.h | 12 +++
+ 2 files changed, 204 insertions(+), 33 deletions(-)
+
+--- a/drivers/spi/spi.c
++++ b/drivers/spi/spi.c
+@@ -524,6 +524,10 @@ int spi_register_master(struct spi_maste
+ dynamic = 1;
+ }
+
++ spin_lock_init(&master->bus_lock_spinlock);
++ mutex_init(&master->bus_lock_mutex);
++ master->bus_lock_flag = 0;
++
+ /* register the device, then userspace will see it.
+ * registration fails if the bus ID is in use.
+ */
+@@ -663,6 +667,35 @@ int spi_setup(struct spi_device *spi)
+ }
+ EXPORT_SYMBOL_GPL(spi_setup);
+
++static int __spi_async(struct spi_device *spi, struct spi_message *message)
++{
++ struct spi_master *master = spi->master;
++
++ /* Half-duplex links include original MicroWire, and ones with
++ * only one data pin like SPI_3WIRE (switches direction) or where
++ * either MOSI or MISO is missing. They can also be caused by
++ * software limitations.
++ */
++ if ((master->flags & SPI_MASTER_HALF_DUPLEX)
++ || (spi->mode & SPI_3WIRE)) {
++ struct spi_transfer *xfer;
++ unsigned flags = master->flags;
++
++ list_for_each_entry(xfer, &message->transfers, transfer_list) {
++ if (xfer->rx_buf && xfer->tx_buf)
++ return -EINVAL;
++ if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
++ return -EINVAL;
++ if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
++ return -EINVAL;
++ }
++ }
++
++ message->spi = spi;
++ message->status = -EINPROGRESS;
++ return master->transfer(spi, message);
++}
++
+ /**
+ * spi_async - asynchronous SPI transfer
+ * @spi: device with which data will be exchanged
+@@ -695,33 +728,68 @@ EXPORT_SYMBOL_GPL(spi_setup);
+ int spi_async(struct spi_device *spi, struct spi_message *message)
+ {
+ struct spi_master *master = spi->master;
++ int ret;
++ unsigned long flags;
+
+- /* Half-duplex links include original MicroWire, and ones with
+- * only one data pin like SPI_3WIRE (switches direction) or where
+- * either MOSI or MISO is missing. They can also be caused by
+- * software limitations.
+- */
+- if ((master->flags & SPI_MASTER_HALF_DUPLEX)
+- || (spi->mode & SPI_3WIRE)) {
+- struct spi_transfer *xfer;
+- unsigned flags = master->flags;
++ spin_lock_irqsave(&master->bus_lock_spinlock, flags);
+
+- list_for_each_entry(xfer, &message->transfers, transfer_list) {
+- if (xfer->rx_buf && xfer->tx_buf)
+- return -EINVAL;
+- if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
+- return -EINVAL;
+- if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
+- return -EINVAL;
+- }
+- }
++ if (master->bus_lock_flag)
++ ret = -EBUSY;
++ else
++ ret = __spi_async(spi, message);
+
+- message->spi = spi;
+- message->status = -EINPROGRESS;
+- return master->transfer(spi, message);
++ spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++
++ return ret;
+ }
+ EXPORT_SYMBOL_GPL(spi_async);
+
++/**
++ * spi_async_locked - version of spi_async with exclusive bus usage
++ * @spi: device with which data will be exchanged
++ * @message: describes the data transfers, including completion callback
++ * Context: any (irqs may be blocked, etc)
++ *
++ * This call may be used in_irq and other contexts which can't sleep,
++ * as well as from task contexts which can sleep.
++ *
++ * The completion callback is invoked in a context which can't sleep.
++ * Before that invocation, the value of message->status is undefined.
++ * When the callback is issued, message->status holds either zero (to
++ * indicate complete success) or a negative error code. After that
++ * callback returns, the driver which issued the transfer request may
++ * deallocate the associated memory; it's no longer in use by any SPI
++ * core or controller driver code.
++ *
++ * Note that although all messages to a spi_device are handled in
++ * FIFO order, messages may go to different devices in other orders.
++ * Some device might be higher priority, or have various "hard" access
++ * time requirements, for example.
++ *
++ * On detection of any fault during the transfer, processing of
++ * the entire message is aborted, and the device is deselected.
++ * Until returning from the associated message completion callback,
++ * no other spi_message queued to that device will be processed.
++ * (This rule applies equally to all the synchronous transfer calls,
++ * which are wrappers around this core asynchronous primitive.)
++ */
++int spi_async_locked(struct spi_device *spi, struct spi_message *message)
++{
++ struct spi_master *master = spi->master;
++ int ret;
++ unsigned long flags;
++
++ spin_lock_irqsave(&master->bus_lock_spinlock, flags);
++
++ ret = __spi_async(spi, message);
++
++ spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++
++ return ret;
++
++}
++EXPORT_SYMBOL_GPL(spi_async_locked);
++
+
+ /*-------------------------------------------------------------------------*/
+
+@@ -735,6 +803,32 @@ static void spi_complete(void *arg)
+ complete(arg);
+ }
+
++static int __spi_sync(struct spi_device *spi, struct spi_message *message,
++ int bus_locked)
++{
++ DECLARE_COMPLETION_ONSTACK(done);
++ int status;
++ struct spi_master *master = spi->master;
++
++ message->complete = spi_complete;
++ message->context = &done;
++
++ if (!bus_locked)
++ mutex_lock(&master->bus_lock_mutex);
++
++ status = spi_async_locked(spi, message);
++
++ if (!bus_locked)
++ mutex_unlock(&master->bus_lock_mutex);
++
++ if (status == 0) {
++ wait_for_completion(&done);
++ status = message->status;
++ }
++ message->context = NULL;
++ return status;
++}
++
+ /**
+ * spi_sync - blocking/synchronous SPI data transfers
+ * @spi: device with which data will be exchanged
+@@ -758,21 +852,86 @@ static void spi_complete(void *arg)
+ */
+ int spi_sync(struct spi_device *spi, struct spi_message *message)
+ {
+- DECLARE_COMPLETION_ONSTACK(done);
+- int status;
+-
+- message->complete = spi_complete;
+- message->context = &done;
+- status = spi_async(spi, message);
+- if (status == 0) {
+- wait_for_completion(&done);
+- status = message->status;
+- }
+- message->context = NULL;
+- return status;
++ return __spi_sync(spi, message, 0);
+ }
+ EXPORT_SYMBOL_GPL(spi_sync);
+
++/**
++ * spi_sync_locked - version of spi_sync with exclusive bus usage
++ * @spi: device with which data will be exchanged
++ * @message: describes the data transfers
++ * Context: can sleep
++ *
++ * This call may only be used from a context that may sleep. The sleep
++ * is non-interruptible, and has no timeout. Low-overhead controller
++ * drivers may DMA directly into and out of the message buffers.
++ *
++ * This call should be used by drivers that require exclusive access to the
++ * SPI bus. It has to be preceeded by a spi_bus_lock call. The SPI bus must
++ * be released by a spi_bus_unlock call when the exclusive access is over.
++ *
++ * It returns zero on success, else a negative error code.
++ */
++int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
++{
++ return __spi_sync(spi, message, 1);
++}
++EXPORT_SYMBOL_GPL(spi_sync_locked);
++
++/**
++ * spi_bus_lock - obtain a lock for exclusive SPI bus usage
++ * @master: SPI bus master that should be locked for exclusive bus access
++ * Context: can sleep
++ *
++ * This call may only be used from a context that may sleep. The sleep
++ * is non-interruptible, and has no timeout.
++ *
++ * This call should be used by drivers that require exclusive access to the
++ * SPI bus. The SPI bus must be released by a spi_bus_unlock call when the
++ * exclusive access is over. Data transfer must be done by spi_sync_locked
++ * and spi_async_locked calls when the SPI bus lock is held.
++ *
++ * It returns zero on success, else a negative error code.
++ */
++int spi_bus_lock(struct spi_master *master)
++{
++ unsigned long flags;
++
++ mutex_lock(&master->bus_lock_mutex);
++
++ spin_lock_irqsave(&master->bus_lock_spinlock, flags);
++ master->bus_lock_flag = 1;
++ spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++
++ /* mutex remains locked until spi_bus_unlock is called */
++
++ return 0;
++}
++EXPORT_SYMBOL_GPL(spi_bus_lock);
++
++/**
++ * spi_bus_unlock - release the lock for exclusive SPI bus usage
++ * @master: SPI bus master that was locked for exclusive bus access
++ * Context: can sleep
++ *
++ * This call may only be used from a context that may sleep. The sleep
++ * is non-interruptible, and has no timeout.
++ *
++ * This call releases an SPI bus lock previously obtained by an spi_bus_lock
++ * call.
++ *
++ * It returns zero on success, else a negative error code.
++ */
++int spi_bus_unlock(struct spi_master *master)
++{
++ master->bus_lock_flag = 0;
++
++ mutex_unlock(&master->bus_lock_mutex);
++
++ return 0;
++}
++EXPORT_SYMBOL_GPL(spi_bus_unlock);
++
+ /* portable code must never pass more than 32 bytes */
+ #define SPI_BUFSIZ max(32,SMP_CACHE_BYTES)
+
+--- a/include/linux/spi/spi.h
++++ b/include/linux/spi/spi.h
+@@ -261,6 +261,13 @@ struct spi_master {
+ #define SPI_MASTER_NO_RX BIT(1) /* can't do buffer read */
+ #define SPI_MASTER_NO_TX BIT(2) /* can't do buffer write */
+
++ /* lock and mutex for SPI bus locking */
++ spinlock_t bus_lock_spinlock;
++ struct mutex bus_lock_mutex;
++
++ /* flag indicating that the SPI bus is locked for exclusive use */
++ bool bus_lock_flag;
++
+ /* Setup mode and clock, etc (spi driver may call many times).
+ *
+ * IMPORTANT: this may be called when transfers to another
+@@ -541,6 +548,8 @@ static inline void spi_message_free(stru
+
+ extern int spi_setup(struct spi_device *spi);
+ extern int spi_async(struct spi_device *spi, struct spi_message *message);
++extern int spi_async_locked(struct spi_device *spi,
++ struct spi_message *message);
+
+ /*---------------------------------------------------------------------------*/
+
+@@ -550,6 +559,9 @@ extern int spi_async(struct spi_device *
+ */
+
+ extern int spi_sync(struct spi_device *spi, struct spi_message *message);
++extern int spi_sync_locked(struct spi_device *spi, struct spi_message *message);
++extern int spi_bus_lock(struct spi_master *master);
++extern int spi_bus_unlock(struct spi_master *master);
+
+ /**
+ * spi_write - SPI synchronous write
--- /dev/null
+From 4751c1c74bc7b596db5de0c93be1a22a570145c0 Mon Sep 17 00:00:00 2001
+From: Ernst Schwab <eschwab@online.de>
+Date: Thu, 18 Feb 2010 12:47:46 +0100
+Subject: [PATCH] spi/mmc_spi: mmc_spi adaptations for SPI bus locking API
+
+Modification of the mmc_spi driver to use the SPI bus locking API.
+With this, the mmc_spi driver can be used together with other SPI
+devices on the same SPI bus. The exclusive access to the SPI bus is
+now managed in the SPI layer. The counting of chip selects in the probe
+function is no longer needed.
+
+Signed-off-by: Ernst Schwab <eschwab@online.de>
+Signed-off-by: Grant Likely <grant.likely@secretlab.ca>
+Tested-by: Matt Fleming <matt@console-pimps.org>
+Tested-by: Antonio Ospite <ospite@studenti.unina.it>
+---
+ drivers/mmc/host/mmc_spi.c | 59 ++++++++-----------------------------------
+ 1 files changed, 11 insertions(+), 48 deletions(-)
+
+--- a/drivers/mmc/host/mmc_spi.c
++++ b/drivers/mmc/host/mmc_spi.c
+@@ -181,7 +181,7 @@ mmc_spi_readbytes(struct mmc_spi_host *h
+ host->data_dma, sizeof(*host->data),
+ DMA_FROM_DEVICE);
+
+- status = spi_sync(host->spi, &host->readback);
++ status = spi_sync_locked(host->spi, &host->readback);
+
+ if (host->dma_dev)
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -540,7 +540,7 @@ mmc_spi_command_send(struct mmc_spi_host
+ host->data_dma, sizeof(*host->data),
+ DMA_BIDIRECTIONAL);
+ }
+- status = spi_sync(host->spi, &host->m);
++ status = spi_sync_locked(host->spi, &host->m);
+
+ if (host->dma_dev)
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -684,7 +684,7 @@ mmc_spi_writeblock(struct mmc_spi_host *
+ host->data_dma, sizeof(*scratch),
+ DMA_BIDIRECTIONAL);
+
+- status = spi_sync(spi, &host->m);
++ status = spi_sync_locked(spi, &host->m);
+
+ if (status != 0) {
+ dev_dbg(&spi->dev, "write error (%d)\n", status);
+@@ -821,7 +821,7 @@ mmc_spi_readblock(struct mmc_spi_host *h
+ DMA_FROM_DEVICE);
+ }
+
+- status = spi_sync(spi, &host->m);
++ status = spi_sync_locked(spi, &host->m);
+
+ if (host->dma_dev) {
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -1017,7 +1017,7 @@ mmc_spi_data_do(struct mmc_spi_host *hos
+ host->data_dma, sizeof(*scratch),
+ DMA_BIDIRECTIONAL);
+
+- tmp = spi_sync(spi, &host->m);
++ tmp = spi_sync_locked(spi, &host->m);
+
+ if (host->dma_dev)
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -1083,6 +1083,9 @@ static void mmc_spi_request(struct mmc_h
+ }
+ #endif
+
++ /* request exclusive bus access */
++ spi_bus_lock(host->spi->master);
++
+ /* issue command; then optionally data and stop */
+ status = mmc_spi_command_send(host, mrq, mrq->cmd, mrq->data != NULL);
+ if (status == 0 && mrq->data) {
+@@ -1093,6 +1096,9 @@ static void mmc_spi_request(struct mmc_h
+ mmc_cs_off(host);
+ }
+
++ /* release the bus */
++ spi_bus_unlock(host->spi->master);
++
+ mmc_request_done(host->mmc, mrq);
+ }
+
+@@ -1289,23 +1295,6 @@ mmc_spi_detect_irq(int irq, void *mmc)
+ return IRQ_HANDLED;
+ }
+
+-struct count_children {
+- unsigned n;
+- struct bus_type *bus;
+-};
+-
+-static int maybe_count_child(struct device *dev, void *c)
+-{
+- struct count_children *ccp = c;
+-
+- if (dev->bus == ccp->bus) {
+- if (ccp->n)
+- return -EBUSY;
+- ccp->n++;
+- }
+- return 0;
+-}
+-
+ static int mmc_spi_probe(struct spi_device *spi)
+ {
+ void *ones;
+@@ -1337,32 +1326,6 @@ static int mmc_spi_probe(struct spi_devi
+ return status;
+ }
+
+- /* We can use the bus safely iff nobody else will interfere with us.
+- * Most commands consist of one SPI message to issue a command, then
+- * several more to collect its response, then possibly more for data
+- * transfer. Clocking access to other devices during that period will
+- * corrupt the command execution.
+- *
+- * Until we have software primitives which guarantee non-interference,
+- * we'll aim for a hardware-level guarantee.
+- *
+- * REVISIT we can't guarantee another device won't be added later...
+- */
+- if (spi->master->num_chipselect > 1) {
+- struct count_children cc;
+-
+- cc.n = 0;
+- cc.bus = spi->dev.bus;
+- status = device_for_each_child(spi->dev.parent, &cc,
+- maybe_count_child);
+- if (status < 0) {
+- dev_err(&spi->dev, "can't share SPI bus\n");
+- return status;
+- }
+-
+- dev_warn(&spi->dev, "ASSUMING SPI bus stays unshared!\n");
+- }
+-
+ /* We need a supply of ones to transmit. This is the only time
+ * the CPU touches these, so cache coherency isn't a concern.
+ *
--- /dev/null
+From cf32b71e981ca63e8f349d8585ca2a3583b556e0 Mon Sep 17 00:00:00 2001
+From: Ernst Schwab <eschwab@online.de>
+Date: Mon, 28 Jun 2010 17:49:29 -0700
+Subject: [PATCH] spi/mmc_spi: SPI bus locking API, using mutex
+
+SPI bus locking API to allow exclusive access to the SPI bus, especially, but
+not limited to, for the mmc_spi driver.
+
+Coded according to an outline from Grant Likely; here is his
+specification (accidentally swapped function names corrected):
+
+It requires 3 things to be added to struct spi_master.
+- 1 Mutex
+- 1 spin lock
+- 1 flag.
+
+The mutex protects spi_sync, and provides sleeping "for free"
+The spinlock protects the atomic spi_async call.
+The flag is set when the lock is obtained, and checked while holding
+the spinlock in spi_async(). If the flag is checked, then spi_async()
+must fail immediately.
+
+The current runtime API looks like this:
+spi_async(struct spi_device*, struct spi_message*);
+spi_sync(struct spi_device*, struct spi_message*);
+
+The API needs to be extended to this:
+spi_async(struct spi_device*, struct spi_message*)
+spi_sync(struct spi_device*, struct spi_message*)
+spi_bus_lock(struct spi_master*) /* although struct spi_device* might
+be easier */
+spi_bus_unlock(struct spi_master*)
+spi_async_locked(struct spi_device*, struct spi_message*)
+spi_sync_locked(struct spi_device*, struct spi_message*)
+
+Drivers can only call the last two if they already hold the spi_master_lock().
+
+spi_bus_lock() obtains the mutex, obtains the spin lock, sets the
+flag, and releases the spin lock before returning. It doesn't even
+need to sleep while waiting for "in-flight" spi_transactions to
+complete because its purpose is to guarantee no additional
+transactions are added. It does not guarantee that the bus is idle.
+
+spi_bus_unlock() clears the flag and releases the mutex, which will
+wake up any waiters.
+
+The difference between spi_async() and spi_async_locked() is that the
+locked version bypasses the check of the lock flag. Both versions
+need to obtain the spinlock.
+
+The difference between spi_sync() and spi_sync_locked() is that
+spi_sync() must hold the mutex while enqueuing a new transfer.
+spi_sync_locked() doesn't because the mutex is already held. Note
+however that spi_sync must *not* continue to hold the mutex while
+waiting for the transfer to complete, otherwise only one transfer
+could be queued up at a time!
+
+Almost no code needs to be written. The current spi_async() and
+spi_sync() can probably be renamed to __spi_async() and __spi_sync()
+so that spi_async(), spi_sync(), spi_async_locked() and
+spi_sync_locked() can just become wrappers around the common code.
+
+spi_sync() is protected by a mutex because it can sleep
+spi_async() needs to be protected with a flag and a spinlock because
+it can be called atomically and must not sleep
+
+Signed-off-by: Ernst Schwab <eschwab@online.de>
+[grant.likely@secretlab.ca: use spin_lock_irqsave()]
+Signed-off-by: Grant Likely <grant.likely@secretlab.ca>
+Tested-by: Matt Fleming <matt@console-pimps.org>
+Tested-by: Antonio Ospite <ospite@studenti.unina.it>
+---
+ drivers/spi/spi.c | 225 ++++++++++++++++++++++++++++++++++++++++-------
+ include/linux/spi/spi.h | 12 +++
+ 2 files changed, 204 insertions(+), 33 deletions(-)
+
+--- a/drivers/spi/spi.c
++++ b/drivers/spi/spi.c
+@@ -527,6 +527,10 @@ int spi_register_master(struct spi_maste
+ dynamic = 1;
+ }
+
++ spin_lock_init(&master->bus_lock_spinlock);
++ mutex_init(&master->bus_lock_mutex);
++ master->bus_lock_flag = 0;
++
+ /* register the device, then userspace will see it.
+ * registration fails if the bus ID is in use.
+ */
+@@ -666,6 +670,35 @@ int spi_setup(struct spi_device *spi)
+ }
+ EXPORT_SYMBOL_GPL(spi_setup);
+
++static int __spi_async(struct spi_device *spi, struct spi_message *message)
++{
++ struct spi_master *master = spi->master;
++
++ /* Half-duplex links include original MicroWire, and ones with
++ * only one data pin like SPI_3WIRE (switches direction) or where
++ * either MOSI or MISO is missing. They can also be caused by
++ * software limitations.
++ */
++ if ((master->flags & SPI_MASTER_HALF_DUPLEX)
++ || (spi->mode & SPI_3WIRE)) {
++ struct spi_transfer *xfer;
++ unsigned flags = master->flags;
++
++ list_for_each_entry(xfer, &message->transfers, transfer_list) {
++ if (xfer->rx_buf && xfer->tx_buf)
++ return -EINVAL;
++ if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
++ return -EINVAL;
++ if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
++ return -EINVAL;
++ }
++ }
++
++ message->spi = spi;
++ message->status = -EINPROGRESS;
++ return master->transfer(spi, message);
++}
++
+ /**
+ * spi_async - asynchronous SPI transfer
+ * @spi: device with which data will be exchanged
+@@ -698,33 +731,68 @@ EXPORT_SYMBOL_GPL(spi_setup);
+ int spi_async(struct spi_device *spi, struct spi_message *message)
+ {
+ struct spi_master *master = spi->master;
++ int ret;
++ unsigned long flags;
+
+- /* Half-duplex links include original MicroWire, and ones with
+- * only one data pin like SPI_3WIRE (switches direction) or where
+- * either MOSI or MISO is missing. They can also be caused by
+- * software limitations.
+- */
+- if ((master->flags & SPI_MASTER_HALF_DUPLEX)
+- || (spi->mode & SPI_3WIRE)) {
+- struct spi_transfer *xfer;
+- unsigned flags = master->flags;
++ spin_lock_irqsave(&master->bus_lock_spinlock, flags);
+
+- list_for_each_entry(xfer, &message->transfers, transfer_list) {
+- if (xfer->rx_buf && xfer->tx_buf)
+- return -EINVAL;
+- if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
+- return -EINVAL;
+- if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
+- return -EINVAL;
+- }
+- }
++ if (master->bus_lock_flag)
++ ret = -EBUSY;
++ else
++ ret = __spi_async(spi, message);
+
+- message->spi = spi;
+- message->status = -EINPROGRESS;
+- return master->transfer(spi, message);
++ spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++
++ return ret;
+ }
+ EXPORT_SYMBOL_GPL(spi_async);
+
++/**
++ * spi_async_locked - version of spi_async with exclusive bus usage
++ * @spi: device with which data will be exchanged
++ * @message: describes the data transfers, including completion callback
++ * Context: any (irqs may be blocked, etc)
++ *
++ * This call may be used in_irq and other contexts which can't sleep,
++ * as well as from task contexts which can sleep.
++ *
++ * The completion callback is invoked in a context which can't sleep.
++ * Before that invocation, the value of message->status is undefined.
++ * When the callback is issued, message->status holds either zero (to
++ * indicate complete success) or a negative error code. After that
++ * callback returns, the driver which issued the transfer request may
++ * deallocate the associated memory; it's no longer in use by any SPI
++ * core or controller driver code.
++ *
++ * Note that although all messages to a spi_device are handled in
++ * FIFO order, messages may go to different devices in other orders.
++ * Some device might be higher priority, or have various "hard" access
++ * time requirements, for example.
++ *
++ * On detection of any fault during the transfer, processing of
++ * the entire message is aborted, and the device is deselected.
++ * Until returning from the associated message completion callback,
++ * no other spi_message queued to that device will be processed.
++ * (This rule applies equally to all the synchronous transfer calls,
++ * which are wrappers around this core asynchronous primitive.)
++ */
++int spi_async_locked(struct spi_device *spi, struct spi_message *message)
++{
++ struct spi_master *master = spi->master;
++ int ret;
++ unsigned long flags;
++
++ spin_lock_irqsave(&master->bus_lock_spinlock, flags);
++
++ ret = __spi_async(spi, message);
++
++ spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++
++ return ret;
++
++}
++EXPORT_SYMBOL_GPL(spi_async_locked);
++
+
+ /*-------------------------------------------------------------------------*/
+
+@@ -738,6 +806,32 @@ static void spi_complete(void *arg)
+ complete(arg);
+ }
+
++static int __spi_sync(struct spi_device *spi, struct spi_message *message,
++ int bus_locked)
++{
++ DECLARE_COMPLETION_ONSTACK(done);
++ int status;
++ struct spi_master *master = spi->master;
++
++ message->complete = spi_complete;
++ message->context = &done;
++
++ if (!bus_locked)
++ mutex_lock(&master->bus_lock_mutex);
++
++ status = spi_async_locked(spi, message);
++
++ if (!bus_locked)
++ mutex_unlock(&master->bus_lock_mutex);
++
++ if (status == 0) {
++ wait_for_completion(&done);
++ status = message->status;
++ }
++ message->context = NULL;
++ return status;
++}
++
+ /**
+ * spi_sync - blocking/synchronous SPI data transfers
+ * @spi: device with which data will be exchanged
+@@ -761,21 +855,86 @@ static void spi_complete(void *arg)
+ */
+ int spi_sync(struct spi_device *spi, struct spi_message *message)
+ {
+- DECLARE_COMPLETION_ONSTACK(done);
+- int status;
+-
+- message->complete = spi_complete;
+- message->context = &done;
+- status = spi_async(spi, message);
+- if (status == 0) {
+- wait_for_completion(&done);
+- status = message->status;
+- }
+- message->context = NULL;
+- return status;
++ return __spi_sync(spi, message, 0);
+ }
+ EXPORT_SYMBOL_GPL(spi_sync);
+
++/**
++ * spi_sync_locked - version of spi_sync with exclusive bus usage
++ * @spi: device with which data will be exchanged
++ * @message: describes the data transfers
++ * Context: can sleep
++ *
++ * This call may only be used from a context that may sleep. The sleep
++ * is non-interruptible, and has no timeout. Low-overhead controller
++ * drivers may DMA directly into and out of the message buffers.
++ *
++ * This call should be used by drivers that require exclusive access to the
++ * SPI bus. It has to be preceeded by a spi_bus_lock call. The SPI bus must
++ * be released by a spi_bus_unlock call when the exclusive access is over.
++ *
++ * It returns zero on success, else a negative error code.
++ */
++int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
++{
++ return __spi_sync(spi, message, 1);
++}
++EXPORT_SYMBOL_GPL(spi_sync_locked);
++
++/**
++ * spi_bus_lock - obtain a lock for exclusive SPI bus usage
++ * @master: SPI bus master that should be locked for exclusive bus access
++ * Context: can sleep
++ *
++ * This call may only be used from a context that may sleep. The sleep
++ * is non-interruptible, and has no timeout.
++ *
++ * This call should be used by drivers that require exclusive access to the
++ * SPI bus. The SPI bus must be released by a spi_bus_unlock call when the
++ * exclusive access is over. Data transfer must be done by spi_sync_locked
++ * and spi_async_locked calls when the SPI bus lock is held.
++ *
++ * It returns zero on success, else a negative error code.
++ */
++int spi_bus_lock(struct spi_master *master)
++{
++ unsigned long flags;
++
++ mutex_lock(&master->bus_lock_mutex);
++
++ spin_lock_irqsave(&master->bus_lock_spinlock, flags);
++ master->bus_lock_flag = 1;
++ spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++
++ /* mutex remains locked until spi_bus_unlock is called */
++
++ return 0;
++}
++EXPORT_SYMBOL_GPL(spi_bus_lock);
++
++/**
++ * spi_bus_unlock - release the lock for exclusive SPI bus usage
++ * @master: SPI bus master that was locked for exclusive bus access
++ * Context: can sleep
++ *
++ * This call may only be used from a context that may sleep. The sleep
++ * is non-interruptible, and has no timeout.
++ *
++ * This call releases an SPI bus lock previously obtained by an spi_bus_lock
++ * call.
++ *
++ * It returns zero on success, else a negative error code.
++ */
++int spi_bus_unlock(struct spi_master *master)
++{
++ master->bus_lock_flag = 0;
++
++ mutex_unlock(&master->bus_lock_mutex);
++
++ return 0;
++}
++EXPORT_SYMBOL_GPL(spi_bus_unlock);
++
+ /* portable code must never pass more than 32 bytes */
+ #define SPI_BUFSIZ max(32,SMP_CACHE_BYTES)
+
+--- a/include/linux/spi/spi.h
++++ b/include/linux/spi/spi.h
+@@ -262,6 +262,13 @@ struct spi_master {
+ #define SPI_MASTER_NO_RX BIT(1) /* can't do buffer read */
+ #define SPI_MASTER_NO_TX BIT(2) /* can't do buffer write */
+
++ /* lock and mutex for SPI bus locking */
++ spinlock_t bus_lock_spinlock;
++ struct mutex bus_lock_mutex;
++
++ /* flag indicating that the SPI bus is locked for exclusive use */
++ bool bus_lock_flag;
++
+ /* Setup mode and clock, etc (spi driver may call many times).
+ *
+ * IMPORTANT: this may be called when transfers to another
+@@ -542,6 +549,8 @@ static inline void spi_message_free(stru
+
+ extern int spi_setup(struct spi_device *spi);
+ extern int spi_async(struct spi_device *spi, struct spi_message *message);
++extern int spi_async_locked(struct spi_device *spi,
++ struct spi_message *message);
+
+ /*---------------------------------------------------------------------------*/
+
+@@ -551,6 +560,9 @@ extern int spi_async(struct spi_device *
+ */
+
+ extern int spi_sync(struct spi_device *spi, struct spi_message *message);
++extern int spi_sync_locked(struct spi_device *spi, struct spi_message *message);
++extern int spi_bus_lock(struct spi_master *master);
++extern int spi_bus_unlock(struct spi_master *master);
+
+ /**
+ * spi_write - SPI synchronous write
--- /dev/null
+From 4751c1c74bc7b596db5de0c93be1a22a570145c0 Mon Sep 17 00:00:00 2001
+From: Ernst Schwab <eschwab@online.de>
+Date: Thu, 18 Feb 2010 12:47:46 +0100
+Subject: [PATCH] spi/mmc_spi: mmc_spi adaptations for SPI bus locking API
+
+Modification of the mmc_spi driver to use the SPI bus locking API.
+With this, the mmc_spi driver can be used together with other SPI
+devices on the same SPI bus. The exclusive access to the SPI bus is
+now managed in the SPI layer. The counting of chip selects in the probe
+function is no longer needed.
+
+Signed-off-by: Ernst Schwab <eschwab@online.de>
+Signed-off-by: Grant Likely <grant.likely@secretlab.ca>
+Tested-by: Matt Fleming <matt@console-pimps.org>
+Tested-by: Antonio Ospite <ospite@studenti.unina.it>
+---
+ drivers/mmc/host/mmc_spi.c | 59 ++++++++-----------------------------------
+ 1 files changed, 11 insertions(+), 48 deletions(-)
+
+--- a/drivers/mmc/host/mmc_spi.c
++++ b/drivers/mmc/host/mmc_spi.c
+@@ -182,7 +182,7 @@ mmc_spi_readbytes(struct mmc_spi_host *h
+ host->data_dma, sizeof(*host->data),
+ DMA_FROM_DEVICE);
+
+- status = spi_sync(host->spi, &host->readback);
++ status = spi_sync_locked(host->spi, &host->readback);
+
+ if (host->dma_dev)
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -541,7 +541,7 @@ mmc_spi_command_send(struct mmc_spi_host
+ host->data_dma, sizeof(*host->data),
+ DMA_BIDIRECTIONAL);
+ }
+- status = spi_sync(host->spi, &host->m);
++ status = spi_sync_locked(host->spi, &host->m);
+
+ if (host->dma_dev)
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -685,7 +685,7 @@ mmc_spi_writeblock(struct mmc_spi_host *
+ host->data_dma, sizeof(*scratch),
+ DMA_BIDIRECTIONAL);
+
+- status = spi_sync(spi, &host->m);
++ status = spi_sync_locked(spi, &host->m);
+
+ if (status != 0) {
+ dev_dbg(&spi->dev, "write error (%d)\n", status);
+@@ -822,7 +822,7 @@ mmc_spi_readblock(struct mmc_spi_host *h
+ DMA_FROM_DEVICE);
+ }
+
+- status = spi_sync(spi, &host->m);
++ status = spi_sync_locked(spi, &host->m);
+
+ if (host->dma_dev) {
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -1018,7 +1018,7 @@ mmc_spi_data_do(struct mmc_spi_host *hos
+ host->data_dma, sizeof(*scratch),
+ DMA_BIDIRECTIONAL);
+
+- tmp = spi_sync(spi, &host->m);
++ tmp = spi_sync_locked(spi, &host->m);
+
+ if (host->dma_dev)
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -1084,6 +1084,9 @@ static void mmc_spi_request(struct mmc_h
+ }
+ #endif
+
++ /* request exclusive bus access */
++ spi_bus_lock(host->spi->master);
++
+ /* issue command; then optionally data and stop */
+ status = mmc_spi_command_send(host, mrq, mrq->cmd, mrq->data != NULL);
+ if (status == 0 && mrq->data) {
+@@ -1094,6 +1097,9 @@ static void mmc_spi_request(struct mmc_h
+ mmc_cs_off(host);
+ }
+
++ /* release the bus */
++ spi_bus_unlock(host->spi->master);
++
+ mmc_request_done(host->mmc, mrq);
+ }
+
+@@ -1290,23 +1296,6 @@ mmc_spi_detect_irq(int irq, void *mmc)
+ return IRQ_HANDLED;
+ }
+
+-struct count_children {
+- unsigned n;
+- struct bus_type *bus;
+-};
+-
+-static int maybe_count_child(struct device *dev, void *c)
+-{
+- struct count_children *ccp = c;
+-
+- if (dev->bus == ccp->bus) {
+- if (ccp->n)
+- return -EBUSY;
+- ccp->n++;
+- }
+- return 0;
+-}
+-
+ static int mmc_spi_probe(struct spi_device *spi)
+ {
+ void *ones;
+@@ -1338,32 +1327,6 @@ static int mmc_spi_probe(struct spi_devi
+ return status;
+ }
+
+- /* We can use the bus safely iff nobody else will interfere with us.
+- * Most commands consist of one SPI message to issue a command, then
+- * several more to collect its response, then possibly more for data
+- * transfer. Clocking access to other devices during that period will
+- * corrupt the command execution.
+- *
+- * Until we have software primitives which guarantee non-interference,
+- * we'll aim for a hardware-level guarantee.
+- *
+- * REVISIT we can't guarantee another device won't be added later...
+- */
+- if (spi->master->num_chipselect > 1) {
+- struct count_children cc;
+-
+- cc.n = 0;
+- cc.bus = spi->dev.bus;
+- status = device_for_each_child(spi->dev.parent, &cc,
+- maybe_count_child);
+- if (status < 0) {
+- dev_err(&spi->dev, "can't share SPI bus\n");
+- return status;
+- }
+-
+- dev_warn(&spi->dev, "ASSUMING SPI bus stays unshared!\n");
+- }
+-
+ /* We need a supply of ones to transmit. This is the only time
+ * the CPU touches these, so cache coherency isn't a concern.
+ *
--- /dev/null
+From cf32b71e981ca63e8f349d8585ca2a3583b556e0 Mon Sep 17 00:00:00 2001
+From: Ernst Schwab <eschwab@online.de>
+Date: Mon, 28 Jun 2010 17:49:29 -0700
+Subject: [PATCH] spi/mmc_spi: SPI bus locking API, using mutex
+
+SPI bus locking API to allow exclusive access to the SPI bus, especially, but
+not limited to, for the mmc_spi driver.
+
+Coded according to an outline from Grant Likely; here is his
+specification (accidentally swapped function names corrected):
+
+It requires 3 things to be added to struct spi_master.
+- 1 Mutex
+- 1 spin lock
+- 1 flag.
+
+The mutex protects spi_sync, and provides sleeping "for free"
+The spinlock protects the atomic spi_async call.
+The flag is set when the lock is obtained, and checked while holding
+the spinlock in spi_async(). If the flag is checked, then spi_async()
+must fail immediately.
+
+The current runtime API looks like this:
+spi_async(struct spi_device*, struct spi_message*);
+spi_sync(struct spi_device*, struct spi_message*);
+
+The API needs to be extended to this:
+spi_async(struct spi_device*, struct spi_message*)
+spi_sync(struct spi_device*, struct spi_message*)
+spi_bus_lock(struct spi_master*) /* although struct spi_device* might
+be easier */
+spi_bus_unlock(struct spi_master*)
+spi_async_locked(struct spi_device*, struct spi_message*)
+spi_sync_locked(struct spi_device*, struct spi_message*)
+
+Drivers can only call the last two if they already hold the spi_master_lock().
+
+spi_bus_lock() obtains the mutex, obtains the spin lock, sets the
+flag, and releases the spin lock before returning. It doesn't even
+need to sleep while waiting for "in-flight" spi_transactions to
+complete because its purpose is to guarantee no additional
+transactions are added. It does not guarantee that the bus is idle.
+
+spi_bus_unlock() clears the flag and releases the mutex, which will
+wake up any waiters.
+
+The difference between spi_async() and spi_async_locked() is that the
+locked version bypasses the check of the lock flag. Both versions
+need to obtain the spinlock.
+
+The difference between spi_sync() and spi_sync_locked() is that
+spi_sync() must hold the mutex while enqueuing a new transfer.
+spi_sync_locked() doesn't because the mutex is already held. Note
+however that spi_sync must *not* continue to hold the mutex while
+waiting for the transfer to complete, otherwise only one transfer
+could be queued up at a time!
+
+Almost no code needs to be written. The current spi_async() and
+spi_sync() can probably be renamed to __spi_async() and __spi_sync()
+so that spi_async(), spi_sync(), spi_async_locked() and
+spi_sync_locked() can just become wrappers around the common code.
+
+spi_sync() is protected by a mutex because it can sleep
+spi_async() needs to be protected with a flag and a spinlock because
+it can be called atomically and must not sleep
+
+Signed-off-by: Ernst Schwab <eschwab@online.de>
+[grant.likely@secretlab.ca: use spin_lock_irqsave()]
+Signed-off-by: Grant Likely <grant.likely@secretlab.ca>
+Tested-by: Matt Fleming <matt@console-pimps.org>
+Tested-by: Antonio Ospite <ospite@studenti.unina.it>
+---
+ drivers/spi/spi.c | 225 ++++++++++++++++++++++++++++++++++++++++-------
+ include/linux/spi/spi.h | 12 +++
+ 2 files changed, 204 insertions(+), 33 deletions(-)
+
+--- a/drivers/spi/spi.c
++++ b/drivers/spi/spi.c
+@@ -527,6 +527,10 @@ int spi_register_master(struct spi_maste
+ dynamic = 1;
+ }
+
++ spin_lock_init(&master->bus_lock_spinlock);
++ mutex_init(&master->bus_lock_mutex);
++ master->bus_lock_flag = 0;
++
+ /* register the device, then userspace will see it.
+ * registration fails if the bus ID is in use.
+ */
+@@ -666,6 +670,35 @@ int spi_setup(struct spi_device *spi)
+ }
+ EXPORT_SYMBOL_GPL(spi_setup);
+
++static int __spi_async(struct spi_device *spi, struct spi_message *message)
++{
++ struct spi_master *master = spi->master;
++
++ /* Half-duplex links include original MicroWire, and ones with
++ * only one data pin like SPI_3WIRE (switches direction) or where
++ * either MOSI or MISO is missing. They can also be caused by
++ * software limitations.
++ */
++ if ((master->flags & SPI_MASTER_HALF_DUPLEX)
++ || (spi->mode & SPI_3WIRE)) {
++ struct spi_transfer *xfer;
++ unsigned flags = master->flags;
++
++ list_for_each_entry(xfer, &message->transfers, transfer_list) {
++ if (xfer->rx_buf && xfer->tx_buf)
++ return -EINVAL;
++ if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
++ return -EINVAL;
++ if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
++ return -EINVAL;
++ }
++ }
++
++ message->spi = spi;
++ message->status = -EINPROGRESS;
++ return master->transfer(spi, message);
++}
++
+ /**
+ * spi_async - asynchronous SPI transfer
+ * @spi: device with which data will be exchanged
+@@ -698,33 +731,68 @@ EXPORT_SYMBOL_GPL(spi_setup);
+ int spi_async(struct spi_device *spi, struct spi_message *message)
+ {
+ struct spi_master *master = spi->master;
++ int ret;
++ unsigned long flags;
+
+- /* Half-duplex links include original MicroWire, and ones with
+- * only one data pin like SPI_3WIRE (switches direction) or where
+- * either MOSI or MISO is missing. They can also be caused by
+- * software limitations.
+- */
+- if ((master->flags & SPI_MASTER_HALF_DUPLEX)
+- || (spi->mode & SPI_3WIRE)) {
+- struct spi_transfer *xfer;
+- unsigned flags = master->flags;
++ spin_lock_irqsave(&master->bus_lock_spinlock, flags);
+
+- list_for_each_entry(xfer, &message->transfers, transfer_list) {
+- if (xfer->rx_buf && xfer->tx_buf)
+- return -EINVAL;
+- if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
+- return -EINVAL;
+- if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
+- return -EINVAL;
+- }
+- }
++ if (master->bus_lock_flag)
++ ret = -EBUSY;
++ else
++ ret = __spi_async(spi, message);
+
+- message->spi = spi;
+- message->status = -EINPROGRESS;
+- return master->transfer(spi, message);
++ spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++
++ return ret;
+ }
+ EXPORT_SYMBOL_GPL(spi_async);
+
++/**
++ * spi_async_locked - version of spi_async with exclusive bus usage
++ * @spi: device with which data will be exchanged
++ * @message: describes the data transfers, including completion callback
++ * Context: any (irqs may be blocked, etc)
++ *
++ * This call may be used in_irq and other contexts which can't sleep,
++ * as well as from task contexts which can sleep.
++ *
++ * The completion callback is invoked in a context which can't sleep.
++ * Before that invocation, the value of message->status is undefined.
++ * When the callback is issued, message->status holds either zero (to
++ * indicate complete success) or a negative error code. After that
++ * callback returns, the driver which issued the transfer request may
++ * deallocate the associated memory; it's no longer in use by any SPI
++ * core or controller driver code.
++ *
++ * Note that although all messages to a spi_device are handled in
++ * FIFO order, messages may go to different devices in other orders.
++ * Some device might be higher priority, or have various "hard" access
++ * time requirements, for example.
++ *
++ * On detection of any fault during the transfer, processing of
++ * the entire message is aborted, and the device is deselected.
++ * Until returning from the associated message completion callback,
++ * no other spi_message queued to that device will be processed.
++ * (This rule applies equally to all the synchronous transfer calls,
++ * which are wrappers around this core asynchronous primitive.)
++ */
++int spi_async_locked(struct spi_device *spi, struct spi_message *message)
++{
++ struct spi_master *master = spi->master;
++ int ret;
++ unsigned long flags;
++
++ spin_lock_irqsave(&master->bus_lock_spinlock, flags);
++
++ ret = __spi_async(spi, message);
++
++ spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++
++ return ret;
++
++}
++EXPORT_SYMBOL_GPL(spi_async_locked);
++
+
+ /*-------------------------------------------------------------------------*/
+
+@@ -738,6 +806,32 @@ static void spi_complete(void *arg)
+ complete(arg);
+ }
+
++static int __spi_sync(struct spi_device *spi, struct spi_message *message,
++ int bus_locked)
++{
++ DECLARE_COMPLETION_ONSTACK(done);
++ int status;
++ struct spi_master *master = spi->master;
++
++ message->complete = spi_complete;
++ message->context = &done;
++
++ if (!bus_locked)
++ mutex_lock(&master->bus_lock_mutex);
++
++ status = spi_async_locked(spi, message);
++
++ if (!bus_locked)
++ mutex_unlock(&master->bus_lock_mutex);
++
++ if (status == 0) {
++ wait_for_completion(&done);
++ status = message->status;
++ }
++ message->context = NULL;
++ return status;
++}
++
+ /**
+ * spi_sync - blocking/synchronous SPI data transfers
+ * @spi: device with which data will be exchanged
+@@ -761,21 +855,86 @@ static void spi_complete(void *arg)
+ */
+ int spi_sync(struct spi_device *spi, struct spi_message *message)
+ {
+- DECLARE_COMPLETION_ONSTACK(done);
+- int status;
+-
+- message->complete = spi_complete;
+- message->context = &done;
+- status = spi_async(spi, message);
+- if (status == 0) {
+- wait_for_completion(&done);
+- status = message->status;
+- }
+- message->context = NULL;
+- return status;
++ return __spi_sync(spi, message, 0);
+ }
+ EXPORT_SYMBOL_GPL(spi_sync);
+
++/**
++ * spi_sync_locked - version of spi_sync with exclusive bus usage
++ * @spi: device with which data will be exchanged
++ * @message: describes the data transfers
++ * Context: can sleep
++ *
++ * This call may only be used from a context that may sleep. The sleep
++ * is non-interruptible, and has no timeout. Low-overhead controller
++ * drivers may DMA directly into and out of the message buffers.
++ *
++ * This call should be used by drivers that require exclusive access to the
++ * SPI bus. It has to be preceeded by a spi_bus_lock call. The SPI bus must
++ * be released by a spi_bus_unlock call when the exclusive access is over.
++ *
++ * It returns zero on success, else a negative error code.
++ */
++int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
++{
++ return __spi_sync(spi, message, 1);
++}
++EXPORT_SYMBOL_GPL(spi_sync_locked);
++
++/**
++ * spi_bus_lock - obtain a lock for exclusive SPI bus usage
++ * @master: SPI bus master that should be locked for exclusive bus access
++ * Context: can sleep
++ *
++ * This call may only be used from a context that may sleep. The sleep
++ * is non-interruptible, and has no timeout.
++ *
++ * This call should be used by drivers that require exclusive access to the
++ * SPI bus. The SPI bus must be released by a spi_bus_unlock call when the
++ * exclusive access is over. Data transfer must be done by spi_sync_locked
++ * and spi_async_locked calls when the SPI bus lock is held.
++ *
++ * It returns zero on success, else a negative error code.
++ */
++int spi_bus_lock(struct spi_master *master)
++{
++ unsigned long flags;
++
++ mutex_lock(&master->bus_lock_mutex);
++
++ spin_lock_irqsave(&master->bus_lock_spinlock, flags);
++ master->bus_lock_flag = 1;
++ spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++
++ /* mutex remains locked until spi_bus_unlock is called */
++
++ return 0;
++}
++EXPORT_SYMBOL_GPL(spi_bus_lock);
++
++/**
++ * spi_bus_unlock - release the lock for exclusive SPI bus usage
++ * @master: SPI bus master that was locked for exclusive bus access
++ * Context: can sleep
++ *
++ * This call may only be used from a context that may sleep. The sleep
++ * is non-interruptible, and has no timeout.
++ *
++ * This call releases an SPI bus lock previously obtained by an spi_bus_lock
++ * call.
++ *
++ * It returns zero on success, else a negative error code.
++ */
++int spi_bus_unlock(struct spi_master *master)
++{
++ master->bus_lock_flag = 0;
++
++ mutex_unlock(&master->bus_lock_mutex);
++
++ return 0;
++}
++EXPORT_SYMBOL_GPL(spi_bus_unlock);
++
+ /* portable code must never pass more than 32 bytes */
+ #define SPI_BUFSIZ max(32,SMP_CACHE_BYTES)
+
+--- a/include/linux/spi/spi.h
++++ b/include/linux/spi/spi.h
+@@ -262,6 +262,13 @@ struct spi_master {
+ #define SPI_MASTER_NO_RX BIT(1) /* can't do buffer read */
+ #define SPI_MASTER_NO_TX BIT(2) /* can't do buffer write */
+
++ /* lock and mutex for SPI bus locking */
++ spinlock_t bus_lock_spinlock;
++ struct mutex bus_lock_mutex;
++
++ /* flag indicating that the SPI bus is locked for exclusive use */
++ bool bus_lock_flag;
++
+ /* Setup mode and clock, etc (spi driver may call many times).
+ *
+ * IMPORTANT: this may be called when transfers to another
+@@ -542,6 +549,8 @@ static inline void spi_message_free(stru
+
+ extern int spi_setup(struct spi_device *spi);
+ extern int spi_async(struct spi_device *spi, struct spi_message *message);
++extern int spi_async_locked(struct spi_device *spi,
++ struct spi_message *message);
+
+ /*---------------------------------------------------------------------------*/
+
+@@ -551,6 +560,9 @@ extern int spi_async(struct spi_device *
+ */
+
+ extern int spi_sync(struct spi_device *spi, struct spi_message *message);
++extern int spi_sync_locked(struct spi_device *spi, struct spi_message *message);
++extern int spi_bus_lock(struct spi_master *master);
++extern int spi_bus_unlock(struct spi_master *master);
+
+ /**
+ * spi_write - SPI synchronous write
--- /dev/null
+From 4751c1c74bc7b596db5de0c93be1a22a570145c0 Mon Sep 17 00:00:00 2001
+From: Ernst Schwab <eschwab@online.de>
+Date: Thu, 18 Feb 2010 12:47:46 +0100
+Subject: [PATCH] spi/mmc_spi: mmc_spi adaptations for SPI bus locking API
+
+Modification of the mmc_spi driver to use the SPI bus locking API.
+With this, the mmc_spi driver can be used together with other SPI
+devices on the same SPI bus. The exclusive access to the SPI bus is
+now managed in the SPI layer. The counting of chip selects in the probe
+function is no longer needed.
+
+Signed-off-by: Ernst Schwab <eschwab@online.de>
+Signed-off-by: Grant Likely <grant.likely@secretlab.ca>
+Tested-by: Matt Fleming <matt@console-pimps.org>
+Tested-by: Antonio Ospite <ospite@studenti.unina.it>
+---
+ drivers/mmc/host/mmc_spi.c | 59 ++++++++-----------------------------------
+ 1 files changed, 11 insertions(+), 48 deletions(-)
+
+--- a/drivers/mmc/host/mmc_spi.c
++++ b/drivers/mmc/host/mmc_spi.c
+@@ -182,7 +182,7 @@ mmc_spi_readbytes(struct mmc_spi_host *h
+ host->data_dma, sizeof(*host->data),
+ DMA_FROM_DEVICE);
+
+- status = spi_sync(host->spi, &host->readback);
++ status = spi_sync_locked(host->spi, &host->readback);
+
+ if (host->dma_dev)
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -541,7 +541,7 @@ mmc_spi_command_send(struct mmc_spi_host
+ host->data_dma, sizeof(*host->data),
+ DMA_BIDIRECTIONAL);
+ }
+- status = spi_sync(host->spi, &host->m);
++ status = spi_sync_locked(host->spi, &host->m);
+
+ if (host->dma_dev)
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -685,7 +685,7 @@ mmc_spi_writeblock(struct mmc_spi_host *
+ host->data_dma, sizeof(*scratch),
+ DMA_BIDIRECTIONAL);
+
+- status = spi_sync(spi, &host->m);
++ status = spi_sync_locked(spi, &host->m);
+
+ if (status != 0) {
+ dev_dbg(&spi->dev, "write error (%d)\n", status);
+@@ -822,7 +822,7 @@ mmc_spi_readblock(struct mmc_spi_host *h
+ DMA_FROM_DEVICE);
+ }
+
+- status = spi_sync(spi, &host->m);
++ status = spi_sync_locked(spi, &host->m);
+
+ if (host->dma_dev) {
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -1018,7 +1018,7 @@ mmc_spi_data_do(struct mmc_spi_host *hos
+ host->data_dma, sizeof(*scratch),
+ DMA_BIDIRECTIONAL);
+
+- tmp = spi_sync(spi, &host->m);
++ tmp = spi_sync_locked(spi, &host->m);
+
+ if (host->dma_dev)
+ dma_sync_single_for_cpu(host->dma_dev,
+@@ -1084,6 +1084,9 @@ static void mmc_spi_request(struct mmc_h
+ }
+ #endif
+
++ /* request exclusive bus access */
++ spi_bus_lock(host->spi->master);
++
+ /* issue command; then optionally data and stop */
+ status = mmc_spi_command_send(host, mrq, mrq->cmd, mrq->data != NULL);
+ if (status == 0 && mrq->data) {
+@@ -1094,6 +1097,9 @@ static void mmc_spi_request(struct mmc_h
+ mmc_cs_off(host);
+ }
+
++ /* release the bus */
++ spi_bus_unlock(host->spi->master);
++
+ mmc_request_done(host->mmc, mrq);
+ }
+
+@@ -1290,23 +1296,6 @@ mmc_spi_detect_irq(int irq, void *mmc)
+ return IRQ_HANDLED;
+ }
+
+-struct count_children {
+- unsigned n;
+- struct bus_type *bus;
+-};
+-
+-static int maybe_count_child(struct device *dev, void *c)
+-{
+- struct count_children *ccp = c;
+-
+- if (dev->bus == ccp->bus) {
+- if (ccp->n)
+- return -EBUSY;
+- ccp->n++;
+- }
+- return 0;
+-}
+-
+ static int mmc_spi_probe(struct spi_device *spi)
+ {
+ void *ones;
+@@ -1338,32 +1327,6 @@ static int mmc_spi_probe(struct spi_devi
+ return status;
+ }
+
+- /* We can use the bus safely iff nobody else will interfere with us.
+- * Most commands consist of one SPI message to issue a command, then
+- * several more to collect its response, then possibly more for data
+- * transfer. Clocking access to other devices during that period will
+- * corrupt the command execution.
+- *
+- * Until we have software primitives which guarantee non-interference,
+- * we'll aim for a hardware-level guarantee.
+- *
+- * REVISIT we can't guarantee another device won't be added later...
+- */
+- if (spi->master->num_chipselect > 1) {
+- struct count_children cc;
+-
+- cc.n = 0;
+- cc.bus = spi->dev.bus;
+- status = device_for_each_child(spi->dev.parent, &cc,
+- maybe_count_child);
+- if (status < 0) {
+- dev_err(&spi->dev, "can't share SPI bus\n");
+- return status;
+- }
+-
+- dev_warn(&spi->dev, "ASSUMING SPI bus stays unshared!\n");
+- }
+-
+ /* We need a supply of ones to transmit. This is the only time
+ * the CPU touches these, so cache coherency isn't a concern.
+ *
projects / openwrt / openwrt.git / commitdiff