Merge branch 'pxa-plat' into devel

* pxa-plat: (53 commits)
  [ARM] 4762/1: Basic support for Toradex Colibri module
  [ARM] pxa: fix mci_init functions returning -1
  [ARM] 4737/1: Refactor corgi_lcd to improve readability + bugfix
  [ARM] 4747/1: pcm027: support for pcm990 baseboard for phyCORE-PXA270
  [ARM] 4746/1: pcm027: network support for phyCORE-PXA270
  [ARM] 4745/1: pcm027: default configuration
  [ARM] 4744/1: pcm027: add support for phyCORE-PXA270 CPU module
  [NET] smc91x: Make smc91x use IRQ resource trigger flags
  [ARM] pxa: add default config for littleton
  [ARM] pxa: add basic support for Littleton (PXA3xx Form Factor Platform)
  [ARM] 4664/1: Add basic support for HTC Magician PDA phones
  [ARM] 4649/1: Base support for pxa-based Toshiba e-series PDAs.
  [ARM] pxa: skip registers saving/restoring if entering standby mode
  [ARM] pxa: fix PXA27x resume
  [ARM] pxa: Avoid fiddling with CKEN register on suspend
  [ARM] pxa: Add PXA3 standby code hooked into the IRQ wake scheme
  [ARM] pxa: Add zylonite MFP wakeup configurations
  [ARM] pxa: program MFPs for low power mode when suspending
  [ARM] pxa: make MFP configuration processor independent
  [ARM] pxa: remove un-used pxa3xx_mfp_set_xxx() functions
  ...

Conflicts:

	arch/arm/mach-pxa/ssp.c

Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>

13 files changed, 173 insertions, 132 deletions

diff --git a/drivers/input/touchscreen/corgi_ts.c b/drivers/input/touchscreen/corgi_ts.c
index b1b2e07bf080..99d92f5c93d6 100644
--- a/drivers/input/touchscreen/corgi_ts.c
+++ b/drivers/input/touchscreen/corgi_ts.c
@@ -74,10 +74,10 @@ extern unsigned int get_clk_frequency_khz(int info);
 
 static unsigned long calc_waittime(struct corgi_ts *corgi_ts)
 {
-        unsigned long hsync_len = corgi_ts->machinfo->get_hsync_len();
+        unsigned long hsync_invperiod = corgi_ts->machinfo->get_hsync_invperiod();
 
-        if (hsync_len)
-                return get_clk_frequency_khz(0)*1000/hsync_len;
+        if (hsync_invperiod)
+                return get_clk_frequency_khz(0)*1000/hsync_invperiod;
         else
                 return 0;
 }
