UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'spi/next' of git://git.secretlab.ca/git/linux-2.6 

* 'spi/next' of git://git.secretlab.ca/git/linux-2.6:
  drivercore: Add helper macro for platform_driver boilerplate
  spi: irq: Remove IRQF_DISABLED
  OMAP: SPI: Fix the trying to free nonexistent resource error
  spi/spi-ep93xx: add module.h include
  spi/tegra: fix compilation error in spi-tegra.c
  spi: spi-dw: fix all sparse warnings
  spi/spi-pl022: Call pl022_dma_remove(pl022) only if enable_dma is true
  spi/spi-pl022: calculate_effective_freq() must set rate <= requested rate
  spi/spi-pl022: Don't allocate more sg than required.
  spi/spi-pl022: Use GFP_ATOMIC for allocation from tasklet
  spi/spi-pl022: Resolve formatting issues
This commit is contained in:
Linus Torvalds 2011-10-29 07:28:36 -07:00
parent 41684f67af 940ab88962
commit 18c0635363
33 changed files with 230 additions and 493 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
drivers/spi/spi-altera.c
View File

@ -320,18 +320,7 @@ static struct platform_driver altera_spi_driver = {
.of_match_table = altera_spi_match, .of_match_table = altera_spi_match,
}, },
}; };
module_platform_driver(altera_spi_driver);
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_DESCRIPTION("Altera SPI driver"); MODULE_DESCRIPTION("Altera SPI driver");
MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>"); MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>");

13
drivers/spi/spi-ath79.c
View File

@ -273,18 +273,7 @@ static struct platform_driver ath79_spi_driver = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
}, },
}; };
module_platform_driver(ath79_spi_driver);
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_DESCRIPTION("SPI controller driver for Atheros AR71XX/AR724X/AR913X"); MODULE_DESCRIPTION("SPI controller driver for Atheros AR71XX/AR724X/AR913X");
MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>"); MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");

13
drivers/spi/spi-atmel.c
View File

@ -1074,18 +1074,7 @@ static struct platform_driver atmel_spi_driver = {
.resume = atmel_spi_resume, .resume = atmel_spi_resume,
.remove = __exit_p(atmel_spi_remove), .remove = __exit_p(atmel_spi_remove),
}; };
module_platform_driver(atmel_spi_driver);
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_DESCRIPTION("Atmel AT32/AT91 SPI Controller driver"); MODULE_DESCRIPTION("Atmel AT32/AT91 SPI Controller driver");
MODULE_AUTHOR("Haavard Skinnemoen (Atmel)"); MODULE_AUTHOR("Haavard Skinnemoen (Atmel)");

13
drivers/spi/spi-bfin-sport.c
View File

@ -938,15 +938,4 @@ static struct platform_driver bfin_sport_spi_driver = {
.suspend = bfin_sport_spi_suspend, .suspend = bfin_sport_spi_suspend,
.resume = bfin_sport_spi_resume, .resume = bfin_sport_spi_resume,
}; };
module_platform_driver(bfin_sport_spi_driver);
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);

2
drivers/spi/spi-bfin5xx.c
View File

@ -1098,7 +1098,7 @@ static int bfin_spi_setup(struct spi_device *spi)
if (chip->pio_interrupt && !drv_data->irq_requested) { if (chip->pio_interrupt && !drv_data->irq_requested) {
ret = request_irq(drv_data->spi_irq, bfin_spi_pio_irq_handler, 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) { if (ret) {
dev_err(&spi->dev, "Unable to register spi IRQ\n"); dev_err(&spi->dev, "Unable to register spi IRQ\n");
goto error; goto error;

16
drivers/spi/spi-coldfire-qspi.c
View File

@ -487,7 +487,7 @@ static int __devinit mcfqspi_probe(struct platform_device *pdev)
goto fail2; goto fail2;
} }
status = request_irq(mcfqspi->irq, mcfqspi_irq_handler, IRQF_DISABLED, status = request_irq(mcfqspi->irq, mcfqspi_irq_handler, 0,
pdev->name, mcfqspi); pdev->name, mcfqspi);
if (status) { if (status) {
dev_dbg(&pdev->dev, "request_irq failed\n"); dev_dbg(&pdev->dev, "request_irq failed\n");
@ -621,20 +621,10 @@ static struct platform_driver mcfqspi_driver = {
.driver.name = DRIVER_NAME, .driver.name = DRIVER_NAME,
.driver.owner = THIS_MODULE, .driver.owner = THIS_MODULE,
.driver.pm = MCFQSPI_DEV_PM_OPS, .driver.pm = MCFQSPI_DEV_PM_OPS,
.probe = mcfqspi_probe,
.remove = __devexit_p(mcfqspi_remove), .remove = __devexit_p(mcfqspi_remove),
}; };
module_platform_driver(mcfqspi_driver);
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_AUTHOR("Steven King <sfking@fdwdc.com>"); MODULE_AUTHOR("Steven King <sfking@fdwdc.com>");
MODULE_DESCRIPTION("Coldfire QSPI Controller Driver"); MODULE_DESCRIPTION("Coldfire QSPI Controller Driver");

20
drivers/spi/spi-davinci.c
View File

@ -799,7 +799,7 @@ rx_dma_failed:
* It will invoke spi_bitbang_start to create work queue so that client driver * It will invoke spi_bitbang_start to create work queue so that client driver
* can register transfer method to work queue. * 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 spi_master *master;
struct davinci_spi *dspi; struct davinci_spi *dspi;
@ -984,7 +984,7 @@ err:
* It will also call spi_bitbang_stop to destroy the work queue which was * It will also call spi_bitbang_stop to destroy the work queue which was
* created by spi_bitbang_start. * 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 davinci_spi *dspi;
struct spi_master *master; struct spi_master *master;
@ -1011,20 +1011,10 @@ static struct platform_driver davinci_spi_driver = {
.name = "spi_davinci", .name = "spi_davinci",
.owner = THIS_MODULE, .owner = THIS_MODULE,
}, },
.remove = __exit_p(davinci_spi_remove), .probe = davinci_spi_probe,
.remove = __devexit_p(davinci_spi_remove),
}; };
module_platform_driver(davinci_spi_driver);
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_DESCRIPTION("TI DaVinci SPI Master Controller Driver"); MODULE_DESCRIPTION("TI DaVinci SPI Master Controller Driver");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

