7 files changed, 86 insertions, 99 deletions

diff --git a/drivers/spi/mpc52xx_psc_spi.c b/drivers/spi/mpc52xx_psc_spi.c
index cdb3d3191719..0debe11b67b4 100644
--- a/drivers/spi/mpc52xx_psc_spi.c
+++ b/drivers/spi/mpc52xx_psc_spi.c
@@ -15,13 +15,7 @@
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/interrupt.h>
-
-#if defined(CONFIG_PPC_MERGE)
 #include <linux/of_platform.h>
-#else
-#include <linux/platform_device.h>
-#endif
-
 #include <linux/workqueue.h>
 #include <linux/completion.h>
 #include <linux/io.h>
@@ -471,53 +465,6 @@ static int __exit mpc52xx_psc_spi_do_remove(struct device *dev)
         return 0;
 }
 
-#if !defined(CONFIG_PPC_MERGE)
-static int __init mpc52xx_psc_spi_probe(struct platform_device *dev)
-{
-        switch(dev->id) {
-        case 1:
-        case 2:
-        case 3:
-        case 6:
-                return mpc52xx_psc_spi_do_probe(&dev->dev,
-                        MPC52xx_PA(MPC52xx_PSCx_OFFSET(dev->id)),
-                        MPC52xx_PSC_SIZE, platform_get_irq(dev, 0), dev->id);
-        default:
-                return -EINVAL;
-        }
-}
-
-static int __exit mpc52xx_psc_spi_remove(struct platform_device *dev)
-{
-        return mpc52xx_psc_spi_do_remove(&dev->dev);
-}
-
-/* work with hotplug and coldplug */
-MODULE_ALIAS("platform:mpc52xx-psc-spi");
-
-static struct platform_driver mpc52xx_psc_spi_platform_driver = {
-        .remove = __exit_p(mpc52xx_psc_spi_remove),
-        .driver = {
-                .name = "mpc52xx-psc-spi",
-                .owner = THIS_MODULE,
-        },
-};
-
-static int __init mpc52xx_psc_spi_init(void)
-{
-        return platform_driver_probe(&mpc52xx_psc_spi_platform_driver,
-                        mpc52xx_psc_spi_probe);
-}
-module_init(mpc52xx_psc_spi_init);
-
-static void __exit mpc52xx_psc_spi_exit(void)
-{
-        platform_driver_unregister(&mpc52xx_psc_spi_platform_driver);
-}
-module_exit(mpc52xx_psc_spi_exit);
-
-#else   /* defined(CONFIG_PPC_MERGE) */
-
 static int __init mpc52xx_psc_spi_of_probe(struct of_device *op,
         const struct of_device_id *match)
 {
@@ -586,8 +533,6 @@ static void __exit mpc52xx_psc_spi_exit(void)
 }
 module_exit(mpc52xx_psc_spi_exit);
 
-#endif  /* defined(CONFIG_PPC_MERGE) */
-
 MODULE_AUTHOR("Dragos Carp");
 MODULE_DESCRIPTION("MPC52xx PSC SPI Driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/spi/omap2_mcspi.c b/drivers/spi/omap2_mcspi.c
index 9d2186fd74aa..454a2712e629 100644
--- a/drivers/spi/omap2_mcspi.c
+++ b/drivers/spi/omap2_mcspi.c
@@ -119,12 +119,14 @@ struct omap2_mcspi {
         struct clk              *fck;
         /* Virtual base address of the controller */
         void __iomem            *base;
+        unsigned long           phys;
         /* SPI1 has 4 channels, while SPI2 has 2 */
         struct omap2_mcspi_dma  *dma_channels;
 };
 
 struct omap2_mcspi_cs {
         void __iomem            *base;
+        unsigned long           phys;
         int                     word_len;
 };
 
@@ -233,7 +235,7 @@ omap2_mcspi_txrx_dma(struct spi_device *spi, struct spi_transfer *xfer)
         c = count;
         word_len = cs->word_len;
 
-        base = (unsigned long) io_v2p(cs->base);
+        base = cs->phys;
         tx_reg = base + OMAP2_MCSPI_TX0;
         rx_reg = base + OMAP2_MCSPI_RX0;
         rx = xfer->rx_buf;
@@ -633,6 +635,7 @@ static int omap2_mcspi_setup(struct spi_device *spi)
                 if (!cs)
                         return -ENOMEM;
                 cs->base = mcspi->base + spi->chip_select * 0x14;
+                cs->phys = mcspi->phys + spi->chip_select * 0x14;
                 spi->controller_state = cs;
         }
 
