source: mainline/kernel/arch/ppc32/src/drivers/cuda.c@ f74bbaf

/*
 * Copyright (c) 2006 Martin Decky
 * 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 ppc32   
 * @{
 */
/** @file
 */

#include <arch/drivers/cuda.h>
#include <ipc/irq.h>
#include <arch/asm.h>
#include <console/console.h>
#include <console/chardev.h>
#include <arch/drivers/pic.h>
#include <sysinfo/sysinfo.h>
#include <interrupt.h>
#include <stdarg.h>

#define CUDA_IRQ 10
#define SPECIAL         '?'

#define PACKET_ADB  0x00
#define PACKET_CUDA 0x01

#define CUDA_POWERDOWN  0x0a
#define CUDA_RESET              0x11

#define RS 0x200
#define B (0 * RS)
#define A (1 * RS)
#define SR (10 * RS)
#define ACR (11 * RS)

#define SR_OUT 0x10
#define TACK 0x10
#define TIP 0x20


static volatile uint8_t *cuda = NULL;
static irq_t cuda_irq;          /**< Cuda's IRQ. */

static char lchars[0x80] = {
        'a',
        's',
        'd',
        'f',
        'h',
        'g',
        'z',
        'x',
        'c',
        'v', 
        SPECIAL,
        'b',
        'q',
        'w',
        'e',
        'r',
        'y',
        't',
        '1',
        '2',
        '3',
        '4',
        '6',
        '5',
        '=',
        '9',
        '7',
        '-',
        '8',
        '0',
        ']',
        'o',
        'u',
        '[',
        'i', 
        'p',
        '\n',    /* Enter */
        'l',
        'j',
        '\'',
        'k',
        ';',
        '\\',
        ',',
        '/',
        'n',
        'm',
        '.',
        '\t',    /* Tab */
        ' ',
        '`',
        '\b',    /* Backspace */
        SPECIAL,
        SPECIAL, /* Escape */
        SPECIAL, /* Ctrl */
        SPECIAL, /* Alt */
        SPECIAL, /* Shift */
        SPECIAL, /* Caps-Lock */
        SPECIAL, /* RAlt */
        SPECIAL, /* Left */
        SPECIAL, /* Right */
        SPECIAL, /* Down */
        SPECIAL, /* Up */
        SPECIAL, 
        SPECIAL,
        '.',     /* Keypad . */
        SPECIAL, 
        '*',     /* Keypad * */
        SPECIAL,
        '+',     /* Keypad + */
        SPECIAL,
        SPECIAL, /* NumLock */
        SPECIAL,
        SPECIAL,
        SPECIAL,
        '/',     /* Keypad / */
        '\n',    /* Keypad Enter */
        SPECIAL,
        '-',     /* Keypad - */
        SPECIAL,
        SPECIAL,
        SPECIAL,
        '0',     /* Keypad 0 */
        '1',     /* Keypad 1 */
        '2',     /* Keypad 2 */
        '3',     /* Keypad 3 */
        '4',     /* Keypad 4 */
        '5',     /* Keypad 5 */
        '6',     /* Keypad 6 */
        '7',     /* Keypad 7 */
        SPECIAL,
        '8',     /* Keypad 8 */
        '9',     /* Keypad 9 */
        SPECIAL,
        SPECIAL,
        SPECIAL,
        SPECIAL, /* F5 */
        SPECIAL, /* F6 */
        SPECIAL, /* F7 */
        SPECIAL, /* F3 */
        SPECIAL, /* F8 */
        SPECIAL, /* F9 */
        SPECIAL,
        SPECIAL, /* F11 */
        SPECIAL,
        SPECIAL, /* F13 */
        SPECIAL,
        SPECIAL, /* ScrollLock */
        SPECIAL,
        SPECIAL, /* F10 */
        SPECIAL,
        SPECIAL, /* F12 */
        SPECIAL,
        SPECIAL, /* Pause */
        SPECIAL, /* Insert */
        SPECIAL, /* Home */
        SPECIAL, /* PageUp */
        SPECIAL, /* Delete */
        SPECIAL, /* F4 */
        SPECIAL, /* End */
        SPECIAL, /* F2 */
        SPECIAL, /* PageDown */
        SPECIAL  /* F1 */
};


