33 files changed, 231 insertions, 494 deletions

diff --git a/drivers/spi/spi-altera.c b/drivers/spi/spi-altera.c
index 4813a63ce6fb..881c1967741d 100644
--- a/drivers/spi/spi-altera.c
+++ b/drivers/spi/spi-altera.c
@@ -320,18 +320,7 @@ static struct platform_driver altera_spi_driver = {
                 .of_match_table = altera_spi_match,
         },
 };
-
-static int __init altera_spi_init(void)
-{
-        return platform_driver_register(&altera_spi_driver);
-}
-module_init(altera_spi_init);
-
-static void __exit altera_spi_exit(void)
-{
-        platform_driver_unregister(&altera_spi_driver);
-}
-module_exit(altera_spi_exit);
+module_platform_driver(altera_spi_driver);
 
 MODULE_DESCRIPTION("Altera SPI driver");
 MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>");
diff --git a/drivers/spi/spi-ath79.c b/drivers/spi/spi-ath79.c
index 03019bf5a5e9..024b48aed5ca 100644
--- a/drivers/spi/spi-ath79.c
+++ b/drivers/spi/spi-ath79.c
@@ -273,18 +273,7 @@ static struct platform_driver ath79_spi_driver = {
                 .owner  = THIS_MODULE,
         },
 };
-
-static __init int ath79_spi_init(void)
-{
-        return platform_driver_register(&ath79_spi_driver);
-}
-module_init(ath79_spi_init);
-
-static __exit void ath79_spi_exit(void)
-{
-        platform_driver_unregister(&ath79_spi_driver);
-}
-module_exit(ath79_spi_exit);
+module_platform_driver(ath79_spi_driver);
 
 MODULE_DESCRIPTION("SPI controller driver for Atheros AR71XX/AR724X/AR913X");
 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
diff --git a/drivers/spi/spi-atmel.c b/drivers/spi/spi-atmel.c
index d3bff424286f..79665e2e6ec5 100644
--- a/drivers/spi/spi-atmel.c
+++ b/drivers/spi/spi-atmel.c
@@ -1074,18 +1074,7 @@ static struct platform_driver atmel_spi_driver = {
         .resume         = atmel_spi_resume,
         .remove         = __exit_p(atmel_spi_remove),
 };
-
-static int __init atmel_spi_init(void)
-{
-        return platform_driver_probe(&atmel_spi_driver, atmel_spi_probe);
-}
-module_init(atmel_spi_init);
-
-static void __exit atmel_spi_exit(void)
-{
-        platform_driver_unregister(&atmel_spi_driver);
-}
-module_exit(atmel_spi_exit);
+module_platform_driver(atmel_spi_driver);
 
 MODULE_DESCRIPTION("Atmel AT32/AT91 SPI Controller driver");
 MODULE_AUTHOR("Haavard Skinnemoen (Atmel)");
diff --git a/drivers/spi/spi-bfin-sport.c b/drivers/spi/spi-bfin-sport.c
index e557ff617b11..248a2cc671a9 100644
--- a/drivers/spi/spi-bfin-sport.c
+++ b/drivers/spi/spi-bfin-sport.c
@@ -938,15 +938,4 @@ static struct platform_driver bfin_sport_spi_driver = {
         .suspend = bfin_sport_spi_suspend,
         .resume  = bfin_sport_spi_resume,
 };
-
-static int __init bfin_sport_spi_init(void)
-{
-        return platform_driver_register(&bfin_sport_spi_driver);
-}
-module_init(bfin_sport_spi_init);
-
-static void __exit bfin_sport_spi_exit(void)
-{
-        platform_driver_unregister(&bfin_sport_spi_driver);
-}
-module_exit(bfin_sport_spi_exit);
+module_platform_driver(bfin_sport_spi_driver);
diff --git a/drivers/spi/spi-bfin5xx.c b/drivers/spi/spi-bfin5xx.c
index b8d25f2b7038..3b83ff8b1e2b 100644
--- a/drivers/spi/spi-bfin5xx.c
+++ b/drivers/spi/spi-bfin5xx.c
@@ -1098,7 +1098,7 @@ static int bfin_spi_setup(struct spi_device *spi)
 
         if (chip->pio_interrupt && !drv_data->irq_requested) {
                 ret = request_irq(drv_data->spi_irq, bfin_spi_pio_irq_handler,
-                        IRQF_DISABLED, "BFIN_SPI", drv_data);
+                        0, "BFIN_SPI", drv_data);
                 if (ret) {
                         dev_err(&spi->dev, "Unable to register spi IRQ\n");
                         goto error;
diff --git a/drivers/spi/spi-coldfire-qspi.c b/drivers/spi/spi-coldfire-qspi.c
index ae2cd1c1fda8..6eee64a5d240 100644
--- a/drivers/spi/spi-coldfire-qspi.c
+++ b/drivers/spi/spi-coldfire-qspi.c
@@ -487,7 +487,7 @@ static int __devinit mcfqspi_probe(struct platform_device *pdev)
                 goto fail2;
         }
 
