/*
 * FILE NAME
 *	drivers/char/vr41xx_keyb.c
 *
 * BRIEF MODULE DESCRIPTION
 *	Keyboard driver for NEC VR4100 series Keyboard Interface Unit.
 *
 * Copyright (C) 1999 Bradley D. LaRonde
 * Copyright (C) 1999 Hiroshi Kawashima <kawashima@iname.com>
 * Copyright (C) 2000 Michael Klar <wyldfier@iname.com>
 * Copyright (C) 2002,2003 Yoichi Yuasa <yuasa@hh.iij4u.or.jp>
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 */
/*
 * Changes:
 *  version 1.0
 *  Yoichi Yuasa <yuasa@hh.iij4u.or.jp>  Mon, 25 Mar 2002
 *  -  Rewrote extensively because of 2.4.18.
 *
 *  version 1.1
 *  Yoichi Yuasa <yuasa@hh.iij4u.or.jp>  Wed,  9 Sep 200
 *  -  Added NEC VRC4173 KIU support.
 */
#include <linux/config.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/kbd_ll.h>
#ifdef CONFIG_PCI
#include <linux/pci.h>
#endif
#include <linux/pm.h>

#include <asm/addrspace.h>
#include <asm/cpu.h>
#include <asm/io.h>
#include <asm/param.h>
#include <asm/vr41xx/vr41xx.h>
#ifdef CONFIG_VRC4173
#include <asm/vr41xx/vrc4173.h>
#endif

#define KIU_BASE			KSEG1ADDR(0x0b000180)
#define MKIUINTREG			KSEG1ADDR(0x0b000092)

#define VRC4173_KIU_OFFSET		0x100
#define VRC4173_MKIUINTREG_OFFSET	0x072

#define KIUDAT0				0x00
#define KIUDAT1				0x02
#define KIUDAT2				0x04
#define KIUDAT3				0x06
#define KIUDAT4				0x08
#define KIUDAT5				0x0a
#define KIUDAT6				0x0c
#define KIUDAT7				0x0e
#define KIUSCANREP			0x10
 #define KIUSCANREP_KEYEN		0x8000
 #define KIUSCANREP_STPREP(x)		((x) << 4)
 #define KIUSCANREP_SCANSTP		0x0008
 #define KIUSCANREP_SCANSTART		0x0004
 #define KIUSCANREP_ATSTP		0x0002
 #define KIUSCANREP_ATSCAN		0x0001
#define KIUSCANS			0x12
 #define KIUSCANS_SCANNING		0x0003
 #define KIUSCANS_INTERVAL		0x0002
 #define KIUSCANS_WAITKEYIN		0x0001
 #define KIUSCANS_STOPPED		0x0000
#define KIUWKS				0x14
 #define KIUWKS_T3CNT			0x7c00
 #define KIUWKS_T3CNT_SHIFT		10
 #define KIUWKS_T2CNT			0x03e0
 #define KIUWKS_T2CNT_SHIFT		5
 #define KIUWKS_T1CNT			0x001f
 #define KIUWKS_T1CNT_SHIFT		0
 #define KIUWKS_CNT_USEC(x)		(((x) / 30) - 1)
#define KIUWKI				0x16
 #define KIUWKI_INTERVAL_USEC(x)	((x) / 30)
#define KIUINT				0x18
 #define KIUINT_KDATLOST		0x0004
 #define KIUINT_KDATRDY			0x0002
 #define KIUINT_SCANINT			0x0001
#define KIURST				0x1a
 #define KIURST_KIURST			0x0001
#define KIUGPEN				0x1c
 #define KIUGPEN_KGPEN(x)		((uint16_t)1 << (x))
#define SCANLINE			0x1e
 #define SCANLINE_DONTUSE		0x0003
 #define SCANLINE_8LINES		0x0002
 #define SCANLINE_10LINES		0x0001
 #define SCANLINE_12LINES		0x0000

static unsigned long kiu_base;
static unsigned long mkiuintreg;

