linux/drivers/input/keyboard/locomokbd.c
<<
>>
Prefs
   1/*
   2 * LoCoMo keyboard driver for Linux-based ARM PDAs:
   3 *      - SHARP Zaurus Collie (SL-5500)
   4 *      - SHARP Zaurus Poodle (SL-5600)
   5 *
   6 * Copyright (c) 2005 John Lenz
   7 * Based on from xtkbd.c
   8 *
   9 *
  10 * This program is free software; you can redistribute it and/or modify
  11 * it under the terms of the GNU General Public License as published by
  12 * the Free Software Foundation; either version 2 of the License, or
  13 * (at your option) any later version.
  14 *
  15 * This program is distributed in the hope that it will be useful,
  16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 * GNU General Public License for more details.
  19 *
  20 * You should have received a copy of the GNU General Public License
  21 * along with this program; if not, write to the Free Software
  22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  23 *
  24 */
  25
  26#include <linux/slab.h>
  27#include <linux/module.h>
  28#include <linux/init.h>
  29#include <linux/input.h>
  30#include <linux/delay.h>
  31#include <linux/device.h>
  32#include <linux/interrupt.h>
  33#include <linux/ioport.h>
  34
  35#include <asm/hardware/locomo.h>
  36#include <asm/irq.h>
  37
  38MODULE_AUTHOR("John Lenz <lenz@cs.wisc.edu>");
  39MODULE_DESCRIPTION("LoCoMo keyboard driver");
  40MODULE_LICENSE("GPL");
  41
  42#define LOCOMOKBD_NUMKEYS       128
  43
  44#define KEY_ACTIVITY            KEY_F16
  45#define KEY_CONTACT             KEY_F18
  46#define KEY_CENTER              KEY_F15
  47
  48static const unsigned char
  49locomokbd_keycode[LOCOMOKBD_NUMKEYS] = {
  50        0, KEY_ESC, KEY_ACTIVITY, 0, 0, 0, 0, 0, 0, 0,                          /* 0 - 9 */
  51        0, 0, 0, 0, 0, 0, 0, KEY_MENU, KEY_HOME, KEY_CONTACT,                   /* 10 - 19 */
  52        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                                           /* 20 - 29 */
  53        0, 0, 0, KEY_CENTER, 0, KEY_MAIL, 0, 0, 0, 0,                           /* 30 - 39 */
  54        0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_RIGHT,                                   /* 40 - 49 */
  55        KEY_UP, KEY_LEFT, 0, 0, KEY_P, 0, KEY_O, KEY_I, KEY_Y, KEY_T,           /* 50 - 59 */
  56        KEY_E, KEY_W, 0, 0, 0, 0, KEY_DOWN, KEY_ENTER, 0, 0,                    /* 60 - 69 */
  57        KEY_BACKSPACE, 0, KEY_L, KEY_U, KEY_H, KEY_R, KEY_D, KEY_Q, 0, 0,       /* 70 - 79 */
  58        0, 0, 0, 0, 0, 0, KEY_ENTER, KEY_RIGHTSHIFT, KEY_K, KEY_J,              /* 80 - 89 */
  59        KEY_G, KEY_F, KEY_X, KEY_S, 0, 0, 0, 0, 0, 0,                           /* 90 - 99 */
  60        0, 0, KEY_DOT, 0, KEY_COMMA, KEY_N, KEY_B, KEY_C, KEY_Z, KEY_A,         /* 100 - 109 */
  61        KEY_LEFTSHIFT, KEY_TAB, KEY_LEFTCTRL, 0, 0, 0, 0, 0, 0, 0,              /* 110 - 119 */
  62        KEY_M, KEY_SPACE, KEY_V, KEY_APOSTROPHE, KEY_SLASH, 0, 0, 0             /* 120 - 128 */
  63};
  64
  65#define KB_ROWS                 16
  66#define KB_COLS                 8
  67#define KB_ROWMASK(r)           (1 << (r))
  68#define SCANCODE(c,r)           ( ((c)<<4) + (r) + 1 )
  69
  70#define KB_DELAY                8
  71#define SCAN_INTERVAL           (HZ/10)
  72
  73struct locomokbd {
  74        unsigned char keycode[LOCOMOKBD_NUMKEYS];
  75        struct input_dev *input;
  76        char phys[32];
  77
  78        unsigned long base;
  79        spinlock_t lock;
  80
  81        struct timer_list timer;
  82        unsigned long suspend_jiffies;
  83        unsigned int count_cancel;
  84};
  85
  86/* helper functions for reading the keyboard matrix */
  87static inline void locomokbd_charge_all(unsigned long membase)
  88{
  89        locomo_writel(0x00FF, membase + LOCOMO_KSC);
  90}
  91
  92static inline void locomokbd_activate_all(unsigned long membase)
  93{
  94        unsigned long r;
  95
  96        locomo_writel(0, membase + LOCOMO_KSC);
  97        r = locomo_readl(membase + LOCOMO_KIC);
  98        r &= 0xFEFF;
  99        locomo_writel(r, membase + LOCOMO_KIC);
 100}
 101
 102static inline void locomokbd_activate_col(unsigned long membase, int col)
 103{
 104        unsigned short nset;
 105        unsigned short nbset;
 106
 107        nset = 0xFF & ~(1 << col);
 108        nbset = (nset << 8) + nset;
 109        locomo_writel(nbset, membase + LOCOMO_KSC);
 110}
 111
 112static inline void locomokbd_reset_col(unsigned long membase, int col)
 113{
 114        unsigned short nbset;
 115
 116        nbset = ((0xFF & ~(1 << col)) << 8) + 0xFF;
 117        locomo_writel(nbset, membase + LOCOMO_KSC);
 118}
 119
 120/*
 121 * The LoCoMo keyboard only generates interrupts when a key is pressed.
 122 * So when a key is pressed, we enable a timer.  This timer scans the
 123 * keyboard, and this is how we detect when the key is released.
 124 */
 125
 126/* Scan the hardware keyboard and push any changes up through the input layer */
 127static void locomokbd_scankeyboard(struct locomokbd *locomokbd)
 128{
 129        unsigned int row, col, rowd;
 130        unsigned long flags;
 131        unsigned int num_pressed;
 132        unsigned long membase = locomokbd->base;
 133
 134        spin_lock_irqsave(&locomokbd->lock, flags);
 135
 136        locomokbd_charge_all(membase);
 137
 138        num_pressed = 0;
 139        for (col = 0; col < KB_COLS; col++) {
 140
 141                locomokbd_activate_col(membase, col);
 142                udelay(KB_DELAY);
 143
 144                rowd = ~locomo_readl(membase + LOCOMO_KIB);
 145                for (row = 0; row < KB_ROWS; row++) {
 146                        unsigned int scancode, pressed, key;
 147
 148                        scancode = SCANCODE(col, row);
 149                        pressed = rowd & KB_ROWMASK(row);
 150                        key = locomokbd->keycode[scancode];
 151
 152                        input_report_key(locomokbd->input, key, pressed);
 153                        if (likely(!pressed))
 154                                continue;
 155
 156                        num_pressed++;
 157
 158                        /* The "Cancel/ESC" key is labeled "On/Off" on
 159                         * Collie and Poodle and should suspend the device
 160                         * if it was pressed for more than a second. */
 161                        if (unlikely(key == KEY_ESC)) {
 162                                if (!time_after(jiffies,
 163                                        locomokbd->suspend_jiffies + HZ))
 164                                        continue;
 165                                if (locomokbd->count_cancel++
 166                                        != (HZ/SCAN_INTERVAL + 1))
 167                                        continue;
 168                                input_event(locomokbd->input, EV_PWR,
 169                                        KEY_SUSPEND, 1);
 170                                locomokbd->suspend_jiffies = jiffies;
 171                        } else
 172                                locomokbd->count_cancel = 0;
 173                }
 174                locomokbd_reset_col(membase, col);
 175        }
 176        locomokbd_activate_all(membase);
 177
 178        input_sync(locomokbd->input);
 179
 180        /* if any keys are pressed, enable the timer */
 181        if (num_pressed)
 182                mod_timer(&locomokbd->timer, jiffies + SCAN_INTERVAL);
 183        else
 184                locomokbd->count_cancel = 0;
 185
 186        spin_unlock_irqrestore(&locomokbd->lock, flags);
 187}
 188
 189/*
 190 * LoCoMo keyboard interrupt handler.
 191 */
 192static irqreturn_t locomokbd_interrupt(int irq, void *dev_id)
 193{
 194        struct locomokbd *locomokbd = dev_id;
 195        u16 r;
 196
 197        r = locomo_readl(locomokbd->base + LOCOMO_KIC);
 198        if ((r & 0x0001) == 0)
 199                return IRQ_HANDLED;
 200
 201        locomo_writel(r & ~0x0100, locomokbd->base + LOCOMO_KIC); /* Ack */
 202
 203        /** wait chattering delay **/
 204        udelay(100);
 205
 206        locomokbd_scankeyboard(locomokbd);
 207        return IRQ_HANDLED;
 208}
 209
 210/*
 211 * LoCoMo timer checking for released keys
 212 */
 213static void locomokbd_timer_callback(struct timer_list *t)
 214{
 215        struct locomokbd *locomokbd = from_timer(locomokbd, t, timer);
 216
 217        locomokbd_scankeyboard(locomokbd);
 218}
 219
 220static int locomokbd_open(struct input_dev *dev)
 221{
 222        struct locomokbd *locomokbd = input_get_drvdata(dev);
 223        u16 r;
 224        
 225        r = locomo_readl(locomokbd->base + LOCOMO_KIC) | 0x0010;
 226        locomo_writel(r, locomokbd->base + LOCOMO_KIC);
 227        return 0;
 228}
 229
 230static void locomokbd_close(struct input_dev *dev)
 231{
 232        struct locomokbd *locomokbd = input_get_drvdata(dev);
 233        u16 r;
 234        
 235        r = locomo_readl(locomokbd->base + LOCOMO_KIC) & ~0x0010;
 236        locomo_writel(r, locomokbd->base + LOCOMO_KIC);
 237}
 238
 239static int locomokbd_probe(struct locomo_dev *dev)
 240{
 241        struct locomokbd *locomokbd;
 242        struct input_dev *input_dev;
 243        int i, err;
 244
 245        locomokbd = kzalloc(sizeof(struct locomokbd), GFP_KERNEL);
 246        input_dev = input_allocate_device();
 247        if (!locomokbd || !input_dev) {
 248                err = -ENOMEM;
 249                goto err_free_mem;
 250        }
 251
 252        /* try and claim memory region */
 253        if (!request_mem_region((unsigned long) dev->mapbase,
 254                                dev->length,
 255                                LOCOMO_DRIVER_NAME(dev))) {
 256                err = -EBUSY;
 257                printk(KERN_ERR "locomokbd: Can't acquire access to io memory for keyboard\n");
 258                goto err_free_mem;
 259        }
 260
 261        locomo_set_drvdata(dev, locomokbd);
 262
 263        locomokbd->base = (unsigned long) dev->mapbase;
 264
 265        spin_lock_init(&locomokbd->lock);
 266
 267        timer_setup(&locomokbd->timer, locomokbd_timer_callback, 0);
 268
 269        locomokbd->suspend_jiffies = jiffies;
 270
 271        locomokbd->input = input_dev;
 272        strcpy(locomokbd->phys, "locomokbd/input0");
 273
 274        input_dev->name = "LoCoMo keyboard";
 275        input_dev->phys = locomokbd->phys;
 276        input_dev->id.bustype = BUS_HOST;
 277        input_dev->id.vendor = 0x0001;
 278        input_dev->id.product = 0x0001;
 279        input_dev->id.version = 0x0100;
 280        input_dev->open = locomokbd_open;
 281        input_dev->close = locomokbd_close;
 282        input_dev->dev.parent = &dev->dev;
 283
 284        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
 285                                BIT_MASK(EV_PWR);
 286        input_dev->keycode = locomokbd->keycode;
 287        input_dev->keycodesize = sizeof(locomokbd_keycode[0]);
 288        input_dev->keycodemax = ARRAY_SIZE(locomokbd_keycode);
 289
 290        input_set_drvdata(input_dev, locomokbd);
 291
 292        memcpy(locomokbd->keycode, locomokbd_keycode, sizeof(locomokbd->keycode));
 293        for (i = 0; i < LOCOMOKBD_NUMKEYS; i++)
 294                set_bit(locomokbd->keycode[i], input_dev->keybit);
 295        clear_bit(0, input_dev->keybit);
 296
 297        /* attempt to get the interrupt */
 298        err = request_irq(dev->irq[0], locomokbd_interrupt, 0, "locomokbd", locomokbd);
 299        if (err) {
 300                printk(KERN_ERR "locomokbd: Can't get irq for keyboard\n");
 301                goto err_release_region;
 302        }
 303
 304        err = input_register_device(locomokbd->input);
 305        if (err)
 306                goto err_free_irq;
 307
 308        return 0;
 309
 310 err_free_irq:
 311        free_irq(dev->irq[0], locomokbd);
 312 err_release_region:
 313        release_mem_region((unsigned long) dev->mapbase, dev->length);
 314        locomo_set_drvdata(dev, NULL);
 315 err_free_mem:
 316        input_free_device(input_dev);
 317        kfree(locomokbd);
 318
 319        return err;
 320}
 321
 322static int locomokbd_remove(struct locomo_dev *dev)
 323{
 324        struct locomokbd *locomokbd = locomo_get_drvdata(dev);
 325
 326        free_irq(dev->irq[0], locomokbd);
 327
 328        del_timer_sync(&locomokbd->timer);
 329
 330        input_unregister_device(locomokbd->input);
 331        locomo_set_drvdata(dev, NULL);
 332
 333        release_mem_region((unsigned long) dev->mapbase, dev->length);
 334
 335        kfree(locomokbd);
 336
 337        return 0;
 338}
 339
 340static struct locomo_driver keyboard_driver = {
 341        .drv = {
 342                .name = "locomokbd"
 343        },
 344        .devid  = LOCOMO_DEVID_KEYBOARD,
 345        .probe  = locomokbd_probe,
 346        .remove = locomokbd_remove,
 347};
 348
 349static int __init locomokbd_init(void)
 350{
 351        return locomo_driver_register(&keyboard_driver);
 352}
 353
 354static void __exit locomokbd_exit(void)
 355{
 356        locomo_driver_unregister(&keyboard_driver);
 357}
 358
 359module_init(locomokbd_init);
 360module_exit(locomokbd_exit);
 361