spi/pxa2xx: add Intel Lynxpoint SPI controller support
Subsystems (3)
v2 cover spi/pxa2xx: add Intel Lynxpoint SPI controller support
Hi all,
This is a second iteration of the patches first introduced here:
http://thread.gmane.org/gmane.linux.kernel/1417691
On Intel Lynxpoint (the PCH used with Haswell) we have two SPI controllers that reside in the Low Power Subsystem of the PCH. The hardware is mostly compliant with PXA2xx SPI controller except that there are few additional registers. Those are described in patch [9/10].
Changes to previous version:
- Split 64-bit build support and warnings fix into separate patches [1,2/10].
- Convert to use common clk API instead of passing the clock rate via custom platform data parameter.
- Split the DMA implementation into a separate files for PXA and DMA engine.
I've dropped the two patches that are already applied in Mark's SPI tree.
Tested on Haswell machine with both DMA and PIO modes. Only compile tested on PXA (due to lack of hardware).
Mika Westerberg (10):
spi/pxa2xx: allow building on a 64-bit kernel
spi/pxa2xx: fix warnings when compiling a 64-bit kernel spi/pxa2xx: convert to the pump message infrastructure spi/pxa2xx: convert to the common clk framework spi/pxa2xx: use the private DMA API only when CONFIG_ARCH_PXA is set spi/pxa2xx: add support for DMA engine
spi/pxa2xx: add support for runtime PM
spi/pxa2xx: add support for SPI_LOOP
spi/pxa2xx: add support for Intel Low Power Subsystem SPI spi/pxa2xx: add support for Lynxpoint SPI controllers
drivers/spi/Kconfig | 11 +- drivers/spi/Makefile | 5 +- drivers/spi/spi-pxa2xx-dma.c | 388 ++++++++++++++ drivers/spi/spi-pxa2xx-pxadma.c | 490 ++++++++++++++++++ drivers/spi/spi-pxa2xx.c | 1068 ++++++++++++--------------------------- drivers/spi/spi-pxa2xx.h | 201 ++++++++ include/linux/pxa2xx_ssp.h | 9 + include/linux/spi/pxa2xx_spi.h | 105 +--- 8 files changed, 1433 insertions(+), 844 deletions(-) create mode 100644 drivers/spi/spi-pxa2xx-dma.c create mode 100644 drivers/spi/spi-pxa2xx-pxadma.c create mode 100644 drivers/spi/spi-pxa2xx.h
Signature · 1 line
1.7.10.4
PATCH v2 1/10 spi/pxa2xx: allow building on a 64-bit kernel
We are going to use it on 64-bit kernel on Intel Lynxpoint so make sure we can build it into such kernel.
--- drivers/spi/Kconfig | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/spi/Kconfig +2 -2
@@ -299,7 +299,7 @@ config SPI_PPC4xx config SPI_PXA2XX tristate "PXA2xx SSP SPI master" - depends on (ARCH_PXA || (X86_32 && PCI)) && EXPERIMENTAL + depends on ARCH_PXA || PCI select PXA_SSP if ARCH_PXA help This enables using a PXA2xx or Sodaville SSP port as a SPI master
@@ -307,7 +307,7 @@ config SPI_PXA2XX additional documentation can be found a Documentation/spi/pxa2xx. config SPI_PXA2XX_PCI - def_bool SPI_PXA2XX && X86_32 && PCI + def_tristate SPI_PXA2XX && PCI config SPI_RSPI tristate "Renesas RSPI controller"
Signature · 1 line
1.7.10.4
PATCH v2 2/10 spi/pxa2xx: fix warnings when compiling a 64-bit kernel
In reply to Mika WesterbergFix following warnings seen when compiling 64-bit:
drivers/spi/spi-pxa2xx.c: In function ‘map_dma_buffers’: drivers/spi/spi-pxa2xx.c:384:7: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] drivers/spi/spi-pxa2xx.c:384:40: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]drivers/spi/spi-pxa2xx.c: In function ‘pxa2xx_spi_probe’:drivers/spi/spi-pxa2xx.c:1572:34: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] drivers/spi/spi-pxa2xx.c:1572:34: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] drivers/spi/spi-pxa2xx.c:1572:34: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] drivers/spi/spi-pxa2xx.c:1572:27: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
--- drivers/spi/spi-pxa2xx.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)
drivers/spi/spi-pxa2xx.c +2 -3
@@ -47,7 +47,7 @@ MODULE_ALIAS("platform:pxa2xx-spi");#define DMA_INT_MASK (DCSR_ENDINTR | DCSR_STARTINTR | DCSR_BUSERR)#define RESET_DMA_CHANNEL (DCSR_NODESC | DMA_INT_MASK) -#define IS_DMA_ALIGNED (x) ((((u32)(x)) & 0x07) == 0) +#define IS_DMA_ALIGNED (x) IS_ALIGNED((unsigned long)x, DMA_ALIGNMENT)#define MAX_DMA_LEN 8191#define DMA_ALIGNMENT 8
@@ -1576,8 +1576,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev) master->transfer = transfer; drv_data->ssp_type = ssp->type; - drv_data->null_dma_buf = (u32 *)ALIGN ((u32)(drv_data + -sizeof (struct driver_data )),8 ); + drv_data->null_dma_buf = (u32 *)PTR_ALIGN (&drv_data[1 ],DMA_ALIGNMENT ); drv_data->ioaddr = ssp->mmio_base; drv_data->ssdr_physical = ssp->phys_base +SSDR ;
Signature · 1 line
1.7.10.4
Re: [PATCH v2 02/10] spi/pxa2xx: fix warnings when compiling a 64-bit kernel
Quoted 20 lines · Mika Westerberg
Fix following warnings seen when compiling 64-bit:
drivers/spi/spi-pxa2xx.c: In function ‘map_dma_buffers’:drivers/spi/spi-pxa2xx.c:384:7: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]drivers/spi/spi-pxa2xx.c:384:40: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]drivers/spi/spi-pxa2xx.c: In function ‘pxa2xx_spi_probe’:drivers/spi/spi-pxa2xx.c:1572:34: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]drivers/spi/spi-pxa2xx.c:1572:34: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]drivers/spi/spi-pxa2xx.c:1572:34: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]drivers/spi/spi-pxa2xx.c:1572:27: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]Signed-off-by Mika Westerberg <[email protected]>--- drivers/spi/spi-pxa2xx.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)drivers/spi/spi-pxa2xx.c +0
-0
drivers/spi/spi-pxa2xx.c MODULE_ALIAS("platform:pxa2xx-spi"); · line 50
Quoted 5 lines
drivers/spi/spi-pxa2xx.c +1
-1@@ -47,7 +47,7 @@ MODULE_ALIAS("platform:pxa2xx-spi");#define DMA_INT_MASK (DCSR_ENDINTR | DCSR_STARTINTR | DCSR_BUSERR)#define RESET_DMA_CHANNEL (DCSR_NODESC | DMA_INT_MASK) -#define IS_DMA_ALIGNED (x) ((((u32)(x)) & 0x07) == 0) +#define IS_DMA_ALIGNED (x) IS_ALIGNED((unsigned long)x, DMA_ALIGNMENT)
x -> (x) due to it's used in macro.
Quoted 21 lines
drivers/spi/spi-pxa2xx.c +1
-3#define MAX_DMA_LEN 8191#define DMA_ALIGNMENT 8@@ -1576,8 +1576,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev) master->transfer = transfer; drv_data->ssp_type = ssp->type; - drv_data->null_dma_buf = (u32 *)ALIGN ((u32)(drv_data + -sizeof (struct driver_data )),8 ); + drv_data->null_dma_buf = (u32 *)PTR_ALIGN (&drv_data[1 ],DMA_ALIGNMENT ); drv_data->ioaddr = ssp->mmio_base; drv_data->ssdr_physical = ssp->phys_base +SSDR ; --1.7.10.4
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Signature · 2 lines
With Best Regards, Andy Shevchenko
PATCH v2 3/10 spi/pxa2xx: convert to the pump message infrastructure
In reply to Mika WesterbergThe SPI core provides infrastructure for standard message queueing so use that instead of handling everything in the driver. This simplifies the driver.
--- drivers/spi/spi-pxa2xx.c | 212 +++------------------------------------------- 1 file changed, 12 insertions(+), 200 deletions(-)
drivers/spi/spi-pxa2xx.c +12 -200
@@ -85,9 +85,6 @@ DEFINE_SSP_REG(SSPSP, 0x2c)#define DONE_STATE ((void*)2)#define ERROR_STATE ((void*)-1) -#define QUEUE_RUNNING 0 -#define QUEUE_STOPPED 1 -struct driver_data {/* Driver model hookup */ struct platform_device *pdev;
@@ -117,14 +114,6 @@ struct driver_data {u32 clear_sr;u32 mask_sr; -/* Driver message queue */ -struct workqueue_struct *workqueue; -struct work_struct pump_messages; -spinlock_t lock; -struct list_head queue; -int busy; -int run; -/* Message Transfer pump */ struct tasklet_struct pump_transfers;
@@ -173,8 +162,6 @@ struct chip_data {void (*cs_control)(u32 command); }; -static void pump_messages (struct work_struct *work); -static void cs_assert (struct driver_data *drv_data) {struct chip_data *chip = drv_data->cur_chip;
@@ -444,15 +431,11 @@ static void unmap_dma_buffers(struct driver_data *drv_data)static void giveback (struct driver_data *drv_data) {struct spi_transfer * last_transfer; -unsigned long flags;struct spi_message *msg; -spin_lock_irqsave (&drv_data->lock, flags); msg = drv_data->cur_msg; drv_data->cur_msg =NULL ; drv_data->cur_transfer =NULL ; -queue_work (drv_data->workqueue, &drv_data->pump_messages); -spin_unlock_irqrestore (&drv_data->lock, flags); last_transfer = list_entry(msg->transfers.prev, struct spi_transfer,
@@ -481,13 +464,7 @@ static void giveback(struct driver_data *drv_data)*/ /* get a pointer to the next message, if any */ -spin_lock_irqsave (&drv_data->lock, flags); -if (list_empty (&drv_data->queue)) - next_msg =NULL ; -else - next_msg =list_entry (drv_data->queue.next, - struct spi_message, queue); -spin_unlock_irqrestore (&drv_data->lock, flags); + next_msg =spi_get_next_queued_message (drv_data->master);/* see if the next and current messages point * to the same chip
@@ -498,10 +475,7 @@ static void giveback(struct driver_data *drv_data)cs_deassert (drv_data); } - msg->state =NULL ; -if (msg->complete) - msg->complete (msg->context); - +spi_finalize_current_message (drv_data->master); drv_data->cur_chip =NULL ; }
@@ -1176,31 +1150,12 @@ static void pump_transfers(unsigned long data)write_SSCR1 (cr1, reg); } -static void pump_messages (struct work_struct *work) +static int pxa2xx_spi_transfer_one_message (struct spi_master *master, +struct spi_message *msg) { -struct driver_data *drv_data = - container_of(work, struct driver_data, pump_messages); -unsigned long flags; - -/* Lock queue and check for queue work */ -spin_lock_irqsave (&drv_data->lock, flags); -if (list_empty (&drv_data->queue) || drv_data->run ==QUEUE_STOPPED ) { - drv_data->busy =0 ; -spin_unlock_irqrestore (&drv_data->lock, flags); -return ; - } - -/* Make sure we are not already running a message */ -if (drv_data->cur_msg) { -spin_unlock_irqrestore (&drv_data->lock, flags); -return ; - } - -/* Extract head of queue */ - drv_data->cur_msg =list_entry (drv_data->queue.next, - struct spi_message, queue); -list_del_init (&drv_data->cur_msg->queue); +struct driver_data *drv_data =spi_master_get_devdata (master); + drv_data->cur_msg = msg;/* Initial message state*/ drv_data->cur_msg->state =START_STATE ; drv_data->cur_transfer = list_entry(drv_data->cur_msg->transfers.next,
@@ -1213,34 +1168,6 @@ static void pump_messages(struct work_struct *work)/* Mark as busy and launch transfers */ tasklet_schedule (&drv_data->pump_transfers); - - drv_data->busy =1 ; -spin_unlock_irqrestore (&drv_data->lock, flags); -} - -static int transfer (struct spi_device *spi,struct spi_message *msg) -{ -struct driver_data *drv_data =spi_master_get_devdata (spi->master); -unsigned long flags; - -spin_lock_irqsave (&drv_data->lock, flags); - -if (drv_data->run ==QUEUE_STOPPED ) { -spin_unlock_irqrestore (&drv_data->lock, flags); -return -ESHUTDOWN ; - } - - msg->actual_length =0 ; - msg->status = -EINPROGRESS ; - msg->state =START_STATE ; - -list_add_tail (&msg->queue, &drv_data->queue); - -if (drv_data->run ==QUEUE_RUNNING && !drv_data->busy) -queue_work (drv_data->workqueue, &drv_data->pump_messages); - -spin_unlock_irqrestore (&drv_data->lock, flags); -return 0 ; }
@@ -1438,94 +1365,6 @@ static void cleanup(struct spi_device *spi)kfree (chip); } -static int init_queue (struct driver_data *drv_data) -{ -INIT_LIST_HEAD (&drv_data->queue); -spin_lock_init (&drv_data->lock); - - drv_data->run =QUEUE_STOPPED ; - drv_data->busy =0 ; - -tasklet_init (&drv_data->pump_transfers, - pump_transfers, (unsigned long )drv_data); - -INIT_WORK (&drv_data->pump_messages, pump_messages); - drv_data->workqueue =create_singlethread_workqueue ( -dev_name (drv_data->master->dev.parent)); -if (drv_data->workqueue ==NULL ) -return -EBUSY ; - -return 0 ; -} - -static int start_queue (struct driver_data *drv_data) -{ -unsigned long flags; - -spin_lock_irqsave (&drv_data->lock, flags); - -if (drv_data->run ==QUEUE_RUNNING || drv_data->busy) { -spin_unlock_irqrestore (&drv_data->lock, flags); -return -EBUSY ; - } - - drv_data->run =QUEUE_RUNNING ; - drv_data->cur_msg =NULL ; - drv_data->cur_transfer =NULL ; - drv_data->cur_chip =NULL ; -spin_unlock_irqrestore (&drv_data->lock, flags); - -queue_work (drv_data->workqueue, &drv_data->pump_messages); - -return 0 ; -} - -static int stop_queue (struct driver_data *drv_data) -{ -unsigned long flags; -unsigned limit =500 ; -int status =0 ; - -spin_lock_irqsave (&drv_data->lock, flags); - -/* This is a bit lame, but is optimized for the common execution path. -* A wait_queue on the drv_data->busy could be used, but then the common -* execution path (pump_messages) would be required to call wake_up or -* friends on every SPI message. Do this instead */ - drv_data->run =QUEUE_STOPPED ; -while ((!list_empty (&drv_data->queue) || drv_data->busy) && limit--) { -spin_unlock_irqrestore (&drv_data->lock, flags); -msleep (10 ); -spin_lock_irqsave (&drv_data->lock, flags); - } - -if (!list_empty (&drv_data->queue) || drv_data->busy) - status = -EBUSY ; - -spin_unlock_irqrestore (&drv_data->lock, flags); - -return status; -} - -static int destroy_queue (struct driver_data *drv_data) -{ -int status; - - status =stop_queue (drv_data); -/* we are unloading the module or failing to load (only two calls -* to this routine), and neither call can handle a return value. -* However, destroy_workqueue calls flush_workqueue, and that will -* block until all work is done. If the reason that stop_queue -* timed out is that the work will never finish, then it does no -* good to call destroy_workqueue, so return anyway. */ -if (status !=0 ) -return status; - -destroy_workqueue (drv_data->workqueue); - -return 0 ; -} -static int pxa2xx_spi_probe (struct platform_device *pdev) {struct device *dev = &pdev->dev;
@@ -1573,7 +1412,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev) master->dma_alignment =DMA_ALIGNMENT ; master->cleanup = cleanup; master->setup = setup; - master->transfer = transfer; + master->transfer_one_message = pxa2xx_spi_transfer_one_message; drv_data->ssp_type = ssp->type; drv_data->null_dma_buf = (u32 *)PTR_ALIGN (&drv_data[1 ],DMA_ALIGNMENT );
@@ -1646,31 +1485,19 @@ static int pxa2xx_spi_probe(struct platform_device *pdev)write_SSTO (0 , drv_data->ioaddr);write_SSPSP (0 , drv_data->ioaddr); -/* Initial and start queue */ - status =init_queue (drv_data); -if (status !=0 ) { -dev_err (&pdev->dev,"problem initializing queue\n" ); - goto out_error_clock_enabled; - } - status =start_queue (drv_data); -if (status !=0 ) { -dev_err (&pdev->dev,"problem starting queue\n" ); - goto out_error_clock_enabled; - } +tasklet_init (&drv_data->pump_transfers, pump_transfers, + (unsigned long )drv_data);/* Register with the SPI framework */ platform_set_drvdata (pdev, drv_data); status =spi_register_master (master);if (status !=0 ) {dev_err (&pdev->dev,"problem registering spi master\n" ); - goto out_error_queue_alloc; + goto out_error_clock_enabled; }return status; -out_error_queue_alloc: -destroy_queue (drv_data); - out_error_clock_enabled:clk_disable (ssp->clk);
@@ -1693,26 +1520,11 @@ static int pxa2xx_spi_remove(struct platform_device *pdev) {struct driver_data *drv_data =platform_get_drvdata (pdev);struct ssp_device *ssp; -int status =0 ;if (!drv_data)return 0 ; ssp = drv_data->ssp; -/* Remove the queue */ - status =destroy_queue (drv_data); -if (status !=0 ) -/* the kernel does not check the return status of this -* this routine (mod->exit, within the kernel). Therefore -* nothing is gained by returning from here, the module is -* going away regardless, and we should not leave any more -* resources allocated than necessary. We cannot free the -* message memory in drv_data->queue, but we can release the -* resources below. I think the kernel should honor -EBUSY -* returns but... */ -dev_err (&pdev->dev,"pxa2xx_spi_remove: workqueue will not " -"complete, message memory not freed\n" ); -/* Disable the SSP at the peripheral and SOC level */ write_SSCR0 (0 , drv_data->ioaddr);clk_disable (ssp->clk);
@@ -1755,7 +1567,7 @@ static int pxa2xx_spi_suspend(struct device *dev)struct ssp_device *ssp = drv_data->ssp;int status =0 ; - status =stop_queue (drv_data); + status =spi_master_suspend (drv_data->master);if (status !=0 )return status;write_SSCR0 (0 , drv_data->ioaddr);
@@ -1781,7 +1593,7 @@ static int pxa2xx_spi_resume(struct device *dev)clk_enable (ssp->clk);/* Start the queue running */ - status =start_queue (drv_data); + status =spi_master_resume (drv_data->master);if (status !=0 ) {dev_err (dev,"problem starting queue (%d)\n" , status);return status;
Signature · 1 line
1.7.10.4
PATCH v2 4/10 spi/pxa2xx: convert to the common clk framework
In reply to Mika WesterbergConvert clk_enable() to clk_prepare_enable() and clk_disable() to clk_disable_unprepare() respectively in order to support the common clk framework. Otherwise we get warnings on the console as the clock is not prepared before it is enabled.
In addition we must cache the maximum clock rate to drv_data->max_clk_rate at probe time because clk_get_rate() cannot be called in tasklet context.
--- drivers/spi/spi-pxa2xx.c | 33 ++++++++++++++++++++------------- include/linux/spi/pxa2xx_spi.h | 18 ------------------ 2 files changed, 20 insertions(+), 31 deletions(-)
drivers/spi/spi-pxa2xx.c +20 -13
@@ -30,6 +30,7 @@#include <linux/delay.h> #include <linux/gpio.h> #include <linux/slab.h> +#include <linux/clk.h> #include <asm/io.h> #include <asm/irq.h>
@@ -114,6 +115,9 @@ struct driver_data {u32 clear_sr;u32 mask_sr; +/* Maximun clock rate */ +unsigned long max_clk_rate; +/* Message Transfer pump */ struct tasklet_struct pump_transfers;
@@ -891,9 +895,12 @@ static int set_dma_burst_and_threshold(struct chip_data *chip,return retval; } -static unsigned int ssp_get_clk_div (struct ssp_device *ssp,int rate) +static unsigned int ssp_get_clk_div (struct driver_data *drv_data,int rate) { -unsigned long ssp_clk =clk_get_rate (ssp->clk); +unsigned long ssp_clk = drv_data->max_clk_rate; +const struct ssp_device *ssp = drv_data->ssp; + + rate =min_t (int, ssp_clk, rate);if (ssp->type == PXA25x_SSP || ssp->type ==CE4100_SSP )return ((ssp_clk / (2 * rate) -1 ) &0xff ) <<8 ;
@@ -908,7 +915,6 @@ static void pump_transfers(unsigned long data)struct spi_transfer *transfer =NULL ;struct spi_transfer *previous =NULL ;struct chip_data *chip =NULL ; -struct ssp_device *ssp = drv_data->ssp;void __iomem *reg = drv_data->ioaddr;u32 clk_div =0 ;u8 bits =0 ;
@@ -1005,7 +1011,7 @@ static void pump_transfers(unsigned long data)if (transfer->bits_per_word) bits = transfer->bits_per_word; - clk_div =ssp_get_clk_div (ssp, speed); + clk_div =ssp_get_clk_div (drv_data, speed);if (bits <=8 ) { drv_data->n_bytes =1 ;
@@ -1214,7 +1220,6 @@ static int setup(struct spi_device *spi)struct pxa2xx_spi_chip *chip_info =NULL ;struct chip_data *chip;struct driver_data *drv_data =spi_master_get_devdata (spi->master); -struct ssp_device *ssp = drv_data->ssp;unsigned int clk_div;uint tx_thres =TX_THRESH_DFLT ;uint rx_thres =RX_THRESH_DFLT ;
@@ -1296,7 +1301,7 @@ static int setup(struct spi_device *spi) } } - clk_div =ssp_get_clk_div (ssp, spi->max_speed_hz); + clk_div =ssp_get_clk_div (drv_data, spi->max_speed_hz); chip->speed_hz = spi->max_speed_hz; chip->cr0 = clk_div
@@ -1312,12 +1317,12 @@ static int setup(struct spi_device *spi)/* NOTE: PXA25x_SSP _could_ use external clocking ... */ if (!pxa25x_ssp_comp (drv_data))dev_dbg (&spi->dev,"%ld Hz actual, %s\n" , -clk_get_rate (ssp->clk) + drv_data->max_clk_rate / (1 + ((chip->cr0 &SSCR0_SCR (0xfff )) >>8 )), chip->enable_dma ?"DMA" :"PIO" );else dev_dbg (&spi->dev,"%ld Hz actual, %s\n" , -clk_get_rate (ssp->clk) /2 + drv_data->max_clk_rate /2 / (1 + ((chip->cr0 &SSCR0_SCR (0x0ff )) >>8 )), chip->enable_dma ?"DMA" :"PIO" );
@@ -1470,7 +1475,9 @@ static int pxa2xx_spi_probe(struct platform_device *pdev) }/* Enable SOC clock */ -clk_enable (ssp->clk); +clk_prepare_enable (ssp->clk); + + drv_data->max_clk_rate =clk_get_rate (ssp->clk);/* Load default SSP configuration */ write_SSCR0 (0 , drv_data->ioaddr);
@@ -1499,7 +1506,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev)return status; out_error_clock_enabled: -clk_disable (ssp->clk); +clk_disable_unprepare (ssp->clk); out_error_dma_alloc:if (drv_data->tx_channel !=-1 )
@@ -1527,7 +1534,7 @@ static int pxa2xx_spi_remove(struct platform_device *pdev)/* Disable the SSP at the peripheral and SOC level */ write_SSCR0 (0 , drv_data->ioaddr); -clk_disable (ssp->clk); +clk_disable_unprepare (ssp->clk);/* Release DMA */ if (drv_data->master_info->enable_dma) {
@@ -1571,7 +1578,7 @@ static int pxa2xx_spi_suspend(struct device *dev)if (status !=0 )return status;write_SSCR0 (0 , drv_data->ioaddr); -clk_disable (ssp->clk); +clk_disable_unprepare (ssp->clk);return 0 ; }
@@ -1590,7 +1597,7 @@ static int pxa2xx_spi_resume(struct device *dev)DRCMR_MAPVLD | drv_data->tx_channel;/* Enable the SSP clock */ -clk_enable (ssp->clk); +clk_prepare_enable (ssp->clk);/* Start the queue running */ status =spi_master_resume (drv_data->master);
include/linux/spi/pxa2xx_spi.h +0 -18
@@ -133,23 +133,5 @@ static inline void pxa_free_dma(int dma_ch) { } -/* -* The CE4100 does not have the clk framework implemented and SPI clock can -* not be switched on/off or the divider changed. -*/ -static inline void clk_disable (struct clk *clk) -{ -} - -static inline int clk_enable (struct clk *clk) -{ -return 0 ; -} - -static inline unsigned long clk_get_rate (struct clk *clk) -{ -return 3686400 ; -} -#endif #endif
Signature · 1 line
1.7.10.4
PATCH v2 5/10 spi/pxa2xx: use the private DMA API only when CONFIG_ARCH_PXA is set
In reply to Mika WesterbergThe PXA SPI driver uses PXA platform specific private DMA implementation which does not work on non-PXA platforms. In order to use this driver on other platforms we break out the private DMA implementation into a separate file that gets compiled only when CONFIG_ARCH_PXA is set. The DMA functions are stubbed out if there is no DMA implementation selected (i.e we are building on non-PXA platform).
While we are there we can kill the dummy DMA bits in pxa2xx_spi.h as they are not needed anymore for CE4100.
Once this is done we can add the generic DMA engine support to the driver that allows usage of any DMA controller that implements DMA engine API.
---
This patch was already acked by Linus W but since I changed this by breaking out the PXA private implementation into a separate file, I'm hoping to get new ack from him ;-)
drivers/spi/Kconfig | 4 + drivers/spi/Makefile | 4 +- drivers/spi/spi-pxa2xx-pxadma.c | 490 +++++++++++++++++++++++++++++++++ drivers/spi/spi-pxa2xx.c | 569 ++------------------------------------- drivers/spi/spi-pxa2xx.h | 165 ++++++++++++ include/linux/spi/pxa2xx_spi.h | 80 ------ 6 files changed, 681 insertions(+), 631 deletions(-) create mode 100644 drivers/spi/spi-pxa2xx-pxadma.c create mode 100644 drivers/spi/spi-pxa2xx.h
drivers/spi/Kconfig +4 -0
@@ -297,10 +297,14 @@ config SPI_PPC4xx help This selects a driver for the PPC4xx SPI Controller. +config SPI_PXA2XX_PXADMA + bool + config SPI_PXA2XX tristate "PXA2xx SSP SPI master" depends on ARCH_PXA || PCI select PXA_SSP if ARCH_PXA + select SPI_PXA2XX_PXADMA if ARCH_PXA help This enables using a PXA2xx or Sodaville SSP port as a SPI master controller. The driver can be configured to use any SSP port and
drivers/spi/Makefile +3 -1
@@ -47,7 +47,9 @@ obj-$(CONFIG_SPI_OMAP24XX) += spi-omap2-mcspi.o obj-$(CONFIG_SPI_ORION) += spi-orion.o obj-$(CONFIG_SPI_PL022) += spi-pl022.o obj-$(CONFIG_SPI_PPC4xx) += spi-ppc4xx.o -obj-$(CONFIG_SPI_PXA2XX) += spi-pxa2xx.o +spi-pxa2xx-platform-objs := spi-pxa2xx.o +spi-pxa2xx-platform-$(CONFIG_SPI_PXA2XX_PXADMA) += spi-pxa2xx-pxadma.o +obj-$(CONFIG_SPI_PXA2XX) += spi-pxa2xx-platform.o obj-$(CONFIG_SPI_PXA2XX_PCI) += spi-pxa2xx-pci.o obj-$(CONFIG_SPI_RSPI) += spi-rspi.o obj-$(CONFIG_SPI_S3C24XX) += spi-s3c24xx-hw.o
drivers/spi/spi-pxa2xx-pxadma.c new file +490 -0
490 lines not on this page · raw message
drivers/spi/spi-pxa2xx.c +19 -550
728 lines not on this page · raw message
drivers/spi/spi-pxa2xx.h new file +165 -0
165 lines not on this page · raw message
include/linux/spi/pxa2xx_spi.h +0 -80
85 lines not on this page · raw message
Signature · 1 line
1.7.10.4
PATCH v2 6/10 spi/pxa2xx: add support for DMA engine
In reply to Mika WesterbergTo be able to use DMA with this driver on non-PXA platforms we implement support for the generic DMA engine API. This lets user to use different DMA engines with little or no modification to the driver.
The DMA engine support will be build to the driver if CONFIG_DMA_ENGINE is set.
Request lines and channel numbers can be passed to the driver from the platform specific data.
---
Linus W, there haven't been any comments from Vinod/Dan about the alignment thing so I added a comment 'REVISIT: ..' so that we remember to change this once it has been sorted out. I hope that is OK for you.
drivers/spi/Kconfig | 3 + drivers/spi/Makefile | 1 + drivers/spi/spi-pxa2xx-dma.c | 388 ++++++++++++++++++++++++++++++++++++++++ drivers/spi/spi-pxa2xx.c | 2 +- drivers/spi/spi-pxa2xx.h | 32 +++- include/linux/spi/pxa2xx_spi.h | 6 + 6 files changed, 430 insertions(+), 2 deletions(-) create mode 100644 drivers/spi/spi-pxa2xx-dma.c
drivers/spi/Kconfig +3 -0
@@ -299,12 +299,15 @@ config SPI_PPC4xx config SPI_PXA2XX_PXADMA bool +config SPI_PXA2XX_DMA + bool config SPI_PXA2XX tristate "PXA2xx SSP SPI master" depends on ARCH_PXA || PCI select PXA_SSP if ARCH_PXA select SPI_PXA2XX_PXADMA if ARCH_PXA + select SPI_PXA2XX_DMA if DMA_ENGINE && !ARCH_PXA help This enables using a PXA2xx or Sodaville SSP port as a SPI master controller. The driver can be configured to use any SSP port and
drivers/spi/Makefile +1 -0
@@ -49,6 +49,7 @@ obj-$(CONFIG_SPI_PL022) += spi-pl022.o obj-$(CONFIG_SPI_PPC4xx) += spi-ppc4xx.o spi-pxa2xx-platform-objs := spi-pxa2xx.o spi-pxa2xx-platform-$(CONFIG_SPI_PXA2XX_PXADMA) += spi-pxa2xx-pxadma.o +spi-pxa2xx-platform-$(CONFIG_SPI_PXA2XX_DMA) += spi-pxa2xx-dma.o obj-$(CONFIG_SPI_PXA2XX) += spi-pxa2xx-platform.o obj-$(CONFIG_SPI_PXA2XX_PCI) += spi-pxa2xx-pci.o obj-$(CONFIG_SPI_RSPI) += spi-rspi.o
drivers/spi/spi-pxa2xx-dma.c new file +388 -0
388 lines not on this page · raw message
drivers/spi/spi-pxa2xx.c +1 -1
@@ -936,7 +936,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev) drv_data->mask_sr =SSSR_RFS |SSSR_TFS |SSSR_ROR ; }else { drv_data->int_cr1 =SSCR1_TIE |SSCR1_RIE |SSCR1_TINTE ; - drv_data->dma_cr1 =SSCR1_TSRE |SSCR1_RSRE |SSCR1_TINTE ; + drv_data->dma_cr1 =DEFAULT_DMA_CR1 ; drv_data->clear_sr =SSSR_ROR |SSSR_TINT ; drv_data->mask_sr =SSSR_TINT |SSSR_RFS |SSSR_TFS |SSSR_ROR ; }
drivers/spi/spi-pxa2xx.h +31 -1
@@ -10,11 +10,15 @@#ifndef SPI_PXA2XX_H #define SPI_PXA2XX_H +#include <linux/atomic.h> +#include <linux/dmaengine.h> #include <linux/errno.h> #include <linux/io.h> #include <linux/interrupt.h> #include <linux/platform_device.h> #include <linux/pxa2xx_ssp.h> +#include <linux/scatterlist.h> +#include <linux/sizes.h> #include <linux/spi/spi.h> #include <linux/spi/pxa2xx_spi.h>
@@ -53,6 +57,16 @@ struct driver_data {/* Message Transfer pump */ struct tasklet_struct pump_transfers; +/* DMA engine support */ +struct dma_chan *rx_chan; +struct dma_chan *tx_chan; +struct sg_table rx_sgt; +struct sg_table tx_sgt; +int rx_nents; +int tx_nents; +void *dummy; +atomic_t dma_running; +/* Current message transfer state info */ struct spi_message *cur_msg;struct spi_transfer *cur_transfer;
@@ -116,7 +130,6 @@ DEFINE_SSP_REG(SSPSP, 0x2c)#define DONE_STATE ((void *)2)#define ERROR_STATE ((void *)-1) -#define MAX_DMA_LEN 8191#define IS_DMA_ALIGNED (x) IS_ALIGNED((unsigned long)x, DMA_ALIGNMENT)#define DMA_ALIGNMENT 8
@@ -133,7 +146,24 @@ extern void write_SSSR_CS(struct driver_data *drv_data, u32 val);extern int flush (struct driver_data *drv_data);extern void *next_transfer (struct driver_data *drv_data); +/* +* Select the right DMA implementation. +*/ #if defined(CONFIG_SPI_PXA2XX_PXADMA ) +#define SPI_PXA2XX_USE_DMA 1 +#define MAX_DMA_LEN 8191 +#define DEFAULT_DMA_CR1 (SSCR1_TSRE | SSCR1_RSRE | SSCR1_TINTE) +#elif defined(CONFIG_SPI_PXA2XX_DMA ) +#define SPI_PXA2XX_USE_DMA 1 +#define MAX_DMA_LEN SZ_64K +#define DEFAULT_DMA_CR1 (SSCR1_TSRE | SSCR1_RSRE | SSCR1_TRAIL) +#else +#undef SPI_PXA2XX_USE_DMA +#define MAX_DMA_LEN 0 +#define DEFAULT_DMA_CR1 0 +#endif + +#ifdef SPI_PXA2XX_USE_DMA extern bool dma_is_possible (size_t len);extern int map_dma_buffers (struct driver_data *drv_data);extern irqreturn_t dma_transfer (struct driver_data *drv_data);
include/linux/spi/pxa2xx_spi.h +6 -0
@@ -29,6 +29,12 @@ struct pxa2xx_spi_master {u16 num_chipselect;u8 enable_dma; +/* DMA engine specific config */ +int rx_chan_id; +int tx_chan_id; +int rx_slave_id; +int tx_slave_id; +/* For non-PXA arches */ struct ssp_device ssp; };
Signature · 1 line
1.7.10.4
Re: [PATCH v2 06/10] spi/pxa2xx: add support for DMA engine
drivers/spi/spi-pxa2xx-dma.c line 374
Quoted 12 lines · Mika Westerberg
drivers/spi/spi-pxa2xx-dma.c new file +12
-0+bool dma_is_possible(size_t len) +int map_dma_buffers(struct driver_data *drv_data) +irqreturn_t dma_transfer(struct driver_data *drv_data) +int dma_prepare(struct driver_data *drv_data, u32 dma_burst) +void dma_start(struct driver_data *drv_data) +int dma_setup(struct driver_data *drv_data) +void dma_release(struct driver_data *drv_data) +void dma_resume(struct driver_data *drv_data) +int set_dma_burst_and_threshold(struct chip_data *chip, + struct spi_device *spi, + u8 bits_per_word, u32 *burst_code, + u32 *threshold)
All the above function names end up in the global namespace in the kernel image. They're rather _too_ generic and non-specific for them to leak to that visibility. I think this needs fixing.
Also, I'd suggest that the long term plan is for PXA to move over to the DMA engine API, so I'd recommend that the pxa2xx SPI driver have the DMA engine API usage built into it, and let's treat the old PXA DMA stuff as legacy code.
Re: [PATCH v2 06/10] spi/pxa2xx: add support for DMA engine
Quoted 17 lines · Russell King - ARM Linux
drivers/spi/spi-pxa2xx-dma.c line 374
Quoted 12 lines · Mika Westerberg
drivers/spi/spi-pxa2xx-dma.c new file +12
-0+bool dma_is_possible(size_t len) +int map_dma_buffers(struct driver_data *drv_data) +irqreturn_t dma_transfer(struct driver_data *drv_data) +int dma_prepare(struct driver_data *drv_data, u32 dma_burst) +void dma_start(struct driver_data *drv_data) +int dma_setup(struct driver_data *drv_data) +void dma_release(struct driver_data *drv_data) +void dma_resume(struct driver_data *drv_data) +int set_dma_burst_and_threshold(struct chip_data *chip, + struct spi_device *spi, + u8 bits_per_word, u32 *burst_code, + u32 *threshold)All the above function names end up in the global namespace in the kernel image. They're rather _too_ generic and non-specific for them to leak to that visibility. I think this needs fixing.
Indeed, good point. I will fix this.
Quoted 4 lines
Also, I'd suggest that the long term plan is for PXA to move over to the DMA engine API, so I'd recommend that the pxa2xx SPI driver have the DMA engine API usage built into it, and let's treat the old PXA DMA stuff as legacy code.
In the previous version I had the old PXA DMA stuff behind #ifdef CONFIG_ARCH_PXA and otherwise it used the DMA engine stuff. Do you mean something like that (e.g keep both DMA in the single file)?
PATCH v2 7/10 spi/pxa2xx: add support for runtime PM
In reply to Mika WesterbergDrivers should put the device into low power states proactively whenever the device is not in use. Thus implement support for runtime PM and use the autosuspend feature to make sure that we can still perform well in case we see lots of SPI traffic within short period of time.
--- drivers/spi/spi-pxa2xx.c | 73 ++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 67 insertions(+), 6 deletions(-)
drivers/spi/spi-pxa2xx.c +67 -6
@@ -30,6 +30,7 @@#include <linux/gpio.h> #include <linux/slab.h> #include <linux/clk.h> +#include <linux/pm_runtime.h> #include <asm/io.h> #include <asm/irq.h>
@@ -427,10 +428,20 @@ static irqreturn_t ssp_int(int irq, void *dev_id) {struct driver_data *drv_data = dev_id;void __iomem *reg = drv_data->ioaddr; -u32 sccr1_reg =read_SSCR1 (reg); +u32 sccr1_reg;u32 mask = drv_data->mask_sr;u32 status; +/* +* The IRQ might be shared with other peripherals so we must first +* check that are we RPM suspended or not. If we are we assume that +* the IRQ was not for us (we shouldn't be RPM suspended when the +* interrupt is enabled). +*/ +if (pm_runtime_suspended (&drv_data->pdev->dev)) +return IRQ_NONE ; + + sccr1_reg =read_SSCR1 (reg); status =read_SSSR (reg);/* Ignore possible writes if we don't need to write */
@@ -687,6 +698,27 @@ static int pxa2xx_spi_transfer_one_message(struct spi_master *master,return 0 ; } +static int pxa2xx_spi_prepare_transfer (struct spi_master *master) +{ +struct driver_data *drv_data =spi_master_get_devdata (master); + +pm_runtime_get_sync (&drv_data->pdev->dev); +return 0 ; +} + +static int pxa2xx_spi_unprepare_transfer (struct spi_master *master) +{ +struct driver_data *drv_data =spi_master_get_devdata (master); + +/* Disable the SSP now */ +write_SSCR0 (read_SSCR0 (drv_data->ioaddr) & ~SSCR0_SSE , + drv_data->ioaddr); + +pm_runtime_mark_last_busy (&drv_data->pdev->dev); +pm_runtime_put_autosuspend (&drv_data->pdev->dev); +return 0 ; +} +static int setup_cs (struct spi_device *spi,struct chip_data *chip,struct pxa2xx_spi_chip *chip_info) {
@@ -923,6 +955,8 @@ static int pxa2xx_spi_probe(struct platform_device *pdev) master->cleanup = cleanup; master->setup = setup; master->transfer_one_message = pxa2xx_spi_transfer_one_message; + master->prepare_transfer_hardware = pxa2xx_spi_prepare_transfer; + master->unprepare_transfer_hardware = pxa2xx_spi_unprepare_transfer; drv_data->ssp_type = ssp->type; drv_data->null_dma_buf = (u32 *)PTR_ALIGN (&drv_data[1 ],DMA_ALIGNMENT );
@@ -988,6 +1022,11 @@ static int pxa2xx_spi_probe(struct platform_device *pdev) goto out_error_clock_enabled; } +pm_runtime_set_autosuspend_delay (&pdev->dev,50 ); +pm_runtime_use_autosuspend (&pdev->dev); +pm_runtime_set_active (&pdev->dev); +pm_runtime_enable (&pdev->dev); +return status; out_error_clock_enabled:
@@ -1010,6 +1049,8 @@ static int pxa2xx_spi_remove(struct platform_device *pdev)return 0 ; ssp = drv_data->ssp; +pm_runtime_get_sync (&pdev->dev); +/* Disable the SSP at the peripheral and SOC level */ write_SSCR0 (0 , drv_data->ioaddr);clk_disable_unprepare (ssp->clk);
@@ -1018,6 +1059,9 @@ static int pxa2xx_spi_remove(struct platform_device *pdev)if (drv_data->master_info->enable_dma)dma_release (drv_data); +pm_runtime_put_noidle (&pdev->dev); +pm_runtime_disable (&pdev->dev); +/* Release IRQ */ free_irq (ssp->irq, drv_data);
@@ -1077,20 +1121,37 @@ static int pxa2xx_spi_resume(struct device *dev)return 0 ; } +#endif + +#ifdef CONFIG_PM_RUNTIME +static int pxa2xx_spi_runtime_suspend (struct device *dev) +{ +struct driver_data *drv_data =dev_get_drvdata (dev); + +clk_disable_unprepare (drv_data->ssp->clk); +return 0 ; +} + +static int pxa2xx_spi_runtime_resume (struct device *dev) +{ +struct driver_data *drv_data =dev_get_drvdata (dev); + +clk_prepare_enable (drv_data->ssp->clk); +return 0 ; +} +#endif static const struct dev_pm_ops pxa2xx_spi_pm_ops = { - .suspend = pxa2xx_spi_suspend, - .resume = pxa2xx_spi_resume, + SET_SYSTEM_SLEEP_PM_OPS(pxa2xx_spi_suspend, pxa2xx_spi_resume) +SET_RUNTIME_PM_OPS (pxa2xx_spi_runtime_suspend, + pxa2xx_spi_runtime_resume,NULL ) }; -#endif static struct platform_driver driver = { .driver = { .name ="pxa2xx-spi" , .owner =THIS_MODULE , -#ifdef CONFIG_PM .pm = &pxa2xx_spi_pm_ops, -#endif }, .probe = pxa2xx_spi_probe, .remove = pxa2xx_spi_remove,
Signature · 1 line
1.7.10.4
PATCH v2 8/10 spi/pxa2xx: add support for SPI_LOOP
In reply to Mika WesterbergThis is useful when testing the functionality of the controller from userspace and there aren't any real SPI slave devices connected to the bus.
--- drivers/spi/spi-pxa2xx.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
drivers/spi/spi-pxa2xx.c +4 -1
@@ -854,6 +854,9 @@ static int setup(struct spi_device *spi) chip->cr1 |= (((spi->mode &SPI_CPHA ) !=0 ) ?SSCR1_SPH :0 ) | (((spi->mode &SPI_CPOL ) !=0 ) ?SSCR1_SPO :0 ); +if (spi->mode &SPI_LOOP ) + chip->cr1 |=SSCR1_LBM ; +/* NOTE: PXA25x_SSP _could_ use external clocking ... */ if (!pxa25x_ssp_comp (drv_data)) dev_dbg(&spi->dev, "%ld Hz actual, %s\n",
@@ -947,7 +950,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev) master->dev.parent = &pdev->dev; master->dev.of_node = pdev->dev.of_node;/* the spi->mode bits understood by this driver: */ - master->mode_bits =SPI_CPOL |SPI_CPHA |SPI_CS_HIGH ; + master->mode_bits =SPI_CPOL |SPI_CPHA |SPI_CS_HIGH |SPI_LOOP ; master->bus_num = ssp->port_id; master->num_chipselect = platform_info->num_chipselect;
Signature · 1 line
1.7.10.4
PATCH v2 9/10 spi/pxa2xx: add support for Intel Low Power Subsystem SPI
In reply to Mika WesterbergIntel LPSS SPI is pretty much the same as the PXA27xx SPI except that it has few additional features over the original:
o FIFO depth is 256 entries
o RX FIFO has one watermark
o TX FIFO has two watermarks, low and high
o chip select can be controlled by writing to a register
The new FIFO registers follow immediately the PXA27xx registers but then there are some additional LPSS private registers at offset 1k or 2k from the base address. For these private registers we add new accessors that take advantage of drv_data->lpss_base once it is resolved.
We add a new type LPSS_SSP that can be used to distinguish the LPSS devices from others.
--- drivers/spi/spi-pxa2xx.c | 133 ++++++++++++++++++++++++++++++++++++++-- drivers/spi/spi-pxa2xx.h | 6 ++ include/linux/pxa2xx_ssp.h | 9 +++ include/linux/spi/pxa2xx_spi.h | 1 + 4 files changed, 145 insertions(+), 4 deletions(-)
drivers/spi/spi-pxa2xx.c +129 -4
@@ -1,5 +1,6 @@/* * Copyright (C) 2005 Stephen Street / StreetFire Sound Labs +* Copyright (C) 2013, Intel Corporation * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by
@@ -61,6 +62,98 @@ MODULE_ALIAS("platform:pxa2xx-spi"); | SSCR1_RFT | SSCR1_TFT | SSCR1_MWDS \ | SSCR1_SPH | SSCR1_SPO | SSCR1_LBM) +#define LPSS_RX_THRESH_DFLT 64 +#define LPSS_TX_LOTHRESH_DFLT 160 +#define LPSS_TX_HITHRESH_DFLT 224 + +/* Offset from drv_data->lpss_base */ +#define SPI_CS_CONTROL 0x18 +#define SPI_CS_CONTROL_SW_MODE BIT(0) +#define SPI_CS_CONTROL_CS_HIGH BIT(1) + +static bool is_lpss_ssp (const struct driver_data *drv_data) +{ +return drv_data->ssp_type ==LPSS_SSP ; +} + +/* +* Read and write LPSS SSP private registers. Caller must first check that +* is_lpss_ssp() returns true before these can be called. +*/ +static u32 __lpss_ssp_read_priv (struct driver_data *drv_data,unsigned offset) +{ +WARN_ON (!drv_data->lpss_base); +return readl (drv_data->lpss_base + offset); +} + +static void __lpss_ssp_write_priv (struct driver_data *drv_data, +unsigned offset,u32 value) +{ +WARN_ON (!drv_data->lpss_base); +writel (value, drv_data->lpss_base + offset); +} + +/* +* lpss_ssp_setup - perform LPSS SSP specific setup +* @drv_data: pointer to the driver private data +* +* Perform LPSS SSP specific setup. This function must be called first if +* one is going to use LPSS SSP private registers. +*/ +static void lpss_ssp_setup (struct driver_data *drv_data) +{ +unsigned offset =0x400 ; +u32 value, orig; + +if (!is_lpss_ssp (drv_data)) +return ; + +/* +* Perform auto-detection of the LPSS SSP private registers. They +* can be either at 1k or 2k offset from the base address. +*/ + orig =readl (drv_data->ioaddr + offset +SPI_CS_CONTROL ); + + value = orig |SPI_CS_CONTROL_SW_MODE ; +writel (value, drv_data->ioaddr + offset +SPI_CS_CONTROL ); + value =readl (drv_data->ioaddr + offset +SPI_CS_CONTROL ); +if (value != (orig |SPI_CS_CONTROL_SW_MODE )) { + offset =0x800 ; + goto detection_done; + } + + value &= ~SPI_CS_CONTROL_SW_MODE ; +writel (value, drv_data->ioaddr + offset +SPI_CS_CONTROL ); + value =readl (drv_data->ioaddr + offset +SPI_CS_CONTROL ); +if (value != orig) { + offset =0x800 ; + goto detection_done; + } + +detection_done: +/* Now set the LPSS base */ + drv_data->lpss_base = drv_data->ioaddr + offset; + +/* Enable software chip select control */ + value =SPI_CS_CONTROL_SW_MODE |SPI_CS_CONTROL_CS_HIGH ; +__lpss_ssp_write_priv (drv_data,SPI_CS_CONTROL , value); +} + +static void lpss_ssp_cs_control (struct driver_data *drv_data,bool enable) +{ +u32 value; + +if (!is_lpss_ssp (drv_data)) +return ; + + value =__lpss_ssp_read_priv (drv_data,SPI_CS_CONTROL ); +if (enable) + value &= ~SPI_CS_CONTROL_CS_HIGH ; +else + value |=SPI_CS_CONTROL_CS_HIGH ; +__lpss_ssp_write_priv (drv_data,SPI_CS_CONTROL , value); +} +static void cs_assert (struct driver_data *drv_data) {struct chip_data *chip = drv_data->cur_chip;
@@ -75,8 +168,12 @@ static void cs_assert(struct driver_data *drv_data)return ; } -if (gpio_is_valid (chip->gpio_cs)) +if (gpio_is_valid (chip->gpio_cs)) {gpio_set_value (chip->gpio_cs, chip->gpio_cs_inverted); +return ; + } + +lpss_ssp_cs_control (drv_data, true); }static void cs_deassert (struct driver_data *drv_data)
@@ -91,8 +188,12 @@ static void cs_deassert(struct driver_data *drv_data)return ; } -if (gpio_is_valid (chip->gpio_cs)) +if (gpio_is_valid (chip->gpio_cs)) {gpio_set_value (chip->gpio_cs, !chip->gpio_cs_inverted); +return ; + } + +lpss_ssp_cs_control (drv_data, false); }void write_SSSR_CS (struct driver_data *drv_data,u32 val)
@@ -651,6 +752,13 @@ static void pump_transfers(unsigned long data)write_SSSR_CS (drv_data, drv_data->clear_sr); } +if (is_lpss_ssp (drv_data)) { +if ((read_SSIRF (reg) &0xff ) != chip->lpss_rx_threshold) +write_SSIRF (chip->lpss_rx_threshold, reg); +if ((read_SSITF (reg) &0xffff ) != chip->lpss_tx_threshold) +write_SSITF (chip->lpss_tx_threshold, reg); + } +/* see if we need to reload the config registers */ if ((read_SSCR0 (reg) != cr0) || (read_SSCR1(reg) & SSCR1_CHANGE_MASK) !=
@@ -763,8 +871,17 @@ static int setup(struct spi_device *spi)struct chip_data *chip;struct driver_data *drv_data =spi_master_get_devdata (spi->master);unsigned int clk_div; -uint tx_thres =TX_THRESH_DFLT ; -uint rx_thres =RX_THRESH_DFLT ; +uint tx_thres, tx_hi_thres, rx_thres; + +if (is_lpss_ssp (drv_data)) { + tx_thres =LPSS_TX_LOTHRESH_DFLT ; + tx_hi_thres =LPSS_TX_HITHRESH_DFLT ; + rx_thres =LPSS_RX_THRESH_DFLT ; + }else { + tx_thres =TX_THRESH_DFLT ; + tx_hi_thres =0 ; + rx_thres =RX_THRESH_DFLT ; + }if (!pxa25x_ssp_comp (drv_data) && (spi->bits_per_word <4 || spi->bits_per_word >32 )) {
@@ -817,6 +934,8 @@ static int setup(struct spi_device *spi) chip->timeout = chip_info->timeout;if (chip_info->tx_threshold) tx_thres = chip_info->tx_threshold; +if (chip_info->tx_hi_threshold) + tx_hi_thres = chip_info->tx_hi_threshold;if (chip_info->rx_threshold) rx_thres = chip_info->rx_threshold; chip->enable_dma = drv_data->master_info->enable_dma;
@@ -828,6 +947,10 @@ static int setup(struct spi_device *spi) chip->threshold = (SSCR1_RxTresh (rx_thres) &SSCR1_RFT ) | (SSCR1_TxTresh (tx_thres) &SSCR1_TFT ); + chip->lpss_rx_threshold =SSIRF_RxThresh (rx_thres); + chip->lpss_tx_threshold =SSITF_TxLoThresh (tx_thres) + |SSITF_TxHiThresh (tx_hi_thres); +/* set dma burst and threshold outside of chip_info path so that if * chip_info goes away after setting chip->enable_dma, the * burst and threshold can still respond to changes in bits_per_word */
@@ -1014,6 +1137,8 @@ static int pxa2xx_spi_probe(struct platform_device *pdev)write_SSTO (0 , drv_data->ioaddr);write_SSPSP (0 , drv_data->ioaddr); +lpss_ssp_setup (drv_data); +tasklet_init (&drv_data->pump_transfers, pump_transfers, (unsigned long )drv_data);
drivers/spi/spi-pxa2xx.h +6 -0
@@ -86,6 +86,8 @@ struct driver_data {int (*read)(struct driver_data *drv_data);irqreturn_t (*transfer_handler)(struct driver_data *drv_data);void (*cs_control)(u32 command); + +void __iomem *lpss_base; };struct chip_data {
@@ -97,6 +99,8 @@ struct chip_data {u32 dma_burst_size;u32 threshold;u32 dma_threshold; +u16 lpss_rx_threshold; +u16 lpss_tx_threshold;u8 enable_dma;u8 bits_per_word;u32 speed_hz;
@@ -124,6 +128,8 @@ DEFINE_SSP_REG(SSITR, 0x0c) DEFINE_SSP_REG(SSDR, 0x10) DEFINE_SSP_REG(SSTO, 0x28) DEFINE_SSP_REG(SSPSP, 0x2c) +DEFINE_SSP_REG(SSITF, SSITF) +DEFINE_SSP_REG(SSIRF, SSIRF)#define START_STATE ((void *)0)#define RUNNING_STATE ((void *)1)
include/linux/pxa2xx_ssp.h +9 -0
@@ -155,6 +155,14 @@#define SSACD_ACDS (x) ((x) << 0)/* Audio clock divider select */ #define SSACD_SCDX8 (1 << 7)/* SYSCLK division ratio select */ +/* LPSS SSP */ +#define SSITF 0x44/* TX FIFO trigger level */ +#define SSITF_TxLoThresh (x) (((x) - 1) << 8) +#define SSITF_TxHiThresh (x) ((x) - 1) + +#define SSIRF 0x48/* RX FIFO trigger level */ +#define SSIRF_RxThresh (x) ((x) - 1) +enum pxa_ssp_type {SSP_UNDEFINED =0 , PXA25x_SSP,/* pxa 210, 250, 255, 26x */
@@ -164,6 +172,7 @@ enum pxa_ssp_type {PXA168_SSP ,PXA910_SSP ,CE4100_SSP , + LPSS_SSP, }; struct ssp_device {
include/linux/spi/pxa2xx_spi.h +1 -0
@@ -44,6 +44,7 @@ struct pxa2xx_spi_master {*/ struct pxa2xx_spi_chip {u8 tx_threshold; +u8 tx_hi_threshold;u8 rx_threshold;u8 dma_burst_size;u32 timeout;
Signature · 1 line
1.7.10.4
PATCH v2 10/10 spi/pxa2xx: add support for Lynxpoint SPI controllers
In reply to Mika WesterbergIntel Lynxpoint PCH Low Power Subsystem has two general purpose SPI controllers that are LPSS_SSP compatible. These controllers are enumerated from ACPI namespace with ACPI IDs INT33C0 and INT33C1.
--- drivers/spi/Kconfig | 2 +- drivers/spi/spi-pxa2xx.c | 110 +++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 109 insertions(+), 3 deletions(-)
drivers/spi/Kconfig +1 -1
@@ -304,7 +304,7 @@ config SPI_PXA2XX_DMA config SPI_PXA2XX tristate "PXA2xx SSP SPI master" - depends on ARCH_PXA || PCI + depends on ARCH_PXA || PCI || ACPI select PXA_SSP if ARCH_PXA select SPI_PXA2XX_PXADMA if ARCH_PXA select SPI_PXA2XX_DMA if DMA_ENGINE && !ARCH_PXA
drivers/spi/spi-pxa2xx.c +108 -2
146 lines not on this page · raw message
Signature · 1 line
1.7.10.4