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