/*
 * 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 <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 SPECIAL		'?'

#define PACKET_ADB  0x00
#define PACKET_CUDA 0x01

#define CUDA_POWERDOWN 0x0a

#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 iroutine vector;


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 */
};


void send_packet(const uint8_t kind, index_t count, ...);


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(int n, istate_t *istate)
{
	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]);
	}
}


/** Initialize keyboard and service interrupts using kernel routine */
void cuda_grab(void)
{
	vector = int_register(CUDA_IRQ, "cuda", cuda_irq);
}


/** Resume the former interrupt vector */
void cuda_release(void)
{
	if (vector)
		int_register(CUDA_IRQ, "user_interrupt", vector);
}


void cuda_init(uintptr_t base, size_t size)
{
	cuda = (uint8_t *) hw_map(base, size);
	
	int_register(CUDA_IRQ, "cuda", cuda_irq);
	pic_enable_interrupt(CUDA_IRQ);
	
	chardev_initialize("cuda_kbd", &kbrd, &ops);
	stdin = &kbrd;
	
	sysinfo_set_item_val("cuda", NULL, true);
	sysinfo_set_item_val("cuda.irq", NULL, CUDA_IRQ);
}


void send_packet(const uint8_t kind, index_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) {
#ifdef CONFIG_POWEROFF
	send_packet(PACKET_CUDA, 1, CUDA_POWERDOWN);
#endif
	asm volatile (
		"b 0\n"
	);
}

/** @}
 */