Pileus Git - ~andy/linux/blob - drivers/input/keyboard/nomadik-ske-keypad.c

   1 /*
   2  * Copyright (C) ST-Ericsson SA 2010
   3  *
   4  * Author: Naveen Kumar G <naveen.gaddipati@stericsson.com> for ST-Ericsson
   5  * Author: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
   6  *
   7  * License terms:GNU General Public License (GPL) version 2
   8  *
   9  * Keypad controller driver for the SKE (Scroll Key Encoder) module used in
  10  * the Nomadik 8815 and Ux500 platforms.
  11  */
  12
  13 #include <linux/platform_device.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/spinlock.h>
  16 #include <linux/io.h>
  17 #include <linux/delay.h>
  18 #include <linux/input.h>
  19 #include <linux/slab.h>
  20 #include <linux/clk.h>
  21 #include <linux/module.h>
  22
  23 #include <plat/ske.h>
  24
  25 /* SKE_CR bits */
  26 #define SKE_KPMLT       (0x1 << 6)
  27 #define SKE_KPCN        (0x7 << 3)
  28 #define SKE_KPASEN      (0x1 << 2)
  29 #define SKE_KPASON      (0x1 << 7)
  30
  31 /* SKE_IMSC bits */
  32 #define SKE_KPIMA       (0x1 << 2)
  33
  34 /* SKE_ICR bits */
  35 #define SKE_KPICS       (0x1 << 3)
  36 #define SKE_KPICA       (0x1 << 2)
  37
  38 /* SKE_RIS bits */
  39 #define SKE_KPRISA      (0x1 << 2)
  40
  41 #define SKE_KEYPAD_ROW_SHIFT    3
  42 #define SKE_KPD_NUM_ROWS        8
  43 #define SKE_KPD_NUM_COLS        8
  44
  45 /* keypad auto scan registers */
  46 #define SKE_ASR0        0x20
  47 #define SKE_ASR1        0x24
  48 #define SKE_ASR2        0x28
  49 #define SKE_ASR3        0x2C
  50
  51 #define SKE_NUM_ASRX_REGISTERS  (4)
  52
  53 /**
  54  * struct ske_keypad  - data structure used by keypad driver
  55  * @irq:        irq no
  56  * @reg_base:   ske regsiters base address
  57  * @input:      pointer to input device object
  58  * @board:      keypad platform device
  59  * @keymap:     matrix scan code table for keycodes
  60  * @clk:        clock structure pointer
  61  */
  62 struct ske_keypad {
  63         int irq;
  64         void __iomem *reg_base;
  65         struct input_dev *input;
  66         const struct ske_keypad_platform_data *board;
  67         unsigned short keymap[SKE_KPD_NUM_ROWS * SKE_KPD_NUM_COLS];
  68         struct clk *clk;
  69         spinlock_t ske_keypad_lock;
  70 };
  71
  72 static void ske_keypad_set_bits(struct ske_keypad *keypad, u16 addr,
  73                 u8 mask, u8 data)
  74 {
  75         u32 ret;
  76
  77         spin_lock(&keypad->ske_keypad_lock);
  78
  79         ret = readl(keypad->reg_base + addr);
  80         ret &= ~mask;
  81         ret |= data;
  82         writel(ret, keypad->reg_base + addr);
  83
  84         spin_unlock(&keypad->ske_keypad_lock);
  85 }
  86
  87 /*
  88  * ske_keypad_chip_init: init keypad controller configuration
  89  *
  90  * Enable Multi key press detection, auto scan mode
  91  */
  92 static int __init ske_keypad_chip_init(struct ske_keypad *keypad)
  93 {
  94         u32 value;
  95         int timeout = 50;
  96
  97         /* check SKE_RIS to be 0 */
  98         while ((readl(keypad->reg_base + SKE_RIS) != 0x00000000) && timeout--)
  99                 cpu_relax();
 100
 101         if (!timeout)
 102                 return -EINVAL;
 103
 104         /*
 105          * set debounce value
 106          * keypad dbounce is configured in DBCR[15:8]
 107          * dbounce value in steps of 32/32.768 ms
 108          */
 109         spin_lock(&keypad->ske_keypad_lock);
 110         value = readl(keypad->reg_base + SKE_DBCR);
 111         value = value & 0xff;
 112         value |= ((keypad->board->debounce_ms * 32000)/32768) << 8;
 113         writel(value, keypad->reg_base + SKE_DBCR);
 114         spin_unlock(&keypad->ske_keypad_lock);
 115
 116         /* enable multi key detection */
 117         ske_keypad_set_bits(keypad, SKE_CR, 0x0, SKE_KPMLT);
 118
 119         /*
 120          * set up the number of columns
 121          * KPCN[5:3] defines no. of keypad columns to be auto scanned
 122          */
 123         value = (keypad->board->kcol - 1) << 3;
 124         ske_keypad_set_bits(keypad, SKE_CR, SKE_KPCN, value);
 125
 126         /* clear keypad interrupt for auto(and pending SW) scans */
 127         ske_keypad_set_bits(keypad, SKE_ICR, 0x0, SKE_KPICA | SKE_KPICS);
 128
 129         /* un-mask keypad interrupts */
 130         ske_keypad_set_bits(keypad, SKE_IMSC, 0x0, SKE_KPIMA);
 131
 132         /* enable automatic scan */
 133         ske_keypad_set_bits(keypad, SKE_CR, 0x0, SKE_KPASEN);
 134
 135         return 0;
 136 }
 137
 138 static void ske_keypad_read_data(struct ske_keypad *keypad)
 139 {
 140         struct input_dev *input = keypad->input;
 141         u16 status;
 142         int col = 0, row = 0, code;
 143         int ske_asr, ske_ris, key_pressed, i;
 144
 145         /*
 146          * Read the auto scan registers
 147          *
 148          * Each SKE_ASRx (x=0 to x=3) contains two row values.
 149          * lower byte contains row value for column 2*x,
 150          * upper byte contains row value for column 2*x + 1
 151          */
 152         for (i = 0; i < SKE_NUM_ASRX_REGISTERS; i++) {
 153                 ske_asr = readl(keypad->reg_base + SKE_ASR0 + (4 * i));
 154                 if (!ske_asr)
 155                         continue;
 156
 157                 /* now that ASRx is zero, find out the column x and row y*/
 158                 if (ske_asr & 0xff) {
 159                         col = i * 2;
 160                         status = ske_asr & 0xff;
 161                 } else {
 162                         col = (i * 2) + 1;
 163                         status = (ske_asr & 0xff00) >> 8;
 164                 }
 165
 166                 /* find out the row */
 167                 row = __ffs(status);
 168
 169                 code = MATRIX_SCAN_CODE(row, col, SKE_KEYPAD_ROW_SHIFT);
 170                 ske_ris = readl(keypad->reg_base + SKE_RIS);
 171                 key_pressed = ske_ris & SKE_KPRISA;
 172
 173                 input_event(input, EV_MSC, MSC_SCAN, code);
 174                 input_report_key(input, keypad->keymap[code], key_pressed);
 175                 input_sync(input);
 176         }
 177 }
 178
 179 static irqreturn_t ske_keypad_irq(int irq, void *dev_id)
 180 {
 181         struct ske_keypad *keypad = dev_id;
 182         int retries = 20;
 183
 184         /* disable auto scan interrupt; mask the interrupt generated */
 185         ske_keypad_set_bits(keypad, SKE_IMSC, ~SKE_KPIMA, 0x0);
 186         ske_keypad_set_bits(keypad, SKE_ICR, 0x0, SKE_KPICA);
 187
 188         while ((readl(keypad->reg_base + SKE_CR) & SKE_KPASON) && --retries)
 189                 msleep(5);
 190
 191         if (retries) {
 192                 /* SKEx registers are stable and can be read */
 193                 ske_keypad_read_data(keypad);
 194         }
 195
 196         /* enable auto scan interrupts */
 197         ske_keypad_set_bits(keypad, SKE_IMSC, 0x0, SKE_KPIMA);
 198
 199         return IRQ_HANDLED;
 200 }
 201
 202 static int __init ske_keypad_probe(struct platform_device *pdev)
 203 {
 204         const struct ske_keypad_platform_data *plat = pdev->dev.platform_data;
 205         struct ske_keypad *keypad;
 206         struct input_dev *input;
 207         struct resource *res;
 208         int irq;
 209         int error;
 210
 211         if (!plat) {
 212                 dev_err(&pdev->dev, "invalid keypad platform data\n");
 213                 return -EINVAL;
 214         }
 215
 216         irq = platform_get_irq(pdev, 0);
 217         if (irq < 0) {
 218                 dev_err(&pdev->dev, "failed to get keypad irq\n");
 219                 return -EINVAL;
 220         }
 221
 222         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 223         if (!res) {
 224                 dev_err(&pdev->dev, "missing platform resources\n");
 225                 return -EINVAL;
 226         }
 227
 228         keypad = kzalloc(sizeof(struct ske_keypad), GFP_KERNEL);
 229         input = input_allocate_device();
 230         if (!keypad || !input) {
 231                 dev_err(&pdev->dev, "failed to allocate keypad memory\n");
 232                 error = -ENOMEM;
 233                 goto err_free_mem;
 234         }
 235
 236         keypad->irq = irq;
 237         keypad->board = plat;
 238         keypad->input = input;
 239         spin_lock_init(&keypad->ske_keypad_lock);
 240
 241         if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
 242                 dev_err(&pdev->dev, "failed to request I/O memory\n");
 243                 error = -EBUSY;
 244                 goto err_free_mem;
 245         }
 246
 247         keypad->reg_base = ioremap(res->start, resource_size(res));
 248         if (!keypad->reg_base) {
 249                 dev_err(&pdev->dev, "failed to remap I/O memory\n");
 250                 error = -ENXIO;
 251                 goto err_free_mem_region;
 252         }
 253
 254         keypad->clk = clk_get(&pdev->dev, NULL);
 255         if (IS_ERR(keypad->clk)) {
 256                 dev_err(&pdev->dev, "failed to get clk\n");
 257                 error = PTR_ERR(keypad->clk);
 258                 goto err_iounmap;
 259         }
 260
 261         input->id.bustype = BUS_HOST;
 262         input->name = "ux500-ske-keypad";
 263         input->dev.parent = &pdev->dev;
 264
 265         error = matrix_keypad_build_keymap(plat->keymap_data, NULL,
 266                                            SKE_KPD_NUM_ROWS, SKE_KPD_NUM_COLS,
 267                                            keypad->keymap, input);
 268         if (error) {
 269                 dev_err(&pdev->dev, "Failed to build keymap\n");
 270                 goto err_iounmap;
 271         }
 272
 273         input_set_capability(input, EV_MSC, MSC_SCAN);
 274         if (!plat->no_autorepeat)
 275                 __set_bit(EV_REP, input->evbit);
 276
 277         clk_enable(keypad->clk);
 278
 279         /* go through board initialization helpers */
 280         if (keypad->board->init)
 281                 keypad->board->init();
 282
 283         error = ske_keypad_chip_init(keypad);
 284         if (error) {
 285                 dev_err(&pdev->dev, "unable to init keypad hardware\n");
 286                 goto err_clk_disable;
 287         }
 288
 289         error = request_threaded_irq(keypad->irq, NULL, ske_keypad_irq,
 290                                      IRQF_ONESHOT, "ske-keypad", keypad);
 291         if (error) {
 292                 dev_err(&pdev->dev, "allocate irq %d failed\n", keypad->irq);
 293                 goto err_clk_disable;
 294         }
 295
 296         error = input_register_device(input);
 297         if (error) {
 298                 dev_err(&pdev->dev,
 299                                 "unable to register input device: %d\n", error);
 300                 goto err_free_irq;
 301         }
 302
 303         if (plat->wakeup_enable)
 304                 device_init_wakeup(&pdev->dev, true);
 305
 306         platform_set_drvdata(pdev, keypad);
 307
 308         return 0;
 309
 310 err_free_irq:
 311         free_irq(keypad->irq, keypad);
 312 err_clk_disable:
 313         clk_disable(keypad->clk);
 314         clk_put(keypad->clk);
 315 err_iounmap:
 316         iounmap(keypad->reg_base);
 317 err_free_mem_region:
 318         release_mem_region(res->start, resource_size(res));
 319 err_free_mem:
 320         input_free_device(input);
 321         kfree(keypad);
 322         return error;
 323 }
 324
 325 static int __devexit ske_keypad_remove(struct platform_device *pdev)
 326 {
 327         struct ske_keypad *keypad = platform_get_drvdata(pdev);
 328         struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 329
 330         free_irq(keypad->irq, keypad);
 331
 332         input_unregister_device(keypad->input);
 333
 334         clk_disable(keypad->clk);
 335         clk_put(keypad->clk);
 336
 337         if (keypad->board->exit)
 338                 keypad->board->exit();
 339
 340         iounmap(keypad->reg_base);
 341         release_mem_region(res->start, resource_size(res));
 342         kfree(keypad);
 343
 344         return 0;
 345 }
 346
 347 #ifdef CONFIG_PM_SLEEP
 348 static int ske_keypad_suspend(struct device *dev)
 349 {
 350         struct platform_device *pdev = to_platform_device(dev);
 351         struct ske_keypad *keypad = platform_get_drvdata(pdev);
 352         int irq = platform_get_irq(pdev, 0);
 353
 354         if (device_may_wakeup(dev))
 355                 enable_irq_wake(irq);
 356         else
 357                 ske_keypad_set_bits(keypad, SKE_IMSC, ~SKE_KPIMA, 0x0);
 358
 359         return 0;
 360 }
 361
 362 static int ske_keypad_resume(struct device *dev)
 363 {
 364         struct platform_device *pdev = to_platform_device(dev);
 365         struct ske_keypad *keypad = platform_get_drvdata(pdev);
 366         int irq = platform_get_irq(pdev, 0);
 367
 368         if (device_may_wakeup(dev))
 369                 disable_irq_wake(irq);
 370         else
 371                 ske_keypad_set_bits(keypad, SKE_IMSC, 0x0, SKE_KPIMA);
 372
 373         return 0;
 374 }
 375 #endif
 376
 377 static SIMPLE_DEV_PM_OPS(ske_keypad_dev_pm_ops,
 378                          ske_keypad_suspend, ske_keypad_resume);
 379
 380 static struct platform_driver ske_keypad_driver = {
 381         .driver = {
 382                 .name = "nmk-ske-keypad",
 383                 .owner  = THIS_MODULE,
 384                 .pm = &ske_keypad_dev_pm_ops,
 385         },
 386         .remove = __devexit_p(ske_keypad_remove),
 387 };
 388
 389 static int __init ske_keypad_init(void)
 390 {
 391         return platform_driver_probe(&ske_keypad_driver, ske_keypad_probe);
 392 }
 393 module_init(ske_keypad_init);
 394
 395 static void __exit ske_keypad_exit(void)
 396 {
 397         platform_driver_unregister(&ske_keypad_driver);
 398 }
 399 module_exit(ske_keypad_exit);
 400
 401 MODULE_LICENSE("GPL v2");
 402 MODULE_AUTHOR("Naveen Kumar <naveen.gaddipati@stericsson.com> / Sundar Iyer <sundar.iyer@stericsson.com>");
 403 MODULE_DESCRIPTION("Nomadik Scroll-Key-Encoder Keypad Driver");
 404 MODULE_ALIAS("platform:nomadik-ske-keypad");