Subversion Repositories HelenOS

Rev

Rev 1787 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1787 Rev 1838
Line 1... Line 1...
1 
/*
 1 
/*
2 
 * Copyright (C) 2001-2004 Jakub Jermar
 2 
 * Copyright (C) 2006 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:
Line 29... Line 29...
29 
/** @addtogroup genarch
 29 
/** @addtogroup genarch
30 
 * @{
 30 
 * @{
31 
 */
 31 
 */
32 
/**
 32 
/**
33 
 * @file
 33 
 * @file
34 
 * @brief   i8042 processor driver.
 34 
 * @brief   Scan codes for pc keyboards.
35 
 *
 - 
 
36 
 * It takes care of low-level keyboard functions.
 - 
 
37 
 */
 35 
 */
38 
 
 36 
 
39 
#include <genarch/i8042/i8042.h>
 37 
#include <genarch/i8042/i8042.h>
40 
#include <arch/drivers/i8042.h>
 - 
 
41 
#include <arch/interrupt.h>
 - 
 
42 
#include <cpu.h>
 - 
 
43 
#include <arch/asm.h>
 - 
 
44 
#include <arch.h>
 - 
 
45 
#include <synch/spinlock.h>
 - 
 
46 
#include <typedefs.h>
 - 
 
47 
#include <console/chardev.h>
 - 
 
48 
#include <console/console.h>
 - 
 
49 
#include <macros.h>
 - 
 
50 
#include <interrupt.h>
 - 
 
51 
 
 - 
 
52 
/* Keyboard commands. */
 - 
 
53 
#define KBD_ENABLE  0xf4
 - 
 
54 
#define KBD_DISABLE 0xf5
 - 
 
55 
#define KBD_ACK     0xfa
 - 
 
56 
 
 - 
 
57 
/*
 - 
 
58 
 * 60  Write 8042 Command Byte: next data byte written to port 60h is
 - 
 
59 
 *     placed in 8042 command register. Format:
 - 
 
60 
 *
 - 
 
61 
 *    |7|6|5|4|3|2|1|0|8042 Command Byte
 - 
 
62 
 *     | | | | | | | `---- 1=enable output register full interrupt
 - 
 
63 
 *     | | | | | | `----- should be 0
 - 
 
64 
 *     | | | | | `------ 1=set status register system, 0=clear
 - 
 
65 
 *     | | | | `------- 1=override keyboard inhibit, 0=allow inhibit
 - 
 
66 
 *     | | | `-------- disable keyboard I/O by driving clock line low
 - 
 
67 
 *     | | `--------- disable auxiliary device, drives clock line low
 - 
 
68 
 *     | `---------- IBM scancode translation 0=AT, 1=PC/XT
 - 
 
69 
 *     `----------- reserved, should be 0
 - 
 
70 
 */
 - 
 
71 
 
 - 
 
72 
#define i8042_SET_COMMAND   0x60
 - 
 
73 
#define i8042_COMMAND       0x69
 - 
 
74 
 
 - 
 
75 
#define i8042_BUFFER_FULL_MASK  0x01
 - 
 
76 
#define i8042_WAIT_MASK     0x02
 - 
 
77 
#define i8042_MOUSE_DATA        0x20
 - 
 
78 
 
 - 
 
79 
#define SPECIAL     '?'
 - 
 
80 
#define KEY_RELEASE 0x80
 - 
 
81 
 
 - 
 
82 
/**
 - 
 
83 
 * These codes read from i8042 data register are silently ignored.
 - 
 
84 
 */
 - 
 
85 
#define IGNORE_CODE 0x7f
 - 
 
86 
 
 - 
 
87 
static void key_released(uint8_t sc);
 - 
 
88 
static void key_pressed(uint8_t sc);
 - 
 
89 
static char key_read(chardev_t *d);
 - 
 
90 
 
 - 
 
91 
#define PRESSED_SHIFT       (1<<0)
 - 
 