#ifdef CONFIG_VRC4173
#define kiu_readw(offset)		vrc4173_inw(kiu_base + (offset))
#define kiu_writew(val, offset)		vrc4173_outw(val, kiu_base + (offset))
#define mkiuintreg_writew(val)		vrc4173_outw((val), mkiuintreg)
#else
#define kiu_readw(offset)		readw(kiu_base + (offset))
#define kiu_writew(val, offset)		writew(val, kiu_base + (offset))
#define mkiuintreg_writew(val)		writew((val), mkiuintreg)
#endif

#define KIU_CLOCK			0x0008

#ifdef CONFIG_VRC4173
#define KIU_IRQ				VRC4173_KIU_IRQ
#else
#define KIU_IRQ				SYSINT1_IRQ(7)
#endif

#define KEY_UP				0
#define KEY_DOWN			1

#define DEFAULT_KIUDAT_REGS		6
#define DEFAULT_DATA_NOT_REVERSED	0
#define DEFAULT_T3CNT			KIUWKS_CNT_USEC(200)
#define DEFAULT_T2CNT			KIUWKS_CNT_USEC(200)
#define DEFAULT_T1CNT			KIUWKS_CNT_USEC(200)
#define DEFAULT_SCAN_INTERVAL		KIUWKI_INTERVAL_USEC(30000)
#define DEFAULT_REPEAT_DELAY		HZ/4
#define DEFAULT_REPEAT_RATE		HZ/25

static char *kiu_driver_name = "Keyboard driver";
static char *kiu_driver_version = "1.1";
static char *kiu_driver_revdate = "2003-09-09";
static char *kiu_driver_device_name = "NEC VR4100 series KIU";

static unsigned char kiudat_regs = DEFAULT_KIUDAT_REGS;
static unsigned char data_reverse = DEFAULT_DATA_NOT_REVERSED;
static uint16_t scanlines = SCANLINE_12LINES;
static uint16_t t3cnt = DEFAULT_T3CNT;
static uint16_t t2cnt = DEFAULT_T2CNT;
static uint16_t t1cnt = DEFAULT_T1CNT;
static uint16_t scan_interval = DEFAULT_SCAN_INTERVAL;

static unsigned long repeat_delay = DEFAULT_REPEAT_DELAY;
static unsigned long repeat_rate = DEFAULT_REPEAT_RATE;

static int repeat_scancode = -1;
static unsigned long next_handle_time;

struct kiudat_t {
	uint32_t reg;
	uint16_t data;
};

static struct kiudat_t kiudat [8] = {
	{KIUDAT0, 0}, {KIUDAT1, 0},
	{KIUDAT2, 0}, {KIUDAT3, 0},
	{KIUDAT4, 0}, {KIUDAT5, 0},
	{KIUDAT6, 0}, {KIUDAT7, 0},
};

int kbd_setkeycode(unsigned int scancode, unsigned int keycode)
{
	return (scancode == keycode) ? 0 : -EINVAL;
}

int kbd_getkeycode(unsigned int scancode)
{
	return scancode;
}

int kbd_translate(unsigned char scancode, unsigned char *keycode, char raw_mode)
{
	*keycode = scancode;
	return 1;
}

char kbd_unexpected_up(unsigned char keycode)
{
	printk(KERN_WARNING "vr41xx_keyb: unexpected up, keycode 0x%02x\n", keycode);
	return 0x80;
}

void kbd_leds(unsigned char leds)
{
	return;
}

static inline void handle_kiudat(uint16_t data, uint16_t cmp_data, int scancode)
{
	uint16_t mask;
	int down, candidate_scancode = 0;

	for (mask = 0x0001; mask ; mask <<= 1) {
		if (cmp_data & mask) {
			down = data & mask ? KEY_DOWN : KEY_UP;
			if (down == KEY_DOWN) {
				repeat_scancode = scancode;
				next_handle_time = jiffies + repeat_delay;
			}
			else {
				if (repeat_scancode == scancode)
					repeat_scancode = -1;
			}
			handle_scancode(scancode, down);
		}
		if (data & mask) {
			candidate_scancode = scancode;
		}
		scancode++;
	}

	if ((repeat_scancode < 0) && (candidate_scancode > 0)) {
			repeat_scancode = candidate_scancode;
			next_handle_time = jiffies + repeat_delay;
	}
}