@@ -114,7 +114,7 @@ static int sync_receive_data_send_cmd(struct corgi_ts *corgi_ts, int doRecive, i
                         if (timer2-timer1 > wait_time) {
                                 /* too slow - timeout, try again */
                                 corgi_ts->machinfo->wait_hsync();
-                                /* get OSCR */
+                                /* get CCNT */
                                 CCNT(timer1);
                                 /* Wait after HSync */
                                 CCNT(timer2);
diff --git a/drivers/mmc/host/pxamci.c b/drivers/mmc/host/pxamci.c
index 1654a3330340..1ea8482037bb 100644
--- a/drivers/mmc/host/pxamci.c
+++ b/drivers/mmc/host/pxamci.c
@@ -65,6 +65,8 @@ struct pxamci_host {
         unsigned int            dma_len;
 
         unsigned int            dma_dir;
+        unsigned int            dma_drcmrrx;
+        unsigned int            dma_drcmrtx;
 };
 
 static void pxamci_stop_clock(struct pxamci_host *host)
@@ -131,13 +133,13 @@ static void pxamci_setup_data(struct pxamci_host *host, struct mmc_data *data)
         if (data->flags & MMC_DATA_READ) {
                 host->dma_dir = DMA_FROM_DEVICE;
                 dcmd = DCMD_INCTRGADDR | DCMD_FLOWTRG;
-                DRCMRTXMMC = 0;
-                DRCMRRXMMC = host->dma | DRCMR_MAPVLD;
+                DRCMR(host->dma_drcmrtx) = 0;
+                DRCMR(host->dma_drcmrrx) = host->dma | DRCMR_MAPVLD;
         } else {
                 host->dma_dir = DMA_TO_DEVICE;
                 dcmd = DCMD_INCSRCADDR | DCMD_FLOWSRC;
-                DRCMRRXMMC = 0;
-                DRCMRTXMMC = host->dma | DRCMR_MAPVLD;
+                DRCMR(host->dma_drcmrrx) = 0;
+                DRCMR(host->dma_drcmrtx) = host->dma | DRCMR_MAPVLD;
         }
 
         dcmd |= DCMD_BURST32 | DCMD_WIDTH1;
@@ -375,14 +377,23 @@ static void pxamci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 if (host->clkrt == CLKRT_OFF)
                         clk_enable(host->clk);
 
-                /*
-                 * clk might result in a lower divisor than we
-                 * desire.  check for that condition and adjust
-                 * as appropriate.
-                 */
-                if (rate / clk > ios->clock)
-                        clk <<= 1;
-                host->clkrt = fls(clk) - 1;
+                if (ios->clock == 26000000) {
+                        /* to support 26MHz on pxa300/pxa310 */
+                        host->clkrt = 7;
+                } else {
+                        /* to handle (19.5MHz, 26MHz) */
+                        if (!clk)
+                                clk = 1;
+
+                        /*
+                         * clk might result in a lower divisor than we
+                         * desire.  check for that condition and adjust
+                         * as appropriate.
+                         */
+                        if (rate / clk > ios->clock)
+                                clk <<= 1;
+                        host->clkrt = fls(clk) - 1;
+                }
 
                 /*
                  * we write clkrt on the next command
@@ -459,7 +470,7 @@ static int pxamci_probe(struct platform_device *pdev)
 {
         struct mmc_host *mmc;
         struct pxamci_host *host = NULL;
-        struct resource *r;
+        struct resource *r, *dmarx, *dmatx;
         int ret, irq;
 
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -519,7 +530,8 @@ static int pxamci_probe(struct platform_device *pdev)
          * Calculate minimum clock rate, rounding up.
          */
         mmc->f_min = (host->clkrate + 63) / 64;
-        mmc->f_max = host->clkrate;
+        mmc->f_max = (cpu_is_pxa300() || cpu_is_pxa310()) ? 26000000
+                                                          : host->clkrate;
 
         mmc->ocr_avail = host->pdata ?
                          host->pdata->ocr_mask :
@@ -529,6 +541,9 @@ static int pxamci_probe(struct platform_device *pdev)
         if (!cpu_is_pxa21x() && !cpu_is_pxa25x()) {
                 mmc->caps |= MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ;
                 host->cmdat |= CMDAT_SDIO_INT_EN;
+                if (cpu_is_pxa300() || cpu_is_pxa310())
+                        mmc->caps |= MMC_CAP_MMC_HIGHSPEED |
+                                     MMC_CAP_SD_HIGHSPEED;
         }
 
         host->sg_cpu = dma_alloc_coherent(&pdev->dev, PAGE_SIZE, &host->sg_dma, GFP_KERNEL);
@@ -570,6 +585,20 @@ static int pxamci_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, mmc);
 
+        dmarx = platform_get_resource(pdev, IORESOURCE_DMA, 0);
+        if (!dmarx) {
+                ret = -ENXIO;
+                goto out;
+        }
+        host->dma_drcmrrx = dmarx->start;
+
+        dmatx = platform_get_resource(pdev, IORESOURCE_DMA, 1);
+        if (!dmatx) {
+                ret = -ENXIO;
+                goto out;
+        }
+        host->dma_drcmrtx = dmatx->start;
+
         if (host->pdata && host->pdata->init)
                 host->pdata->init(&pdev->dev, pxamci_detect_irq, mmc);
 
@@ -613,8 +642,8 @@ static int pxamci_remove(struct platform_device *pdev)
                        END_CMD_RES|PRG_DONE|DATA_TRAN_DONE,
                        host->base + MMC_I_MASK);
 