9
drivers/spi/spi-dw-mid.c
View File

@ -116,13 +116,13 @@ static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change)
/* 1. setup DMA related registers */ /* 1. setup DMA related registers */
if (cs_change) { if (cs_change) {
spi_enable_chip(dws, 0); spi_enable_chip(dws, 0);
dw_writew(dws, dmardlr, 0xf); dw_writew(dws, DW_SPI_DMARDLR, 0xf);
dw_writew(dws, dmatdlr, 0x10); dw_writew(dws, DW_SPI_DMATDLR, 0x10);
if (dws->tx_dma) if (dws->tx_dma)
dma_ctrl |= 0x2; dma_ctrl |= 0x2;
if (dws->rx_dma) if (dws->rx_dma)
dma_ctrl |= 0x1; dma_ctrl |= 0x1;
dw_writew(dws, dmacr, dma_ctrl); dw_writew(dws, DW_SPI_DMACR, dma_ctrl);
spi_enable_chip(dws, 1); 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) 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); clk_reg = ioremap_nocache(MRST_CLK_SPI0_REG, 16);
if (!clk_reg) if (!clk_reg)

14
drivers/spi/spi-dw-mmio.c
View File

@ -127,24 +127,14 @@ static int __devexit dw_spi_mmio_remove(struct platform_device *pdev)
} }
static struct platform_driver dw_spi_mmio_driver = { static struct platform_driver dw_spi_mmio_driver = {
.probe = dw_spi_mmio_probe,
.remove = __devexit_p(dw_spi_mmio_remove), .remove = __devexit_p(dw_spi_mmio_remove),
.driver = { .driver = {
.name = DRIVER_NAME, .name = DRIVER_NAME,
.owner = THIS_MODULE, .owner = THIS_MODULE,
}, },
}; };
module_platform_driver(dw_spi_mmio_driver);
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_AUTHOR("Jean-Hugues Deschenes <jean-hugues.deschenes@octasic.com>"); MODULE_AUTHOR("Jean-Hugues Deschenes <jean-hugues.deschenes@octasic.com>");
MODULE_DESCRIPTION("Memory-mapped I/O interface driver for DW SPI Core"); MODULE_DESCRIPTION("Memory-mapped I/O interface driver for DW SPI Core");

62
drivers/spi/spi-dw.c
View File

