From: Dirk Brandewie <[email protected]> The file naming convention for drivers in the SPI subsystem is now being enforced update internal naming convention to match file naming.
Signed-off-by: Dirk Brandewie <[email protected]> --- drivers/spi/spi-dw-mid.c | 26 +++--- drivers/spi/spi-dw-mmio.c | 38 +++++----- drivers/spi/spi-dw-pci.c | 34 ++++---- drivers/spi/spi-dw.c | 196 ++++++++++++++++++++++---------------------- drivers/spi/spi-dw.h | 48 ++++++------ 5 files changed, 171 insertions(+), 171 deletions(-) diff --git a/drivers/spi/spi-dw-mid.c b/drivers/spi/spi-dw-mid.c index 130e555..7659cef 100644 --- a/drivers/spi/spi-dw-mid.c +++ b/drivers/spi/spi-dw-mid.c @@ -36,12 +36,12 @@ struct mid_dma { static bool mid_spi_dma_chan_filter(struct dma_chan *chan, void *param) { - struct dw_spi *dws = param; + struct spi_dw *dws = param; return dws->dmac && (&dws->dmac->dev == chan->device->dev); } -static int mid_spi_dma_init(struct dw_spi *dws) +static int mid_spi_dma_init(struct spi_dw *dws) { struct mid_dma *dw_dma = dws->dma_priv; struct intel_mid_dma_slave *rxs, *txs; @@ -86,7 +86,7 @@ err_exit: } -static void mid_spi_dma_exit(struct dw_spi *dws) +static void mid_spi_dma_exit(struct spi_dw *dws) { dma_release_channel(dws->txchan); dma_release_channel(dws->rxchan); @@ -97,16 +97,16 @@ static void mid_spi_dma_exit(struct dw_spi *dws) * callback for rx/tx channel will each increment it by 1. * Reaching 2 means the whole spi transaction is done. */ -static void dw_spi_dma_done(void *arg) +static void spi_dw_dma_done(void *arg) { - struct dw_spi *dws = arg; + struct spi_dw *dws = arg; if (++dws->dma_chan_done != 2) return; - dw_spi_xfer_done(dws); + spi_dw_xfer_done(dws); } -static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change) +static int mid_spi_dma_transfer(struct spi_dw *dws, int cs_change) { struct dma_async_tx_descriptor *txdesc = NULL, *rxdesc = NULL; struct dma_chan *txchan, *rxchan; @@ -115,7 +115,7 @@ 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); + spi_dw_enable_chip(dws, 0); dw_writew(dws, dmardlr, 0xf); dw_writew(dws, dmatdlr, 0x10); if (dws->tx_dma) @@ -123,7 +123,7 @@ static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change) if (dws->rx_dma) dma_ctrl |= 0x1; dw_writew(dws, dmacr, dma_ctrl); - spi_enable_chip(dws, 1); + spi_dw_enable_chip(dws, 1); } dws->dma_chan_done = 0; @@ -149,7 +149,7 @@ static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change) 1, DMA_TO_DEVICE, DMA_PREP_INTERRUPT | DMA_COMPL_SKIP_DEST_UNMAP); - txdesc->callback = dw_spi_dma_done; + txdesc->callback = spi_dw_dma_done; txdesc->callback_param = dws; /* 3. Prepare the RX dma transfer */ @@ -171,7 +171,7 @@ static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change) 1, DMA_FROM_DEVICE, DMA_PREP_INTERRUPT | DMA_COMPL_SKIP_DEST_UNMAP); - rxdesc->callback = dw_spi_dma_done; + rxdesc->callback = spi_dw_dma_done; rxdesc->callback_param = dws; /* rx must be started before tx due to spi instinct */ @@ -180,7 +180,7 @@ static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change) return 0; } -static struct dw_spi_dma_ops mid_dma_ops = { +static struct spi_dw_dma_ops mid_dma_ops = { .dma_init = mid_spi_dma_init, .dma_exit = mid_spi_dma_exit, .dma_transfer = mid_spi_dma_transfer, @@ -198,7 +198,7 @@ static struct dw_spi_dma_ops mid_dma_ops = { #define CLK_SPI_CDIV_MASK 0x00000e00 #define CLK_SPI_DISABLE_OFFSET 8 -int dw_spi_mid_init(struct dw_spi *dws) +int spi_dw_mid_init(struct spi_dw *dws) { u32 *clk_reg, clk_cdiv; diff --git a/drivers/spi/spi-dw-mmio.c b/drivers/spi/spi-dw-mmio.c index 34eb665..d98d28d 100644 --- a/drivers/spi/spi-dw-mmio.c +++ b/drivers/spi/spi-dw-mmio.c @@ -18,21 +18,21 @@ #include "spi-dw.h" -#define DRIVER_NAME "dw_spi_mmio" +#define DRIVER_NAME "spi_dw_mmio" -struct dw_spi_mmio { - struct dw_spi dws; +struct spi_dw_mmio { + struct spi_dw dws; struct clk *clk; }; -static int __devinit dw_spi_mmio_probe(struct platform_device *pdev) +static int __devinit spi_dw_mmio_probe(struct platform_device *pdev) { - struct dw_spi_mmio *dwsmmio; - struct dw_spi *dws; + struct spi_dw_mmio *dwsmmio; + struct spi_dw *dws; struct resource *mem, *ioarea; int ret; - dwsmmio = kzalloc(sizeof(struct dw_spi_mmio), GFP_KERNEL); + dwsmmio = kzalloc(sizeof(struct spi_dw_mmio), GFP_KERNEL); if (!dwsmmio) { ret = -ENOMEM; goto err_end; @@ -82,7 +82,7 @@ static int __devinit dw_spi_mmio_probe(struct platform_device *pdev) dws->num_cs = 4; dws->max_freq = clk_get_rate(dwsmmio->clk); - ret = dw_spi_add_host(dws); + ret = spi_dw_add_host(dws); if (ret) goto err_clk; @@ -105,9 +105,9 @@ err_end: return ret; } -static int __devexit dw_spi_mmio_remove(struct platform_device *pdev) +static int __devexit spi_dw_mmio_remove(struct platform_device *pdev) { - struct dw_spi_mmio *dwsmmio = platform_get_drvdata(pdev); + struct spi_dw_mmio *dwsmmio = platform_get_drvdata(pdev); struct resource *mem; platform_set_drvdata(pdev, NULL); @@ -117,7 +117,7 @@ static int __devexit dw_spi_mmio_remove(struct platform_device *pdev) dwsmmio->clk = NULL; free_irq(dwsmmio->dws.irq, &dwsmmio->dws); - dw_spi_remove_host(&dwsmmio->dws); + spi_dw_remove_host(&dwsmmio->dws); iounmap(dwsmmio->dws.regs); kfree(dwsmmio); @@ -126,25 +126,25 @@ static int __devexit dw_spi_mmio_remove(struct platform_device *pdev) return 0; } -static struct platform_driver dw_spi_mmio_driver = { - .remove = __devexit_p(dw_spi_mmio_remove), +static struct platform_driver spi_dw_mmio_driver = { + .remove = __devexit_p(spi_dw_mmio_remove), .driver = { .name = DRIVER_NAME, .owner = THIS_MODULE, }, }; -static int __init dw_spi_mmio_init(void) +static int __init spi_dw_mmio_init(void) { - return platform_driver_probe(&dw_spi_mmio_driver, dw_spi_mmio_probe); + return platform_driver_probe(&spi_dw_mmio_driver, spi_dw_mmio_probe); } -module_init(dw_spi_mmio_init); +module_init(spi_dw_mmio_init); -static void __exit dw_spi_mmio_exit(void) +static void __exit spi_dw_mmio_exit(void) { - platform_driver_unregister(&dw_spi_mmio_driver); + platform_driver_unregister(&spi_dw_mmio_driver); } -module_exit(dw_spi_mmio_exit); +module_exit(spi_dw_mmio_exit); MODULE_AUTHOR("Jean-Hugues Deschenes <[email protected]>"); MODULE_DESCRIPTION("Memory-mapped I/O interface driver for DW SPI Core"); diff --git a/drivers/spi/spi-dw-pci.c b/drivers/spi/spi-dw-pci.c index c5f37f0..af9db5c 100644 --- a/drivers/spi/spi-dw-pci.c +++ b/drivers/spi/spi-dw-pci.c @@ -24,18 +24,18 @@ #include "spi-dw.h" -#define DRIVER_NAME "dw_spi_pci" +#define DRIVER_NAME "spi_dw_pci" -struct dw_spi_pci { +struct spi_dw_pci { struct pci_dev *pdev; - struct dw_spi dws; + struct spi_dw dws; }; static int __devinit spi_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { - struct dw_spi_pci *dwpci; - struct dw_spi *dws; + struct spi_dw_pci *dwpci; + struct spi_dw *dws; int pci_bar = 0; int ret; @@ -46,7 +46,7 @@ static int __devinit spi_pci_probe(struct pci_dev *pdev, if (ret) return ret; - dwpci = kzalloc(sizeof(struct dw_spi_pci), GFP_KERNEL); + dwpci = kzalloc(sizeof(struct spi_dw_pci), GFP_KERNEL); if (!dwpci) { ret = -ENOMEM; goto err_disable; @@ -80,12 +80,12 @@ static int __devinit spi_pci_probe(struct pci_dev *pdev, * clock rate, FIFO depth. */ if (pdev->device == 0x0800) { - ret = dw_spi_mid_init(dws); + ret = spi_dw_mid_init(dws); if (ret) goto err_unmap; } - ret = dw_spi_add_host(dws); + ret = spi_dw_add_host(dws); if (ret) goto err_unmap; @@ -106,10 +106,10 @@ err_disable: static void __devexit spi_pci_remove(struct pci_dev *pdev) { - struct dw_spi_pci *dwpci = pci_get_drvdata(pdev); + struct spi_dw_pci *dwpci = pci_get_drvdata(pdev); pci_set_drvdata(pdev, NULL); - dw_spi_remove_host(&dwpci->dws); + spi_dw_remove_host(&dwpci->dws); iounmap(dwpci->dws.regs); pci_release_region(pdev, 0); kfree(dwpci); @@ -119,10 +119,10 @@ static void __devexit spi_pci_remove(struct pci_dev *pdev) #ifdef CONFIG_PM static int spi_suspend(struct pci_dev *pdev, pm_message_t state) { - struct dw_spi_pci *dwpci = pci_get_drvdata(pdev); + struct spi_dw_pci *dwpci = pci_get_drvdata(pdev); int ret; - ret = dw_spi_suspend_host(&dwpci->dws); + ret = spi_dw_suspend_host(&dwpci->dws); if (ret) return ret; pci_save_state(pdev); @@ -133,7 +133,7 @@ static int spi_suspend(struct pci_dev *pdev, pm_message_t state) static int spi_resume(struct pci_dev *pdev) { - struct dw_spi_pci *dwpci = pci_get_drvdata(pdev); + struct spi_dw_pci *dwpci = pci_get_drvdata(pdev); int ret; pci_set_power_state(pdev, PCI_D0); @@ -141,7 +141,7 @@ static int spi_resume(struct pci_dev *pdev) ret = pci_enable_device(pdev); if (ret) return ret; - return dw_spi_resume_host(&dwpci->dws); + return spi_dw_resume_host(&dwpci->dws); } #else #define spi_suspend NULL @@ -154,7 +154,7 @@ static const struct pci_device_id pci_ids[] __devinitdata = { {}, }; -static struct pci_driver dw_spi_driver = { +static struct pci_driver spi_dw_driver = { .name = DRIVER_NAME, .id_table = pci_ids, .probe = spi_pci_probe, @@ -165,12 +165,12 @@ static struct pci_driver dw_spi_driver = { static int __init mrst_spi_init(void) { - return pci_register_driver(&dw_spi_driver); + return pci_register_driver(&spi_dw_driver); } static void __exit mrst_spi_exit(void) { - pci_unregister_driver(&dw_spi_driver); + pci_unregister_driver(&spi_dw_driver); } module_init(mrst_spi_init); diff --git a/drivers/spi/spi-dw.c b/drivers/spi/spi-dw.c index 61f7ed8..fb09a9d 100644 --- a/drivers/spi/spi-dw.c +++ b/drivers/spi/spi-dw.c @@ -59,17 +59,17 @@ struct chip_data { }; #ifdef CONFIG_DEBUG_FS -static int spi_show_regs_open(struct inode *inode, struct file *file) +static int spi_dw_show_regs_open(struct inode *inode, struct file *file) { file->private_data = inode->i_private; return 0; } #define SPI_REGS_BUFSIZE 1024 -static ssize_t spi_show_regs(struct file *file, char __user *user_buf, +static ssize_t spi_dw_show_regs(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { - struct dw_spi *dws; + struct spi_dw *dws; char *buf; u32 len = 0; ssize_t ret; @@ -81,7 +81,7 @@ static ssize_t spi_show_regs(struct file *file, char __user *user_buf, return 0; len += snprintf(buf + len, SPI_REGS_BUFSIZE - len, - "MRST SPI0 registers:\n"); + "DW SPI0 registers:\n"); len += snprintf(buf + len, SPI_REGS_BUFSIZE - len, "=================================\n"); len += snprintf(buf + len, SPI_REGS_BUFSIZE - len, @@ -122,43 +122,43 @@ static ssize_t spi_show_regs(struct file *file, char __user *user_buf, return ret; } -static const struct file_operations mrst_spi_regs_ops = { +static const struct file_operations spi_dw_regs_ops = { .owner = THIS_MODULE, - .open = spi_show_regs_open, - .read = spi_show_regs, + .open = spi_dw_show_regs_open, + .read = spi_dw_show_regs, .llseek = default_llseek, }; -static int mrst_spi_debugfs_init(struct dw_spi *dws) +static int spi_dw_debugfs_init(struct spi_dw *dws) { dws->debugfs = debugfs_create_dir("mrst_spi", NULL); if (!dws->debugfs) return -ENOMEM; debugfs_create_file("registers", S_IFREG | S_IRUGO, - dws->debugfs, (void *)dws, &mrst_spi_regs_ops); + dws->debugfs, (void *)dws, &spi_dw_regs_ops); return 0; } -static void mrst_spi_debugfs_remove(struct dw_spi *dws) +static void spi_dw_debugfs_remove(struct spi_dw *dws) { if (dws->debugfs) debugfs_remove_recursive(dws->debugfs); } #else -static inline int mrst_spi_debugfs_init(struct dw_spi *dws) +static inline int spi_dw_debugfs_init(struct spi_dw *dws) { return 0; } -static inline void mrst_spi_debugfs_remove(struct dw_spi *dws) +static inline void spi_dw_debugfs_remove(struct spi_dw *dws) { } #endif /* CONFIG_DEBUG_FS */ /* Return the max entries we can fill into tx fifo */ -static inline u32 tx_max(struct dw_spi *dws) +static inline u32 tx_max(struct spi_dw *dws) { u32 tx_left, tx_room, rxtx_gap; @@ -180,14 +180,14 @@ static inline u32 tx_max(struct dw_spi *dws) } /* Return the max entries we should read out of rx fifo */ -static inline u32 rx_max(struct dw_spi *dws) +static inline u32 rx_max(struct spi_dw *dws) { u32 rx_left = (dws->rx_end - dws->rx) / dws->n_bytes; return min(rx_left, (u32)dw_readw(dws, rxflr)); } -static void dw_writer(struct dw_spi *dws) +static void spi_dw_writer(struct spi_dw *dws) { u32 max = tx_max(dws); u16 txw = 0; @@ -205,7 +205,7 @@ static void dw_writer(struct dw_spi *dws) } } -static void dw_reader(struct dw_spi *dws) +static void spi_dw_reader(struct spi_dw *dws) { u32 max = rx_max(dws); u16 rxw; @@ -223,7 +223,7 @@ static void dw_reader(struct dw_spi *dws) } } -static void *next_transfer(struct dw_spi *dws) +static void *spi_dw_next_transfer(struct spi_dw *dws) { struct spi_message *msg = dws->cur_msg; struct spi_transfer *trans = dws->cur_transfer; @@ -244,7 +244,7 @@ static void *next_transfer(struct dw_spi *dws) * a dma-capable memory, and this func just need translate * the virt addr to physical */ -static int map_dma_buffers(struct dw_spi *dws) +static int spi_dw_map_dma_buffers(struct spi_dw *dws) { if (!dws->cur_msg->is_dma_mapped || !dws->dma_inited @@ -262,7 +262,7 @@ static int map_dma_buffers(struct dw_spi *dws) } /* Caller already set message->status; dma and pio irqs are blocked */ -static void giveback(struct dw_spi *dws) +static void spi_dw_giveback(struct spi_dw *dws) { struct spi_transfer *last_transfer; unsigned long flags; @@ -290,34 +290,34 @@ static void giveback(struct dw_spi *dws) msg->complete(msg->context); } -static void int_error_stop(struct dw_spi *dws, const char *msg) +static void spi_dw_int_error_stop(struct spi_dw *dws, const char *msg) { /* Stop the hw */ - spi_enable_chip(dws, 0); + spi_dw_enable_chip(dws, 0); dev_err(&dws->master->dev, "%s\n", msg); dws->cur_msg->state = ERROR_STATE; tasklet_schedule(&dws->pump_transfers); } -void dw_spi_xfer_done(struct dw_spi *dws) +void spi_dw_xfer_done(struct spi_dw *dws) { /* Update total byte transferred return count actual bytes read */ dws->cur_msg->actual_length += dws->len; /* Move to next transfer */ - dws->cur_msg->state = next_transfer(dws); + dws->cur_msg->state = spi_dw_next_transfer(dws); /* Handle end of message */ if (dws->cur_msg->state == DONE_STATE) { dws->cur_msg->status = 0; - giveback(dws); + spi_dw_giveback(dws); } else tasklet_schedule(&dws->pump_transfers); } -EXPORT_SYMBOL_GPL(dw_spi_xfer_done); +EXPORT_SYMBOL_GPL(spi_dw_xfer_done); -static irqreturn_t interrupt_transfer(struct dw_spi *dws) +static irqreturn_t spi_dw_interrupt_transfer(struct spi_dw *dws) { u16 irq_status = dw_readw(dws, isr); @@ -326,36 +326,36 @@ static irqreturn_t interrupt_transfer(struct dw_spi *dws) dw_readw(dws, txoicr); dw_readw(dws, rxoicr); dw_readw(dws, rxuicr); - int_error_stop(dws, "interrupt_transfer: fifo overrun/underrun"); + spi_dw_int_error_stop(dws, "spi-dw: fifo overrun/underrun"); return IRQ_HANDLED; } - dw_reader(dws); + spi_dw_reader(dws); if (dws->rx_end == dws->rx) { - spi_mask_intr(dws, SPI_INT_TXEI); - dw_spi_xfer_done(dws); + spi_dw_mask_intr(dws, SPI_INT_TXEI); + spi_dw_xfer_done(dws); return IRQ_HANDLED; } if (irq_status & SPI_INT_TXEI) { - spi_mask_intr(dws, SPI_INT_TXEI); - dw_writer(dws); + spi_dw_mask_intr(dws, SPI_INT_TXEI); + spi_dw_writer(dws); /* Enable TX irq always, it will be disabled when RX finished */ - spi_umask_intr(dws, SPI_INT_TXEI); + spi_dw_umask_intr(dws, SPI_INT_TXEI); } return IRQ_HANDLED; } -static irqreturn_t dw_spi_irq(int irq, void *dev_id) +static irqreturn_t spi_dw_irq(int irq, void *dev_id) { - struct dw_spi *dws = dev_id; + struct spi_dw *dws = dev_id; u16 irq_status = dw_readw(dws, isr) & 0x3f; if (!irq_status) return IRQ_NONE; if (!dws->cur_msg) { - spi_mask_intr(dws, SPI_INT_TXEI); + spi_dw_mask_intr(dws, SPI_INT_TXEI); return IRQ_HANDLED; } @@ -363,20 +363,20 @@ static irqreturn_t dw_spi_irq(int irq, void *dev_id) } /* Must be called inside pump_transfers() */ -static void poll_transfer(struct dw_spi *dws) +static void spi_dw_poll_transfer(struct spi_dw *dws) { do { - dw_writer(dws); - dw_reader(dws); + spi_dw_writer(dws); + spi_dw_reader(dws); cpu_relax(); } while (dws->rx_end > dws->rx); - dw_spi_xfer_done(dws); + spi_dw_xfer_done(dws); } -static void pump_transfers(unsigned long data) +static void spi_dw_pump_transfers(unsigned long data) { - struct dw_spi *dws = (struct dw_spi *)data; + struct spi_dw *dws = (struct spi_dw *)data; struct spi_message *message = NULL; struct spi_transfer *transfer = NULL; struct spi_transfer *previous = NULL; @@ -496,7 +496,7 @@ static void pump_transfers(unsigned long data) } /* Check if current transfer is a DMA transaction */ - dws->dma_mapped = map_dma_buffers(dws); + dws->dma_mapped = spi_dw_map_dma_buffers(dws); /* * Interrupt mode @@ -508,7 +508,7 @@ static void pump_transfers(unsigned long data) txint_level = (templen > txint_level) ? txint_level : templen; imask |= SPI_INT_TXEI | SPI_INT_TXOI | SPI_INT_RXUI | SPI_INT_RXOI; - dws->transfer_handler = interrupt_transfer; + dws->transfer_handler = spi_dw_interrupt_transfer; } /* @@ -518,22 +518,22 @@ static void pump_transfers(unsigned long data) * 3. control value changes */ if (dw_readw(dws, ctrl0) != cr0 || cs_change || clk_div || imask) { - spi_enable_chip(dws, 0); + spi_dw_enable_chip(dws, 0); if (dw_readw(dws, ctrl0) != cr0) dw_writew(dws, ctrl0, cr0); - spi_set_clk(dws, clk_div ? clk_div : chip->clk_div); - spi_chip_sel(dws, spi->chip_select); + spi_dw_set_clk(dws, clk_div ? clk_div : chip->clk_div); + spi_dw_chip_sel(dws, spi->chip_select); /* Set the interrupt mask, for poll mode just disable all int */ - spi_mask_intr(dws, 0xff); + spi_dw_mask_intr(dws, 0xff); if (imask) - spi_umask_intr(dws, imask); + spi_dw_umask_intr(dws, imask); if (txint_level) dw_writew(dws, txfltr, txint_level); - spi_enable_chip(dws, 1); + spi_dw_enable_chip(dws, 1); if (cs_change) dws->prev_chip = chip; } @@ -542,19 +542,19 @@ static void pump_transfers(unsigned long data) dws->dma_ops->dma_transfer(dws, cs_change); if (chip->poll_mode) - poll_transfer(dws); + spi_dw_poll_transfer(dws); return; early_exit: - giveback(dws); + spi_dw_giveback(dws); return; } -static void pump_messages(struct work_struct *work) +static void spi_dw_pump_messages(struct work_struct *work) { - struct dw_spi *dws = - container_of(work, struct dw_spi, pump_messages); + struct spi_dw *dws = + container_of(work, struct spi_dw, pump_messages); unsigned long flags; /* Lock queue and check for queue work */ @@ -590,9 +590,9 @@ static void pump_messages(struct work_struct *work) } /* spi_device use this to queue in their spi_msg */ -static int dw_spi_transfer(struct spi_device *spi, struct spi_message *msg) +static int spi_dw_transfer(struct spi_device *spi, struct spi_message *msg) { - struct dw_spi *dws = spi_master_get_devdata(spi->master); + struct spi_dw *dws = spi_master_get_devdata(spi->master); unsigned long flags; spin_lock_irqsave(&dws->lock, flags); @@ -616,7 +616,7 @@ static int dw_spi_transfer(struct spi_device *spi, struct spi_message *msg) else { /* If no other data transaction in air, just go */ spin_unlock_irqrestore(&dws->lock, flags); - pump_messages(&dws->pump_messages); + spi_dw_pump_messages(&dws->pump_messages); return 0; } } @@ -626,7 +626,7 @@ static int dw_spi_transfer(struct spi_device *spi, struct spi_message *msg) } /* This may be called twice for each spi dev */ -static int dw_spi_setup(struct spi_device *spi) +static int spi_dw_setup(struct spi_device *spi) { struct dw_spi_chip *chip_info = NULL; struct chip_data *chip; @@ -692,13 +692,13 @@ static int dw_spi_setup(struct spi_device *spi) return 0; } -static void dw_spi_cleanup(struct spi_device *spi) +static void spi_dw_cleanup(struct spi_device *spi) { struct chip_data *chip = spi_get_ctldata(spi); kfree(chip); } -static int __devinit init_queue(struct dw_spi *dws) +static int __devinit spi_dw_init_queue(struct spi_dw *dws) { INIT_LIST_HEAD(&dws->queue); spin_lock_init(&dws->lock); @@ -707,9 +707,9 @@ static int __devinit init_queue(struct dw_spi *dws) dws->busy = 0; tasklet_init(&dws->pump_transfers, - pump_transfers, (unsigned long)dws); + spi_dw_pump_transfers, (unsigned long)dws); - INIT_WORK(&dws->pump_messages, pump_messages); + INIT_WORK(&dws->pump_messages, spi_dw_pump_messages); dws->workqueue = create_singlethread_workqueue( dev_name(dws->master->dev.parent)); if (dws->workqueue == NULL) @@ -718,7 +718,7 @@ static int __devinit init_queue(struct dw_spi *dws) return 0; } -static int start_queue(struct dw_spi *dws) +static int spi_dw_start_queue(struct spi_dw *dws) { unsigned long flags; @@ -741,7 +741,7 @@ static int start_queue(struct dw_spi *dws) return 0; } -static int stop_queue(struct dw_spi *dws) +static int spi_dw_stop_queue(struct spi_dw *dws) { unsigned long flags; unsigned limit = 50; @@ -762,11 +762,11 @@ static int stop_queue(struct dw_spi *dws) return status; } -static int destroy_queue(struct dw_spi *dws) +static int destroy_queue(struct spi_dw *dws) { int status; - status = stop_queue(dws); + status = spi_dw_stop_queue(dws); if (status != 0) return status; destroy_workqueue(dws->workqueue); @@ -774,11 +774,11 @@ static int destroy_queue(struct dw_spi *dws) } /* Restart the controller, disable all interrupts, clean rx fifo */ -static void spi_hw_init(struct dw_spi *dws) +static void spi_dw_hw_init(struct spi_dw *dws) { - spi_enable_chip(dws, 0); - spi_mask_intr(dws, 0xff); - spi_enable_chip(dws, 1); + spi_dw_enable_chip(dws, 0); + spi_dw_mask_intr(dws, 0xff); + spi_dw_enable_chip(dws, 1); /* * Try to detect the FIFO depth if not set by interface driver, @@ -797,7 +797,7 @@ static void spi_hw_init(struct dw_spi *dws) } } -int __devinit dw_spi_add_host(struct dw_spi *dws) +int __devinit spi_dw_add_host(struct spi_dw *dws) { struct spi_master *master; int ret; @@ -816,8 +816,8 @@ int __devinit dw_spi_add_host(struct dw_spi *dws) dws->dma_inited = 0; dws->dma_addr = (dma_addr_t)(dws->paddr + 0x60); - ret = request_irq(dws->irq, dw_spi_irq, IRQF_SHARED, - "dw_spi", dws); + ret = request_irq(dws->irq, spi_dw_irq, IRQF_SHARED, + "spi_dw", dws); if (ret < 0) { dev_err(&master->dev, "can not get IRQ\n"); goto err_free_master; @@ -826,12 +826,12 @@ int __devinit dw_spi_add_host(struct dw_spi *dws) master->mode_bits = SPI_CPOL | SPI_CPHA; master->bus_num = dws->bus_num; master->num_chipselect = dws->num_cs; - master->cleanup = dw_spi_cleanup; - master->setup = dw_spi_setup; - master->transfer = dw_spi_transfer; + master->cleanup = spi_dw_cleanup; + master->setup = spi_dw_setup; + master->transfer = spi_dw_transfer; /* Basic HW init */ - spi_hw_init(dws); + spi_dw_hw_init(dws); if (dws->dma_ops && dws->dma_ops->dma_init) { ret = dws->dma_ops->dma_init(dws); @@ -842,12 +842,12 @@ int __devinit dw_spi_add_host(struct dw_spi *dws) } /* Initial and start queue */ - ret = init_queue(dws); + ret = spi_dw_init_queue(dws); if (ret) { dev_err(&master->dev, "problem initializing queue\n"); goto err_diable_hw; } - ret = start_queue(dws); + ret = spi_dw_start_queue(dws); if (ret) { dev_err(&master->dev, "problem starting queue\n"); goto err_diable_hw; @@ -860,7 +860,7 @@ int __devinit dw_spi_add_host(struct dw_spi *dws) goto err_queue_alloc; } - mrst_spi_debugfs_init(dws); + spi_dw_debugfs_init(dws); return 0; err_queue_alloc: @@ -868,65 +868,65 @@ err_queue_alloc: if (dws->dma_ops && dws->dma_ops->dma_exit) dws->dma_ops->dma_exit(dws); err_diable_hw: - spi_enable_chip(dws, 0); + spi_dw_enable_chip(dws, 0); free_irq(dws->irq, dws); err_free_master: spi_master_put(master); exit: return ret; } -EXPORT_SYMBOL_GPL(dw_spi_add_host); +EXPORT_SYMBOL_GPL(spi_dw_add_host); -void __devexit dw_spi_remove_host(struct dw_spi *dws) +void __devexit spi_dw_remove_host(struct spi_dw *dws) { int status = 0; if (!dws) return; - mrst_spi_debugfs_remove(dws); + spi_dw_debugfs_remove(dws); /* Remove the queue */ status = destroy_queue(dws); if (status != 0) - dev_err(&dws->master->dev, "dw_spi_remove: workqueue will not " + dev_err(&dws->master->dev, "spi_dw_remove: workqueue will not " "complete, message memory not freed\n"); if (dws->dma_ops && dws->dma_ops->dma_exit) dws->dma_ops->dma_exit(dws); - spi_enable_chip(dws, 0); + spi_dw_enable_chip(dws, 0); /* Disable clk */ - spi_set_clk(dws, 0); + spi_dw_set_clk(dws, 0); free_irq(dws->irq, dws); /* Disconnect from the SPI framework */ spi_unregister_master(dws->master); } -EXPORT_SYMBOL_GPL(dw_spi_remove_host); +EXPORT_SYMBOL_GPL(spi_dw_remove_host); -int dw_spi_suspend_host(struct dw_spi *dws) +int spi_dw_suspend_host(struct spi_dw *dws) { int ret = 0; - ret = stop_queue(dws); + ret = spi_dw_stop_queue(dws); if (ret) return ret; - spi_enable_chip(dws, 0); - spi_set_clk(dws, 0); + spi_dw_enable_chip(dws, 0); + spi_dw_set_clk(dws, 0); return ret; } -EXPORT_SYMBOL_GPL(dw_spi_suspend_host); +EXPORT_SYMBOL_GPL(spi_dw_suspend_host); -int dw_spi_resume_host(struct dw_spi *dws) +int spi_dw_resume_host(struct spi_dw *dws) { int ret; - spi_hw_init(dws); - ret = start_queue(dws); + spi_dw_hw_init(dws); + ret = spi_dw_start_queue(dws); if (ret) dev_err(&dws->master->dev, "fail to start queue (%d)\n", ret); return ret; } -EXPORT_SYMBOL_GPL(dw_spi_resume_host); +EXPORT_SYMBOL_GPL(spi_dw_resume_host); MODULE_AUTHOR("Feng Tang <[email protected]>"); MODULE_DESCRIPTION("Driver for DesignWare SPI controller core"); diff --git a/drivers/spi/spi-dw.h b/drivers/spi/spi-dw.h index 92bee30..83b9a59 100644 --- a/drivers/spi/spi-dw.h +++ b/drivers/spi/spi-dw.h @@ -51,7 +51,7 @@ #define SPI_INT_THRESHOLD 32 -struct dw_spi_reg { +struct spi_dw_reg { u32 ctrl0; u32 ctrl1; u32 ssienr; @@ -80,14 +80,14 @@ struct dw_spi_reg { though only low 16 bits matters */ } __packed; -struct dw_spi; -struct dw_spi_dma_ops { - int (*dma_init)(struct dw_spi *dws); - void (*dma_exit)(struct dw_spi *dws); - int (*dma_transfer)(struct dw_spi *dws, int cs_change); +struct spi_dw; +struct spi_dw_dma_ops { + int (*dma_init)(struct spi_dw *dws); + void (*dma_exit)(struct spi_dw *dws); + int (*dma_transfer)(struct spi_dw *dws, int cs_change); }; -struct dw_spi { +struct spi_dw { struct spi_master *master; struct spi_device *cur_dev; struct device *parent_dev; @@ -133,7 +133,7 @@ struct dw_spi { u8 max_bits_per_word; /* maxim is 16b */ u32 dma_width; int cs_change; - irqreturn_t (*transfer_handler)(struct dw_spi *dws); + irqreturn_t (*transfer_handler)(struct spi_dw *dws); void (*cs_control)(u32 command); /* Dma info */ @@ -145,7 +145,7 @@ struct dw_spi { int dma_chan_done; struct device *dma_dev; dma_addr_t dma_addr; /* phy address of the Data register */ - struct dw_spi_dma_ops *dma_ops; + struct spi_dw_dma_ops *dma_ops; void *dma_priv; /* platform relate info */ struct pci_dev *dmac; @@ -157,25 +157,25 @@ struct dw_spi { }; #define dw_readl(dw, name) \ - __raw_readl(&(((struct dw_spi_reg *)dw->regs)->name)) + __raw_readl(&(((struct spi_dw_reg *)dw->regs)->name)) #define dw_writel(dw, name, val) \ - __raw_writel((val), &(((struct dw_spi_reg *)dw->regs)->name)) + __raw_writel((val), &(((struct spi_dw_reg *)dw->regs)->name)) #define dw_readw(dw, name) \ - __raw_readw(&(((struct dw_spi_reg *)dw->regs)->name)) + __raw_readw(&(((struct spi_dw_reg *)dw->regs)->name)) #define dw_writew(dw, name, val) \ - __raw_writew((val), &(((struct dw_spi_reg *)dw->regs)->name)) + __raw_writew((val), &(((struct spi_dw_reg *)dw->regs)->name)) -static inline void spi_enable_chip(struct dw_spi *dws, int enable) +static inline void spi_dw_enable_chip(struct spi_dw *dws, int enable) { dw_writel(dws, ssienr, (enable ? 1 : 0)); } -static inline void spi_set_clk(struct dw_spi *dws, u16 div) +static inline void spi_dw_set_clk(struct spi_dw *dws, u16 div) { dw_writel(dws, baudr, div); } -static inline void spi_chip_sel(struct dw_spi *dws, u16 cs) +static inline void spi_dw_chip_sel(struct spi_dw *dws, u16 cs) { if (cs > dws->num_cs) return; @@ -187,7 +187,7 @@ static inline void spi_chip_sel(struct dw_spi *dws, u16 cs) } /* Disable IRQ bits */ -static inline void spi_mask_intr(struct dw_spi *dws, u32 mask) +static inline void spi_dw_mask_intr(struct spi_dw *dws, u32 mask) { u32 new_mask; @@ -196,7 +196,7 @@ static inline void spi_mask_intr(struct dw_spi *dws, u32 mask) } /* Enable IRQ bits */ -static inline void spi_umask_intr(struct dw_spi *dws, u32 mask) +static inline void spi_dw_umask_intr(struct spi_dw *dws, u32 mask) { u32 new_mask; @@ -205,12 +205,12 @@ static inline void spi_umask_intr(struct dw_spi *dws, u32 mask) } -extern int dw_spi_add_host(struct dw_spi *dws); -extern void dw_spi_remove_host(struct dw_spi *dws); -extern int dw_spi_suspend_host(struct dw_spi *dws); -extern int dw_spi_resume_host(struct dw_spi *dws); -extern void dw_spi_xfer_done(struct dw_spi *dws); +extern int spi_dw_add_host(struct spi_dw *dws); +extern void spi_dw_remove_host(struct spi_dw *dws); +extern int spi_dw_suspend_host(struct spi_dw *dws); +extern int spi_dw_resume_host(struct spi_dw *dws); +extern void spi_dw_xfer_done(struct spi_dw *dws); /* platform related setup */ -extern int dw_spi_mid_init(struct dw_spi *dws); /* Intel MID platforms */ +extern int spi_dw_mid_init(struct spi_dw *dws); /* Intel MID platforms */ #endif /* DW_SPI_HEADER_H */ -- 1.7.3.4 ------------------------------------------------------------------------------ Simplify data backup and recovery for your virtual environment with vRanger. Installation's a snap, and flexible recovery options mean your data is safe, secure and there when you need it. Data protection magic? Nope - It's vRanger. Get your free trial download today. http://p.sf.net/sfu/quest-sfdev2dev _______________________________________________ spi-devel-general mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/spi-devel-general
