Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-12-28 13:51:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

[ARM] pxa: make pxa2xx_spi driver use ssp_request()/ssp_free()

Browse Source 
1. make pxa2xx_spi.c use ssp_request() and ssp_free() to get the common
   information of the designated SSP port.

2. remove those IRQ/memory request code, ssp_request() has done that for
   the driver

3. the SPI platform device is thus made psuedo, no resource (memory/IRQ)
   has to be defined, all will be retreived by ssp_request()

4. introduce ssp_get_clk_div() to handle controller difference in clock
   divisor setting

5. use clk_xxx() API for clock enable/disable, and clk_get_rate() to
   handle the different SSP clock frequency between different processors

Signed-off-by: eric miao <eric.miao@marvell.com>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
This commit is contained in:
eric miao 2007-11-21 18:50:53 +08:00 committed by Russell King
parent 3dcb00ea58
commit 2f1a74e5a2
4 changed files with 53 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
arch/arm/mach-pxa/lubbock.c
View File

@ -206,30 +206,13 @@ static struct resource smc91x_resources[] = {
* (to J5) and poking board registers (as done below). Else it's only useful * (to J5) and poking board registers (as done below). Else it's only useful
* for the temperature sensors. * for the temperature sensors.
*/ */
static struct resource pxa_ssp_resources[] = {
[0] = {
.start = __PREG(SSCR0_P(1)),
.end = __PREG(SSCR0_P(1)) + 0x14,
.flags = IORESOURCE_MEM,
},
[1] = {
.start = IRQ_SSP,
.end = IRQ_SSP,
.flags = IORESOURCE_IRQ,
},
};
static struct pxa2xx_spi_master pxa_ssp_master_info = { static struct pxa2xx_spi_master pxa_ssp_master_info = {
.ssp_type = PXA25x_SSP,
.clock_enable = CKEN_SSP,
.num_chipselect = 0, .num_chipselect = 0,
}; };
static struct platform_device pxa_ssp = { static struct platform_device pxa_ssp = {
.name = "pxa2xx-spi", .name = "pxa2xx-spi",
.id = 1, .id = 1,
.resource = pxa_ssp_resources,
.num_resources = ARRAY_SIZE(pxa_ssp_resources),
.dev = { .dev = {
.platform_data = &pxa_ssp_master_info, .platform_data = &pxa_ssp_master_info,
}, },

1
drivers/spi/Kconfig
View File

@ -153,6 +153,7 @@ config SPI_OMAP24XX
config SPI_PXA2XX config SPI_PXA2XX
tristate "PXA2xx SSP SPI master" tristate "PXA2xx SSP SPI master"
depends on SPI_MASTER && ARCH_PXA && EXPERIMENTAL depends on SPI_MASTER && ARCH_PXA && EXPERIMENTAL
select PXA_SSP
help help
This enables using a PXA2xx SSP port as a SPI master controller. This enables using a PXA2xx SSP port as a SPI master controller.
The driver can be configured to use any SSP port and additional The driver can be configured to use any SSP port and additional

138
drivers/spi/pxa2xx_spi.c
View File

@ -27,6 +27,7 @@
#include <linux/spi/spi.h> #include <linux/spi/spi.h>
#include <linux/workqueue.h> #include <linux/workqueue.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/clk.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/irq.h> #include <asm/irq.h>
@ -37,6 +38,7 @@
#include <asm/arch/hardware.h> #include <asm/arch/hardware.h>
#include <asm/arch/pxa-regs.h> #include <asm/arch/pxa-regs.h>
#include <asm/arch/regs-ssp.h> #include <asm/arch/regs-ssp.h>
#include <asm/arch/ssp.h>
#include <asm/arch/pxa2xx_spi.h> #include <asm/arch/pxa2xx_spi.h>
MODULE_AUTHOR("Stephen Street"); MODULE_AUTHOR("Stephen Street");
@ -81,6 +83,9 @@ struct driver_data {
/* Driver model hookup */ /* Driver model hookup */
struct platform_device *pdev; struct platform_device *pdev;
/* SSP Info */
struct ssp_device *ssp;
/* SPI framework hookup */ /* SPI framework hookup */
enum pxa_ssp_type ssp_type; enum pxa_ssp_type ssp_type;
struct spi_master *master; struct spi_master *master;
@ -779,6 +784,16 @@ int set_dma_burst_and_threshold(struct chip_data *chip, struct spi_device *spi,
return retval; return retval;
} }
static unsigned int ssp_get_clk_div(struct ssp_device *ssp, int rate)
{
unsigned long ssp_clk = clk_get_rate(ssp->clk);
if (ssp->type == PXA25x_SSP)
return ((ssp_clk / (2 * rate) - 1) & 0xff) << 8;
else
return ((ssp_clk / rate - 1) & 0xfff) << 8;
}
static void pump_transfers(unsigned long data) static void pump_transfers(unsigned long data)
{ {
struct driver_data *drv_data = (struct driver_data *)data; struct driver_data *drv_data = (struct driver_data *)data;
@ -786,6 +801,7 @@ static void pump_transfers(unsigned long data)
struct spi_transfer *transfer = NULL; struct spi_transfer *transfer = NULL;
struct spi_transfer *previous = NULL; struct spi_transfer *previous = NULL;
struct chip_data *chip = NULL; struct chip_data *chip = NULL;
struct ssp_device *ssp = drv_data->ssp;
void *reg = drv_data->ioaddr; void *reg = drv_data->ioaddr;
u32 clk_div = 0; u32 clk_div = 0;
u8 bits = 0; u8 bits = 0;
@ -867,12 +883,7 @@ static void pump_transfers(unsigned long data)
if (transfer->bits_per_word) if (transfer->bits_per_word)
bits = transfer->bits_per_word; bits = transfer->bits_per_word;
if (reg == SSP1_VIRT) clk_div = ssp_get_clk_div(ssp, speed);
clk_div = SSP1_SerClkDiv(speed);
else if (reg == SSP2_VIRT)
clk_div = SSP2_SerClkDiv(speed);
else if (reg == SSP3_VIRT)
clk_div = SSP3_SerClkDiv(speed);
if (bits <= 8) { if (bits <= 8) {
drv_data->n_bytes = 1; drv_data->n_bytes = 1;
@ -1075,6 +1086,7 @@ static int setup(struct spi_device *spi)
struct pxa2xx_spi_chip *chip_info = NULL; struct pxa2xx_spi_chip *chip_info = NULL;
struct chip_data *chip; struct chip_data *chip;
struct driver_data *drv_data = spi_master_get_devdata(spi->master); struct driver_data *drv_data = spi_master_get_devdata(spi->master);
struct ssp_device *ssp = drv_data->ssp;
unsigned int clk_div; unsigned int clk_div;
if (!spi->bits_per_word) if (!spi->bits_per_word)
@ -1158,18 +1170,7 @@ static int setup(struct spi_device *spi)
} }
} }
if (drv_data->ioaddr == SSP1_VIRT) clk_div = ssp_get_clk_div(ssp, spi->max_speed_hz);
clk_div = SSP1_SerClkDiv(spi->max_speed_hz);
else if (drv_data->ioaddr == SSP2_VIRT)
clk_div = SSP2_SerClkDiv(spi->max_speed_hz);
else if (drv_data->ioaddr == SSP3_VIRT)
clk_div = SSP3_SerClkDiv(spi->max_speed_hz);
else
{
dev_err(&spi->dev, "failed setup: unknown IO address=0x%p\n",
drv_data->ioaddr);
return -ENODEV;
}
chip->speed_hz = spi->max_speed_hz; chip->speed_hz = spi->max_speed_hz;
chip->cr0 = clk_div chip->cr0 = clk_div
@ -1184,15 +1185,15 @@ static int setup(struct spi_device *spi)
/* NOTE: PXA25x_SSP _could_ use external clocking ... */ /* NOTE: PXA25x_SSP _could_ use external clocking ... */
if (drv_data->ssp_type != PXA25x_SSP) if (drv_data->ssp_type != PXA25x_SSP)
dev_dbg(&spi->dev, "%d bits/word, %d Hz, mode %d\n", dev_dbg(&spi->dev, "%d bits/word, %ld Hz, mode %d\n",
spi->bits_per_word, spi->bits_per_word,
(CLOCK_SPEED_HZ) clk_get_rate(ssp->clk)
/ (1 + ((chip->cr0 & SSCR0_SCR) >> 8)), / (1 + ((chip->cr0 & SSCR0_SCR) >> 8)),
spi->mode & 0x3); spi->mode & 0x3);
else else
dev_dbg(&spi->dev, "%d bits/word, %d Hz, mode %d\n", dev_dbg(&spi->dev, "%d bits/word, %ld Hz, mode %d\n",
spi->bits_per_word, spi->bits_per_word,
(CLOCK_SPEED_HZ/2) clk_get_rate(ssp->clk)
/ (1 + ((chip->cr0 & SSCR0_SCR) >> 8)), / (1 + ((chip->cr0 & SSCR0_SCR) >> 8)),
spi->mode & 0x3); spi->mode & 0x3);
@ -1324,14 +1325,14 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
struct pxa2xx_spi_master *platform_info; struct pxa2xx_spi_master *platform_info;
struct spi_master *master; struct spi_master *master;
struct driver_data *drv_data = 0; struct driver_data *drv_data = 0;
struct resource *memory_resource; struct ssp_device *ssp;
int irq;
int status = 0; int status = 0;
platform_info = dev->platform_data; platform_info = dev->platform_data;
if (platform_info->ssp_type == SSP_UNDEFINED) { ssp = ssp_request(pdev->id, pdev->name);
dev_err(&pdev->dev, "undefined SSP\n"); if (ssp == NULL) {
dev_err(&pdev->dev, "failed to request SSP%d\n", pdev->id);
return -ENODEV; return -ENODEV;
} }
@ -1339,12 +1340,14 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
master = spi_alloc_master(dev, sizeof(struct driver_data) + 16); master = spi_alloc_master(dev, sizeof(struct driver_data) + 16);
if (!master) { if (!master) {
dev_err(&pdev->dev, "can not alloc spi_master\n"); dev_err(&pdev->dev, "can not alloc spi_master\n");
ssp_free(ssp);
return -ENOMEM; return -ENOMEM;
} }
drv_data = spi_master_get_devdata(master); drv_data = spi_master_get_devdata(master);
drv_data->master = master; drv_data->master = master;
drv_data->master_info = platform_info; drv_data->master_info = platform_info;
drv_data->pdev = pdev; drv_data->pdev = pdev;
drv_data->ssp = ssp;
master->bus_num = pdev->id; master->bus_num = pdev->id;
master->num_chipselect = platform_info->num_chipselect; master->num_chipselect = platform_info->num_chipselect;
@ -1352,21 +1355,13 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
master->setup = setup; master->setup = setup;
master->transfer = transfer; master->transfer = transfer;
drv_data->ssp_type = platform_info->ssp_type; drv_data->ssp_type = ssp->type;
drv_data->null_dma_buf = (u32 *)ALIGN((u32)(drv_data + drv_data->null_dma_buf = (u32 *)ALIGN((u32)(drv_data +
sizeof(struct driver_data)), 8); sizeof(struct driver_data)), 8);
/* Setup register addresses */ drv_data->ioaddr = ssp->mmio_base;
memory_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0); drv_data->ssdr_physical = ssp->phys_base + SSDR;
if (!memory_resource) { if (ssp->type == PXA25x_SSP) {
dev_err(&pdev->dev, "memory resources not defined\n");
status = -ENODEV;
goto out_error_master_alloc;
}
drv_data->ioaddr = (void *)io_p2v((unsigned long)(memory_resource->start));
drv_data->ssdr_physical = memory_resource->start + 0x00000010;
if (platform_info->ssp_type == PXA25x_SSP) {
drv_data->int_cr1 = SSCR1_TIE | SSCR1_RIE; drv_data->int_cr1 = SSCR1_TIE | SSCR1_RIE;
drv_data->dma_cr1 = 0; drv_data->dma_cr1 = 0;
drv_data->clear_sr = SSSR_ROR; drv_data->clear_sr = SSSR_ROR;
@ -1378,15 +1373,7 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
drv_data->mask_sr = SSSR_TINT | SSSR_RFS | SSSR_TFS | SSSR_ROR; drv_data->mask_sr = SSSR_TINT | SSSR_RFS | SSSR_TFS | SSSR_ROR;
} }
/* Attach to IRQ */ status = request_irq(ssp->irq, ssp_int, 0, dev->bus_id, drv_data);
irq = platform_get_irq(pdev, 0);
if (irq < 0) {
dev_err(&pdev->dev, "irq resource not defined\n");
status = -ENODEV;
goto out_error_master_alloc;
}
status = request_irq(irq, ssp_int, 0, dev->bus_id, drv_data);
if (status < 0) { if (status < 0) {
dev_err(&pdev->dev, "can not get IRQ\n"); dev_err(&pdev->dev, "can not get IRQ\n");
goto out_error_master_alloc; goto out_error_master_alloc;
@ -1419,29 +1406,12 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
goto out_error_dma_alloc; goto out_error_dma_alloc;
} }
if (drv_data->ioaddr == SSP1_VIRT) { DRCMR(ssp->drcmr_rx) = DRCMR_MAPVLD | drv_data->rx_channel;
DRCMRRXSSDR = DRCMR_MAPVLD DRCMR(ssp->drcmr_tx) = DRCMR_MAPVLD | drv_data->tx_channel;
| drv_data->rx_channel;
DRCMRTXSSDR = DRCMR_MAPVLD
| drv_data->tx_channel;
} else if (drv_data->ioaddr == SSP2_VIRT) {
DRCMRRXSS2DR = DRCMR_MAPVLD
| drv_data->rx_channel;
DRCMRTXSS2DR = DRCMR_MAPVLD
| drv_data->tx_channel;
} else if (drv_data->ioaddr == SSP3_VIRT) {
DRCMRRXSS3DR = DRCMR_MAPVLD
| drv_data->rx_channel;
DRCMRTXSS3DR = DRCMR_MAPVLD
| drv_data->tx_channel;
} else {
dev_err(dev, "bad SSP type\n");
goto out_error_dma_alloc;
}
} }
/* Enable SOC clock */ /* Enable SOC clock */
pxa_set_cken(platform_info->clock_enable, 1); clk_enable(ssp->clk);
/* Load default SSP configuration */ /* Load default SSP configuration */
write_SSCR0(0, drv_data->ioaddr); write_SSCR0(0, drv_data->ioaddr);
@ -1480,7 +1450,7 @@ out_error_queue_alloc:
destroy_queue(drv_data); destroy_queue(drv_data);
out_error_clock_enabled: out_error_clock_enabled:
pxa_set_cken(platform_info->clock_enable, 0); clk_disable(ssp->clk);
out_error_dma_alloc: out_error_dma_alloc:
if (drv_data->tx_channel != -1) if (drv_data->tx_channel != -1)
@ -1489,17 +1459,18 @@ out_error_dma_alloc:
pxa_free_dma(drv_data->rx_channel); pxa_free_dma(drv_data->rx_channel);
out_error_irq_alloc: out_error_irq_alloc:
free_irq(irq, drv_data); free_irq(ssp->irq, drv_data);
out_error_master_alloc: out_error_master_alloc:
spi_master_put(master); spi_master_put(master);
ssp_free(ssp);
return status; return status;
} }
static int pxa2xx_spi_remove(struct platform_device *pdev) static int pxa2xx_spi_remove(struct platform_device *pdev)
{ {
struct driver_data *drv_data = platform_get_drvdata(pdev); struct driver_data *drv_data = platform_get_drvdata(pdev);
int irq; struct ssp_device *ssp = drv_data->ssp;
int status = 0; int status = 0;
if (!drv_data) if (!drv_data)
@ -1521,28 +1492,21 @@ static int pxa2xx_spi_remove(struct platform_device *pdev)
/* Disable the SSP at the peripheral and SOC level */ /* Disable the SSP at the peripheral and SOC level */
write_SSCR0(0, drv_data->ioaddr); write_SSCR0(0, drv_data->ioaddr);
pxa_set_cken(drv_data->master_info->clock_enable, 0); clk_disable(ssp->clk);
/* Release DMA */ /* Release DMA */
if (drv_data->master_info->enable_dma) { if (drv_data->master_info->enable_dma) {
if (drv_data->ioaddr == SSP1_VIRT) { DRCMR(ssp->drcmr_rx) = 0;
DRCMRRXSSDR = 0; DRCMR(ssp->drcmr_tx) = 0;
DRCMRTXSSDR = 0;
} else if (drv_data->ioaddr == SSP2_VIRT) {
DRCMRRXSS2DR = 0;
DRCMRTXSS2DR = 0;
} else if (drv_data->ioaddr == SSP3_VIRT) {
DRCMRRXSS3DR = 0;
DRCMRTXSS3DR = 0;
}
pxa_free_dma(drv_data->tx_channel); pxa_free_dma(drv_data->tx_channel);
pxa_free_dma(drv_data->rx_channel); pxa_free_dma(drv_data->rx_channel);
} }
/* Release IRQ */ /* Release IRQ */
irq = platform_get_irq(pdev, 0); free_irq(ssp->irq, drv_data);
if (irq >= 0)
free_irq(irq, drv_data); /* Release SSP */
ssp_free(ssp);
/* Disconnect from the SPI framework */ /* Disconnect from the SPI framework */
spi_unregister_master(drv_data->master); spi_unregister_master(drv_data->master);
@ -1577,6 +1541,7 @@ static int suspend_devices(struct device *dev, void *pm_message)
static int pxa2xx_spi_suspend(struct platform_device *pdev, pm_message_t state) static int pxa2xx_spi_suspend(struct platform_device *pdev, pm_message_t state)
{ {
struct driver_data *drv_data = platform_get_drvdata(pdev); struct driver_data *drv_data = platform_get_drvdata(pdev);
struct ssp_device *ssp = drv_data->ssp;
int status = 0; int status = 0;
/* Check all childern for current power state */ /* Check all childern for current power state */
@ -1589,7 +1554,7 @@ static int pxa2xx_spi_suspend(struct platform_device *pdev, pm_message_t state)
if (status != 0) if (status != 0)
return status; return status;
write_SSCR0(0, drv_data->ioaddr); write_SSCR0(0, drv_data->ioaddr);
pxa_set_cken(drv_data->master_info->clock_enable, 0); clk_disable(ssp->clk);
return 0; return 0;
} }
@ -1597,10 +1562,11 @@ static int pxa2xx_spi_suspend(struct platform_device *pdev, pm_message_t state)
static int pxa2xx_spi_resume(struct platform_device *pdev) static int pxa2xx_spi_resume(struct platform_device *pdev)
{ {
struct driver_data *drv_data = platform_get_drvdata(pdev); struct driver_data *drv_data = platform_get_drvdata(pdev);
struct ssp_device *ssp = drv_data->ssp;
int status = 0; int status = 0;
/* Enable the SSP clock */ /* Enable the SSP clock */
pxa_set_cken(drv_data->master_info->clock_enable, 1); clk_disable(ssp->clk);
/* Start the queue running */ /* Start the queue running */
status = start_queue(drv_data); status = start_queue(drv_data);

24
include/asm-arm/arch-pxa/pxa2xx_spi.h
View File

@ -22,32 +22,8 @@
#define PXA2XX_CS_ASSERT (0x01) #define PXA2XX_CS_ASSERT (0x01)
#define PXA2XX_CS_DEASSERT (0x02) #define PXA2XX_CS_DEASSERT (0x02)
#if defined(CONFIG_PXA25x)
#define CLOCK_SPEED_HZ 3686400
#define SSP1_SerClkDiv(x) (((CLOCK_SPEED_HZ/2/(x+1))<<8)&0x0000ff00)
#define SSP2_SerClkDiv(x) (((CLOCK_SPEED_HZ/(x+1))<<8)&0x000fff00)
#define SSP3_SerClkDiv(x) (((CLOCK_SPEED_HZ/(x+1))<<8)&0x000fff00)
#elif defined(CONFIG_PXA27x)
#define CLOCK_SPEED_HZ 13000000
#define SSP1_SerClkDiv(x) (((CLOCK_SPEED_HZ/(x+1))<<8)&0x000fff00)
#define SSP2_SerClkDiv(x) (((CLOCK_SPEED_HZ/(x+1))<<8)&0x000fff00)
#define SSP3_SerClkDiv(x) (((CLOCK_SPEED_HZ/(x+1))<<8)&0x000fff00)
#endif
#define SSP1_VIRT ((void *)(io_p2v(__PREG(SSCR0_P(1)))))
#define SSP2_VIRT ((void *)(io_p2v(__PREG(SSCR0_P(2)))))
#define SSP3_VIRT ((void *)(io_p2v(__PREG(SSCR0_P(3)))))
enum pxa_ssp_type {
SSP_UNDEFINED = 0,
PXA25x_SSP, /* pxa 210, 250, 255, 26x */
PXA25x_NSSP, /* pxa 255, 26x (including ASSP) */
PXA27x_SSP,
};
/* device.platform_data for SSP controller devices */ /* device.platform_data for SSP controller devices */
struct pxa2xx_spi_master { struct pxa2xx_spi_master {
enum pxa_ssp_type ssp_type;
u32 clock_enable; u32 clock_enable;
u16 num_chipselect; u16 num_chipselect;
u8 enable_dma; u8 enable_dma;