1 files changed, 136 insertions, 125 deletions

diff --git a/arch/arm/mach-pxa/mfp.c b/arch/arm/mach-pxa/mfp.c
index 436f96574964..ec1b2d8f61c4 100644
--- a/arch/arm/mach-pxa/mfp.c
+++ b/arch/arm/mach-pxa/mfp.c
@@ -17,9 +17,11 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/io.h>
+#include <linux/sysdev.h>
 
 #include <asm/hardware.h>
 #include <asm/arch/mfp.h>
+#include <asm/arch/mfp-pxa3xx.h>
 
 /* mfp_spin_lock is used to ensure that MFP register configuration
  * (most likely a read-modify-write operation) is atomic, and that
@@ -28,43 +30,110 @@
 static DEFINE_SPINLOCK(mfp_spin_lock);
 
 static void __iomem *mfpr_mmio_base = (void __iomem *)&__REG(MFPR_BASE);
+
+struct pxa3xx_mfp_pin {
+        unsigned long   config;         /* -1 for not configured */
+        unsigned long   mfpr_off;       /* MFPRxx Register offset */
+        unsigned long   mfpr_run;       /* Run-Mode Register Value */
+        unsigned long   mfpr_lpm;       /* Low Power Mode Register Value */
+};
+
 static struct pxa3xx_mfp_pin mfp_table[MFP_PIN_MAX];
 
+/* mapping of MFP_LPM_* definitions to MFPR_LPM_* register bits */
+const static unsigned long mfpr_lpm[] = {
+        MFPR_LPM_INPUT,
+        MFPR_LPM_DRIVE_LOW,
+        MFPR_LPM_DRIVE_HIGH,
+        MFPR_LPM_PULL_LOW,
+        MFPR_LPM_PULL_HIGH,
+        MFPR_LPM_FLOAT,
+};
+
+/* mapping of MFP_PULL_* definitions to MFPR_PULL_* register bits */
+const static unsigned long mfpr_pull[] = {
+        MFPR_PULL_NONE,
+        MFPR_PULL_LOW,
+        MFPR_PULL_HIGH,
+        MFPR_PULL_BOTH,
+};
+
+/* mapping of MFP_LPM_EDGE_* definitions to MFPR_EDGE_* register bits */
+const static unsigned long mfpr_edge[] = {
+        MFPR_EDGE_NONE,
+        MFPR_EDGE_RISE,
+        MFPR_EDGE_FALL,
+        MFPR_EDGE_BOTH,
+};
+
 #define mfpr_readl(off)                 \
         __raw_readl(mfpr_mmio_base + (off))
 
 #define mfpr_writel(off, val)           \
         __raw_writel(val, mfpr_mmio_base + (off))
 
+#define mfp_configured(p)       ((p)->config != -1)
+
 /*
  * perform a read-back of any MFPR register to make sure the
  * previous writings are finished
  */
 #define mfpr_sync()     (void)__raw_readl(mfpr_mmio_base + 0)
 
-static inline void __mfp_config(int pin, unsigned long val)
+static inline void __mfp_config_run(struct pxa3xx_mfp_pin *p)
 {
-        unsigned long off = mfp_table[pin].mfpr_off;
+        if (mfp_configured(p))
+                mfpr_writel(p->mfpr_off, p->mfpr_run);
+}
 
-        mfp_table[pin].mfpr_val = val;
-        mfpr_writel(off, val);
+static inline void __mfp_config_lpm(struct pxa3xx_mfp_pin *p)
+{
+        if (mfp_configured(p)) {
+                unsigned long mfpr_clr = (p->mfpr_run & ~MFPR_EDGE_BOTH) | MFPR_EDGE_CLEAR;
+                if (mfpr_clr != p->mfpr_run)
+                        mfpr_writel(p->mfpr_off, mfpr_clr);
+                if (p->mfpr_lpm != mfpr_clr)
+                        mfpr_writel(p->mfpr_off, p->mfpr_lpm);
+        }
 }
 
