WebSVN – HelenOS – Diff – /trunk/kernel/genarch/src/kbd/i8042.c


/*
 * Copyright (C) 2001-2004 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup genarch
 * @{
 */
/**
 * @file
 * @brief   i8042 processor driver.
 *
 * It takes care of low-level keyboard functions.
 */
 
#include <genarch/kbd/i8042.h>
#include <genarch/kbd/scanc.h>
#include <genarch/kbd/scanc_pc.h>
#include <arch/drivers/i8042.h>
#include <arch/interrupt.h>
#include <cpu.h>
#include <arch/asm.h>
#include <arch.h>
#include <synch/spinlock.h>
#include <typedefs.h>
#include <console/chardev.h>
#include <console/console.h>
#include <macros.h>
#include <interrupt.h>
 
/* Keyboard commands. */
#define KBD_ENABLE  0xf4
#define KBD_DISABLE 0xf5
#define KBD_ACK     0xfa
 
/*
 * 60  Write 8042 Command Byte: next data byte written to port 60h is
 *     placed in 8042 command register. Format:
 *
 *    |7|6|5|4|3|2|1|0|8042 Command Byte
 *     | | | | | | | `---- 1=enable output register full interrupt
 *     | | | | | | `----- should be 0
 *     | | | | | `------ 1=set status register system, 0=clear
 *     | | | | `------- 1=override keyboard inhibit, 0=allow inhibit
 *     | | | `-------- disable keyboard I/O by driving clock line low
 *     | | `--------- disable auxiliary device, drives clock line low
 *     | `---------- IBM scancode translation 0=AT, 1=PC/XT
 *     `----------- reserved, should be 0
 */
 
#define i8042_SET_COMMAND   0x60
#define i8042_COMMAND       0x69
 
#define i8042_BUFFER_FULL_MASK  0x01
#define i8042_WAIT_MASK     0x02
#define i8042_MOUSE_DATA        0x20
 
#define KEY_RELEASE 0x80
 
 
 
 
 
 
static void key_released(uint8_t sc);
static void key_pressed(uint8_t sc);
static char key_read(chardev_t *d);
 
#define PRESSED_SHIFT       (1<<0)
#define PRESSED_CAPSLOCK    (1<<1)
#define LOCKED_CAPSLOCK     (1<<0)
 
#define ACTIVE_READ_BUFF_SIZE 16    /* Must be power of 2 */
 
static uint8_t active_read_buff[ACTIVE_READ_BUFF_SIZE];
 
SPINLOCK_INITIALIZE(keylock);       /**< keylock protects keyflags and lockflags. */
static volatile int keyflags;       /**< Tracking of multiple keypresses. */
static volatile int lockflags;      /**< Tracking of multiple keys lockings. */
 
static void i8042_suspend(chardev_t *);
static void i8042_resume(chardev_t *);
 
static chardev_t kbrd;
static chardev_operations_t ops = {
    .suspend = i8042_suspend,
    .resume = i8042_resume,
    .read = key_read
};
 
static void i8042_interrupt(int n, istate_t *istate);
static void i8042_wait(void);
 
static iroutine oldvector;
/** Initialize keyboard and service interrupts using kernel routine */
void i8042_grab(void)
{
    oldvector = exc_register(VECTOR_KBD, "i8042_interrupt", (iroutine) i8042_interrupt);
    i8042_wait();
    i8042_command_write(i8042_SET_COMMAND);
    i8042_wait();
    i8042_data_write(i8042_COMMAND);
    i8042_wait();
}
/** Resume the former interrupt vector */
void i8042_release(void)
{
    if (oldvector)
        exc_register(VECTOR_KBD, "user_interrupt", oldvector);
}
 
/** Initialize i8042. */
void i8042_init(void)
{
    int i;
 
    i8042_grab();
        /* Prevent user from accidentaly releasing calling i8042_resume
     * and disabling keyboard
     */
    oldvector = NULL;
 
    trap_virtual_enable_irqs(1<<IRQ_KBD);
    chardev_initialize("i8042_kbd", &kbrd, &ops);
    stdin = &kbrd;
 
    /*
     * Clear input buffer.
     * Number of iterations is limited to prevent infinite looping.
     */
    for (i = 0; (i8042_status_read() & i8042_BUFFER_FULL_MASK) && i < 100; i++) {
        i8042_data_read();
    }  
}
 
/** Process i8042 interrupt.
 *
 * @param n Interrupt vector.
 * @param istate Interrupted state.
 */
void i8042_interrupt(int n, istate_t *istate)
{
    uint8_t x;
    uint8_t status;
 
    while (((status=i8042_status_read()) & i8042_BUFFER_FULL_MASK)) {
        x = i8042_data_read();
 
        if ((status & i8042_MOUSE_DATA))
            continue;
 
        if (x & KEY_RELEASE)
            key_released(x ^ KEY_RELEASE);
        else
            key_pressed(x);
    }
    trap_virtual_eoi();
}
 