-                DRCMRRXMMC = 0;
-                DRCMRTXMMC = 0;
+                DRCMR(host->dma_drcmrrx) = 0;
+                DRCMR(host->dma_drcmrtx) = 0;
 
                 free_irq(host->irq, host);
                 pxa_free_dma(host->dma);
diff --git a/drivers/mmc/host/pxamci.h b/drivers/mmc/host/pxamci.h
index 748c7706f237..f6c2e2fcce37 100644
--- a/drivers/mmc/host/pxamci.h
+++ b/drivers/mmc/host/pxamci.h
@@ -68,7 +68,7 @@
 #define PRG_DONE                (1 << 1)
 #define DATA_TRAN_DONE          (1 << 0)
 
-#ifdef CONFIG_PXA27x
+#if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
 #define MMC_I_MASK_ALL          0x00001fff
 #else
 #define MMC_I_MASK_ALL          0x0000007f
diff --git a/drivers/net/dm9000.c b/drivers/net/dm9000.c
index 3286d2a0a870..6a20a5491a96 100644
--- a/drivers/net/dm9000.c
+++ b/drivers/net/dm9000.c
@@ -66,6 +66,7 @@
 #include <linux/dm9000.h>
 #include <linux/delay.h>
 #include <linux/platform_device.h>
+#include <linux/irq.h>
 
 #include <asm/delay.h>
 #include <asm/irq.h>
@@ -113,7 +114,7 @@
 #define writesl outsl
 #define DM9000_IRQ_FLAGS        (IRQF_SHARED | IRQF_TRIGGER_HIGH)
 #else
-#define DM9000_IRQ_FLAGS        IRQF_SHARED
+#define DM9000_IRQ_FLAGS        (IRQF_SHARED | IRQT_RISING)
 #endif
 
 /*
diff --git a/drivers/net/smc91x.c b/drivers/net/smc91x.c
index 7da7589d45dd..4020e9e955b3 100644
--- a/drivers/net/smc91x.c
+++ b/drivers/net/smc91x.c
@@ -1775,7 +1775,8 @@ static int __init smc_findirq(void __iomem *ioaddr)
  * o  actually GRAB the irq.
  * o  GRAB the region
  */
-static int __init smc_probe(struct net_device *dev, void __iomem *ioaddr)
+static int __init smc_probe(struct net_device *dev, void __iomem *ioaddr,
+                            unsigned long irq_flags)
 {
         struct smc_local *lp = netdev_priv(dev);
         static int version_printed = 0;
@@ -1941,7 +1942,7 @@ static int __init smc_probe(struct net_device *dev, void __iomem *ioaddr)
         }
 
         /* Grab the IRQ */
-        retval = request_irq(dev->irq, &smc_interrupt, SMC_IRQ_FLAGS, dev->name, dev);
+        retval = request_irq(dev->irq, &smc_interrupt, irq_flags, dev->name, dev);
         if (retval)
                 goto err_out;
 