-        status = request_irq(mcfqspi->irq, mcfqspi_irq_handler, IRQF_DISABLED,
+        status = request_irq(mcfqspi->irq, mcfqspi_irq_handler, 0,
                              pdev->name, mcfqspi);
         if (status) {
                 dev_dbg(&pdev->dev, "request_irq failed\n");
@@ -621,20 +621,10 @@ static struct platform_driver mcfqspi_driver = {
         .driver.name    = DRIVER_NAME,
         .driver.owner   = THIS_MODULE,
         .driver.pm      = MCFQSPI_DEV_PM_OPS,
+        .probe          = mcfqspi_probe,
         .remove         = __devexit_p(mcfqspi_remove),
 };
-
-static int __init mcfqspi_init(void)
-{
-        return platform_driver_probe(&mcfqspi_driver, mcfqspi_probe);
-}
-module_init(mcfqspi_init);
-
-static void __exit mcfqspi_exit(void)
-{
-        platform_driver_unregister(&mcfqspi_driver);
-}
-module_exit(mcfqspi_exit);
+module_platform_driver(mcfqspi_driver);
 
 MODULE_AUTHOR("Steven King <sfking@fdwdc.com>");
 MODULE_DESCRIPTION("Coldfire QSPI Controller Driver");
diff --git a/drivers/spi/spi-davinci.c b/drivers/spi/spi-davinci.c
index 1f0ed8005c91..31bfba805cf4 100644
--- a/drivers/spi/spi-davinci.c
+++ b/drivers/spi/spi-davinci.c
@@ -799,7 +799,7 @@ rx_dma_failed:
  * It will invoke spi_bitbang_start to create work queue so that client driver
  * can register transfer method to work queue.
  */
-static int davinci_spi_probe(struct platform_device *pdev)
+static int __devinit davinci_spi_probe(struct platform_device *pdev)
 {
         struct spi_master *master;
         struct davinci_spi *dspi;
@@ -984,7 +984,7 @@ err:
  * It will also call spi_bitbang_stop to destroy the work queue which was
  * created by spi_bitbang_start.
  */
-static int __exit davinci_spi_remove(struct platform_device *pdev)
+static int __devexit davinci_spi_remove(struct platform_device *pdev)
 {
         struct davinci_spi *dspi;
         struct spi_master *master;
@@ -1011,20 +1011,10 @@ static struct platform_driver davinci_spi_driver = {
                 .name = "spi_davinci",
                 .owner = THIS_MODULE,
         },
-        .remove = __exit_p(davinci_spi_remove),
+        .probe = davinci_spi_probe,
+        .remove = __devexit_p(davinci_spi_remove),
 };
-
-static int __init davinci_spi_init(void)
-{
-        return platform_driver_probe(&davinci_spi_driver, davinci_spi_probe);
-}
-module_init(davinci_spi_init);
-
-static void __exit davinci_spi_exit(void)
-{
-        platform_driver_unregister(&davinci_spi_driver);
-}
-module_exit(davinci_spi_exit);
+module_platform_driver(davinci_spi_driver);
 
 MODULE_DESCRIPTION("TI DaVinci SPI Master Controller Driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi-dw-mid.c b/drivers/spi/spi-dw-mid.c
index 130e55537db6..e743a45ee92c 100644
--- a/drivers/spi/spi-dw-mid.c
+++ b/drivers/spi/spi-dw-mid.c
@@ -116,13 +116,13 @@ static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change)
         /* 1. setup DMA related registers */
         if (cs_change) {
                 spi_enable_chip(dws, 0);
-                dw_writew(dws, dmardlr, 0xf);
-                dw_writew(dws, dmatdlr, 0x10);
+                dw_writew(dws, DW_SPI_DMARDLR, 0xf);
+                dw_writew(dws, DW_SPI_DMATDLR, 0x10);
                 if (dws->tx_dma)
                         dma_ctrl |= 0x2;
                 if (dws->rx_dma)
                         dma_ctrl |= 0x1;
-                dw_writew(dws, dmacr, dma_ctrl);
+                dw_writew(dws, DW_SPI_DMACR, dma_ctrl);
                 spi_enable_chip(dws, 1);
         }
 
@@ -200,7 +200,8 @@ static struct dw_spi_dma_ops mid_dma_ops = {
 
 int dw_spi_mid_init(struct dw_spi *dws)
 {
-        u32 *clk_reg, clk_cdiv;
+        void __iomem *clk_reg;
+        u32 clk_cdiv;
 
         clk_reg = ioremap_nocache(MRST_CLK_SPI0_REG, 16);
         if (!clk_reg)
diff --git a/drivers/spi/spi-dw-mmio.c b/drivers/spi/spi-dw-mmio.c
index 34eb66501dbf..fac399c3022c 100644
--- a/drivers/spi/spi-dw-mmio.c
+++ b/drivers/spi/spi-dw-mmio.c
@@ -127,24 +127,14 @@ static int __devexit dw_spi_mmio_remove(struct platform_device *pdev)
 }
 
 static struct platform_driver dw_spi_mmio_driver = {
+        .probe          = dw_spi_mmio_probe,
         .remove         = __devexit_p(dw_spi_mmio_remove),
         .driver         = {
                 .name   = DRIVER_NAME,
                 .owner  = THIS_MODULE,
         },
 };
-
-static int __init dw_spi_mmio_init(void)
-{
-        return platform_driver_probe(&dw_spi_mmio_driver, dw_spi_mmio_probe);
-}
-module_init(dw_spi_mmio_init);
-
-static void __exit dw_spi_mmio_exit(void)
-{
-        platform_driver_unregister(&dw_spi_mmio_driver);
-}
-module_exit(dw_spi_mmio_exit);
+module_platform_driver(dw_spi_mmio_driver);
 
 MODULE_AUTHOR("Jean-Hugues Deschenes <jean-hugues.deschenes@octasic.com>");
 MODULE_DESCRIPTION("Memory-mapped I/O interface driver for DW SPI Core");
diff --git a/drivers/spi/spi-dw.c b/drivers/spi/spi-dw.c
index 857cd30b44bb..296d94f4cf72 100644
--- a/drivers/spi/spi-dw.c
+++ b/drivers/spi/spi-dw.c
@@ -88,35 +88,35 @@ static ssize_t  spi_show_regs(struct file *file, char __user *user_buf,
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
                         "=================================\n");
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "CTRL0: \t\t0x%08x\n", dw_readl(dws, ctrl0));
+                        "CTRL0: \t\t0x%08x\n", dw_readl(dws, DW_SPI_CTRL0));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "CTRL1: \t\t0x%08x\n", dw_readl(dws, ctrl1));
+                        "CTRL1: \t\t0x%08x\n", dw_readl(dws, DW_SPI_CTRL1));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "SSIENR: \t0x%08x\n", dw_readl(dws, ssienr));
+                        "SSIENR: \t0x%08x\n", dw_readl(dws, DW_SPI_SSIENR));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "SER: \t\t0x%08x\n", dw_readl(dws, ser));
+                        "SER: \t\t0x%08x\n", dw_readl(dws, DW_SPI_SER));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "BAUDR: \t\t0x%08x\n", dw_readl(dws, baudr));
+                        "BAUDR: \t\t0x%08x\n", dw_readl(dws, DW_SPI_BAUDR));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "TXFTLR: \t0x%08x\n", dw_readl(dws, txfltr));
+                        "TXFTLR: \t0x%08x\n", dw_readl(dws, DW_SPI_TXFLTR));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "RXFTLR: \t0x%08x\n", dw_readl(dws, rxfltr));
+                        "RXFTLR: \t0x%08x\n", dw_readl(dws, DW_SPI_RXFLTR));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "TXFLR: \t\t0x%08x\n", dw_readl(dws, txflr));
+                        "TXFLR: \t\t0x%08x\n", dw_readl(dws, DW_SPI_TXFLR));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "RXFLR: \t\t0x%08x\n", dw_readl(dws, rxflr));
+                        "RXFLR: \t\t0x%08x\n", dw_readl(dws, DW_SPI_RXFLR));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "SR: \t\t0x%08x\n", dw_readl(dws, sr));
+                        "SR: \t\t0x%08x\n", dw_readl(dws, DW_SPI_SR));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "IMR: \t\t0x%08x\n", dw_readl(dws, imr));
+                        "IMR: \t\t0x%08x\n", dw_readl(dws, DW_SPI_IMR));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "ISR: \t\t0x%08x\n", dw_readl(dws, isr));
+                        "ISR: \t\t0x%08x\n", dw_readl(dws, DW_SPI_ISR));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "DMACR: \t\t0x%08x\n", dw_readl(dws, dmacr));
+                        "DMACR: \t\t0x%08x\n", dw_readl(dws, DW_SPI_DMACR));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "DMATDLR: \t0x%08x\n", dw_readl(dws, dmatdlr));
+                        "DMATDLR: \t0x%08x\n", dw_readl(dws, DW_SPI_DMATDLR));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "DMARDLR: \t0x%08x\n", dw_readl(dws, dmardlr));
+                        "DMARDLR: \t0x%08x\n", dw_readl(dws, DW_SPI_DMARDLR));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
                         "=================================\n");
 
@@ -166,7 +166,7 @@ static inline u32 tx_max(struct dw_spi *dws)
         u32 tx_left, tx_room, rxtx_gap;
 
         tx_left = (dws->tx_end - dws->tx) / dws->n_bytes;