static inline void handle_kiu_event(void)
{
	struct kiudat_t *kiu = kiudat;
	uint16_t data, last_data, cmp_data;
	int i;

	for (i = 0; i < kiudat_regs; i++) {
		last_data = kiu->data;
		data = kiu_readw(kiu->reg);
		if (data_reverse)
			data = ~data;
		kiu->data = data;
		cmp_data = data ^ last_data;
		handle_kiudat(data, cmp_data, i * 16);
		kiu++;
	}

	if ((repeat_scancode >= 0) &&
	    (time_after_eq(jiffies, next_handle_time))) {
		handle_scancode(repeat_scancode, KEY_DOWN);
		next_handle_time = jiffies + repeat_rate;
	}
}

static void kiu_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
	uint16_t status;

	mkiuintreg_writew(0);

	status = kiu_readw(KIUINT);
	kiu_writew(KIUINT_KDATLOST | KIUINT_KDATRDY | KIUINT_SCANINT, KIUINT);

	if (status & KIUINT_KDATRDY)
		handle_kiu_event();

	mkiuintreg_writew(KIUINT_KDATLOST | KIUINT_KDATRDY);
}

#ifdef CONFIG_PM

static int pm_kiu_request(struct pm_dev *dev, pm_request_t rqst, void *data)
{
	switch (rqst) {
	case PM_SUSPEND:
		mkiuintreg_writew(KIUINT_SCANINT);
		break;
	case PM_RESUME:
		kiu_writew(KIUINT_KDATLOST | KIUINT_KDATRDY | KIUINT_SCANINT, KIUINT);
		mkiuintreg_writew(KIUINT_KDATLOST | KIUINT_KDATRDY, MKIUINTREG);
		break;
	}

	return 0;
}

#endif

void __devinit kbd_init_hw(void)
{
	uint16_t kiugpen = 0;
	int i;

	if (current_cpu_data.cputype == CPU_VR4111 ||
	    current_cpu_data.cputype == CPU_VR4121) {
		kiu_base = KIU_BASE;
		mkiuintreg = MKIUINTREG;
#if defined(CONFIG_PCI) && defined(CONFIG_VRC4173)
	} else if (current_cpu_data.cputype == CPU_VR4122 ||
	           current_cpu_data.cputype == CPU_VR4131) {
		struct pci_dev *dev;
		int found = 0;
		dev = pci_find_device(PCI_VENDOR_ID_NEC,
		                      PCI_DEVICE_ID_NEC_VRC4173, NULL);
		if (dev != NULL) {
			switch (scanlines) {
			case SCANLINE_8LINES:
				vrc4173_select_function(KIU8_SELECT);
				found = 1;
				break;
			case SCANLINE_10LINES:
				vrc4173_select_function(KIU10_SELECT);
				found = 1;
				break;
			case SCANLINE_12LINES:
				vrc4173_select_function(KIU12_SELECT);
				found = 1;
				break;
			default:
				break;
			}

			if (found != 0) {
				kiu_base = VRC4173_KIU_OFFSET;
				mkiuintreg = VRC4173_MKIUINTREG_OFFSET;
				vrc4173_clock_supply(VRC4173_KIU_CLOCK);
			}
		}
#endif
	}

	if (kiu_base == 0 || mkiuintreg == 0)
		return;

	printk(KERN_INFO "%s version %s (%s) for %s\n",
	       kiu_driver_name, kiu_driver_version,
	       kiu_driver_revdate, kiu_driver_device_name);

	mkiuintreg_writew(0);

	if (current_cpu_data.cputype == CPU_VR4111 ||
	    current_cpu_data.cputype == CPU_VR4121)
		vr41xx_clock_supply(KIU_CLOCK);

	kiu_writew(KIURST_KIURST, KIURST);

	for (i = 0; i < scanlines; i++)
		kiugpen &= ~(0x0001 << i);

	kiu_writew(kiugpen, KIUGPEN);
	kiu_writew(scanlines, SCANLINE);
	kiu_writew((t3cnt << KIUWKS_T3CNT_SHIFT) |
	           (t2cnt << KIUWKS_T2CNT_SHIFT) |
	           (t1cnt << KIUWKS_T1CNT_SHIFT), KIUWKS);
	kiu_writew(scan_interval, KIUWKI);
	kiu_writew(KIUINT_KDATLOST | KIUINT_KDATRDY | KIUINT_SCANINT, KIUINT);


	request_irq(KIU_IRQ, kiu_interrupt, 0, "keyboard", NULL);

	mkiuintreg_writew(KIUINT_KDATLOST | KIUINT_KDATRDY);
	kiu_writew(KIUSCANREP_KEYEN | KIUSCANREP_STPREP(1) |
	       KIUSCANREP_ATSTP | KIUSCANREP_ATSCAN, KIUSCANREP);

#ifdef CONFIG_PM
	pm_register(PM_SYS_DEV, PM_SYS_KBC, pm_kiu_request);
#endif
}