@@ -2123,8 +2124,9 @@ static void smc_release_datacs(struct platform_device *pdev, struct net_device *
 static int smc_drv_probe(struct platform_device *pdev)
 {
         struct net_device *ndev;
-        struct resource *res;
+        struct resource *res, *ires;
         unsigned int __iomem *addr;
+        unsigned long irq_flags = SMC_IRQ_FLAGS;
         int ret;
 
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "smc91x-regs");
@@ -2150,12 +2152,17 @@ static int smc_drv_probe(struct platform_device *pdev)
         SET_NETDEV_DEV(ndev, &pdev->dev);
 
         ndev->dma = (unsigned char)-1;
-        ndev->irq = platform_get_irq(pdev, 0);
-        if (ndev->irq < 0) {
+
+        ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!ires) {
                 ret = -ENODEV;
                 goto out_free_netdev;
         }
 
+        ndev->irq = ires->start;
+        if (SMC_IRQ_FLAGS == -1)
+                irq_flags = ires->flags & IRQF_TRIGGER_MASK;
+
         ret = smc_request_attrib(pdev);
         if (ret)
                 goto out_free_netdev;
@@ -2181,7 +2188,7 @@ static int smc_drv_probe(struct platform_device *pdev)
 #endif
 
         platform_set_drvdata(pdev, ndev);
-        ret = smc_probe(ndev, addr);
+        ret = smc_probe(ndev, addr, irq_flags);
         if (ret != 0)
                 goto out_iounmap;
 
diff --git a/drivers/net/smc91x.h b/drivers/net/smc91x.h
index 07b7f7120e37..271c28dc9baa 100644
--- a/drivers/net/smc91x.h
+++ b/drivers/net/smc91x.h
@@ -54,6 +54,7 @@
 #define SMC_outw(v, a, r)       writew(v, (a) + (r))
 #define SMC_insw(a, r, p, l)    readsw((a) + (r), p, l)
 #define SMC_outsw(a, r, p, l)   writesw((a) + (r), p, l)
+#define SMC_IRQ_FLAGS           (-1)    /* from resource */
 
 #elif defined(CONFIG_BLACKFIN)
 
@@ -158,7 +159,7 @@
 #define SMC_outw(v, a, r)       writew(v, (a) + (r))
 #define SMC_outsw(a, r, p, l)   writesw((a) + (r), p, l)
 
-#define SMC_IRQ_FLAGS           (0)
+#define SMC_IRQ_FLAGS           (-1)
 
 #elif defined(CONFIG_SA1100_ASSABET)
 
@@ -177,6 +178,7 @@
 #define SMC_outb(v, a, r)       writeb(v, (a) + (r))
 #define SMC_insb(a, r, p, l)    readsb((a) + (r), p, (l))
 #define SMC_outsb(a, r, p, l)   writesb((a) + (r), p, (l))
+#define SMC_IRQ_FLAGS           (-1)    /* from resource */
 
 #elif   defined(CONFIG_MACH_LOGICPD_PXA270)
 
@@ -194,7 +196,8 @@
 #elif   defined(CONFIG_ARCH_INNOKOM) || \
         defined(CONFIG_MACH_MAINSTONE) || \
         defined(CONFIG_ARCH_PXA_IDP) || \
-        defined(CONFIG_ARCH_RAMSES)
+        defined(CONFIG_ARCH_RAMSES) || \
+        defined(CONFIG_ARCH_PCM027)
 
 #define SMC_CAN_USE_8BIT        1
 #define SMC_CAN_USE_16BIT       1
@@ -210,6 +213,7 @@
 #define SMC_outl(v, a, r)       writel(v, (a) + (r))
 #define SMC_insl(a, r, p, l)    readsl((a) + (r), p, l)
 #define SMC_outsl(a, r, p, l)   writesl((a) + (r), p, l)
+#define SMC_IRQ_FLAGS           (-1)    /* from resource */
 
 /* We actually can't write halfwords properly if not word aligned */
 static inline void
@@ -238,6 +242,7 @@ SMC_outw(u16 val, void __iomem *ioaddr, int reg)
 #define SMC_outsw(a, r, p, l)   outsw((a) + (r), p, l)
 #define SMC_outb(v, a, r)       writeb(v, (a) + (r))
 #define SMC_outw(v, a, r)       writew(v, (a) + (r))
+#define SMC_IRQ_FLAGS           (-1)    /* from resource */
 
 #elif   defined(CONFIG_ARCH_OMAP)
 
@@ -252,17 +257,7 @@ SMC_outw(u16 val, void __iomem *ioaddr, int reg)
 #define SMC_outw(v, a, r)       writew(v, (a) + (r))
 #define SMC_insw(a, r, p, l)    readsw((a) + (r), p, l)
 #define SMC_outsw(a, r, p, l)   writesw((a) + (r), p, l)
-
-#include <asm/mach-types.h>
-#include <asm/arch/cpu.h>
-
-#define SMC_IRQ_FLAGS (( \
-                   machine_is_omap_h2() \
-                || machine_is_omap_h3() \
-                || machine_is_omap_h4() \
-                || (machine_is_omap_innovator() && !cpu_is_omap1510()) \
-        ) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING)
-
+#define SMC_IRQ_FLAGS           (-1)    /* from resource */
 
 #elif   defined(CONFIG_SH_SH4202_MICRODEV)
 