@@ -1005,7 +1008,13 @@ static int __init omap2_mcspi_probe(struct platform_device *pdev)
                 goto err1;
         }
 
-        mcspi->base = (void __iomem *) io_p2v(r->start);
+        mcspi->phys = r->start;
+        mcspi->base = ioremap(r->start, r->end - r->start + 1);
+        if (!mcspi->base) {
+                dev_dbg(&pdev->dev, "can't ioremap MCSPI\n");
+                status = -ENOMEM;
+                goto err1aa;
+        }
 
         INIT_WORK(&mcspi->work, omap2_mcspi_work);
 
@@ -1055,6 +1064,8 @@ err3:
 err2:
         clk_put(mcspi->ick);
 err1a:
+        iounmap(mcspi->base);
+err1aa:
         release_mem_region(r->start, (r->end - r->start) + 1);
 err1:
         spi_master_put(master);
@@ -1067,6 +1078,7 @@ static int __exit omap2_mcspi_remove(struct platform_device *pdev)
         struct omap2_mcspi      *mcspi;
         struct omap2_mcspi_dma  *dma_channels;
         struct resource         *r;
+        void __iomem *base;
 
         master = dev_get_drvdata(&pdev->dev);
         mcspi = spi_master_get_devdata(master);
@@ -1078,7 +1090,9 @@ static int __exit omap2_mcspi_remove(struct platform_device *pdev)
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         release_mem_region(r->start, (r->end - r->start) + 1);
 
+        base = mcspi->base;
         spi_unregister_master(master);
+        iounmap(base);
         kfree(dma_channels);
 
         return 0;
diff --git a/drivers/spi/omap_uwire.c b/drivers/spi/omap_uwire.c
index 5515eb97d7c5..bab6ff061e91 100644
--- a/drivers/spi/omap_uwire.c
+++ b/drivers/spi/omap_uwire.c
@@ -59,7 +59,6 @@
  * and irqs should show there too...
  */
 #define UWIRE_BASE_PHYS         0xFFFB3000
-#define UWIRE_BASE              ((void *__iomem)IO_ADDRESS(UWIRE_BASE_PHYS))
 
 /* uWire Registers: */
 #define UWIRE_IO_SIZE 0x20
@@ -103,16 +102,21 @@ struct uwire_state {
 };
 
 /* REVISIT compile time constant for idx_shift? */
+/*
+ * Or, put it in a structure which is used throughout the driver;
+ * that avoids having to issue two loads for each bit of static data.
+ */
 static unsigned int uwire_idx_shift;
+static void __iomem *uwire_base;
 
 static inline void uwire_write_reg(int idx, u16 val)
 {
-        __raw_writew(val, UWIRE_BASE + (idx << uwire_idx_shift));
+        __raw_writew(val, uwire_base + (idx << uwire_idx_shift));
 }
 
 static inline u16 uwire_read_reg(int idx)
 {
-        return __raw_readw(UWIRE_BASE + (idx << uwire_idx_shift));
+        return __raw_readw(uwire_base + (idx << uwire_idx_shift));
 }
 
 static inline void omap_uwire_configure_mode(u8 cs, unsigned long flags)
@@ -492,6 +496,14 @@ static int __init uwire_probe(struct platform_device *pdev)
                 return -ENODEV;
 
         uwire = spi_master_get_devdata(master);
+
+        uwire_base = ioremap(UWIRE_BASE_PHYS, UWIRE_IO_SIZE);
+        if (!uwire_base) {
+                dev_dbg(&pdev->dev, "can't ioremap UWIRE\n");
+                spi_master_put(master);
+                return -ENOMEM;
+        }
+
         dev_set_drvdata(&pdev->dev, uwire);
 
         uwire->ck = clk_get(&pdev->dev, "armxor_ck");
@@ -520,8 +532,10 @@ static int __init uwire_probe(struct platform_device *pdev)
         uwire->bitbang.txrx_bufs = uwire_txrx;
 
         status = spi_bitbang_start(&uwire->bitbang);
-        if (status < 0)
+        if (status < 0) {
                 uwire_off(uwire);
+                iounmap(uwire_base);
+        }
         return status;
 }
 
@@ -534,6 +548,7 @@ static int __exit uwire_remove(struct platform_device *pdev)
 
         status = spi_bitbang_stop(&uwire->bitbang);
         uwire_off(uwire);
+        iounmap(uwire_base);
         return status;
 }
 
diff --git a/drivers/spi/orion_spi.c b/drivers/spi/orion_spi.c
index b872bfaf4bd2..014becb7d530 100644
--- a/drivers/spi/orion_spi.c
+++ b/drivers/spi/orion_spi.c
@@ -364,6 +364,11 @@ static int orion_spi_setup(struct spi_device *spi)
                 return -EINVAL;
         }
 