/** Wait until the controller reads its data. */
void i8042_wait(void) {
    while (i8042_status_read() & i8042_WAIT_MASK) {
        /* wait */
    }
}
 
/** Process release of key.
 *
 * @param sc Scancode of the key being released.
 */
void key_released(uint8_t sc)
{
    spinlock_lock(&keylock);
    switch (sc) {
        case SC_LSHIFT:
        case SC_RSHIFT:
        keyflags &= ~PRESSED_SHIFT;
        break;
        case SC_CAPSLOCK:
        keyflags &= ~PRESSED_CAPSLOCK;
        if (lockflags & LOCKED_CAPSLOCK)
            lockflags &= ~LOCKED_CAPSLOCK;
        else
            lockflags |= LOCKED_CAPSLOCK;
        break;
        default:
        break;
    }
    spinlock_unlock(&keylock);
}
 
/** Process keypress.
 *
 * @param sc Scancode of the key being pressed.
 */
void key_pressed(uint8_t sc)
{
    char *map = sc_primary_map;
    char ascii = sc_primary_map[sc];
    bool shift, capslock;
    bool letter = false;
 
    spinlock_lock(&keylock);
    switch (sc) {
    case SC_LSHIFT:
    case SC_RSHIFT:
            keyflags |= PRESSED_SHIFT;
        break;
    case SC_CAPSLOCK:
        keyflags |= PRESSED_CAPSLOCK;
        break;
    case SC_SPEC_ESCAPE:
        break;
    case SC_LEFTARR:
        chardev_push_character(&kbrd, 0x1b);
        chardev_push_character(&kbrd, 0x5b);
        chardev_push_character(&kbrd, 0x44);
        break;
    case SC_RIGHTARR:
        chardev_push_character(&kbrd, 0x1b);
        chardev_push_character(&kbrd, 0x5b);
        chardev_push_character(&kbrd, 0x43);
        break;
    case SC_UPARR:
        chardev_push_character(&kbrd, 0x1b);
        chardev_push_character(&kbrd, 0x5b);
        chardev_push_character(&kbrd, 0x41);
        break;
    case SC_DOWNARR:
        chardev_push_character(&kbrd, 0x1b);
        chardev_push_character(&kbrd, 0x5b);
        chardev_push_character(&kbrd, 0x42);
        break;
    case SC_HOME:
        chardev_push_character(&kbrd, 0x1b);
        chardev_push_character(&kbrd, 0x4f);
        chardev_push_character(&kbrd, 0x48);
        break;
    case SC_END:
        chardev_push_character(&kbrd, 0x1b);
        chardev_push_character(&kbrd, 0x4f);
        chardev_push_character(&kbrd, 0x46);
        break;
    case SC_DELETE:
        chardev_push_character(&kbrd, 0x1b);
        chardev_push_character(&kbrd, 0x5b);
        chardev_push_character(&kbrd, 0x33);
        chardev_push_character(&kbrd, 0x7e);
        break;
    default:
            letter = is_lower(ascii);
        capslock = (keyflags & PRESSED_CAPSLOCK) || (lockflags & LOCKED_CAPSLOCK);
        shift = keyflags & PRESSED_SHIFT;
        if (letter && capslock)
            shift = !shift;
        if (shift)
            map = sc_secondary_map;
        chardev_push_character(&kbrd, map[sc]);
        break;
    }
    spinlock_unlock(&keylock);
}
 
/* Called from getc(). */
void i8042_resume(chardev_t *d)
{
}
 
/* Called from getc(). */
void i8042_suspend(chardev_t *d)
{
}
 
static uint8_t active_read_buff_read(void)
{
    static int i=0;
    i &= (ACTIVE_READ_BUFF_SIZE-1);
    if(!active_read_buff[i]) {
        return 0;
    }
    return active_read_buff[i++];
}
 