@@ -453,8 +448,7 @@ static inline void LPD7_SMC_outsw (unsigned char* a, int r,
 #define SMC_outl(v, a, r)       writel(v, (a) + (r))
 #define SMC_insl(a, r, p, l)    readsl((a) + (r), p, l)
 #define SMC_outsl(a, r, p, l)   writesl((a) + (r), p, l)
-
-#define SMC_IRQ_FLAGS           (0)
+#define SMC_IRQ_FLAGS           (-1)    /* from resource */
 
 #else
 
diff --git a/drivers/pcmcia/pxa2xx_base.c b/drivers/pcmcia/pxa2xx_base.c
index 874923fcb2f9..e439044d88f2 100644
--- a/drivers/pcmcia/pxa2xx_base.c
+++ b/drivers/pcmcia/pxa2xx_base.c
@@ -29,6 +29,7 @@
 #include <asm/irq.h>
 #include <asm/system.h>
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/pxa2xx-regs.h>
 
 #include <pcmcia/cs_types.h>
 #include <pcmcia/ss.h>
diff --git a/drivers/rtc/rtc-sa1100.c b/drivers/rtc/rtc-sa1100.c
index 6f1e9a9804bc..2eb38520f0c8 100644
--- a/drivers/rtc/rtc-sa1100.c
+++ b/drivers/rtc/rtc-sa1100.c
@@ -337,6 +337,8 @@ static int sa1100_rtc_probe(struct platform_device *pdev)
         if (IS_ERR(rtc))
                 return PTR_ERR(rtc);
 
+        device_init_wakeup(&pdev->dev, 1);
+
         platform_set_drvdata(pdev, rtc);
 
         return 0;
@@ -352,9 +354,38 @@ static int sa1100_rtc_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_PM
+static int sa1100_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        if (pdev->dev.power.power_state.event != state.event) {
+                if (state.event == PM_EVENT_SUSPEND &&
+                    device_may_wakeup(&pdev->dev))
+                        enable_irq_wake(IRQ_RTCAlrm);
+
+                pdev->dev.power.power_state = state;
+        }
+        return 0;
+}
+
+static int sa1100_rtc_resume(struct platform_device *pdev)
+{
+        if (pdev->dev.power.power_state.event != PM_EVENT_ON) {
+                if (device_may_wakeup(&pdev->dev))
+                        disable_irq_wake(IRQ_RTCAlrm);
+                pdev->dev.power.power_state = PMSG_ON;
+        }
+        return 0;
+}
+#else
+#define sa1100_rtc_suspend      NULL
+#define sa1100_rtc_resume       NULL
+#endif
+
 static struct platform_driver sa1100_rtc_driver = {
         .probe          = sa1100_rtc_probe,
         .remove         = sa1100_rtc_remove,
+        .suspend        = sa1100_rtc_suspend,
+        .resume         = sa1100_rtc_resume,
         .driver         = {
                 .name           = "sa1100-rtc",
         },
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index abf05048c638..aaaea81e412a 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -153,6 +153,7 @@ config SPI_OMAP24XX
 config SPI_PXA2XX
         tristate "PXA2xx SSP SPI master"
         depends on SPI_MASTER && ARCH_PXA && EXPERIMENTAL
+        select PXA_SSP
         help
           This enables using a PXA2xx SSP port as a SPI master controller.
           The driver can be configured to use any SSP port and additional
diff --git a/drivers/spi/pxa2xx_spi.c b/drivers/spi/pxa2xx_spi.c
index 1c2ab541d37d..eb817b8eb024 100644
--- a/drivers/spi/pxa2xx_spi.c
+++ b/drivers/spi/pxa2xx_spi.c
@@ -27,6 +27,7 @@
 #include <linux/spi/spi.h>
 #include <linux/workqueue.h>
 #include <linux/delay.h>
+#include <linux/clk.h>
 
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -36,6 +37,8 @@
 
 #include <asm/arch/hardware.h>
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/regs-ssp.h>
+#include <asm/arch/ssp.h>
 #include <asm/arch/pxa2xx_spi.h>
 
 MODULE_AUTHOR("Stephen Street");
@@ -80,6 +83,9 @@ struct driver_data {
         /* Driver model hookup */
         struct platform_device *pdev;
 
+        /* SSP Info */
+        struct ssp_device *ssp;
+
         /* SPI framework hookup */
         enum pxa_ssp_type ssp_type;
         struct spi_master *master;
@@ -778,6 +784,16 @@ int set_dma_burst_and_threshold(struct chip_data *chip, struct spi_device *spi,
         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)
 {
         struct driver_data *drv_data = (struct driver_data *)data;
@@ -785,6 +801,7 @@ 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 *reg = drv_data->ioaddr;
         u32 clk_div = 0;
         u8 bits = 0;
@@ -866,12 +883,7 @@ static void pump_transfers(unsigned long data)
                 if (transfer->bits_per_word)
                         bits = transfer->bits_per_word;
 
-                if (reg == SSP1_VIRT)
-                        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);
+                clk_div = ssp_get_clk_div(ssp, speed);
 
                 if (bits <= 8) {
                         drv_data->n_bytes = 1;
@@ -1074,6 +1086,7 @@ 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;
 
         if (!spi->bits_per_word)
@@ -1157,18 +1170,7 @@ static int setup(struct spi_device *spi)
                 }
         }
 
-        if (drv_data->ioaddr == SSP1_VIRT)
-                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;
-        }
+        clk_div = ssp_get_clk_div(ssp, spi->max_speed_hz);
         chip->speed_hz = spi->max_speed_hz;
 
         chip->cr0 = clk_div
