Skip to content

L
linux
Commit dd68fd71 authored by David S. Miller's avatar David S. Miller
Browse files
Options

SPARC: Move of move to generic input layer for kbd/mouse.

parent 40b4cd90
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 2229 deletions
drivers/sbus/char/Makefile
View file @ dd68fd71
......@@ -8,13 +8,10 @@
#
export-objs := bbc_i2c.o
obj-y := sunkbdmap.o
vfc-objs := vfc_dev.o vfc_i2c.o
bbc-objs := bbc_i2c.o bbc_envctrl.o
obj-$(CONFIG_PCI) += pcikbd.o
obj-$(CONFIG_ENVCTRL) += envctrl.o
obj-$(CONFIG_DISPLAY7SEG) += display7seg.o
obj-$(CONFIG_WATCHDOG_CP1XXX) += cpwatchdog.o
......
drivers/sbus/char/pcikbd.c deleted 100644 → 0
View file @ 40b4cd90
/* $Id: pcikbd.c,v 1.61 2001/08/18 09:40:46 davem Exp $
* pcikbd.c: Ultra/AX PC keyboard support.
*
* Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
* JavaStation support by Pete A. Zaitcev.
*
* This code is mainly put together from various places in
* drivers/char, please refer to these sources for credits
* to the original authors.
*/
#include <linux/config.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/random.h>
#include <linux/miscdevice.h>
#include <linux/kbd_ll.h>
#include <linux/kbd_kern.h>
#include <linux/vt_kern.h>
#include <linux/delay.h>
#include <linux/spinlock.h>
#include <linux/smp_lock.h>
#include <linux/init.h>
#include <asm/ebus.h>
#if defined(CONFIG_USB) && defined(CONFIG_SPARC64)
#include <asm/isa.h>
#endif
#include <asm/oplib.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/uaccess.h>
/*
* Different platforms provide different permutations of names.
* AXi - kb_ps2, kdmouse.
* MrCoffee - keyboard, mouse.
* Espresso - keyboard, kdmouse.
*/
#define PCI_KB_NAME1 "kb_ps2"
#define PCI_KB_NAME2 "keyboard"
#define PCI_MS_NAME1 "kdmouse"
#define PCI_MS_NAME2 "mouse"
#include "pcikbd.h"
#include "sunserial.h"
#ifndef __sparc_v9__
static int pcikbd_mrcoffee = 0;
#else
#define pcikbd_mrcoffee 0
extern void (*prom_keyboard)(void);
#endif
static unsigned long pcikbd_iobase = 0;
static unsigned int pcikbd_irq = 0;
/* used only by send_data - set by keyboard_interrupt */
static volatile unsigned char reply_expected = 0;
static volatile unsigned char acknowledge = 0;
static volatile unsigned char resend = 0;
static spinlock_t pcikbd_lock = SPIN_LOCK_UNLOCKED;
static void pcikbd_write(int address, int data);
static int pcikbd_wait_for_input(void);
unsigned char pckbd_read_mask = KBD_STAT_OBF;
extern int pcikbd_init(void);
extern void pci_compute_shiftstate(void);
extern int pci_setkeycode(unsigned int, unsigned int);
extern int pci_getkeycode(unsigned int);
extern void pci_setledstate(struct kbd_struct *, unsigned int);
extern unsigned char pci_getledstate(void);
#define pcikbd_inb(x) inb(x)
#define pcikbd_outb(v,x) outb(v,x)
/* Wait for keyboard controller input buffer to drain.
* Must be invoked under the pcikbd_lock.
*/
static void kb_wait(void)
{
unsigned long timeout = 250;
do {
if(!(pcikbd_inb(pcikbd_iobase + KBD_STATUS_REG) & KBD_STAT_IBF))
return;
mdelay(1);
} while (--timeout);
}
/*
* Translation of escaped scancodes to keycodes.
* This is now user-settable.
* The keycodes 1-88,96-111,119 are fairly standard, and
* should probably not be changed - changing might confuse X.
* X also interprets scancode 0x5d (KEY_Begin).
*
* For 1-88 keycode equals scancode.
*/
#define E0_KPENTER 96
#define E0_RCTRL 97
#define E0_KPSLASH 98
#define E0_PRSCR 99
#define E0_RALT 100
#define E0_BREAK 101 /* (control-pause) */
#define E0_HOME 102
#define E0_UP 103
#define E0_PGUP 104
#define E0_LEFT 105
#define E0_RIGHT 106
#define E0_END 107
#define E0_DOWN 108
#define E0_PGDN 109
#define E0_INS 110
#define E0_DEL 111
#define E1_PAUSE 119
/*
* The keycodes below are randomly located in 89-95,112-118,120-127.
* They could be thrown away (and all occurrences below replaced by 0),
* but that would force many users to use the `setkeycodes' utility, where
* they needed not before. It does not matter that there are duplicates, as
* long as no duplication occurs for any single keyboard.
*/
#define SC_LIM 89
#define FOCUS_PF1 85 /* actual code! */
#define FOCUS_PF2 89
#define FOCUS_PF3 90
#define FOCUS_PF4 91
#define FOCUS_PF5 92
#define FOCUS_PF6 93
#define FOCUS_PF7 94
#define FOCUS_PF8 95
#define FOCUS_PF9 120
#define FOCUS_PF10 121
#define FOCUS_PF11 122
#define FOCUS_PF12 123
#define JAP_86 124
/* tfj@olivia.ping.dk:
* The four keys are located over the numeric keypad, and are
* labelled A1-A4. It's an rc930 keyboard, from
* Regnecentralen/RC International, Now ICL.
* Scancodes: 59, 5a, 5b, 5c.
*/
#define RGN1 124
#define RGN2 125
#define RGN3 126
#define RGN4 127
static unsigned char high_keys[128 - SC_LIM] = {
RGN1, RGN2, RGN3, RGN4, 0, 0, 0, /* 0x59-0x5f */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x60-0x67 */
0, 0, 0, 0, 0, FOCUS_PF11, 0, FOCUS_PF12, /* 0x68-0x6f */
0, 0, 0, FOCUS_PF2, FOCUS_PF9, 0, 0, FOCUS_PF3, /* 0x70-0x77 */
FOCUS_PF4, FOCUS_PF5, FOCUS_PF6, FOCUS_PF7, /* 0x78-0x7b */
FOCUS_PF8, JAP_86, FOCUS_PF10, 0 /* 0x7c-0x7f */
};
/* BTC */
#define E0_MACRO 112
/* LK450 */
#define E0_F13 113
#define E0_F14 114
#define E0_HELP 115
#define E0_DO 116
#define E0_F17 117
#define E0_KPMINPLUS 118
/*
* My OmniKey generates e0 4c for the "OMNI" key and the
* right alt key does nada. [kkoller@nyx10.cs.du.edu]
*/
#define E0_OK 124
/*
* New microsoft keyboard is rumoured to have
* e0 5b (left window button), e0 5c (right window button),
* e0 5d (menu button). [or: LBANNER, RBANNER, RMENU]
* [or: Windows_L, Windows_R, TaskMan]
*/
#define E0_MSLW 125
#define E0_MSRW 126
#define E0_MSTM 127
static unsigned char e0_keys[128] = {
0, 0, 0, 0, 0, 0, 0, 0, /* 0x00-0x07 */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x08-0x0f */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x10-0x17 */
0, 0, 0, 0, E0_KPENTER, E0_RCTRL, 0, 0, /* 0x18-0x1f */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x20-0x27 */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x28-0x2f */
0, 0, 0, 0, 0, E0_KPSLASH, 0, E0_PRSCR, /* 0x30-0x37 */
E0_RALT, 0, 0, 0, 0, E0_F13, E0_F14, E0_HELP, /* 0x38-0x3f */
E0_DO, E0_F17, 0, 0, 0, 0, E0_BREAK, E0_HOME, /* 0x40-0x47 */
E0_UP, E0_PGUP, 0, E0_LEFT, E0_OK, E0_RIGHT, E0_KPMINPLUS, E0_END,/* 0x48-0x4f */
E0_DOWN, E0_PGDN, E0_INS, E0_DEL, 0, 0, 0, 0, /* 0x50-0x57 */
0, 0, 0, E0_MSLW, E0_MSRW, E0_MSTM, 0, 0, /* 0x58-0x5f */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x60-0x67 */
0, 0, 0, 0, 0, 0, 0, E0_MACRO, /* 0x68-0x6f */
0, 0, 0, 0, 0, 0, 0, 0, /* 0x70-0x77 */
0, 0, 0, 0, 0, 0, 0, 0 /* 0x78-0x7f */
};
/* Simple translation table for the SysRq keys */
#ifdef CONFIG_MAGIC_SYSRQ
unsigned char pcikbd_sysrq_xlate[128] =
"\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
"qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
"dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
"bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
"\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
"230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
"\r\000/"; /* 0x60 - 0x6f */
#endif
#define DEFAULT_KEYB_REP_DELAY 250
#define DEFAULT_KEYB_REP_RATE 30 /* cps */
static struct kbd_repeat kbdrate = {
DEFAULT_KEYB_REP_DELAY,
DEFAULT_KEYB_REP_RATE
};
static unsigned char parse_kbd_rate(struct kbd_repeat *r);
static int write_kbd_rate(unsigned char r);
int pcikbd_setkeycode(unsigned int scancode, unsigned int keycode)
{
if(scancode < SC_LIM || scancode > 255 || keycode > 127)
return -EINVAL;
if(scancode < 128)
high_keys[scancode - SC_LIM] = keycode;
else
e0_keys[scancode - 128] = keycode;
return 0;
}
int pcikbd_getkeycode(unsigned int scancode)
{
return
(scancode < SC_LIM || scancode > 255) ? -EINVAL :
(scancode < 128) ? high_keys[scancode - SC_LIM] :
e0_keys[scancode - 128];
}
static int do_acknowledge(unsigned char scancode)
{
if(reply_expected) {
if(scancode == KBD_REPLY_ACK) {
acknowledge = 1;
reply_expected = 0;
return 0;
} else if(scancode == KBD_REPLY_RESEND) {
resend = 1;
reply_expected = 0;
return 0;
}
}
return 1;
}
#ifdef __sparc_v9__
static void pcikbd_enter_prom(void)
{
pcikbd_write(KBD_DATA_REG, KBD_CMD_DISABLE);
if(pcikbd_wait_for_input() != KBD_REPLY_ACK)
printk("Prom Enter: Disable keyboard: no ACK\n");
/* Disable PC scancode translation */
pcikbd_write(KBD_CNTL_REG, KBD_CCMD_WRITE_MODE);
pcikbd_write(KBD_DATA_REG, KBD_MODE_SYS);
pcikbd_write(KBD_DATA_REG, KBD_CMD_ENABLE);
if (pcikbd_wait_for_input() != KBD_REPLY_ACK)
printk("Prom Enter: Enable Keyboard: no ACK\n");
}
#endif
static void ctrl_break(void)
{
extern int stop_a_enabled;
unsigned long timeout;
int status, data;
int mode;
if (!stop_a_enabled)
return;
pcikbd_write(KBD_DATA_REG, KBD_CMD_DISABLE);
if(pcikbd_wait_for_input() != KBD_REPLY_ACK)
printk("Prom Enter: Disable keyboard: no ACK\n");
/* Save current mode register settings */
pcikbd_write(KBD_CNTL_REG, KBD_CCMD_READ_MODE);
if ((mode = pcikbd_wait_for_input()) == -1)
printk("Prom Enter: Read Mode: no ACK\n");
/* Disable PC scancode translation */
pcikbd_write(KBD_CNTL_REG, KBD_CCMD_WRITE_MODE);
pcikbd_write(KBD_DATA_REG, mode & ~(KBD_MODE_KCC));
pcikbd_write(KBD_DATA_REG, KBD_CMD_ENABLE);
if (pcikbd_wait_for_input() != KBD_REPLY_ACK)
printk("Prom Enter: Enable Keyboard: no ACK\n");
/* Drop into OBP.
* Note that we must flush the user windows
* first before giving up control.
*/
flush_user_windows();
prom_cmdline();
/* Read prom's key up event (use short timeout) */
do {
timeout = 10;
do {
mdelay(1);
status = pcikbd_inb(pcikbd_iobase + KBD_STATUS_REG);
if (!(status & KBD_STAT_OBF))
continue;
data = pcikbd_inb(pcikbd_iobase + KBD_DATA_REG);
if (status & (KBD_STAT_GTO | KBD_STAT_PERR))
continue;
break;
} while (--timeout > 0);
} while (timeout > 0);
/* Reenable PC scancode translation */
pcikbd_write(KBD_DATA_REG, KBD_CMD_DISABLE);
if(pcikbd_wait_for_input() != KBD_REPLY_ACK)
printk("Prom Leave: Disable keyboard: no ACK\n");
pcikbd_write(KBD_CNTL_REG, KBD_CCMD_WRITE_MODE);
pcikbd_write(KBD_DATA_REG, mode);
pcikbd_write(KBD_DATA_REG, KBD_CMD_ENABLE);
if (pcikbd_wait_for_input() != KBD_REPLY_ACK)
printk("Prom Leave: Enable Keyboard: no ACK\n");
/* Reset keyboard rate */
write_kbd_rate(parse_kbd_rate(&kbdrate));
}
int pcikbd_translate(unsigned char scancode, unsigned char *keycode,
char raw_mode)
{
static int prev_scancode = 0;
int down = scancode & 0x80 ? 0 : 1;
if (scancode == 0xe0 || scancode == 0xe1) {
prev_scancode = scancode;
return 0;
}
if (scancode == 0x00 || scancode == 0xff) {
prev_scancode = 0;
return 0;
}
scancode &= 0x7f;
if(prev_scancode) {
if(prev_scancode != 0xe0) {
if(prev_scancode == 0xe1 && scancode == 0x1d) {
prev_scancode = 0x100;
return 0;
} else if(prev_scancode == 0x100 && scancode == 0x45) {
*keycode = E1_PAUSE;
prev_scancode = 0;
} else {
prev_scancode = 0;
return 0;
}
} else {
prev_scancode = 0;
if(scancode == 0x2a || scancode == 0x36)
return 0;
if(e0_keys[scancode])
*keycode = e0_keys[scancode];
else
return 0;
}
} else if(scancode >= SC_LIM) {
*keycode = high_keys[scancode - SC_LIM];
if(!*keycode)
return 0;
} else
*keycode = scancode;
if (*keycode == E0_BREAK) {
if (down)
return 0;
/* Handle ctrl-break event */
ctrl_break();
/* Send ctrl up event to the keyboard driver */
*keycode = 0x1d;
}
return 1;
}
char pcikbd_unexpected_up(unsigned char keycode)
{
if(keycode >= SC_LIM || keycode == 85)
return 0;
else
return 0200;
}
static void
pcikbd_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
unsigned long flags;
unsigned char status;
spin_lock_irqsave(&pcikbd_lock, flags);
kbd_pt_regs = regs;
status = pcikbd_inb(pcikbd_iobase + KBD_STATUS_REG);
do {
unsigned char scancode;
if(status & pckbd_read_mask & KBD_STAT_MOUSE_OBF)
break;
scancode = pcikbd_inb(pcikbd_iobase + KBD_DATA_REG);
if((status & KBD_STAT_OBF) && do_acknowledge(scancode))
handle_scancode(scancode, !(scancode & 0x80));
status = pcikbd_inb(pcikbd_iobase + KBD_STATUS_REG);
} while(status & KBD_STAT_OBF);
tasklet_schedule(&keyboard_tasklet);
spin_unlock_irqrestore(&pcikbd_lock, flags);
}
static int send_data(unsigned char data)
{
int retries = 3;
unsigned long flags;
do {
unsigned long timeout = 1000;
spin_lock_irqsave(&pcikbd_lock, flags);
kb_wait();
acknowledge = 0;
resend = 0;
reply_expected = 1;
pcikbd_outb(data, pcikbd_iobase + KBD_DATA_REG);
spin_unlock_irqrestore(&pcikbd_lock, flags);
do {
if (acknowledge)
return 1;
if (resend)
break;
mdelay(1);
} while (--timeout);
if (timeout == 0)
break;
} while (retries-- > 0);
return 0;
}
void pcikbd_leds(unsigned char leds)
{
if (!pcikbd_iobase)
return;
if (!send_data(KBD_CMD_SET_LEDS) || !send_data(leds))
send_data(KBD_CMD_ENABLE);
}
static unsigned char parse_kbd_rate(struct kbd_repeat *r)
{
static struct r2v {
int rate;
unsigned char val;
} kbd_rates[]={ { 5, 0x14 },
{ 7, 0x10 },
{ 10, 0x0c },
{ 15, 0x08 },
{ 20, 0x04 },
{ 25, 0x02 },
{ 30, 0x00 } };
static struct d2v {
int delay;
unsigned char val;
} kbd_delays[]={ { 250, 0 },
{ 500, 1 },
{ 750, 2 },
{ 1000, 3 } };
int rate = 0, delay = 0;
if (r != NULL) {
int i, new_rate = 30, new_delay = 250;
if (r->rate <= 0)
r->rate = kbdrate.rate;
if (r->delay <= 0)
r->delay = kbdrate.delay;
for (i = 0; i < sizeof(kbd_rates) / sizeof(struct r2v); i++) {
if (kbd_rates[i].rate == r->rate) {
new_rate = kbd_rates[i].rate;
rate = kbd_rates[i].val;
break;
}
}
for (i=0; i < sizeof(kbd_delays) / sizeof(struct d2v); i++) {
if (kbd_delays[i].delay == r->delay) {
new_delay = kbd_delays[i].delay;
delay = kbd_delays[i].val;
break;
}
}
r->rate = new_rate;
r->delay = new_delay;
}
return (delay << 5) | rate;
}
static int write_kbd_rate(unsigned char r)
{
if (!send_data(KBD_CMD_SET_RATE) || !send_data(r)) {
/* re-enable kbd if any errors */
send_data(KBD_CMD_ENABLE);
return 0;
}
return 1;
}
static int pcikbd_rate(struct kbd_repeat *rep)
{
unsigned char r;
struct kbd_repeat old_rep;
if (rep == NULL)
return -EINVAL;
r = parse_kbd_rate(rep);
memcpy(&old_rep, &kbdrate, sizeof(struct kbd_repeat));
if (write_kbd_rate(r)) {
memcpy(&kbdrate,rep,sizeof(struct kbd_repeat));
memcpy(rep,&old_rep,sizeof(struct kbd_repeat));
return 0;
}
return -EIO;
}
static int pcikbd_wait_for_input(void)
{
int status, data;
unsigned long timeout = 1000;
do {
mdelay(1);
status = pcikbd_inb(pcikbd_iobase + KBD_STATUS_REG);
if (!(status & KBD_STAT_OBF))
continue;
data = pcikbd_inb(pcikbd_iobase + KBD_DATA_REG);
if (status & (KBD_STAT_GTO | KBD_STAT_PERR))
continue;
return (data & 0xff);
} while (--timeout > 0);
return -1;
}
static void pcikbd_write(int address, int data)
{
int status;
do {
status = pcikbd_inb(pcikbd_iobase + KBD_STATUS_REG);
} while (status & KBD_STAT_IBF);
pcikbd_outb(data, pcikbd_iobase + address);
}
#ifdef __sparc_v9__
static unsigned long pcibeep_iobase = 0;
/* Timer routine to turn off the beep after the interval expires. */
static void pcikbd_kd_nosound(unsigned long __unused)
{
if (pcibeep_iobase & 0x2UL)
outb(0, pcibeep_iobase);
else
outl(0, pcibeep_iobase);
}
/*
* Initiate a keyboard beep. If the frequency is zero, then we stop
* the beep. Any other frequency will start a monotone beep. The beep
* will be stopped by a timer after "ticks" jiffies. If ticks is 0,
* then we do not start a timer.
*/
static void pcikbd_kd_mksound(unsigned int hz, unsigned int ticks)
{
unsigned long flags;
static struct timer_list sound_timer = { function: pcikbd_kd_nosound };
save_flags(flags); cli();
del_timer(&sound_timer);
if (hz) {
if (pcibeep_iobase & 0x2UL)
outb(1, pcibeep_iobase);
else
outl(1, pcibeep_iobase);
if (ticks) {
sound_timer.expires = jiffies + ticks;
add_timer(&sound_timer);
}
} else {
if (pcibeep_iobase & 0x2UL)
outb(0, pcibeep_iobase);
else
outl(0, pcibeep_iobase);
}
restore_flags(flags);
}
#if defined(CONFIG_USB) && defined(CONFIG_SPARC64)
static void isa_kd_nosound(unsigned long __unused)
{
/* disable counter 2 */
outb(inb(pcibeep_iobase + 0x61)&0xFC, pcibeep_iobase + 0x61);
return;
}
static void isa_kd_mksound(unsigned int hz, unsigned int ticks)
{
static struct timer_list sound_timer = { function: isa_kd_nosound };
unsigned int count = 0;
unsigned long flags;
if (hz > 20 && hz < 32767)
count = 1193180 / hz;
save_flags(flags);
cli();
del_timer(&sound_timer);
if (count) {
/* enable counter 2 */
outb(inb(pcibeep_iobase + 0x61)|3, pcibeep_iobase + 0x61);
/* set command for counter 2, 2 byte write */
outb(0xB6, pcibeep_iobase + 0x43);
/* select desired HZ */
outb(count & 0xff, pcibeep_iobase + 0x42);
outb((count >> 8) & 0xff, pcibeep_iobase + 0x42);
if (ticks) {
sound_timer.expires = jiffies+ticks;
add_timer(&sound_timer);
}
} else
isa_kd_nosound(0);
restore_flags(flags);
return;
}
#endif
#endif
static void nop_kd_mksound(unsigned int hz, unsigned int ticks)
{
}
extern void (*kd_mksound)(unsigned int hz, unsigned int ticks);
static char * __init do_pcikbd_init_hw(void)
{
while(pcikbd_wait_for_input() != -1)
;
pcikbd_write(KBD_CNTL_REG, KBD_CCMD_SELF_TEST);
if(pcikbd_wait_for_input() != 0x55)
return "Keyboard failed self test";
pcikbd_write(KBD_CNTL_REG, KBD_CCMD_KBD_TEST);
if(pcikbd_wait_for_input() != 0x00)
return "Keyboard interface failed self test";
pcikbd_write(KBD_CNTL_REG, KBD_CCMD_KBD_ENABLE);
pcikbd_write(KBD_DATA_REG, KBD_CMD_RESET);
if(pcikbd_wait_for_input() != KBD_REPLY_ACK)
return "Keyboard reset failed, no ACK";
if(pcikbd_wait_for_input() != KBD_REPLY_POR)
return "Keyboard reset failed, no ACK";
pcikbd_write(KBD_DATA_REG, KBD_CMD_DISABLE);
if(pcikbd_wait_for_input() != KBD_REPLY_ACK)
return "Disable keyboard: no ACK";
pcikbd_write(KBD_CNTL_REG, KBD_CCMD_WRITE_MODE);
pcikbd_write(KBD_DATA_REG,
(KBD_MODE_KBD_INT | KBD_MODE_SYS |
KBD_MODE_DISABLE_MOUSE | KBD_MODE_KCC));
pcikbd_write(KBD_DATA_REG, KBD_CMD_ENABLE);
if(pcikbd_wait_for_input() != KBD_REPLY_ACK)
return "Enable keyboard: no ACK";
write_kbd_rate(parse_kbd_rate(&kbdrate));
return NULL; /* success */
}
void __init pcikbd_init_hw(void)
{
struct linux_ebus *ebus;
struct linux_ebus_device *edev;
struct linux_ebus_child *child;
char *msg;
if (pcikbd_mrcoffee) {
if ((pcikbd_iobase = (unsigned long) ioremap(0x71300060, 8)) == 0) {
prom_printf("pcikbd_init_hw: cannot map\n");
return;
}
pcikbd_irq = 13 | 0x20;
if (request_irq(pcikbd_irq, &pcikbd_interrupt,
SA_SHIRQ, "keyboard", (void *)pcikbd_iobase)) {
printk("8042: cannot register IRQ %x\n", pcikbd_irq);
return;
}
printk("8042(kbd): iobase[%x] irq[%x]\n",
(unsigned)pcikbd_iobase, pcikbd_irq);
} else {
for_each_ebus(ebus) {
for_each_ebusdev(edev, ebus) {
if(!strcmp(edev->prom_name, "8042")) {
for_each_edevchild(edev, child) {
if (strcmp(child->prom_name, PCI_KB_NAME1) == 0 ||
strcmp(child->prom_name, PCI_KB_NAME2) == 0)
goto found;
}
}
}
}
#ifdef CONFIG_USB
/* We are being called for the sake of USB keyboard
* state initialization. So we should check for beeper
* device in this case.
*/
edev = 0;
for_each_ebus(ebus) {
for_each_ebusdev(edev, ebus) {
if (!strcmp(edev->prom_name, "beep")) {
pcibeep_iobase = edev->resource[0].start;
kd_mksound = pcikbd_kd_mksound;
printk("8042(speaker): iobase[%016lx]\n", pcibeep_iobase);
return;
}
}
}
#ifdef CONFIG_SPARC64
/* Maybe we have one inside the ALI southbridge? */
{
struct isa_bridge *isa_br;
struct isa_device *isa_dev;
for_each_isa(isa_br) {
for_each_isadev(isa_dev, isa_br) {
/* This is a hack, the 'dma' device node has
* the base of the I/O port space for that PBM
* as it's resource, so we use that. -DaveM
*/
if (!strcmp(isa_dev->prom_name, "dma")) {
pcibeep_iobase = isa_dev->resource.start;
kd_mksound = isa_kd_mksound;
printk("isa(speaker): iobase[%016lx:%016lx]\n",
pcibeep_iobase + 0x42,
pcibeep_iobase + 0x61);
return;
}
}
}
}
#endif
/* No beeper found, ok complain. */
#endif
printk("pcikbd_init_hw: no 8042 found\n");
return;
found:
pcikbd_iobase = child->resource[0].start;
pcikbd_irq = child->irqs[0];
if (request_irq(pcikbd_irq, &pcikbd_interrupt,
SA_SHIRQ, "keyboard", (void *)pcikbd_iobase)) {
printk("8042: cannot register IRQ %s\n",
__irq_itoa(pcikbd_irq));
return;
}
printk("8042(kbd) at 0x%lx (irq %s)\n", pcikbd_iobase,
__irq_itoa(pcikbd_irq));
}
kd_mksound = nop_kd_mksound;
kbd_rate = pcikbd_rate;
#ifdef __sparc_v9__
edev = 0;
for_each_ebus(ebus) {
for_each_ebusdev(edev, ebus) {
if(!strcmp(edev->prom_name, "beeper"))
goto ebus_done;
}
}
ebus_done:
/*
* XXX: my 3.1.3 PROM does not give me the beeper node for the audio
* auxio register, though I know it is there... (ecd)
*
* JavaStations appear not to have beeper. --zaitcev
*/
if (!edev)
pcibeep_iobase = (pcikbd_iobase & ~(0xffffff)) | 0x722000;
else
pcibeep_iobase = edev->resource[0].start;
kd_mksound = pcikbd_kd_mksound;
printk("8042(speaker): iobase[%016lx]%s\n", pcibeep_iobase,
edev ? "" : " (forced)");
prom_keyboard = pcikbd_enter_prom;
#endif
disable_irq(pcikbd_irq);
msg = do_pcikbd_init_hw();
enable_irq(pcikbd_irq);
if(msg)
printk("8042: keyboard init failure [%s]\n", msg);
}
/*
* Here begins the Mouse Driver.
*/
static unsigned long pcimouse_iobase = 0;
static unsigned int pcimouse_irq;
#define AUX_BUF_SIZE 2048
struct aux_queue {
unsigned long head;
unsigned long tail;
wait_queue_head_t proc_list;
struct fasync_struct *fasync;
unsigned char buf[AUX_BUF_SIZE];
};
static struct aux_queue *queue;
static int aux_count = 0;
static int aux_present = 0;
#define pcimouse_inb(x) inb(x)
#define pcimouse_outb(v,x) outb(v,x)
/*
* Shared subroutines
*/
static unsigned int get_from_queue(void)
{
unsigned int result;
unsigned long flags;
spin_lock_irqsave(&pcikbd_lock, flags);
result = queue->buf[queue->tail];
queue->tail = (queue->tail + 1) & (AUX_BUF_SIZE-1);
spin_unlock_irqrestore(&pcikbd_lock, flags);
return result;
}
static inline int queue_empty(void)
{
return queue->head == queue->tail;
}
static int aux_fasync(int fd, struct file *filp, int on)
{
int retval;
retval = fasync_helper(fd, filp, on, &queue->fasync);
if (retval < 0)
return retval;
return 0;
}
/*
* PS/2 Aux Device
*/
#define AUX_INTS_OFF (KBD_MODE_KCC | KBD_MODE_DISABLE_MOUSE | \
KBD_MODE_SYS | KBD_MODE_KBD_INT)
#define AUX_INTS_ON (KBD_MODE_KCC | KBD_MODE_SYS | \
KBD_MODE_MOUSE_INT | KBD_MODE_KBD_INT)
#define MAX_RETRIES 60 /* some aux operations take long time*/
/*
* Status polling
*/
static int poll_aux_status(void)
{
int retries = 0;
while ((pcimouse_inb(pcimouse_iobase + KBD_STATUS_REG) &
(KBD_STAT_IBF | KBD_STAT_OBF)) && retries < MAX_RETRIES) {
if ((pcimouse_inb(pcimouse_iobase + KBD_STATUS_REG) & AUX_STAT_OBF)
== AUX_STAT_OBF)
pcimouse_inb(pcimouse_iobase + KBD_DATA_REG);
mdelay(5);
retries++;
}
return (retries < MAX_RETRIES);
}
/*
* Write to aux device
*/
static void aux_write_dev(int val)
{
poll_aux_status();
pcimouse_outb(KBD_CCMD_WRITE_MOUSE, pcimouse_iobase + KBD_CNTL_REG);/* Write magic cookie */
poll_aux_status();
pcimouse_outb(val, pcimouse_iobase + KBD_DATA_REG); /* Write data */
udelay(1);
}
/*
* Write to device & handle returned ack
*/
static int __init aux_write_ack(int val)
{
aux_write_dev(val);
poll_aux_status();
if ((pcimouse_inb(pcimouse_iobase + KBD_STATUS_REG) & AUX_STAT_OBF) == AUX_STAT_OBF)
return (pcimouse_inb(pcimouse_iobase + KBD_DATA_REG));
return 0;
}
/*
* Write aux device command
*/
static void aux_write_cmd(int val)
{
poll_aux_status();
pcimouse_outb(KBD_CCMD_WRITE_MODE, pcimouse_iobase + KBD_CNTL_REG);
poll_aux_status();
pcimouse_outb(val, pcimouse_iobase + KBD_DATA_REG);
}
/*
* Interrupt from the auxiliary device: a character
* is waiting in the keyboard/aux controller.
*/
void pcimouse_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
unsigned long flags;
int head, maxhead;
unsigned char val;
spin_lock_irqsave(&pcikbd_lock, flags);
head = queue->head;
maxhead = (queue->tail - 1) & (AUX_BUF_SIZE - 1);
if ((pcimouse_inb(pcimouse_iobase + KBD_STATUS_REG) & AUX_STAT_OBF) !=
AUX_STAT_OBF) {
spin_unlock_irqrestore(&pcikbd_lock, flags);
return;
}
val = pcimouse_inb(pcimouse_iobase + KBD_DATA_REG);
queue->buf[head] = val;
add_mouse_randomness(val);
if (head != maxhead) {
head++;
head &= AUX_BUF_SIZE - 1;
}
queue->head = head;
spin_unlock_irqrestore(&pcikbd_lock, flags);
kill_fasync(&queue->fasync, SIGIO, POLL_IN);
wake_up_interruptible(&queue->proc_list);
}
static int aux_release(struct inode * inode, struct file * file)
{
unsigned long flags;
aux_fasync(-1, file, 0);
spin_lock_irqsave(&pcikbd_lock, flags);
if (--aux_count)
goto out;
/* Disable controller ints */
aux_write_cmd(AUX_INTS_OFF);
poll_aux_status();
/* Disable Aux device */
pcimouse_outb(KBD_CCMD_MOUSE_DISABLE, pcimouse_iobase + KBD_CNTL_REG);
poll_aux_status();
out:
spin_unlock_irqrestore(&pcikbd_lock, flags);
return 0;
}
/*
* Install interrupt handler.
* Enable auxiliary device.
*/
static int aux_open(struct inode * inode, struct file * file)
{
unsigned long flags;
if (!aux_present)
return -ENODEV;
spin_lock_irqsave(&pcikbd_lock, flags);
if (aux_count++) {
spin_unlock_irqrestore(&pcikbd_lock, flags);
return 0;
}
if (!poll_aux_status()) {
aux_count--;
spin_unlock_irqrestore(&pcikbd_lock, flags);
return -EBUSY;
}
queue->head = queue->tail = 0; /* Flush input queue */
poll_aux_status();
pcimouse_outb(KBD_CCMD_MOUSE_ENABLE, pcimouse_iobase+KBD_CNTL_REG); /* Enable Aux */
aux_write_dev(AUX_ENABLE_DEV); /* Enable aux device */
aux_write_cmd(AUX_INTS_ON); /* Enable controller ints */
poll_aux_status();
spin_unlock_irqrestore(&pcikbd_lock, flags);
return 0;
}
/*
* Write to the aux device.
*/
static ssize_t aux_write(struct file * file, const char * buffer,
size_t count, loff_t *ppos)
{
ssize_t retval = 0;
unsigned long flags;
if (count) {
ssize_t written = 0;
spin_lock_irqsave(&pcikbd_lock, flags);
do {
char c;
spin_unlock_irqrestore(&pcikbd_lock, flags);
get_user(c, buffer++);
spin_lock_irqsave(&pcikbd_lock, flags);
if (!poll_aux_status())
break;
pcimouse_outb(KBD_CCMD_WRITE_MOUSE,
pcimouse_iobase + KBD_CNTL_REG);
if (!poll_aux_status())
break;
pcimouse_outb(c, pcimouse_iobase + KBD_DATA_REG);
written++;
} while (--count);
spin_unlock_irqrestore(&pcikbd_lock, flags);
retval = -EIO;
if (written) {
retval = written;
file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
}
}
return retval;
}
/*
* Generic part continues...
*/
/*
* Put bytes from input queue to buffer.
*/
static ssize_t aux_read(struct file * file, char * buffer,
size_t count, loff_t *ppos)
{
DECLARE_WAITQUEUE(wait, current);
ssize_t i = count;
unsigned char c;
if (queue_empty()) {
if (file->f_flags & O_NONBLOCK)
return -EAGAIN;
add_wait_queue(&queue->proc_list, &wait);
repeat:
set_current_state(TASK_INTERRUPTIBLE);
if (queue_empty() && !signal_pending(current)) {
schedule();
goto repeat;
}
current->state = TASK_RUNNING;
remove_wait_queue(&queue->proc_list, &wait);
}
while (i > 0 && !queue_empty()) {
c = get_from_queue();
put_user(c, buffer++);
i--;
}
if (count-i) {
file->f_dentry->d_inode->i_atime = CURRENT_TIME;
return count-i;
}
if (signal_pending(current))
return -ERESTARTSYS;
return 0;
}
static unsigned int aux_poll(struct file *file, poll_table * wait)
{
poll_wait(file, &queue->proc_list, wait);
if (!queue_empty())
return POLLIN | POLLRDNORM;
return 0;
}
struct file_operations psaux_fops = {
.owner = THIS_MODULE,
.read = aux_read,
.write = aux_write,
.poll = aux_poll,
.open = aux_open,
.release = aux_release,
.fasync = aux_fasync,
};
static int aux_no_open(struct inode *inode, struct file *file)
{
return -ENODEV;
}
struct file_operations psaux_no_fops = {
.owner = THIS_MODULE,
.open = aux_no_open,
};
static struct miscdevice psaux_mouse = {
PSMOUSE_MINOR, "ps2aux", &psaux_fops
};
static struct miscdevice psaux_no_mouse = {
PSMOUSE_MINOR, "ps2aux", &psaux_no_fops
};
int __init pcimouse_init(void)
{
struct linux_ebus *ebus;
struct linux_ebus_device *edev;
struct linux_ebus_child *child;
if (pcikbd_mrcoffee) {
if ((pcimouse_iobase = pcikbd_iobase) == 0) {
printk("pcimouse_init: no 8042 given\n");
goto do_enodev;
}
pcimouse_irq = pcikbd_irq;
} else {
for_each_ebus(ebus) {
for_each_ebusdev(edev, ebus) {
if(!strcmp(edev->prom_name, "8042")) {
for_each_edevchild(edev, child) {
if (strcmp(child->prom_name, PCI_MS_NAME1) == 0 ||
strcmp(child->prom_name, PCI_MS_NAME2) == 0)
goto found;
}
}
}
}
printk("pcimouse_init: no 8042 found\n");
goto do_enodev;
found:
pcimouse_iobase = child->resource[0].start;
pcimouse_irq = child->irqs[0];
}
queue = (struct aux_queue *) kmalloc(sizeof(*queue), GFP_KERNEL);
if (!queue) {
printk("pcimouse_init: kmalloc(aux_queue) failed.\n");
return -ENOMEM;
}
memset(queue, 0, sizeof(*queue));
init_waitqueue_head(&queue->proc_list);
if (request_irq(pcimouse_irq, &pcimouse_interrupt,
SA_SHIRQ, "mouse", (void *)pcimouse_iobase)) {
printk("8042: Cannot register IRQ %s\n",
__irq_itoa(pcimouse_irq));
goto do_enodev;
}
printk("8042(mouse) at %lx (irq %s)\n", pcimouse_iobase,
__irq_itoa(pcimouse_irq));
printk("8042: PS/2 auxiliary pointing device detected.\n");
aux_present = 1;
pckbd_read_mask = AUX_STAT_OBF;
misc_register(&psaux_mouse);
spin_lock_irq(&pcikbd_lock);
pcimouse_outb(KBD_CCMD_MOUSE_ENABLE, pcimouse_iobase + KBD_CNTL_REG);
aux_write_ack(AUX_RESET);
aux_write_ack(AUX_SET_SAMPLE);
aux_write_ack(100);
aux_write_ack(AUX_SET_RES);
aux_write_ack(3);
aux_write_ack(AUX_SET_SCALE21);
poll_aux_status();
pcimouse_outb(KBD_CCMD_MOUSE_DISABLE, pcimouse_iobase + KBD_CNTL_REG);
poll_aux_status();
pcimouse_outb(KBD_CCMD_WRITE_MODE, pcimouse_iobase + KBD_CNTL_REG);
poll_aux_status();
pcimouse_outb(AUX_INTS_OFF, pcimouse_iobase + KBD_DATA_REG);
poll_aux_status();
spin_unlock_irq(&pcikbd_lock);
return 0;
do_enodev:
misc_register(&psaux_no_mouse);
return -ENODEV;
}
int __init pcimouse_no_init(void)
{
misc_register(&psaux_no_mouse);
return -ENODEV;
}
int __init ps2kbd_probe(void)
{
int pnode, enode, node, dnode, xnode;
int kbnode = 0, msnode = 0, bnode = 0;
int devices = 0;
char prop[128];
int len;
#ifndef __sparc_v9__
/*
* MrCoffee has hardware but has no PROM nodes whatsoever.
*/
len = prom_getproperty(prom_root_node, "name", prop, sizeof(prop));
if (len < 0) {
printk("ps2kbd_probe: no name of root node\n");
goto do_enodev;
}
if (strncmp(prop, "SUNW,JavaStation-1", len) == 0) {
pcikbd_mrcoffee = 1; /* Brain damage detected */
goto found;
}
#endif
/*
* Get the nodes for keyboard and mouse from aliases on normal systems.
*/
node = prom_getchild(prom_root_node);
node = prom_searchsiblings(node, "aliases");
if (!node)
goto do_enodev;
len = prom_getproperty(node, "keyboard", prop, sizeof(prop));
if (len > 0) {
prop[len] = 0;
kbnode = prom_finddevice(prop);
}
if (!kbnode)
goto do_enodev;
len = prom_getproperty(node, "mouse", prop, sizeof(prop));
if (len > 0) {
prop[len] = 0;
msnode = prom_finddevice(prop);
}
if (!msnode)
goto do_enodev;
/*
* Find matching EBus nodes...
*/
node = prom_getchild(prom_root_node);
pnode = prom_searchsiblings(node, "pci");
/*
* Check for SUNW,sabre on Ultra5/10/AXi.
*/
len = prom_getproperty(pnode, "model", prop, sizeof(prop));
if ((len > 0) && !strncmp(prop, "SUNW,sabre", len)) {
pnode = prom_getchild(pnode);
pnode = prom_searchsiblings(pnode, "pci");
}
/*
* For each PCI bus...
*/
while (pnode) {
enode = prom_getchild(pnode);
enode = prom_searchsiblings(enode, "ebus");
/*
* For each EBus on this PCI...
*/
while (enode) {
node = prom_getchild(enode);
bnode = prom_searchsiblings(node, "beeper");
node = prom_getchild(enode);
node = prom_searchsiblings(node, "8042");
/*
* For each '8042' on this EBus...
*/
while (node) {
dnode = prom_getchild(node);
/*
* Does it match?
*/
if ((xnode = prom_searchsiblings(dnode, PCI_KB_NAME1)) == kbnode) {
++devices;
} else if ((xnode = prom_searchsiblings(dnode, PCI_KB_NAME2)) == kbnode) {
++devices;
}
if ((xnode = prom_searchsiblings(dnode, PCI_MS_NAME1)) == msnode) {
++devices;
} else if ((xnode = prom_searchsiblings(dnode, PCI_MS_NAME2)) == msnode) {
++devices;
}
/*
* Found everything we need?
*/
if (devices == 2)
goto found;
node = prom_getsibling(node);
node = prom_searchsiblings(node, "8042");
}
enode = prom_getsibling(enode);
enode = prom_searchsiblings(enode, "ebus");
}
pnode = prom_getsibling(pnode);
pnode = prom_searchsiblings(pnode, "pci");
}
do_enodev:
sunkbd_setinitfunc(pcimouse_no_init);
return -ENODEV;
found:
sunkbd_setinitfunc(pcimouse_init);
sunkbd_setinitfunc(pcikbd_init);
kbd_ops.compute_shiftstate = pci_compute_shiftstate;
kbd_ops.setledstate = pci_setledstate;
kbd_ops.getledstate = pci_getledstate;
kbd_ops.setkeycode = pci_setkeycode;
kbd_ops.getkeycode = pci_getkeycode;
return 0;
}
drivers/sbus/char/pcikbd.h deleted 100644 → 0
View file @ 40b4cd90
/* $Id: pcikbd.h,v 1.2 1997/12/25 21:13:14 geert Exp $
* pcikbd.h: PCI/PC 8042 keyboard/mouse driver stuff. Mostly snarfed
* from the existing driver by Martin Mares.
*
* Copyright (C) 1997 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
*
* Ultra/AX specific hacks are:
*
* Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
*/
#ifndef __PCIKBD_H
#define __PCIKBD_H
/*
* Configuration Switches
*/
#define KBD_REPORT_ERR /* Report keyboard errors */
#define KBD_REPORT_UNKN /* Report unknown scan codes */
#define KBD_REPORT_TIMEOUTS /* Report keyboard timeouts */
#define KBD_INIT_TIMEOUT HZ /* Timeout for initializing the keyboard */
#define KBC_TIMEOUT (HZ/4) /* Timeout for sending to keyboard controller */
#define KBD_TIMEOUT (HZ/4) /* Timeout for keyboard command acknowledge */
/*
* Internal variables of the driver
*/
extern unsigned char pckbd_read_mask;
extern unsigned char aux_device_present;
extern unsigned long pcikbd_iobase;
extern unsigned int pcikbd_irq;
/*
* Keyboard Controller Registers
*
* NOTE: These are offsets from pcikbd_iobase, not absolute.
*/
#define KBD_STATUS_REG 0x04
#define KBD_CNTL_REG KBD_STATUS_REG
#define KBD_DATA_REG 0x00
/*
* Keyboard Controller Commands
*/
#define KBD_CCMD_READ_MODE 0x20 /* Read mode bits */
#define KBD_CCMD_WRITE_MODE 0x60 /* Write mode bits */
#define KBD_CCMD_GET_VERSION 0xA1 /* Get controller version */
#define KBD_CCMD_MOUSE_DISABLE 0xA7 /* Disable mouse interface */
#define KBD_CCMD_MOUSE_ENABLE 0xA8 /* Enable mouse interface */
#define KBD_CCMD_TEST_MOUSE 0xA9 /* Mouse interface test */
#define KBD_CCMD_SELF_TEST 0xAA /* Controller self test */
#define KBD_CCMD_KBD_TEST 0xAB /* Keyboard interface test */
#define KBD_CCMD_KBD_DISABLE 0xAD /* Keyboard interface disable */
#define KBD_CCMD_KBD_ENABLE 0xAE /* Keyboard interface enable */
#define KBD_CCMD_WRITE_MOUSE 0xD4 /* Write the following byte to the mouse */
/*
* Keyboard Commands
*/
#define KBD_CMD_SET_LEDS 0xED /* Set keyboard leds */
#define KBD_CMD_SET_RATE 0xF3 /* Set typematic rate */
#define KBD_CMD_ENABLE 0xF4 /* Enable scanning */
#define KBD_CMD_DISABLE 0xF5 /* Disable scanning */
#define KBD_CMD_RESET 0xFF /* Reset */
/*
* Keyboard Replies
*/
#define KBD_REPLY_POR 0xAA /* Power on reset */
#define KBD_REPLY_ACK 0xFA /* Command ACK */
#define KBD_REPLY_RESEND 0xFE /* Command NACK, send the cmd again */
/*
* Status Register Bits
*/
#define KBD_STAT_OBF 0x01 /* Keyboard output buffer full */
#define KBD_STAT_IBF 0x02 /* Keyboard input buffer full */
#define KBD_STAT_SELFTEST 0x04 /* Self test successful */
#define KBD_STAT_CMD 0x08 /* Last write was a command write (0=data) */
#define KBD_STAT_UNLOCKED 0x10 /* Zero if keyboard locked */
#define KBD_STAT_MOUSE_OBF 0x20 /* Mouse output buffer full */
#define KBD_STAT_GTO 0x40 /* General receive/xmit timeout */
#define KBD_STAT_PERR 0x80 /* Parity error */
#define AUX_STAT_OBF (KBD_STAT_OBF | KBD_STAT_MOUSE_OBF)
/*
* Controller Mode Register Bits
*/
#define KBD_MODE_KBD_INT 0x01 /* Keyboard data generage IRQ1 */
#define KBD_MODE_MOUSE_INT 0x02 /* Mouse data generate IRQ12 */
#define KBD_MODE_SYS 0x04 /* The system flag (?) */
#define KBD_MODE_NO_KEYLOCK 0x08 /* The keylock doesn't affect the keyboard if set */
#define KBD_MODE_DISABLE_KBD 0x10 /* Disable keyboard interface */
#define KBD_MODE_DISABLE_MOUSE 0x20 /* Disable mouse interface */
#define KBD_MODE_KCC 0x40 /* Scan code conversion to PC format */
#define KBD_MODE_RFU 0x80
/*
* Mouse Commands
*/
#define AUX_SET_RES 0xE8 /* Set resolution */
#define AUX_SET_SCALE11 0xE6 /* Set 1:1 scaling */
#define AUX_SET_SCALE21 0xE7 /* Set 2:1 scaling */
#define AUX_GET_SCALE 0xE9 /* Get scaling factor */
#define AUX_SET_STREAM 0xEA /* Set stream mode */
#define AUX_SET_SAMPLE 0xF3 /* Set sample rate */
#define AUX_ENABLE_DEV 0xF4 /* Enable aux device */
#define AUX_DISABLE_DEV 0xF5 /* Disable aux device */
#define AUX_RESET 0xFF /* Reset aux device */
#endif /* __PCIKBD_H */
drivers/sbus/char/sunkbdmap.c deleted 100644 → 0
View file @ 40b4cd90
/* $Id: sunkbdmap.c,v 1.1 1997/09/07 15:40:27 ecd Exp $
* sunkbdmap.c: Wrapper around sunkeymap.c to change table names.
*
* Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
*/
#include <linux/config.h>
#ifdef CONFIG_PCI
#define func_buf sun_func_buf
#define func_table sun_func_table
#define funcbufsize sun_funcbufsize
#define funcbufleft sun_funcbufleft
#define funcbufptr sun_funcbufptr
#define accent_table sun_accent_table
#define accent_table_size sun_accent_table_size
#define key_maps sun_key_maps
#define keymap_count sun_keymap_count
#define plain_map sun_plain_map
#define shift_map sun_shift_map
#define ctrl_map sun_ctrl_map
#define alt_map sun_alt_map
#define altgr_map sun_altgr_map
#define shift_ctrl_map sun_shift_ctrl_map
#define ctrl_alt_map sun_ctrl_alt_map
#endif /* CONFIG_PCI */
#include "sunkeymap.c"
drivers/sbus/char/sunkeymap.c deleted 100644 → 0
View file @ 40b4cd90
/* Do not edit this file! It was automatically generated by */
/* loadkeys --mktable defkeymap.map > defkeymap.c */
#include <linux/types.h>
#include <linux/keyboard.h>
#include <linux/kd.h>
u_short plain_map[NR_KEYS] = {
0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf100, 0xf101, 0xf109,
0xf102, 0xf10a, 0xf103, 0xf10b, 0xf104, 0xf701, 0xf105, 0xf200,
0xf106, 0xf107, 0xf108, 0xf703, 0xf603, 0xf11d, 0xf200, 0xf209,
0xf601, 0xf200, 0xf200, 0xf600, 0xf602, 0xf01b, 0xf031, 0xf032,
0xf033, 0xf034, 0xf035, 0xf036, 0xf037, 0xf038, 0xf039, 0xf030,
0xf02d, 0xf03d, 0xf060, 0xf07f, 0xf115, 0xf03d, 0xf30d, 0xf30c,
0xf200, 0xf200, 0xf310, 0xf200, 0xf114, 0xf009, 0xfb71, 0xfb77,
0xfb65, 0xfb72, 0xfb74, 0xfb79, 0xfb75, 0xfb69, 0xfb6f, 0xfb70,
0xf05b, 0xf05d, 0xf07f, 0xf20e, 0xf307, 0xf308, 0xf309, 0xf30b,
0xf200, 0xf200, 0xf117, 0xf200, 0xf702, 0xfb61, 0xfb73, 0xfb64,
0xfb66, 0xfb67, 0xfb68, 0xfb6a, 0xfb6b, 0xfb6c, 0xf03b, 0xf027,
0xf05c, 0xf201, 0xf30e, 0xf304, 0xf305, 0xf306, 0xf300, 0xf200,
0xf118, 0xf200, 0xf208, 0xf700, 0xfb7a, 0xfb78, 0xfb63, 0xfb76,
0xfb62, 0xfb6e, 0xfb6d, 0xf02c, 0xf02e, 0xf02f, 0xf700, 0xf00a,
0xf301, 0xf302, 0xf303, 0xf200, 0xf200, 0xf200, 0xf11b, 0xf207,
0xf200, 0xf020, 0xf200, 0xf119, 0xf200, 0xf30a, 0xf200, 0xf200,
};
u_short shift_map[NR_KEYS] = {
0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf10a, 0xf10b, 0xf113,
0xf10c, 0xf10a, 0xf10d, 0xf10b, 0xf10e, 0xf701, 0xf10f, 0xf200,
0xf110, 0xf111, 0xf112, 0xf703, 0xf603, 0xf11d, 0xf200, 0xf203,
0xf601, 0xf200, 0xf200, 0xf600, 0xf602, 0xf01b, 0xf021, 0xf040,
0xf023, 0xf024, 0xf025, 0xf05e, 0xf026, 0xf02a, 0xf028, 0xf029,
0xf05f, 0xf02b, 0xf07e, 0xf07f, 0xf115, 0xf03d, 0xf30d, 0xf30c,
0xf200, 0xf200, 0xf310, 0xf200, 0xf114, 0xf009, 0xfb51, 0xfb57,
0xfb45, 0xfb52, 0xfb54, 0xfb59, 0xfb55, 0xfb49, 0xfb4f, 0xfb50,
0xf07b, 0xf07d, 0xf07f, 0xf20e, 0xf307, 0xf308, 0xf309, 0xf30b,
0xf200, 0xf200, 0xf117, 0xf200, 0xf702, 0xfb41, 0xfb53, 0xfb44,
0xfb46, 0xfb47, 0xfb48, 0xfb4a, 0xfb4b, 0xfb4c, 0xf03a, 0xf022,
0xf07c, 0xf201, 0xf30e, 0xf304, 0xf305, 0xf306, 0xf300, 0xf200,
0xf20b, 0xf200, 0xf208, 0xf700, 0xfb5a, 0xfb58, 0xfb43, 0xfb56,
0xfb42, 0xfb4e, 0xfb4d, 0xf03c, 0xf03e, 0xf03f, 0xf700, 0xf00a,
0xf301, 0xf302, 0xf303, 0xf200, 0xf200, 0xf200, 0xf11b, 0xf207,
0xf200, 0xf020, 0xf200, 0xf20a, 0xf200, 0xf30a, 0xf200, 0xf200,
};
u_short altgr_map[NR_KEYS] = {
0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf50c, 0xf50d, 0xf515,
0xf50e, 0xf516, 0xf50f, 0xf517, 0xf510, 0xf701, 0xf511, 0xf200,
0xf512, 0xf513, 0xf514, 0xf703, 0xf603, 0xf11d, 0xf200, 0xf202,
0xf601, 0xf200, 0xf200, 0xf600, 0xf602, 0xf200, 0xf200, 0xf040,
0xf200, 0xf024, 0xf200, 0xf200, 0xf07b, 0xf05b, 0xf05d, 0xf07d,
0xf05c, 0xf200, 0xf200, 0xf200, 0xf115, 0xf03d, 0xf30d, 0xf30c,
0xf200, 0xf200, 0xf310, 0xf200, 0xf114, 0xf200, 0xfb71, 0xfb77,
0xf918, 0xfb72, 0xfb74, 0xfb79, 0xfb75, 0xfb69, 0xfb6f, 0xfb70,
0xf200, 0xf07e, 0xf200, 0xf20e, 0xf911, 0xf912, 0xf913, 0xf30b,
0xf200, 0xf200, 0xf117, 0xf200, 0xf702, 0xf914, 0xfb73, 0xf917,
0xf919, 0xfb67, 0xfb68, 0xfb6a, 0xfb6b, 0xfb6c, 0xf200, 0xf200,
0xf200, 0xf201, 0xf30e, 0xf90e, 0xf90f, 0xf910, 0xf90a, 0xf200,
0xf118, 0xf200, 0xf208, 0xf700, 0xfb7a, 0xfb78, 0xf916, 0xfb76,
0xf915, 0xfb6e, 0xfb6d, 0xf200, 0xf200, 0xf200, 0xf700, 0xf00a,
0xf90b, 0xf90c, 0xf90d, 0xf200, 0xf200, 0xf200, 0xf11b, 0xf207,
0xf200, 0xf200, 0xf200, 0xf119, 0xf200, 0xf30a, 0xf200, 0xf200,
};
u_short ctrl_map[NR_KEYS] = {
0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf100, 0xf101, 0xf109,
0xf102, 0xf10a, 0xf103, 0xf10b, 0xf104, 0xf701, 0xf105, 0xf200,
0xf106, 0xf107, 0xf108, 0xf703, 0xf603, 0xf11d, 0xf200, 0xf204,
0xf601, 0xf200, 0xf200, 0xf600, 0xf602, 0xf200, 0xf200, 0xf000,
0xf01b, 0xf01c, 0xf01d, 0xf01e, 0xf01f, 0xf07f, 0xf200, 0xf200,
0xf01f, 0xf200, 0xf000, 0xf008, 0xf115, 0xf03d, 0xf30d, 0xf30c,
0xf200, 0xf200, 0xf310, 0xf200, 0xf114, 0xf200, 0xf011, 0xf017,
0xf005, 0xf012, 0xf014, 0xf019, 0xf015, 0xf009, 0xf00f, 0xf010,
0xf01b, 0xf01d, 0xf008, 0xf20e, 0xf307, 0xf308, 0xf309, 0xf30b,
0xf200, 0xf200, 0xf117, 0xf200, 0xf702, 0xf001, 0xf013, 0xf004,
0xf006, 0xf007, 0xf008, 0xf00a, 0xf00b, 0xf00c, 0xf200, 0xf007,
0xf01c, 0xf201, 0xf30e, 0xf304, 0xf305, 0xf306, 0xf300, 0xf200,
0xf118, 0xf200, 0xf208, 0xf700, 0xf01a, 0xf018, 0xf003, 0xf016,
0xf002, 0xf00e, 0xf00d, 0xf200, 0xf20e, 0xf07f, 0xf700, 0xf00a,
0xf301, 0xf302, 0xf303, 0xf200, 0xf200, 0xf200, 0xf11b, 0xf207,
0xf200, 0xf000, 0xf200, 0xf119, 0xf200, 0xf30a, 0xf200, 0xf200,
};
u_short shift_ctrl_map[NR_KEYS] = {
0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf701, 0xf200, 0xf200,
0xf200, 0xf200, 0xf200, 0xf703, 0xf603, 0xf11d, 0xf200, 0xf200,
0xf601, 0xf200, 0xf200, 0xf600, 0xf602, 0xf200, 0xf200, 0xf000,
0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
0xf01f, 0xf200, 0xf200, 0xf200, 0xf115, 0xf03d, 0xf30d, 0xf30c,
0xf200, 0xf200, 0xf310, 0xf200, 0xf114, 0xf200, 0xf011, 0xf017,
0xf005, 0xf012, 0xf014, 0xf019, 0xf015, 0xf009, 0xf00f, 0xf010,
0xf200, 0xf200, 0xf200, 0xf20e, 0xf307, 0xf308, 0xf309, 0xf30b,
0xf200, 0xf200, 0xf117, 0xf200, 0xf702, 0xf001, 0xf013, 0xf004,
0xf006, 0xf007, 0xf008, 0xf00a, 0xf00b, 0xf00c, 0xf200, 0xf200,
0xf200, 0xf201, 0xf30e, 0xf304, 0xf305, 0xf306, 0xf300, 0xf200,
0xf118, 0xf200, 0xf208, 0xf700, 0xf01a, 0xf018, 0xf003, 0xf016,
0xf002, 0xf00e, 0xf00d, 0xf200, 0xf200, 0xf200, 0xf700, 0xf00a,
0xf301, 0xf302, 0xf303, 0xf200, 0xf200, 0xf200, 0xf11b, 0xf207,
0xf200, 0xf200, 0xf200, 0xf119, 0xf200, 0xf30a, 0xf200, 0xf200,
};
u_short alt_map[NR_KEYS] = {
0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf500, 0xf501, 0xf509,
0xf502, 0xf50a, 0xf503, 0xf50b, 0xf504, 0xf701, 0xf505, 0xf200,
0xf506, 0xf507, 0xf508, 0xf703, 0xf603, 0xf11d, 0xf200, 0xf209,
0xf210, 0xf200, 0xf200, 0xf600, 0xf211, 0xf81b, 0xf831, 0xf832,
0xf833, 0xf834, 0xf835, 0xf836, 0xf837, 0xf838, 0xf839, 0xf830,
0xf82d, 0xf83d, 0xf860, 0xf87f, 0xf115, 0xf03d, 0xf30d, 0xf30c,
0xf200, 0xf200, 0xf310, 0xf200, 0xf114, 0xf809, 0xf871, 0xf877,
0xf865, 0xf872, 0xf874, 0xf879, 0xf875, 0xf869, 0xf86f, 0xf870,
0xf85b, 0xf85d, 0xf87f, 0xf20e, 0xf907, 0xf908, 0xf909, 0xf30b,
0xf200, 0xf200, 0xf117, 0xf200, 0xf702, 0xf861, 0xf873, 0xf864,
0xf866, 0xf867, 0xf868, 0xf86a, 0xf86b, 0xf86c, 0xf83b, 0xf827,
0xf85c, 0xf80d, 0xf30e, 0xf904, 0xf905, 0xf906, 0xf900, 0xf200,
0xf118, 0xf200, 0xf208, 0xf700, 0xf87a, 0xf878, 0xf863, 0xf876,
0xf862, 0xf86e, 0xf86d, 0xf82c, 0xf82e, 0xf82f, 0xf700, 0xf00a,
0xf901, 0xf902, 0xf903, 0xf200, 0xf200, 0xf200, 0xf11b, 0xf207,
0xf200, 0xf820, 0xf200, 0xf119, 0xf200, 0xf30a, 0xf200, 0xf200,
};
u_short ctrl_alt_map[NR_KEYS] = {
0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf500, 0xf501, 0xf509,
0xf502, 0xf50a, 0xf503, 0xf50b, 0xf504, 0xf701, 0xf505, 0xf200,
0xf506, 0xf507, 0xf508, 0xf703, 0xf603, 0xf11d, 0xf200, 0xf200,
0xf601, 0xf200, 0xf200, 0xf600, 0xf602, 0xf200, 0xf200, 0xf200,
0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
0xf200, 0xf200, 0xf200, 0xf200, 0xf115, 0xf03d, 0xf30d, 0xf30c,
0xf200, 0xf200, 0xf20c, 0xf200, 0xf114, 0xf200, 0xf811, 0xf817,
0xf805, 0xf812, 0xf814, 0xf819, 0xf815, 0xf809, 0xf80f, 0xf810,
0xf200, 0xf200, 0xf20c, 0xf20e, 0xf307, 0xf308, 0xf309, 0xf30b,
0xf200, 0xf200, 0xf117, 0xf200, 0xf702, 0xf801, 0xf813, 0xf804,
0xf806, 0xf807, 0xf808, 0xf80a, 0xf80b, 0xf80c, 0xf200, 0xf200,
0xf200, 0xf201, 0xf30e, 0xf304, 0xf305, 0xf306, 0xf300, 0xf200,
0xf118, 0xf200, 0xf208, 0xf700, 0xf81a, 0xf818, 0xf803, 0xf816,
0xf802, 0xf80e, 0xf80d, 0xf200, 0xf200, 0xf200, 0xf700, 0xf00a,
0xf301, 0xf302, 0xf303, 0xf200, 0xf200, 0xf200, 0xf11b, 0xf207,
0xf200, 0xf200, 0xf200, 0xf119, 0xf200, 0xf30a, 0xf200, 0xf200,
};
ushort *key_maps[MAX_NR_KEYMAPS] = {
plain_map, shift_map, altgr_map, 0,
ctrl_map, shift_ctrl_map, 0, 0,
alt_map, 0, 0, 0,
ctrl_alt_map, 0
};
unsigned int keymap_count = 7;
/*
* Philosophy: most people do not define more strings, but they who do
* often want quite a lot of string space. So, we statically allocate
* the default and allocate dynamically in chunks of 512 bytes.
*/
char func_buf[] = {
'\033', '[', '[', 'A', 0,
'\033', '[', '[', 'B', 0,
'\033', '[', '[', 'C', 0,
'\033', '[', '[', 'D', 0,
'\033', '[', '[', 'E', 0,
'\033', '[', '1', '7', '~', 0,
'\033', '[', '1', '8', '~', 0,
'\033', '[', '1', '9', '~', 0,
'\033', '[', '2', '0', '~', 0,
'\033', '[', '2', '1', '~', 0,
'\033', '[', '2', '3', '~', 0,
'\033', '[', '2', '4', '~', 0,
'\033', '[', '2', '5', '~', 0,
'\033', '[', '2', '6', '~', 0,
'\033', '[', '2', '8', '~', 0,
'\033', '[', '2', '9', '~', 0,
'\033', '[', '3', '1', '~', 0,
'\033', '[', '3', '2', '~', 0,
'\033', '[', '3', '3', '~', 0,
'\033', '[', '3', '4', '~', 0,
'\033', '[', '1', '~', 0,
'\033', '[', '2', '~', 0,
'\033', '[', '3', '~', 0,
'\033', '[', '4', '~', 0,
'\033', '[', '5', '~', 0,
'\033', '[', '6', '~', 0,
'\033', '[', 'M', 0,
'\033', '[', 'P', 0,
};
char *funcbufptr = func_buf;
int funcbufsize = sizeof(func_buf);
int funcbufleft = 0; /* space left */
char *func_table[MAX_NR_FUNC] = {
func_buf + 0,
func_buf + 5,
func_buf + 10,
func_buf + 15,
func_buf + 20,
func_buf + 25,
func_buf + 31,
func_buf + 37,
func_buf + 43,
func_buf + 49,
func_buf + 55,
func_buf + 61,
func_buf + 67,
func_buf + 73,
func_buf + 79,
func_buf + 85,
func_buf + 91,
func_buf + 97,
func_buf + 103,
func_buf + 109,
func_buf + 115,
func_buf + 120,
func_buf + 125,
func_buf + 130,
func_buf + 135,
func_buf + 140,
func_buf + 145,
0,
0,
func_buf + 149,
0,
};
struct kbdiacr accent_table[MAX_DIACR] = {
{'`', 'A', '\300'}, {'`', 'a', '\340'},
{'\'', 'A', '\301'}, {'\'', 'a', '\341'},
{'^', 'A', '\302'}, {'^', 'a', '\342'},
{'~', 'A', '\303'}, {'~', 'a', '\343'},
{'"', 'A', '\304'}, {'"', 'a', '\344'},
{'O', 'A', '\305'}, {'o', 'a', '\345'},
{'0', 'A', '\305'}, {'0', 'a', '\345'},
{'A', 'A', '\305'}, {'a', 'a', '\345'},
{'A', 'E', '\306'}, {'a', 'e', '\346'},
{',', 'C', '\307'}, {',', 'c', '\347'},
{'`', 'E', '\310'}, {'`', 'e', '\350'},
{'\'', 'E', '\311'}, {'\'', 'e', '\351'},
{'^', 'E', '\312'}, {'^', 'e', '\352'},
{'"', 'E', '\313'}, {'"', 'e', '\353'},
{'`', 'I', '\314'}, {'`', 'i', '\354'},
{'\'', 'I', '\315'}, {'\'', 'i', '\355'},
{'^', 'I', '\316'}, {'^', 'i', '\356'},
{'"', 'I', '\317'}, {'"', 'i', '\357'},
{'-', 'D', '\320'}, {'-', 'd', '\360'},
{'~', 'N', '\321'}, {'~', 'n', '\361'},
{'`', 'O', '\322'}, {'`', 'o', '\362'},
{'\'', 'O', '\323'}, {'\'', 'o', '\363'},
{'^', 'O', '\324'}, {'^', 'o', '\364'},
{'~', 'O', '\325'}, {'~', 'o', '\365'},
{'"', 'O', '\326'}, {'"', 'o', '\366'},
{'/', 'O', '\330'}, {'/', 'o', '\370'},
{'`', 'U', '\331'}, {'`', 'u', '\371'},
{'\'', 'U', '\332'}, {'\'', 'u', '\372'},
{'^', 'U', '\333'}, {'^', 'u', '\373'},
{'"', 'U', '\334'}, {'"', 'u', '\374'},
{'\'', 'Y', '\335'}, {'\'', 'y', '\375'},
{'T', 'H', '\336'}, {'t', 'h', '\376'},
{'s', 's', '\337'}, {'"', 'y', '\377'},
{'s', 'z', '\337'}, {'i', 'j', '\377'},
};
unsigned int accent_table_size = 68;
drivers/sbus/char/sunkeymap.map deleted 100644 → 0
View file @ 40b4cd90
# Keyboard map for the Sun Type4/Type5 keyboards
# found on SparcStations
keymaps 0-2,4-5,8,12
#
#
# Stop/L1
keycode 0x01 =
# SND_LOWER
keycode 0x02 =
# Again/L2
keycode 0x03 =
# SND_LOUDER
keycode 0x04 =
keycode 0x05 = F1 F11 Console_13
control keycode 0x05 = F1
alt keycode 0x05 = Console_1
control alt keycode 0x05 = Console_1
keycode 0x06 = F2 F12 Console_14
control keycode 0x06 = F2
alt keycode 0x06 = Console_2
control alt keycode 0x06 = Console_2
keycode 0x07 = F10 F20 Console_22
control keycode 0x07 = F10
alt keycode 0x07 = Console_10
control alt keycode 0x07 = Console_10
keycode 0x08 = F3 F13 Console_15
control keycode 0x08 = F3
alt keycode 0x08 = Console_3
control alt keycode 0x08 = Console_3
keycode 0x09 = F11 F11 Console_23
control keycode 0x09 = F11
alt keycode 0x09 = Console_11
control alt keycode 0x09 = Console_11
keycode 0x0a = F4 F14 Console_16
control keycode 0x0a = F4
alt keycode 0x0a = Console_4
control alt keycode 0x0a = Console_4
keycode 0x0b = F12 F12 Console_24
control keycode 0x0b = F12
alt keycode 0x0b = Console_12
control alt keycode 0x0b = Console_12
keycode 0x0c = F5 F15 Console_17
control Keycode 0x0c = F5
alt keycode 0x0c = Console_5
control alt keycode 0x0c = Console_5
keycode 0x0d = AltGr
keycode 0x0e = F6 F16 Console_18
control keycode 0x0e = F6
alt keycode 0x0e = Console_6
control alt keycode 0x0e = Console_6
# BLANK KEY on type 5 keyboards
keycode 0x0f =
keycode 0x10 = F7 F17 Console_19
control keycode 0x10 = F7
alt keycode 0x10 = Console_7
control alt keycode 0x10 = Console_7
keycode 0x11 = F8 F18 Console_20
control keycode 0x11 = F8
alt keycode 0x11 = Console_8
control alt keycode 0x11 = Console_8
keycode 0x12 = F9 F19 Console_21
control keycode 0x12 = F9
alt keycode 0x12 = Console_9
control alt keycode 0x12 = Console_9
keycode 0x13 = Alt
keycode 0x14 = Up
keycode 0x15 = Pause
# Print Screen
keycode 0x16 =
keycode 0x17 = Scroll_Lock Show_Memory Show_Registers
control keycode 0x17 = Show_State
alt keycode 0x17 = Scroll_Lock
keycode 0x18 = Left
alt keycode 0x18 = Decr_Console
# Props/L3
keycode 0x19 =
# UNDO/L4
keycode 0x1a =
keycode 0x1b = Down
keycode 0x1c = Right
alt keycode 0x1c = Incr_Console
keycode 0x1d = Escape Escape
alt keycode 0x1d = Meta_Escape
keycode 0x1e = one exclam
alt keycode 0x1e = Meta_one
keycode 0x1f = two at at
control keycode 0x1f = nul
shift control keycode 0x1f = nul
alt keycode 0x1f = Meta_two
keycode 0x20 = three numbersign
control keycode 0x20 = Escape
alt keycode 0x20 = Meta_three
keycode 0x21 = four dollar dollar
control keycode 0x21 = Control_backslash
alt keycode 0x21 = Meta_four
keycode 0x22 = five percent
control keycode 0x22 = Control_bracketright
alt keycode 0x22 = Meta_five
keycode 0x23 = six asciicircum
control keycode 0x23 = Control_asciicircum
alt keycode 0x23 = Meta_six
keycode 0x24 = seven ampersand braceleft
control keycode 0x24 = Control_underscore
alt keycode 0x24 = Meta_seven
keycode 0x25 = eight asterisk bracketleft
control keycode 0x25 = Delete
alt keycode 0x25 = Meta_eight
keycode 0x26 = nine parenleft bracketright
alt keycode 0x26 = Meta_nine
keycode 0x27 = zero parenright braceright
alt keycode 0x27 = Meta_zero
keycode 0x28 = minus underscore backslash
control keycode 0x28 = Control_underscore
shift control keycode 0x28 = Control_underscore
alt keycode 0x28 = Meta_minus
keycode 0x29 = equal plus
alt keycode 0x29 = Meta_equal
keycode 0x2a = grave asciitilde
control keycode 0x2a = nul
alt keycode 0x2a = Meta_grave
# Is marked as BackSpace but we define it as delete just like the i386
# keyboard maps does
keycode 0x2b = Delete Delete
control keycode 0x2b = BackSpace
alt keycode 0x2b = Meta_Delete
keycode 0x2c = Insert
# This is really keypad = on type 4 keyboards
keycode 0x2d = equal
keycode 0x2e = KP_Divide
keycode 0x2f = KP_Multiply
# Power ON/OFF key on type 5 keyboard
keycode 0x30 =
# FRONT/L5
keycode 0x31 =
keycode 0x32 = KP_Period
# altgr control keycode 0x32 = Boot
control alt keycode 0x32 = Boot
# COPY/L6
keycode 0x33 =
# Home key, same difference
keycode 0x34 = Find
keycode 0x35 = Tab Tab
alt keycode 0x35 = Meta_Tab
keycode 0x36 = q
keycode 0x37 = w
keycode 0x38 = e
altgr keycode 0x38 = Hex_E
keycode 0x39 = r
keycode 0x3a = t
keycode 0x3b = y
keycode 0x3c = u
keycode 0x3d = i
keycode 0x3e = o
keycode 0x3f = p
keycode 0x40 = bracketleft braceleft
control keycode 0x40 = Escape
alt keycode 0x40 = Meta_bracketleft
keycode 0x41 = bracketright braceright asciitilde
control keycode 0x41 = Control_bracketright
alt keycode 0x41 = Meta_bracketright
keycode 0x42 = Delete Delete
control keycode 0x42 = BackSpace
alt keycode 0x42 = Meta_Delete
control alt keycode 0x42 = Boot
keycode 0x43 = Compose
keycode 0x44 = KP_7
alt keycode 0x44 = Ascii_7
altgr keycode 0x44 = Hex_7
keycode 0x45 = KP_8
alt keycode 0x45 = Ascii_8
altgr keycode 0x45 = Hex_8
keycode 0x46 = KP_9
alt keycode 0x46 = Ascii_9
altgr keycode 0x46 = Hex_9
keycode 0x47 = KP_Subtract
# OPEN/L6
keycode 0x48 =
# PASTE/L8
keycode 0x49 =
keycode 0x4a = Select
# No key produces 0x4b to my knowledge
keycode 0x4b =
keycode 0x4c = Control
keycode 0x4d = a
altgr keycode 0x4d = Hex_A
keycode 0x4e = s
keycode 0x4f = d
altgr keycode 0x4f = Hex_D
keycode 0x50 = f
altgr keycode 0x50 = Hex_F
keycode 0x51 = g
keycode 0x52 = h
keycode 0x53 = j
keycode 0x54 = k
keycode 0x55 = l
keycode 0x56 = semicolon colon
alt keycode 0x56 = Meta_semicolon
keycode 0x57 = apostrophe quotedbl
control keycode 0x57 = Control_g
alt keycode 0x57 = Meta_apostrophe
keycode 0x58 = backslash bar
control keycode 0x58 = Control_backslash
alt keycode 0x58 = Meta_backslash
keycode 0x59 = Return
alt keycode 0x59 = Meta_Control_m
keycode 0x5a = KP_Enter
keycode 0x5b = KP_4
alt keycode 0x5b = Ascii_4
altgr keycode 0x5b = Hex_4
keycode 0x5c = KP_5
alt keycode 0x5c = Ascii_5
altgr keycode 0x5c = Hex_5
keycode 0x5d = KP_6
alt keycode 0x5d = Ascii_6
altgr keycode 0x5d = Hex_6
keycode 0x5e = KP_0
alt keycode 0x5e = Ascii_0
altgr keycode 0x5e = Hex_0
# FIND/L9
keycode 0x5f =
keycode 0x60 = Prior
shift keycode 0x60 = Scroll_Backward
# CUT/L10
keycode 0x61 =
keycode 0x62 = Num_Lock
# Linux/i386 console makes no distinction between right/left shift
# so neither do we.
keycode 0x63 = Shift
keycode 0x64 = z
keycode 0x65 = x
keycode 0x66 = c
altgr keycode 0x66 = Hex_C
keycode 0x67 = v
keycode 0x68 = b
altgr keycode 0x68 = Hex_B
keycode 0x69 = n
keycode 0x6a = m
keycode 0x6b = comma less
alt keycode 0x6b = Meta_comma
keycode 0x6c = period greater
control keycode 0x6c = Compose
alt keycode 0x6c = Meta_period
keycode 0x6d = slash question
control keycode 0x6d = Delete
alt keycode 0x6d = Meta_slash
keycode 0x6e = Shift
keycode 0x6f = Linefeed
keycode 0x70 = KP_1
alt keycode 0x70 = Ascii_1
altgr keycode 0x70 = Hex_1
keycode 0x71 = KP_2
alt keycode 0x71 = Ascii_2
altgr keycode 0x71 = Hex_2
keycode 0x72 = KP_3
alt keycode 0x72 = Ascii_3
altgr keycode 0x72 = Hex_3
# To my knowledge no key produces 0x73, 0x74, or 0x75
keycode 0x73 =
keycode 0x74 =
keycode 0x75 =
keycode 0x76 = Help
keycode 0x77 = Caps_Lock
# A True Meta-key, unused at this time
keycode 0x78 =
keycode 0x79 = space space
control keycode 0x79 = nul
alt keycode 0x79 = Meta_space
# Another real Meta-key, again unused
keycode 0x7a =
keycode 0x7b = Next
shift keycode 0x7b = Scroll_Forward
# No keys produce the following
keycode 0x7c =
keycode 0x7d = KP_Add
keycode 0x7e =
# keycode 0x7f is special and it means 'all keys released' and is
# taken care of within the sun keyboard driver itself
keycode 0x7f =
# That's all folks...
string F1 = "\033[[A"
string F2 = "\033[[B"
string F3 = "\033[[C"
string F4 = "\033[[D"
string F5 = "\033[[E"
string F6 = "\033[17~"
string F7 = "\033[18~"
string F8 = "\033[19~"
string F9 = "\033[20~"
string F10 = "\033[21~"
string F11 = "\033[23~"
string F12 = "\033[24~"
string F13 = "\033[25~"
string F14 = "\033[26~"
string F15 = "\033[28~"
string F16 = "\033[29~"
string F17 = "\033[31~"
string F18 = "\033[32~"
string F19 = "\033[33~"
string F20 = "\033[34~"
string Find = "\033[1~"
string Insert = "\033[2~"
string Remove = "\033[3~"
string Select = "\033[4~"
string Prior = "\033[5~"
string Next = "\033[6~"
string Macro = "\033[M"
string Pause = "\033[P"
compose '`' 'A' to ''
compose '`' 'a' to ''
compose '\'' 'A' to ''
compose '\'' 'a' to ''
compose '^' 'A' to ''
compose '^' 'a' to ''
compose '~' 'A' to ''
compose '~' 'a' to ''
compose '"' 'A' to ''
compose '"' 'a' to ''
compose 'O' 'A' to ''
compose 'o' 'a' to ''
compose '0' 'A' to ''
compose '0' 'a' to ''
compose 'A' 'A' to ''
compose 'a' 'a' to ''
compose 'A' 'E' to ''
compose 'a' 'e' to ''
compose ',' 'C' to ''
compose ',' 'c' to ''
compose '`' 'E' to ''
compose '`' 'e' to ''
compose '\'' 'E' to ''
compose '\'' 'e' to ''
compose '^' 'E' to ''
compose '^' 'e' to ''
compose '"' 'E' to ''
compose '"' 'e' to ''
compose '`' 'I' to ''
compose '`' 'i' to ''
compose '\'' 'I' to ''
compose '\'' 'i' to ''
compose '^' 'I' to ''
compose '^' 'i' to ''
compose '"' 'I' to ''
compose '"' 'i' to ''
compose '-' 'D' to ''
compose '-' 'd' to ''
compose '~' 'N' to ''
compose '~' 'n' to ''
compose '`' 'O' to ''
compose '`' 'o' to ''
compose '\'' 'O' to ''
compose '\'' 'o' to ''
compose '^' 'O' to ''
compose '^' 'o' to ''
compose '~' 'O' to ''
compose '~' 'o' to ''
compose '"' 'O' to ''
compose '"' 'o' to ''
compose '/' 'O' to ''
compose '/' 'o' to ''
compose '`' 'U' to ''
compose '`' 'u' to ''
compose '\'' 'U' to ''
compose '\'' 'u' to ''
compose '^' 'U' to ''
compose '^' 'u' to ''
compose '"' 'U' to ''
compose '"' 'u' to ''
compose '\'' 'Y' to ''
compose '\'' 'y' to ''
compose 'T' 'H' to ''
compose 't' 'h' to ''
compose 's' 's' to ''
compose '"' 'y' to ''
compose 's' 'z' to ''
compose 'i' 'j' to ''
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7