Merge commit 'v2.6.28-rc6' into core/debug

1 files changed, 134 insertions, 60 deletions

diff --git a/drivers/spi/pxa2xx_spi.c b/drivers/spi/pxa2xx_spi.c
index 34c7c9875681..cf12f2d84be2 100644
--- a/drivers/spi/pxa2xx_spi.c
+++ b/drivers/spi/pxa2xx_spi.c
@@ -47,9 +47,14 @@ MODULE_ALIAS("platform:pxa2xx-spi");
 
 #define MAX_BUSES 3
 
-#define DMA_INT_MASK (DCSR_ENDINTR | DCSR_STARTINTR | DCSR_BUSERR)
-#define RESET_DMA_CHANNEL (DCSR_NODESC | DMA_INT_MASK)
-#define IS_DMA_ALIGNED(x) (((u32)(x)&0x07)==0)
+#define RX_THRESH_DFLT  8
+#define TX_THRESH_DFLT  8
+#define TIMOUT_DFLT             1000
+
+#define DMA_INT_MASK            (DCSR_ENDINTR | DCSR_STARTINTR | DCSR_BUSERR)
+#define RESET_DMA_CHANNEL       (DCSR_NODESC | DMA_INT_MASK)
+#define IS_DMA_ALIGNED(x)       ((((u32)(x)) & 0x07) == 0)
+#define MAX_DMA_LEN             8191
 
 /*
  * for testing SSCR1 changes that require SSP restart, basically
@@ -144,7 +149,6 @@ struct driver_data {
         size_t tx_map_len;
         u8 n_bytes;
         u32 dma_width;
-        int cs_change;
         int (*write)(struct driver_data *drv_data);
         int (*read)(struct driver_data *drv_data);
         irqreturn_t (*transfer_handler)(struct driver_data *drv_data);
@@ -348,21 +352,21 @@ static int map_dma_buffers(struct driver_data *drv_data)
         } else
                 drv_data->tx_map_len = drv_data->len;
 
-        /* Stream map the rx buffer */
-        drv_data->rx_dma = dma_map_single(dev, drv_data->rx,
-                                                drv_data->rx_map_len,
-                                                DMA_FROM_DEVICE);
-        if (dma_mapping_error(dev, drv_data->rx_dma))
-                return 0;
-
-        /* Stream map the tx buffer */
+        /* Stream map the tx buffer. Always do DMA_TO_DEVICE first
+         * so we flush the cache *before* invalidating it, in case
+         * the tx and rx buffers overlap.
+         */
         drv_data->tx_dma = dma_map_single(dev, drv_data->tx,
-                                                drv_data->tx_map_len,
-                                                DMA_TO_DEVICE);
+                                        drv_data->tx_map_len, DMA_TO_DEVICE);
+        if (dma_mapping_error(dev, drv_data->tx_dma))
+                return 0;
 