92 
#define PRESSED_CAPSLOCK    (1<<1)
 - 
 
93 
#define LOCKED_CAPSLOCK     (1<<0)
 - 
 
94 
 
 - 
 
95 
#define ACTIVE_READ_BUFF_SIZE 16    /* Must be power of 2 */
 - 
 
96 
 
 - 
 
97 
static uint8_t active_read_buff[ACTIVE_READ_BUFF_SIZE];
 - 
 
98 
 
 - 
 
99 
SPINLOCK_INITIALIZE(keylock);       /**< keylock protects keyflags and lockflags. */
 - 
 
100 
static volatile int keyflags;       /**< Tracking of multiple keypresses. */
 - 
 
101 
static volatile int lockflags;      /**< Tracking of multiple keys lockings. */
 - 
 
102 
 
 - 
 
103 
static void i8042_suspend(chardev_t *);
 - 
 
104 
static void i8042_resume(chardev_t *);
 - 
 
105 
 
 - 
 
106 
static chardev_t kbrd;
 - 
 
107 
static chardev_operations_t ops = {
 - 
 
108 
    .suspend = i8042_suspend,
 - 
 
109 
    .resume = i8042_resume,
 - 
 
110 
    .read = key_read
 - 
 
111 
};
 - 
 
112 
 
 38 
 
113 
/** Primary meaning of scancodes. */
 39 
/** Primary meaning of scancodes. */
114 
static char sc_primary_map[] = {
 40 
char sc_primary_map[] = {
115 
    SPECIAL, /* 0x00 */
 41 
    SPECIAL, /* 0x00 */
116 
    SPECIAL, /* 0x01 - Esc */
 42 
    SPECIAL, /* 0x01 - Esc */
117 
    '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=',
 43 
    '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=',
118 
    '\b', /* 0x0e - Backspace */
 44 
    '\b', /* 0x0e - Backspace */
119 
    '\t', 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n',
 45 
    '\t', 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n',
Line 189... Line 115...
189 
    SPECIAL, /* 0x7e */
 115 
    SPECIAL, /* 0x7e */
190 
    SPECIAL, /* 0x7f */
 116 
    SPECIAL, /* 0x7f */
191 
};
 117 
};
192 
 
 118 
 
193 
/** Secondary meaning of scancodes. */
 119 
/** Secondary meaning of scancodes. */
194 
static char sc_secondary_map[] = {
 120 
char sc_secondary_map[] = {
195 
    SPECIAL, /* 0x00 */
 121 
    SPECIAL, /* 0x00 */
196 
    SPECIAL, /* 0x01 - Esc */
 122 
    SPECIAL, /* 0x01 - Esc */
197 
    '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+',
 123 
    '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+',
198 
    SPECIAL, /* 0x0e - Backspace */
 124 
    SPECIAL, /* 0x0e - Backspace */
199 
    '\t', 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '{', '}', '\n',
 125 
    '\t', 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '{', '}', '\n',
Line 268... Line 194...
268 
    SPECIAL, /* 0x7d */
 194 
    SPECIAL, /* 0x7d */
269 
    SPECIAL, /* 0x7e */
 195 
    SPECIAL, /* 0x7e */
270 
    SPECIAL, /* 0x7f */
 196 
    SPECIAL, /* 0x7f */
271 
};
 197 
};
272 
 
 198 
 
273 
static void i8042_interrupt(int n, istate_t *istate);
 - 
 
274 
static void i8042_wait(void);
 - 
 
275 
 
 - 
 
276 
static iroutine oldvector;
 - 
 
277 
/** Initialize keyboard and service interrupts using kernel routine */
 - 
 
278 
void i8042_grab(void)
 - 
 
