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

drivers/mmc/host/mmc_spi.c

+11 −48

Original line number	Original line	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),		host->data_dma, sizeof(*host->data),
	DMA_FROM_DEVICE);		DMA_FROM_DEVICE);

	status = spi_sync(host->spi, &host->readback);		status = spi_sync_locked(host->spi, &host->readback);

	if (host->dma_dev)		if (host->dma_dev)
	dma_sync_single_for_cpu(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),		host->data_dma, sizeof(*host->data),
	DMA_BIDIRECTIONAL);		DMA_BIDIRECTIONAL);
	}		}
	status = spi_sync(host->spi, &host->m);		status = spi_sync_locked(host->spi, &host->m);

	if (host->dma_dev)		if (host->dma_dev)
	dma_sync_single_for_cpu(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),		host->data_dma, sizeof(*scratch),
	DMA_BIDIRECTIONAL);		DMA_BIDIRECTIONAL);

	status = spi_sync(spi, &host->m);		status = spi_sync_locked(spi, &host->m);

	if (status != 0) {		if (status != 0) {
	dev_dbg(&spi->dev, "write error (%d)\n", status);		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);		DMA_FROM_DEVICE);
	}		}

	status = spi_sync(spi, &host->m);		status = spi_sync_locked(spi, &host->m);

	if (host->dma_dev) {		if (host->dma_dev) {
	dma_sync_single_for_cpu(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),		host->data_dma, sizeof(*scratch),
	DMA_BIDIRECTIONAL);		DMA_BIDIRECTIONAL);

	tmp = spi_sync(spi, &host->m);		tmp = spi_sync_locked(spi, &host->m);

	if (host->dma_dev)		if (host->dma_dev)
	dma_sync_single_for_cpu(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		#endif

			/* request exclusive bus access */
			spi_bus_lock(host->spi->master);

	/* issue command; then optionally data and stop */		/* issue command; then optionally data and stop */
	status = mmc_spi_command_send(host, mrq, mrq->cmd, mrq->data != NULL);		status = mmc_spi_command_send(host, mrq, mrq->cmd, mrq->data != NULL);
	if (status == 0 && mrq->data) {		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);		mmc_cs_off(host);
	}		}

			/* release the bus */
			spi_bus_unlock(host->spi->master);

	mmc_request_done(host->mmc, mrq);		mmc_request_done(host->mmc, mrq);
	}		}

	@@ -1290,23 +1296,6 @@ mmc_spi_detect_irq(int irq, void *mmc)
	return IRQ_HANDLED;		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)		static int mmc_spi_probe(struct spi_device *spi)
	{		{
	void *ones;		void *ones;
	@@ -1338,32 +1327,6 @@ static int mmc_spi_probe(struct spi_device *spi)
	return status;		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		/* We need a supply of ones to transmit. This is the only time
	* the CPU touches these, so cache coherency isn't a concern.		* the CPU touches these, so cache coherency isn't a concern.
	*		*

drivers/spi/amba-pl022.c

+3 −3

Original line number	Original line	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)		pl022_probe(struct amba_device adev, struct amba_id id)
	{		{
	struct device *dev = &adev->dev;		struct device *dev = &adev->dev;
	@@ -1838,7 +1838,7 @@ pl022_probe(struct amba_device adev, struct amba_id id)
	return status;		return status;
	}		}

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

drivers/spi/mpc512x_psc_spi.c

+8 −8

Original line number	Original line	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 */		/* 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,		u32 size, unsigned int irq,
	s16 bus_num)		s16 bus_num)
	{		{
	@@ -492,7 +492,7 @@ free_master:
	return ret;		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 spi_master *master = dev_get_drvdata(dev);
	struct mpc512x_psc_spi *mps = spi_master_get_devdata(master);		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;		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 struct of_device_id *match)
	{		{
	const u32 *regaddr_p;		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);		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);		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 = {		static struct of_platform_driver mpc512x_psc_spi_of_driver = {
	.probe = mpc512x_psc_spi_of_probe,		.probe = mpc512x_psc_spi_of_probe,
	.remove = __exit_p(mpc512x_psc_spi_of_remove),		.remove = __devexit_p(mpc512x_psc_spi_of_remove),
	.driver = {		.driver = {
	.name = "mpc512x-psc-spi",		.name = "mpc512x-psc-spi",
	.owner = THIS_MODULE,		.owner = THIS_MODULE,

drivers/spi/omap_spi_100k.c

+12 −11

Original line number	Original line	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);		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);		spi100k_enable_clock(master);
	writew( data , spi100k->base + SPI_TX_MSB);		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;		int dataH,dataL;
	struct omap1_spi100k *spi100k = spi_master_get_devdata(master);		struct omap1_spi100k *spi100k = spi_master_get_devdata(master);

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

	spi100k_enable_clock(master);		spi100k_enable_clock(master);
	writew(SPI_CTRL_SEN(0) \|		writew(SPI_CTRL_SEN(0) \|
	SPI_CTRL_WORD_SIZE(len) \|		SPI_CTRL_WORD_SIZE(len) \|
	@@ -214,10 +223,6 @@ omap1_spi100k_txrx_pio(struct spi_device spi, struct spi_transfer xfer)
	c = count;		c = count;
	word_len = cs->word_len;		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) {		if (word_len <= 8) {
	u8 *rx;		u8 *rx;
	const u8 *tx;		const u8 *tx;
	@@ -227,9 +232,9 @@ omap1_spi100k_txrx_pio(struct spi_device spi, struct spi_transfer xfer)
	do {		do {
	c-=1;		c-=1;
	if (xfer->tx_buf != NULL)		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)		if (xfer->rx_buf != NULL)
	*rx = spi100k_read_data(spi->master,word_len);		*rx++ = spi100k_read_data(spi->master, word_len);
	} while(c);		} while(c);
	} else if (word_len <= 16) {		} else if (word_len <= 16) {
	u16 *rx;		u16 *rx;
	@@ -380,10 +385,6 @@ static void omap1_spi100k_work(struct work_struct *work)
	if (t->len) {		if (t->len) {
	unsigned count;		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);		count = omap1_spi100k_txrx_pio(spi, t);
	m->actual_length += count;		m->actual_length += count;

drivers/spi/spi.c

+192 −33

Original line number	Original line	Diff line number	Diff line
	@@ -528,6 +528,10 @@ int spi_register_master(struct spi_master *master)
	dynamic = 1;		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.		/* register the device, then userspace will see it.
	* registration fails if the bus ID is in use.		* 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);		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_async - asynchronous SPI transfer
	* @spi: device with which data will be exchanged		* @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)		int spi_async(struct spi_device spi, struct spi_message message)
	{		{
	struct spi_master *master = spi->master;		struct spi_master *master = spi->master;
			int ret;
			unsigned long flags;

	/* Half-duplex links include original MicroWire, and ones with		spin_lock_irqsave(&master->bus_lock_spinlock, flags);
	* 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 (master->bus_lock_flag)
	if (xfer->rx_buf && xfer->tx_buf)		ret = -EBUSY;
	return -EINVAL;		else
	if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)		ret = __spi_async(spi, message);
	return -EINVAL;
	if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
	return -EINVAL;
	}
	}

	message->spi = spi;		spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
	message->status = -EINPROGRESS;
	return master->transfer(spi, message);		return ret;
	}		}
	EXPORT_SYMBOL_GPL(spi_async);		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);		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_sync - blocking/synchronous SPI data transfers
	* @spi: device with which data will be exchanged		* @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)		int spi_sync(struct spi_device spi, struct spi_message message)
	{		{
	DECLARE_COMPLETION_ONSTACK(done);		return __spi_sync(spi, message, 0);
	int status;		}
			EXPORT_SYMBOL_GPL(spi_sync);

	message->complete = spi_complete;		/**
	message->context = &done;		* spi_sync_locked - version of spi_sync with exclusive bus usage
	status = spi_async(spi, message);		* @spi: device with which data will be exchanged
	if (status == 0) {		* @message: describes the data transfers
	wait_for_completion(&done);		* Context: can sleep
	status = message->status;		*
			* 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;		EXPORT_SYMBOL_GPL(spi_sync_locked);
	return status;
			/**
			* 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 */		/* portable code must never pass more than 32 bytes */
	#define SPI_BUFSIZ max(32,SMP_CACHE_BYTES)		#define SPI_BUFSIZ max(32,SMP_CACHE_BYTES)

Admin message