1 files changed, 91 insertions, 54 deletions

diff --git a/drivers/input/keyboard/sh_keysc.c b/drivers/input/keyboard/sh_keysc.c
index 8e9380bfed40..854e2035cd6e 100644
--- a/drivers/input/keyboard/sh_keysc.c
+++ b/drivers/input/keyboard/sh_keysc.c
@@ -19,101 +19,141 @@
 #include <linux/platform_device.h>
 #include <linux/input.h>
 #include <linux/input/sh_keysc.h>
+#include <linux/bitmap.h>
 #include <linux/clk.h>
 #include <linux/io.h>
 
-#define KYCR1_OFFS   0x00
-#define KYCR2_OFFS   0x04
-#define KYINDR_OFFS  0x08
-#define KYOUTDR_OFFS 0x0c
-
-#define KYCR2_IRQ_LEVEL    0x10
-#define KYCR2_IRQ_DISABLED 0x00
-
 static const struct {
         unsigned char kymd, keyout, keyin;
 } sh_keysc_mode[] = {
         [SH_KEYSC_MODE_1] = { 0, 6, 5 },
         [SH_KEYSC_MODE_2] = { 1, 5, 6 },
         [SH_KEYSC_MODE_3] = { 2, 4, 7 },
+        [SH_KEYSC_MODE_4] = { 3, 6, 6 },
+        [SH_KEYSC_MODE_5] = { 4, 6, 7 },
+        [SH_KEYSC_MODE_6] = { 5, 7, 7 },
 };
 
 struct sh_keysc_priv {
         void __iomem *iomem_base;
         struct clk *clk;
-        unsigned long last_keys;
+        DECLARE_BITMAP(last_keys, SH_KEYSC_MAXKEYS);
         struct input_dev *input;
         struct sh_keysc_info pdata;
 };
 