static void active_read_buff_write(uint8_t ch)
{
    static int i=0;
    active_read_buff[i] = ch;
    i++;
    i &= (ACTIVE_READ_BUFF_SIZE-1);
    active_read_buff[i]=0;
}
 
 
static void active_read_key_pressed(uint8_t sc)
{
    char *map = sc_primary_map;
    char ascii = sc_primary_map[sc];
    bool shift, capslock;
    bool letter = false;
 
    /*spinlock_lock(&keylock);*/
    switch (sc) {
    case SC_LSHIFT:
    case SC_RSHIFT:
            keyflags |= PRESSED_SHIFT;
        break;
    case SC_CAPSLOCK:
        keyflags |= PRESSED_CAPSLOCK;
        break;
    case SC_SPEC_ESCAPE:
        break;
    case SC_LEFTARR:
        active_read_buff_write(0x1b);
        active_read_buff_write(0x5b);
        active_read_buff_write(0x44);
        break;
    case SC_RIGHTARR:
        active_read_buff_write(0x1b);
        active_read_buff_write(0x5b);
        active_read_buff_write(0x43);
        break;
    case SC_UPARR:
        active_read_buff_write(0x1b);
        active_read_buff_write(0x5b);
        active_read_buff_write(0x41);
        break;
    case SC_DOWNARR:
        active_read_buff_write(0x1b);
        active_read_buff_write(0x5b);
        active_read_buff_write(0x42);
        break;
    case SC_HOME:
        active_read_buff_write(0x1b);
        active_read_buff_write(0x4f);
        active_read_buff_write(0x48);
        break;
    case SC_END:
        active_read_buff_write(0x1b);
        active_read_buff_write(0x4f);
        active_read_buff_write(0x46);
        break;
    case SC_DELETE:
        active_read_buff_write(0x1b);
        active_read_buff_write(0x5b);
        active_read_buff_write(0x33);
        active_read_buff_write(0x7e);
        break;
    default:
            letter = is_lower(ascii);
        capslock = (keyflags & PRESSED_CAPSLOCK) || (lockflags & LOCKED_CAPSLOCK);
        shift = keyflags & PRESSED_SHIFT;
        if (letter && capslock)
            shift = !shift;
        if (shift)
            map = sc_secondary_map;
        active_read_buff_write(map[sc]);
        break;
    }
    /*spinlock_unlock(&keylock);*/
 
}
 
static char key_read(chardev_t *d)
{
    char ch;   
 
    while(!(ch = active_read_buff_read())) {
        uint8_t x;
        while (!(i8042_status_read() & i8042_BUFFER_FULL_MASK))
            ;
        x = i8042_data_read();
 
        if (x & KEY_RELEASE)
            key_released(x ^ KEY_RELEASE);
        else
            active_read_key_pressed(x);
 
    }
    return ch;
}
 
/** Poll for key press and release events.
 *
 * This function can be used to implement keyboard polling.
 */
void i8042_poll(void)
{
    uint8_t x;
 
    while (((x = i8042_status_read() & i8042_BUFFER_FULL_MASK))) {
        x = i8042_data_read();
 
        if (x & KEY_RELEASE)
            key_released(x ^ KEY_RELEASE);
        else
            key_pressed(x);
 
    }
}
 
/** @}
 */
 
 