279 
{
 - 
 
280 
    oldvector = exc_register(VECTOR_KBD, "i8042_interrupt", (iroutine) i8042_interrupt);
 - 
 
281 
    i8042_wait();
 - 
 
282 
    i8042_command_write(i8042_SET_COMMAND);
 - 
 
283 
    i8042_wait();
 - 
 
284 
    i8042_data_write(i8042_COMMAND);
 - 
 
285 
    i8042_wait();
 - 
 
286 
}
 - 
 
287 
/** Resume the former interrupt vector */
 - 
 
288 
void i8042_release(void)
 - 
 
289 
{
 - 
 
290 
    if (oldvector)
 - 
 
291 
        exc_register(VECTOR_KBD, "user_interrupt", oldvector);
 - 
 
292 
}
 - 
 
293 
 
 - 
 
294 
/** Initialize i8042. */
 - 
 
295 
void i8042_init(void)
 - 
 
296 
{
 - 
 
297 
    int i;
 - 
 
298 
 
 - 
 
299 
    i8042_grab();
 - 
 
300 
        /* Prevent user from accidentaly releasing calling i8042_resume
 - 
 
301 
     * and disabling keyboard
 - 
 
302 
     */
 - 
 
303 
    oldvector = NULL;
 - 
 
304 
 
 - 
 
305 
    trap_virtual_enable_irqs(1<<IRQ_KBD);
 - 
 
306 
    chardev_initialize("i8042_kbd", &kbrd, &ops);
 - 
 
307 
    stdin = &kbrd;
 - 
 
308 
 
 - 
 
309 
    /*
 - 
 
310 
     * Clear input buffer.
 - 
 
311 
     * Number of iterations is limited to prevent infinite looping.
 - 
 
312 
     */
 - 
 
313 
    for (i = 0; (i8042_status_read() & i8042_BUFFER_FULL_MASK) && i < 100; i++) {
 - 
 
314 
        i8042_data_read();
 - 
 
315 
    }  
 - 
 
316 
}
 - 
 
317 
 
 - 
 
318 
/** Process i8042 interrupt.
 - 
 
319 
 *
 - 
 
320 
 * @param n Interrupt vector.
 - 
 
321 
 * @param istate Interrupted state.
 - 
 
322 
 */
 - 
 
323 
void i8042_interrupt(int n, istate_t *istate)
 - 
 
324 
{
 - 
 
325 
    uint8_t x;
 - 
 
326 
    uint8_t status;
 - 
 
327 
 
 - 
 
328 
    while (((status=i8042_status_read()) & i8042_BUFFER_FULL_MASK)) {
 - 
 
329 
        x = i8042_data_read();
 - 
 
330 
 
 - 
 
331 
        if ((status & i8042_MOUSE_DATA))
 - 
 
332 
            continue;
 - 
 
333 
 
 - 
 
334 
        if (x & KEY_RELEASE)
 - 
 
335 
            key_released(x ^ KEY_RELEASE);
 - 
 
336 
        else
 - 
 
337 
            key_pressed(x);
 - 
 
338 
    }
 - 
 
339 
    trap_virtual_eoi();
 - 
 
340 
}
 - 
 
341 
 
 - 
 
342 
/** Wait until the controller reads its data. */
 - 
 
343 
void i8042_wait(void) {
 - 
 
344 
    while (i8042_status_read() & i8042_WAIT_MASK) {
 - 
 
345 
        /* wait */
 - 
 
346 
    }
 - 
 
347 
}
 - 
 
348 
 
 - 
 
349 
/** Process release of key.
 - 
 
350 
 *
 - 
 
351 
 * @param sc Scancode of the key being released.
 - 
 
352 
 */
 - 
 
353 
void key_released(uint8_t sc)
 - 
 