-        tx_room = dws->fifo_len - dw_readw(dws, txflr);
+        tx_room = dws->fifo_len - dw_readw(dws, DW_SPI_TXFLR);
 
         /*
          * Another concern is about the tx/rx mismatch, we
@@ -187,7 +187,7 @@ static inline u32 rx_max(struct dw_spi *dws)
 {
         u32 rx_left = (dws->rx_end - dws->rx) / dws->n_bytes;
 
-        return min(rx_left, (u32)dw_readw(dws, rxflr));
+        return min(rx_left, (u32)dw_readw(dws, DW_SPI_RXFLR));
 }
 
 static void dw_writer(struct dw_spi *dws)
@@ -203,7 +203,7 @@ static void dw_writer(struct dw_spi *dws)
                         else
                                 txw = *(u16 *)(dws->tx);
                 }
-                dw_writew(dws, dr, txw);
+                dw_writew(dws, DW_SPI_DR, txw);
                 dws->tx += dws->n_bytes;
         }
 }
@@ -214,7 +214,7 @@ static void dw_reader(struct dw_spi *dws)
         u16 rxw;
 
         while (max--) {
-                rxw = dw_readw(dws, dr);
+                rxw = dw_readw(dws, DW_SPI_DR);
                 /* Care rx only if the transfer's original "rx" is not null */
                 if (dws->rx_end - dws->len) {
                         if (dws->n_bytes == 1)
@@ -322,13 +322,13 @@ EXPORT_SYMBOL_GPL(dw_spi_xfer_done);
 
 static irqreturn_t interrupt_transfer(struct dw_spi *dws)
 {
-        u16 irq_status = dw_readw(dws, isr);
+        u16 irq_status = dw_readw(dws, DW_SPI_ISR);
 
         /* Error handling */
         if (irq_status & (SPI_INT_TXOI | SPI_INT_RXOI | SPI_INT_RXUI)) {
-                dw_readw(dws, txoicr);
-                dw_readw(dws, rxoicr);
-                dw_readw(dws, rxuicr);
+                dw_readw(dws, DW_SPI_TXOICR);
+                dw_readw(dws, DW_SPI_RXOICR);
+                dw_readw(dws, DW_SPI_RXUICR);
                 int_error_stop(dws, "interrupt_transfer: fifo overrun/underrun");
                 return IRQ_HANDLED;
         }
@@ -352,7 +352,7 @@ static irqreturn_t interrupt_transfer(struct dw_spi *dws)
 static irqreturn_t dw_spi_irq(int irq, void *dev_id)
 {
         struct dw_spi *dws = dev_id;
-        u16 irq_status = dw_readw(dws, isr) & 0x3f;
+        u16 irq_status = dw_readw(dws, DW_SPI_ISR) & 0x3f;
 
         if (!irq_status)
                 return IRQ_NONE;
@@ -520,11 +520,11 @@ static void pump_transfers(unsigned long data)
          *      2. clk_div is changed
          *      3. control value changes
          */
-        if (dw_readw(dws, ctrl0) != cr0 || cs_change || clk_div || imask) {
+        if (dw_readw(dws, DW_SPI_CTRL0) != cr0 || cs_change || clk_div || imask) {
                 spi_enable_chip(dws, 0);
 
-                if (dw_readw(dws, ctrl0) != cr0)
-                        dw_writew(dws, ctrl0, cr0);
+                if (dw_readw(dws, DW_SPI_CTRL0) != cr0)
+                        dw_writew(dws, DW_SPI_CTRL0, cr0);
 
                 spi_set_clk(dws, clk_div ? clk_div : chip->clk_div);
                 spi_chip_sel(dws, spi->chip_select);
@@ -534,7 +534,7 @@ static void pump_transfers(unsigned long data)
                 if (imask)
                         spi_umask_intr(dws, imask);
                 if (txint_level)
-                        dw_writew(dws, txfltr, txint_level);
+                        dw_writew(dws, DW_SPI_TXFLTR, txint_level);
 
                 spi_enable_chip(dws, 1);
                 if (cs_change)
@@ -790,13 +790,13 @@ static void spi_hw_init(struct dw_spi *dws)
         if (!dws->fifo_len) {
                 u32 fifo;
                 for (fifo = 2; fifo <= 257; fifo++) {
-                        dw_writew(dws, txfltr, fifo);
-                        if (fifo != dw_readw(dws, txfltr))
+                        dw_writew(dws, DW_SPI_TXFLTR, fifo);
+                        if (fifo != dw_readw(dws, DW_SPI_TXFLTR))
                                 break;
                 }
 
                 dws->fifo_len = (fifo == 257) ? 0 : fifo;
-                dw_writew(dws, txfltr, 0);
+                dw_writew(dws, DW_SPI_TXFLTR, 0);
         }
 }
 
diff --git a/drivers/spi/spi-dw.h b/drivers/spi/spi-dw.h
index 8b7b07bf6c3f..9c57c078031e 100644
--- a/drivers/spi/spi-dw.h
+++ b/drivers/spi/spi-dw.h
@@ -4,6 +4,33 @@
 #include <linux/io.h>
 #include <linux/scatterlist.h>
 
+/* Register offsets */
+#define DW_SPI_CTRL0                    0x00
+#define DW_SPI_CTRL1                    0x04
+#define DW_SPI_SSIENR                   0x08
+#define DW_SPI_MWCR                     0x0c
+#define DW_SPI_SER                      0x10
+#define DW_SPI_BAUDR                    0x14
+#define DW_SPI_TXFLTR                   0x18
+#define DW_SPI_RXFLTR                   0x1c
+#define DW_SPI_TXFLR                    0x20
+#define DW_SPI_RXFLR                    0x24
+#define DW_SPI_SR                       0x28
+#define DW_SPI_IMR                      0x2c
+#define DW_SPI_ISR                      0x30
+#define DW_SPI_RISR                     0x34
+#define DW_SPI_TXOICR                   0x38
+#define DW_SPI_RXOICR                   0x3c
+#define DW_SPI_RXUICR                   0x40
+#define DW_SPI_MSTICR                   0x44
+#define DW_SPI_ICR                      0x48
+#define DW_SPI_DMACR                    0x4c
+#define DW_SPI_DMATDLR                  0x50
+#define DW_SPI_DMARDLR                  0x54
+#define DW_SPI_IDR                      0x58
+#define DW_SPI_VERSION                  0x5c
+#define DW_SPI_DR                       0x60
+
 /* Bit fields in CTRLR0 */
 #define SPI_DFS_OFFSET                  0
 
@@ -55,35 +82,6 @@ enum dw_ssi_type {
         SSI_NS_MICROWIRE,
 };
 
-struct dw_spi_reg {
-        u32     ctrl0;
-        u32     ctrl1;
-        u32     ssienr;
-        u32     mwcr;
-        u32     ser;
-        u32     baudr;
-        u32     txfltr;
-        u32     rxfltr;
-        u32     txflr;
-        u32     rxflr;
-        u32     sr;
-        u32     imr;
-        u32     isr;
-        u32     risr;
-        u32     txoicr;
-        u32     rxoicr;
-        u32     rxuicr;
-        u32     msticr;
-        u32     icr;
-        u32     dmacr;
-        u32     dmatdlr;
-        u32     dmardlr;
-        u32     idr;
-        u32     version;
-        u32     dr;             /* Currently oper as 32 bits,
-                                though only low 16 bits matters */
-} __packed;
-
 struct dw_spi;
 struct dw_spi_dma_ops {
         int (*dma_init)(struct dw_spi *dws);
@@ -161,23 +159,34 @@ struct dw_spi {
 #endif
 };
 
-#define dw_readl(dw, name) \
-        __raw_readl(&(((struct dw_spi_reg *)dw->regs)->name))
-#define dw_writel(dw, name, val) \
-        __raw_writel((val), &(((struct dw_spi_reg *)dw->regs)->name))
-#define dw_readw(dw, name) \
-        __raw_readw(&(((struct dw_spi_reg *)dw->regs)->name))
-#define dw_writew(dw, name, val) \
-        __raw_writew((val), &(((struct dw_spi_reg *)dw->regs)->name))
+static inline u32 dw_readl(struct dw_spi *dws, u32 offset)
+{
+        return __raw_readl(dws->regs + offset);
+}
+
+static inline void dw_writel(struct dw_spi *dws, u32 offset, u32 val)
+{
+        __raw_writel(val, dws->regs + offset);
+}
+
+static inline u16 dw_readw(struct dw_spi *dws, u32 offset)
+{
+        return __raw_readw(dws->regs + offset);
+}
+
+static inline void dw_writew(struct dw_spi *dws, u32 offset, u16 val)
+{
+        __raw_writew(val, dws->regs + offset);
+}
 
 static inline void spi_enable_chip(struct dw_spi *dws, int enable)
 {
-        dw_writel(dws, ssienr, (enable ? 1 : 0));
+        dw_writel(dws, DW_SPI_SSIENR, (enable ? 1 : 0));
 }
 
 static inline void spi_set_clk(struct dw_spi *dws, u16 div)
 {
-        dw_writel(dws, baudr, div);
+        dw_writel(dws, DW_SPI_BAUDR, div);
 }
 
 static inline void spi_chip_sel(struct dw_spi *dws, u16 cs)
@@ -188,7 +197,7 @@ static inline void spi_chip_sel(struct dw_spi *dws, u16 cs)
         if (dws->cs_control)
                 dws->cs_control(1);
 
-        dw_writel(dws, ser, 1 << cs);
+        dw_writel(dws, DW_SPI_SER, 1 << cs);
 }
 
 /* Disable IRQ bits */
@@ -196,8 +205,8 @@ static inline void spi_mask_intr(struct dw_spi *dws, u32 mask)
 {
         u32 new_mask;
 
-        new_mask = dw_readl(dws, imr) & ~mask;
-        dw_writel(dws, imr, new_mask);
+        new_mask = dw_readl(dws, DW_SPI_IMR) & ~mask;
+        dw_writel(dws, DW_SPI_IMR, new_mask);
 }
 
 /* Enable IRQ bits */
@@ -205,8 +214,8 @@ static inline void spi_umask_intr(struct dw_spi *dws, u32 mask)
 {
         u32 new_mask;
 
-        new_mask = dw_readl(dws, imr) | mask;
-        dw_writel(dws, imr, new_mask);
+        new_mask = dw_readl(dws, DW_SPI_IMR) | mask;
+        dw_writel(dws, DW_SPI_IMR, new_mask);
 }
 
 /*
diff --git a/drivers/spi/spi-ep93xx.c b/drivers/spi/spi-ep93xx.c
index 1cf645479bfe..0a282e5fcc9c 100644
--- a/drivers/spi/spi-ep93xx.c
+++ b/drivers/spi/spi-ep93xx.c
@@ -24,6 +24,7 @@
 #include <linux/dmaengine.h>
 #include <linux/bitops.h>
 #include <linux/interrupt.h>
+#include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/workqueue.h>
 #include <linux/sched.h>
@@ -1025,7 +1026,7 @@ static void ep93xx_spi_release_dma(struct ep93xx_spi *espi)
                 free_page((unsigned long)espi->zeropage);
 }
 
-static int __init ep93xx_spi_probe(struct platform_device *pdev)
+static int __devinit ep93xx_spi_probe(struct platform_device *pdev)
 {
         struct spi_master *master;
         struct ep93xx_spi_info *info;
@@ -1150,7 +1151,7 @@ fail_release_master:
         return error;
 }
 
-static int __exit ep93xx_spi_remove(struct platform_device *pdev)
+static int __devexit ep93xx_spi_remove(struct platform_device *pdev)
 {
         struct spi_master *master = platform_get_drvdata(pdev);
         struct ep93xx_spi *espi = spi_master_get_devdata(master);
@@ -1196,20 +1197,10 @@ static struct platform_driver ep93xx_spi_driver = {
                 .name   = "ep93xx-spi",
                 .owner  = THIS_MODULE,
         },
-        .remove         = __exit_p(ep93xx_spi_remove),
+        .probe          = ep93xx_spi_probe,
+        .remove         = __devexit_p(ep93xx_spi_remove),
 };
-
-static int __init ep93xx_spi_init(void)
-{
-        return platform_driver_probe(&ep93xx_spi_driver, ep93xx_spi_probe);
-}
-module_init(ep93xx_spi_init);
-
-static void __exit ep93xx_spi_exit(void)
-{
-        platform_driver_unregister(&ep93xx_spi_driver);
-}
-module_exit(ep93xx_spi_exit);
+module_platform_driver(ep93xx_spi_driver);
 
 MODULE_DESCRIPTION("EP93xx SPI Controller driver");
 MODULE_AUTHOR("Mika Westerberg <mika.westerberg@iki.fi>");
diff --git a/drivers/spi/spi-fsl-espi.c b/drivers/spi/spi-fsl-espi.c
index 54e499d5f92c..d770f03705c3 100644
--- a/drivers/spi/spi-fsl-espi.c
+++ b/drivers/spi/spi-fsl-espi.c
@@ -744,18 +744,7 @@ static struct platform_driver fsl_espi_driver = {
         .probe          = of_fsl_espi_probe,
         .remove         = __devexit_p(of_fsl_espi_remove),
 };
-
-static int __init fsl_espi_init(void)
-{
-        return platform_driver_register(&fsl_espi_driver);
-}
-module_init(fsl_espi_init);
-
-static void __exit fsl_espi_exit(void)
-{
-        platform_driver_unregister(&fsl_espi_driver);
-}
-module_exit(fsl_espi_exit);
+module_platform_driver(fsl_espi_driver);
 
 MODULE_AUTHOR("Mingkai Hu");
 MODULE_DESCRIPTION("Enhanced Freescale SPI Driver");
diff --git a/drivers/spi/spi-gpio.c b/drivers/spi/spi-gpio.c
index 0e88ab745490..635ff08b377f 100644
--- a/drivers/spi/spi-gpio.c
+++ b/drivers/spi/spi-gpio.c
@@ -311,7 +311,7 @@ done:
         return value;
 }
 
-static int __init spi_gpio_probe(struct platform_device *pdev)
+static int __devinit spi_gpio_probe(struct platform_device *pdev)
 {
         int                             status;
         struct spi_master               *master;
@@ -379,7 +379,7 @@ gpio_free:
         return status;
 }
 
-static int __exit spi_gpio_remove(struct platform_device *pdev)
+static int __devexit spi_gpio_remove(struct platform_device *pdev)
 {
         struct spi_gpio                 *spi_gpio;
         struct spi_gpio_platform_data   *pdata;
@@ -408,21 +408,10 @@ MODULE_ALIAS("platform:" DRIVER_NAME);
 static struct platform_driver spi_gpio_driver = {
         .driver.name    = DRIVER_NAME,
         .driver.owner   = THIS_MODULE,
-        .remove         = __exit_p(spi_gpio_remove),
+        .probe          = spi_gpio_probe,
+        .remove         = __devexit_p(spi_gpio_remove),
 };
-
-static int __init spi_gpio_init(void)
-{
-        return platform_driver_probe(&spi_gpio_driver, spi_gpio_probe);
-}
-module_init(spi_gpio_init);
-
-static void __exit spi_gpio_exit(void)
-{
-        platform_driver_unregister(&spi_gpio_driver);
-}
-module_exit(spi_gpio_exit);
-
+module_platform_driver(spi_gpio_driver);
 
 MODULE_DESCRIPTION("SPI master driver using generic bitbanged GPIO ");
 MODULE_AUTHOR("David Brownell");
diff --git a/drivers/spi/spi-imx.c b/drivers/spi/spi-imx.c
index fa594d604aca..c6e697f5e007 100644
--- a/drivers/spi/spi-imx.c
+++ b/drivers/spi/spi-imx.c
@@ -929,19 +929,7 @@ static struct platform_driver spi_imx_driver = {
         .probe = spi_imx_probe,
         .remove = __devexit_p(spi_imx_remove),
 };
-
-static int __init spi_imx_init(void)
-{
-        return platform_driver_register(&spi_imx_driver);
-}
-
-static void __exit spi_imx_exit(void)
-{
-        platform_driver_unregister(&spi_imx_driver);
-}
-
-module_init(spi_imx_init);
-module_exit(spi_imx_exit);
+module_platform_driver(spi_imx_driver);
 
 MODULE_DESCRIPTION("SPI Master Controller driver");
 MODULE_AUTHOR("Sascha Hauer, Pengutronix");
diff --git a/drivers/spi/spi-mpc512x-psc.c b/drivers/spi/spi-mpc512x-psc.c
index 6a5b4238fb6b..4c63f772780a 100644
--- a/drivers/spi/spi-mpc512x-psc.c
+++ b/drivers/spi/spi-mpc512x-psc.c
@@ -559,18 +559,7 @@ static struct platform_driver mpc512x_psc_spi_of_driver = {
                 .of_match_table = mpc512x_psc_spi_of_match,
         },
 };
-
-static int __init mpc512x_psc_spi_init(void)
-{
-        return platform_driver_register(&mpc512x_psc_spi_of_driver);
-}
-module_init(mpc512x_psc_spi_init);
-
-static void __exit mpc512x_psc_spi_exit(void)
-{
-        platform_driver_unregister(&mpc512x_psc_spi_of_driver);
-}
-module_exit(mpc512x_psc_spi_exit);
+module_platform_driver(mpc512x_psc_spi_of_driver);
 
 MODULE_AUTHOR("John Rigby");
 MODULE_DESCRIPTION("MPC512x PSC SPI Driver");
diff --git a/drivers/spi/spi-mpc52xx-psc.c b/drivers/spi/spi-mpc52xx-psc.c
index e30baf0852ac..66047156d90d 100644
--- a/drivers/spi/spi-mpc52xx-psc.c
+++ b/drivers/spi/spi-mpc52xx-psc.c
@@ -511,18 +511,7 @@ static struct platform_driver mpc52xx_psc_spi_of_driver = {
                 .of_match_table = mpc52xx_psc_spi_of_match,
         },
 };
-
-static int __init mpc52xx_psc_spi_init(void)
-{
-        return platform_driver_register(&mpc52xx_psc_spi_of_driver);
-}
-module_init(mpc52xx_psc_spi_init);
-
-static void __exit mpc52xx_psc_spi_exit(void)
-{
-        platform_driver_unregister(&mpc52xx_psc_spi_of_driver);
-}
-module_exit(mpc52xx_psc_spi_exit);
+module_platform_driver(mpc52xx_psc_spi_of_driver);
 
 MODULE_AUTHOR("Dragos Carp");
 MODULE_DESCRIPTION("MPC52xx PSC SPI Driver");
diff --git a/drivers/spi/spi-mpc52xx.c b/drivers/spi/spi-mpc52xx.c
index 015a974bed72..57633d963456 100644
--- a/drivers/spi/spi-mpc52xx.c
+++ b/drivers/spi/spi-mpc52xx.c
@@ -564,16 +564,4 @@ static struct platform_driver mpc52xx_spi_of_driver = {
         .probe = mpc52xx_spi_probe,
         .remove = __devexit_p(mpc52xx_spi_remove),
 };
-
-static int __init mpc52xx_spi_init(void)
-{
-        return platform_driver_register(&mpc52xx_spi_of_driver);
-}
-module_init(mpc52xx_spi_init);
-
-static void __exit mpc52xx_spi_exit(void)
-{
-        platform_driver_unregister(&mpc52xx_spi_of_driver);
-}
-module_exit(mpc52xx_spi_exit);
-
+module_platform_driver(mpc52xx_spi_of_driver);
diff --git a/drivers/spi/spi-nuc900.c b/drivers/spi/spi-nuc900.c
index c0a6ce81f9c0..e763254741c2 100644
--- a/drivers/spi/spi-nuc900.c
+++ b/drivers/spi/spi-nuc900.c
@@ -484,19 +484,7 @@ static struct platform_driver nuc900_spi_driver = {
                 .owner  = THIS_MODULE,
         },
 };
-
-static int __init nuc900_spi_init(void)
-{
-        return platform_driver_register(&nuc900_spi_driver);
-}
-
-static void __exit nuc900_spi_exit(void)
-{
-        platform_driver_unregister(&nuc900_spi_driver);
-}
-
-module_init(nuc900_spi_init);
-module_exit(nuc900_spi_exit);
+module_platform_driver(nuc900_spi_driver);
 
 MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
 MODULE_DESCRIPTION("nuc900 spi driver!");
diff --git a/drivers/spi/spi-oc-tiny.c b/drivers/spi/spi-oc-tiny.c
index f1bde66cea19..897274e8715c 100644
--- a/drivers/spi/spi-oc-tiny.c
+++ b/drivers/spi/spi-oc-tiny.c
@@ -406,18 +406,7 @@ static struct platform_driver tiny_spi_driver = {
                 .of_match_table = tiny_spi_match,
         },
 };
-
-static int __init tiny_spi_init(void)
-{
-        return platform_driver_register(&tiny_spi_driver);
-}
-module_init(tiny_spi_init);
-
-static void __exit tiny_spi_exit(void)
-{
-        platform_driver_unregister(&tiny_spi_driver);
-}
-module_exit(tiny_spi_exit);
+module_platform_driver(tiny_spi_driver);
 
 MODULE_DESCRIPTION("OpenCores tiny SPI driver");
 MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>");
diff --git a/drivers/spi/spi-omap2-mcspi.c b/drivers/spi/spi-omap2-mcspi.c
index fde3a2d4f120..322be7aea8b4 100644
--- a/drivers/spi/spi-omap2-mcspi.c
+++ b/drivers/spi/spi-omap2-mcspi.c
@@ -1116,15 +1116,16 @@ static int __init omap2_mcspi_probe(struct platform_device *pdev)
                 status = -ENODEV;
                 goto err1;
         }
+
+        r->start += pdata->regs_offset;
+        r->end += pdata->regs_offset;
+        mcspi->phys = r->start;
         if (!request_mem_region(r->start, resource_size(r),
                                 dev_name(&pdev->dev))) {
                 status = -EBUSY;
                 goto err1;
         }
 
-        r->start += pdata->regs_offset;
-        r->end += pdata->regs_offset;
-        mcspi->phys = r->start;
         mcspi->base = ioremap(r->start, resource_size(r));
         if (!mcspi->base) {
                 dev_dbg(&pdev->dev, "can't ioremap MCSPI\n");
diff --git a/drivers/spi/spi-pl022.c b/drivers/spi/spi-pl022.c
index 1ab2fa0d37fd..f103e470cb63 100644
--- a/drivers/spi/spi-pl022.c
+++ b/drivers/spi/spi-pl022.c
@@ -113,7 +113,6 @@
 #define SSP_CR0_MASK_CSS_ST     (0x1FUL << 16)
 #define SSP_CR0_MASK_FRF_ST     (0x3UL << 21)
 
-
 /*
  * SSP Control Register 0  - SSP_CR1
  */
@@ -283,7 +282,6 @@
 
 #define SPI_POLLING_TIMEOUT 1000
 
-
 /*
  * The type of reading going on on this chip
  */
@@ -749,7 +747,6 @@ static void readwriter(struct pl022 *pl022)
          */
 }
 
-
 /**
  * next_transfer - Move to the Next transfer in the current spi message
  * @pl022: SSP driver private data structure
@@ -1016,14 +1013,14 @@ static int configure_dma(struct pl022 *pl022)
         dmaengine_slave_config(txchan, &tx_conf);
 
         /* Create sglists for the transfers */
-        pages = (pl022->cur_transfer->len >> PAGE_SHIFT) + 1;
+        pages = DIV_ROUND_UP(pl022->cur_transfer->len, PAGE_SIZE);
         dev_dbg(&pl022->adev->dev, "using %d pages for transfer\n", pages);
 
-        ret = sg_alloc_table(&pl022->sgt_rx, pages, GFP_KERNEL);
+        ret = sg_alloc_table(&pl022->sgt_rx, pages, GFP_ATOMIC);
         if (ret)
                 goto err_alloc_rx_sg;
 
-        ret = sg_alloc_table(&pl022->sgt_tx, pages, GFP_KERNEL);
+        ret = sg_alloc_table(&pl022->sgt_tx, pages, GFP_ATOMIC);
         if (ret)
                 goto err_alloc_tx_sg;
 
@@ -1531,8 +1528,7 @@ static void pump_messages(struct work_struct *work)
         /* Initial message state */
         pl022->cur_msg->state = STATE_START;
         pl022->cur_transfer = list_entry(pl022->cur_msg->transfers.next,
-                                            struct spi_transfer,
-                                            transfer_list);
+                                            struct spi_transfer, transfer_list);
 
         /* Setup the SPI using the per chip configuration */
         pl022->cur_chip = spi_get_ctldata(pl022->cur_msg->spi);
@@ -1551,7 +1547,6 @@ static void pump_messages(struct work_struct *work)
                 do_interrupt_dma_transfer(pl022);
 }
 
-
 static int __init init_queue(struct pl022 *pl022)
 {
         INIT_LIST_HEAD(&pl022->queue);
@@ -1560,8 +1555,8 @@ static int __init init_queue(struct pl022 *pl022)
         pl022->running = false;
         pl022->busy = false;
 
-        tasklet_init(&pl022->pump_transfers,
-                        pump_transfers, (unsigned long)pl022);
+        tasklet_init(&pl022->pump_transfers, pump_transfers,
+                        (unsigned long)pl022);
 
         INIT_WORK(&pl022->pump_messages, pump_messages);
         pl022->workqueue = create_singlethread_workqueue(
@@ -1572,7 +1567,6 @@ static int __init init_queue(struct pl022 *pl022)
         return 0;
 }
 
-
 static int start_queue(struct pl022 *pl022)
 {
         unsigned long flags;
@@ -1595,7 +1589,6 @@ static int start_queue(struct pl022 *pl022)
         return 0;
 }
 
-
 static int stop_queue(struct pl022 *pl022)
 {
         unsigned long flags;
@@ -1791,71 +1784,70 @@ static int pl022_transfer(struct spi_device *spi, struct spi_message *msg)
         return 0;
 }
 
-static int calculate_effective_freq(struct pl022 *pl022,
-                                    int freq,
-                                    struct ssp_clock_params *clk_freq)
+static inline u32 spi_rate(u32 rate, u16 cpsdvsr, u16 scr)
+{
+        return rate / (cpsdvsr * (1 + scr));
+}
+
+static int calculate_effective_freq(struct pl022 *pl022, int freq, struct
+                                    ssp_clock_params * clk_freq)
 {
         /* Lets calculate the frequency parameters */
-        u16 cpsdvsr = 2;
-        u16 scr = 0;
-        bool freq_found = false;
-        u32 rate;
-        u32 max_tclk;
-        u32 min_tclk;
+        u16 cpsdvsr = CPSDVR_MIN, scr = SCR_MIN;
+        u32 rate, max_tclk, min_tclk, best_freq = 0, best_cpsdvsr = 0,
+                best_scr = 0, tmp, found = 0;
 
         rate = clk_get_rate(pl022->clk);
         /* cpsdvscr = 2 & scr 0 */
-        max_tclk = (rate / (CPSDVR_MIN * (1 + SCR_MIN)));
+        max_tclk = spi_rate(rate, CPSDVR_MIN, SCR_MIN);
         /* cpsdvsr = 254 & scr = 255 */
-        min_tclk = (rate / (CPSDVR_MAX * (1 + SCR_MAX)));
-
-        if ((freq <= max_tclk) && (freq >= min_tclk)) {
-                while (cpsdvsr <= CPSDVR_MAX && !freq_found) {
-                        while (scr <= SCR_MAX && !freq_found) {
-                                if ((rate /
-                                     (cpsdvsr * (1 + scr))) > freq)
-                                        scr += 1;
-                                else {
-                                        /*
-                                         * This bool is made true when
-                                         * effective frequency >=
-                                         * target frequency is found
-                                         */
-                                        freq_found = true;
-                                        if ((rate /
-                                             (cpsdvsr * (1 + scr))) != freq) {
-                                                if (scr == SCR_MIN) {
-                                                        cpsdvsr -= 2;
-                                                        scr = SCR_MAX;
-                                                } else
-                                                        scr -= 1;
-                                        }
-                                }
-                        }
-                        if (!freq_found) {
-                                cpsdvsr += 2;
-                                scr = SCR_MIN;
-                        }
-                }
-                if (cpsdvsr != 0) {
-                        dev_dbg(&pl022->adev->dev,
-                                "SSP Effective Frequency is %u\n",
-                                (rate / (cpsdvsr * (1 + scr))));
-                        clk_freq->cpsdvsr = (u8) (cpsdvsr & 0xFF);
-                        clk_freq->scr = (u8) (scr & 0xFF);
-                        dev_dbg(&pl022->adev->dev,
-                                "SSP cpsdvsr = %d, scr = %d\n",
-                                clk_freq->cpsdvsr, clk_freq->scr);
-                }
-        } else {
+        min_tclk = spi_rate(rate, CPSDVR_MAX, SCR_MAX);
+
+        if (!((freq <= max_tclk) && (freq >= min_tclk))) {
                 dev_err(&pl022->adev->dev,
                         "controller data is incorrect: out of range frequency");
                 return -EINVAL;
         }
+
+        /*
+         * best_freq will give closest possible available rate (<= requested
+         * freq) for all values of scr & cpsdvsr.
+         */
+        while ((cpsdvsr <= CPSDVR_MAX) && !found) {
+                while (scr <= SCR_MAX) {
+                        tmp = spi_rate(rate, cpsdvsr, scr);
+
+                        if (tmp > freq)
+                                scr++;
+                        /*
+                         * If found exact value, update and break.
+                         * If found more closer value, update and continue.
+                         */
+                        else if ((tmp == freq) || (tmp > best_freq)) {
+                                best_freq = tmp;
+                                best_cpsdvsr = cpsdvsr;
+                                best_scr = scr;
+
+                                if (tmp == freq)
+                                        break;
+                        }
+                        scr++;
+                }
+                cpsdvsr += 2;
+                scr = SCR_MIN;
+        }
+
+        clk_freq->cpsdvsr = (u8) (best_cpsdvsr & 0xFF);
+        clk_freq->scr = (u8) (best_scr & 0xFF);
+        dev_dbg(&pl022->adev->dev,
+                "SSP Target Frequency is: %u, Effective Frequency is %u\n",
+                freq, best_freq);
+        dev_dbg(&pl022->adev->dev, "SSP cpsdvsr = %d, scr = %d\n",
+                clk_freq->cpsdvsr, clk_freq->scr);
+
         return 0;
 }
 
-
 /*
  * A piece of default chip info unless the platform
  * supplies it.
@@ -1873,7 +1865,6 @@ static const struct pl022_config_chip pl022_default_chip_info = {
         .cs_control = null_cs_control,
 };
 
-
 /**
  * pl022_setup - setup function registered to SPI master framework
  * @spi: spi device which is requesting setup
@@ -1950,7 +1941,6 @@ static int pl022_setup(struct spi_device *spi)
                 goto err_config_params;
         }
 
-
         status = verify_controller_parameters(pl022, chip_info);
         if (status) {
                 dev_err(&spi->dev, "controller data is incorrect");
@@ -2090,7 +2080,8 @@ static int pl022_setup(struct spi_device *spi)
         }
         SSP_WRITE_BITS(chip->cr1, SSP_DISABLED, SSP_CR1_MASK_SSE, 1);
         SSP_WRITE_BITS(chip->cr1, chip_info->hierarchy, SSP_CR1_MASK_MS, 2);
-        SSP_WRITE_BITS(chip->cr1, chip_info->slave_tx_disable, SSP_CR1_MASK_SOD, 3);
+        SSP_WRITE_BITS(chip->cr1, chip_info->slave_tx_disable, SSP_CR1_MASK_SOD,
+                3);
 
         /* Save controller_state */
         spi_set_ctldata(spi, chip);
@@ -2116,7 +2107,6 @@ static void pl022_cleanup(struct spi_device *spi)
         kfree(chip);
 }
 
-
 static int __devinit
 pl022_probe(struct amba_device *adev, const struct amba_id *id)
 {
@@ -2242,7 +2232,9 @@ pl022_probe(struct amba_device *adev, const struct amba_id *id)
  err_start_queue:
  err_init_queue:
         destroy_queue(pl022);
-        pl022_dma_remove(pl022);
+        if (platform_info->enable_dma)
+                pl022_dma_remove(pl022);
+
         free_irq(adev->irq[0], pl022);
  err_no_irq:
         clk_unprepare(pl022->clk);
@@ -2277,7 +2269,9 @@ pl022_remove(struct amba_device *adev)
         if (destroy_queue(pl022) != 0)
                 dev_err(&adev->dev, "queue remove failed\n");
         load_ssp_default_config(pl022);
-        pl022_dma_remove(pl022);
+        if (pl022->master_info->enable_dma)
+                pl022_dma_remove(pl022);
+
         free_irq(adev->irq[0], pl022);
         clk_disable(pl022->clk);
         clk_unprepare(pl022->clk);
@@ -2364,7 +2358,6 @@ static struct vendor_data vendor_arm = {
         .loopback = true,
 };
 
-
 static struct vendor_data vendor_st = {
         .fifodepth = 32,
         .max_bpw = 32,
@@ -2419,9 +2412,9 @@ static struct amba_id pl022_ids[] = {
                  * and 32 locations deep TX/RX FIFO but no extended
                  * CR0/CR1 register
                  */
-                .id     = 0x00080023,
-                .mask   = 0xffffffff,
-                .data   = &vendor_st_pl023,
+                .id     = 0x00080023,
+                .mask   = 0xffffffff,
+                .data   = &vendor_st_pl023,
         },
         {
                 .id     = 0x10080023,
@@ -2441,19 +2434,16 @@ static struct amba_driver pl022_driver = {
         .remove         = __devexit_p(pl022_remove),
 };
 
-
 static int __init pl022_init(void)
 {
         return amba_driver_register(&pl022_driver);
 }
-
 subsys_initcall(pl022_init);
 
 static void __exit pl022_exit(void)
 {
         amba_driver_unregister(&pl022_driver);
 }
-
 module_exit(pl022_exit);
 
 MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
diff --git a/drivers/spi/spi-ppc4xx.c b/drivers/spi/spi-ppc4xx.c
index b267fd901e54..98ec53285fc7 100644
--- a/drivers/spi/spi-ppc4xx.c
+++ b/drivers/spi/spi-ppc4xx.c
@@ -514,7 +514,7 @@ static int __init spi_ppc4xx_of_probe(struct platform_device *op)
         /* Request IRQ */
         hw->irqnum = irq_of_parse_and_map(np, 0);
         ret = request_irq(hw->irqnum, spi_ppc4xx_int,
-                          IRQF_DISABLED, "spi_ppc4xx_of", (void *)hw);
+                          0, "spi_ppc4xx_of", (void *)hw);
         if (ret) {
                 dev_err(dev, "unable to allocate interrupt\n");
                 goto free_gpios;
@@ -594,18 +594,7 @@ static struct platform_driver spi_ppc4xx_of_driver = {
                 .of_match_table = spi_ppc4xx_of_match,
         },
 };
-
-static int __init spi_ppc4xx_init(void)
-{
-        return platform_driver_register(&spi_ppc4xx_of_driver);
-}
-module_init(spi_ppc4xx_init);
-
-static void __exit spi_ppc4xx_exit(void)
-{
-        platform_driver_unregister(&spi_ppc4xx_of_driver);
-}
-module_exit(spi_ppc4xx_exit);
+module_platform_driver(spi_ppc4xx_of_driver);
 
 MODULE_AUTHOR("Gary Jennejohn & Stefan Roese");
 MODULE_DESCRIPTION("Simple PPC4xx SPI Driver");
diff --git a/drivers/spi/spi-s3c24xx.c b/drivers/spi/spi-s3c24xx.c
index 1996ac57ef91..b857a3e7af94 100644
--- a/drivers/spi/spi-s3c24xx.c
+++ b/drivers/spi/spi-s3c24xx.c
@@ -505,7 +505,7 @@ static void s3c24xx_spi_initialsetup(struct s3c24xx_spi *hw)
         }
 }
 
-static int __init s3c24xx_spi_probe(struct platform_device *pdev)
+static int __devinit s3c24xx_spi_probe(struct platform_device *pdev)
 {
         struct s3c2410_spi_info *pdata;
         struct s3c24xx_spi *hw;
@@ -661,7 +661,7 @@ static int __init s3c24xx_spi_probe(struct platform_device *pdev)
         return err;
 }
 
-static int __exit s3c24xx_spi_remove(struct platform_device *dev)
+static int __devexit s3c24xx_spi_remove(struct platform_device *dev)
 {
         struct s3c24xx_spi *hw = platform_get_drvdata(dev);
 
@@ -719,26 +719,15 @@ static const struct dev_pm_ops s3c24xx_spi_pmops = {
 
 MODULE_ALIAS("platform:s3c2410-spi");
 static struct platform_driver s3c24xx_spi_driver = {
-        .remove         = __exit_p(s3c24xx_spi_remove),
+        .probe          = s3c24xx_spi_probe,
+        .remove         = __devexit_p(s3c24xx_spi_remove),
         .driver         = {
                 .name   = "s3c2410-spi",
                 .owner  = THIS_MODULE,
                 .pm     = S3C24XX_SPI_PMOPS,
         },
 };
-
-static int __init s3c24xx_spi_init(void)
-{
-        return platform_driver_probe(&s3c24xx_spi_driver, s3c24xx_spi_probe);
-}
-
-static void __exit s3c24xx_spi_exit(void)
-{
-        platform_driver_unregister(&s3c24xx_spi_driver);
-}
-
-module_init(s3c24xx_spi_init);
-module_exit(s3c24xx_spi_exit);
+module_platform_driver(s3c24xx_spi_driver);
 
 MODULE_DESCRIPTION("S3C24XX SPI Driver");
 MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
diff --git a/drivers/spi/spi-sh-msiof.c b/drivers/spi/spi-sh-msiof.c
index e00d94b22250..0f4834ae28cd 100644
--- a/drivers/spi/spi-sh-msiof.c
+++ b/drivers/spi/spi-sh-msiof.c
@@ -635,7 +635,7 @@ static int sh_msiof_spi_probe(struct platform_device *pdev)
                 goto err2;
         }
 
-        ret = request_irq(i, sh_msiof_spi_irq, IRQF_DISABLED,
+        ret = request_irq(i, sh_msiof_spi_irq, 0,
                           dev_name(&pdev->dev), p);
         if (ret) {
                 dev_err(&pdev->dev, "unable to request irq\n");
@@ -730,18 +730,7 @@ static struct platform_driver sh_msiof_spi_drv = {
                 .pm             = &sh_msiof_spi_dev_pm_ops,
         },
 };
-
-static int __init sh_msiof_spi_init(void)
-{
-        return platform_driver_register(&sh_msiof_spi_drv);
-}
-module_init(sh_msiof_spi_init);
-
-static void __exit sh_msiof_spi_exit(void)
-{
-        platform_driver_unregister(&sh_msiof_spi_drv);
-}
-module_exit(sh_msiof_spi_exit);
+module_platform_driver(sh_msiof_spi_drv);
 
 MODULE_DESCRIPTION("SuperH MSIOF SPI Master Interface Driver");
 MODULE_AUTHOR("Magnus Damm");
diff --git a/drivers/spi/spi-sh-sci.c b/drivers/spi/spi-sh-sci.c
index e7779c09f6ef..8844bc342782 100644
--- a/drivers/spi/spi-sh-sci.c
+++ b/drivers/spi/spi-sh-sci.c
@@ -186,18 +186,7 @@ static struct platform_driver sh_sci_spi_drv = {
                 .owner  = THIS_MODULE,
         },
 };
-
-static int __init sh_sci_spi_init(void)
-{
-        return platform_driver_register(&sh_sci_spi_drv);
-}
-module_init(sh_sci_spi_init);
-
-static void __exit sh_sci_spi_exit(void)
-{
-        platform_driver_unregister(&sh_sci_spi_drv);
-}
-module_exit(sh_sci_spi_exit);
+module_platform_driver(sh_sci_spi_drv);
 
 MODULE_DESCRIPTION("SH SCI SPI Driver");
 MODULE_AUTHOR("Magnus Damm <damm@opensource.se>");
diff --git a/drivers/spi/spi-sh.c b/drivers/spi/spi-sh.c
index 9eedd71ad898..70c8af9f7ccc 100644
--- a/drivers/spi/spi-sh.c
+++ b/drivers/spi/spi-sh.c
@@ -484,7 +484,7 @@ static int __devinit spi_sh_probe(struct platform_device *pdev)
                 goto error2;
         }
 
-        ret = request_irq(irq, spi_sh_irq, IRQF_DISABLED, "spi_sh", ss);
+        ret = request_irq(irq, spi_sh_irq, 0, "spi_sh", ss);
         if (ret < 0) {
                 dev_err(&pdev->dev, "request_irq error\n");
                 goto error3;
@@ -524,18 +524,7 @@ static struct platform_driver spi_sh_driver = {
                 .owner = THIS_MODULE,
         },
 };
-
-static int __init spi_sh_init(void)
-{
-        return platform_driver_register(&spi_sh_driver);
-}
-module_init(spi_sh_init);
-
-static void __exit spi_sh_exit(void)
-{
-        platform_driver_unregister(&spi_sh_driver);
-}
-module_exit(spi_sh_exit);
+module_platform_driver(spi_sh_driver);
 
 MODULE_DESCRIPTION("SH SPI bus driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi-stmp.c b/drivers/spi/spi-stmp.c
index fadff76eb7e0..58e385285323 100644
--- a/drivers/spi/spi-stmp.c
+++ b/drivers/spi/spi-stmp.c
@@ -659,19 +659,8 @@ static struct platform_driver stmp_spi_driver = {
         .suspend = stmp_spi_suspend,
         .resume  = stmp_spi_resume,
 };
+module_platform_driver(stmp_spi_driver);
 
-static int __init stmp_spi_init(void)
-{
-        return platform_driver_register(&stmp_spi_driver);
-}
-
-static void __exit stmp_spi_exit(void)
-{
-        platform_driver_unregister(&stmp_spi_driver);
-}
-
-module_init(stmp_spi_init);
-module_exit(stmp_spi_exit);
 module_param(pio, int, S_IRUGO);
 module_param(clock, int, S_IRUGO);
 MODULE_AUTHOR("dmitry pervushin <dpervushin@embeddedalley.com>");
diff --git a/drivers/spi/spi-tegra.c b/drivers/spi/spi-tegra.c
index a5a6302dc8e0..ae6d78a3e912 100644
--- a/drivers/spi/spi-tegra.c
+++ b/drivers/spi/spi-tegra.c
@@ -18,6 +18,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/init.h>
 #include <linux/err.h>
 #include <linux/platform_device.h>
@@ -464,7 +465,7 @@ static int spi_tegra_transfer(struct spi_device *spi, struct spi_message *m)
         return 0;
 }
 
-static int __init spi_tegra_probe(struct platform_device *pdev)
+static int __devinit spi_tegra_probe(struct platform_device *pdev)
 {
         struct spi_master       *master;
         struct spi_tegra_data   *tspi;
@@ -612,19 +613,9 @@ static struct platform_driver spi_tegra_driver = {
                 .owner =        THIS_MODULE,
                 .of_match_table = spi_tegra_of_match_table,
         },
+        .probe =        spi_tegra_probe,
         .remove =       __devexit_p(spi_tegra_remove),
 };
-
-static int __init spi_tegra_init(void)
-{
-        return platform_driver_probe(&spi_tegra_driver, spi_tegra_probe);
-}
-module_init(spi_tegra_init);
-
-static void __exit spi_tegra_exit(void)
-{
-        platform_driver_unregister(&spi_tegra_driver);
-}
-module_exit(spi_tegra_exit);
+module_platform_driver(spi_tegra_driver);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi-ti-ssp.c b/drivers/spi/spi-ti-ssp.c
index ee22795c7973..7963c60063d6 100644
--- a/drivers/spi/spi-ti-ssp.c
+++ b/drivers/spi/spi-ti-ssp.c
@@ -383,18 +383,7 @@ static struct platform_driver ti_ssp_spi_driver = {
                 .owner  = THIS_MODULE,
         },
 };
-
-static int __init ti_ssp_spi_init(void)
-{
-        return platform_driver_register(&ti_ssp_spi_driver);
-}
-module_init(ti_ssp_spi_init);
-
-static void __exit ti_ssp_spi_exit(void)
-{
-        platform_driver_unregister(&ti_ssp_spi_driver);
-}
-module_exit(ti_ssp_spi_exit);
+module_platform_driver(ti_ssp_spi_driver);
 
 MODULE_DESCRIPTION("SSP SPI Master");
 MODULE_AUTHOR("Cyril Chemparathy");
diff --git a/drivers/spi/spi-xilinx.c b/drivers/spi/spi-xilinx.c
index 4d2c75df886c..4c5a663b9fa8 100644
--- a/drivers/spi/spi-xilinx.c
+++ b/drivers/spi/spi-xilinx.c
@@ -538,18 +538,7 @@ static struct platform_driver xilinx_spi_driver = {
                 .of_match_table = xilinx_spi_of_match,
         },
 };