Rev 1841	Rev 1842
1	/*	1	/*
2	* Copyright (C) 2001-2004 Jakub Jermar	2	* Copyright (C) 2001-2004 Jakub Jermar
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup genarch	29	/** @addtogroup genarch
30	* @{	30	* @{
31	*/	31	*/
32	/**	32	/**
33	* @file	33	* @file
34	* @brief i8042 processor driver.	34	* @brief i8042 processor driver.
35	*	35	*
36	* It takes care of low-level keyboard functions.	36	* It takes care of low-level keyboard functions.
37	*/	37	*/
38		38
39	#include <genarch/i8042/i8042.h>	39	#include <genarch/kbd/i8042.h>
-		40	#include <genarch/kbd/scanc.h>
-		41	#include <genarch/kbd/scanc_pc.h>
40	#include <arch/drivers/i8042.h>	42	#include <arch/drivers/i8042.h>
41	#include <arch/interrupt.h>	43	#include <arch/interrupt.h>
42	#include <cpu.h>	44	#include <cpu.h>
43	#include <arch/asm.h>	45	#include <arch/asm.h>
44	#include <arch.h>	46	#include <arch.h>
45	#include <synch/spinlock.h>	47	#include <synch/spinlock.h>
46	#include <typedefs.h>	48	#include <typedefs.h>
47	#include <console/chardev.h>	49	#include <console/chardev.h>
48	#include <console/console.h>	50	#include <console/console.h>
49	#include <macros.h>	51	#include <macros.h>
50	#include <interrupt.h>	52	#include <interrupt.h>
51		53
52	/* Keyboard commands. */	54	/* Keyboard commands. */
53	#define KBD_ENABLE 0xf4	55	#define KBD_ENABLE 0xf4
54	#define KBD_DISABLE 0xf5	56	#define KBD_DISABLE 0xf5
55	#define KBD_ACK 0xfa	57	#define KBD_ACK 0xfa
56		58
57	/*	59	/*
58	* 60 Write 8042 Command Byte: next data byte written to port 60h is	60	* 60 Write 8042 Command Byte: next data byte written to port 60h is
59	* placed in 8042 command register. Format:	61	* placed in 8042 command register. Format:
60	*	62	*
61	* \|7\|6\|5\|4\|3\|2\|1\|0\|8042 Command Byte	63	* \|7\|6\|5\|4\|3\|2\|1\|0\|8042 Command Byte
62	* \| \| \| \| \| \| \| `---- 1=enable output register full interrupt	64	* \| \| \| \| \| \| \| `---- 1=enable output register full interrupt
63	* \| \| \| \| \| \| `----- should be 0	65	* \| \| \| \| \| \| `----- should be 0
64	* \| \| \| \| \| `------ 1=set status register system, 0=clear	66	* \| \| \| \| \| `------ 1=set status register system, 0=clear
65	* \| \| \| \| `------- 1=override keyboard inhibit, 0=allow inhibit	67	* \| \| \| \| `------- 1=override keyboard inhibit, 0=allow inhibit
66	* \| \| \| `-------- disable keyboard I/O by driving clock line low	68	* \| \| \| `-------- disable keyboard I/O by driving clock line low
67	* \| \| `--------- disable auxiliary device, drives clock line low	69	* \| \| `--------- disable auxiliary device, drives clock line low
68	* \| `---------- IBM scancode translation 0=AT, 1=PC/XT	70	* \| `---------- IBM scancode translation 0=AT, 1=PC/XT
69	* `----------- reserved, should be 0	71	* `----------- reserved, should be 0
70	*/	72	*/
71		73
72	#define i8042_SET_COMMAND 0x60	74	#define i8042_SET_COMMAND 0x60
73	#define i8042_COMMAND 0x69	75	#define i8042_COMMAND 0x69
74		76
75	#define i8042_BUFFER_FULL_MASK 0x01	77	#define i8042_BUFFER_FULL_MASK 0x01
76	#define i8042_WAIT_MASK 0x02	78	#define i8042_WAIT_MASK 0x02
77	#define i8042_MOUSE_DATA 0x20	79	#define i8042_MOUSE_DATA 0x20
78		80
79	#define KEY_RELEASE 0x80	81	#define KEY_RELEASE 0x80
80		82
81	/**	-
82	* These codes read from i8042 data register are silently ignored.	-
83	*/	-
84	#define IGNORE_CODE 0x7f	-
85		-
86	static void key_released(uint8_t sc);	83	static void key_released(uint8_t sc);
87	static void key_pressed(uint8_t sc);	84	static void key_pressed(uint8_t sc);
88	static char key_read(chardev_t *d);	85	static char key_read(chardev_t *d);
89		86
90	#define PRESSED_SHIFT (1<<0)	87	#define PRESSED_SHIFT (1<<0)
91	#define PRESSED_CAPSLOCK (1<<1)	88	#define PRESSED_CAPSLOCK (1<<1)
92	#define LOCKED_CAPSLOCK (1<<0)	89	#define LOCKED_CAPSLOCK (1<<0)
93		90
94	#define ACTIVE_READ_BUFF_SIZE 16 /* Must be power of 2 */	91	#define ACTIVE_READ_BUFF_SIZE 16 /* Must be power of 2 */
95		92
96	static uint8_t active_read_buff[ACTIVE_READ_BUFF_SIZE];	93	static uint8_t active_read_buff[ACTIVE_READ_BUFF_SIZE];
97		94
98	SPINLOCK_INITIALIZE(keylock); /*< keylock protects keyflags and lockflags. /	95	SPINLOCK_INITIALIZE(keylock); /*< keylock protects keyflags and lockflags. /
99	static volatile int keyflags; /*< Tracking of multiple keypresses. /	96	static volatile int keyflags; /*< Tracking of multiple keypresses. /
100	static volatile int lockflags; /*< Tracking of multiple keys lockings. /	97	static volatile int lockflags; /*< Tracking of multiple keys lockings. /
101		98
102	static void i8042_suspend(chardev_t *);	99	static void i8042_suspend(chardev_t *);
103	static void i8042_resume(chardev_t *);	100	static void i8042_resume(chardev_t *);
104		101
105	static chardev_t kbrd;	102	static chardev_t kbrd;
106	static chardev_operations_t ops = {	103	static chardev_operations_t ops = {
107	.suspend = i8042_suspend,	104	.suspend = i8042_suspend,
108	.resume = i8042_resume,	105	.resume = i8042_resume,
109	.read = key_read	106	.read = key_read
110	};	107	};
111		108
112	static void i8042_interrupt(int n, istate_t *istate);	109	static void i8042_interrupt(int n, istate_t *istate);
113	static void i8042_wait(void);	110	static void i8042_wait(void);
114		111
115	static iroutine oldvector;	112	static iroutine oldvector;
116	/** Initialize keyboard and service interrupts using kernel routine */	113	/** Initialize keyboard and service interrupts using kernel routine */
117	void i8042_grab(void)	114	void i8042_grab(void)
118	{	115	{
119	oldvector = exc_register(VECTOR_KBD, "i8042_interrupt", (iroutine) i8042_interrupt);	116	oldvector = exc_register(VECTOR_KBD, "i8042_interrupt", (iroutine) i8042_interrupt);
120	i8042_wait();	117	i8042_wait();
121	i8042_command_write(i8042_SET_COMMAND);	118	i8042_command_write(i8042_SET_COMMAND);
122	i8042_wait();	119	i8042_wait();
123	i8042_data_write(i8042_COMMAND);	120	i8042_data_write(i8042_COMMAND);
124	i8042_wait();	121	i8042_wait();
125	}	122	}
126	/** Resume the former interrupt vector */	123	/** Resume the former interrupt vector */
127	void i8042_release(void)	124	void i8042_release(void)
128	{	125	{
129	if (oldvector)	126	if (oldvector)
130	exc_register(VECTOR_KBD, "user_interrupt", oldvector);	127	exc_register(VECTOR_KBD, "user_interrupt", oldvector);
131	}	128	}
132		129
133	/** Initialize i8042. */	130	/** Initialize i8042. */
134	void i8042_init(void)	131	void i8042_init(void)
135	{	132	{
136	int i;	133	int i;
137		134
138	i8042_grab();	135	i8042_grab();
139	/* Prevent user from accidentaly releasing calling i8042_resume	136	/* Prevent user from accidentaly releasing calling i8042_resume
140	* and disabling keyboard	137	* and disabling keyboard
141	*/	138	*/
142	oldvector = NULL;	139	oldvector = NULL;
143		140
144	trap_virtual_enable_irqs(1<<IRQ_KBD);	141	trap_virtual_enable_irqs(1<<IRQ_KBD);
145	chardev_initialize("i8042_kbd", &kbrd, &ops);	142	chardev_initialize("i8042_kbd", &kbrd, &ops);
146	stdin = &kbrd;	143	stdin = &kbrd;
147		144
148	/*	145	/*
149	* Clear input buffer.	146	* Clear input buffer.
150	* Number of iterations is limited to prevent infinite looping.	147	* Number of iterations is limited to prevent infinite looping.
151	*/	148	*/
152	for (i = 0; (i8042_status_read() & i8042_BUFFER_FULL_MASK) && i < 100; i++) {	149	for (i = 0; (i8042_status_read() & i8042_BUFFER_FULL_MASK) && i < 100; i++) {
153	i8042_data_read();	150	i8042_data_read();
154	}	151	}
155	}	152	}
156		153
157	/** Process i8042 interrupt.	154	/** Process i8042 interrupt.
158	*	155	*
159	* @param n Interrupt vector.	156	* @param n Interrupt vector.
160	* @param istate Interrupted state.	157	* @param istate Interrupted state.
161	*/	158	*/
162	void i8042_interrupt(int n, istate_t *istate)	159	void i8042_interrupt(int n, istate_t *istate)
163	{	160	{
164	uint8_t x;	161	uint8_t x;
165	uint8_t status;	162	uint8_t status;
166		163
167	while (((status=i8042_status_read()) & i8042_BUFFER_FULL_MASK)) {	164	while (((status=i8042_status_read()) & i8042_BUFFER_FULL_MASK)) {
168	x = i8042_data_read();	165	x = i8042_data_read();
169		166
170	if ((status & i8042_MOUSE_DATA))	167	if ((status & i8042_MOUSE_DATA))
171	continue;	168	continue;
172		169
173	if (x & KEY_RELEASE)	170	if (x & KEY_RELEASE)
174	key_released(x ^ KEY_RELEASE);	171	key_released(x ^ KEY_RELEASE);
175	else	172	else
176	key_pressed(x);	173	key_pressed(x);
177	}	174	}
178	trap_virtual_eoi();	175	trap_virtual_eoi();
179	}	176	}
180		177
181	/** Wait until the controller reads its data. */	178	/** Wait until the controller reads its data. */
182	void i8042_wait(void) {	179	void i8042_wait(void) {
183	while (i8042_status_read() & i8042_WAIT_MASK) {	180	while (i8042_status_read() & i8042_WAIT_MASK) {
184	/* wait */	181	/* wait */
185	}	182	}
186	}	183	}
187		184
188	/** Process release of key.	185	/** Process release of key.
189	*	186	*
190	* @param sc Scancode of the key being released.	187	* @param sc Scancode of the key being released.
191	*/	188	*/
192	void key_released(uint8_t sc)	189	void key_released(uint8_t sc)
193	{	190	{
194	spinlock_lock(&keylock);	191	spinlock_lock(&keylock);
195	switch (sc) {	192	switch (sc) {
196	case SC_LSHIFT:	193	case SC_LSHIFT:
197	case SC_RSHIFT:	194	case SC_RSHIFT:
198	keyflags &= ~PRESSED_SHIFT;	195	keyflags &= ~PRESSED_SHIFT;
199	break;	196	break;
200	case SC_CAPSLOCK:	197	case SC_CAPSLOCK:
201	keyflags &= ~PRESSED_CAPSLOCK;	198	keyflags &= ~PRESSED_CAPSLOCK;
202	if (lockflags & LOCKED_CAPSLOCK)	199	if (lockflags & LOCKED_CAPSLOCK)
203	lockflags &= ~LOCKED_CAPSLOCK;	200	lockflags &= ~LOCKED_CAPSLOCK;
204	else	201	else
205	lockflags \|= LOCKED_CAPSLOCK;	202	lockflags \|= LOCKED_CAPSLOCK;
206	break;	203	break;
207	default:	204	default:
208	break;	205	break;
209	}	206	}
210	spinlock_unlock(&keylock);	207	spinlock_unlock(&keylock);
211	}	208	}
212		209
213	/** Process keypress.	210	/** Process keypress.
214	*	211	*
215	* @param sc Scancode of the key being pressed.	212	* @param sc Scancode of the key being pressed.
216	*/	213	*/
217	void key_pressed(uint8_t sc)	214	void key_pressed(uint8_t sc)
218	{	215	{
219	char *map = sc_primary_map;	216	char *map = sc_primary_map;
220	char ascii = sc_primary_map[sc];	217	char ascii = sc_primary_map[sc];
221	bool shift, capslock;	218	bool shift, capslock;
222	bool letter = false;	219	bool letter = false;
223		220
224	spinlock_lock(&keylock);	221	spinlock_lock(&keylock);
225	switch (sc) {	222	switch (sc) {
226	case SC_LSHIFT:	223	case SC_LSHIFT:
227	case SC_RSHIFT:	224	case SC_RSHIFT:
228	keyflags \|= PRESSED_SHIFT;	225	keyflags \|= PRESSED_SHIFT;
229	break;	226	break;
230	case SC_CAPSLOCK:	227	case SC_CAPSLOCK:
231	keyflags \|= PRESSED_CAPSLOCK;	228	keyflags \|= PRESSED_CAPSLOCK;
232	break;	229	break;
233	case SC_SPEC_ESCAPE:	230	case SC_SPEC_ESCAPE:
234	break;	231	break;
235	case SC_LEFTARR:	232	case SC_LEFTARR:
236	chardev_push_character(&kbrd, 0x1b);	233	chardev_push_character(&kbrd, 0x1b);
237	chardev_push_character(&kbrd, 0x5b);	234	chardev_push_character(&kbrd, 0x5b);
238	chardev_push_character(&kbrd, 0x44);	235	chardev_push_character(&kbrd, 0x44);
239	break;	236	break;
240	case SC_RIGHTARR:	237	case SC_RIGHTARR:
241	chardev_push_character(&kbrd, 0x1b);	238	chardev_push_character(&kbrd, 0x1b);
242	chardev_push_character(&kbrd, 0x5b);	239	chardev_push_character(&kbrd, 0x5b);
243	chardev_push_character(&kbrd, 0x43);	240	chardev_push_character(&kbrd, 0x43);
244	break;	241	break;
245	case SC_UPARR:	242	case SC_UPARR:
246	chardev_push_character(&kbrd, 0x1b);	243	chardev_push_character(&kbrd, 0x1b);
247	chardev_push_character(&kbrd, 0x5b);	244	chardev_push_character(&kbrd, 0x5b);
248	chardev_push_character(&kbrd, 0x41);	245	chardev_push_character(&kbrd, 0x41);
249	break;	246	break;
250	case SC_DOWNARR:	247	case SC_DOWNARR:
251	chardev_push_character(&kbrd, 0x1b);	248	chardev_push_character(&kbrd, 0x1b);
252	chardev_push_character(&kbrd, 0x5b);	249	chardev_push_character(&kbrd, 0x5b);
253	chardev_push_character(&kbrd, 0x42);	250	chardev_push_character(&kbrd, 0x42);
254	break;	251	break;
255	case SC_HOME:	252	case SC_HOME:
256	chardev_push_character(&kbrd, 0x1b);	253	chardev_push_character(&kbrd, 0x1b);
257	chardev_push_character(&kbrd, 0x4f);	254	chardev_push_character(&kbrd, 0x4f);
258	chardev_push_character(&kbrd, 0x48);	255	chardev_push_character(&kbrd, 0x48);
259	break;	256	break;
260	case SC_END:	257	case SC_END:
261	chardev_push_character(&kbrd, 0x1b);	258	chardev_push_character(&kbrd, 0x1b);
262	chardev_push_character(&kbrd, 0x4f);	259	chardev_push_character(&kbrd, 0x4f);
263	chardev_push_character(&kbrd, 0x46);	260	chardev_push_character(&kbrd, 0x46);
264	break;	261	break;
265	case SC_DELETE:	262	case SC_DELETE:
266	chardev_push_character(&kbrd, 0x1b);	263	chardev_push_character(&kbrd, 0x1b);
267	chardev_push_character(&kbrd, 0x5b);	264	chardev_push_character(&kbrd, 0x5b);
268	chardev_push_character(&kbrd, 0x33);	265	chardev_push_character(&kbrd, 0x33);
269	chardev_push_character(&kbrd, 0x7e);	266	chardev_push_character(&kbrd, 0x7e);
270	break;	267	break;
271	default:	268	default:
272	letter = is_lower(ascii);	269	letter = is_lower(ascii);
273	capslock = (keyflags & PRESSED_CAPSLOCK) \|\| (lockflags & LOCKED_CAPSLOCK);	270	capslock = (keyflags & PRESSED_CAPSLOCK) \|\| (lockflags & LOCKED_CAPSLOCK);
274	shift = keyflags & PRESSED_SHIFT;	271	shift = keyflags & PRESSED_SHIFT;
275	if (letter && capslock)	272	if (letter && capslock)
276	shift = !shift;	273	shift = !shift;
277	if (shift)	274	if (shift)
278	map = sc_secondary_map;	275	map = sc_secondary_map;
279	chardev_push_character(&kbrd, map[sc]);	276	chardev_push_character(&kbrd, map[sc]);
280	break;	277	break;
281	}	278	}
282	spinlock_unlock(&keylock);	279	spinlock_unlock(&keylock);
283	}	280	}
284		281
285	/* Called from getc(). */	282	/* Called from getc(). */
286	void i8042_resume(chardev_t *d)	283	void i8042_resume(chardev_t *d)
287	{	284	{
288	}	285	}
289		286
290	/* Called from getc(). */	287	/* Called from getc(). */
291	void i8042_suspend(chardev_t *d)	288	void i8042_suspend(chardev_t *d)
292	{	289	{
293	}	290	}
294		291
295	static uint8_t active_read_buff_read(void)	292	static uint8_t active_read_buff_read(void)
296	{	293	{
297	static int i=0;	294	static int i=0;
298	i &= (ACTIVE_READ_BUFF_SIZE-1);	295	i &= (ACTIVE_READ_BUFF_SIZE-1);
299	if(!active_read_buff[i]) {	296	if(!active_read_buff[i]) {
300	return 0;	297	return 0;
301	}	298	}
302	return active_read_buff[i++];	299	return active_read_buff[i++];
303	}	300	}
304		301
305	static void active_read_buff_write(uint8_t ch)	302	static void active_read_buff_write(uint8_t ch)
306	{	303	{
307	static int i=0;	304	static int i=0;
308	active_read_buff[i] = ch;	305	active_read_buff[i] = ch;
309	i++;	306	i++;
310	i &= (ACTIVE_READ_BUFF_SIZE-1);	307	i &= (ACTIVE_READ_BUFF_SIZE-1);
311	active_read_buff[i]=0;	308	active_read_buff[i]=0;
312	}	309	}
313		310
314		311
315	static void active_read_key_pressed(uint8_t sc)	312	static void active_read_key_pressed(uint8_t sc)
316	{	313	{
317	char *map = sc_primary_map;	314	char *map = sc_primary_map;
318	char ascii = sc_primary_map[sc];	315	char ascii = sc_primary_map[sc];
319	bool shift, capslock;	316	bool shift, capslock;
320	bool letter = false;	317	bool letter = false;
321		318
322	/spinlock_lock(&keylock);/	319	/spinlock_lock(&keylock);/
323	switch (sc) {	320	switch (sc) {
324	case SC_LSHIFT:	321	case SC_LSHIFT:
325	case SC_RSHIFT:	322	case SC_RSHIFT:
326	keyflags \|= PRESSED_SHIFT;	323	keyflags \|= PRESSED_SHIFT;
327	break;	324	break;
328	case SC_CAPSLOCK:	325	case SC_CAPSLOCK:
329	keyflags \|= PRESSED_CAPSLOCK;	326	keyflags \|= PRESSED_CAPSLOCK;
330	break;	327	break;
331	case SC_SPEC_ESCAPE:	328	case SC_SPEC_ESCAPE:
332	break;	329	break;
333	case SC_LEFTARR:	330	case SC_LEFTARR:
334	active_read_buff_write(0x1b);	331	active_read_buff_write(0x1b);
335	active_read_buff_write(0x5b);	332	active_read_buff_write(0x5b);
336	active_read_buff_write(0x44);	333	active_read_buff_write(0x44);
337	break;	334	break;
338	case SC_RIGHTARR:	335	case SC_RIGHTARR:
339	active_read_buff_write(0x1b);	336	active_read_buff_write(0x1b);
340	active_read_buff_write(0x5b);	337	active_read_buff_write(0x5b);
341	active_read_buff_write(0x43);	338	active_read_buff_write(0x43);
342	break;	339	break;
343	case SC_UPARR:	340	case SC_UPARR:
344	active_read_buff_write(0x1b);	341	active_read_buff_write(0x1b);
345	active_read_buff_write(0x5b);	342	active_read_buff_write(0x5b);
346	active_read_buff_write(0x41);	343	active_read_buff_write(0x41);
347	break;	344	break;
348	case SC_DOWNARR:	345	case SC_DOWNARR:
349	active_read_buff_write(0x1b);	346	active_read_buff_write(0x1b);
350	active_read_buff_write(0x5b);	347	active_read_buff_write(0x5b);
351	active_read_buff_write(0x42);	348	active_read_buff_write(0x42);
352	break;	349	break;
353	case SC_HOME:	350	case SC_HOME:
354	active_read_buff_write(0x1b);	351	active_read_buff_write(0x1b);
355	active_read_buff_write(0x4f);	352	active_read_buff_write(0x4f);
356	active_read_buff_write(0x48);	353	active_read_buff_write(0x48);
357	break;	354	break;
358	case SC_END:	355	case SC_END:
359	active_read_buff_write(0x1b);	356	active_read_buff_write(0x1b);
360	active_read_buff_write(0x4f);	357	active_read_buff_write(0x4f);
361	active_read_buff_write(0x46);	358	active_read_buff_write(0x46);
362	break;	359	break;
363	case SC_DELETE:	360	case SC_DELETE:
364	active_read_buff_write(0x1b);	361	active_read_buff_write(0x1b);
365	active_read_buff_write(0x5b);	362	active_read_buff_write(0x5b);
366	active_read_buff_write(0x33);	363	active_read_buff_write(0x33);
367	active_read_buff_write(0x7e);	364	active_read_buff_write(0x7e);
368	break;	365	break;
369	default:	366	default:
370	letter = is_lower(ascii);	367	letter = is_lower(ascii);
371	capslock = (keyflags & PRESSED_CAPSLOCK) \|\| (lockflags & LOCKED_CAPSLOCK);	368	capslock = (keyflags & PRESSED_CAPSLOCK) \|\| (lockflags & LOCKED_CAPSLOCK);
372	shift = keyflags & PRESSED_SHIFT;	369	shift = keyflags & PRESSED_SHIFT;
373	if (letter && capslock)	370	if (letter && capslock)
374	shift = !shift;	371	shift = !shift;
375	if (shift)	372	if (shift)
376	map = sc_secondary_map;	373	map = sc_secondary_map;
377	active_read_buff_write(map[sc]);	374	active_read_buff_write(map[sc]);
378	break;	375	break;
379	}	376	}
380	/spinlock_unlock(&keylock);/	377	/spinlock_unlock(&keylock);/
381		378
382	}	379	}
383		380
384	static char key_read(chardev_t *d)	381	static char key_read(chardev_t *d)
385	{	382	{
386	char ch;	383	char ch;
387		384
388	while(!(ch = active_read_buff_read())) {	385	while(!(ch = active_read_buff_read())) {
389	uint8_t x;	386	uint8_t x;
390	while (!(i8042_status_read() & i8042_BUFFER_FULL_MASK))	387	while (!(i8042_status_read() & i8042_BUFFER_FULL_MASK))
391	;	388	;
392	x = i8042_data_read();	389	x = i8042_data_read();
393	if (x != IGNORE_CODE) {	-
394	if (x & KEY_RELEASE)	390	if (x & KEY_RELEASE)
395	key_released(x ^ KEY_RELEASE);	391	key_released(x ^ KEY_RELEASE);
396	else	392	else
397	active_read_key_pressed(x);	393	active_read_key_pressed(x);
398	}	-
399	}	394	}
400	return ch;	395	return ch;
401	}	396	}
402		397
403	/** Poll for key press and release events.	398	/** Poll for key press and release events.
404	*	399	*
405	* This function can be used to implement keyboard polling.	400	* This function can be used to implement keyboard polling.
406	*/	401	*/
407	void i8042_poll(void)	402	void i8042_poll(void)
408	{	403	{
409	uint8_t x;	404	uint8_t x;
410		405
411	while (((x = i8042_status_read() & i8042_BUFFER_FULL_MASK))) {	406	while (((x = i8042_status_read() & i8042_BUFFER_FULL_MASK))) {
412	x = i8042_data_read();	407	x = i8042_data_read();
413	if (x != IGNORE_CODE) {	-
414	if (x & KEY_RELEASE)	408	if (x & KEY_RELEASE)
415	key_released(x ^ KEY_RELEASE);	409	key_released(x ^ KEY_RELEASE);
416	else	410	else
417	key_pressed(x);	411	key_pressed(x);
418	}	-
419	}	412	}
420	}	413	}
421		414
422	/** @}	415	/** @}
423	*/	416	*/
424		-
425		417

Subversion Repositories HelenOS

(root)/trunk/kernel/genarch/src/kbd/i8042.c – Rev 1841 → 1842