354 
{
 - 
 
355 
    spinlock_lock(&keylock);
 - 
 
356 
    switch (sc) {
 - 
 
357 
        case SC_LSHIFT:
 - 
 
358 
        case SC_RSHIFT:
 - 
 
359 
        keyflags &= ~PRESSED_SHIFT;
 - 
 
360 
        break;
 - 
 
361 
        case SC_CAPSLOCK:
 - 
 
362 
        keyflags &= ~PRESSED_CAPSLOCK;
 - 
 
363 
        if (lockflags & LOCKED_CAPSLOCK)
 - 
 
364 
            lockflags &= ~LOCKED_CAPSLOCK;
 - 
 
365 
        else
 - 
 
366 
            lockflags |= LOCKED_CAPSLOCK;
 - 
 
367 
        break;
 - 
 
368 
        default:
 - 
 
369 
        break;
 - 
 
370 
    }
 - 
 
371 
    spinlock_unlock(&keylock);
 - 
 
372 
}
 - 
 
373 
 
 - 
 
374 
/** Process keypress.
 - 
 
375 
 *
 - 
 
376 
 * @param sc Scancode of the key being pressed.
 - 
 
377 
 */
 - 
 
378 
void key_pressed(uint8_t sc)
 - 
 
379 
{
 - 
 
380 
    char *map = sc_primary_map;
 - 
 
381 
    char ascii = sc_primary_map[sc];
 - 
 
382 
    bool shift, capslock;
 - 
 
383 
    bool letter = false;
 - 
 
384 
 
 - 
 
385 
    spinlock_lock(&keylock);
 - 
 
386 
    switch (sc) {
 - 
 
387 
    case SC_LSHIFT:
 - 
 
388 
    case SC_RSHIFT:
 - 
 
389 
            keyflags |= PRESSED_SHIFT;
 - 
 
390 
        break;
 - 
 
391 
    case SC_CAPSLOCK:
 - 
 
392 
        keyflags |= PRESSED_CAPSLOCK;
 - 
 
393 
        break;
 - 
 
394 
    case SC_SPEC_ESCAPE:
 - 
 
395 
        break;
 - 
 
396 
    case SC_LEFTARR:
 - 
 
397 
        chardev_push_character(&kbrd, 0x1b);
 - 
 
398 
        chardev_push_character(&kbrd, 0x5b);
 - 
 
399 
        chardev_push_character(&kbrd, 0x44);
 - 
 
400 
        break;
 - 
 
401 
    case SC_RIGHTARR:
 - 
 
402 
        chardev_push_character(&kbrd, 0x1b);
 - 
 
403 
        chardev_push_character(&kbrd, 0x5b);
 - 
 
404 
        chardev_push_character(&kbrd, 0x43);
 - 
 
405 
        break;
 - 
 
406 
    case SC_UPARR:
 - 
 
407 
        chardev_push_character(&kbrd, 0x1b);
 - 
 
408 
        chardev_push_character(&kbrd, 0x5b);
 - 
 
409 
        chardev_push_character(&kbrd, 0x41);
 - 
 
410 
        break;
 - 
 
411 
    case SC_DOWNARR:
 - 
 
412 
        chardev_push_character(&kbrd, 0x1b);
 - 
 
413 
        chardev_push_character(&kbrd, 0x5b);
 - 
 
414 
        chardev_push_character(&kbrd, 0x42);
 - 
 
415 
        break;
 - 
 
416 
    case SC_HOME:
 - 
 
417 
        chardev_push_character(&kbrd, 0x1b);
 - 
 
418 
        chardev_push_character(&kbrd, 0x4f);
 - 
 
419 
        chardev_push_character(&kbrd, 0x48);
 - 
 
420 
        break;
 - 
 
421 
    case SC_END:
 - 
 
422 
        chardev_push_character(&kbrd, 0x1b);
 - 
 
423 
        chardev_push_character(&kbrd, 0x4f);
 - 
 
424 
        chardev_push_character(&kbrd, 0x46);
 - 
 
425 
        break;
 - 
 
426 
    case SC_DELETE:
 - 
 
427 
        chardev_push_character(&kbrd, 0x1b);
 - 
 
428 
        chardev_push_character(&kbrd, 0x5b);
 - 
 
429 
        chardev_push_character(&kbrd, 0x33);
 - 
 
430 
        chardev_push_character(&kbrd, 0x7e);
 - 
 
431 
        break;
 - 
 
432 
    default:
 - 
 
433 
            letter = is_lower(ascii);
 - 
 
434 
        capslock = (keyflags & PRESSED_CAPSLOCK) || (lockflags & LOCKED_CAPSLOCK);
 - 
 
435 
        shift = keyflags & PRESSED_SHIFT;
 - 
 
436 
        if (letter && capslock)
 - 
 
437 
            shift = !shift;
 - 
 
438 
        if (shift)
 - 
 
439 
            map = sc_secondary_map;
 - 
 
440 
        chardev_push_character(&kbrd, map[sc]);
 - 
 
441 
        break;
 - 
 
442 
    }
 - 
 
443 
    spinlock_unlock(&keylock);
 - 
 
444 
}
 - 
 
