drivers/input/keyboard/hilkbd.c

   1 /*
   2  *  linux/drivers/hil/hilkbd.c
   3  *
   4  *  Copyright (C) 1998 Philip Blundell <philb@gnu.org>
   5  *  Copyright (C) 1999 Matthew Wilcox <willy@infradead.org>
   6  *  Copyright (C) 1999-2007 Helge Deller <deller@gmx.de>
   7  *
   8  *  Very basic HP Human Interface Loop (HIL) driver.
   9  *  This driver handles the keyboard on HP300 (m68k) and on some
  10  *  HP700 (parisc) series machines.
  11  *
  12  *
  13  * This file is subject to the terms and conditions of the GNU General Public
  14  * License version 2.  See the file COPYING in the main directory of this
  15  * archive for more details.
  16  */
  17
  18 #include <linux/pci_ids.h>
  19 #include <linux/ioport.h>
  20 #include <linux/module.h>
  21 #include <linux/errno.h>
  22 #include <linux/input.h>
  23 #include <linux/init.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/hil.h>
  26 #include <linux/io.h>
  27 #include <linux/sched.h>
  28 #include <linux/spinlock.h>
  29 #include <asm/irq.h>
  30 #ifdef CONFIG_HP300
  31 #include <asm/hwtest.h>
  32 #endif
  33
  34
  35 MODULE_AUTHOR("Philip Blundell, Matthew Wilcox, Helge Deller");
  36 MODULE_DESCRIPTION("HIL keyboard driver (basic functionality)");
  37 MODULE_LICENSE("GPL v2");
  38
  39
  40 #if defined(CONFIG_PARISC)
  41
  42  #include <asm/io.h>
  43  #include <asm/hardware.h>
  44  #include <asm/parisc-device.h>
  45  static unsigned long hil_base; /* HPA for the HIL device */
  46  static unsigned int hil_irq;
  47  #define HILBASE                hil_base /* HPPA (parisc) port address */
  48  #define HIL_DATA               0x800
  49  #define HIL_CMD                0x801
  50  #define HIL_IRQ                hil_irq
  51  #define hil_readb(p)           gsc_readb(p)
  52  #define hil_writeb(v,p)        gsc_writeb((v),(p))
  53
  54 #elif defined(CONFIG_HP300)
  55
  56  #define HILBASE                0xf0428000UL /* HP300 (m68k) port address */
  57  #define HIL_DATA               0x1
  58  #define HIL_CMD                0x3
  59  #define HIL_IRQ                2
  60  #define hil_readb(p)           readb((const volatile void __iomem *)(p))
  61  #define hil_writeb(v, p)       writeb((v), (volatile void __iomem *)(p))
  62
  63 #else
  64 #error "HIL is not supported on this platform"
  65 #endif
  66
  67
  68
  69 /* HIL helper functions */
  70
  71 #define hil_busy()              (hil_readb(HILBASE + HIL_CMD) & HIL_BUSY)
  72 #define hil_data_available()    (hil_readb(HILBASE + HIL_CMD) & HIL_DATA_RDY)
  73 #define hil_status()            (hil_readb(HILBASE + HIL_CMD))
  74 #define hil_command(x)          do { hil_writeb((x), HILBASE + HIL_CMD); } while (0)
  75 #define hil_read_data()         (hil_readb(HILBASE + HIL_DATA))
  76 #define hil_write_data(x)       do { hil_writeb((x), HILBASE + HIL_DATA); } while (0)
  77
  78 /* HIL constants */
  79
  80 #define HIL_BUSY                0x02
  81 #define HIL_DATA_RDY            0x01
  82
  83 #define HIL_SETARD              0xA0            /* set auto-repeat delay */
  84 #define HIL_SETARR              0xA2            /* set auto-repeat rate */
  85 #define HIL_SETTONE             0xA3            /* set tone generator */
  86 #define HIL_CNMT                0xB2            /* clear nmi */
  87 #define HIL_INTON               0x5C            /* Turn on interrupts. */
  88 #define HIL_INTOFF              0x5D            /* Turn off interrupts. */
  89
  90 #define HIL_READKBDSADR         0xF9
  91 #define HIL_WRITEKBDSADR        0xE9
  92
  93 static unsigned int hphilkeyb_keycode[HIL_KEYCODES_SET1_TBLSIZE] __read_mostly =
  94         { HIL_KEYCODES_SET1 };
  95
  96 /* HIL structure */
  97 static struct {
  98         struct input_dev *dev;
  99
 100         unsigned int curdev;
 101
 102         unsigned char s;
 103         unsigned char c;
 104         int valid;
 105
 106         unsigned char data[16];
 107         unsigned int ptr;
 108         spinlock_t lock;
 109
 110         void *dev_id;   /* native bus device */
 111 } hil_dev;
 112
 113
 114 static void poll_finished(void)
 115 {
 116         int down;
 117         int key;
 118         unsigned char scode;
 119
 120         switch (hil_dev.data[0]) {
 121         case 0x40:
 122                 down = (hil_dev.data[1] & 1) == 0;
 123                 scode = hil_dev.data[1] >> 1;
 124                 key = hphilkeyb_keycode[scode];
 125                 input_report_key(hil_dev.dev, key, down);
 126                 break;
 127         }
 128         hil_dev.curdev = 0;
 129 }
 130
 131
 132 static inline void handle_status(unsigned char s, unsigned char c)
 133 {
 134         if (c & 0x8) {
 135                 /* End of block */
 136                 if (c & 0x10)
 137                         poll_finished();
 138         } else {
 139                 if (c & 0x10) {
 140                         if (hil_dev.curdev)
 141                                 poll_finished();  /* just in case */
 142                         hil_dev.curdev = c & 7;
 143                         hil_dev.ptr = 0;
 144                 }
 145         }
 146 }
 147
 148
 149 static inline void handle_data(unsigned char s, unsigned char c)
 150 {
 151         if (hil_dev.curdev) {
 152                 hil_dev.data[hil_dev.ptr++] = c;
 153                 hil_dev.ptr &= 15;
 154         }
 155 }
 156
 157
 158 /* handle HIL interrupts */
 159 static irqreturn_t hil_interrupt(int irq, void *handle)
 160 {
 161         unsigned char s, c;
 162
 163         s = hil_status();
 164         c = hil_read_data();
 165
 166         switch (s >> 4) {
 167         case 0x5:
 168                 handle_status(s, c);
 169                 break;
 170         case 0x6:
 171                 handle_data(s, c);
 172                 break;
 173         case 0x4:
 174                 hil_dev.s = s;
 175                 hil_dev.c = c;
 176                 mb();
 177                 hil_dev.valid = 1;
 178                 break;
 179         }
 180         return IRQ_HANDLED;
 181 }
 182
 183
 184 /* send a command to the HIL */
 185 static void hil_do(unsigned char cmd, unsigned char *data, unsigned int len)
 186 {
 187         unsigned long flags;
 188
 189         spin_lock_irqsave(&hil_dev.lock, flags);
 190         while (hil_busy())
 191                 /* wait */;
 192         hil_command(cmd);
 193         while (len--) {
 194                 while (hil_busy())
 195                         /* wait */;
 196                 hil_write_data(*(data++));
 197         }
 198         spin_unlock_irqrestore(&hil_dev.lock, flags);
 199 }
 200
 201
 202 /* initialize HIL */
 203 static int hil_keyb_init(void)
 204 {
 205         unsigned char c;
 206         unsigned int i, kbid;
 207         wait_queue_head_t hil_wait;
 208         int err;
 209
 210         if (hil_dev.dev)
 211                 return -ENODEV; /* already initialized */
 212
 213         init_waitqueue_head(&hil_wait);
 214         spin_lock_init(&hil_dev.lock);
 215
 216         hil_dev.dev = input_allocate_device();
 217         if (!hil_dev.dev)
 218                 return -ENOMEM;
 219
 220         err = request_irq(HIL_IRQ, hil_interrupt, 0, "hil", hil_dev.dev_id);
 221         if (err) {
 222                 printk(KERN_ERR "HIL: Can't get IRQ\n");
 223                 goto err1;
 224         }
 225
 226         /* Turn on interrupts */
 227         hil_do(HIL_INTON, NULL, 0);
 228
 229         /* Look for keyboards */
 230         hil_dev.valid = 0;      /* clear any pending data */
 231         hil_do(HIL_READKBDSADR, NULL, 0);
 232
 233         wait_event_interruptible_timeout(hil_wait, hil_dev.valid, 3 * HZ);
 234         if (!hil_dev.valid)
 235                 printk(KERN_WARNING "HIL: timed out, assuming no keyboard present\n");
 236
 237         c = hil_dev.c;
 238         hil_dev.valid = 0;
 239         if (c == 0) {
 240                 kbid = -1;
 241                 printk(KERN_WARNING "HIL: no keyboard present\n");
 242         } else {
 243                 kbid = ffz(~c);
 244                 printk(KERN_INFO "HIL: keyboard found at id %d\n", kbid);
 245         }
 246
 247         /* set it to raw mode */
 248         c = 0;
 249         hil_do(HIL_WRITEKBDSADR, &c, 1);
 250
 251         for (i = 0; i < HIL_KEYCODES_SET1_TBLSIZE; i++)
 252                 if (hphilkeyb_keycode[i] != KEY_RESERVED)
 253                         __set_bit(hphilkeyb_keycode[i], hil_dev.dev->keybit);
 254
 255         hil_dev.dev->evbit[0]   = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
 256         hil_dev.dev->ledbit[0]  = BIT_MASK(LED_NUML) | BIT_MASK(LED_CAPSL) |
 257                 BIT_MASK(LED_SCROLLL);
 258         hil_dev.dev->keycodemax = HIL_KEYCODES_SET1_TBLSIZE;
 259         hil_dev.dev->keycodesize= sizeof(hphilkeyb_keycode[0]);
 260         hil_dev.dev->keycode    = hphilkeyb_keycode;
 261         hil_dev.dev->name       = "HIL keyboard";
 262         hil_dev.dev->phys       = "hpkbd/input0";
 263
 264         hil_dev.dev->id.bustype = BUS_HIL;
 265         hil_dev.dev->id.vendor  = PCI_VENDOR_ID_HP;
 266         hil_dev.dev->id.product = 0x0001;
 267         hil_dev.dev->id.version = 0x0010;
 268
 269         err = input_register_device(hil_dev.dev);
 270         if (err) {
 271                 printk(KERN_ERR "HIL: Can't register device\n");
 272                 goto err2;
 273         }
 274
 275         printk(KERN_INFO "input: %s, ID %d at 0x%08lx (irq %d) found and attached\n",
 276                hil_dev.dev->name, kbid, HILBASE, HIL_IRQ);
 277
 278         return 0;
 279
 280 err2:
 281         hil_do(HIL_INTOFF, NULL, 0);
 282         free_irq(HIL_IRQ, hil_dev.dev_id);
 283 err1:
 284         input_free_device(hil_dev.dev);
 285         hil_dev.dev = NULL;
 286         return err;
 287 }
 288
 289 static void hil_keyb_exit(void)
 290 {
 291         if (HIL_IRQ)
 292                 free_irq(HIL_IRQ, hil_dev.dev_id);
 293
 294         /* Turn off interrupts */
 295         hil_do(HIL_INTOFF, NULL, 0);
 296
 297         input_unregister_device(hil_dev.dev);
 298         hil_dev.dev = NULL;
 299 }
 300
 301 #if defined(CONFIG_PARISC)
 302 static int __init hil_probe_chip(struct parisc_device *dev)
 303 {
 304         /* Only allow one HIL keyboard */
 305         if (hil_dev.dev)
 306                 return -ENODEV;
 307
 308         if (!dev->irq) {
 309                 printk(KERN_WARNING "HIL: IRQ not found for HIL bus at 0x%p\n",
 310                         (void *)dev->hpa.start);
 311                 return -ENODEV;
 312         }
 313
 314         hil_base = dev->hpa.start;
 315         hil_irq  = dev->irq;
 316         hil_dev.dev_id = dev;
 317
 318         printk(KERN_INFO "Found HIL bus at 0x%08lx, IRQ %d\n", hil_base, hil_irq);
 319
 320         return hil_keyb_init();
 321 }
 322
 323 static int __exit hil_remove_chip(struct parisc_device *dev)
 324 {
 325         hil_keyb_exit();
 326
 327         return 0;
 328 }
 329
 330 static const struct parisc_device_id hil_tbl[] __initconst = {
 331         { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x00073 },
 332         { 0, }
 333 };
 334
 335 #if 0
 336 /* Disabled to avoid conflicts with the HP SDC HIL drivers */
 337 MODULE_DEVICE_TABLE(parisc, hil_tbl);
 338 #endif
 339
 340 static struct parisc_driver hil_driver __refdata = {
 341         .name           = "hil",
 342         .id_table       = hil_tbl,
 343         .probe          = hil_probe_chip,
 344         .remove         = __exit_p(hil_remove_chip),
 345 };
 346
 347 static int __init hil_init(void)
 348 {
 349         return register_parisc_driver(&hil_driver);
 350 }
 351
 352 static void __exit hil_exit(void)
 353 {
 354         unregister_parisc_driver(&hil_driver);
 355 }
 356
 357 #else /* !CONFIG_PARISC */
 358
 359 static int __init hil_init(void)
 360 {
 361         int error;
 362
 363         /* Only allow one HIL keyboard */
 364         if (hil_dev.dev)
 365                 return -EBUSY;
 366
 367         if (!MACH_IS_HP300)
 368                 return -ENODEV;
 369
 370         if (!hwreg_present((void *)(HILBASE + HIL_DATA))) {
 371                 printk(KERN_ERR "HIL: hardware register was not found\n");
 372                 return -ENODEV;
 373         }
 374
 375         if (!request_region(HILBASE + HIL_DATA, 2, "hil")) {
 376                 printk(KERN_ERR "HIL: IOPORT region already used\n");
 377                 return -EIO;
 378         }
 379
 380         error = hil_keyb_init();
 381         if (error) {
 382                 release_region(HILBASE + HIL_DATA, 2);
 383                 return error;
 384         }
 385
 386         return 0;
 387 }
 388
 389 static void __exit hil_exit(void)
 390 {
 391         hil_keyb_exit();
 392         release_region(HILBASE + HIL_DATA, 2);
 393 }
 394
 395 #endif /* CONFIG_PARISC */
 396
 397 module_init(hil_init);
 398 module_exit(hil_exit);