-void pxa3xx_mfp_config(mfp_cfg_t *mfp_cfgs, int num)
+void pxa3xx_mfp_config(unsigned long *mfp_cfgs, int num)
 {
-        int i, pin;
-        unsigned long val, flags;
-        mfp_cfg_t *mfp_cfg = mfp_cfgs;
+        unsigned long flags;
+        int i;
 
         spin_lock_irqsave(&mfp_spin_lock, flags);
 
-        for (i = 0; i < num; i++, mfp_cfg++) {
-                pin = MFP_CFG_PIN(*mfp_cfg);
-                val = MFP_CFG_VAL(*mfp_cfg);
+        for (i = 0; i < num; i++, mfp_cfgs++) {
+                unsigned long tmp, c = *mfp_cfgs;
+                struct pxa3xx_mfp_pin *p;
+                int pin, af, drv, lpm, edge, pull;
 
+                pin = MFP_PIN(c);
                 BUG_ON(pin >= MFP_PIN_MAX);
-
-                __mfp_config(pin, val);
+                p = &mfp_table[pin];
+
+                af  = MFP_AF(c);
+                drv = MFP_DS(c);
+                lpm = MFP_LPM_STATE(c);
+                edge = MFP_LPM_EDGE(c);
+                pull = MFP_PULL(c);
+
+                /* run-mode pull settings will conflict with MFPR bits of
+                 * low power mode state,  calculate mfpr_run and mfpr_lpm
+                 * individually if pull != MFP_PULL_NONE
+                 */
+                tmp = MFPR_AF_SEL(af) | MFPR_DRIVE(drv);
+
+                if (likely(pull == MFP_PULL_NONE)) {
+                        p->mfpr_run = tmp | mfpr_lpm[lpm] | mfpr_edge[edge];
+                        p->mfpr_lpm = p->mfpr_run;
+                } else {
+                        p->mfpr_lpm = tmp | mfpr_lpm[lpm] | mfpr_edge[edge];
+                        p->mfpr_run = tmp | mfpr_pull[pull];
+                }
+
+                p->config = c; __mfp_config_run(p);
         }
 
         mfpr_sync();
@@ -96,140 +165,82 @@ void pxa3xx_mfp_write(int mfp, unsigned long val)
         spin_unlock_irqrestore(&mfp_spin_lock, flags);
 }
 
-void pxa3xx_mfp_set_afds(int mfp, int af, int ds)
-{
-        uint32_t mfpr_off, mfpr_val;
-        unsigned long flags;
-
-        BUG_ON(mfp >= MFP_PIN_MAX);
-
-        spin_lock_irqsave(&mfp_spin_lock, flags);
-        mfpr_off = mfp_table[mfp].mfpr_off;
-
-        mfpr_val = mfpr_readl(mfpr_off);
-        mfpr_val &= ~(MFPR_AF_MASK | MFPR_DRV_MASK);
-        mfpr_val |= (((af & 0x7) << MFPR_ALT_OFFSET) |
-                     ((ds & 0x7) << MFPR_DRV_OFFSET));
-
-        mfpr_writel(mfpr_off, mfpr_val);
-        mfpr_sync();
-
-        spin_unlock_irqrestore(&mfp_spin_lock, flags);
-}
-
-void pxa3xx_mfp_set_rdh(int mfp, int rdh)
+void __init pxa3xx_mfp_init_addr(struct pxa3xx_mfp_addr_map *map)
 {
-        uint32_t mfpr_off, mfpr_val;
-        unsigned long flags;
-
-        BUG_ON(mfp >= MFP_PIN_MAX);
+        struct pxa3xx_mfp_addr_map *p;
+        unsigned long offset, flags;
+        int i;
 
         spin_lock_irqsave(&mfp_spin_lock, flags);
 
-        mfpr_off = mfp_table[mfp].mfpr_off;
-
-        mfpr_val = mfpr_readl(mfpr_off);
-        mfpr_val &= ~MFPR_RDH_MASK;
-
-        if (likely(rdh))
-                mfpr_val |= (1u << MFPR_SS_OFFSET);
+        for (p = map; p->start != MFP_PIN_INVALID; p++) {
+                offset = p->offset;
+                i = p->start;
 
-        mfpr_writel(mfpr_off, mfpr_val);
-        mfpr_sync();
+                do {
+                        mfp_table[i].mfpr_off = offset;
+                        mfp_table[i].mfpr_run = 0;
+                        mfp_table[i].mfpr_lpm = 0;
+                        offset += 4; i++;
+                } while ((i <= p->end) && (p->end != -1));
+        }
 
         spin_unlock_irqrestore(&mfp_spin_lock, flags);
 }
 
-void pxa3xx_mfp_set_lpm(int mfp, int lpm)
+void __init pxa3xx_init_mfp(void)
 {
-        uint32_t mfpr_off, mfpr_val;
-        unsigned long flags;
-
-        BUG_ON(mfp >= MFP_PIN_MAX);
-
-        spin_lock_irqsave(&mfp_spin_lock, flags);
-
-        mfpr_off = mfp_table[mfp].mfpr_off;
-        mfpr_val = mfpr_readl(mfpr_off);
-        mfpr_val &= ~MFPR_LPM_MASK;
-
-        if (lpm & 0x1) mfpr_val |= 1u << MFPR_SON_OFFSET;
-        if (lpm & 0x2) mfpr_val |= 1u << MFPR_SD_OFFSET;
-        if (lpm & 0x4) mfpr_val |= 1u << MFPR_PU_OFFSET;
-        if (lpm & 0x8) mfpr_val |= 1u << MFPR_PD_OFFSET;
-        if (lpm &0x10) mfpr_val |= 1u << MFPR_PS_OFFSET;
-
-        mfpr_writel(mfpr_off, mfpr_val);
-        mfpr_sync();
+        int i;
 
-        spin_unlock_irqrestore(&mfp_spin_lock, flags);
+        for (i = 0; i < ARRAY_SIZE(mfp_table); i++)
+                mfp_table[i].config = -1;
 }
 
-void pxa3xx_mfp_set_pull(int mfp, int pull)
+#ifdef CONFIG_PM
+/*
+ * Configure the MFPs appropriately for suspend/resume.
+ * FIXME: this should probably depend on which system state we're
+ * entering - for instance, we might not want to place MFP pins in
+ * a pull-down mode if they're an active low chip select, and we're
+ * just entering standby.
+ */
+static int pxa3xx_mfp_suspend(struct sys_device *d, pm_message_t state)
 {
-        uint32_t mfpr_off, mfpr_val;
-        unsigned long flags;
-
-        BUG_ON(mfp >= MFP_PIN_MAX);
-
-        spin_lock_irqsave(&mfp_spin_lock, flags);
+        int pin;
 
-        mfpr_off = mfp_table[mfp].mfpr_off;
-        mfpr_val = mfpr_readl(mfpr_off);
-        mfpr_val &= ~MFPR_PULL_MASK;
-        mfpr_val |= ((pull & 0x7u) << MFPR_PD_OFFSET);
-
-        mfpr_writel(mfpr_off, mfpr_val);
-        mfpr_sync();
-
-        spin_unlock_irqrestore(&mfp_spin_lock, flags);
+        for (pin = 0; pin < ARRAY_SIZE(mfp_table); pin++) {
+                struct pxa3xx_mfp_pin *p = &mfp_table[pin];
+                __mfp_config_lpm(p);
+        }
+        return 0;
 }
 
-void pxa3xx_mfp_set_edge(int mfp, int edge)
+static int pxa3xx_mfp_resume(struct sys_device *d)
 {
-        uint32_t mfpr_off, mfpr_val;
-        unsigned long flags;
-
-        BUG_ON(mfp >= MFP_PIN_MAX);
-
-        spin_lock_irqsave(&mfp_spin_lock, flags);
-
-        mfpr_off = mfp_table[mfp].mfpr_off;
-        mfpr_val = mfpr_readl(mfpr_off);
-
-        mfpr_val &= ~MFPR_EDGE_MASK;
-        mfpr_val |= (edge & 0x3u) << MFPR_ERE_OFFSET;
-        mfpr_val |= (!edge & 0x1) << MFPR_EC_OFFSET;
+        int pin;
 
-        mfpr_writel(mfpr_off, mfpr_val);
-        mfpr_sync();
-
-        spin_unlock_irqrestore(&mfp_spin_lock, flags);
+        for (pin = 0; pin < ARRAY_SIZE(mfp_table); pin++) {
+                struct pxa3xx_mfp_pin *p = &mfp_table[pin];
+                __mfp_config_run(p);
+        }
+        return 0;
 }
 
-void __init pxa3xx_mfp_init_addr(struct pxa3xx_mfp_addr_map *map)
-{
-        struct pxa3xx_mfp_addr_map *p;
-        unsigned long offset, flags;
-        int i;
-
-        spin_lock_irqsave(&mfp_spin_lock, flags);
-
-        for (p = map; p->start != MFP_PIN_INVALID; p++) {
-                offset = p->offset;
-                i = p->start;
-
-                do {
-                        mfp_table[i].mfpr_off = offset;
-                        mfp_table[i].mfpr_val = 0;
-                        offset += 4; i++;
-                } while ((i <= p->end) && (p->end != -1));
-        }
+static struct sysdev_class mfp_sysclass = {
+        set_kset_name("mfp"),
+        .suspend        = pxa3xx_mfp_suspend,
+        .resume         = pxa3xx_mfp_resume,
+};
 
-        spin_unlock_irqrestore(&mfp_spin_lock, flags);
-}
+static struct sys_device mfp_device = {
+        .id             = 0,
+        .cls            = &mfp_sysclass,
+};
 
-void __init pxa3xx_init_mfp(void)
+static int __init mfp_init_devicefs(void)
 {
-        memset(mfp_table, 0, sizeof(mfp_table));
+        sysdev_class_register(&mfp_sysclass);
+        return sysdev_register(&mfp_device);
 }
+device_initcall(mfp_init_devicefs);
+#endif