@ -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, len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
"=================================\n"); "=================================\n");
len += snprintf(buf + len, SPI_REGS_BUFSIZE - len, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
"=================================\n"); "=================================\n");
@ -166,7 +166,7 @@ static inline u32 tx_max(struct dw_spi *dws)
u32 tx_left, tx_room, rxtx_gap; u32 tx_left, tx_room, rxtx_gap;
tx_left = (dws->tx_end - dws->tx) / dws->n_bytes; 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 * 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; 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) static void dw_writer(struct dw_spi *dws)
@ -203,7 +203,7 @@ static void dw_writer(struct dw_spi *dws)
else else
txw = *(u16 *)(dws->tx); txw = *(u16 *)(dws->tx);
} }
dw_writew(dws, dr, txw); dw_writew(dws, DW_SPI_DR, txw);
dws->tx += dws->n_bytes; dws->tx += dws->n_bytes;
} }
} }
@ -214,7 +214,7 @@ static void dw_reader(struct dw_spi *dws)
u16 rxw; u16 rxw;
while (max--) { 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 */ /* Care rx only if the transfer's original "rx" is not null */
if (dws->rx_end - dws->len) { if (dws->rx_end - dws->len) {
if (dws->n_bytes == 1) 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) 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 */ /* Error handling */
if (irq_status & (SPI_INT_TXOI | SPI_INT_RXOI | SPI_INT_RXUI)) { if (irq_status & (SPI_INT_TXOI | SPI_INT_RXOI | SPI_INT_RXUI)) {
dw_readw(dws, txoicr); dw_readw(dws, DW_SPI_TXOICR);
dw_readw(dws, rxoicr); dw_readw(dws, DW_SPI_RXOICR);
dw_readw(dws, rxuicr); dw_readw(dws, DW_SPI_RXUICR);
int_error_stop(dws, "interrupt_transfer: fifo overrun/underrun"); int_error_stop(dws, "interrupt_transfer: fifo overrun/underrun");
return IRQ_HANDLED; 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) static irqreturn_t dw_spi_irq(int irq, void *dev_id)
{ {
struct dw_spi *dws = 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) if (!irq_status)
return IRQ_NONE; return IRQ_NONE;
@ -520,11 +520,11 @@ static void pump_transfers(unsigned long data)
* 2. clk_div is changed * 2. clk_div is changed
* 3. control value changes * 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); spi_enable_chip(dws, 0);
if (dw_readw(dws, ctrl0) != cr0) if (dw_readw(dws, DW_SPI_CTRL0) != cr0)
dw_writew(dws, ctrl0, cr0); dw_writew(dws, DW_SPI_CTRL0, cr0);
spi_set_clk(dws, clk_div ? clk_div : chip->clk_div); spi_set_clk(dws, clk_div ? clk_div : chip->clk_div);
spi_chip_sel(dws, spi->chip_select); spi_chip_sel(dws, spi->chip_select);
@ -534,7 +534,7 @@ static void pump_transfers(unsigned long data)
if (imask) if (imask)
spi_umask_intr(dws, imask); spi_umask_intr(dws, imask);
if (txint_level) if (txint_level)
dw_writew(dws, txfltr, txint_level); dw_writew(dws, DW_SPI_TXFLTR, txint_level);
spi_enable_chip(dws, 1); spi_enable_chip(dws, 1);
if (cs_change) if (cs_change)
@ -790,13 +790,13 @@ static void spi_hw_init(struct dw_spi *dws)
if (!dws->fifo_len) { if (!dws->fifo_len) {
u32 fifo; u32 fifo;
for (fifo = 2; fifo <= 257; fifo++) { for (fifo = 2; fifo <= 257; fifo++) {
dw_writew(dws, txfltr, fifo); dw_writew(dws, DW_SPI_TXFLTR, fifo);
if (fifo != dw_readw(dws, txfltr)) if (fifo != dw_readw(dws, DW_SPI_TXFLTR))
break; break;
} }
dws->fifo_len = (fifo == 257) ? 0 : fifo; dws->fifo_len = (fifo == 257) ? 0 : fifo;
dw_writew(dws, txfltr, 0); dw_writew(dws, DW_SPI_TXFLTR, 0);
} }
} }

97
drivers/spi/spi-dw.h
View File

@ -4,6 +4,33 @@
#include <linux/io.h> #include <linux/io.h>
#include <linux/scatterlist.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 */ /* Bit fields in CTRLR0 */
#define SPI_DFS_OFFSET 0 #define SPI_DFS_OFFSET 0
@ -55,35 +82,6 @@ enum dw_ssi_type {
SSI_NS_MICROWIRE, 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;
struct dw_spi_dma_ops { struct dw_spi_dma_ops {
int (*dma_init)(struct dw_spi *dws); int (*dma_init)(struct dw_spi *dws);
@ -161,23 +159,34 @@ struct dw_spi {
#endif #endif
}; };
#define dw_readl(dw, name) \ static inline u32 dw_readl(struct dw_spi *dws, u32 offset)
__raw_readl(&(((struct dw_spi_reg *)dw->regs)->name)) {
#define dw_writel(dw, name, val) \ return __raw_readl(dws->regs + offset);
__raw_writel((val), &(((struct dw_spi_reg *)dw->regs)->name)) }
#define dw_readw(dw, name) \
__raw_readw(&(((struct dw_spi_reg *)dw->regs)->name)) static inline void dw_writel(struct dw_spi *dws, u32 offset, u32 val)
#define dw_writew(dw, name, val) \ {
__raw_writew((val), &(((struct dw_spi_reg *)dw->regs)->name)) __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) 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) 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) 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) if (dws->cs_control)
dws->cs_control(1); dws->cs_control(1);
dw_writel(dws, ser, 1 << cs); dw_writel(dws, DW_SPI_SER, 1 << cs);
} }
/* Disable IRQ bits */ /* Disable IRQ bits */
@ -196,8 +205,8 @@ static inline void spi_mask_intr(struct dw_spi *dws, u32 mask)
{ {
u32 new_mask; u32 new_mask;
new_mask = dw_readl(dws, imr) & ~mask; new_mask = dw_readl(dws, DW_SPI_IMR) & ~mask;
dw_writel(dws, imr, new_mask); dw_writel(dws, DW_SPI_IMR, new_mask);
} }
/* Enable IRQ bits */ /* Enable IRQ bits */
@ -205,8 +214,8 @@ static inline void spi_umask_intr(struct dw_spi *dws, u32 mask)
{ {
u32 new_mask; u32 new_mask;
new_mask = dw_readl(dws, imr) | mask; new_mask = dw_readl(dws, DW_SPI_IMR) | mask;
dw_writel(dws, imr, new_mask); dw_writel(dws, DW_SPI_IMR, new_mask);
} }
/* /*

21
drivers/spi/spi-ep93xx.c
View File

@ -24,6 +24,7 @@
#include <linux/dmaengine.h> #include <linux/dmaengine.h>
#include <linux/bitops.h> #include <linux/bitops.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/platform_device.h> #include <linux/platform_device.h>
#include <linux/workqueue.h> #include <linux/workqueue.h>
#include <linux/sched.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); 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 spi_master *master;
struct ep93xx_spi_info *info; struct ep93xx_spi_info *info;
@ -1150,7 +1151,7 @@ fail_release_master:
return error; 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 spi_master *master = platform_get_drvdata(pdev);
struct ep93xx_spi *espi = spi_master_get_devdata(master); struct ep93xx_spi *espi = spi_master_get_devdata(master);
@ -1196,20 +1197,10 @@ static struct platform_driver ep93xx_spi_driver = {
.name = "ep93xx-spi", .name = "ep93xx-spi",
.owner = THIS_MODULE, .owner = THIS_MODULE,
}, },
.remove = __exit_p(ep93xx_spi_remove), .probe = ep93xx_spi_probe,
.remove = __devexit_p(ep93xx_spi_remove),
}; };
module_platform_driver(ep93xx_spi_driver);
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_DESCRIPTION("EP93xx SPI Controller driver"); MODULE_DESCRIPTION("EP93xx SPI Controller driver");
MODULE_AUTHOR("Mika Westerberg <mika.westerberg@iki.fi>"); MODULE_AUTHOR("Mika Westerberg <mika.westerberg@iki.fi>");

13
drivers/spi/spi-fsl-espi.c
View File

@ -744,18 +744,7 @@ static struct platform_driver fsl_espi_driver = {
.probe = of_fsl_espi_probe, .probe = of_fsl_espi_probe,
.remove = __devexit_p(of_fsl_espi_remove), .remove = __devexit_p(of_fsl_espi_remove),
}; };
module_platform_driver(fsl_espi_driver);
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_AUTHOR("Mingkai Hu"); MODULE_AUTHOR("Mingkai Hu");
MODULE_DESCRIPTION("Enhanced Freescale SPI Driver"); MODULE_DESCRIPTION("Enhanced Freescale SPI Driver");

21
drivers/spi/spi-gpio.c
View File

@ -311,7 +311,7 @@ done:
return value; return value;
} }
static int __init spi_gpio_probe(struct platform_device *pdev) static int __devinit spi_gpio_probe(struct platform_device *pdev)
{ {
int status; int status;
struct spi_master *master; struct spi_master *master;
@ -379,7 +379,7 @@ gpio_free:
return status; 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 *spi_gpio;
struct spi_gpio_platform_data *pdata; struct spi_gpio_platform_data *pdata;
@ -408,21 +408,10 @@ MODULE_ALIAS("platform:" DRIVER_NAME);
static struct platform_driver spi_gpio_driver = { static struct platform_driver spi_gpio_driver = {
.driver.name = DRIVER_NAME, .driver.name = DRIVER_NAME,
.driver.owner = THIS_MODULE, .driver.owner = THIS_MODULE,
.remove = __exit_p(spi_gpio_remove), .probe = spi_gpio_probe,
.remove = __devexit_p(spi_gpio_remove),
}; };
module_platform_driver(spi_gpio_driver);
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_DESCRIPTION("SPI master driver using generic bitbanged GPIO "); MODULE_DESCRIPTION("SPI master driver using generic bitbanged GPIO ");
MODULE_AUTHOR("David Brownell"); MODULE_AUTHOR("David Brownell");

14
drivers/spi/spi-imx.c
View File

@ -929,19 +929,7 @@ static struct platform_driver spi_imx_driver = {
.probe = spi_imx_probe, .probe = spi_imx_probe,
.remove = __devexit_p(spi_imx_remove), .remove = __devexit_p(spi_imx_remove),
}; };
module_platform_driver(spi_imx_driver);
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_DESCRIPTION("SPI Master Controller driver"); MODULE_DESCRIPTION("SPI Master Controller driver");
MODULE_AUTHOR("Sascha Hauer, Pengutronix"); MODULE_AUTHOR("Sascha Hauer, Pengutronix");

13
drivers/spi/spi-mpc512x-psc.c
View File

@ -559,18 +559,7 @@ static struct platform_driver mpc512x_psc_spi_of_driver = {
.of_match_table = mpc512x_psc_spi_of_match, .of_match_table = mpc512x_psc_spi_of_match,
}, },
}; };
module_platform_driver(mpc512x_psc_spi_of_driver);
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_AUTHOR("John Rigby"); MODULE_AUTHOR("John Rigby");
MODULE_DESCRIPTION("MPC512x PSC SPI Driver"); MODULE_DESCRIPTION("MPC512x PSC SPI Driver");

13
drivers/spi/spi-mpc52xx-psc.c
View File

@ -511,18 +511,7 @@ static struct platform_driver mpc52xx_psc_spi_of_driver = {
.of_match_table = mpc52xx_psc_spi_of_match, .of_match_table = mpc52xx_psc_spi_of_match,
}, },
}; };
module_platform_driver(mpc52xx_psc_spi_of_driver);
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_AUTHOR("Dragos Carp"); MODULE_AUTHOR("Dragos Carp");
MODULE_DESCRIPTION("MPC52xx PSC SPI Driver"); MODULE_DESCRIPTION("MPC52xx PSC SPI Driver");

14
drivers/spi/spi-mpc52xx.c
View File

@ -564,16 +564,4 @@ static struct platform_driver mpc52xx_spi_of_driver = {
.probe = mpc52xx_spi_probe, .probe = mpc52xx_spi_probe,
.remove = __devexit_p(mpc52xx_spi_remove), .remove = __devexit_p(mpc52xx_spi_remove),
}; };
module_platform_driver(mpc52xx_spi_of_driver);
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);

14
drivers/spi/spi-nuc900.c
View File

@ -484,19 +484,7 @@ static struct platform_driver nuc900_spi_driver = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
}, },
}; };
module_platform_driver(nuc900_spi_driver);
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_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>"); MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
MODULE_DESCRIPTION("nuc900 spi driver!"); MODULE_DESCRIPTION("nuc900 spi driver!");

13
drivers/spi/spi-oc-tiny.c
View File

@ -406,18 +406,7 @@ static struct platform_driver tiny_spi_driver = {
.of_match_table = tiny_spi_match, .of_match_table = tiny_spi_match,
}, },
}; };
module_platform_driver(tiny_spi_driver);
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_DESCRIPTION("OpenCores tiny SPI driver"); MODULE_DESCRIPTION("OpenCores tiny SPI driver");
MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>"); MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>");

7
drivers/spi/spi-omap2-mcspi.c
View File

@ -1116,15 +1116,16 @@ static int __init omap2_mcspi_probe(struct platform_device *pdev)
status = -ENODEV; status = -ENODEV;
goto err1; 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), if (!request_mem_region(r->start, resource_size(r),
dev_name(&pdev->dev))) { dev_name(&pdev->dev))) {
status = -EBUSY; status = -EBUSY;
goto err1; goto err1;
} }
r->start += pdata->regs_offset;
r->end += pdata->regs_offset;
mcspi->phys = r->start;
mcspi->base = ioremap(r->start, resource_size(r)); mcspi->base = ioremap(r->start, resource_size(r));
if (!mcspi->base) { if (!mcspi->base) {
dev_dbg(&pdev->dev, "can't ioremap MCSPI\n"); dev_dbg(&pdev->dev, "can't ioremap MCSPI\n");

144
drivers/spi/spi-pl022.c
View File

@ -113,7 +113,6 @@
#define SSP_CR0_MASK_CSS_ST (0x1FUL << 16) #define SSP_CR0_MASK_CSS_ST (0x1FUL << 16)
#define SSP_CR0_MASK_FRF_ST (0x3UL << 21) #define SSP_CR0_MASK_FRF_ST (0x3UL << 21)
/* /*
* SSP Control Register 0 - SSP_CR1 * SSP Control Register 0 - SSP_CR1
*/ */
@ -283,7 +282,6 @@
#define SPI_POLLING_TIMEOUT 1000 #define SPI_POLLING_TIMEOUT 1000
/* /*
* The type of reading going on on this chip * 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 * next_transfer - Move to the Next transfer in the current spi message
* @pl022: SSP driver private data structure * @pl022: SSP driver private data structure
@ -1016,14 +1013,14 @@ static int configure_dma(struct pl022 *pl022)
dmaengine_slave_config(txchan, &tx_conf); dmaengine_slave_config(txchan, &tx_conf);
/* Create sglists for the transfers */ /* 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); 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) if (ret)
goto err_alloc_rx_sg; 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) if (ret)
goto err_alloc_tx_sg; goto err_alloc_tx_sg;
@ -1531,8 +1528,7 @@ static void pump_messages(struct work_struct *work)
/* Initial message state */ /* Initial message state */
pl022->cur_msg->state = STATE_START; pl022->cur_msg->state = STATE_START;
pl022->cur_transfer = list_entry(pl022->cur_msg->transfers.next, pl022->cur_transfer = list_entry(pl022->cur_msg->transfers.next,
struct spi_transfer, struct spi_transfer, transfer_list);
transfer_list);
/* Setup the SPI using the per chip configuration */ /* Setup the SPI using the per chip configuration */
pl022->cur_chip = spi_get_ctldata(pl022->cur_msg->spi); 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); do_interrupt_dma_transfer(pl022);
} }
static int __init init_queue(struct pl022 *pl022) static int __init init_queue(struct pl022 *pl022)
{ {
INIT_LIST_HEAD(&pl022->queue); INIT_LIST_HEAD(&pl022->queue);
@ -1560,8 +1555,8 @@ static int __init init_queue(struct pl022 *pl022)
pl022->running = false; pl022->running = false;
pl022->busy = false; pl022->busy = false;
tasklet_init(&pl022->pump_transfers, tasklet_init(&pl022->pump_transfers, pump_transfers,
pump_transfers, (unsigned long)pl022); (unsigned long)pl022);
INIT_WORK(&pl022->pump_messages, pump_messages); INIT_WORK(&pl022->pump_messages, pump_messages);
pl022->workqueue = create_singlethread_workqueue( pl022->workqueue = create_singlethread_workqueue(
@ -1572,7 +1567,6 @@ static int __init init_queue(struct pl022 *pl022)
return 0; return 0;
} }
static int start_queue(struct pl022 *pl022) static int start_queue(struct pl022 *pl022)
{ {
unsigned long flags; unsigned long flags;
@ -1595,7 +1589,6 @@ static int start_queue(struct pl022 *pl022)
return 0; return 0;
} }
static int stop_queue(struct pl022 *pl022) static int stop_queue(struct pl022 *pl022)
{ {
unsigned long flags; unsigned long flags;
@ -1791,71 +1784,70 @@ static int pl022_transfer(struct spi_device *spi, struct spi_message *msg)
return 0; return 0;
} }
static int calculate_effective_freq(struct pl022 *pl022, static inline u32 spi_rate(u32 rate, u16 cpsdvsr, u16 scr)
int freq, {
struct ssp_clock_params *clk_freq) 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 */ /* Lets calculate the frequency parameters */
u16 cpsdvsr = 2; u16 cpsdvsr = CPSDVR_MIN, scr = SCR_MIN;
u16 scr = 0; u32 rate, max_tclk, min_tclk, best_freq = 0, best_cpsdvsr = 0,
bool freq_found = false; best_scr = 0, tmp, found = 0;
u32 rate;
u32 max_tclk;
u32 min_tclk;
rate = clk_get_rate(pl022->clk); rate = clk_get_rate(pl022->clk);
/* cpsdvscr = 2 & scr 0 */ /* 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 */ /* cpsdvsr = 254 & scr = 255 */
min_tclk = (rate / (CPSDVR_MAX * (1 + SCR_MAX))); min_tclk = spi_rate(rate, CPSDVR_MAX, SCR_MAX);
if ((freq <= max_tclk) && (freq >= min_tclk)) { 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 {
dev_err(&pl022->adev->dev, dev_err(&pl022->adev->dev,
"controller data is incorrect: out of range frequency"); "controller data is incorrect: out of range frequency");
return -EINVAL; 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; return 0;
} }
/* /*
* A piece of default chip info unless the platform * A piece of default chip info unless the platform
* supplies it. * supplies it.
@ -1873,7 +1865,6 @@ static const struct pl022_config_chip pl022_default_chip_info = {
.cs_control = null_cs_control, .cs_control = null_cs_control,
}; };
/** /**
* pl022_setup - setup function registered to SPI master framework * pl022_setup - setup function registered to SPI master framework
* @spi: spi device which is requesting setup * @spi: spi device which is requesting setup
@ -1950,7 +1941,6 @@ static int pl022_setup(struct spi_device *spi)
goto err_config_params; goto err_config_params;
} }
status = verify_controller_parameters(pl022, chip_info); status = verify_controller_parameters(pl022, chip_info);
if (status) { if (status) {
dev_err(&spi->dev, "controller data is incorrect"); 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, 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->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 */ /* Save controller_state */
spi_set_ctldata(spi, chip); spi_set_ctldata(spi, chip);
@ -2116,7 +2107,6 @@ static void pl022_cleanup(struct spi_device *spi)
kfree(chip); kfree(chip);
} }
static int __devinit static int __devinit
pl022_probe(struct amba_device *adev, const struct amba_id *id) 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_start_queue:
err_init_queue: err_init_queue:
destroy_queue(pl022); destroy_queue(pl022);
pl022_dma_remove(pl022); if (platform_info->enable_dma)
pl022_dma_remove(pl022);
free_irq(adev->irq[0], pl022); free_irq(adev->irq[0], pl022);
err_no_irq: err_no_irq:
clk_unprepare(pl022->clk); clk_unprepare(pl022->clk);
@ -2277,7 +2269,9 @@ pl022_remove(struct amba_device *adev)
if (destroy_queue(pl022) != 0) if (destroy_queue(pl022) != 0)
dev_err(&adev->dev, "queue remove failed\n"); dev_err(&adev->dev, "queue remove failed\n");
load_ssp_default_config(pl022); 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); free_irq(adev->irq[0], pl022);
clk_disable(pl022->clk); clk_disable(pl022->clk);
clk_unprepare(pl022->clk); clk_unprepare(pl022->clk);
@ -2364,7 +2358,6 @@ static struct vendor_data vendor_arm = {
.loopback = true, .loopback = true,
}; };
static struct vendor_data vendor_st = { static struct vendor_data vendor_st = {
.fifodepth = 32, .fifodepth = 32,
.max_bpw = 32, .max_bpw = 32,
@ -2419,9 +2412,9 @@ static struct amba_id pl022_ids[] = {
* and 32 locations deep TX/RX FIFO but no extended * and 32 locations deep TX/RX FIFO but no extended
* CR0/CR1 register * CR0/CR1 register
*/ */
.id = 0x00080023, .id = 0x00080023,
.mask = 0xffffffff, .mask = 0xffffffff,
.data = &vendor_st_pl023, .data = &vendor_st_pl023,
}, },
{ {
.id = 0x10080023, .id = 0x10080023,
@ -2441,19 +2434,16 @@ static struct amba_driver pl022_driver = {
.remove = __devexit_p(pl022_remove), .remove = __devexit_p(pl022_remove),
}; };
static int __init pl022_init(void) static int __init pl022_init(void)
{ {
return amba_driver_register(&pl022_driver); return amba_driver_register(&pl022_driver);
} }
subsys_initcall(pl022_init); subsys_initcall(pl022_init);
static void __exit pl022_exit(void) static void __exit pl022_exit(void)
{ {
amba_driver_unregister(&pl022_driver); amba_driver_unregister(&pl022_driver);
} }
module_exit(pl022_exit); module_exit(pl022_exit);
MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>"); MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");

15
drivers/spi/spi-ppc4xx.c
View File

@ -514,7 +514,7 @@ static int __init spi_ppc4xx_of_probe(struct platform_device *op)
/* Request IRQ */ /* Request IRQ */
hw->irqnum = irq_of_parse_and_map(np, 0); hw->irqnum = irq_of_parse_and_map(np, 0);
ret = request_irq(hw->irqnum, spi_ppc4xx_int, ret = request_irq(hw->irqnum, spi_ppc4xx_int,
IRQF_DISABLED, "spi_ppc4xx_of", (void *)hw); 0, "spi_ppc4xx_of", (void *)hw);
if (ret) { if (ret) {
dev_err(dev, "unable to allocate interrupt\n"); dev_err(dev, "unable to allocate interrupt\n");
goto free_gpios; goto free_gpios;
@ -594,18 +594,7 @@ static struct platform_driver spi_ppc4xx_of_driver = {
.of_match_table = spi_ppc4xx_of_match, .of_match_table = spi_ppc4xx_of_match,
}, },
}; };
module_platform_driver(spi_ppc4xx_of_driver);
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_AUTHOR("Gary Jennejohn & Stefan Roese"); MODULE_AUTHOR("Gary Jennejohn & Stefan Roese");
MODULE_DESCRIPTION("Simple PPC4xx SPI Driver"); MODULE_DESCRIPTION("Simple PPC4xx SPI Driver");