-        if (dma_mapping_error(dev, drv_data->tx_dma)) {
-                dma_unmap_single(dev, drv_data->rx_dma,
+        /* Stream map the rx buffer */
+        drv_data->rx_dma = dma_map_single(dev, drv_data->rx,
                                         drv_data->rx_map_len, DMA_FROM_DEVICE);
+        if (dma_mapping_error(dev, drv_data->rx_dma)) {
+                dma_unmap_single(dev, drv_data->tx_dma,
+                                        drv_data->tx_map_len, DMA_TO_DEVICE);
                 return 0;
         }
 
@@ -406,8 +410,45 @@ static void giveback(struct driver_data *drv_data)
                                         struct spi_transfer,
                                         transfer_list);
 
+        /* Delay if requested before any change in chip select */
+        if (last_transfer->delay_usecs)
+                udelay(last_transfer->delay_usecs);
+
+        /* Drop chip select UNLESS cs_change is true or we are returning
+         * a message with an error, or next message is for another chip
+         */
         if (!last_transfer->cs_change)
                 drv_data->cs_control(PXA2XX_CS_DEASSERT);
+        else {
+                struct spi_message *next_msg;
+
+                /* Holding of cs was hinted, but we need to make sure
+                 * the next message is for the same chip.  Don't waste
+                 * time with the following tests unless this was hinted.
+                 *
+                 * We cannot postpone this until pump_messages, because
+                 * after calling msg->complete (below) the driver that
+                 * sent the current message could be unloaded, which
+                 * could invalidate the cs_control() callback...
+                 */
+
+                /* get a pointer to the next message, if any */
+                spin_lock_irqsave(&drv_data->lock, flags);
+                if (list_empty(&drv_data->queue))
+                        next_msg = NULL;
+                else
+                        next_msg = list_entry(drv_data->queue.next,
+                                        struct spi_message, queue);
+                spin_unlock_irqrestore(&drv_data->lock, flags);
+
+                /* see if the next and current messages point
+                 * to the same chip
+                 */
+                if (next_msg && next_msg->spi != msg->spi)
+                        next_msg = NULL;
+                if (!next_msg || msg->state == ERROR_STATE)
+                        drv_data->cs_control(PXA2XX_CS_DEASSERT);
+        }
 
         msg->state = NULL;
         if (msg->complete)
@@ -490,10 +531,9 @@ static void dma_transfer_complete(struct driver_data *drv_data)
         msg->actual_length += drv_data->len -
                                 (drv_data->rx_end - drv_data->rx);
 
-        /* Release chip select if requested, transfer delays are
-         * handled in pump_transfers */
-        if (drv_data->cs_change)
-                drv_data->cs_control(PXA2XX_CS_DEASSERT);
+        /* Transfer delays and chip select release are
+         * handled in pump_transfers or giveback
+         */
 
         /* Move to next transfer */
         msg->state = next_transfer(drv_data);
@@ -602,10 +642,9 @@ static void int_transfer_complete(struct driver_data *drv_data)
         drv_data->cur_msg->actual_length += drv_data->len -
                                 (drv_data->rx_end - drv_data->rx);
 
-        /* Release chip select if requested, transfer delays are
-         * handled in pump_transfers */
-        if (drv_data->cs_change)
-                drv_data->cs_control(PXA2XX_CS_DEASSERT);
+        /* Transfer delays and chip select release are
+         * handled in pump_transfers or giveback
+         */
 
         /* Move to next transfer */
         drv_data->cur_msg->state = next_transfer(drv_data);
@@ -840,23 +879,40 @@ static void pump_transfers(unsigned long data)
                 return;
         }
 
-        /* Delay if requested at end of transfer*/
+        /* Delay if requested at end of transfer before CS change */
         if (message->state == RUNNING_STATE) {
                 previous = list_entry(transfer->transfer_list.prev,
                                         struct spi_transfer,
                                         transfer_list);
                 if (previous->delay_usecs)
                         udelay(previous->delay_usecs);
+
+                /* Drop chip select only if cs_change is requested */
+                if (previous->cs_change)
+                        drv_data->cs_control(PXA2XX_CS_DEASSERT);
         }
 
