WebSVN – HelenOS – Diff – /trunk/kernel/genarch/src/kbd/key.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/i8042/i8042.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
 
/**
 * These codes read from i8042 data register are silently ignored.
 */
#define IGNORE_CODE 0x7f
 
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 != IGNORE_CODE) {
            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 != IGNORE_CODE) {
            if (x & KEY_RELEASE)
                key_released(x ^ KEY_RELEASE);
            else
                key_pressed(x);
        }
    }
}
 
/** @}
 */
 
 

Rev 1838	Rev 1841
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/i8042/i8042.h>
40	#include <arch/drivers/i8042.h>	40	#include <arch/drivers/i8042.h>
41	#include <arch/interrupt.h>	41	#include <arch/interrupt.h>
42	#include <cpu.h>	42	#include <cpu.h>
43	#include <arch/asm.h>	43	#include <arch/asm.h>
44	#include <arch.h>	44	#include <arch.h>
45	#include <synch/spinlock.h>	45	#include <synch/spinlock.h>
46	#include <typedefs.h>	46	#include <typedefs.h>
47	#include <console/chardev.h>	47	#include <console/chardev.h>
48	#include <console/console.h>	48	#include <console/console.h>
49	#include <macros.h>	49	#include <macros.h>
50	#include <interrupt.h>	50	#include <interrupt.h>
51		51
52	/* Keyboard commands. */	52	/* Keyboard commands. */
53	#define KBD_ENABLE 0xf4	53	#define KBD_ENABLE 0xf4
54	#define KBD_DISABLE 0xf5	54	#define KBD_DISABLE 0xf5
55	#define KBD_ACK 0xfa	55	#define KBD_ACK 0xfa
56		56
57	/*	57	/*
58	* 60 Write 8042 Command Byte: next data byte written to port 60h is	58	* 60 Write 8042 Command Byte: next data byte written to port 60h is
59	* placed in 8042 command register. Format:	59	* placed in 8042 command register. Format:
60	*	60	*
61	* \|7\|6\|5\|4\|3\|2\|1\|0\|8042 Command Byte	61	* \|7\|6\|5\|4\|3\|2\|1\|0\|8042 Command Byte
62	* \| \| \| \| \| \| \| `---- 1=enable output register full interrupt	62	* \| \| \| \| \| \| \| `---- 1=enable output register full interrupt
63	* \| \| \| \| \| \| `----- should be 0	63	* \| \| \| \| \| \| `----- should be 0
64	* \| \| \| \| \| `------ 1=set status register system, 0=clear	64	* \| \| \| \| \| `------ 1=set status register system, 0=clear
65	* \| \| \| \| `------- 1=override keyboard inhibit, 0=allow inhibit	65	* \| \| \| \| `------- 1=override keyboard inhibit, 0=allow inhibit
66	* \| \| \| `-------- disable keyboard I/O by driving clock line low	66	* \| \| \| `-------- disable keyboard I/O by driving clock line low
67	* \| \| `--------- disable auxiliary device, drives clock line low	67	* \| \| `--------- disable auxiliary device, drives clock line low
68	* \| `---------- IBM scancode translation 0=AT, 1=PC/XT	68	* \| `---------- IBM scancode translation 0=AT, 1=PC/XT
69	* `----------- reserved, should be 0	69	* `----------- reserved, should be 0
70	*/	70	*/
71		71
72	#define i8042_SET_COMMAND 0x60	72	#define i8042_SET_COMMAND 0x60
73	#define i8042_COMMAND 0x69	73	#define i8042_COMMAND 0x69
74		74
75	#define i8042_BUFFER_FULL_MASK 0x01	75	#define i8042_BUFFER_FULL_MASK 0x01
76	#define i8042_WAIT_MASK 0x02	76	#define i8042_WAIT_MASK 0x02
77	#define i8042_MOUSE_DATA 0x20	77	#define i8042_MOUSE_DATA 0x20
78		78
79	#define KEY_RELEASE 0x80	79	#define KEY_RELEASE 0x80
80		80
81	/**	81	/**
82	* These codes read from i8042 data register are silently ignored.	82	* These codes read from i8042 data register are silently ignored.
83	*/	83	*/
84	#define IGNORE_CODE 0x7f	84	#define IGNORE_CODE 0x7f
85		85
86	static void key_released(uint8_t sc);	86	static void key_released(uint8_t sc);
87	static void key_pressed(uint8_t sc);	87	static void key_pressed(uint8_t sc);
88	static char key_read(chardev_t *d);	88	static char key_read(chardev_t *d);
89		89
90	#define PRESSED_SHIFT (1<<0)	90	#define PRESSED_SHIFT (1<<0)
91	#define PRESSED_CAPSLOCK (1<<1)	91	#define PRESSED_CAPSLOCK (1<<1)
92	#define LOCKED_CAPSLOCK (1<<0)	92	#define LOCKED_CAPSLOCK (1<<0)
93		93
94	#define ACTIVE_READ_BUFF_SIZE 16 /* Must be power of 2 */	94	#define ACTIVE_READ_BUFF_SIZE 16 /* Must be power of 2 */
95		95
96	static uint8_t active_read_buff[ACTIVE_READ_BUFF_SIZE];	96	static uint8_t active_read_buff[ACTIVE_READ_BUFF_SIZE];
97		97
98	SPINLOCK_INITIALIZE(keylock); /*< keylock protects keyflags and lockflags. /	98	SPINLOCK_INITIALIZE(keylock); /*< keylock protects keyflags and lockflags. /
99	static volatile int keyflags; /*< Tracking of multiple keypresses. /	99	static volatile int keyflags; /*< Tracking of multiple keypresses. /
100	static volatile int lockflags; /*< Tracking of multiple keys lockings. /	100	static volatile int lockflags; /*< Tracking of multiple keys lockings. /
101		101
102	static void i8042_suspend(chardev_t *);	102	static void i8042_suspend(chardev_t *);
103	static void i8042_resume(chardev_t *);	103	static void i8042_resume(chardev_t *);
104		104
105	static chardev_t kbrd;	105	static chardev_t kbrd;
106	static chardev_operations_t ops = {	106	static chardev_operations_t ops = {
107	.suspend = i8042_suspend,	107	.suspend = i8042_suspend,
108	.resume = i8042_resume,	108	.resume = i8042_resume,
109	.read = key_read	109	.read = key_read
110	};	110	};
111		111
112	static void i8042_interrupt(int n, istate_t *istate);	112	static void i8042_interrupt(int n, istate_t *istate);
113	static void i8042_wait(void);	113	static void i8042_wait(void);
114		114
115	static iroutine oldvector;	115	static iroutine oldvector;
116	/** Initialize keyboard and service interrupts using kernel routine */	116	/** Initialize keyboard and service interrupts using kernel routine */
117	void i8042_grab(void)	117	void i8042_grab(void)
118	{	118	{
119	oldvector = exc_register(VECTOR_KBD, "i8042_interrupt", (iroutine) i8042_interrupt);	119	oldvector = exc_register(VECTOR_KBD, "i8042_interrupt", (iroutine) i8042_interrupt);
120	i8042_wait();	120	i8042_wait();
121	i8042_command_write(i8042_SET_COMMAND);	121	i8042_command_write(i8042_SET_COMMAND);
122	i8042_wait();	122	i8042_wait();
123	i8042_data_write(i8042_COMMAND);	123	i8042_data_write(i8042_COMMAND);
124	i8042_wait();	124	i8042_wait();
125	}	125	}
126	/** Resume the former interrupt vector */	126	/** Resume the former interrupt vector */
127	void i8042_release(void)	127	void i8042_release(void)
128	{	128	{
129	if (oldvector)	129	if (oldvector)
130	exc_register(VECTOR_KBD, "user_interrupt", oldvector);	130	exc_register(VECTOR_KBD, "user_interrupt", oldvector);
131	}	131	}
132		132
133	/** Initialize i8042. */	133	/** Initialize i8042. */
134	void i8042_init(void)	134	void i8042_init(void)
135	{	135	{
136	int i;	136	int i;
137		137
138	i8042_grab();	138	i8042_grab();
139	/* Prevent user from accidentaly releasing calling i8042_resume	139	/* Prevent user from accidentaly releasing calling i8042_resume
140	* and disabling keyboard	140	* and disabling keyboard
141	*/	141	*/
142	oldvector = NULL;	142	oldvector = NULL;
143		143
144	trap_virtual_enable_irqs(1<<IRQ_KBD);	144	trap_virtual_enable_irqs(1<<IRQ_KBD);
145	chardev_initialize("i8042_kbd", &kbrd, &ops);	145	chardev_initialize("i8042_kbd", &kbrd, &ops);
146	stdin = &kbrd;	146	stdin = &kbrd;
147		147
148	/*	148	/*
149	* Clear input buffer.	149	* Clear input buffer.
150	* Number of iterations is limited to prevent infinite looping.	150	* Number of iterations is limited to prevent infinite looping.
151	*/	151	*/
152	for (i = 0; (i8042_status_read() & i8042_BUFFER_FULL_MASK) && i < 100; i++) {	152	for (i = 0; (i8042_status_read() & i8042_BUFFER_FULL_MASK) && i < 100; i++) {
153	i8042_data_read();	153	i8042_data_read();
154	}	154	}
155	}	155	}
156		156
157	/** Process i8042 interrupt.	157	/** Process i8042 interrupt.
158	*	158	*
159	* @param n Interrupt vector.	159	* @param n Interrupt vector.
160	* @param istate Interrupted state.	160	* @param istate Interrupted state.
161	*/	161	*/
162	void i8042_interrupt(int n, istate_t *istate)	162	void i8042_interrupt(int n, istate_t *istate)
163	{	163	{
164	uint8_t x;	164	uint8_t x;
165	uint8_t status;	165	uint8_t status;
166		166
167	while (((status=i8042_status_read()) & i8042_BUFFER_FULL_MASK)) {	167	while (((status=i8042_status_read()) & i8042_BUFFER_FULL_MASK)) {
168	x = i8042_data_read();	168	x = i8042_data_read();
169		169
170	if ((status & i8042_MOUSE_DATA))	170	if ((status & i8042_MOUSE_DATA))
171	continue;	171	continue;
172		172
173	if (x & KEY_RELEASE)	173	if (x & KEY_RELEASE)
174	key_released(x ^ KEY_RELEASE);	174	key_released(x ^ KEY_RELEASE);
175	else	175	else
176	key_pressed(x);	176	key_pressed(x);
177	}	177	}
178	trap_virtual_eoi();	178	trap_virtual_eoi();
179	}	179	}
180		180
181	/** Wait until the controller reads its data. */	181	/** Wait until the controller reads its data. */
182	void i8042_wait(void) {	182	void i8042_wait(void) {
183	while (i8042_status_read() & i8042_WAIT_MASK) {	183	while (i8042_status_read() & i8042_WAIT_MASK) {
184	/* wait */	184	/* wait */
185	}	185	}
186	}	186	}
187		187
188	/** Process release of key.	188	/** Process release of key.
189	*	189	*
190	* @param sc Scancode of the key being released.	190	* @param sc Scancode of the key being released.
191	*/	191	*/
192	void key_released(uint8_t sc)	192	void key_released(uint8_t sc)
193	{	193	{
194	spinlock_lock(&keylock);	194	spinlock_lock(&keylock);
195	switch (sc) {	195	switch (sc) {
196	case SC_LSHIFT:	196	case SC_LSHIFT:
197	case SC_RSHIFT:	197	case SC_RSHIFT:
198	keyflags &= ~PRESSED_SHIFT;	198	keyflags &= ~PRESSED_SHIFT;
199	break;	199	break;
200	case SC_CAPSLOCK:	200	case SC_CAPSLOCK:
201	keyflags &= ~PRESSED_CAPSLOCK;	201	keyflags &= ~PRESSED_CAPSLOCK;
202	if (lockflags & LOCKED_CAPSLOCK)	202	if (lockflags & LOCKED_CAPSLOCK)
203	lockflags &= ~LOCKED_CAPSLOCK;	203	lockflags &= ~LOCKED_CAPSLOCK;
204	else	204	else
205	lockflags \|= LOCKED_CAPSLOCK;	205	lockflags \|= LOCKED_CAPSLOCK;
206	break;	206	break;
207	default:	207	default:
208	break;	208	break;
209	}	209	}
210	spinlock_unlock(&keylock);	210	spinlock_unlock(&keylock);
211	}	211	}
212		212
213	/** Process keypress.	213	/** Process keypress.
214	*	214	*
215	* @param sc Scancode of the key being pressed.	215	* @param sc Scancode of the key being pressed.
216	*/	216	*/
217	void key_pressed(uint8_t sc)	217	void key_pressed(uint8_t sc)
218	{	218	{
219	char *map = sc_primary_map;	219	char *map = sc_primary_map;
220	char ascii = sc_primary_map[sc];	220	char ascii = sc_primary_map[sc];
221	bool shift, capslock;	221	bool shift, capslock;
222	bool letter = false;	222	bool letter = false;
223		223
224	spinlock_lock(&keylock);	224	spinlock_lock(&keylock);
225	switch (sc) {	225	switch (sc) {
226	case SC_LSHIFT:	226	case SC_LSHIFT:
227	case SC_RSHIFT:	227	case SC_RSHIFT:
228	keyflags \|= PRESSED_SHIFT;	228	keyflags \|= PRESSED_SHIFT;
229	break;	229	break;
230	case SC_CAPSLOCK:	230	case SC_CAPSLOCK:
231	keyflags \|= PRESSED_CAPSLOCK;	231	keyflags \|= PRESSED_CAPSLOCK;
232	break;	232	break;
233	case SC_SPEC_ESCAPE:	233	case SC_SPEC_ESCAPE:
234	break;	234	break;
235	case SC_LEFTARR:	235	case SC_LEFTARR:
236	chardev_push_character(&kbrd, 0x1b);	236	chardev_push_character(&kbrd, 0x1b);
237	chardev_push_character(&kbrd, 0x5b);	237	chardev_push_character(&kbrd, 0x5b);
238	chardev_push_character(&kbrd, 0x44);	238	chardev_push_character(&kbrd, 0x44);
239	break;	239	break;
240	case SC_RIGHTARR:	240	case SC_RIGHTARR:
241	chardev_push_character(&kbrd, 0x1b);	241	chardev_push_character(&kbrd, 0x1b);
242	chardev_push_character(&kbrd, 0x5b);	242	chardev_push_character(&kbrd, 0x5b);
243	chardev_push_character(&kbrd, 0x43);	243	chardev_push_character(&kbrd, 0x43);
244	break;	244	break;
245	case SC_UPARR:	245	case SC_UPARR:
246	chardev_push_character(&kbrd, 0x1b);	246	chardev_push_character(&kbrd, 0x1b);
247	chardev_push_character(&kbrd, 0x5b);	247	chardev_push_character(&kbrd, 0x5b);
248	chardev_push_character(&kbrd, 0x41);	248	chardev_push_character(&kbrd, 0x41);
249	break;	249	break;
250	case SC_DOWNARR:	250	case SC_DOWNARR:
251	chardev_push_character(&kbrd, 0x1b);	251	chardev_push_character(&kbrd, 0x1b);
252	chardev_push_character(&kbrd, 0x5b);	252	chardev_push_character(&kbrd, 0x5b);
253	chardev_push_character(&kbrd, 0x42);	253	chardev_push_character(&kbrd, 0x42);
254	break;	254	break;
255	case SC_HOME:	255	case SC_HOME:
256	chardev_push_character(&kbrd, 0x1b);	256	chardev_push_character(&kbrd, 0x1b);
257	chardev_push_character(&kbrd, 0x4f);	257	chardev_push_character(&kbrd, 0x4f);
258	chardev_push_character(&kbrd, 0x48);	258	chardev_push_character(&kbrd, 0x48);
259	break;	259	break;
260	case SC_END:	260	case SC_END:
261	chardev_push_character(&kbrd, 0x1b);	261	chardev_push_character(&kbrd, 0x1b);
262	chardev_push_character(&kbrd, 0x4f);	262	chardev_push_character(&kbrd, 0x4f);
263	chardev_push_character(&kbrd, 0x46);	263	chardev_push_character(&kbrd, 0x46);
264	break;	264	break;
265	case SC_DELETE:	265	case SC_DELETE:
266	chardev_push_character(&kbrd, 0x1b);	266	chardev_push_character(&kbrd, 0x1b);
267	chardev_push_character(&kbrd, 0x5b);	267	chardev_push_character(&kbrd, 0x5b);
268	chardev_push_character(&kbrd, 0x33);	268	chardev_push_character(&kbrd, 0x33);
269	chardev_push_character(&kbrd, 0x7e);	269	chardev_push_character(&kbrd, 0x7e);
270	break;	270	break;
271	default:	271	default:
272	letter = is_lower(ascii);	272	letter = is_lower(ascii);
273	capslock = (keyflags & PRESSED_CAPSLOCK) \|\| (lockflags & LOCKED_CAPSLOCK);	273	capslock = (keyflags & PRESSED_CAPSLOCK) \|\| (lockflags & LOCKED_CAPSLOCK);
274	shift = keyflags & PRESSED_SHIFT;	274	shift = keyflags & PRESSED_SHIFT;
275	if (letter && capslock)	275	if (letter && capslock)
276	shift = !shift;	276	shift = !shift;
277	if (shift)	277	if (shift)
278	map = sc_secondary_map;	278	map = sc_secondary_map;
279	chardev_push_character(&kbrd, map[sc]);	279	chardev_push_character(&kbrd, map[sc]);
280	break;	280	break;
281	}	281	}
282	spinlock_unlock(&keylock);	282	spinlock_unlock(&keylock);
283	}	283	}
284		284
285	/* Called from getc(). */	285	/* Called from getc(). */
286	void i8042_resume(chardev_t *d)	286	void i8042_resume(chardev_t *d)
287	{	287	{
288	}	288	}
289		289
290	/* Called from getc(). */	290	/* Called from getc(). */
291	void i8042_suspend(chardev_t *d)	291	void i8042_suspend(chardev_t *d)
292	{	292	{
293	}	293	}
294		294
295	static uint8_t active_read_buff_read(void)	295	static uint8_t active_read_buff_read(void)
296	{	296	{
297	static int i=0;	297	static int i=0;
298	i &= (ACTIVE_READ_BUFF_SIZE-1);	298	i &= (ACTIVE_READ_BUFF_SIZE-1);
299	if(!active_read_buff[i]) {	299	if(!active_read_buff[i]) {
300	return 0;	300	return 0;
301	}	301	}
302	return active_read_buff[i++];	302	return active_read_buff[i++];
303	}	303	}
304		304
305	static void active_read_buff_write(uint8_t ch)	305	static void active_read_buff_write(uint8_t ch)
306	{	306	{
307	static int i=0;	307	static int i=0;
308	active_read_buff[i] = ch;	308	active_read_buff[i] = ch;
309	i++;	309	i++;
310	i &= (ACTIVE_READ_BUFF_SIZE-1);	310	i &= (ACTIVE_READ_BUFF_SIZE-1);
311	active_read_buff[i]=0;	311	active_read_buff[i]=0;
312	}	312	}
313		313
314		314
315	static void active_read_key_pressed(uint8_t sc)	315	static void active_read_key_pressed(uint8_t sc)
316	{	316	{
317	char *map = sc_primary_map;	317	char *map = sc_primary_map;
318	char ascii = sc_primary_map[sc];	318	char ascii = sc_primary_map[sc];
319	bool shift, capslock;	319	bool shift, capslock;
320	bool letter = false;	320	bool letter = false;
321		321
322	/spinlock_lock(&keylock);/	322	/spinlock_lock(&keylock);/
323	switch (sc) {	323	switch (sc) {
324	case SC_LSHIFT:	324	case SC_LSHIFT:
325	case SC_RSHIFT:	325	case SC_RSHIFT:
326	keyflags \|= PRESSED_SHIFT;	326	keyflags \|= PRESSED_SHIFT;
327	break;	327	break;
328	case SC_CAPSLOCK:	328	case SC_CAPSLOCK:
329	keyflags \|= PRESSED_CAPSLOCK;	329	keyflags \|= PRESSED_CAPSLOCK;
330	break;	330	break;
331	case SC_SPEC_ESCAPE:	331	case SC_SPEC_ESCAPE:
332	break;	332	break;
333	case SC_LEFTARR:	333	case SC_LEFTARR:
334	active_read_buff_write(0x1b);	334	active_read_buff_write(0x1b);
335	active_read_buff_write(0x5b);	335	active_read_buff_write(0x5b);
336	active_read_buff_write(0x44);	336	active_read_buff_write(0x44);
337	break;	337	break;
338	case SC_RIGHTARR:	338	case SC_RIGHTARR:
339	active_read_buff_write(0x1b);	339	active_read_buff_write(0x1b);
340	active_read_buff_write(0x5b);	340	active_read_buff_write(0x5b);
341	active_read_buff_write(0x43);	341	active_read_buff_write(0x43);
342	break;	342	break;
343	case SC_UPARR:	343	case SC_UPARR:
344	active_read_buff_write(0x1b);	344	active_read_buff_write(0x1b);
345	active_read_buff_write(0x5b);	345	active_read_buff_write(0x5b);
346	active_read_buff_write(0x41);	346	active_read_buff_write(0x41);
347	break;	347	break;
348	case SC_DOWNARR:	348	case SC_DOWNARR:
349	active_read_buff_write(0x1b);	349	active_read_buff_write(0x1b);
350	active_read_buff_write(0x5b);	350	active_read_buff_write(0x5b);
351	active_read_buff_write(0x42);	351	active_read_buff_write(0x42);
352	break;	352	break;
353	case SC_HOME:	353	case SC_HOME:
354	active_read_buff_write(0x1b);	354	active_read_buff_write(0x1b);
355	active_read_buff_write(0x4f);	355	active_read_buff_write(0x4f);
356	active_read_buff_write(0x48);	356	active_read_buff_write(0x48);
357	break;	357	break;
358	case SC_END:	358	case SC_END:
359	active_read_buff_write(0x1b);	359	active_read_buff_write(0x1b);
360	active_read_buff_write(0x4f);	360	active_read_buff_write(0x4f);
361	active_read_buff_write(0x46);	361	active_read_buff_write(0x46);
362	break;	362	break;
363	case SC_DELETE:	363	case SC_DELETE:
364	active_read_buff_write(0x1b);	364	active_read_buff_write(0x1b);
365	active_read_buff_write(0x5b);	365	active_read_buff_write(0x5b);
366	active_read_buff_write(0x33);	366	active_read_buff_write(0x33);
367	active_read_buff_write(0x7e);	367	active_read_buff_write(0x7e);
368	break;	368	break;
369	default:	369	default:
370	letter = is_lower(ascii);	370	letter = is_lower(ascii);
371	capslock = (keyflags & PRESSED_CAPSLOCK) \|\| (lockflags & LOCKED_CAPSLOCK);	371	capslock = (keyflags & PRESSED_CAPSLOCK) \|\| (lockflags & LOCKED_CAPSLOCK);
372	shift = keyflags & PRESSED_SHIFT;	372	shift = keyflags & PRESSED_SHIFT;
373	if (letter && capslock)	373	if (letter && capslock)
374	shift = !shift;	374	shift = !shift;
375	if (shift)	375	if (shift)
376	map = sc_secondary_map;	376	map = sc_secondary_map;
377	active_read_buff_write(map[sc]);	377	active_read_buff_write(map[sc]);
378	break;	378	break;
379	}	379	}
380	/spinlock_unlock(&keylock);/	380	/spinlock_unlock(&keylock);/
381		381
382	}	382	}
383		383
384	static char key_read(chardev_t *d)	384	static char key_read(chardev_t *d)
385	{	385	{
386	char ch;	386	char ch;
387		387
388	while(!(ch = active_read_buff_read())) {	388	while(!(ch = active_read_buff_read())) {
389	uint8_t x;	389	uint8_t x;
390	while (!(i8042_status_read() & i8042_BUFFER_FULL_MASK))	390	while (!(i8042_status_read() & i8042_BUFFER_FULL_MASK))
391	;	391	;
392	x = i8042_data_read();	392	x = i8042_data_read();
393	if (x != IGNORE_CODE) {	393	if (x != IGNORE_CODE) {
394	if (x & KEY_RELEASE)	394	if (x & KEY_RELEASE)
395	key_released(x ^ KEY_RELEASE);	395	key_released(x ^ KEY_RELEASE);
396	else	396	else
397	active_read_key_pressed(x);	397	active_read_key_pressed(x);
398	}	398	}
399	}	399	}
400	return ch;	400	return ch;
401	}	401	}
402		402
403	/** Poll for key press and release events.	403	/** Poll for key press and release events.
404	*	404	*
405	* This function can be used to implement keyboard polling.	405	* This function can be used to implement keyboard polling.
406	*/	406	*/
407	void i8042_poll(void)	407	void i8042_poll(void)
408	{	408	{
409	uint8_t x;	409	uint8_t x;
410		410
411	while (((x = i8042_status_read() & i8042_BUFFER_FULL_MASK))) {	411	while (((x = i8042_status_read() & i8042_BUFFER_FULL_MASK))) {
412	x = i8042_data_read();	412	x = i8042_data_read();
413	if (x != IGNORE_CODE) {	413	if (x != IGNORE_CODE) {
414	if (x & KEY_RELEASE)	414	if (x & KEY_RELEASE)
415	key_released(x ^ KEY_RELEASE);	415	key_released(x ^ KEY_RELEASE);
416	else	416	else
417	key_pressed(x);	417	key_pressed(x);
418	}	418	}
419	}	419	}
420	}	420	}
421		421
422	/** @}	422	/** @}
423	*/	423	*/
424		424
425		425

Subversion Repositories HelenOS

(root)/trunk/kernel/genarch/src/kbd/key.c @ 2114 – Rev 1838 → 1841