21
drivers/spi/spi-s3c24xx.c
View File

@ -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 s3c2410_spi_info *pdata;
struct s3c24xx_spi *hw; struct s3c24xx_spi *hw;
@ -661,7 +661,7 @@ static int __init s3c24xx_spi_probe(struct platform_device *pdev)
return err; 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); 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"); MODULE_ALIAS("platform:s3c2410-spi");
static struct platform_driver s3c24xx_spi_driver = { static struct platform_driver s3c24xx_spi_driver = {
.remove = __exit_p(s3c24xx_spi_remove), .probe = s3c24xx_spi_probe,
.remove = __devexit_p(s3c24xx_spi_remove),
.driver = { .driver = {
.name = "s3c2410-spi", .name = "s3c2410-spi",
.owner = THIS_MODULE, .owner = THIS_MODULE,
.pm = S3C24XX_SPI_PMOPS, .pm = S3C24XX_SPI_PMOPS,
}, },
}; };
module_platform_driver(s3c24xx_spi_driver);
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_DESCRIPTION("S3C24XX SPI Driver"); MODULE_DESCRIPTION("S3C24XX SPI Driver");
MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>"); MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");

15
drivers/spi/spi-sh-msiof.c
View File

@ -635,7 +635,7 @@ static int sh_msiof_spi_probe(struct platform_device *pdev)
goto err2; 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); dev_name(&pdev->dev), p);
if (ret) { if (ret) {
dev_err(&pdev->dev, "unable to request irq\n"); 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, .pm = &sh_msiof_spi_dev_pm_ops,
}, },
}; };
module_platform_driver(sh_msiof_spi_drv);
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_DESCRIPTION("SuperH MSIOF SPI Master Interface Driver"); MODULE_DESCRIPTION("SuperH MSIOF SPI Master Interface Driver");
MODULE_AUTHOR("Magnus Damm"); MODULE_AUTHOR("Magnus Damm");

