Merge git://git.kernel.org/pub/scm/linux/kernel/git/bunk/trivial
[linux-3.10.git] / drivers / spi / spi_bitbang.c
index 44aff19..a23862e 100644 (file)
@@ -16,7 +16,6 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include <linux/config.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
@@ -138,6 +137,45 @@ static unsigned bitbang_txrx_32(
        return t->len - count;
 }
 
+int spi_bitbang_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
+{
+       struct spi_bitbang_cs   *cs = spi->controller_state;
+       u8                      bits_per_word;
+       u32                     hz;
+
+       if (t) {
+               bits_per_word = t->bits_per_word;
+               hz = t->speed_hz;
+       } else {
+               bits_per_word = 0;
+               hz = 0;
+       }
+
+       /* spi_transfer level calls that work per-word */
+       if (!bits_per_word)
+               bits_per_word = spi->bits_per_word;
+       if (bits_per_word <= 8)
+               cs->txrx_bufs = bitbang_txrx_8;
+       else if (bits_per_word <= 16)
+               cs->txrx_bufs = bitbang_txrx_16;
+       else if (bits_per_word <= 32)
+               cs->txrx_bufs = bitbang_txrx_32;
+       else
+               return -EINVAL;
+
+       /* nsecs = (clock period)/2 */
+       if (!hz)
+               hz = spi->max_speed_hz;
+       if (hz) {
+               cs->nsecs = (1000000000/2) / hz;
+               if (cs->nsecs > (MAX_UDELAY_MS * 1000 * 1000))
+                       return -EINVAL;
+       }
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(spi_bitbang_setup_transfer);
+
 /**
  * spi_bitbang_setup - default setup for per-word I/O loops
  */
@@ -145,6 +183,17 @@ int spi_bitbang_setup(struct spi_device *spi)
 {
        struct spi_bitbang_cs   *cs = spi->controller_state;
        struct spi_bitbang      *bitbang;
+       int                     retval;
+
+       bitbang = spi_master_get_devdata(spi->master);
+
+       /* REVISIT: some systems will want to support devices using lsb-first
+        * bit encodings on the wire.  In pure software that would be trivial,
+        * just bitbang_txrx_le_cphaX() routines shifting the other way, and
+        * some hardware controllers also have this support.
+        */
+       if ((spi->mode & SPI_LSB_FIRST) != 0)
+               return -EINVAL;
 
        if (!cs) {
                cs = kzalloc(sizeof *cs, SLAB_KERNEL);
@@ -152,37 +201,20 @@ int spi_bitbang_setup(struct spi_device *spi)
                        return -ENOMEM;
                spi->controller_state = cs;
        }
-       bitbang = spi_master_get_devdata(spi->master);
 
        if (!spi->bits_per_word)
                spi->bits_per_word = 8;
 
-       /* spi_transfer level calls that work per-word */
-       if (spi->bits_per_word <= 8)
-               cs->txrx_bufs = bitbang_txrx_8;
-       else if (spi->bits_per_word <= 16)
-               cs->txrx_bufs = bitbang_txrx_16;
-       else if (spi->bits_per_word <= 32)
-               cs->txrx_bufs = bitbang_txrx_32;
-       else
-               return -EINVAL;
-
        /* per-word shift register access, in hardware or bitbanging */
        cs->txrx_word = bitbang->txrx_word[spi->mode & (SPI_CPOL|SPI_CPHA)];
        if (!cs->txrx_word)
                return -EINVAL;
 
-       if (!spi->max_speed_hz)
-               spi->max_speed_hz = 500 * 1000;
-
-       /* nsecs = max(50, (clock period)/2), be optimistic */
-       cs->nsecs = (1000000000/2) / (spi->max_speed_hz);
-       if (cs->nsecs < 50)
-               cs->nsecs = 50;
-       if (cs->nsecs > MAX_UDELAY_MS * 1000)
-               return -EINVAL;
+       retval = spi_bitbang_setup_transfer(spi, NULL);
+       if (retval < 0)
+               return retval;
 
-       dev_dbg(&spi->dev, "%s, mode %d, %u bits/w, %u nsec\n",
+       dev_dbg(&spi->dev, "%s, mode %d, %u bits/w, %u nsec/bit\n",
                        __FUNCTION__, spi->mode & (SPI_CPOL | SPI_CPHA),
                        spi->bits_per_word, 2 * cs->nsecs);
 
@@ -194,7 +226,7 @@ int spi_bitbang_setup(struct spi_device *spi)
        /* deselect chip (low or high) */
        spin_lock(&bitbang->lock);
        if (!bitbang->busy) {
-               bitbang->chipselect(spi, 0);
+               bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
                ndelay(cs->nsecs);
        }
        spin_unlock(&bitbang->lock);
@@ -244,47 +276,76 @@ static void bitbang_work(void *_bitbang)
                struct spi_message      *m;
                struct spi_device       *spi;
                unsigned                nsecs;
-               struct spi_transfer     *t;
+               struct spi_transfer     *t = NULL;
                unsigned                tmp;
-               unsigned                chipselect;
+               unsigned                cs_change;
                int                     status;
+               int                     (*setup_transfer)(struct spi_device *,
+                                               struct spi_transfer *);
 
                m = container_of(bitbang->queue.next, struct spi_message,
                                queue);
                list_del_init(&m->queue);
                spin_unlock_irqrestore(&bitbang->lock, flags);
 
-// FIXME this is made-up
-nsecs = 100;
+               /* FIXME this is made-up ... the correct value is known to
+                * word-at-a-time bitbang code, and presumably chipselect()
+                * should enforce these requirements too?
+                */
+               nsecs = 100;
 
                spi = m->spi;
-               t = m->transfers;
                tmp = 0;
-               chipselect = 0;
+               cs_change = 1;
                status = 0;
+               setup_transfer = NULL;
 
-               for (;;t++) {
+               list_for_each_entry (t, &m->transfers, transfer_list) {
                        if (bitbang->shutdown) {
                                status = -ESHUTDOWN;
                                break;
                        }
 
-                       /* set up default clock polarity, and activate chip */
-                       if (!chipselect) {
-                               bitbang->chipselect(spi, 1);
+                       /* override or restore speed and wordsize */
+                       if (t->speed_hz || t->bits_per_word) {
+                               setup_transfer = bitbang->setup_transfer;
+                               if (!setup_transfer) {
+                                       status = -ENOPROTOOPT;
+                                       break;
+                               }
+                       }
+                       if (setup_transfer) {
+                               status = setup_transfer(spi, t);
+                               if (status < 0)
+                                       break;
+                       }
+
+                       /* set up default clock polarity, and activate chip;
+                        * this implicitly updates clock and spi modes as
+                        * previously recorded for this device via setup().
+                        * (and also deselects any other chip that might be
+                        * selected ...)
+                        */
+                       if (cs_change) {
+                               bitbang->chipselect(spi, BITBANG_CS_ACTIVE);
                                ndelay(nsecs);
                        }
+                       cs_change = t->cs_change;
                        if (!t->tx_buf && !t->rx_buf && t->len) {
                                status = -EINVAL;
                                break;
                        }
 
-                       /* transfer data */
+                       /* transfer data.  the lower level code handles any
+                        * new dma mappings it needs. our caller always gave
+                        * us dma-safe buffers.
+                        */
                        if (t->len) {
-                               /* FIXME if bitbang->use_dma, dma_map_single()
-                                * before the transfer, and dma_unmap_single()
-                                * afterwards, for either or both buffers...
+                               /* REVISIT dma API still needs a designated
+                                * DMA_ADDR_INVALID; ~0 might be better.
                                 */
+                               if (!m->is_dma_mapped)
+                                       t->rx_dma = t->tx_dma = 0;
                                status = bitbang->txrx_bufs(spi, t);
                        }
                        if (status != t->len) {
@@ -299,29 +360,35 @@ nsecs = 100;
                        if (t->delay_usecs)
                                udelay(t->delay_usecs);
 
-                       tmp++;
-                       if (tmp >= m->n_transfer)
-                               break;
-
-                       chipselect = !t->cs_change;
-                       if (chipselect);
+                       if (!cs_change)
                                continue;
+                       if (t->transfer_list.next == &m->transfers)
+                               break;
 
-                       bitbang->chipselect(spi, 0);
-
-                       /* REVISIT do we want the udelay here instead? */
-                       msleep(1);
+                       /* sometimes a short mid-message deselect of the chip
+                        * may be needed to terminate a mode or command
+                        */
+                       ndelay(nsecs);
+                       bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
+                       ndelay(nsecs);
                }
 
-               tmp = m->n_transfer - 1;
-               tmp = m->transfers[tmp].cs_change;
-
                m->status = status;
                m->complete(m->context);
 
-               ndelay(2 * nsecs);
-               bitbang->chipselect(spi, status == 0 && tmp);
-               ndelay(nsecs);
+               /* restore speed and wordsize */
+               if (setup_transfer)
+                       setup_transfer(spi, NULL);
+
+               /* normally deactivate chipselect ... unless no error and
+                * cs_change has hinted that the next message will probably
+                * be for this chip too.
+                */
+               if (!(status == 0 && cs_change)) {
+                       ndelay(nsecs);
+                       bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
+                       ndelay(nsecs);
+               }
 
                spin_lock_irqsave(&bitbang->lock, flags);
        }
@@ -336,6 +403,7 @@ int spi_bitbang_transfer(struct spi_device *spi, struct spi_message *m)
 {
        struct spi_bitbang      *bitbang;
        unsigned long           flags;
+       int                     status = 0;
 
        m->actual_length = 0;
        m->status = -EINPROGRESS;
@@ -345,11 +413,15 @@ int spi_bitbang_transfer(struct spi_device *spi, struct spi_message *m)
                return -ESHUTDOWN;
 
        spin_lock_irqsave(&bitbang->lock, flags);
-       list_add_tail(&m->queue, &bitbang->queue);
-       queue_work(bitbang->workqueue, &bitbang->work);
+       if (!spi->max_speed_hz)
+               status = -ENETDOWN;
+       else {
+               list_add_tail(&m->queue, &bitbang->queue);
+               queue_work(bitbang->workqueue, &bitbang->work);
+       }
        spin_unlock_irqrestore(&bitbang->lock, flags);
 
-       return 0;
+       return status;
 }
 EXPORT_SYMBOL_GPL(spi_bitbang_transfer);
 
@@ -394,6 +466,9 @@ int spi_bitbang_start(struct spi_bitbang *bitbang)
                bitbang->use_dma = 0;
                bitbang->txrx_bufs = spi_bitbang_bufs;
                if (!bitbang->master->setup) {
+                       if (!bitbang->setup_transfer)
+                               bitbang->setup_transfer =
+                                        spi_bitbang_setup_transfer;
                        bitbang->master->setup = spi_bitbang_setup;
                        bitbang->master->cleanup = spi_bitbang_cleanup;
                }