-        /* Check transfer length */
-        if (transfer->len > 8191)
-        {
-                dev_warn(&drv_data->pdev->dev, "pump_transfers: transfer "
-                                "length greater than 8191\n");
-                message->status = -EINVAL;
-                giveback(drv_data);
-                return;
+        /* Check for transfers that need multiple DMA segments */
+        if (transfer->len > MAX_DMA_LEN && chip->enable_dma) {
+
+                /* reject already-mapped transfers; PIO won't always work */
+                if (message->is_dma_mapped
+                                || transfer->rx_dma || transfer->tx_dma) {
+                        dev_err(&drv_data->pdev->dev,
+                                "pump_transfers: mapped transfer length "
+                                "of %u is greater than %d\n",
+                                transfer->len, MAX_DMA_LEN);
+                        message->status = -EINVAL;
+                        giveback(drv_data);
+                        return;
+                }
+
+                /* warn ... we force this to PIO mode */
+                if (printk_ratelimit())
+                        dev_warn(&message->spi->dev, "pump_transfers: "
+                                "DMA disabled for transfer length %ld "
+                                "greater than %d\n",
+                                (long)drv_data->len, MAX_DMA_LEN);
         }
 
         /* Setup the transfer state based on the type of transfer */
@@ -878,7 +934,6 @@ static void pump_transfers(unsigned long data)
         drv_data->len = transfer->len & DCMD_LENGTH;
         drv_data->write = drv_data->tx ? chip->write : null_writer;
         drv_data->read = drv_data->rx ? chip->read : null_reader;
-        drv_data->cs_change = transfer->cs_change;
 
         /* Change speed and bit per word on a per transfer */
         cr0 = chip->cr0;
@@ -925,7 +980,7 @@ static void pump_transfers(unsigned long data)
                                                         &dma_thresh))
                                 if (printk_ratelimit())
                                         dev_warn(&message->spi->dev,
-                                                "pump_transfer: "
+                                                "pump_transfers: "
                                                 "DMA burst size reduced to "
                                                 "match bits_per_word\n");
                 }
@@ -939,8 +994,23 @@ static void pump_transfers(unsigned long data)
 
         message->state = RUNNING_STATE;
 
