/*
* linux/drivers/char/pc_keyb.c
*
* Separation of the PC low-level part by Geert Uytterhoeven, May 1997
* See keyboard.c for the whole history.
*
* Major cleanup by Martin Mares, May 1997
*
* Combined the keyboard and PS/2 mouse handling into one file,
* because they share the same hardware.
* Johan Myreen <jem@iki.fi> 1998-10-08.
*
* Code fixes to handle mouse ACKs properly.
* C. Scott Ananian <cananian@alumni.princeton.edu> 1999-01-29.
*
*/
#include <linux/config.h>
#include <linux/spinlock.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/tty.h>
#include <linux/mm.h>
#include <linux/signal.h>
#include <linux/init.h>
#include <linux/kbd_ll.h>
#include <linux/delay.h>
#include <linux/random.h>
#include <linux/poll.h>
#include <linux/miscdevice.h>
#include <linux/malloc.h>
#include <linux/kbd_kern.h>
#include <linux/smp_lock.h>
#include <asm/keyboard.h>
#include <asm/bitops.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/system.h>
#include <asm/io.h>
/* Some configuration switches are present in the include file... */
#include <linux/pc_keyb.h>
/* Simple translation table for the SysRq keys */
#ifdef CONFIG_MAGIC_SYSRQ
unsigned char pckbd_sysrq_xlate[128] =
"\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
"qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
"dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
"bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
"\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
"230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
"\r\000/"; /* 0x60 - 0x6f */
#endif
static void kbd_write_command_w(int data);
static void kbd_write_output_w(int data);
#ifdef CONFIG_PSMOUSE
static void aux_write_ack(int val);
static void __aux_write_ack(int val);
#endif
static spinlock_t kbd_controller_lock = SPIN_LOCK_UNLOCKED;
static unsigned char handle_kbd_event(void);
/* used only by send_data - set by keyboard_interrupt */
static volatile unsigned char reply_expected;
static volatile unsigned char acknowledge;
static volatile unsigned char resend;
#if defined CONFIG_PSMOUSE
/*
* PS/2 Auxiliary Device
*/
static int __init psaux_init(void);
#define AUX_RECONNECT 170 /* scancode when ps2 device is plugged (back) in */
static struct aux_queue *queue; /* Mouse data buffer. */
static int aux_count;
/* used when we send commands to the mouse that expect an ACK. */
static unsigned char mouse_reply_expected;
#define AUX_INTS_OFF (KBD_MODE_KCC | KBD_MODE_DISABLE_MOUSE | KBD_MODE_SYS | KBD_MODE_KBD_INT)
#define AUX_INTS_ON (KBD_MODE_KCC | KBD_MODE_SYS | KBD_MODE_MOUSE_INT | KBD_MODE_KBD_INT)
#define MAX_RETRIES 60 /* some aux operations take long time*/
#endif /* CONFIG_PSMOUSE */
/*
* Wait for keyboard controller input buffer to drain.
*
* Don't use 'jiffies' so that we don't depend on
* interrupts..
*
* Quote from PS/2 System Reference Manual:
*
* "Address hex 0060 and address hex 0064 should be written only when
* the input-buffer-full bit and output-buffer-full bit in the
* Controller Status register are set 0."
*/
110 static void kb_wait(void)
{
unsigned long timeout = KBC_TIMEOUT;
114 do {
/*
* "handle_kbd_event()" will handle any incoming events
* while we wait - keypresses or mouse movement.
*/
unsigned char status = handle_kbd_event();
121 if (! (status & KBD_STAT_IBF))
122 return;
mdelay(1);
timeout--;
125 } while (timeout);
#ifdef KBD_REPORT_TIMEOUTS
printk(KERN_WARNING "Keyboard timed out[1]\n");
#endif
}
/*
* Translation of escaped scancodes to keycodes.
* This is now user-settable.
* The keycodes 1-88,96-111,119 are fairly standard, and
* should probably not be changed - changing might confuse X.
* X also interprets scancode 0x5d (KEY_Begin).
*
* For 1-88 keycode equals scancode.
*/
#define E0_KPENTER 96
#define E0_RCTRL 97
#define E0_KPSLASH 98
#define E0_PRSCR 99
#define E0_RALT 100
#define E0_BREAK 101 /* (control-pause) */
#define E0_HOME 102
#define E0_UP 103
#define E0_PGUP 104
#define E0_LEFT 105
#define E0_RIGHT 106
#define E0_END 107
#define E0_DOWN 108
#define E0_PGDN 109
#define E0_INS 110
#define E0_DEL 111
#define E1_PAUSE 119
/*
* The keycodes below are randomly located in 89-95,112-118,120-127.
* They could be thrown away (and all occurrences below replaced by 0),
* but that would force many users to use the `setkeycodes' utility, where
* they needed not before. It does not matter that there are duplicates, as
* long as no duplication occurs for any single keyboard.
*/
#define SC_LIM 89
#define FOCUS_PF1 85 /* actual code! */
#define FOCUS_PF2 89
#define FOCUS_PF3 90
#define FOCUS_PF4 91
#define FOCUS_PF5 92
#define FOCUS_PF6 93
#define FOCUS_PF7 94
#define FOCUS_PF8 95
#define FOCUS_PF9 120
#define FOCUS_PF10 121
#define FOCUS_PF11 122
#define FOCUS_PF12 123
#define JAP_86 124
/* tfj@olivia.ping.dk:
* The four keys are located over the numeric keypad, and are
* labelled A1-A4. It's an rc930 keyboard, from
* Regnecentralen/RC International, Now ICL.
* Scancodes: 59, 5a, 5b, 5c.
*/
#define RGN1 124
#define RGN2 125
#define RGN3 126
#define RGN4 127
static unsigned char high_keys[128 - SC_LIM] = {
RGN1, RGN2, RGN3, RGN4, 0, 0, 0, /* 0x59-0x5f */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x60-0x67 */
0, 0, 0, 0, 0, FOCUS_PF11, 0, FOCUS_PF12, /* 0x68-0x6f */
0, 0, 0, FOCUS_PF2, FOCUS_PF9, 0, 0, FOCUS_PF3, /* 0x70-0x77 */
FOCUS_PF4, FOCUS_PF5, FOCUS_PF6, FOCUS_PF7, /* 0x78-0x7b */
FOCUS_PF8, JAP_86, FOCUS_PF10, 0 /* 0x7c-0x7f */
};
/* BTC */
#define E0_MACRO 112
/* LK450 */
#define E0_F13 113
#define E0_F14 114
#define E0_HELP 115
#define E0_DO 116
#define E0_F17 117
#define E0_KPMINPLUS 118
/*
* My OmniKey generates e0 4c for the "OMNI" key and the
* right alt key does nada. [kkoller@nyx10.cs.du.edu]
*/
#define E0_OK 124
/*
* New microsoft keyboard is rumoured to have
* e0 5b (left window button), e0 5c (right window button),
* e0 5d (menu button). [or: LBANNER, RBANNER, RMENU]
* [or: Windows_L, Windows_R, TaskMan]
*/
#define E0_MSLW 125
#define E0_MSRW 126
#define E0_MSTM 127
static unsigned char e0_keys[128] = {
0, 0, 0, 0, 0, 0, 0, 0, /* 0x00-0x07 */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x08-0x0f */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x10-0x17 */
0, 0, 0, 0, E0_KPENTER, E0_RCTRL, 0, 0, /* 0x18-0x1f */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x20-0x27 */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x28-0x2f */
0, 0, 0, 0, 0, E0_KPSLASH, 0, E0_PRSCR, /* 0x30-0x37 */
E0_RALT, 0, 0, 0, 0, E0_F13, E0_F14, E0_HELP, /* 0x38-0x3f */
E0_DO, E0_F17, 0, 0, 0, 0, E0_BREAK, E0_HOME, /* 0x40-0x47 */
E0_UP, E0_PGUP, 0, E0_LEFT, E0_OK, E0_RIGHT, E0_KPMINPLUS, E0_END,/* 0x48-0x4f */
E0_DOWN, E0_PGDN, E0_INS, E0_DEL, 0, 0, 0, 0, /* 0x50-0x57 */
0, 0, 0, E0_MSLW, E0_MSRW, E0_MSTM, 0, 0, /* 0x58-0x5f */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x60-0x67 */
0, 0, 0, 0, 0, 0, 0, E0_MACRO, /* 0x68-0x6f */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x70-0x77 */
0, 0, 0, 0, 0, 0, 0, 0 /* 0x78-0x7f */
};
246 int pckbd_setkeycode(unsigned int scancode, unsigned int keycode)
{
248 if (scancode < SC_LIM || scancode > 255 || keycode > 127)
249 return -EINVAL;
250 if (scancode < 128)
high_keys[scancode - SC_LIM] = keycode;
252 else
e0_keys[scancode - 128] = keycode;
254 return 0;
}
257 int pckbd_getkeycode(unsigned int scancode)
{
return
(scancode < SC_LIM || scancode > 255) ? -EINVAL :
(scancode < 128) ? high_keys[scancode - SC_LIM] :
262 e0_keys[scancode - 128];
}
265 static int do_acknowledge(unsigned char scancode)
{
267 if (reply_expected) {
/* Unfortunately, we must recognise these codes only if we know they
* are known to be valid (i.e., after sending a command), because there
* are some brain-damaged keyboards (yes, FOCUS 9000 again) which have
* keys with such codes :(
*/
273 if (scancode == KBD_REPLY_ACK) {
acknowledge = 1;
reply_expected = 0;
276 return 0;
277 } else if (scancode == KBD_REPLY_RESEND) {
resend = 1;
reply_expected = 0;
280 return 0;
}
/* Should not happen... */
#if 0
printk(KERN_DEBUG "keyboard reply expected - got %02x\n",
scancode);
#endif
}
288 return 1;
}
291 int pckbd_translate(unsigned char scancode, unsigned char *keycode,
char raw_mode)
{
static int prev_scancode;
/* special prefix scancodes.. */
297 if (scancode == 0xe0 || scancode == 0xe1) {
prev_scancode = scancode;
299 return 0;
}
/* 0xFF is sent by a few keyboards, ignore it. 0x00 is error */
303 if (scancode == 0x00 || scancode == 0xff) {
prev_scancode = 0;
305 return 0;
}
scancode &= 0x7f;
310 if (prev_scancode) {
/*
* usually it will be 0xe0, but a Pause key generates
* e1 1d 45 e1 9d c5 when pressed, and nothing when released
*/
315 if (prev_scancode != 0xe0) {
316 if (prev_scancode == 0xe1 && scancode == 0x1d) {
prev_scancode = 0x100;
318 return 0;
319 } else if (prev_scancode == 0x100 && scancode == 0x45) {
*keycode = E1_PAUSE;
prev_scancode = 0;
322 } else {
#ifdef KBD_REPORT_UNKN
324 if (!raw_mode)
printk(KERN_INFO "keyboard: unknown e1 escape sequence\n");
#endif
prev_scancode = 0;
328 return 0;
}
330 } else {
prev_scancode = 0;
/*
* The keyboard maintains its own internal caps lock and
* num lock statuses. In caps lock mode E0 AA precedes make
* code and E0 2A follows break code. In num lock mode,
* E0 2A precedes make code and E0 AA follows break code.
* We do our own book-keeping, so we will just ignore these.
*/
/*
* For my keyboard there is no caps lock mode, but there are
* both Shift-L and Shift-R modes. The former mode generates
* E0 2A / E0 AA pairs, the latter E0 B6 / E0 36 pairs.
* So, we should also ignore the latter. - aeb@cwi.nl
*/
345 if (scancode == 0x2a || scancode == 0x36)
346 return 0;
348 if (e0_keys[scancode])
*keycode = e0_keys[scancode];
350 else {
#ifdef KBD_REPORT_UNKN
352 if (!raw_mode)
printk(KERN_INFO "keyboard: unknown scancode e0 %02x\n",
scancode);
#endif
356 return 0;
}
}
359 } else if (scancode >= SC_LIM) {
/* This happens with the FOCUS 9000 keyboard
Its keys PF1..PF12 are reported to generate
55 73 77 78 79 7a 7b 7c 74 7e 6d 6f
Moreover, unless repeated, they do not generate
key-down events, so we have to zero up_flag below */
/* Also, Japanese 86/106 keyboards are reported to
generate 0x73 and 0x7d for \ - and \ | respectively. */
/* Also, some Brazilian keyboard is reported to produce
0x73 and 0x7e for \ ? and KP-dot, respectively. */
*keycode = high_keys[scancode - SC_LIM];
372 if (!*keycode) {
373 if (!raw_mode) {
#ifdef KBD_REPORT_UNKN
printk(KERN_INFO "keyboard: unrecognized scancode (%02x)"
" - ignored\n", scancode);
#endif
}
379 return 0;
}
381 } else
*keycode = scancode;
383 return 1;
}
386 char pckbd_unexpected_up(unsigned char keycode)
{
/* unexpected, but this can happen: maybe this was a key release for a
FOCUS 9000 PF key; if we want to see it, we have to clear up_flag */
390 if (keycode >= SC_LIM || keycode == 85)
391 return 0;
392 else
393 return 0200;
}
396 static inline void handle_mouse_event(unsigned char scancode)
{
#ifdef CONFIG_PSMOUSE
399 if (mouse_reply_expected) {
400 if (scancode == AUX_ACK) {
mouse_reply_expected--;
402 return;
}
mouse_reply_expected = 0;
}
406 else if(scancode == AUX_RECONNECT){
queue->head = queue->tail = 0; /* Flush input queue */
__aux_write_ack(AUX_ENABLE_DEV); /* ping the mouse :) */
409 return;
}
add_mouse_randomness(scancode);
413 if (aux_count) {
int head = queue->head;
queue->buf[head] = scancode;
head = (head + 1) & (AUX_BUF_SIZE-1);
418 if (head != queue->tail) {
queue->head = head;
kill_fasync(&queue->fasync, SIGIO, POLL_IN);
wake_up_interruptible(&queue->proc_list);
}
}
#endif
}
static unsigned char kbd_exists = 1;
429 static inline void handle_keyboard_event(unsigned char scancode)
{
#ifdef CONFIG_VT
kbd_exists = 1;
433 if (do_acknowledge(scancode))
handle_scancode(scancode, !(scancode & 0x80));
#endif
tasklet_schedule(&keyboard_tasklet);
}
/*
* This reads the keyboard status port, and does the
* appropriate action.
*
* It requires that we hold the keyboard controller
* spinlock.
*/
446 static unsigned char handle_kbd_event(void)
{
unsigned char status = kbd_read_status();
unsigned int work = 10000;
451 while ((--work > 0) && (status & KBD_STAT_OBF)) {
unsigned char scancode;
scancode = kbd_read_input();
/* Error bytes must be ignored to make the
Synaptics touchpads compaq use work */
#if 1
/* Ignore error bytes */
460 if (!(status & (KBD_STAT_GTO | KBD_STAT_PERR)))
#endif
{
463 if (status & KBD_STAT_MOUSE_OBF)
handle_mouse_event(scancode);
465 else
handle_keyboard_event(scancode);
}
status = kbd_read_status();
}
472 if (!work)
printk(KERN_ERR "pc_keyb: controller jammed (0x%02X).\n", status);
475 return status;
}
479 static void keyboard_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
#ifdef CONFIG_VT
kbd_pt_regs = regs;
#endif
485 spin_lock_irq(&kbd_controller_lock);
handle_kbd_event();
487 spin_unlock_irq(&kbd_controller_lock);
}
/*
* send_data sends a character to the keyboard and waits
* for an acknowledge, possibly retrying if asked to. Returns
* the success status.
*
* Don't use 'jiffies', so that we don't depend on interrupts
*/
497 static int send_data(unsigned char data)
{
int retries = 3;
501 do {
unsigned long timeout = KBD_TIMEOUT;
acknowledge = 0; /* Set by interrupt routine on receipt of ACK. */
resend = 0;
reply_expected = 1;
kbd_write_output_w(data);
508 for (;;) {
509 if (acknowledge)
510 return 1;
511 if (resend)
512 break;
mdelay(1);
514 if (!--timeout) {
#ifdef KBD_REPORT_TIMEOUTS
printk(KERN_WARNING "keyboard: Timeout - AT keyboard not present?\n");
#endif
518 return 0;
}
}
521 } while (retries-- > 0);
#ifdef KBD_REPORT_TIMEOUTS
printk(KERN_WARNING "keyboard: Too many NACKs -- noisy kbd cable?\n");
#endif
525 return 0;
}
528 void pckbd_leds(unsigned char leds)
{
530 if (kbd_exists && (!send_data(KBD_CMD_SET_LEDS) || !send_data(leds))) {
send_data(KBD_CMD_ENABLE); /* re-enable kbd if any errors */
kbd_exists = 0;
}
}
/*
* In case we run on a non-x86 hardware we need to initialize both the
* keyboard controller and the keyboard. On a x86, the BIOS will
* already have initialized them.
*
* Some x86 BIOSes do not correctly initialize the keyboard, so the
* "kbd-reset" command line options can be given to force a reset.
* [Ranger]
*/
#ifdef __i386__
int kbd_startup_reset __initdata = 0;
#else
int kbd_startup_reset __initdata = 1;
#endif
/* for "kbd-reset" cmdline param */
552 static int __init kbd_reset_setup(char *str)
{
kbd_startup_reset = 1;
555 return 1;
}
__setup("kbd-reset", kbd_reset_setup);
#define KBD_NO_DATA (-1) /* No data */
#define KBD_BAD_DATA (-2) /* Parity or other error */
563 static int __init kbd_read_data(void)
{
int retval = KBD_NO_DATA;
unsigned char status;
status = kbd_read_status();
569 if (status & KBD_STAT_OBF) {
unsigned char data = kbd_read_input();
retval = data;
573 if (status & (KBD_STAT_GTO | KBD_STAT_PERR))
retval = KBD_BAD_DATA;
}
576 return retval;
}
579 static void __init kbd_clear_input(void)
{
int maxread = 100; /* Random number */
583 do {
584 if (kbd_read_data() == KBD_NO_DATA)
585 break;
586 } while (--maxread);
}
589 static int __init kbd_wait_for_input(void)
{
long timeout = KBD_INIT_TIMEOUT;
593 do {
int retval = kbd_read_data();
595 if (retval >= 0)
596 return retval;
mdelay(1);
598 } while (--timeout);
599 return -1;
}
602 static void kbd_write_command_w(int data)
{
unsigned long flags;
606 spin_lock_irqsave(&kbd_controller_lock, flags);
kb_wait();
kbd_write_command(data);
609 spin_unlock_irqrestore(&kbd_controller_lock, flags);
}
612 static void kbd_write_output_w(int data)
{
unsigned long flags;
616 spin_lock_irqsave(&kbd_controller_lock, flags);
kb_wait();
kbd_write_output(data);
619 spin_unlock_irqrestore(&kbd_controller_lock, flags);
}
#if defined CONFIG_PSMOUSE
623 static void kbd_write_cmd(int cmd)
{
unsigned long flags;
627 spin_lock_irqsave(&kbd_controller_lock, flags);
kb_wait();
kbd_write_command(KBD_CCMD_WRITE_MODE);
kb_wait();
kbd_write_output(cmd);
632 spin_unlock_irqrestore(&kbd_controller_lock, flags);
}
#endif /* CONFIG_PSMOUSE */
636 static char * __init initialize_kbd(void)
{
int status;
/*
* Test the keyboard interface.
* This seems to be the only way to get it going.
* If the test is successful a x55 is placed in the input buffer.
*/
kbd_write_command_w(KBD_CCMD_SELF_TEST);
646 if (kbd_wait_for_input() != 0x55)
647 return "Keyboard failed self test";
/*
* Perform a keyboard interface test. This causes the controller
* to test the keyboard clock and data lines. The results of the
* test are placed in the input buffer.
*/
kbd_write_command_w(KBD_CCMD_KBD_TEST);
655 if (kbd_wait_for_input() != 0x00)
656 return "Keyboard interface failed self test";
/*
* Enable the keyboard by allowing the keyboard clock to run.
*/
kbd_write_command_w(KBD_CCMD_KBD_ENABLE);
/*
* Reset keyboard. If the read times out
* then the assumption is that no keyboard is
* plugged into the machine.
* This defaults the keyboard to scan-code set 2.
*
* Set up to try again if the keyboard asks for RESEND.
*/
671 do {
kbd_write_output_w(KBD_CMD_RESET);
status = kbd_wait_for_input();
674 if (status == KBD_REPLY_ACK)
675 break;
676 if (status != KBD_REPLY_RESEND)
677 return "Keyboard reset failed, no ACK";
678 } while (1);
680 if (kbd_wait_for_input() != KBD_REPLY_POR)
681 return "Keyboard reset failed, no POR";
/*
* Set keyboard controller mode. During this, the keyboard should be
* in the disabled state.
*
* Set up to try again if the keyboard asks for RESEND.
*/
689 do {
kbd_write_output_w(KBD_CMD_DISABLE);
status = kbd_wait_for_input();
692 if (status == KBD_REPLY_ACK)
693 break;
694 if (status != KBD_REPLY_RESEND)
695 return "Disable keyboard: no ACK";
696 } while (1);
kbd_write_command_w(KBD_CCMD_WRITE_MODE);
kbd_write_output_w(KBD_MODE_KBD_INT
| KBD_MODE_SYS
| KBD_MODE_DISABLE_MOUSE
| KBD_MODE_KCC);
/* ibm powerpc portables need this to use scan-code set 1 -- Cort */
kbd_write_command_w(KBD_CCMD_READ_MODE);
706 if (!(kbd_wait_for_input() & KBD_MODE_KCC)) {
/*
* If the controller does not support conversion,
* Set the keyboard to scan-code set 1.
*/
kbd_write_output_w(0xF0);
kbd_wait_for_input();
kbd_write_output_w(0x01);
kbd_wait_for_input();
}
kbd_write_output_w(KBD_CMD_ENABLE);
719 if (kbd_wait_for_input() != KBD_REPLY_ACK)
720 return "Enable keyboard: no ACK";
/*
* Finally, set the typematic rate to maximum.
*/
kbd_write_output_w(KBD_CMD_SET_RATE);
726 if (kbd_wait_for_input() != KBD_REPLY_ACK)
727 return "Set rate: no ACK";
kbd_write_output_w(0x00);
729 if (kbd_wait_for_input() != KBD_REPLY_ACK)
730 return "Set rate: no ACK";
732 return NULL;
}
735 void __init pckbd_init_hw(void)
{
kbd_request_region();
/* Flush any pending input. */
kbd_clear_input();
742 if (kbd_startup_reset) {
char *msg = initialize_kbd();
744 if (msg)
printk(KERN_WARNING "initialize_kbd: %s\n", msg);
}
#if defined CONFIG_PSMOUSE
psaux_init();
#endif
/* Ok, finally allocate the IRQ, and off we go.. */
kbd_request_irq(keyboard_interrupt);
}
#if defined CONFIG_PSMOUSE
/*
* Check if this is a dual port controller.
*/
761 static int __init detect_auxiliary_port(void)
{
unsigned long flags;
int loops = 10;
int retval = 0;
/* Check if the BIOS detected a device on the auxiliary port. */
768 if (aux_device_present == 0xaa)
769 return 1;
771 spin_lock_irqsave(&kbd_controller_lock, flags);
/* Put the value 0x5A in the output buffer using the "Write
* Auxiliary Device Output Buffer" command (0xD3). Poll the
* Status Register for a while to see if the value really
* turns up in the Data Register. If the KBD_STAT_MOUSE_OBF
* bit is also set to 1 in the Status Register, we assume this
* controller has an Auxiliary Port (a.k.a. Mouse Port).
*/
kb_wait();
kbd_write_command(KBD_CCMD_WRITE_AUX_OBUF);
kb_wait();
kbd_write_output(0x5a); /* 0x5a is a random dummy value. */
786 do {
unsigned char status = kbd_read_status();
789 if (status & KBD_STAT_OBF) {
(void) kbd_read_input();
791 if (status & KBD_STAT_MOUSE_OBF) {
printk(KERN_INFO "Detected PS/2 Mouse Port.\n");
retval = 1;
}
795 break;
}
mdelay(1);
798 } while (--loops);
799 spin_unlock_irqrestore(&kbd_controller_lock, flags);
801 return retval;
}
/*
* Send a byte to the mouse.
*/
807 static void aux_write_dev(int val)
{
unsigned long flags;
811 spin_lock_irqsave(&kbd_controller_lock, flags);
kb_wait();
kbd_write_command(KBD_CCMD_WRITE_MOUSE);
kb_wait();
kbd_write_output(val);
816 spin_unlock_irqrestore(&kbd_controller_lock, flags);
}
/*
* Send a byte to the mouse & handle returned ack
*/
822 static void __aux_write_ack(int val)
{
kb_wait();
kbd_write_command(KBD_CCMD_WRITE_MOUSE);
kb_wait();
kbd_write_output(val);
/* we expect an ACK in response. */
mouse_reply_expected++;
kb_wait();
}
833 static void aux_write_ack(int val)
{
unsigned long flags;
837 spin_lock_irqsave(&kbd_controller_lock, flags);
__aux_write_ack(val);
839 spin_unlock_irqrestore(&kbd_controller_lock, flags);
}
842 static unsigned char get_from_queue(void)
{
unsigned char result;
unsigned long flags;
847 spin_lock_irqsave(&kbd_controller_lock, flags);
result = queue->buf[queue->tail];
queue->tail = (queue->tail + 1) & (AUX_BUF_SIZE-1);
850 spin_unlock_irqrestore(&kbd_controller_lock, flags);
851 return result;
}
855 static inline int queue_empty(void)
{
857 return queue->head == queue->tail;
}
860 static int fasync_aux(int fd, struct file *filp, int on)
{
int retval;
retval = fasync_helper(fd, filp, on, &queue->fasync);
865 if (retval < 0)
866 return retval;
867 return 0;
}
/*
* Random magic cookie for the aux device
*/
#define AUX_DEV ((void *)queue)
876 static int release_aux(struct inode * inode, struct file * file)
{
878 lock_kernel();
fasync_aux(-1, file, 0);
880 if (--aux_count) {
881 unlock_kernel();
882 return 0;
}
kbd_write_cmd(AUX_INTS_OFF); /* Disable controller ints */
kbd_write_command_w(KBD_CCMD_MOUSE_DISABLE);
aux_free_irq(AUX_DEV);
887 unlock_kernel();
888 return 0;
}
/*
* Install interrupt handler.
* Enable auxiliary device.
*/
896 static int open_aux(struct inode * inode, struct file * file)
{
898 if (aux_count++) {
899 return 0;
}
queue->head = queue->tail = 0; /* Flush input queue */
902 if (aux_request_irq(keyboard_interrupt, AUX_DEV)) {
aux_count--;
904 return -EBUSY;
}
kbd_write_command_w(KBD_CCMD_MOUSE_ENABLE); /* Enable the
auxiliary port on
controller. */
aux_write_ack(AUX_ENABLE_DEV); /* Enable aux device */
kbd_write_cmd(AUX_INTS_ON); /* Enable controller ints */
send_data(KBD_CMD_ENABLE); /* try to workaround toshiba4030cdt problem */
914 return 0;
}
/*
* Put bytes from input queue to buffer.
*/
921 static ssize_t read_aux(struct file * file, char * buffer,
size_t count, loff_t *ppos)
{
DECLARE_WAITQUEUE(wait, current);
ssize_t i = count;
unsigned char c;
928 if (queue_empty()) {
929 if (file->f_flags & O_NONBLOCK)
930 return -EAGAIN;
add_wait_queue(&queue->proc_list, &wait);
repeat:
933 set_current_state(TASK_INTERRUPTIBLE);
934 if (queue_empty() && !signal_pending(current)) {
schedule();
936 goto repeat;
}
current->state = TASK_RUNNING;
remove_wait_queue(&queue->proc_list, &wait);
}
941 while (i > 0 && !queue_empty()) {
c = get_from_queue();
put_user(c, buffer++);
i--;
}
946 if (count-i) {
file->f_dentry->d_inode->i_atime = CURRENT_TIME;
948 return count-i;
}
950 if (signal_pending(current))
951 return -ERESTARTSYS;
952 return 0;
}
/*
* Write to the aux device.
*/
959 static ssize_t write_aux(struct file * file, const char * buffer,
size_t count, loff_t *ppos)
{
ssize_t retval = 0;
964 if (count) {
ssize_t written = 0;
967 if (count > 32)
count = 32; /* Limit to 32 bytes. */
969 do {
char c;
get_user(c, buffer++);
aux_write_dev(c);
written++;
974 } while (--count);
retval = -EIO;
976 if (written) {
retval = written;
file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
}
}
982 return retval;
}
/* No kernel lock held - fine */
986 static unsigned int aux_poll(struct file *file, poll_table * wait)
{
poll_wait(file, &queue->proc_list, wait);
989 if (!queue_empty())
990 return POLLIN | POLLRDNORM;
991 return 0;
}
struct file_operations psaux_fops = {
read: read_aux,
write: write_aux,
poll: aux_poll,
open: open_aux,
release: release_aux,
fasync: fasync_aux,
};
/*
* Initialize driver.
*/
static struct miscdevice psaux_mouse = {
PSMOUSE_MINOR, "psaux", &psaux_fops
};
1010 static int __init psaux_init(void)
{
1012 if (!detect_auxiliary_port())
1013 return -EIO;
misc_register(&psaux_mouse);
queue = (struct aux_queue *) kmalloc(sizeof(*queue), GFP_KERNEL);
memset(queue, 0, sizeof(*queue));
queue->head = queue->tail = 0;
init_waitqueue_head(&queue->proc_list);
#ifdef INITIALIZE_MOUSE
kbd_write_command_w(KBD_CCMD_MOUSE_ENABLE); /* Enable Aux. */
aux_write_ack(AUX_SET_SAMPLE);
aux_write_ack(100); /* 100 samples/sec */
aux_write_ack(AUX_SET_RES);
aux_write_ack(3); /* 8 counts per mm */
aux_write_ack(AUX_SET_SCALE21); /* 2:1 scaling */
#endif /* INITIALIZE_MOUSE */
kbd_write_command(KBD_CCMD_MOUSE_DISABLE); /* Disable aux device. */
kbd_write_cmd(AUX_INTS_OFF); /* Disable controller ints. */
1032 return 0;
}
#endif /* CONFIG_PSMOUSE */