Merge branch 'next-spi' of git://git.secretlab.ca/git/linux-2.6 (b171aa27) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/mmc/host/mmc_spi.c

+11 −48

Original line number	Diff line number	Diff line
		@@ -182,7 +182,7 @@ mmc_spi_readbytes(struct mmc_spi_host *host, unsigned len)
		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,
		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, struct spi_transfer t,
		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 host, struct spi_transfer t,
		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 host, struct mmc_command cmd,
		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_host mmc, struct mmc_request mrq)
		}
		#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_host mmc, struct mmc_request mrq)
		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_device *spi)
		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.
		*

drivers/spi/amba-pl022.c

+3 −3

Original line number	Diff line number	Diff line
		@@ -1723,7 +1723,7 @@ static void pl022_cleanup(struct spi_device *spi)
		}


		static int __init
		static int __devinit
		pl022_probe(struct amba_device adev, struct amba_id id)
		{
		struct device *dev = &adev->dev;
		@@ -1838,7 +1838,7 @@ pl022_probe(struct amba_device adev, struct amba_id id)
		return status;
		}

		static int __exit
		static int __devexit
		pl022_remove(struct amba_device *adev)
		{
		struct pl022 *pl022 = amba_get_drvdata(adev);
		@@ -1970,7 +1970,7 @@ static struct amba_driver pl022_driver = {
		},
		.id_table = pl022_ids,
		.probe = pl022_probe,
		.remove = __exit_p(pl022_remove),
		.remove = __devexit_p(pl022_remove),
		.suspend = pl022_suspend,
		.resume = pl022_resume,
		};

drivers/spi/mpc512x_psc_spi.c

+8 −8

Original line number	Diff line number	Diff line
		@@ -406,7 +406,7 @@ static irqreturn_t mpc512x_psc_spi_isr(int irq, void *dev_id)
		}

		/* bus_num is used only for the case dev->platform_data == NULL */
		static int __init mpc512x_psc_spi_do_probe(struct device *dev, u32 regaddr,
		static int __devinit mpc512x_psc_spi_do_probe(struct device *dev, u32 regaddr,
		u32 size, unsigned int irq,
		s16 bus_num)
		{
		@@ -492,7 +492,7 @@ free_master:
		return ret;
		}

		static int __exit mpc512x_psc_spi_do_remove(struct device *dev)
		static int __devexit mpc512x_psc_spi_do_remove(struct device *dev)
		{
		struct spi_master *master = dev_get_drvdata(dev);
		struct mpc512x_psc_spi *mps = spi_master_get_devdata(master);
		@@ -507,7 +507,7 @@ static int __exit mpc512x_psc_spi_do_remove(struct device *dev)
		return 0;
		}

		static int __init mpc512x_psc_spi_of_probe(struct platform_device *op,
		static int __devinit mpc512x_psc_spi_of_probe(struct platform_device *op,
		const struct of_device_id *match)
		{
		const u32 *regaddr_p;
		@@ -539,7 +539,7 @@ static int __init mpc512x_psc_spi_of_probe(struct platform_device *op,
		irq_of_parse_and_map(op->dev.of_node, 0), id);
		}

		static int __exit mpc512x_psc_spi_of_remove(struct platform_device *op)
		static int __devexit mpc512x_psc_spi_of_remove(struct platform_device *op)
		{
		return mpc512x_psc_spi_do_remove(&op->dev);
		}
		@@ -553,7 +553,7 @@ MODULE_DEVICE_TABLE(of, mpc512x_psc_spi_of_match);

		static struct of_platform_driver mpc512x_psc_spi_of_driver = {
		.probe = mpc512x_psc_spi_of_probe,
		.remove = __exit_p(mpc512x_psc_spi_of_remove),
		.remove = __devexit_p(mpc512x_psc_spi_of_remove),
		.driver = {
		.name = "mpc512x-psc-spi",
		.owner = THIS_MODULE,

drivers/spi/omap_spi_100k.c

+12 −11

Original line number	Diff line number	Diff line
		@@ -141,7 +141,12 @@ static void spi100k_write_data(struct spi_master *master, int len, int data)
		{
		struct omap1_spi100k *spi100k = spi_master_get_devdata(master);

		/* write 16-bit word */
		/* write 16-bit word, shifting 8-bit data if necessary */
		if (len <= 8) {
		data <<= 8;
		len = 16;
		}

		spi100k_enable_clock(master);
		writew( data , spi100k->base + SPI_TX_MSB);

		@@ -162,6 +167,10 @@ static int spi100k_read_data(struct spi_master *master, int len)
		int dataH,dataL;
		struct omap1_spi100k *spi100k = spi_master_get_devdata(master);

		/* Always do at least 16 bits */
		if (len <= 8)
		len = 16;

		spi100k_enable_clock(master);
		writew(SPI_CTRL_SEN(0) \|
		SPI_CTRL_WORD_SIZE(len) \|
		@@ -214,10 +223,6 @@ omap1_spi100k_txrx_pio(struct spi_device spi, struct spi_transfer xfer)
		c = count;
		word_len = cs->word_len;

		/* RX_ONLY mode needs dummy data in TX reg */
		if (xfer->tx_buf == NULL)
		spi100k_write_data(spi->master,word_len, 0);

		if (word_len <= 8) {
		u8 *rx;
		const u8 *tx;
		@@ -227,9 +232,9 @@ omap1_spi100k_txrx_pio(struct spi_device spi, struct spi_transfer xfer)
		do {
		c-=1;
		if (xfer->tx_buf != NULL)
		spi100k_write_data(spi->master,word_len, *tx);
		spi100k_write_data(spi->master, word_len, *tx++);
		if (xfer->rx_buf != NULL)
		*rx = spi100k_read_data(spi->master,word_len);
		*rx++ = spi100k_read_data(spi->master, word_len);
		} while(c);
		} else if (word_len <= 16) {
		u16 *rx;
		@@ -380,10 +385,6 @@ static void omap1_spi100k_work(struct work_struct *work)
		if (t->len) {
		unsigned count;

		/* RX_ONLY mode needs dummy data in TX reg */
		if (t->tx_buf == NULL)
		spi100k_write_data(spi->master, 8, 0);

		count = omap1_spi100k_txrx_pio(spi, t);
		m->actual_length += count;

drivers/spi/spi.c

+192 −33

Original line number	Diff line number	Diff line
		@@ -528,6 +528,10 @@ int spi_register_master(struct spi_master *master)
		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.
		*/
		@@ -670,6 +674,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
		@@ -702,33 +735,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);


		/-------------------------------------------------------------------------/

		@@ -742,6 +810,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
		@@ -765,20 +859,85 @@ static void spi_complete(void *arg)
		*/
		int spi_sync(struct spi_device spi, struct spi_message message)
		{
		DECLARE_COMPLETION_ONSTACK(done);
		int status;
		return __spi_sync(spi, message, 0);
		}
		EXPORT_SYMBOL_GPL(spi_sync);

		message->complete = spi_complete;
		message->context = &done;
		status = spi_async(spi, message);
		if (status == 0) {
		wait_for_completion(&done);
		status = message->status;
		/**
		* 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);
		}
		message->context = NULL;
		return status;
		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_sync);
		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)