445 
 
 - 
 
446 
/* Called from getc(). */
 - 
 
447 
void i8042_resume(chardev_t *d)
 - 
 
448 
{
 - 
 
449 
}
 - 
 
450 
 
 - 
 
451 
/* Called from getc(). */
 - 
 
452 
void i8042_suspend(chardev_t *d)
 - 
 
453 
{
 - 
 
454 
}
 - 
 
455 
 
 - 
 
456 
static uint8_t active_read_buff_read(void)
 - 
 
457 
{
 - 
 
458 
    static int i=0;
 - 
 
459 
    i &= (ACTIVE_READ_BUFF_SIZE-1);
 - 
 
460 
    if(!active_read_buff[i]) {
 - 
 
461 
        return 0;
 - 
 
462 
    }
 - 
 
463 
    return active_read_buff[i++];
 - 
 
464 
}
 - 
 
465 
 
 - 
 
466 
static void active_read_buff_write(uint8_t ch)
 - 
 
467 
{
 - 
 
468 
    static int i=0;
 - 
 
469 
    active_read_buff[i] = ch;
 - 
 
470 
    i++;
 - 
 
471 
    i &= (ACTIVE_READ_BUFF_SIZE-1);
 - 
 
472 
    active_read_buff[i]=0;
 - 
 
473 
}
 - 
 
474 
 
 - 
 
475 
 
 - 
 
476 
static void active_read_key_pressed(uint8_t sc)
 - 
 
