drivers/input/keyboard/sh_keysc.c

   1 /*
   2  * SuperH KEYSC Keypad Driver
   3  *
   4  * Copyright (C) 2008 Magnus Damm
   5  *
   6  * Based on gpio_keys.c, Copyright 2005 Phil Blundell
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/irq.h>
  17 #include <linux/delay.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/input.h>
  20 #include <linux/input/sh_keysc.h>
  21 #include <linux/bitmap.h>
  22 #include <linux/pm_runtime.h>
  23 #include <linux/io.h>
  24 #include <linux/slab.h>
  25
  26 static const struct {
  27         unsigned char kymd, keyout, keyin;
  28 } sh_keysc_mode[] = {
  29         [SH_KEYSC_MODE_1] = { 0, 6, 5 },
  30         [SH_KEYSC_MODE_2] = { 1, 5, 6 },
  31         [SH_KEYSC_MODE_3] = { 2, 4, 7 },
  32         [SH_KEYSC_MODE_4] = { 3, 6, 6 },
  33         [SH_KEYSC_MODE_5] = { 4, 6, 7 },
  34         [SH_KEYSC_MODE_6] = { 5, 8, 8 },
  35 };
  36
  37 struct sh_keysc_priv {
  38         void __iomem *iomem_base;
  39         DECLARE_BITMAP(last_keys, SH_KEYSC_MAXKEYS);
  40         struct input_dev *input;
  41         struct sh_keysc_info pdata;
  42 };
  43
  44 #define KYCR1 0
  45 #define KYCR2 1
  46 #define KYINDR 2
  47 #define KYOUTDR 3
  48
  49 #define KYCR2_IRQ_LEVEL    0x10
  50 #define KYCR2_IRQ_DISABLED 0x00
  51
  52 static unsigned long sh_keysc_read(struct sh_keysc_priv *p, int reg_nr)
  53 {
  54         return ioread16(p->iomem_base + (reg_nr << 2));
  55 }
  56
  57 static void sh_keysc_write(struct sh_keysc_priv *p, int reg_nr,
  58                            unsigned long value)
  59 {
  60         iowrite16(value, p->iomem_base + (reg_nr << 2));
  61 }
  62
  63 static void sh_keysc_level_mode(struct sh_keysc_priv *p,
  64                                 unsigned long keys_set)
  65 {
  66         struct sh_keysc_info *pdata = &p->pdata;
  67
  68         sh_keysc_write(p, KYOUTDR, 0);
  69         sh_keysc_write(p, KYCR2, KYCR2_IRQ_LEVEL | (keys_set << 8));
  70
  71         if (pdata->kycr2_delay)
  72                 udelay(pdata->kycr2_delay);
  73 }
  74
  75 static void sh_keysc_map_dbg(struct device *dev, unsigned long *map,
  76                              const char *str)
  77 {
  78         int k;
  79
  80         for (k = 0; k < BITS_TO_LONGS(SH_KEYSC_MAXKEYS); k++)
  81                 dev_dbg(dev, "%s[%d] 0x%lx\n", str, k, map[k]);
  82 }
  83
  84 static irqreturn_t sh_keysc_isr(int irq, void *dev_id)
  85 {
  86         struct platform_device *pdev = dev_id;
  87         struct sh_keysc_priv *priv = platform_get_drvdata(pdev);
  88         struct sh_keysc_info *pdata = &priv->pdata;
  89         int keyout_nr = sh_keysc_mode[pdata->mode].keyout;
  90         int keyin_nr = sh_keysc_mode[pdata->mode].keyin;
  91         DECLARE_BITMAP(keys, SH_KEYSC_MAXKEYS);
  92         DECLARE_BITMAP(keys0, SH_KEYSC_MAXKEYS);
  93         DECLARE_BITMAP(keys1, SH_KEYSC_MAXKEYS);
  94         unsigned char keyin_set, tmp;
  95         int i, k, n;
  96
  97         dev_dbg(&pdev->dev, "isr!\n");
  98
  99         bitmap_fill(keys1, SH_KEYSC_MAXKEYS);
 100         bitmap_zero(keys0, SH_KEYSC_MAXKEYS);
 101
 102         do {
 103                 bitmap_zero(keys, SH_KEYSC_MAXKEYS);
 104                 keyin_set = 0;
 105
 106                 sh_keysc_write(priv, KYCR2, KYCR2_IRQ_DISABLED);
 107
 108                 for (i = 0; i < keyout_nr; i++) {
 109                         n = keyin_nr * i;
 110
 111                         /* drive one KEYOUT pin low, read KEYIN pins */
 112                         sh_keysc_write(priv, KYOUTDR, 0xffff ^ (3 << (i * 2)));
 113                         udelay(pdata->delay);
 114                         tmp = sh_keysc_read(priv, KYINDR);
 115
 116                         /* set bit if key press has been detected */
 117                         for (k = 0; k < keyin_nr; k++) {
 118                                 if (tmp & (1 << k))
 119                                         __set_bit(n + k, keys);
 120                         }
 121
 122                         /* keep track of which KEYIN bits that have been set */
 123                         keyin_set |= tmp ^ ((1 << keyin_nr) - 1);
 124                 }
 125
 126                 sh_keysc_level_mode(priv, keyin_set);
 127
 128                 bitmap_complement(keys, keys, SH_KEYSC_MAXKEYS);
 129                 bitmap_and(keys1, keys1, keys, SH_KEYSC_MAXKEYS);
 130                 bitmap_or(keys0, keys0, keys, SH_KEYSC_MAXKEYS);
 131
 132                 sh_keysc_map_dbg(&pdev->dev, keys, "keys");
 133
 134         } while (sh_keysc_read(priv, KYCR2) & 0x01);
 135
 136         sh_keysc_map_dbg(&pdev->dev, priv->last_keys, "last_keys");
 137         sh_keysc_map_dbg(&pdev->dev, keys0, "keys0");
 138         sh_keysc_map_dbg(&pdev->dev, keys1, "keys1");
 139
 140         for (i = 0; i < SH_KEYSC_MAXKEYS; i++) {
 141                 k = pdata->keycodes[i];
 142                 if (!k)
 143                         continue;
 144
 145                 if (test_bit(i, keys0) == test_bit(i, priv->last_keys))
 146                         continue;
 147
 148                 if (test_bit(i, keys1) || test_bit(i, keys0)) {
 149                         input_event(priv->input, EV_KEY, k, 1);
 150                         __set_bit(i, priv->last_keys);
 151                 }
 152
 153                 if (!test_bit(i, keys1)) {
 154                         input_event(priv->input, EV_KEY, k, 0);
 155                         __clear_bit(i, priv->last_keys);
 156                 }
 157
 158         }
 159         input_sync(priv->input);
 160
 161         return IRQ_HANDLED;
 162 }
 163
 164 static int sh_keysc_probe(struct platform_device *pdev)
 165 {
 166         struct sh_keysc_priv *priv;
 167         struct sh_keysc_info *pdata;
 168         struct resource *res;
 169         struct input_dev *input;
 170         int i;
 171         int irq, error;
 172
 173         if (!dev_get_platdata(&pdev->dev)) {
 174                 dev_err(&pdev->dev, "no platform data defined\n");
 175                 error = -EINVAL;
 176                 goto err0;
 177         }
 178
 179         error = -ENXIO;
 180         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 181         if (res == NULL) {
 182                 dev_err(&pdev->dev, "failed to get I/O memory\n");
 183                 goto err0;
 184         }
 185
 186         irq = platform_get_irq(pdev, 0);
 187         if (irq < 0) {
 188                 dev_err(&pdev->dev, "failed to get irq\n");
 189                 goto err0;
 190         }
 191
 192         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 193         if (priv == NULL) {
 194                 dev_err(&pdev->dev, "failed to allocate driver data\n");
 195                 error = -ENOMEM;
 196                 goto err0;
 197         }
 198
 199         platform_set_drvdata(pdev, priv);
 200         memcpy(&priv->pdata, dev_get_platdata(&pdev->dev), sizeof(priv->pdata));
 201         pdata = &priv->pdata;
 202
 203         priv->iomem_base = ioremap_nocache(res->start, resource_size(res));
 204         if (priv->iomem_base == NULL) {
 205                 dev_err(&pdev->dev, "failed to remap I/O memory\n");
 206                 error = -ENXIO;
 207                 goto err1;
 208         }
 209
 210         priv->input = input_allocate_device();
 211         if (!priv->input) {
 212                 dev_err(&pdev->dev, "failed to allocate input device\n");
 213                 error = -ENOMEM;
 214                 goto err2;
 215         }
 216
 217         input = priv->input;
 218         input->evbit[0] = BIT_MASK(EV_KEY);
 219
 220         input->name = pdev->name;
 221         input->phys = "sh-keysc-keys/input0";
 222         input->dev.parent = &pdev->dev;
 223
 224         input->id.bustype = BUS_HOST;
 225         input->id.vendor = 0x0001;
 226         input->id.product = 0x0001;
 227         input->id.version = 0x0100;
 228
 229         input->keycode = pdata->keycodes;
 230         input->keycodesize = sizeof(pdata->keycodes[0]);
 231         input->keycodemax = ARRAY_SIZE(pdata->keycodes);
 232
 233         error = request_threaded_irq(irq, NULL, sh_keysc_isr, IRQF_ONESHOT,
 234                                      dev_name(&pdev->dev), pdev);
 235         if (error) {
 236                 dev_err(&pdev->dev, "failed to request IRQ\n");
 237                 goto err3;
 238         }
 239
 240         for (i = 0; i < SH_KEYSC_MAXKEYS; i++)
 241                 __set_bit(pdata->keycodes[i], input->keybit);
 242         __clear_bit(KEY_RESERVED, input->keybit);
 243
 244         error = input_register_device(input);
 245         if (error) {
 246                 dev_err(&pdev->dev, "failed to register input device\n");
 247                 goto err4;
 248         }
 249
 250         pm_runtime_enable(&pdev->dev);
 251         pm_runtime_get_sync(&pdev->dev);
 252
 253         sh_keysc_write(priv, KYCR1, (sh_keysc_mode[pdata->mode].kymd << 8) |
 254                        pdata->scan_timing);
 255         sh_keysc_level_mode(priv, 0);
 256
 257         device_init_wakeup(&pdev->dev, 1);
 258
 259         return 0;
 260
 261  err4:
 262         free_irq(irq, pdev);
 263  err3:
 264         input_free_device(input);
 265  err2:
 266         iounmap(priv->iomem_base);
 267  err1:
 268         kfree(priv);
 269  err0:
 270         return error;
 271 }
 272
 273 static int sh_keysc_remove(struct platform_device *pdev)
 274 {
 275         struct sh_keysc_priv *priv = platform_get_drvdata(pdev);
 276
 277         sh_keysc_write(priv, KYCR2, KYCR2_IRQ_DISABLED);
 278
 279         input_unregister_device(priv->input);
 280         free_irq(platform_get_irq(pdev, 0), pdev);
 281         iounmap(priv->iomem_base);
 282
 283         pm_runtime_put_sync(&pdev->dev);
 284         pm_runtime_disable(&pdev->dev);
 285
 286         kfree(priv);
 287
 288         return 0;
 289 }
 290
 291 #ifdef CONFIG_PM_SLEEP
 292 static int sh_keysc_suspend(struct device *dev)
 293 {
 294         struct platform_device *pdev = to_platform_device(dev);
 295         struct sh_keysc_priv *priv = platform_get_drvdata(pdev);
 296         int irq = platform_get_irq(pdev, 0);
 297         unsigned short value;
 298
 299         value = sh_keysc_read(priv, KYCR1);
 300
 301         if (device_may_wakeup(dev)) {
 302                 sh_keysc_write(priv, KYCR1, value | 0x80);
 303                 enable_irq_wake(irq);
 304         } else {
 305                 sh_keysc_write(priv, KYCR1, value & ~0x80);
 306                 pm_runtime_put_sync(dev);
 307         }
 308
 309         return 0;
 310 }
 311
 312 static int sh_keysc_resume(struct device *dev)
 313 {
 314         struct platform_device *pdev = to_platform_device(dev);
 315         int irq = platform_get_irq(pdev, 0);
 316
 317         if (device_may_wakeup(dev))
 318                 disable_irq_wake(irq);
 319         else
 320                 pm_runtime_get_sync(dev);
 321
 322         return 0;
 323 }
 324 #endif
 325
 326 static SIMPLE_DEV_PM_OPS(sh_keysc_dev_pm_ops,
 327                          sh_keysc_suspend, sh_keysc_resume);
 328
 329 static struct platform_driver sh_keysc_device_driver = {
 330         .probe          = sh_keysc_probe,
 331         .remove         = sh_keysc_remove,
 332         .driver         = {
 333                 .name   = "sh_keysc",
 334                 .pm     = &sh_keysc_dev_pm_ops,
 335         }
 336 };
 337 module_platform_driver(sh_keysc_device_driver);
 338
 339 MODULE_AUTHOR("Magnus Damm");
 340 MODULE_DESCRIPTION("SuperH KEYSC Keypad Driver");
 341 MODULE_LICENSE("GPL");