static void receive_packet(uint8_t *kind, index_t count, uint8_t data[])
{
        cuda[B] = cuda[B] & ~TIP;
        *kind = cuda[SR];
        
        index_t i;
        for (i = 0; i < count; i++)
                data[i] = cuda[SR];
        
        cuda[B] = cuda[B] | TIP;
}


/* Called from getc(). */
static void cuda_resume(chardev_t *d)
{
}


/* Called from getc(). */
static void cuda_suspend(chardev_t *d)
{
}


static char key_read(chardev_t *d)
{
        char ch;
        
        ch = 0;
        return ch;
}


static chardev_t kbrd;
static chardev_operations_t ops = {
        .suspend = cuda_suspend,
        .resume = cuda_resume,
        .read = key_read
};


int cuda_get_scancode(void)
{
        uint8_t kind;
        uint8_t data[4];
        
        receive_packet(&kind, 4, data);
        
        if ((kind == PACKET_ADB) && (data[0] == 0x40) && (data[1] == 0x2c))
                return data[2];
        
        return -1;
}

static void cuda_irq_handler(irq_t *irq, void *arg, ...)
{
        if ((irq->notif_cfg.notify) && (irq->notif_cfg.answerbox))
                ipc_irq_send_notif(irq);
        else {
                int scan_code = cuda_get_scancode();
                
                if (scan_code != -1) {
                        uint8_t scancode = (uint8_t) scan_code;
                        if ((scancode & 0x80) != 0x80)
                                chardev_push_character(&kbrd, lchars[scancode & 0x7f]);
                }
        }
}

static irq_ownership_t cuda_claim(void)
{
        return IRQ_ACCEPT;
}


/** Initialize keyboard and service interrupts using kernel routine */
void cuda_grab(void)
{
        ipl_t ipl = interrupts_disable();
        spinlock_lock(&cuda_irq.lock);
        cuda_irq.notif_cfg.notify = false;
        spinlock_unlock(&cuda_irq.lock);
        interrupts_restore(ipl);
}


/** Resume the former interrupt vector */
void cuda_release(void)
{
        ipl_t ipl = interrupts_disable();
        spinlock_lock(&cuda_irq.lock);
        if (cuda_irq.notif_cfg.answerbox)
                cuda_irq.notif_cfg.notify = true;
        spinlock_unlock(&cuda_irq.unlock);
        interrupts_restore(ipl);
}


void cuda_init(devno_t devno, uintptr_t base, size_t size)
{
        cuda = (uint8_t *) hw_map(base, size);  
        
        chardev_initialize("cuda_kbd", &kbrd, &ops);
        stdin = &kbrd;
        
        irq_initialize(&cuda_irq);
        cuda_irq.devno = devno;
        cuda_irq.inr = CUDA_IRQ;
        cuda_irq.claim = cuda_claim;
        cuda_irq.handler = cuda_irq_handler;
        irq_register(&cuda_irq);
        
        pic_enable_interrupt(CUDA_IRQ);

        sysinfo_set_item_val("kbd", NULL, true);
        sysinfo_set_item_val("kbd.devno", NULL, devno);
        sysinfo_set_item_val("kbd.inr", NULL, CUDA_IRQ);
        sysinfo_set_item_val("kbd.address.virtual", NULL, base);
}


static void send_packet(const uint8_t kind, count_t count, ...)
{
        index_t i;
        va_list va;
        
        cuda[B] = cuda[B] | TIP;
        cuda[ACR] = cuda[ACR] | SR_OUT;
        cuda[SR] = kind;
        cuda[B] = cuda[B] & ~TIP;
        
        va_start(va, count);
        
        for (i = 0; i < count; i++) {
                cuda[ACR] = cuda[ACR] | SR_OUT;
                cuda[SR] = va_arg(va, int);
                cuda[B] = cuda[B] | TACK;
        }
        
        va_end(va);
        
        cuda[B] = cuda[B] | TIP;
}


void cpu_halt(void) {
        asm volatile (
                "b 0\n"
        );
}

void arch_reboot(void) {
        send_packet(PACKET_CUDA, 1, CUDA_RESET);
        asm volatile (
                "b 0\n"
        );
}

/** @}
 */