@@ -1183,15 +1185,15 @@ static int setup(struct spi_device *spi)
 
         /* NOTE:  PXA25x_SSP _could_ use external clocking ... */
         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,
-                                (CLOCK_SPEED_HZ)
+                                clk_get_rate(ssp->clk)
                                         / (1 + ((chip->cr0 & SSCR0_SCR) >> 8)),
                                 spi->mode & 0x3);
         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,
-                                (CLOCK_SPEED_HZ/2)
+                                clk_get_rate(ssp->clk)
                                         / (1 + ((chip->cr0 & SSCR0_SCR) >> 8)),
                                 spi->mode & 0x3);
 
@@ -1323,14 +1325,14 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
         struct pxa2xx_spi_master *platform_info;
         struct spi_master *master;
         struct driver_data *drv_data = 0;
-        struct resource *memory_resource;
-        int irq;
+        struct ssp_device *ssp;
         int status = 0;
 
         platform_info = dev->platform_data;
 
-        if (platform_info->ssp_type == SSP_UNDEFINED) {
-                dev_err(&pdev->dev, "undefined SSP\n");
+        ssp = ssp_request(pdev->id, pdev->name);
+        if (ssp == NULL) {
+                dev_err(&pdev->dev, "failed to request SSP%d\n", pdev->id);
                 return -ENODEV;
         }
 
@@ -1338,12 +1340,14 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
         master = spi_alloc_master(dev, sizeof(struct driver_data) + 16);
         if (!master) {
                 dev_err(&pdev->dev, "can not alloc spi_master\n");
+                ssp_free(ssp);
                 return -ENOMEM;
         }
         drv_data = spi_master_get_devdata(master);
         drv_data->master = master;
         drv_data->master_info = platform_info;
         drv_data->pdev = pdev;
+        drv_data->ssp = ssp;
 
         master->bus_num = pdev->id;
         master->num_chipselect = platform_info->num_chipselect;
@@ -1351,21 +1355,13 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
         master->setup = setup;
         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 +
                                                 sizeof(struct driver_data)), 8);
 