13
drivers/spi/spi-sh-sci.c
View File

@ -186,18 +186,7 @@ static struct platform_driver sh_sci_spi_drv = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
}, },
}; };
module_platform_driver(sh_sci_spi_drv);
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_DESCRIPTION("SH SCI SPI Driver"); MODULE_DESCRIPTION("SH SCI SPI Driver");
MODULE_AUTHOR("Magnus Damm <damm@opensource.se>"); MODULE_AUTHOR("Magnus Damm <damm@opensource.se>");

15
drivers/spi/spi-sh.c
View File

@ -484,7 +484,7 @@ static int __devinit spi_sh_probe(struct platform_device *pdev)
goto error2; 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) { if (ret < 0) {
dev_err(&pdev->dev, "request_irq error\n"); dev_err(&pdev->dev, "request_irq error\n");
goto error3; goto error3;
@ -524,18 +524,7 @@ static struct platform_driver spi_sh_driver = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
}, },
}; };
module_platform_driver(spi_sh_driver);
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_DESCRIPTION("SH SPI bus driver"); MODULE_DESCRIPTION("SH SPI bus driver");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

13
drivers/spi/spi-stmp.c
View File

@ -659,19 +659,8 @@ static struct platform_driver stmp_spi_driver = {
.suspend = stmp_spi_suspend, .suspend = stmp_spi_suspend,
.resume = stmp_spi_resume, .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(pio, int, S_IRUGO);
module_param(clock, int, S_IRUGO); module_param(clock, int, S_IRUGO);
MODULE_AUTHOR("dmitry pervushin <dpervushin@embeddedalley.com>"); MODULE_AUTHOR("dmitry pervushin <dpervushin@embeddedalley.com>");

17
drivers/spi/spi-tegra.c
View File

@ -18,6 +18,7 @@
*/ */
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/err.h> #include <linux/err.h>
#include <linux/platform_device.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; 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_master *master;
struct spi_tegra_data *tspi; struct spi_tegra_data *tspi;
@ -612,19 +613,9 @@ static struct platform_driver spi_tegra_driver = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.of_match_table = spi_tegra_of_match_table, .of_match_table = spi_tegra_of_match_table,
}, },
.probe = spi_tegra_probe,
.remove = __devexit_p(spi_tegra_remove), .remove = __devexit_p(spi_tegra_remove),
}; };
module_platform_driver(spi_tegra_driver);
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_LICENSE("GPL"); MODULE_LICENSE("GPL");