+        /* Fix ac timing if required.   */
+        if (orion_spi->spi_info->enable_clock_fix)
+                orion_spi_setbits(orion_spi, ORION_SPI_IF_CONFIG_REG,
+                                  (1 << 14));
+
         if (spi->bits_per_word == 0)
                 spi->bits_per_word = 8;
 
diff --git a/drivers/spi/pxa2xx_spi.c b/drivers/spi/pxa2xx_spi.c
index d47d3636227f..dae87b1a4c6e 100644
--- a/drivers/spi/pxa2xx_spi.c
+++ b/drivers/spi/pxa2xx_spi.c
@@ -47,6 +47,10 @@ MODULE_ALIAS("platform:pxa2xx-spi");
 
 #define MAX_BUSES 3
 
+#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)
@@ -1171,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;
@@ -1209,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;
         }
@@ -1224,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 */
@@ -1268,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;
@@ -1407,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;
 
@@ -1422,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;
         }
@@ -1458,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;
         }
 
@@ -1498,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),
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 75e86865234c..3734dc9708e1 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -660,7 +660,7 @@ int spi_write_then_read(struct spi_device *spi,
 
         int                     status;
         struct spi_message      message;
-        struct spi_transfer     x[2];
+        struct spi_transfer     x;
         u8                      *local_buf;
 
         /* Use preallocated DMA-safe buffer.  We can't avoid copying here,
@@ -671,15 +671,9 @@ int spi_write_then_read(struct spi_device *spi,
                 return -EINVAL;
 
         spi_message_init(&message);
-        memset(x, 0, sizeof x);
-        if (n_tx) {
-                x[0].len = n_tx;
-                spi_message_add_tail(&x[0], &message);
-        }
-        if (n_rx) {
-                x[1].len = n_rx;
-                spi_message_add_tail(&x[1], &message);
-        }
+        memset(&x, 0, sizeof x);
+        x.len = n_tx + n_rx;
+        spi_message_add_tail(&x, &message);
 
         /* ... unless someone else is using the pre-allocated buffer */
         if (!mutex_trylock(&lock)) {
@@ -690,15 +684,15 @@ int spi_write_then_read(struct spi_device *spi,
                 local_buf = buf;
 
         memcpy(local_buf, txbuf, n_tx);
-        x[0].tx_buf = local_buf;
-        x[1].rx_buf = local_buf + n_tx;
+        x.tx_buf = local_buf;
+        x.rx_buf = local_buf;
 
         /* do the i/o */
         status = spi_sync(spi, &message);
         if (status == 0)
-                memcpy(rxbuf, x[1].rx_buf, n_rx);
+                memcpy(rxbuf, x.rx_buf + n_tx, n_rx);
 
-        if (x[0].tx_buf == buf)
+        if (x.tx_buf == buf)
                 mutex_unlock(&lock);
         else
                 kfree(local_buf);
@@ -744,5 +738,5 @@ err0:
  * driver registration) _could_ be dynamically linked (modular) ... costs
  * include needing to have boardinfo data structures be much more public.
  */
-subsys_initcall(spi_init);
+postcore_initcall(spi_init);
 
diff --git a/drivers/spi/spi_s3c24xx.c b/drivers/spi/spi_s3c24xx.c
index 3eb414b84a9d..c252cbac00f1 100644
--- a/drivers/spi/spi_s3c24xx.c
+++ b/drivers/spi/spi_s3c24xx.c
@@ -247,6 +247,9 @@ static void s3c24xx_spi_initialsetup(struct s3c24xx_spi *hw)
         writeb(0xff, hw->regs + S3C2410_SPPRE);
         writeb(SPPIN_DEFAULT, hw->regs + S3C2410_SPPIN);
         writeb(SPCON_DEFAULT, hw->regs + S3C2410_SPCON);
+
+        if (hw->pdata && hw->pdata->gpio_setup)
+                hw->pdata->gpio_setup(hw->pdata, 1);
 }
 
 static int __init s3c24xx_spi_probe(struct platform_device *pdev)
@@ -412,6 +415,9 @@ static int s3c24xx_spi_suspend(struct platform_device *pdev, pm_message_t msg)
 {
         struct s3c24xx_spi *hw = platform_get_drvdata(pdev);
 
+        if (hw->pdata && hw->pdata->gpio_setup)
+                hw->pdata->gpio_setup(hw->pdata, 0);
+
         clk_disable(hw->clk);
         return 0;
 }