477 
{
 - 
 
478 
    char *map = sc_primary_map;
 - 
 
479 
    char ascii = sc_primary_map[sc];
 - 
 
480 
    bool shift, capslock;
 - 
 
481 
    bool letter = false;
 - 
 
482 
 
 - 
 
483 
    /*spinlock_lock(&keylock);*/
 - 
 
484 
    switch (sc) {
 - 
 
485 
    case SC_LSHIFT:
 - 
 
486 
    case SC_RSHIFT:
 - 
 
487 
            keyflags |= PRESSED_SHIFT;
 - 
 
488 
        break;
 - 
 
489 
    case SC_CAPSLOCK:
 - 
 
490 
        keyflags |= PRESSED_CAPSLOCK;
 - 
 
491 
        break;
 - 
 
492 
    case SC_SPEC_ESCAPE:
 - 
 
493 
        break;
 - 
 
494 
    case SC_LEFTARR:
 - 
 
495 
        active_read_buff_write(0x1b);
 - 
 
496 
        active_read_buff_write(0x5b);
 - 
 
497 
        active_read_buff_write(0x44);
 - 
 
498 
        break;
 - 
 
499 
    case SC_RIGHTARR:
 - 
 
500 
        active_read_buff_write(0x1b);
 - 
 
501 
        active_read_buff_write(0x5b);
 - 
 
502 
        active_read_buff_write(0x43);
 - 
 
503 
        break;
 - 
 
504 
    case SC_UPARR:
 - 
 
505 
        active_read_buff_write(0x1b);
 - 
 
506 
        active_read_buff_write(0x5b);
 - 
 
507 
        active_read_buff_write(0x41);
 - 
 
508 
        break;
 - 
 
509 
    case SC_DOWNARR:
 - 
 
510 
        active_read_buff_write(0x1b);
 - 
 
511 
        active_read_buff_write(0x5b);
 - 
 
512 
        active_read_buff_write(0x42);
 - 
 
513 
        break;
 - 
 
514 
    case SC_HOME:
 - 
 
515 
        active_read_buff_write(0x1b);
 - 
 
516 
        active_read_buff_write(0x4f);
 - 
 
517 
        active_read_buff_write(0x48);
 - 
 
518 
        break;
 - 
 
519 
    case SC_END:
 - 
 
520 
        active_read_buff_write(0x1b);
 - 
 
521 
        active_read_buff_write(0x4f);
 - 
 
522 
        active_read_buff_write(0x46);
 - 
 
523 
        break;
 - 
 
524 
    case SC_DELETE:
 - 
 
525 
        active_read_buff_write(0x1b);
 - 
 
526 
        active_read_buff_write(0x5b);
 - 
 
527 
        active_read_buff_write(0x33);
 - 
 
528 
        active_read_buff_write(0x7e);
 - 
 
529 
        break;
 - 
 
530 
    default:
 - 
 
531 
            letter = is_lower(ascii);
 - 
 
532 
        capslock = (keyflags & PRESSED_CAPSLOCK) || (lockflags & LOCKED_CAPSLOCK);
 - 
 
533 
        shift = keyflags & PRESSED_SHIFT;
 - 
 
534 
        if (letter && capslock)
 - 
 
535 
            shift = !shift;
 - 
 
536 
        if (shift)
 - 
 
537 
            map = sc_secondary_map;
 - 
 
538 
        active_read_buff_write(map[sc]);
 - 
 
539 
        break;
 - 
 
540 
    }
 - 
 
541 
    /*spinlock_unlock(&keylock);*/
 - 
 
542 
 
 - 
 
543 
}
 - 
 
544 
 
 - 
 
545 
static char key_read(chardev_t *d)
 - 
 
546 
{
 - 
 
547 
    char ch;   
 - 
 
548 
 
 - 
 
549 
    while(!(ch = active_read_buff_read())) {
 - 
 
550 
        uint8_t x;
 - 
 
551 
        while (!(i8042_status_read() & i8042_BUFFER_FULL_MASK))
 - 
 
552 
            ;
 - 
 
553 
        x = i8042_data_read();
 - 
 
554 
        if (x != IGNORE_CODE) {
 - 
 
555 
            if (x & KEY_RELEASE)
 - 
 
556 
                key_released(x ^ KEY_RELEASE);
 - 
 
557 
            else
 - 
 
558 
                active_read_key_pressed(x);
 - 
 
559 
        }
 - 
 
560 
    }
 - 
 
561 
    return ch;
 - 
 
562 
}
 - 
 
563 
 
 - 
 
564 
/** Poll for key press and release events.
 - 
 
565 
 *
 - 
 
566 
 * This function can be used to implement keyboard polling.
 - 
 
567 
 */
 - 
 
568 
void i8042_poll(void)
 - 
 
569 
{
 - 
 
570 
    uint8_t x;
 - 
 
571 
 
 - 
 
572 
    while (((x = i8042_status_read() & i8042_BUFFER_FULL_MASK))) {
 - 
 
573 
        x = i8042_data_read();
 - 
 
574 
        if (x != IGNORE_CODE) {
 - 
 
575 
            if (x & KEY_RELEASE)
 - 
 
576 
                key_released(x ^ KEY_RELEASE);
 - 
 
577 
            else
 - 
 
578 
                key_pressed(x);
 - 
 
579 
        }
 - 
 
580 
    }
 - 
 
581 
}
 - 
 
582 
 
 - 
 
583 
/** @}
 199 
/** @}
584 
 */
 200 
 */
585 
 
 -