13
drivers/spi/spi-ti-ssp.c
View File

@ -383,18 +383,7 @@ static struct platform_driver ti_ssp_spi_driver = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
}, },
}; };
module_platform_driver(ti_ssp_spi_driver);
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_DESCRIPTION("SSP SPI Master"); MODULE_DESCRIPTION("SSP SPI Master");
MODULE_AUTHOR("Cyril Chemparathy"); MODULE_AUTHOR("Cyril Chemparathy");

13
drivers/spi/spi-xilinx.c
View File

@ -538,18 +538,7 @@ static struct platform_driver xilinx_spi_driver = {
.of_match_table = xilinx_spi_of_match, .of_match_table = xilinx_spi_of_match,
}, },
}; };
module_platform_driver(xilinx_spi_driver);
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_AUTHOR("MontaVista Software, Inc. <source@mvista.com>"); MODULE_AUTHOR("MontaVista Software, Inc. <source@mvista.com>");
MODULE_DESCRIPTION("Xilinx SPI driver"); MODULE_DESCRIPTION("Xilinx SPI driver");

12
drivers/tty/serial/of_serial.c
View File

@ -200,17 +200,7 @@ static struct platform_driver of_platform_serial_driver = {
.remove = of_platform_serial_remove, .remove = of_platform_serial_remove,
}; };
static int __init of_platform_serial_init(void) module_platform_driver(of_platform_serial_driver);
{
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_AUTHOR("Arnd Bergmann <arnd@arndb.de>"); MODULE_AUTHOR("Arnd Bergmann <arnd@arndb.de>");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

17
include/linux/platform_device.h
View File

@ -190,6 +190,23 @@ static inline void platform_set_drvdata(struct platform_device *pdev, void *data
dev_set_drvdata(&pdev->dev, 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, extern struct platform_device *platform_create_bundle(struct platform_driver *driver,
int (*probe)(struct platform_device *), int (*probe)(struct platform_device *),
struct resource *res, unsigned int n_res, struct resource *res, unsigned int n_res,