-        /* Setup register addresses */
-        memory_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!memory_resource) {
-                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->ioaddr = ssp->mmio_base;
+        drv_data->ssdr_physical = ssp->phys_base + SSDR;
+        if (ssp->type == PXA25x_SSP) {
                 drv_data->int_cr1 = SSCR1_TIE | SSCR1_RIE;
                 drv_data->dma_cr1 = 0;
                 drv_data->clear_sr = SSSR_ROR;
@@ -1377,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;
         }
 
-        /* Attach to IRQ */
-        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);
+        status = request_irq(ssp->irq, ssp_int, 0, dev->bus_id, drv_data);
         if (status < 0) {
                 dev_err(&pdev->dev, "can not get IRQ\n");
                 goto out_error_master_alloc;
@@ -1418,29 +1406,12 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
                         goto out_error_dma_alloc;
                 }
 
-                if (drv_data->ioaddr == SSP1_VIRT) {
-                                DRCMRRXSSDR = DRCMR_MAPVLD
-                                                | 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;
-                }
+                DRCMR(ssp->drcmr_rx) = DRCMR_MAPVLD | drv_data->rx_channel;
+                DRCMR(ssp->drcmr_tx) = DRCMR_MAPVLD | drv_data->tx_channel;
         }
 
         /* Enable SOC clock */
-        pxa_set_cken(platform_info->clock_enable, 1);
+        clk_enable(ssp->clk);
 
         /* Load default SSP configuration */
         write_SSCR0(0, drv_data->ioaddr);
@@ -1479,7 +1450,7 @@ out_error_queue_alloc:
         destroy_queue(drv_data);
 
 out_error_clock_enabled:
-        pxa_set_cken(platform_info->clock_enable, 0);
+        clk_disable(ssp->clk);
 
 out_error_dma_alloc:
         if (drv_data->tx_channel != -1)
@@ -1488,17 +1459,18 @@ out_error_dma_alloc:
                 pxa_free_dma(drv_data->rx_channel);
 
 out_error_irq_alloc:
-        free_irq(irq, drv_data);
+        free_irq(ssp->irq, drv_data);
 
 out_error_master_alloc:
         spi_master_put(master);
+        ssp_free(ssp);
         return status;
 }
 
 static int pxa2xx_spi_remove(struct platform_device *pdev)
 {
         struct driver_data *drv_data = platform_get_drvdata(pdev);
-        int irq;
+        struct ssp_device *ssp = drv_data->ssp;
         int status = 0;
 
         if (!drv_data)
@@ -1520,28 +1492,21 @@ static int pxa2xx_spi_remove(struct platform_device *pdev)
 
         /* Disable the SSP at the peripheral and SOC level */
         write_SSCR0(0, drv_data->ioaddr);
-        pxa_set_cken(drv_data->master_info->clock_enable, 0);
+        clk_disable(ssp->clk);
 
         /* Release DMA */
         if (drv_data->master_info->enable_dma) {
-                if (drv_data->ioaddr == SSP1_VIRT) {
-                        DRCMRRXSSDR = 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;
-                }
+                DRCMR(ssp->drcmr_rx) = 0;
+                DRCMR(ssp->drcmr_tx) = 0;
                 pxa_free_dma(drv_data->tx_channel);
                 pxa_free_dma(drv_data->rx_channel);
         }
 
         /* Release IRQ */
-        irq = platform_get_irq(pdev, 0);
-        if (irq >= 0)
-                free_irq(irq, drv_data);
+        free_irq(ssp->irq, drv_data);
+
+        /* Release SSP */
+        ssp_free(ssp);
 
         /* Disconnect from the SPI framework */
         spi_unregister_master(drv_data->master);
@@ -1576,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)
 {
         struct driver_data *drv_data = platform_get_drvdata(pdev);
+        struct ssp_device *ssp = drv_data->ssp;
         int status = 0;
 
         /* Check all childern for current power state */
@@ -1588,7 +1554,7 @@ static int pxa2xx_spi_suspend(struct platform_device *pdev, pm_message_t state)
         if (status != 0)
                 return status;
         write_SSCR0(0, drv_data->ioaddr);
-        pxa_set_cken(drv_data->master_info->clock_enable, 0);
+        clk_disable(ssp->clk);
 
         return 0;
 }
