Subversion Repositories openrisc

//==========================================================================
//
//        kbd_support.c
//
//        Cirrus Logic EDB7xxx eval board ASCII keyboard support functions
//
//==========================================================================
// ####ECOSGPLCOPYRIGHTBEGIN####                                            
// -------------------------------------------                              
// This file is part of eCos, the Embedded Configurable Operating System.   
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
//
// eCos is free software; you can redistribute it and/or modify it under    
// the terms of the GNU General Public License as published by the Free     
// Software Foundation; either version 2 or (at your option) any later      
// version.                                                                 
//
// eCos is distributed in the hope that it will be useful, but WITHOUT      
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or    
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License    
// for more details.                                                        
//
// You should have received a copy of the GNU General Public License        
// along with eCos; if not, write to the Free Software Foundation, Inc.,    
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            
//
// As a special exception, if other files instantiate templates or use      
// macros or inline functions from this file, or you compile this file      
// and link it with other works to produce a work based on this file,       
// this file does not by itself cause the resulting work to be covered by   
// the GNU General Public License. However the source code for this file    
// must still be made available in accordance with section (3) of the GNU   
// General Public License v2.                                               
//
// This exception does not invalidate any other reasons why a work based    
// on this file might be covered by the GNU General Public License.         
// -------------------------------------------                              
// ####ECOSGPLCOPYRIGHTEND####                                              
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s):     gthomas
// Contributors:  gthomas
// Date:          1999-05-15
// Description:   Functions used to support ASCII keyboard
//####DESCRIPTIONEND####
 
static char kbd_server_stack[STACK_SIZE];
static cyg_thread kbd_server_thread_data;
static cyg_handle_t kbd_server_thread_handle;
 
static cyg_interrupt kbd_interrupt;
static cyg_handle_t  kbd_interrupt_handle;
 
static cyg_mbox      kbd_events_mbox;
static cyg_handle_t  kbd_events_mbox_handle;
static cyg_sem_t     kbd_sem;
 
static cyg_uint8 col_state[8];
static cyg_uint8 ext_state[8];
 
static void
kbd_delay(void)
{
    volatile int i;
    for (i = 0;  i < 250;  i++) ;
}
 
static void
kbd_scan(void)
{
    int i;
    cyg_uint8 port_data, ext_data;
    // Turn off drive (de-select) all columns
    *(volatile cyg_uint32 *)SYSCON1 = (*(volatile cyg_uint32 *)SYSCON1 & ~SYSCON1_KBD_CTL) |
        SYSCON1_KBD_LOW;
    for (i = 0;  i < 8;  i++) {
        // Select column 'i'
        *(volatile cyg_uint32 *)SYSCON1 = (*(volatile cyg_uint32 *)SYSCON1 & ~SYSCON1_KBD_CTL) |
            SYSCON1_KBD_COL(i);
        // Small pause to let the wires charge up :-)
        kbd_delay();
        // Grab the data
        col_state[i] = port_data = *(volatile cyg_uint8 *)PADR;
        ext_state[i] = ext_data = *(volatile cyg_uint8 *)KBD_PORT;
        // De-Select column 'i'
        *(volatile cyg_uint32 *)SYSCON1 = (*(volatile cyg_uint32 *)SYSCON1 & ~SYSCON1_KBD_CTL) |
            SYSCON1_KBD_TRISTATE;
        // Allow line to go slack
        kbd_delay();
    }
    // Turn on drive (select) all columns - necessary to see interrupts
    *(volatile cyg_uint32 *)SYSCON1 = (*(volatile cyg_uint32 *)SYSCON1 & ~SYSCON1_KBD_CTL) |
        SYSCON1_KBD_HIGH;
}
 
static cyg_uint8     kbd_state[128];      // Known state of each key
static cyg_uint8     kbd_new_state[128];  // Current state of each key
 