-
-static int __init xilinx_spi_pltfm_init(void)
-{
-        return platform_driver_register(&xilinx_spi_driver);
-}
-module_init(xilinx_spi_pltfm_init);
-
-static void __exit xilinx_spi_pltfm_exit(void)
-{
-        platform_driver_unregister(&xilinx_spi_driver);
-}
-module_exit(xilinx_spi_pltfm_exit);
+module_platform_driver(xilinx_spi_driver);
 
 MODULE_AUTHOR("MontaVista Software, Inc. <source@mvista.com>");
 MODULE_DESCRIPTION("Xilinx SPI driver");
diff --git a/drivers/tty/serial/of_serial.c b/drivers/tty/serial/of_serial.c
index e58cece6f443..e8c9cee07d00 100644
--- a/drivers/tty/serial/of_serial.c
+++ b/drivers/tty/serial/of_serial.c
@@ -200,17 +200,7 @@ static struct platform_driver of_platform_serial_driver = {
         .remove = of_platform_serial_remove,
 };
 
-static int __init of_platform_serial_init(void)
-{
-        return platform_driver_register(&of_platform_serial_driver);
-}
-module_init(of_platform_serial_init);
-
-static void __exit of_platform_serial_exit(void)
-{
-        return platform_driver_unregister(&of_platform_serial_driver);
-};
-module_exit(of_platform_serial_exit);
+module_platform_driver(of_platform_serial_driver);
 
 MODULE_AUTHOR("Arnd Bergmann <arnd@arndb.de>");
 MODULE_LICENSE("GPL");
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index 651a066686ac..2a23f7d1a825 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -190,6 +190,23 @@ static inline void platform_set_drvdata(struct platform_device *pdev, void *data
         dev_set_drvdata(&pdev->dev, data);
 }
 
+/* module_platform_driver() - Helper macro for drivers that don't do
+ * anything special in module init/exit.  This eliminates a lot of
+ * boilerplate.  Each module may only use this macro once, and
+ * calling it replaces module_init() and module_exit()
+ */
+#define module_platform_driver(__platform_driver) \
+static int __init __platform_driver##_init(void) \
+{ \
+        return platform_driver_register(&(__platform_driver)); \
+} \
+module_init(__platform_driver##_init); \
+static void __exit __platform_driver##_exit(void) \
+{ \
+        platform_driver_unregister(&(__platform_driver)); \
+} \
+module_exit(__platform_driver##_exit);
+
 extern struct platform_device *platform_create_bundle(struct platform_driver *driver,
                                         int (*probe)(struct platform_device *),
                                         struct resource *res, unsigned int n_res,