@@ -1596,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)
 {
         struct driver_data *drv_data = platform_get_drvdata(pdev);
+        struct ssp_device *ssp = drv_data->ssp;
         int status = 0;
 
         /* Enable the SSP clock */
-        pxa_set_cken(drv_data->master_info->clock_enable, 1);
+        clk_disable(ssp->clk);
 
         /* Start the queue running */
         status = start_queue(drv_data);
diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig
index 7580aa5da0f8..7a6499008b89 100644
--- a/drivers/usb/Kconfig
+++ b/drivers/usb/Kconfig
@@ -33,6 +33,7 @@ config USB_ARCH_HAS_OHCI
         default y if ARCH_LH7A404
         default y if ARCH_S3C2410
         default y if PXA27x
+        default y if PXA3xx
         default y if ARCH_EP93XX
         default y if ARCH_AT91
         default y if ARCH_PNX4008
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index ecfe800fd720..ddd4ee1f2413 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -997,7 +997,7 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         ohci_hcd_lh7a404_driver
 #endif
 
-#ifdef CONFIG_PXA27x
+#if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
 #include "ohci-pxa27x.c"
 #define PLATFORM_DRIVER         ohci_hcd_pxa27x_driver
 #endif
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index 23d2fe5a62f4..ff9a79843471 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -22,6 +22,7 @@
 #include <linux/device.h>
 #include <linux/signal.h>
 #include <linux/platform_device.h>
+#include <linux/clk.h>
 
 #include <asm/mach-types.h>
 #include <asm/hardware.h>
@@ -32,6 +33,8 @@
 
 #define UHCRHPS(x)              __REG2( 0x4C000050, (x)<<2 )
 
+static struct clk *usb_clk;
+
 /*
   PMM_NPS_MODE -- PMM Non-power switching mode
       Ports are powered continuously.
@@ -80,7 +83,7 @@ static int pxa27x_start_hc(struct device *dev)
 
         inf = dev->platform_data;
 
-        pxa_set_cken(CKEN_USBHOST, 1);
+        clk_enable(usb_clk);
 
         UHCHR |= UHCHR_FHR;
         udelay(11);
@@ -123,7 +126,7 @@ static void pxa27x_stop_hc(struct device *dev)
         UHCCOMS |= 1;
         udelay(10);
 
-        pxa_set_cken(CKEN_USBHOST, 0);
+        clk_disable(usb_clk);
 }
 
 
@@ -158,6 +161,10 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
                 return -ENOMEM;
         }
 
+        usb_clk = clk_get(&pdev->dev, "USBCLK");
+        if (IS_ERR(usb_clk))
+                return PTR_ERR(usb_clk);
+
         hcd = usb_create_hcd (driver, &pdev->dev, "pxa27x");
         if (!hcd)
                 return -ENOMEM;
@@ -201,6 +208,7 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
  err1:
         usb_put_hcd(hcd);
+        clk_put(usb_clk);
         return retval;
 }
 
@@ -225,6 +233,7 @@ void usb_hcd_pxa27x_remove (struct usb_hcd *hcd, struct platform_device *pdev)
         iounmap(hcd->regs);
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
+        clk_put(usb_clk);
 }
 
 /*-------------------------------------------------------------------------*/