// Row #1
#define KBD_Escape     0x00
#define KBD_F1         0x01
#define KBD_F2         0x02
#define KBD_F3         0x03
#define KBD_F4         0x04
#define KBD_F5         0x05
#define KBD_F6         0x06
#define KBD_F7         0x07
#define KBD_F8         0x08
#define KBD_F9         0x09
#define KBD_F10        0x0A
#define KBD_NumLock    0x0B
#define KBD_SysReq     0x0C
#define KBD_ScrlLock   0x0D
#define KBD_Break      0x0E
// Row #2
#define KBD_1          0x10
#define KBD_2          0x11
#define KBD_3          0x12
#define KBD_4          0x13
#define KBD_5          0x14
#define KBD_6          0x15
#define KBD_7          0x16
#define KBD_8          0x17
#define KBD_9          0x18
#define KBD_0          0x19
#define KBD_Hyphen     0x1A
#define KBD_Equals     0x1B
#define KBD_BackSpace  0x1C
#define KBD_Home       0x1D
// Row #3
#define KBD_Tab        0x20
#define KBD_Q          0x21
#define KBD_W          0x22
#define KBD_E          0x23
#define KBD_R          0x24
#define KBD_T          0x25
#define KBD_Y          0x26
#define KBD_U          0x27
#define KBD_I          0x28
#define KBD_O          0x29
#define KBD_P          0x2A
#define KBD_LeftBrkt   0x2B
#define KBD_RightBrkt  0x2C
#define KBD_BackSlash  0x2D
#define KBD_PageUp     0x2E
// Row #4
#define KBD_CapsLock   0x30
#define KBD_A          0x31
#define KBD_S          0x32
#define KBD_D          0x33
#define KBD_F          0x34
#define KBD_G          0x35
#define KBD_H          0x36
#define KBD_J          0x37
#define KBD_K          0x38
#define KBD_L          0x39
#define KBD_SemiColon  0x3A
#define KBD_Quote      0x3B
#define KBD_Enter      0x3C
#define KBD_PageDown   0x3D
// Row #5
#define KBD_LeftShift  0x40
#define KBD_Z          0x41
#define KBD_X          0x42
#define KBD_C          0x43
#define KBD_V          0x44
#define KBD_B          0x45
#define KBD_N          0x46
#define KBD_M          0x47
#define KBD_Comma      0x48
#define KBD_Period     0x49
#define KBD_Slash      0x4A
#define KBD_RightShift 0x4B
#define KBD_UpArrow    0x4C
#define KBD_End        0x4D
// Row #6
#define KBD_Ctrl       0x50
#define KBD_Function   0x51
#define KBD_LeftAlt    0x52
#define KBD_Accent     0x53
#define KBD_Space      0x54
#define KBD_RightAlt   0x55
#define KBD_Ins        0x56
#define KBD_Del        0x57
#define KBD_LeftArrow  0x58
#define KBD_DownArrow  0x59
#define KBD_RightArrow 0x5A
 
#define KBD_Press      0x80  // Event has this bit when the key is pressed
#define KBD_Empty      0xFF
 
