drivers/sbus/char/pcikbd.c

   1 /* $Id: pcikbd.c,v 1.61 2001/08/18 09:40:46 davem Exp $
   2  * pcikbd.c: Ultra/AX PC keyboard support.
   3  *
   4  * Copyright (C) 1997  Eddie C. Dost  (ecd@skynet.be)
   5  * JavaStation support by Pete A. Zaitcev.
   6  *
   7  * This code is mainly put together from various places in
   8  * drivers/char, please refer to these sources for credits
   9  * to the original authors.
  10  */
  11
  12 #include <linux/config.h>
  13 #include <linux/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/sched.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/ioport.h>
  18 #include <linux/poll.h>
  19 #include <linux/slab.h>
  20 #include <linux/errno.h>
  21 #include <linux/random.h>
  22 #include <linux/miscdevice.h>
  23 #include <linux/kbd_ll.h>
  24 #include <linux/kbd_kern.h>
  25 #include <linux/vt_kern.h>
  26 #include <linux/delay.h>
  27 #include <linux/spinlock.h>
  28 #include <linux/smp_lock.h>
  29 #include <linux/init.h>
  30
  31 #include <asm/ebus.h>
  32 #if (defined(CONFIG_USB) || defined(CONFIG_USB_MODULE)) && defined(CONFIG_SPARC64)
  33 #include <asm/isa.h>
  34 #endif
  35 #include <asm/oplib.h>
  36 #include <asm/irq.h>
  37 #include <asm/io.h>
  38 #include <asm/uaccess.h>
  39
  40 /*
  41  * Different platforms provide different permutations of names.
  42  * AXi - kb_ps2, kdmouse.
  43  * MrCoffee - keyboard, mouse.
  44  * Espresso - keyboard, kdmouse.
  45  */
  46 #define PCI_KB_NAME1    "kb_ps2"
  47 #define PCI_KB_NAME2    "keyboard"
  48 #define PCI_MS_NAME1    "kdmouse"
  49 #define PCI_MS_NAME2    "mouse"
  50
  51 #include "pcikbd.h"
  52 #include "sunserial.h"
  53
  54 #ifndef __sparc_v9__
  55 static int pcikbd_mrcoffee = 0;
  56 #else
  57 #define pcikbd_mrcoffee 0
  58 extern void (*prom_keyboard)(void);
  59 #endif
  60
  61 static unsigned long pcikbd_iobase = 0;
  62 static unsigned int pcikbd_irq = 0;
  63
  64 /* used only by send_data - set by keyboard_interrupt */
  65 static volatile unsigned char reply_expected = 0;
  66 static volatile unsigned char acknowledge = 0;
  67 static volatile unsigned char resend = 0;
  68
  69 static spinlock_t pcikbd_lock = SPIN_LOCK_UNLOCKED;
  70
  71 static void pcikbd_write(int address, int data);
  72 static int pcikbd_wait_for_input(void);
  73
  74 unsigned char pckbd_read_mask = KBD_STAT_OBF;
  75
  76 extern int pcikbd_init(void);
  77 extern void pci_compute_shiftstate(void);
  78 extern int pci_setkeycode(unsigned int, unsigned int);
  79 extern int pci_getkeycode(unsigned int);
  80 extern void pci_setledstate(struct kbd_struct *, unsigned int);
  81 extern unsigned char pci_getledstate(void);
  82
  83 #define pcikbd_inb(x)     inb(x)
  84 #define pcikbd_outb(v,x)  outb(v,x)
  85
  86 /* Wait for keyboard controller input buffer to drain.
  87  * Must be invoked under the pcikbd_lock.
  88  */
  89 static void kb_wait(void)
  90 {
  91         unsigned long timeout = 250;
  92
  93         do {
  94                 if(!(pcikbd_inb(pcikbd_iobase + KBD_STATUS_REG) & KBD_STAT_IBF))
  95                         return;
  96                 mdelay(1);
  97         } while (--timeout);
  98 }
  99
 100 /*
 101  * Translation of escaped scancodes to keycodes.
 102  * This is now user-settable.
 103  * The keycodes 1-88,96-111,119 are fairly standard, and
 104  * should probably not be changed - changing might confuse X.
 105  * X also interprets scancode 0x5d (KEY_Begin).
 106  *
 107  * For 1-88 keycode equals scancode.
 108  */
 109
 110 #define E0_KPENTER 96
 111 #define E0_RCTRL   97
 112 #define E0_KPSLASH 98
 113 #define E0_PRSCR   99
 114 #define E0_RALT    100
 115 #define E0_BREAK   101  /* (control-pause) */
 116 #define E0_HOME    102
 117 #define E0_UP      103
 118 #define E0_PGUP    104
 119 #define E0_LEFT    105
 120 #define E0_RIGHT   106
 121 #define E0_END     107
 122 #define E0_DOWN    108
 123 #define E0_PGDN    109
 124 #define E0_INS     110
 125 #define E0_DEL     111
 126
 127 #define E1_PAUSE   119
 128
 129 /*
 130  * The keycodes below are randomly located in 89-95,112-118,120-127.
 131  * They could be thrown away (and all occurrences below replaced by 0),
 132  * but that would force many users to use the `setkeycodes' utility, where
 133  * they needed not before. It does not matter that there are duplicates, as
 134  * long as no duplication occurs for any single keyboard.
 135  */
 136 #define SC_LIM 89
 137
 138 #define FOCUS_PF1 85           /* actual code! */
 139 #define FOCUS_PF2 89
 140 #define FOCUS_PF3 90
 141 #define FOCUS_PF4 91
 142 #define FOCUS_PF5 92
 143 #define FOCUS_PF6 93
 144 #define FOCUS_PF7 94
 145 #define FOCUS_PF8 95
 146 #define FOCUS_PF9 120
 147 #define FOCUS_PF10 121
 148 #define FOCUS_PF11 122
 149 #define FOCUS_PF12 123
 150
 151 #define JAP_86     124
 152 /* tfj@olivia.ping.dk:
 153  * The four keys are located over the numeric keypad, and are
 154  * labelled A1-A4. It's an rc930 keyboard, from
 155  * Regnecentralen/RC International, Now ICL.
 156  * Scancodes: 59, 5a, 5b, 5c.
 157  */
 158 #define RGN1 124
 159 #define RGN2 125
 160 #define RGN3 126
 161 #define RGN4 127
 162
 163 static unsigned char high_keys[128 - SC_LIM] = {
 164   RGN1, RGN2, RGN3, RGN4, 0, 0, 0,                   /* 0x59-0x5f */
 165   0, 0, 0, 0, 0, 0, 0, 0,                            /* 0x60-0x67 */
 166   0, 0, 0, 0, 0, FOCUS_PF11, 0, FOCUS_PF12,          /* 0x68-0x6f */
 167   0, 0, 0, FOCUS_PF2, FOCUS_PF9, 0, 0, FOCUS_PF3,    /* 0x70-0x77 */
 168   FOCUS_PF4, FOCUS_PF5, FOCUS_PF6, FOCUS_PF7,        /* 0x78-0x7b */
 169   FOCUS_PF8, JAP_86, FOCUS_PF10, 0                   /* 0x7c-0x7f */
 170 };
 171
 172 /* BTC */
 173 #define E0_MACRO   112
 174 /* LK450 */
 175 #define E0_F13     113
 176 #define E0_F14     114
 177 #define E0_HELP    115
 178 #define E0_DO      116
 179 #define E0_F17     117
 180 #define E0_KPMINPLUS 118
 181 /*
 182  * My OmniKey generates e0 4c for  the "OMNI" key and the
 183  * right alt key does nada. [kkoller@nyx10.cs.du.edu]
 184  */
 185 #define E0_OK   124
 186 /*
 187  * New microsoft keyboard is rumoured to have
 188  * e0 5b (left window button), e0 5c (right window button),
 189  * e0 5d (menu button). [or: LBANNER, RBANNER, RMENU]
 190  * [or: Windows_L, Windows_R, TaskMan]
 191  */
 192 #define E0_MSLW 125
 193 #define E0_MSRW 126
 194 #define E0_MSTM 127
 195
 196 static unsigned char e0_keys[128] = {
 197   0, 0, 0, 0, 0, 0, 0, 0,                             /* 0x00-0x07 */
 198   0, 0, 0, 0, 0, 0, 0, 0,                             /* 0x08-0x0f */
 199   0, 0, 0, 0, 0, 0, 0, 0,                             /* 0x10-0x17 */
 200   0, 0, 0, 0, E0_KPENTER, E0_RCTRL, 0, 0,             /* 0x18-0x1f */
 201   0, 0, 0, 0, 0, 0, 0, 0,                             /* 0x20-0x27 */
 202   0, 0, 0, 0, 0, 0, 0, 0,                             /* 0x28-0x2f */
 203   0, 0, 0, 0, 0, E0_KPSLASH, 0, E0_PRSCR,             /* 0x30-0x37 */
 204   E0_RALT, 0, 0, 0, 0, E0_F13, E0_F14, E0_HELP,       /* 0x38-0x3f */
 205   E0_DO, E0_F17, 0, 0, 0, 0, E0_BREAK, E0_HOME,       /* 0x40-0x47 */
 206   E0_UP, E0_PGUP, 0, E0_LEFT, E0_OK, E0_RIGHT, E0_KPMINPLUS, E0_END,/* 0x48-0x4f */
 207   E0_DOWN, E0_PGDN, E0_INS, E0_DEL, 0, 0, 0, 0,       /* 0x50-0x57 */
 208   0, 0, 0, E0_MSLW, E0_MSRW, E0_MSTM, 0, 0,           /* 0x58-0x5f */
 209   0, 0, 0, 0, 0, 0, 0, 0,                             /* 0x60-0x67 */
 210   0, 0, 0, 0, 0, 0, 0, E0_MACRO,                      /* 0x68-0x6f */
 211   0, 0, 0, 0, 0, 0, 0, 0,                             /* 0x70-0x77 */
 212   0, 0, 0, 0, 0, 0, 0, 0                              /* 0x78-0x7f */
 213 };
 214
 215 /* Simple translation table for the SysRq keys */
 216
 217 #ifdef CONFIG_MAGIC_SYSRQ
 218 unsigned char pcikbd_sysrq_xlate[128] =
 219         "\000\0331234567890-=\177\t"                    /* 0x00 - 0x0f */
 220         "qwertyuiop[]\r\000as"                          /* 0x10 - 0x1f */
 221         "dfghjkl;'`\000\\zxcv"                          /* 0x20 - 0x2f */
 222         "bnm,./\000*\000 \000\201\202\203\204\205"      /* 0x30 - 0x3f */
 223         "\206\207\210\211\212\000\000789-456+1"         /* 0x40 - 0x4f */
 224         "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
 225         "\r\000/";                                      /* 0x60 - 0x6f */
 226 #endif
 227
 228 #define DEFAULT_KEYB_REP_DELAY  250
 229 #define DEFAULT_KEYB_REP_RATE   30      /* cps */
 230
 231 static struct kbd_repeat kbdrate = {
 232         DEFAULT_KEYB_REP_DELAY,
 233         DEFAULT_KEYB_REP_RATE
 234 };
 235
 236 static unsigned char parse_kbd_rate(struct kbd_repeat *r);
 237 static int write_kbd_rate(unsigned char r);
 238
 239 int pcikbd_setkeycode(unsigned int scancode, unsigned int keycode)
 240 {
 241         if(scancode < SC_LIM || scancode > 255 || keycode > 127)
 242                 return -EINVAL;
 243         if(scancode < 128)
 244                 high_keys[scancode - SC_LIM] = keycode;
 245         else
 246                 e0_keys[scancode - 128] = keycode;
 247         return 0;
 248 }
 249
 250 int pcikbd_getkeycode(unsigned int scancode)
 251 {
 252         return
 253                 (scancode < SC_LIM || scancode > 255) ? -EINVAL :
 254                 (scancode < 128) ? high_keys[scancode - SC_LIM] :
 255                 e0_keys[scancode - 128];
 256 }
 257
 258 static int do_acknowledge(unsigned char scancode)
 259 {
 260         if(reply_expected) {
 261                 if(scancode == KBD_REPLY_ACK) {
 262                         acknowledge = 1;
 263                         reply_expected = 0;
 264                         return 0;
 265                 } else if(scancode == KBD_REPLY_RESEND) {
 266                         resend = 1;
 267                         reply_expected = 0;
 268                         return 0;
 269                 }
 270         }
 271         return 1;
 272 }
 273
 274 #ifdef __sparc_v9__
 275 static void pcikbd_enter_prom(void)
 276 {
 277         pcikbd_write(KBD_DATA_REG, KBD_CMD_DISABLE);
 278         if(pcikbd_wait_for_input() != KBD_REPLY_ACK)
 279                 printk("Prom Enter: Disable keyboard: no ACK\n");
 280
 281         /* Disable PC scancode translation */
 282         pcikbd_write(KBD_CNTL_REG, KBD_CCMD_WRITE_MODE);
 283         pcikbd_write(KBD_DATA_REG, KBD_MODE_SYS);
 284         pcikbd_write(KBD_DATA_REG, KBD_CMD_ENABLE);
 285         if (pcikbd_wait_for_input() != KBD_REPLY_ACK)
 286                 printk("Prom Enter: Enable Keyboard: no ACK\n");
 287 }
 288 #endif
 289
 290 static void ctrl_break(void)
 291 {
 292         extern int stop_a_enabled;
 293         unsigned long timeout;
 294         int status, data;
 295         int mode;
 296
 297         if (!stop_a_enabled)
 298                 return;
 299
 300         pcikbd_write(KBD_DATA_REG, KBD_CMD_DISABLE);
 301         if(pcikbd_wait_for_input() != KBD_REPLY_ACK)
 302                 printk("Prom Enter: Disable keyboard: no ACK\n");
 303
 304         /* Save current mode register settings */
 305         pcikbd_write(KBD_CNTL_REG, KBD_CCMD_READ_MODE);
 306         if ((mode = pcikbd_wait_for_input()) == -1)
 307                 printk("Prom Enter: Read Mode: no ACK\n");
 308
 309         /* Disable PC scancode translation */
 310         pcikbd_write(KBD_CNTL_REG, KBD_CCMD_WRITE_MODE);
 311         pcikbd_write(KBD_DATA_REG, mode & ~(KBD_MODE_KCC));
 312         pcikbd_write(KBD_DATA_REG, KBD_CMD_ENABLE);
 313         if (pcikbd_wait_for_input() != KBD_REPLY_ACK)
 314                 printk("Prom Enter: Enable Keyboard: no ACK\n");
 315
 316         /* Drop into OBP.
 317          * Note that we must flush the user windows
 318          * first before giving up control.
 319          */
 320         flush_user_windows();
 321         prom_cmdline();
 322
 323         /* Read prom's key up event (use short timeout) */
 324         do {
 325                 timeout = 10;
 326                 do {
 327                         mdelay(1);
 328                         status = pcikbd_inb(pcikbd_iobase + KBD_STATUS_REG);
 329                         if (!(status & KBD_STAT_OBF))
 330                                 continue;
 331                         data = pcikbd_inb(pcikbd_iobase + KBD_DATA_REG);
 332                         if (status & (KBD_STAT_GTO | KBD_STAT_PERR))
 333                                 continue;
 334                         break;
 335                 } while (--timeout > 0);
 336         } while (timeout > 0);
 337
 338         /* Reenable PC scancode translation */
 339         pcikbd_write(KBD_DATA_REG, KBD_CMD_DISABLE);
 340         if(pcikbd_wait_for_input() != KBD_REPLY_ACK)
 341                 printk("Prom Leave: Disable keyboard: no ACK\n");
 342
 343         pcikbd_write(KBD_CNTL_REG, KBD_CCMD_WRITE_MODE);
 344         pcikbd_write(KBD_DATA_REG, mode);
 345         pcikbd_write(KBD_DATA_REG, KBD_CMD_ENABLE);
 346         if (pcikbd_wait_for_input() != KBD_REPLY_ACK)
 347                 printk("Prom Leave: Enable Keyboard: no ACK\n");
 348
 349         /* Reset keyboard rate */
 350         write_kbd_rate(parse_kbd_rate(&kbdrate));
 351 }
 352
 353 int pcikbd_translate(unsigned char scancode, unsigned char *keycode,
 354                      char raw_mode)
 355 {
 356         static int prev_scancode = 0;
 357         int down = scancode & 0x80 ? 0 : 1;
 358
 359         if (scancode == 0xe0 || scancode == 0xe1) {
 360                 prev_scancode = scancode;
 361                 return 0;
 362         }
 363         if (scancode == 0x00 || scancode == 0xff) {
 364                 prev_scancode = 0;
 365                 return 0;
 366         }
 367         scancode &= 0x7f;
 368         if(prev_scancode) {
 369                 if(prev_scancode != 0xe0) {
 370                         if(prev_scancode == 0xe1 && scancode == 0x1d) {
 371                                 prev_scancode = 0x100;
 372                                 return 0;
 373                         } else if(prev_scancode == 0x100 && scancode == 0x45) {
 374                                 *keycode = E1_PAUSE;
 375                                 prev_scancode = 0;
 376                         } else {
 377                                 prev_scancode = 0;
 378                                 return 0;
 379                         }
 380                 } else {
 381                         prev_scancode = 0;
 382                         if(scancode == 0x2a || scancode == 0x36)
 383                                 return 0;
 384                         if(e0_keys[scancode])
 385                                 *keycode = e0_keys[scancode];
 386                         else
 387                                 return 0;
 388                 }
 389         } else if(scancode >= SC_LIM) {
 390                 *keycode = high_keys[scancode - SC_LIM];
 391                 if(!*keycode)
 392                         return 0;
 393
 394         } else
 395                 *keycode = scancode;
 396
 397         if (*keycode == E0_BREAK) {
 398                 if (down)
 399                         return 0;
 400
 401                 /* Handle ctrl-break event */
 402                 ctrl_break();
 403
 404                 /* Send ctrl up event to the keyboard driver */
 405                 *keycode = 0x1d;
 406         }
 407
 408         return 1;
 409 }
 410
 411 char pcikbd_unexpected_up(unsigned char keycode)
 412 {
 413         if(keycode >= SC_LIM || keycode == 85)
 414                 return 0;
 415         else
 416                 return 0200;
 417 }
 418
 419 static void
 420 pcikbd_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 421 {
 422         unsigned long flags;
 423         unsigned char status;
 424
 425         spin_lock_irqsave(&pcikbd_lock, flags);
 426
 427         kbd_pt_regs = regs;
 428         status = pcikbd_inb(pcikbd_iobase + KBD_STATUS_REG);
 429         do {
 430                 unsigned char scancode;
 431
 432                 if(status & pckbd_read_mask & KBD_STAT_MOUSE_OBF)
 433                         break;
 434                 scancode = pcikbd_inb(pcikbd_iobase + KBD_DATA_REG);
 435                 if((status & KBD_STAT_OBF) && do_acknowledge(scancode))
 436                         handle_scancode(scancode, !(scancode & 0x80));
 437                 status = pcikbd_inb(pcikbd_iobase + KBD_STATUS_REG);
 438         } while(status & KBD_STAT_OBF);
 439         tasklet_schedule(&keyboard_tasklet);
 440
 441         spin_unlock_irqrestore(&pcikbd_lock, flags);
 442 }
 443
 444 static int send_data(unsigned char data)
 445 {
 446         int retries = 3;
 447         unsigned long flags;
 448
 449         do {
 450                 unsigned long timeout = 1000;
 451
 452                 spin_lock_irqsave(&pcikbd_lock, flags);
 453
 454                 kb_wait();
 455
 456                 acknowledge = 0;
 457                 resend = 0;
 458                 reply_expected = 1;
 459
 460                 pcikbd_outb(data, pcikbd_iobase + KBD_DATA_REG);
 461
 462                 spin_unlock_irqrestore(&pcikbd_lock, flags);
 463
 464                 do {
 465                         if (acknowledge)
 466                                 return 1;
 467                         if (resend)
 468                                 break;
 469                         mdelay(1);
 470                 } while (--timeout);
 471
 472                 if (timeout == 0)
 473                         break;
 474
 475         } while (retries-- > 0);
 476
 477         return 0;
 478 }
 479
 480 void pcikbd_leds(unsigned char leds)
 481 {
 482         if (!pcikbd_iobase)
 483                 return;
 484         if (!send_data(KBD_CMD_SET_LEDS) || !send_data(leds))
 485                 send_data(KBD_CMD_ENABLE);
 486 }
 487
 488 static unsigned char parse_kbd_rate(struct kbd_repeat *r)
 489 {
 490         static struct r2v {
 491                 int rate;
 492                 unsigned char val;
 493         } kbd_rates[]={ { 5,  0x14 },
 494                         { 7,  0x10 },
 495                         { 10, 0x0c },
 496                         { 15, 0x08 },
 497                         { 20, 0x04 },
 498                         { 25, 0x02 },
 499                         { 30, 0x00 } };
 500         static struct d2v {
 501                 int delay;
 502                 unsigned char val;
 503         } kbd_delays[]={ { 250,  0 },
 504                          { 500,  1 },
 505                          { 750,  2 },
 506                          { 1000, 3 } };
 507         int rate = 0, delay = 0;
 508
 509         if (r != NULL) {
 510                 int i, new_rate = 30, new_delay = 250;
 511                 if (r->rate <= 0)
 512                         r->rate = kbdrate.rate;
 513                 if (r->delay <= 0)
 514                         r->delay = kbdrate.delay;
 515
 516                 for (i = 0; i < sizeof(kbd_rates) / sizeof(struct r2v); i++) {
 517                         if (kbd_rates[i].rate == r->rate) {
 518                                 new_rate = kbd_rates[i].rate;
 519                                 rate = kbd_rates[i].val;
 520                                 break;
 521                         }
 522                 }
 523                 for (i=0; i < sizeof(kbd_delays) / sizeof(struct d2v); i++) {
 524                         if (kbd_delays[i].delay == r->delay) {
 525                                 new_delay = kbd_delays[i].delay;
 526                                 delay = kbd_delays[i].val;
 527                                 break;
 528                         }
 529                 }
 530                 r->rate = new_rate;
 531                 r->delay = new_delay;
 532         }
 533         return (delay << 5) | rate;
 534 }
 535
 536 static int write_kbd_rate(unsigned char r)
 537 {
 538         if (!send_data(KBD_CMD_SET_RATE) || !send_data(r)) {
 539                 /* re-enable kbd if any errors */
 540                 send_data(KBD_CMD_ENABLE);
 541                 return 0;
 542         }
 543
 544         return 1;
 545 }
 546
 547 static int pcikbd_rate(struct kbd_repeat *rep)
 548 {
 549         unsigned char r;
 550         struct kbd_repeat old_rep;
 551
 552         if (rep == NULL)
 553                 return -EINVAL;
 554
 555         r = parse_kbd_rate(rep);
 556         memcpy(&old_rep, &kbdrate, sizeof(struct kbd_repeat));
 557         if (write_kbd_rate(r)) {
 558                 memcpy(&kbdrate,rep,sizeof(struct kbd_repeat));
 559                 memcpy(rep,&old_rep,sizeof(struct kbd_repeat));
 560                 return 0;
 561         }
 562
 563         return -EIO;
 564 }
 565
 566 static int pcikbd_wait_for_input(void)
 567 {
 568         int status, data;
 569         unsigned long timeout = 1000;
 570
 571         do {
 572                 mdelay(1);
 573
 574                 status = pcikbd_inb(pcikbd_iobase + KBD_STATUS_REG);
 575                 if (!(status & KBD_STAT_OBF))
 576                         continue;
 577
 578                 data = pcikbd_inb(pcikbd_iobase + KBD_DATA_REG);
 579                 if (status & (KBD_STAT_GTO | KBD_STAT_PERR))
 580                         continue;
 581
 582                 return (data & 0xff);
 583
 584         } while (--timeout > 0);
 585
 586         return -1;
 587 }
 588
 589 static void pcikbd_write(int address, int data)
 590 {
 591         int status;
 592
 593         do {
 594                 status = pcikbd_inb(pcikbd_iobase + KBD_STATUS_REG);
 595         } while (status & KBD_STAT_IBF);
 596         pcikbd_outb(data, pcikbd_iobase + address);
 597 }
 598
 599 #ifdef __sparc_v9__
 600
 601 static unsigned long pcibeep_iobase = 0;
 602
 603 /* Timer routine to turn off the beep after the interval expires. */
 604 static void pcikbd_kd_nosound(unsigned long __unused)
 605 {
 606         if (pcibeep_iobase & 0x2UL)
 607                 outb(0, pcibeep_iobase);
 608         else
 609                 outl(0, pcibeep_iobase);
 610 }
 611
 612 /*
 613  * Initiate a keyboard beep. If the frequency is zero, then we stop
 614  * the beep. Any other frequency will start a monotone beep. The beep
 615  * will be stopped by a timer after "ticks" jiffies. If ticks is 0,
 616  * then we do not start a timer.
 617  */
 618 static void pcikbd_kd_mksound(unsigned int hz, unsigned int ticks)
 619 {
 620         unsigned long flags;
 621         static struct timer_list sound_timer = { function: pcikbd_kd_nosound };
 622
 623         save_flags(flags); cli();
 624         del_timer(&sound_timer);
 625         if (hz) {
 626                 if (pcibeep_iobase & 0x2UL)
 627                         outb(1, pcibeep_iobase);
 628                 else
 629                         outl(1, pcibeep_iobase);
 630                 if (ticks) {
 631                         sound_timer.expires = jiffies + ticks;
 632                         add_timer(&sound_timer);
 633                 }
 634         } else {
 635                 if (pcibeep_iobase & 0x2UL)
 636                         outb(0, pcibeep_iobase);
 637                 else
 638                         outl(0, pcibeep_iobase);
 639         }
 640         restore_flags(flags);
 641 }
 642
 643 #if (defined(CONFIG_USB) || defined(CONFIG_USB_MODULE)) && defined(CONFIG_SPARC64)
 644 static void isa_kd_nosound(unsigned long __unused)
 645 {
 646         /* disable counter 2 */
 647         outb(inb(pcibeep_iobase + 0x61)&0xFC, pcibeep_iobase + 0x61);
 648         return;
 649 }
 650
 651 static void isa_kd_mksound(unsigned int hz, unsigned int ticks)
 652 {
 653         static struct timer_list sound_timer = { function: isa_kd_nosound };
 654         unsigned int count = 0;
 655         unsigned long flags;
 656
 657         if (hz > 20 && hz < 32767)
 658                 count = 1193180 / hz;
 659
 660         save_flags(flags);
 661         cli();
 662         del_timer(&sound_timer);
 663         if (count) {
 664                 /* enable counter 2 */
 665                 outb(inb(pcibeep_iobase + 0x61)|3, pcibeep_iobase + 0x61);
 666                 /* set command for counter 2, 2 byte write */
 667                 outb(0xB6, pcibeep_iobase + 0x43);
 668                 /* select desired HZ */
 669                 outb(count & 0xff, pcibeep_iobase + 0x42);
 670                 outb((count >> 8) & 0xff, pcibeep_iobase + 0x42);
 671
 672                 if (ticks) {
 673                         sound_timer.expires = jiffies+ticks;
 674                         add_timer(&sound_timer);
 675                 }
 676         } else
 677                 isa_kd_nosound(0);
 678         restore_flags(flags);
 679         return;
 680 }
 681 #endif
 682
 683 #endif
 684
 685 static void nop_kd_mksound(unsigned int hz, unsigned int ticks)
 686 {
 687 }
 688
 689 extern void (*kd_mksound)(unsigned int hz, unsigned int ticks);
 690
 691 static char * __init do_pcikbd_init_hw(void)
 692 {
 693
 694         while(pcikbd_wait_for_input() != -1)
 695                 ;
 696
 697         pcikbd_write(KBD_CNTL_REG, KBD_CCMD_SELF_TEST);
 698         if(pcikbd_wait_for_input() != 0x55)
 699                 return "Keyboard failed self test";
 700
 701         pcikbd_write(KBD_CNTL_REG, KBD_CCMD_KBD_TEST);
 702         if(pcikbd_wait_for_input() != 0x00)
 703                 return "Keyboard interface failed self test";
 704
 705         pcikbd_write(KBD_CNTL_REG, KBD_CCMD_KBD_ENABLE);
 706         pcikbd_write(KBD_DATA_REG, KBD_CMD_RESET);
 707         if(pcikbd_wait_for_input() != KBD_REPLY_ACK)
 708                 return "Keyboard reset failed, no ACK";
 709         if(pcikbd_wait_for_input() != KBD_REPLY_POR)
 710                 return "Keyboard reset failed, no ACK";
 711
 712         pcikbd_write(KBD_DATA_REG, KBD_CMD_DISABLE);
 713         if(pcikbd_wait_for_input() != KBD_REPLY_ACK)
 714                 return "Disable keyboard: no ACK";
 715
 716         pcikbd_write(KBD_CNTL_REG, KBD_CCMD_WRITE_MODE);
 717         pcikbd_write(KBD_DATA_REG,
 718                      (KBD_MODE_KBD_INT | KBD_MODE_SYS |
 719                       KBD_MODE_DISABLE_MOUSE | KBD_MODE_KCC));
 720         pcikbd_write(KBD_DATA_REG, KBD_CMD_ENABLE);
 721         if(pcikbd_wait_for_input() != KBD_REPLY_ACK)
 722                 return "Enable keyboard: no ACK";
 723
 724         write_kbd_rate(parse_kbd_rate(&kbdrate));
 725
 726         return NULL; /* success */
 727 }
 728
 729 void __init pcikbd_init_hw(void)
 730 {
 731         struct linux_ebus *ebus;
 732         struct linux_ebus_device *edev;
 733         struct linux_ebus_child *child;
 734         char *msg;
 735
 736         if (pcikbd_mrcoffee) {
 737                 if ((pcikbd_iobase = (unsigned long) ioremap(0x71300060, 8)) == 0) {
 738                         prom_printf("pcikbd_init_hw: cannot map\n");
 739                         return;
 740                 }
 741                 pcikbd_irq = 13 | 0x20;
 742                 if (request_irq(pcikbd_irq, &pcikbd_interrupt,
 743                                 SA_SHIRQ, "keyboard", (void *)pcikbd_iobase)) {
 744                         printk("8042: cannot register IRQ %x\n", pcikbd_irq);
 745                         return;
 746                 }
 747                 printk("8042(kbd): iobase[%x] irq[%x]\n",
 748                     (unsigned)pcikbd_iobase, pcikbd_irq);
 749         } else {
 750                 for_each_ebus(ebus) {
 751                         for_each_ebusdev(edev, ebus) {
 752                                 if(!strcmp(edev->prom_name, "8042")) {
 753                                         for_each_edevchild(edev, child) {
 754                                                 if (strcmp(child->prom_name, PCI_KB_NAME1) == 0 ||
 755                                                     strcmp(child->prom_name, PCI_KB_NAME2) == 0)
 756                                                         goto found;
 757                                         }
 758                                 }
 759                         }
 760                 }
 761 #if defined(CONFIG_USB) || defined(CONFIG_USB_MODULE)
 762                 /* We are being called for the sake of USB keyboard
 763                  * state initialization.  So we should check for beeper
 764                  * device in this case.
 765                  */
 766                 edev = 0;
 767                 for_each_ebus(ebus) {
 768                         for_each_ebusdev(edev, ebus) {
 769                                 if (!strcmp(edev->prom_name, "beep")) {
 770                                         pcibeep_iobase = edev->resource[0].start;
 771                                         kd_mksound = pcikbd_kd_mksound;
 772                                         printk("8042(speaker): iobase[%016lx]\n", pcibeep_iobase);
 773                                         return;
 774                                 }
 775                         }
 776                 }
 777
 778 #ifdef CONFIG_SPARC64
 779                 /* Maybe we have one inside the ALI southbridge? */
 780                 {
 781                         struct isa_bridge *isa_br;
 782                         struct isa_device *isa_dev;
 783                         for_each_isa(isa_br) {
 784                                 for_each_isadev(isa_dev, isa_br) {
 785                                         /* This is a hack, the 'dma' device node has
 786                                          * the base of the I/O port space for that PBM
 787                                          * as it's resource, so we use that. -DaveM
 788                                          */
 789                                         if (!strcmp(isa_dev->prom_name, "dma")) {
 790                                                 pcibeep_iobase = isa_dev->resource.start;
 791                                                 kd_mksound = isa_kd_mksound;
 792                                                 printk("isa(speaker): iobase[%016lx:%016lx]\n",
 793                                                        pcibeep_iobase + 0x42,
 794                                                        pcibeep_iobase + 0x61);
 795                                                 return;
 796                                         }
 797                                 }
 798                         }
 799                 }
 800 #endif
 801
 802                 /* No beeper found, ok complain. */
 803 #endif
 804                 printk("pcikbd_init_hw: no 8042 found\n");
 805                 return;
 806
 807 found:
 808                 pcikbd_iobase = child->resource[0].start;
 809                 pcikbd_irq = child->irqs[0];
 810                 if (request_irq(pcikbd_irq, &pcikbd_interrupt,
 811                                 SA_SHIRQ, "keyboard", (void *)pcikbd_iobase)) {
 812                         printk("8042: cannot register IRQ %s\n",
 813                                __irq_itoa(pcikbd_irq));
 814                         return;
 815                 }
 816
 817                 printk("8042(kbd) at 0x%lx (irq %s)\n", pcikbd_iobase,
 818                        __irq_itoa(pcikbd_irq));
 819         }
 820
 821         kd_mksound = nop_kd_mksound;
 822         kbd_rate = pcikbd_rate;
 823
 824 #ifdef __sparc_v9__
 825         edev = 0;
 826         for_each_ebus(ebus) {
 827                 for_each_ebusdev(edev, ebus) {
 828                         if(!strcmp(edev->prom_name, "beeper"))
 829                                 goto ebus_done;
 830                 }
 831         }
 832 ebus_done:
 833
 834         /*
 835          * XXX: my 3.1.3 PROM does not give me the beeper node for the audio
 836          *      auxio register, though I know it is there... (ecd)
 837          *
 838          * JavaStations appear not to have beeper. --zaitcev
 839          */
 840         if (!edev)
 841                 pcibeep_iobase = (pcikbd_iobase & ~(0xffffff)) | 0x722000;
 842         else
 843                 pcibeep_iobase = edev->resource[0].start;
 844
 845         kd_mksound = pcikbd_kd_mksound;
 846         printk("8042(speaker): iobase[%016lx]%s\n", pcibeep_iobase,
 847                edev ? "" : " (forced)");
 848
 849         prom_keyboard = pcikbd_enter_prom;
 850 #endif
 851
 852         disable_irq(pcikbd_irq);
 853         msg = do_pcikbd_init_hw();
 854         enable_irq(pcikbd_irq);
 855
 856         if(msg)
 857                 printk("8042: keyboard init failure [%s]\n", msg);
 858 }
 859
 860
 861 /*
 862  * Here begins the Mouse Driver.
 863  */
 864
 865 static unsigned long pcimouse_iobase = 0;
 866 static unsigned int pcimouse_irq;
 867
 868 #define AUX_BUF_SIZE    2048
 869
 870 struct aux_queue {
 871         unsigned long head;
 872         unsigned long tail;
 873         wait_queue_head_t proc_list;
 874         struct fasync_struct *fasync;
 875         unsigned char buf[AUX_BUF_SIZE];
 876 };
 877
 878 static struct aux_queue *queue;
 879 static int aux_count = 0;
 880 static int aux_present = 0;
 881
 882 #define pcimouse_inb(x)     inb(x)
 883 #define pcimouse_outb(v,x)  outb(v,x)
 884
 885 /*
 886  *      Shared subroutines
 887  */
 888
 889 static unsigned int get_from_queue(void)
 890 {
 891         unsigned int result;
 892         unsigned long flags;
 893
 894         spin_lock_irqsave(&pcikbd_lock, flags);
 895         result = queue->buf[queue->tail];
 896         queue->tail = (queue->tail + 1) & (AUX_BUF_SIZE-1);
 897         spin_unlock_irqrestore(&pcikbd_lock, flags);
 898
 899         return result;
 900 }
 901
 902
 903 static inline int queue_empty(void)
 904 {
 905         return queue->head == queue->tail;
 906 }
 907
 908 static int aux_fasync(int fd, struct file *filp, int on)
 909 {
 910         int retval;
 911
 912         retval = fasync_helper(fd, filp, on, &queue->fasync);
 913         if (retval < 0)
 914                 return retval;
 915         return 0;
 916 }
 917
 918 /*
 919  *      PS/2 Aux Device
 920  */
 921
 922 #define AUX_INTS_OFF    (KBD_MODE_KCC | KBD_MODE_DISABLE_MOUSE | \
 923                          KBD_MODE_SYS | KBD_MODE_KBD_INT)
 924
 925 #define AUX_INTS_ON     (KBD_MODE_KCC | KBD_MODE_SYS | \
 926                          KBD_MODE_MOUSE_INT | KBD_MODE_KBD_INT)
 927
 928 #define MAX_RETRIES     60              /* some aux operations take long time*/
 929
 930 /*
 931  *      Status polling
 932  */
 933
 934 static int poll_aux_status(void)
 935 {
 936         int retries = 0;
 937
 938         while ((pcimouse_inb(pcimouse_iobase + KBD_STATUS_REG) &
 939                 (KBD_STAT_IBF | KBD_STAT_OBF)) && retries < MAX_RETRIES) {
 940                 if ((pcimouse_inb(pcimouse_iobase + KBD_STATUS_REG) & AUX_STAT_OBF)
 941                     == AUX_STAT_OBF)
 942                         pcimouse_inb(pcimouse_iobase + KBD_DATA_REG);
 943                 mdelay(5);
 944                 retries++;
 945         }
 946
 947         return (retries < MAX_RETRIES);
 948 }
 949
 950 /*
 951  * Write to aux device
 952  */
 953
 954 static void aux_write_dev(int val)
 955 {
 956         poll_aux_status();
 957         pcimouse_outb(KBD_CCMD_WRITE_MOUSE, pcimouse_iobase + KBD_CNTL_REG);/* Write magic cookie */
 958         poll_aux_status();
 959         pcimouse_outb(val, pcimouse_iobase + KBD_DATA_REG);              /* Write data */
 960         udelay(1);
 961 }
 962
 963 /*
 964  * Write to device & handle returned ack
 965  */
 966
 967 static int __init aux_write_ack(int val)
 968 {
 969         aux_write_dev(val);
 970         poll_aux_status();
 971
 972         if ((pcimouse_inb(pcimouse_iobase + KBD_STATUS_REG) & AUX_STAT_OBF) == AUX_STAT_OBF)
 973                 return (pcimouse_inb(pcimouse_iobase + KBD_DATA_REG));
 974         return 0;
 975 }
 976
 977 /*
 978  * Write aux device command
 979  */
 980
 981 static void aux_write_cmd(int val)
 982 {
 983         poll_aux_status();
 984         pcimouse_outb(KBD_CCMD_WRITE_MODE, pcimouse_iobase + KBD_CNTL_REG);
 985         poll_aux_status();
 986         pcimouse_outb(val, pcimouse_iobase + KBD_DATA_REG);
 987 }
 988
 989 /*
 990  * Interrupt from the auxiliary device: a character
 991  * is waiting in the keyboard/aux controller.
 992  */
 993
 994 void pcimouse_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 995 {
 996         unsigned long flags;
 997         int head, maxhead;
 998         unsigned char val;
 999
1000         spin_lock_irqsave(&pcikbd_lock, flags);
1001
1002         head = queue->head;
1003         maxhead = (queue->tail - 1) & (AUX_BUF_SIZE - 1);
1004
1005         if ((pcimouse_inb(pcimouse_iobase + KBD_STATUS_REG) & AUX_STAT_OBF) !=
1006             AUX_STAT_OBF) {
1007                 spin_unlock_irqrestore(&pcikbd_lock, flags);
1008                 return;
1009         }
1010
1011         val = pcimouse_inb(pcimouse_iobase + KBD_DATA_REG);
1012         queue->buf[head] = val;
1013         add_mouse_randomness(val);
1014         if (head != maxhead) {
1015                 head++;
1016                 head &= AUX_BUF_SIZE - 1;
1017         }
1018         queue->head = head;
1019
1020         spin_unlock_irqrestore(&pcikbd_lock, flags);
1021
1022         kill_fasync(&queue->fasync, SIGIO, POLL_IN);
1023         wake_up_interruptible(&queue->proc_list);
1024 }
1025
1026 static int aux_release(struct inode * inode, struct file * file)
1027 {
1028         unsigned long flags;
1029
1030         aux_fasync(-1, file, 0);
1031
1032         spin_lock_irqsave(&pcikbd_lock, flags);
1033
1034         if (--aux_count)
1035                 goto out;
1036
1037         /* Disable controller ints */
1038         aux_write_cmd(AUX_INTS_OFF);
1039         poll_aux_status();
1040
1041         /* Disable Aux device */
1042         pcimouse_outb(KBD_CCMD_MOUSE_DISABLE, pcimouse_iobase + KBD_CNTL_REG);
1043         poll_aux_status();
1044
1045 out:
1046         spin_unlock_irqrestore(&pcikbd_lock, flags);
1047
1048         return 0;
1049 }
1050
1051 /*
1052  * Install interrupt handler.
1053  * Enable auxiliary device.
1054  */
1055
1056 static int aux_open(struct inode * inode, struct file * file)
1057 {
1058         unsigned long flags;
1059
1060         if (!aux_present)
1061                 return -ENODEV;
1062
1063         spin_lock_irqsave(&pcikbd_lock, flags);
1064
1065         if (aux_count++) {
1066                 spin_unlock_irqrestore(&pcikbd_lock, flags);
1067                 return 0;
1068         }
1069
1070         if (!poll_aux_status()) {
1071                 aux_count--;
1072                 spin_unlock_irqrestore(&pcikbd_lock, flags);
1073                 return -EBUSY;
1074         }
1075         queue->head = queue->tail = 0;          /* Flush input queue */
1076
1077         poll_aux_status();
1078         pcimouse_outb(KBD_CCMD_MOUSE_ENABLE, pcimouse_iobase+KBD_CNTL_REG);    /* Enable Aux */
1079         aux_write_dev(AUX_ENABLE_DEV);                      /* Enable aux device */
1080         aux_write_cmd(AUX_INTS_ON);                         /* Enable controller ints */
1081         poll_aux_status();
1082
1083         spin_unlock_irqrestore(&pcikbd_lock, flags);
1084
1085
1086         return 0;
1087 }
1088
1089 /*
1090  * Write to the aux device.
1091  */
1092
1093 static ssize_t aux_write(struct file * file, const char * buffer,
1094                          size_t count, loff_t *ppos)
1095 {
1096         ssize_t retval = 0;
1097         unsigned long flags;
1098
1099         if (count) {
1100                 ssize_t written = 0;
1101
1102                 spin_lock_irqsave(&pcikbd_lock, flags);
1103
1104                 do {
1105                         char c;
1106
1107                         spin_unlock_irqrestore(&pcikbd_lock, flags);
1108
1109                         get_user(c, buffer++);
1110
1111                         spin_lock_irqsave(&pcikbd_lock, flags);
1112
1113                         if (!poll_aux_status())
1114                                 break;
1115                         pcimouse_outb(KBD_CCMD_WRITE_MOUSE,
1116                                       pcimouse_iobase + KBD_CNTL_REG);
1117                         if (!poll_aux_status())
1118                                 break;
1119
1120                         pcimouse_outb(c, pcimouse_iobase + KBD_DATA_REG);
1121                         written++;
1122                 } while (--count);
1123
1124                 spin_unlock_irqrestore(&pcikbd_lock, flags);
1125
1126                 retval = -EIO;
1127                 if (written) {
1128                         retval = written;
1129                         file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
1130                 }
1131         }
1132
1133         return retval;
1134 }
1135
1136 /*
1137  *      Generic part continues...
1138  */
1139
1140 /*
1141  * Put bytes from input queue to buffer.
1142  */
1143
1144 static ssize_t aux_read(struct file * file, char * buffer,
1145                         size_t count, loff_t *ppos)
1146 {
1147         DECLARE_WAITQUEUE(wait, current);
1148         ssize_t i = count;
1149         unsigned char c;
1150
1151         if (queue_empty()) {
1152                 if (file->f_flags & O_NONBLOCK)
1153                         return -EAGAIN;
1154                 add_wait_queue(&queue->proc_list, &wait);
1155 repeat:
1156                 set_current_state(TASK_INTERRUPTIBLE);
1157                 if (queue_empty() && !signal_pending(current)) {
1158                         schedule();
1159                         goto repeat;
1160                 }
1161                 current->state = TASK_RUNNING;
1162                 remove_wait_queue(&queue->proc_list, &wait);
1163         }
1164         while (i > 0 && !queue_empty()) {
1165                 c = get_from_queue();
1166                 put_user(c, buffer++);
1167                 i--;
1168         }
1169         if (count-i) {
1170                 file->f_dentry->d_inode->i_atime = CURRENT_TIME;
1171                 return count-i;
1172         }
1173         if (signal_pending(current))
1174                 return -ERESTARTSYS;
1175         return 0;
1176 }
1177
1178 static unsigned int aux_poll(struct file *file, poll_table * wait)
1179 {
1180         poll_wait(file, &queue->proc_list, wait);
1181         if (!queue_empty())
1182                 return POLLIN | POLLRDNORM;
1183         return 0;
1184 }
1185
1186 struct file_operations psaux_fops = {
1187         owner:          THIS_MODULE,
1188         read:           aux_read,
1189         write:          aux_write,
1190         poll:           aux_poll,
1191         open:           aux_open,
1192         release:        aux_release,
1193         fasync:         aux_fasync,
1194 };
1195
1196 static int aux_no_open(struct inode *inode, struct file *file)
1197 {
1198         return -ENODEV;
1199 }
1200
1201 struct file_operations psaux_no_fops = {
1202         owner:          THIS_MODULE,
1203         open:           aux_no_open,
1204 };
1205
1206 static struct miscdevice psaux_mouse = {
1207         PSMOUSE_MINOR, "ps2aux", &psaux_fops
1208 };
1209
1210 static struct miscdevice psaux_no_mouse = {
1211         PSMOUSE_MINOR, "ps2aux", &psaux_no_fops
1212 };
1213
1214 int __init pcimouse_init(void)
1215 {
1216         struct linux_ebus *ebus;
1217         struct linux_ebus_device *edev;
1218         struct linux_ebus_child *child;
1219
1220         if (pcikbd_mrcoffee) {
1221                 if ((pcimouse_iobase = pcikbd_iobase) == 0) {
1222                         printk("pcimouse_init: no 8042 given\n");
1223                         goto do_enodev;
1224                 }
1225                 pcimouse_irq = pcikbd_irq;
1226         } else {
1227                 for_each_ebus(ebus) {
1228                         for_each_ebusdev(edev, ebus) {
1229                                 if(!strcmp(edev->prom_name, "8042")) {
1230                                         for_each_edevchild(edev, child) {
1231                                                         if (strcmp(child->prom_name, PCI_MS_NAME1) == 0 ||
1232                                                             strcmp(child->prom_name, PCI_MS_NAME2) == 0)
1233                                                         goto found;
1234                                         }
1235                                 }
1236                         }
1237                 }
1238                 printk("pcimouse_init: no 8042 found\n");
1239                 goto do_enodev;
1240
1241 found:
1242                 pcimouse_iobase = child->resource[0].start;
1243                 pcimouse_irq = child->irqs[0];
1244         }
1245
1246         queue = (struct aux_queue *) kmalloc(sizeof(*queue), GFP_KERNEL);
1247         if (!queue) {
1248                 printk("pcimouse_init: kmalloc(aux_queue) failed.\n");
1249                 return -ENOMEM;
1250         }
1251         memset(queue, 0, sizeof(*queue));
1252
1253         init_waitqueue_head(&queue->proc_list);
1254
1255         if (request_irq(pcimouse_irq, &pcimouse_interrupt,
1256                         SA_SHIRQ, "mouse", (void *)pcimouse_iobase)) {
1257                 printk("8042: Cannot register IRQ %s\n",
1258                        __irq_itoa(pcimouse_irq));
1259                 goto do_enodev;
1260         }
1261
1262         printk("8042(mouse) at %lx (irq %s)\n", pcimouse_iobase,
1263                __irq_itoa(pcimouse_irq));
1264
1265         printk("8042: PS/2 auxiliary pointing device detected.\n");
1266         aux_present = 1;
1267         pckbd_read_mask = AUX_STAT_OBF;
1268
1269         misc_register(&psaux_mouse);
1270
1271         spin_lock_irq(&pcikbd_lock);
1272
1273         pcimouse_outb(KBD_CCMD_MOUSE_ENABLE, pcimouse_iobase + KBD_CNTL_REG);
1274         aux_write_ack(AUX_RESET);
1275         aux_write_ack(AUX_SET_SAMPLE);
1276         aux_write_ack(100);
1277         aux_write_ack(AUX_SET_RES);
1278         aux_write_ack(3);
1279         aux_write_ack(AUX_SET_SCALE21);
1280         poll_aux_status();
1281         pcimouse_outb(KBD_CCMD_MOUSE_DISABLE, pcimouse_iobase + KBD_CNTL_REG);
1282         poll_aux_status();
1283         pcimouse_outb(KBD_CCMD_WRITE_MODE, pcimouse_iobase + KBD_CNTL_REG);
1284         poll_aux_status();
1285         pcimouse_outb(AUX_INTS_OFF, pcimouse_iobase + KBD_DATA_REG);
1286         poll_aux_status();
1287
1288         spin_unlock_irq(&pcikbd_lock);
1289
1290         return 0;
1291
1292 do_enodev:
1293         misc_register(&psaux_no_mouse);
1294         return -ENODEV;
1295 }
1296
1297 int __init pcimouse_no_init(void)
1298 {
1299         misc_register(&psaux_no_mouse);
1300         return -ENODEV;
1301 }
1302
1303 int __init ps2kbd_probe(void)
1304 {
1305         int pnode, enode, node, dnode, xnode;
1306         int kbnode = 0, msnode = 0, bnode = 0;
1307         int devices = 0;
1308         char prop[128];
1309         int len;
1310
1311 #ifndef __sparc_v9__
1312         /*
1313          * MrCoffee has hardware but has no PROM nodes whatsoever.
1314          */
1315         len = prom_getproperty(prom_root_node, "name", prop, sizeof(prop));
1316         if (len < 0) {
1317                 printk("ps2kbd_probe: no name of root node\n");
1318                 goto do_enodev;
1319         }
1320         if (strncmp(prop, "SUNW,JavaStation-1", len) == 0) {
1321                 pcikbd_mrcoffee = 1;    /* Brain damage detected */
1322                 goto found;
1323         }
1324 #endif
1325         /*
1326          * Get the nodes for keyboard and mouse from aliases on normal systems.
1327          */
1328         node = prom_getchild(prom_root_node);
1329         node = prom_searchsiblings(node, "aliases");
1330         if (!node)
1331                 goto do_enodev;
1332
1333         len = prom_getproperty(node, "keyboard", prop, sizeof(prop));
1334         if (len > 0) {
1335                 prop[len] = 0;
1336                 kbnode = prom_finddevice(prop);
1337         }
1338         if (!kbnode)
1339                 goto do_enodev;
1340
1341         len = prom_getproperty(node, "mouse", prop, sizeof(prop));
1342         if (len > 0) {
1343                 prop[len] = 0;
1344                 msnode = prom_finddevice(prop);
1345         }
1346         if (!msnode)
1347                 goto do_enodev;
1348
1349         /*
1350          * Find matching EBus nodes...
1351          */
1352         node = prom_getchild(prom_root_node);
1353         pnode = prom_searchsiblings(node, "pci");
1354
1355         /*
1356          * Check for SUNW,sabre on Ultra5/10/AXi.
1357          */
1358         len = prom_getproperty(pnode, "model", prop, sizeof(prop));
1359         if ((len > 0) && !strncmp(prop, "SUNW,sabre", len)) {
1360                 pnode = prom_getchild(pnode);
1361                 pnode = prom_searchsiblings(pnode, "pci");
1362         }
1363
1364         /*
1365          * For each PCI bus...
1366          */
1367         while (pnode) {
1368                 enode = prom_getchild(pnode);
1369                 enode = prom_searchsiblings(enode, "ebus");
1370
1371                 /*
1372                  * For each EBus on this PCI...
1373                  */
1374                 while (enode) {
1375                         node = prom_getchild(enode);
1376                         bnode = prom_searchsiblings(node, "beeper");
1377
1378                         node = prom_getchild(enode);
1379                         node = prom_searchsiblings(node, "8042");
1380
1381                         /*
1382                          * For each '8042' on this EBus...
1383                          */
1384                         while (node) {
1385                                 dnode = prom_getchild(node);
1386
1387                                 /*
1388                                  * Does it match?
1389                                  */
1390                                 if ((xnode = prom_searchsiblings(dnode, PCI_KB_NAME1)) == kbnode) {
1391                                         ++devices;
1392                                 } else if ((xnode = prom_searchsiblings(dnode, PCI_KB_NAME2)) == kbnode) {
1393                                         ++devices;
1394                                 }
1395
1396                                 if ((xnode = prom_searchsiblings(dnode, PCI_MS_NAME1)) == msnode) {
1397                                         ++devices;
1398                                 } else if ((xnode = prom_searchsiblings(dnode, PCI_MS_NAME2)) == msnode) {
1399                                         ++devices;
1400                                 }
1401
1402                                 /*
1403                                  * Found everything we need?
1404                                  */
1405                                 if (devices == 2)
1406                                         goto found;
1407
1408                                 node = prom_getsibling(node);
1409                                 node = prom_searchsiblings(node, "8042");
1410                         }
1411                         enode = prom_getsibling(enode);
1412                         enode = prom_searchsiblings(enode, "ebus");
1413                 }
1414                 pnode = prom_getsibling(pnode);
1415                 pnode = prom_searchsiblings(pnode, "pci");
1416         }
1417 do_enodev:
1418         sunkbd_setinitfunc(pcimouse_no_init);
1419         return -ENODEV;
1420
1421 found:
1422         sunkbd_setinitfunc(pcimouse_init);
1423         sunkbd_setinitfunc(pcikbd_init);
1424         kbd_ops.compute_shiftstate = pci_compute_shiftstate;
1425         kbd_ops.setledstate = pci_setledstate;
1426         kbd_ops.getledstate = pci_getledstate;
1427         kbd_ops.setkeycode = pci_setkeycode;
1428         kbd_ops.getkeycode = pci_getkeycode;
1429         return 0;
1430 }