-        /* Try to map dma buffer and do a dma transfer if successful */
-        if ((drv_data->dma_mapped = map_dma_buffers(drv_data))) {
+        /* Try to map dma buffer and do a dma transfer if successful, but
+         * only if the length is non-zero and less than MAX_DMA_LEN.
+         *
+         * Zero-length non-descriptor DMA is illegal on PXA2xx; force use
+         * of PIO instead.  Care is needed above because the transfer may
+         * have have been passed with buffers that are already dma mapped.
+         * A zero-length transfer in PIO mode will not try to write/read
+         * to/from the buffers
+         *
+         * REVISIT large transfers are exactly where we most want to be
+         * using DMA.  If this happens much, split those transfers into
+         * multiple DMA segments rather than forcing PIO.
+         */
+        drv_data->dma_mapped = 0;
+        if (drv_data->len > 0 && drv_data->len <= MAX_DMA_LEN)
+                drv_data->dma_mapped = map_dma_buffers(drv_data);
+        if (drv_data->dma_mapped) {
 
                 /* Ensure we have the correct interrupt handler */
                 drv_data->transfer_handler = dma_transfer;
@@ -1105,6 +1175,8 @@ static int setup(struct spi_device *spi)
         struct driver_data *drv_data = spi_master_get_devdata(spi->master);
         struct ssp_device *ssp = drv_data->ssp;
         unsigned int clk_div;
+        uint tx_thres = TX_THRESH_DFLT;
+        uint rx_thres = RX_THRESH_DFLT;
 
         if (!spi->bits_per_word)
                 spi->bits_per_word = 8;
@@ -1143,8 +1215,7 @@ static int setup(struct spi_device *spi)
 
                 chip->cs_control = null_cs_control;
                 chip->enable_dma = 0;
-                chip->timeout = 1000;
-                chip->threshold = SSCR1_RxTresh(1) | SSCR1_TxTresh(1);
+                chip->timeout = TIMOUT_DFLT;
                 chip->dma_burst_size = drv_data->master_info->enable_dma ?
                                         DCMD_BURST8 : 0;
         }
@@ -1158,22 +1229,21 @@ static int setup(struct spi_device *spi)
         if (chip_info) {
                 if (chip_info->cs_control)
                         chip->cs_control = chip_info->cs_control;
-
-                chip->timeout = chip_info->timeout;
-
-                chip->threshold = (SSCR1_RxTresh(chip_info->rx_threshold) &
-                                                                SSCR1_RFT) |
-                                (SSCR1_TxTresh(chip_info->tx_threshold) &
-                                                                SSCR1_TFT);
-
-                chip->enable_dma = chip_info->dma_burst_size != 0
-                                        && drv_data->master_info->enable_dma;
+                if (chip_info->timeout)
+                        chip->timeout = chip_info->timeout;
+                if (chip_info->tx_threshold)
+                        tx_thres = chip_info->tx_threshold;
+                if (chip_info->rx_threshold)
+                        rx_thres = chip_info->rx_threshold;
+                chip->enable_dma = drv_data->master_info->enable_dma;
                 chip->dma_threshold = 0;
-
                 if (chip_info->enable_loopback)
                         chip->cr1 = SSCR1_LBM;
         }
 
+        chip->threshold = (SSCR1_RxTresh(rx_thres) & SSCR1_RFT) |
+                        (SSCR1_TxTresh(tx_thres) & SSCR1_TFT);
+
         /* set dma burst and threshold outside of chip_info path so that if
          * chip_info goes away after setting chip->enable_dma, the
          * burst and threshold can still respond to changes in bits_per_word */
@@ -1202,17 +1272,19 @@ static int setup(struct spi_device *spi)
 
         /* NOTE:  PXA25x_SSP _could_ use external clocking ... */
         if (drv_data->ssp_type != PXA25x_SSP)
-                dev_dbg(&spi->dev, "%d bits/word, %ld Hz, mode %d\n",
+                dev_dbg(&spi->dev, "%d bits/word, %ld Hz, mode %d, %s\n",
                                 spi->bits_per_word,
                                 clk_get_rate(ssp->clk)
                                         / (1 + ((chip->cr0 & SSCR0_SCR) >> 8)),
-                                spi->mode & 0x3);
+                                spi->mode & 0x3,
+                                chip->enable_dma ? "DMA" : "PIO");
         else
-                dev_dbg(&spi->dev, "%d bits/word, %ld Hz, mode %d\n",
+                dev_dbg(&spi->dev, "%d bits/word, %ld Hz, mode %d, %s\n",
                                 spi->bits_per_word,
-                                clk_get_rate(ssp->clk)
+                                clk_get_rate(ssp->clk) / 2
                                         / (1 + ((chip->cr0 & SSCR0_SCR) >> 8)),
-                                spi->mode & 0x3);
+                                spi->mode & 0x3,
+                                chip->enable_dma ? "DMA" : "PIO");
 
         if (spi->bits_per_word <= 8) {
                 chip->n_bytes = 1;
@@ -1341,9 +1413,9 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
         struct device *dev = &pdev->dev;
         struct pxa2xx_spi_master *platform_info;
         struct spi_master *master;
-        struct driver_data *drv_data = NULL;
+        struct driver_data *drv_data;
         struct ssp_device *ssp;
-        int status = 0;
+        int status;
 
         platform_info = dev->platform_data;
 
@@ -1356,7 +1428,7 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
         /* Allocate master with space for drv_data and null dma buffer */
         master = spi_alloc_master(dev, sizeof(struct driver_data) + 16);
         if (!master) {
-                dev_err(&pdev->dev, "can not alloc spi_master\n");
+                dev_err(&pdev->dev, "cannot alloc spi_master\n");
                 ssp_free(ssp);
                 return -ENOMEM;
         }
@@ -1392,7 +1464,7 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
 
         status = request_irq(ssp->irq, ssp_int, 0, dev->bus_id, drv_data);
         if (status < 0) {
-                dev_err(&pdev->dev, "can not get IRQ\n");
+                dev_err(&pdev->dev, "cannot get IRQ %d\n", ssp->irq);
                 goto out_error_master_alloc;
         }
 
@@ -1432,7 +1504,9 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
 
         /* Load default SSP configuration */
         write_SSCR0(0, drv_data->ioaddr);
-        write_SSCR1(SSCR1_RxTresh(4) | SSCR1_TxTresh(12), drv_data->ioaddr);
+        write_SSCR1(SSCR1_RxTresh(RX_THRESH_DFLT) |
+                                SSCR1_TxTresh(TX_THRESH_DFLT),
+                                drv_data->ioaddr);
         write_SSCR0(SSCR0_SerClkDiv(2)
                         | SSCR0_Motorola
                         | SSCR0_DataSize(8),