// Map column, bit -> keycode
static cyg_uint32    kbd_map[8][16] = {
    // Column #0
    {KBD_Escape,    KBD_1,          KBD_Tab,        KBD_CapsLock,
     KBD_BackSlash, KBD_Space,      KBD_LeftArrow,  KBD_UpArrow,
     KBD_DownArrow, KBD_RightArrow, KBD_LeftShift,  KBD_Ctrl, 
     KBD_Function,  KBD_LeftAlt,    KBD_RightAlt,   KBD_RightShift },
    // Column #1
    {KBD_F5,        KBD_6,          KBD_T,          KBD_G,  
     KBD_B,         KBD_Slash,      KBD_SemiColon,  KBD_P,  
     KBD_Hyphen,    KBD_F10,        KBD_Empty,      KBD_Empty,
     KBD_Empty,     KBD_Empty,      KBD_Empty,      KBD_Empty     },
    // Column #2
    {KBD_F4,        KBD_5,          KBD_R,          KBD_F,  
     KBD_V,         KBD_Del,        KBD_Quote,      KBD_LeftBrkt,  
     KBD_Equals,    KBD_NumLock,    KBD_Empty,      KBD_Empty,
     KBD_Empty,     KBD_Empty,      KBD_Empty,      KBD_Empty },
    // Column #3
    {KBD_F3,        KBD_4,          KBD_E,          KBD_D,  
     KBD_C,         KBD_Ins,        KBD_Empty,      KBD_RightBrkt,  
     KBD_BackSpace, KBD_SysReq,     KBD_Empty,      KBD_Empty,
     KBD_Empty,     KBD_Empty,      KBD_Empty,      KBD_Empty },
    // Column #4
    {KBD_F2,        KBD_3,          KBD_W,          KBD_S,  
     KBD_X,         KBD_Empty,      KBD_Enter,      KBD_Empty,
     KBD_Empty,     KBD_ScrlLock,   KBD_Empty,      KBD_Empty,
     KBD_Empty,     KBD_Empty,      KBD_Empty,      KBD_Empty },
    // Column #5
    {KBD_F1,        KBD_2,          KBD_Q,          KBD_A,  
     KBD_Z,         KBD_End,        KBD_PageDown,   KBD_PageUp,
     KBD_Home,      KBD_Break,      KBD_Empty,      KBD_Empty,
     KBD_Empty,     KBD_Empty,      KBD_Empty,      KBD_Empty },
    // Column #6
    {KBD_F6,        KBD_7,          KBD_Y,          KBD_H,  
     KBD_N,         KBD_Period,     KBD_L,          KBD_O,  
     KBD_0,         KBD_F9,         KBD_Empty,      KBD_Empty,
     KBD_Empty,     KBD_Empty,      KBD_Empty,      KBD_Empty },
    // Column #7
    {KBD_F7,        KBD_8,          KBD_U,          KBD_J,  
     KBD_M,         KBD_Comma,      KBD_K,          KBD_I,  
     KBD_9,         KBD_F8,         KBD_Empty,      KBD_Empty,
     KBD_Empty,     KBD_Empty,      KBD_Empty,      KBD_Empty },
};
 