+#define KYCR1 0
+#define KYCR2 1
+#define KYINDR 2
+#define KYOUTDR 3
+
+#define KYCR2_IRQ_LEVEL    0x10
+#define KYCR2_IRQ_DISABLED 0x00
+
+static unsigned long sh_keysc_read(struct sh_keysc_priv *p, int reg_nr)
+{
+        return ioread16(p->iomem_base + (reg_nr << 2));
+}
+
+static void sh_keysc_write(struct sh_keysc_priv *p, int reg_nr,
+                           unsigned long value)
+{
+        iowrite16(value, p->iomem_base + (reg_nr << 2));
+}
+
+static void sh_keysc_level_mode(struct sh_keysc_priv *p,
+                                unsigned long keys_set)
+{
+        struct sh_keysc_info *pdata = &p->pdata;
+
+        sh_keysc_write(p, KYOUTDR, 0);
+        sh_keysc_write(p, KYCR2, KYCR2_IRQ_LEVEL | (keys_set << 8));
+
+        if (pdata->kycr2_delay)
+                udelay(pdata->kycr2_delay);
+}
+
+static void sh_keysc_map_dbg(struct device *dev, unsigned long *map,
+                             const char *str)
+{
+        int k;
+
+        for (k = 0; k < BITS_TO_LONGS(SH_KEYSC_MAXKEYS); k++)
+                dev_dbg(dev, "%s[%d] 0x%lx\n", str, k, map[k]);
+}
+
 static irqreturn_t sh_keysc_isr(int irq, void *dev_id)
 {
         struct platform_device *pdev = dev_id;
         struct sh_keysc_priv *priv = platform_get_drvdata(pdev);
         struct sh_keysc_info *pdata = &priv->pdata;
-        unsigned long keys, keys1, keys0, mask;
+        int keyout_nr = sh_keysc_mode[pdata->mode].keyout;
+        int keyin_nr = sh_keysc_mode[pdata->mode].keyin;
+        DECLARE_BITMAP(keys, SH_KEYSC_MAXKEYS);
+        DECLARE_BITMAP(keys0, SH_KEYSC_MAXKEYS);
+        DECLARE_BITMAP(keys1, SH_KEYSC_MAXKEYS);
         unsigned char keyin_set, tmp;
-        int i, k;
+        int i, k, n;
 
         dev_dbg(&pdev->dev, "isr!\n");
 
-        keys1 = ~0;
-        keys0 = 0;
+        bitmap_fill(keys1, SH_KEYSC_MAXKEYS);
+        bitmap_zero(keys0, SH_KEYSC_MAXKEYS);
 
         do {
-                keys = 0;
+                bitmap_zero(keys, SH_KEYSC_MAXKEYS);
                 keyin_set = 0;
 
-                iowrite16(KYCR2_IRQ_DISABLED, priv->iomem_base + KYCR2_OFFS);
+                sh_keysc_write(priv, KYCR2, KYCR2_IRQ_DISABLED);
+
+                for (i = 0; i < keyout_nr; i++) {
+                        n = keyin_nr * i;
 
-                for (i = 0; i < sh_keysc_mode[pdata->mode].keyout; i++) {
-                        iowrite16(0xfff ^ (3 << (i * 2)),
-                                  priv->iomem_base + KYOUTDR_OFFS);
+                        /* drive one KEYOUT pin low, read KEYIN pins */
+                        sh_keysc_write(priv, KYOUTDR, 0xffff ^ (3 << (i * 2)));
                         udelay(pdata->delay);
-                        tmp = ioread16(priv->iomem_base + KYINDR_OFFS);
-                        keys |= tmp << (sh_keysc_mode[pdata->mode].keyin * i);
-                        tmp ^= (1 << sh_keysc_mode[pdata->mode].keyin) - 1;
-                        keyin_set |= tmp;
-                }
+                        tmp = sh_keysc_read(priv, KYINDR);
 
-                iowrite16(0, priv->iomem_base + KYOUTDR_OFFS);
-                iowrite16(KYCR2_IRQ_LEVEL | (keyin_set << 8),
-                          priv->iomem_base + KYCR2_OFFS);
+                        /* set bit if key press has been detected */
+                        for (k = 0; k < keyin_nr; k++) {
+                                if (tmp & (1 << k))
+                                        __set_bit(n + k, keys);
+                        }
 
-                if (pdata->kycr2_delay)
-                        udelay(pdata->kycr2_delay);
+                        /* keep track of which KEYIN bits that have been set */
+                        keyin_set |= tmp ^ ((1 << keyin_nr) - 1);
+                }
 
-                keys ^= ~0;
-                keys &= (1 << (sh_keysc_mode[pdata->mode].keyin *
-                               sh_keysc_mode[pdata->mode].keyout)) - 1;
-                keys1 &= keys;
-                keys0 |= keys;
+                sh_keysc_level_mode(priv, keyin_set);
 
-                dev_dbg(&pdev->dev, "keys 0x%08lx\n", keys);
+                bitmap_complement(keys, keys, SH_KEYSC_MAXKEYS);
+                bitmap_and(keys1, keys1, keys, SH_KEYSC_MAXKEYS);
+                bitmap_or(keys0, keys0, keys, SH_KEYSC_MAXKEYS);
 
-        } while (ioread16(priv->iomem_base + KYCR2_OFFS) & 0x01);
+                sh_keysc_map_dbg(&pdev->dev, keys, "keys");
 
-        dev_dbg(&pdev->dev, "last_keys 0x%08lx keys0 0x%08lx keys1 0x%08lx\n",
-                priv->last_keys, keys0, keys1);
+        } while (sh_keysc_read(priv, KYCR2) & 0x01);
+
+        sh_keysc_map_dbg(&pdev->dev, priv->last_keys, "last_keys");
+        sh_keysc_map_dbg(&pdev->dev, keys0, "keys0");
+        sh_keysc_map_dbg(&pdev->dev, keys1, "keys1");
 
         for (i = 0; i < SH_KEYSC_MAXKEYS; i++) {
                 k = pdata->keycodes[i];
                 if (!k)
                         continue;
 
-                mask = 1 << i;
-
-                if (!((priv->last_keys ^ keys0) & mask))
+                if (test_bit(i, keys0) == test_bit(i, priv->last_keys))
                         continue;
 
-                if ((keys1 | keys0) & mask) {
+                if (test_bit(i, keys1) || test_bit(i, keys0)) {
                         input_event(priv->input, EV_KEY, k, 1);
-                        priv->last_keys |= mask;
+                        __set_bit(i, priv->last_keys);
                 }
 
-                if (!(keys1 & mask)) {
+                if (!test_bit(i, keys1)) {
                         input_event(priv->input, EV_KEY, k, 0);
-                        priv->last_keys &= ~mask;
+                        __clear_bit(i, priv->last_keys);
                 }
 
         }
@@ -122,8 +162,6 @@ static irqreturn_t sh_keysc_isr(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-#define res_size(res) ((res)->end - (res)->start + 1)
-
 static int __devinit sh_keysc_probe(struct platform_device *pdev)
 {
         struct sh_keysc_priv *priv;
@@ -164,7 +202,7 @@ static int __devinit sh_keysc_probe(struct platform_device *pdev)
         memcpy(&priv->pdata, pdev->dev.platform_data, sizeof(priv->pdata));
         pdata = &priv->pdata;
 
-        priv->iomem_base = ioremap_nocache(res->start, res_size(res));
+        priv->iomem_base = ioremap_nocache(res->start, resource_size(res));
         if (priv->iomem_base == NULL) {
                 dev_err(&pdev->dev, "failed to remap I/O memory\n");
                 error = -ENXIO;
@@ -220,10 +258,9 @@ static int __devinit sh_keysc_probe(struct platform_device *pdev)
 
         clk_enable(priv->clk);
 
-        iowrite16((sh_keysc_mode[pdata->mode].kymd << 8) |
-                  pdata->scan_timing, priv->iomem_base + KYCR1_OFFS);
-        iowrite16(0, priv->iomem_base + KYOUTDR_OFFS);
-        iowrite16(KYCR2_IRQ_LEVEL, priv->iomem_base + KYCR2_OFFS);
+        sh_keysc_write(priv, KYCR1, (sh_keysc_mode[pdata->mode].kymd << 8) |
+                       pdata->scan_timing);
+        sh_keysc_level_mode(priv, 0);
 
         device_init_wakeup(&pdev->dev, 1);
 
@@ -248,7 +285,7 @@ static int __devexit sh_keysc_remove(struct platform_device *pdev)
 {
         struct sh_keysc_priv *priv = platform_get_drvdata(pdev);
 
-        iowrite16(KYCR2_IRQ_DISABLED, priv->iomem_base + KYCR2_OFFS);
+        sh_keysc_write(priv, KYCR2, KYCR2_IRQ_DISABLED);
 
         input_unregister_device(priv->input);
         free_irq(platform_get_irq(pdev, 0), pdev);
@@ -270,7 +307,7 @@ static int sh_keysc_suspend(struct device *dev)
         int irq = platform_get_irq(pdev, 0);
         unsigned short value;
 
-        value = ioread16(priv->iomem_base + KYCR1_OFFS);
+        value = sh_keysc_read(priv, KYCR1);
 
         if (device_may_wakeup(dev)) {
                 value |= 0x80;
@@ -279,7 +316,7 @@ static int sh_keysc_suspend(struct device *dev)
                 value &= ~0x80;
         }
 
-        iowrite16(value, priv->iomem_base + KYCR1_OFFS);
+        sh_keysc_write(priv, KYCR1, value);
 
         return 0;
 }