static int __devinit vr41xx_kbd_setup(char *options)
{
	char *this_opt;
	int num;

	if (!options || !*options)
		return 1;

	for (this_opt = strtok(options, ","); this_opt; this_opt = strtok(NULL, ",")) {
		if (!strncmp(this_opt, "regs:", 5)) {
			num = simple_strtoul(this_opt+5, NULL, 0);
			if (num == 6 || num == 8)
				kiudat_regs = num;
		} else if (!strncmp(this_opt, "lines:", 6)) {
			num = simple_strtoul(this_opt+6, NULL, 0);
			if (num == 8)
				scanlines = SCANLINE_8LINES;
			else if (num == 10)
				scanlines = SCANLINE_10LINES;
			else if (num == 12)
				scanlines = SCANLINE_12LINES;
		} else if (!strncmp(this_opt, "reverse:", 8)) {
			num = simple_strtoul(this_opt+8, NULL, 0);
			if (num == 0 || num == 1)
				data_reverse = num;
		} else if (!strncmp(this_opt, "t3cnt:", 6)) {
			num = simple_strtoul(this_opt+6, NULL, 0);
			if (num >= 60 && num <= 960)
				t3cnt = KIUWKS_CNT_USEC(num);
		} else if (!strncmp(this_opt, "t2cnt:", 6)) {
			num = simple_strtoul(this_opt+6, NULL, 0);
			if (num >= 60 && num <= 960)
				t2cnt = KIUWKS_CNT_USEC(num);
		} else if (!strncmp(this_opt, "t1cnt:", 6)) {
			num = simple_strtoul(this_opt+6, NULL, 0);
			if (num >= 60 && num <= 960)
				t1cnt = KIUWKS_CNT_USEC(num);
		} else if (!strncmp(this_opt, "interval:", 9)) {
			num = simple_strtoul(this_opt+9, NULL, 0);
			if (num >= 30 && num <= 30690)
				scan_interval = KIUWKI_INTERVAL_USEC(num);
		} else if (!strncmp(this_opt, "delay:", 6)) {
			num = simple_strtoul(this_opt+6, NULL, 0);
			if (num > 0 && num <= HZ)
				repeat_delay = num;
		} else if (!strncmp(this_opt, "rate:", 5)) {
			num = simple_strtoul(this_opt+5, NULL, 0);
			if (num > 0 && num <= HZ)
				repeat_rate = num;
		}
	}

	return 1;
}

__setup("vr41xx_kbd=", vr41xx_kbd_setup);