static cyg_uint8 kbd_chars[96] = {
    /* 0x00 - 0x0F */
    0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0x10 - 0x1F */
     '1',  '2',  '3',  '4',  '5',  '6',  '7',  '8',  '9',  '0',  '-',  '=', 0x08, 0x00, 0x00, 0x00,
    /* 0x20 - 0x2F */
    '\t',  'q',  'w',  'e',  'r',  't',  'y',  'u',  'i',  'o',  'p',  '[',  ']', '\\', 0x00, 0x00,
    /* 0x30 - 0x3F */
    0x00,  'a',  's',  'd',  'f',  'g',  'h',  'j',  'k',  'l',  ';', '\'', 0x0D, 0x00, 0x00, 0x00,
    /* 0x40 - 0x4F */
    0x00,  'z',  'x',  'c',  'v',  'b',  'n',  'm',  ',',  '.',  '/', 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0x50 - 0x5F */
    0x00, 0x00, 0x00, 0x00,  ' ', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
 
static cyg_uint8 kbd_shifted_chars[96] = {
    /* 0x00 - 0x0F */
    '\b', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0x10 - 0x1F */
     '!',  '@',  '#',  '$',  '%',  '^',  '&',  '*',  '(',  ')',  '_',  '+', 0x08, 0x00, 0x00, 0x00,
    /* 0x20 - 0x2F */
    '\t',  'Q',  'W',  'E',  'R',  'T',  'Y',  'U',  'I',  'O',  'P',  '{',  '}',  '|', 0x00, 0x00,
    /* 0x30 - 0x3F */
    0x00,  'A',  'S',  'D',  'F',  'G',  'H',  'J',  'K',  'L',  ':',  '"', 0x0D, 0x00, 0x00, 0x00,
    /* 0x40 - 0x4F */
    0x00,  'Z',  'X',  'C',  'V',  'B',  'N',  'M',  '<',  '>',  '?', 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0x50 - 0x5F */
    0x00, 0x00, 0x00, 0x00,  ' ', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
 
// This ISR is called when the keyboard interrupt occurs
static int
keyboard_isr(cyg_vector_t vector, cyg_addrword_t data, HAL_SavedRegisters *regs)
{
    cyg_drv_interrupt_mask(CYGNUM_HAL_INTERRUPT_KBDINT);
    return (CYG_ISR_HANDLED|CYG_ISR_CALL_DSR);  // Run the DSR
}
 
// This DSR handles the keyboard [logical] processing
static void
keyboard_dsr(cyg_vector_t vector, cyg_ucount32 count, cyg_addrword_t data)
{
    // Tell the keyboard processing thread to give it a shot
    cyg_semaphore_post(&kbd_sem);
}
 
static void
kbd_server(cyg_addrword_t p)
{
    int col, bit, key, event, timeout;
    diag_printf("KBD server here\n");
    while (TRUE) {
        cyg_semaphore_wait(&kbd_sem);
        // As long as keys are pressed, scan and update
        timeout = 0;
        while (TRUE) {
            // Wait for 20ms - time to debounce keyboard
            cyg_thread_delay(2);
            // Scan keyboard
            kbd_scan();
            // Reset state
            for (key = 0;  key < sizeof(kbd_new_state);  key++) {
                kbd_new_state[key] = 0;
            }
            // Check state of all keys and send events for those that change
            for (col = 0;  col < 8;  col++) {
                for (bit = 0;  bit < 8;  bit++) {
                    if (col_state[col] & (1<<bit)) {
                        key = kbd_map[col][bit];
                        if (key != KBD_Empty) {
                            kbd_new_state[key] = 1;
                        }
                    }
                    if (ext_state[col] & (1<<bit)) {
                        key = kbd_map[col][bit+8];
                        if (key != KBD_Empty) {
                            kbd_new_state[key] = 1;
                        }
                    }
                }
            }
            // Compare new and old (known) states, generate events for changes
            // Send events for modifier keys first.
            for (key = 0;  key < sizeof(kbd_new_state);  key++) {
                if (kbd_state[key] != kbd_new_state[key]) {
                    event = 0xFF;
                    switch (key) {
                    case KBD_LeftShift:
                    case KBD_RightShift:
                    case KBD_Ctrl:
                    case KBD_LeftAlt:
                    case KBD_RightAlt:
                    case KBD_Function:
                    case KBD_CapsLock:
                        if (kbd_state[key]) {
                            // Key going up
                            event = key;
                        } else {
                            // Key going down
                            event = key + KBD_Press;
                        }
                        kbd_state[key] = kbd_new_state[key];
                    }
                    if (event != 0xFF) {
                        if (!cyg_mbox_tryput(kbd_events_mbox_handle, (void *)event)) {
                            diag_printf("KBD event lost: %x\n", event);
                        }
                    }
                }
            }
            // First key up events
            for (key = 0;  key < sizeof(kbd_new_state);  key++) {
                if (kbd_state[key] != kbd_new_state[key]) {
                    if (kbd_state[key]) {
                        // Key going up
                        event = key;
                    } else {
                        // Key going down
                        event = key + KBD_Press;
                    }
                    if (!cyg_mbox_tryput(kbd_events_mbox_handle, (void *)event)) {
                        diag_printf("KBD event lost: %x\n", event);
                    }
                }
                kbd_state[key] = kbd_new_state[key];
            }
            // Clear interrupt (true when keys are pressed)
            cyg_drv_interrupt_acknowledge(CYGNUM_HAL_INTERRUPT_KBDINT);
#if 0
            if (*(volatile cyg_uint32 *)INTSR2 & INTSR2_KBDINT) {
                timeout = 0;
            } else if (++timeout == 5) {
                // No keys for 100ms
                break;
            }
#endif
        }
        // Allow interrupts to happen again
        cyg_drv_interrupt_acknowledge(CYGNUM_HAL_INTERRUPT_KBDINT);
        cyg_drv_interrupt_unmask(CYGNUM_HAL_INTERRUPT_KBDINT);
    }
}
 
void
kbd_init(void)
{
    // Initialize environment, setup interrupt handler
    cyg_drv_interrupt_create(CYGNUM_HAL_INTERRUPT_KBDINT,
                             99,                     // Priority - what goes here?
                             0,                      //  Data item passed to interrupt handler
                             (cyg_ISR_t *)keyboard_isr,
                             (cyg_DSR_t *)keyboard_dsr,
                             &kbd_interrupt_handle,
                             &kbd_interrupt);
    cyg_drv_interrupt_attach(kbd_interrupt_handle);
    cyg_drv_interrupt_acknowledge(CYGNUM_HAL_INTERRUPT_KBDINT);
    cyg_drv_interrupt_unmask(CYGNUM_HAL_INTERRUPT_KBDINT);
    // Set up the mbox for keyboard data
    cyg_mbox_create(&kbd_events_mbox_handle, &kbd_events_mbox);
    // This semaphore is set when there is a keypress
    cyg_semaphore_init(&kbd_sem, 0);  
    // Create a thread whose job it is to de-bounce the keyboard and
    // actually process the input, turning it into a series of events
    cyg_thread_create(10,                           // Priority - just a number
                      kbd_server,                   // entry
                      0,                            // initial parameter
                      "KBD_server",                 // Name
                      &kbd_server_stack[0],         // Stack
                      STACK_SIZE,                   // Size
                      &kbd_server_thread_handle,    // Handle
                      &kbd_server_thread_data       // Thread data structure
            );
    cyg_thread_resume(kbd_server_thread_handle);  // Start it
}
 
#define MOD_Shift    0x40
#define MOD_Ctrl     0x20
#define MOD_CapsLock 0x10
static cyg_uint32    kbd_modifiers;
 
cyg_uint8 
kbd_getc(void)
{
    cyg_uint8 ch;
    cyg_uint32 kbd_event;
    while (TRUE) {
        kbd_event = (cyg_uint32)cyg_mbox_get(kbd_events_mbox_handle);
        switch (kbd_event & 0x7F) {
        case KBD_LeftShift:
        case KBD_RightShift:
            if (kbd_event & KBD_Press) {
                kbd_modifiers |= MOD_Shift;
            } else {
                kbd_modifiers &= ~MOD_Shift;
            }
            break;
        case KBD_Ctrl:
            if (kbd_event & KBD_Press) {
                kbd_modifiers |= MOD_Ctrl;
            } else {
                kbd_modifiers &= ~MOD_Ctrl;
            }
            break;
        case KBD_CapsLock:
            if (kbd_event & KBD_Press) {                
                kbd_modifiers ^= MOD_CapsLock;
            }
            break;
        case KBD_LeftAlt:
        case KBD_RightAlt:
        case KBD_Function:
        default:
        }
        // Return character [if one has arrived]
        if (kbd_event & KBD_Press) {
            if (kbd_modifiers & (MOD_Shift|MOD_CapsLock)) {
                ch = kbd_shifted_chars[kbd_event & 0x7F];
            } else {
                ch = kbd_chars[kbd_event & 0x7F];
            }
            if (kbd_modifiers & MOD_Ctrl) {
                ch &= 0x1F;
            }
            if (ch) {
                return (ch);
            }
        }
    }
}