q3k/linux
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
linux/drivers/char/ec3104_keyb.c
David Howells 7d12e780e0 IRQ: Maintain regs pointer globally rather than passing to IRQ handlers 
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.

The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around.  On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).

Where appropriate, an arch may override the generic storage facility and do
something different with the variable.  On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.

Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions.  Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller.  A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.

I've build this code with allyesconfig for x86_64 and i386.  I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.

This will affect all archs.  Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:

	struct pt_regs *old_regs = set_irq_regs(regs);

And put the old one back at the end:

	set_irq_regs(old_regs);

Don't pass regs through to generic_handle_irq() or __do_IRQ().

In timer_interrupt(), this sort of change will be necessary:

	-	update_process_times(user_mode(regs));
	-	profile_tick(CPU_PROFILING, regs);
	+	update_process_times(user_mode(get_irq_regs()));
	+	profile_tick(CPU_PROFILING);

I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().

Some notes on the interrupt handling in the drivers:

 (*) input_dev() is now gone entirely.  The regs pointer is no longer stored in
     the input_dev struct.

 (*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking.  It does
     something different depending on whether it's been supplied with a regs
     pointer or not.

 (*) Various IRQ handler function pointers have been moved to type
     irq_handler_t.

Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 15:10:12 +01:00

458 lines
9 KiB
C
Raw Blame History

/*
* linux/drivers/char/ec3104_keyb.c
*
* Copyright (C) 2000 Philipp Rumpf <prumpf@tux.org>
*
* based on linux/drivers/char/pc_keyb.c, which had the following comments:
*
* Separation of the PC low-level part by Geert Uytterhoeven, May 1997
* See keyboard.c for the whole history.
*
* Major cleanup by Martin Mares, May 1997
*
* Combined the keyboard and PS/2 mouse handling into one file,
* because they share the same hardware.
* Johan Myreen <jem@iki.fi> 1998-10-08.
*
* Code fixes to handle mouse ACKs properly.
* C. Scott Ananian <cananian@alumni.princeton.edu> 1999-01-29.
*/
/* EC3104 note:
* This code was written without any documentation about the EC3104 chip. While
* I hope I got most of the basic functionality right, the register names I use
* are most likely completely different from those in the chip documentation.
*
* If you have any further information about the EC3104, please tell me
* (prumpf@tux.org).
*/
#include <linux/spinlock.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/tty.h>
#include <linux/mm.h>
#include <linux/signal.h>
#include <linux/init.h>
#include <linux/kbd_ll.h>
#include <linux/delay.h>
#include <linux/random.h>
#include <linux/poll.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/kbd_kern.h>
#include <linux/smp_lock.h>
#include <linux/bitops.h>
#include <asm/keyboard.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/system.h>
#include <asm/ec3104.h>
#include <asm/io.h>
/* Some configuration switches are present in the include file... */
#include <linux/pc_keyb.h>
#define MSR_CTS 0x10
#define MCR_RTS 0x02
#define LSR_DR 0x01
#define LSR_BOTH_EMPTY 0x60
static struct e5_struct {
u8 packet[8];
int pos;
int length;
u8 cached_mcr;
u8 last_msr;
} ec3104_keyb;
/* Simple translation table for the SysRq keys */
#ifdef CONFIG_MAGIC_SYSRQ
unsigned char ec3104_kbd_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
static void kbd_write_command_w(int data);
static void kbd_write_output_w(int data);
#ifdef CONFIG_PSMOUSE
static void aux_write_ack(int val);
static void __aux_write_ack(int val);
#endif
static DEFINE_SPINLOCK(kbd_controller_lock);
static unsigned char handle_kbd_event(void);
/* used only by send_data - set by keyboard_interrupt */
static volatile unsigned char reply_expected;
static volatile unsigned char acknowledge;
static volatile unsigned char resend;
int ec3104_kbd_setkeycode(unsigned int scancode, unsigned int keycode)
{
return 0;
}
int ec3104_kbd_getkeycode(unsigned int scancode)
{
return 0;
}
/* yes, it probably would be faster to use an array. I don't care. */
static inline unsigned char ec3104_scan2key(unsigned char scancode)
{
switch (scancode) {
case 1: /* '`' */
return 41;
case 2 ... 27:
return scancode;
case 28: /* '\\' */
return 43;
case 29 ... 39:
return scancode + 1;
case 40: /* '\r' */
return 28;
case 41 ... 50:
return scancode + 3;
case 51: /* ' ' */
return 57;
case 52: /* escape */
return 1;
case 54: /* insert/delete (labelled delete) */
/* this should arguably be 110, but I'd like to have ctrl-alt-del
* working with a standard keymap */
return 111;
case 55: /* left */
return 105;
case 56: /* home */
return 102;
case 57: /* end */
return 107;
case 58: /* up */
return 103;
case 59: /* down */
return 108;
case 60: /* pgup */
return 104;
case 61: /* pgdown */
return 109;
case 62: /* right */
return 106;
case 79 ... 88: /* f1 - f10 */
return scancode - 20;
case 89 ... 90: /* f11 - f12 */
return scancode - 2;
case 91: /* left shift */
return 42;
case 92: /* right shift */
return 54;
case 93: /* left alt */
return 56;
case 94: /* right alt */
return 100;
case 95: /* left ctrl */
return 29;
case 96: /* right ctrl */
return 97;
case 97: /* caps lock */
return 58;
case 102: /* left windows */
return 125;
case 103: /* right windows */
return 126;
case 106: /* Fn */
/* this is wrong. */
return 84;
default:
return 0;
}
}
int ec3104_kbd_translate(unsigned char scancode, unsigned char *keycode,
char raw_mode)
{
scancode &= 0x7f;
*keycode = ec3104_scan2key(scancode);
return 1;
}
char ec3104_kbd_unexpected_up(unsigned char keycode)
{
return 0200;
}
static inline void handle_keyboard_event(unsigned char scancode)
{
#ifdef CONFIG_VT
handle_scancode(scancode, !(scancode & 0x80));
#endif
tasklet_schedule(&keyboard_tasklet);
}
void ec3104_kbd_leds(unsigned char leds)
{
}
static u8 e5_checksum(u8 *packet, int count)
{
int i;
u8 sum = 0;
for (i=0; i<count; i++)
sum ^= packet[i];
if (sum & 0x80)
sum ^= 0xc0;
return sum;
}
static void e5_wait_for_cts(struct e5_struct *k)
{
u8 msr;
do {
msr = ctrl_inb(EC3104_SER4_MSR);
} while (!(msr & MSR_CTS));
}
static void e5_send_byte(u8 byte, struct e5_struct *k)
{
u8 status;
do {
status = ctrl_inb(EC3104_SER4_LSR);
} while ((status & LSR_BOTH_EMPTY) != LSR_BOTH_EMPTY);
printk("<%02x>", byte);
ctrl_outb(byte, EC3104_SER4_DATA);
do {
status = ctrl_inb(EC3104_SER4_LSR);
} while ((status & LSR_BOTH_EMPTY) != LSR_BOTH_EMPTY);
}
static int e5_send_packet(u8 *packet, int count, struct e5_struct *k)
{
int i;
disable_irq(EC3104_IRQ_SER4);
if (k->cached_mcr & MCR_RTS) {
printk("e5_send_packet: too slow\n");
enable_irq(EC3104_IRQ_SER4);
return -EAGAIN;
}
k->cached_mcr |= MCR_RTS;
ctrl_outb(k->cached_mcr, EC3104_SER4_MCR);
e5_wait_for_cts(k);
printk("p: ");
for(i=0; i<count; i++)
e5_send_byte(packet[i], k);
e5_send_byte(e5_checksum(packet, count), k);
printk("\n");
udelay(1500);
k->cached_mcr &= ~MCR_RTS;
ctrl_outb(k->cached_mcr, EC3104_SER4_MCR);
set_current_state(TASK_UNINTERRUPTIBLE);
enable_irq(EC3104_IRQ_SER4);
return 0;
}
/*
* E5 packets we know about:
* E5->host 0x80 0x05 <checksum> - resend packet
* host->E5 0x83 0x43 <contrast> - set LCD contrast
* host->E5 0x85 0x41 0x02 <brightness> 0x02 - set LCD backlight
* E5->host 0x87 <ps2 packet> 0x00 <checksum> - external PS2
* E5->host 0x88 <scancode> <checksum> - key press
*/
static void e5_receive(struct e5_struct *k)
{
k->packet[k->pos++] = ctrl_inb(EC3104_SER4_DATA);
if (k->pos == 1) {
switch(k->packet[0]) {
case 0x80:
k->length = 3;
break;
case 0x87: /* PS2 ext */
k->length = 6;
break;
case 0x88: /* keyboard */
k->length = 3;
break;
default:
k->length = 1;
printk(KERN_WARNING "unknown E5 packet %02x\n",
k->packet[0]);
}
}
if (k->pos == k->length) {
int i;
if (e5_checksum(k->packet, k->length) != 0)
printk(KERN_WARNING "E5: wrong checksum\n");
#if 0
printk("E5 packet [");
for(i=0; i<k->length; i++) {
printk("%02x ", k->packet[i]);
}
printk("(%02x)]\n", e5_checksum(k->packet, k->length-1));
#endif
switch(k->packet[0]) {
case 0x80:
case 0x88:
handle_keyboard_event(k->packet[1]);
break;
}
k->pos = k->length = 0;
}
}
static void ec3104_keyb_interrupt(int irq, void *data)
{
struct e5_struct *k = &ec3104_keyb;
u8 msr, lsr;
msr = ctrl_inb(EC3104_SER4_MSR);
if ((msr & MSR_CTS) && !(k->last_msr & MSR_CTS)) {
if (k->cached_mcr & MCR_RTS)
printk("confused: RTS already high\n");
/* CTS went high. Send RTS. */
k->cached_mcr |= MCR_RTS;
ctrl_outb(k->cached_mcr, EC3104_SER4_MCR);
} else if ((!(msr & MSR_CTS)) && (k->last_msr & MSR_CTS)) {
/* CTS went low. */
if (!(k->cached_mcr & MCR_RTS))
printk("confused: RTS already low\n");
k->cached_mcr &= ~MCR_RTS;
ctrl_outb(k->cached_mcr, EC3104_SER4_MCR);
}
k->last_msr = msr;
lsr = ctrl_inb(EC3104_SER4_LSR);
if (lsr & LSR_DR)
e5_receive(k);
}
static void ec3104_keyb_clear_state(void)
{
struct e5_struct *k = &ec3104_keyb;
u8 msr, lsr;
/* we want CTS to be low */
k->last_msr = 0;
for (;;) {
msleep(100);
msr = ctrl_inb(EC3104_SER4_MSR);
lsr = ctrl_inb(EC3104_SER4_LSR);
if (lsr & LSR_DR) {
e5_receive(k);
continue;
}
if ((msr & MSR_CTS) && !(k->last_msr & MSR_CTS)) {
if (k->cached_mcr & MCR_RTS)
printk("confused: RTS already high\n");
/* CTS went high. Send RTS. */
k->cached_mcr |= MCR_RTS;
ctrl_outb(k->cached_mcr, EC3104_SER4_MCR);
} else if ((!(msr & MSR_CTS)) && (k->last_msr & MSR_CTS)) {
/* CTS went low. */
if (!(k->cached_mcr & MCR_RTS))
printk("confused: RTS already low\n");
k->cached_mcr &= ~MCR_RTS;
ctrl_outb(k->cached_mcr, EC3104_SER4_MCR);
} else
break;
k->last_msr = msr;
continue;
}
}
void __init ec3104_kbd_init_hw(void)
{
ec3104_keyb.last_msr = ctrl_inb(EC3104_SER4_MSR);
ec3104_keyb.cached_mcr = ctrl_inb(EC3104_SER4_MCR);
ec3104_keyb_clear_state();
/* Ok, finally allocate the IRQ, and off we go.. */
request_irq(EC3104_IRQ_SER4, ec3104_keyb_interrupt, 0, "keyboard", NULL);
}
Reference in a new issue View git blame Copy permalink