2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* linux/drivers/char/keyboard.c
|
|
|
|
|
*
|
|
|
|
|
* Written for linux by Johan Myreen as a translation from
|
|
|
|
|
* the assembly version by Linus (with diacriticals added)
|
|
|
|
|
*
|
|
|
|
|
* Some additional features added by Christoph Niemann (ChN), March 1993
|
|
|
|
|
*
|
|
|
|
|
* Loadable keymaps by Risto Kankkunen, May 1993
|
|
|
|
|
*
|
|
|
|
|
* Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
|
|
|
|
|
* Added decr/incr_console, dynamic keymaps, Unicode support,
|
|
|
|
|
* dynamic function/string keys, led setting, Sept 1994
|
|
|
|
|
* `Sticky' modifier keys, 951006.
|
|
|
|
|
*
|
|
|
|
|
* 11-11-96: SAK should now work in the raw mode (Martin Mares)
|
2005-09-11 01:03:38 +08:00
|
|
|
*
|
2005-04-17 06:20:36 +08:00
|
|
|
* Modified to provide 'generic' keyboard support by Hamish Macdonald
|
|
|
|
|
* Merge with the m68k keyboard driver and split-off of the PC low-level
|
|
|
|
|
* parts by Geert Uytterhoeven, May 1997
|
|
|
|
|
*
|
|
|
|
|
* 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
|
|
|
|
|
* 30-07-98: Dead keys redone, aeb@cwi.nl.
|
|
|
|
|
* 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
|
|
|
|
|
*/
|
|
|
|
|
|
2010-03-22 13:31:26 +08:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
|
2007-07-16 14:40:40 +08:00
|
|
|
#include <linux/consolemap.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/sched.h>
|
|
|
|
|
#include <linux/tty.h>
|
|
|
|
|
#include <linux/tty_flip.h>
|
|
|
|
|
#include <linux/mm.h>
|
|
|
|
|
#include <linux/string.h>
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/slab.h>
|
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 21:55:46 +08:00
|
|
|
#include <linux/irq.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
#include <linux/kbd_kern.h>
|
|
|
|
|
#include <linux/kbd_diacr.h>
|
|
|
|
|
#include <linux/vt_kern.h>
|
|
|
|
|
#include <linux/input.h>
|
2006-06-25 20:47:41 +08:00
|
|
|
#include <linux/reboot.h>
|
Console keyboard events and accessibility
Some blind people use a kernel engine called Speakup which uses hardware
synthesis to speak what gets displayed on the screen. They use the
PC keyboard to control this engine (start/stop, accelerate, ...) and
also need to get keyboard feedback (to make sure to know what they are
typing, the caps lock status, etc.)
Up to now, the way it was done was very ugly. Below is a patch to add a
notifier list for permitting a far better implementation, see ChangeLog
above for details.
You may wonder why this can't be done at the input layer. The problem
is that what people want to monitor is the console keyboard, i.e. all
input keyboards that got attached to the console, and with the currently
active keymap (i.e. keysyms, not only keycodes).
This adds a keyboard notifier that such modules can use to get the keyboard
events and possibly eat them, at several stages:
- keycodes: even before translation into keysym.
- unbound keycodes: when no keysym is bound.
- unicode: when the keycode would get translated into a unicode character.
- keysym: when the keycode would get translated into a keysym.
- post_keysym: after the keysym got interpreted, so as to see the result
(caps lock, etc.)
This also provides access to k_handler so as to permit simulation of
keypresses.
[akpm@linux-foundation.org: various fixes]
Signed-off-by: Samuel Thibault <samuel.thibault@ens-lyon.org>
Cc: Jiri Kosina <jkosina@suse.cz>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-19 14:39:12 +08:00
|
|
|
#include <linux/notifier.h>
|
2008-04-17 21:28:25 +08:00
|
|
|
#include <linux/jiffies.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
extern void ctrl_alt_del(void);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Exported functions/variables
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
|
|
|
|
|
* This seems a good reason to start with NumLock off. On HIL keyboards
|
2005-09-11 01:03:38 +08:00
|
|
|
* of PARISC machines however there is no NumLock key and everyone expects the keypad
|
2005-04-17 06:20:36 +08:00
|
|
|
* to be used for numbers.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
|
|
|
|
|
#define KBD_DEFLEDS (1 << VC_NUMLOCK)
|
|
|
|
|
#else
|
|
|
|
|
#define KBD_DEFLEDS 0
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#define KBD_DEFLOCK 0
|
|
|
|
|
|
|
|
|
|
void compute_shiftstate(void);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Handler Tables.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define K_HANDLERS\
|
|
|
|
|
k_self, k_fn, k_spec, k_pad,\
|
|
|
|
|
k_dead, k_cons, k_cur, k_shift,\
|
|
|
|
|
k_meta, k_ascii, k_lock, k_lowercase,\
|
2006-04-02 13:10:28 +08:00
|
|
|
k_slock, k_dead2, k_brl, k_ignore
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-09-11 01:03:38 +08:00
|
|
|
typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
|
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 21:55:46 +08:00
|
|
|
char up_flag);
|
2005-04-17 06:20:36 +08:00
|
|
|
static k_handler_fn K_HANDLERS;
|
2010-03-22 13:31:26 +08:00
|
|
|
static k_handler_fn *k_handler[16] = { K_HANDLERS };
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
#define FN_HANDLERS\
|
2005-09-11 01:03:38 +08:00
|
|
|
fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
|
|
|
|
|
fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
|
|
|
|
|
fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
|
|
|
|
|
fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
|
|
|
|
|
fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
|
2005-04-17 06:20:36 +08:00
|
|
|
|
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 21:55:46 +08:00
|
|
|
typedef void (fn_handler_fn)(struct vc_data *vc);
|
2005-04-17 06:20:36 +08:00
|
|
|
static fn_handler_fn FN_HANDLERS;
|
|
|
|
|
static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Variables exported for vt_ioctl.c
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* maximum values each key_handler can handle */
|
|
|
|
|
const int max_vals[] = {
|
|
|
|
|
255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
|
|
|
|
|
NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
|
2006-04-02 13:10:28 +08:00
|
|
|
255, NR_LOCK - 1, 255, NR_BRL - 1
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const int NR_TYPES = ARRAY_SIZE(max_vals);
|
|
|
|
|
|
|
|
|
|
struct kbd_struct kbd_table[MAX_NR_CONSOLES];
|
2008-04-30 15:54:51 +08:00
|
|
|
EXPORT_SYMBOL_GPL(kbd_table);
|
2005-04-17 06:20:36 +08:00
|
|
|
static struct kbd_struct *kbd = kbd_table;
|
|
|
|
|
|
2006-10-02 17:17:13 +08:00
|
|
|
struct vt_spawn_console vt_spawn_con = {
|
2007-05-08 15:30:09 +08:00
|
|
|
.lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
|
2006-10-02 17:17:13 +08:00
|
|
|
.pid = NULL,
|
|
|
|
|
.sig = 0,
|
|
|
|
|
};
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Variables exported for vt.c
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
int shift_state = 0;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Internal Data.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static struct input_handler kbd_handler;
|
2009-11-30 15:40:58 +08:00
|
|
|
static DEFINE_SPINLOCK(kbd_event_lock);
|
2007-10-19 14:40:32 +08:00
|
|
|
static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
|
2005-04-17 06:20:36 +08:00
|
|
|
static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
|
2010-03-22 13:31:26 +08:00
|
|
|
static bool dead_key_next;
|
2005-04-17 06:20:36 +08:00
|
|
|
static int npadch = -1; /* -1 or number assembled on pad */
|
2006-04-02 13:10:28 +08:00
|
|
|
static unsigned int diacr;
|
2005-04-17 06:20:36 +08:00
|
|
|
static char rep; /* flag telling character repeat */
|
|
|
|
|
|
|
|
|
|
static unsigned char ledstate = 0xff; /* undefined */
|
|
|
|
|
static unsigned char ledioctl;
|
|
|
|
|
|
|
|
|
|
static struct ledptr {
|
|
|
|
|
unsigned int *addr;
|
|
|
|
|
unsigned int mask;
|
|
|
|
|
unsigned char valid:1;
|
|
|
|
|
} ledptrs[3];
|
|
|
|
|
|
Console keyboard events and accessibility
Some blind people use a kernel engine called Speakup which uses hardware
synthesis to speak what gets displayed on the screen. They use the
PC keyboard to control this engine (start/stop, accelerate, ...) and
also need to get keyboard feedback (to make sure to know what they are
typing, the caps lock status, etc.)
Up to now, the way it was done was very ugly. Below is a patch to add a
notifier list for permitting a far better implementation, see ChangeLog
above for details.
You may wonder why this can't be done at the input layer. The problem
is that what people want to monitor is the console keyboard, i.e. all
input keyboards that got attached to the console, and with the currently
active keymap (i.e. keysyms, not only keycodes).
This adds a keyboard notifier that such modules can use to get the keyboard
events and possibly eat them, at several stages:
- keycodes: even before translation into keysym.
- unbound keycodes: when no keysym is bound.
- unicode: when the keycode would get translated into a unicode character.
- keysym: when the keycode would get translated into a keysym.
- post_keysym: after the keysym got interpreted, so as to see the result
(caps lock, etc.)
This also provides access to k_handler so as to permit simulation of
keypresses.
[akpm@linux-foundation.org: various fixes]
Signed-off-by: Samuel Thibault <samuel.thibault@ens-lyon.org>
Cc: Jiri Kosina <jkosina@suse.cz>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-19 14:39:12 +08:00
|
|
|
/*
|
|
|
|
|
* Notifier list for console keyboard events
|
|
|
|
|
*/
|
|
|
|
|
static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
|
|
|
|
|
|
|
|
|
|
int register_keyboard_notifier(struct notifier_block *nb)
|
|
|
|
|
{
|
|
|
|
|
return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(register_keyboard_notifier);
|
|
|
|
|
|
|
|
|
|
int unregister_keyboard_notifier(struct notifier_block *nb)
|
|
|
|
|
{
|
|
|
|
|
return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2007-03-15 10:50:42 +08:00
|
|
|
* Translation of scancodes to keycodes. We set them on only the first
|
|
|
|
|
* keyboard in the list that accepts the scancode and keycode.
|
|
|
|
|
* Explanation for not choosing the first attached keyboard anymore:
|
|
|
|
|
* USB keyboards for example have two event devices: one for all "normal"
|
|
|
|
|
* keys and one for extra function keys (like "volume up", "make coffee",
|
|
|
|
|
* etc.). So this means that scancodes for the extra function keys won't
|
|
|
|
|
* be valid for the first event device, but will be for the second.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2009-12-02 13:54:35 +08:00
|
|
|
|
|
|
|
|
struct getset_keycode_data {
|
|
|
|
|
unsigned int scancode;
|
|
|
|
|
unsigned int keycode;
|
|
|
|
|
int error;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int getkeycode_helper(struct input_handle *handle, void *data)
|
|
|
|
|
{
|
|
|
|
|
struct getset_keycode_data *d = data;
|
|
|
|
|
|
|
|
|
|
d->error = input_get_keycode(handle->dev, d->scancode, &d->keycode);
|
|
|
|
|
|
|
|
|
|
return d->error == 0; /* stop as soon as we successfully get one */
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
int getkeycode(unsigned int scancode)
|
|
|
|
|
{
|
2009-12-02 13:54:35 +08:00
|
|
|
struct getset_keycode_data d = { scancode, 0, -ENODEV };
|
2007-03-15 10:50:42 +08:00
|
|
|
|
2009-12-02 13:54:35 +08:00
|
|
|
input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-12-02 13:54:35 +08:00
|
|
|
return d.error ?: d.keycode;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int setkeycode_helper(struct input_handle *handle, void *data)
|
|
|
|
|
{
|
|
|
|
|
struct getset_keycode_data *d = data;
|
|
|
|
|
|
|
|
|
|
d->error = input_set_keycode(handle->dev, d->scancode, d->keycode);
|
|
|
|
|
|
|
|
|
|
return d->error == 0; /* stop as soon as we successfully set one */
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int setkeycode(unsigned int scancode, unsigned int keycode)
|
|
|
|
|
{
|
2009-12-02 13:54:35 +08:00
|
|
|
struct getset_keycode_data d = { scancode, keycode, -ENODEV };
|
2007-03-15 10:50:42 +08:00
|
|
|
|
2009-12-02 13:54:35 +08:00
|
|
|
input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-12-02 13:54:35 +08:00
|
|
|
return d.error;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2009-12-16 08:26:53 +08:00
|
|
|
* Making beeps and bells. Note that we prefer beeps to bells, but when
|
|
|
|
|
* shutting the sound off we do both.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2009-12-02 13:54:35 +08:00
|
|
|
|
|
|
|
|
static int kd_sound_helper(struct input_handle *handle, void *data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-12-02 13:54:35 +08:00
|
|
|
unsigned int *hz = data;
|
|
|
|
|
struct input_dev *dev = handle->dev;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-12-02 13:54:35 +08:00
|
|
|
if (test_bit(EV_SND, dev->evbit)) {
|
2009-12-16 08:26:53 +08:00
|
|
|
if (test_bit(SND_TONE, dev->sndbit)) {
|
2009-12-02 13:54:35 +08:00
|
|
|
input_inject_event(handle, EV_SND, SND_TONE, *hz);
|
2009-12-16 08:26:53 +08:00
|
|
|
if (*hz)
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (test_bit(SND_BELL, dev->sndbit))
|
2009-12-02 13:54:35 +08:00
|
|
|
input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2009-12-02 13:54:35 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void kd_nosound(unsigned long ignored)
|
|
|
|
|
{
|
|
|
|
|
static unsigned int zero;
|
|
|
|
|
|
|
|
|
|
input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2005-09-10 04:10:40 +08:00
|
|
|
static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
void kd_mksound(unsigned int hz, unsigned int ticks)
|
|
|
|
|
{
|
2009-12-02 13:54:35 +08:00
|
|
|
del_timer_sync(&kd_mksound_timer);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-12-02 13:54:35 +08:00
|
|
|
input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-12-02 13:54:35 +08:00
|
|
|
if (hz && ticks)
|
|
|
|
|
mod_timer(&kd_mksound_timer, jiffies + ticks);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-04-30 15:54:51 +08:00
|
|
|
EXPORT_SYMBOL(kd_mksound);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Setting the keyboard rate.
|
|
|
|
|
*/
|
|
|
|
|
|
2009-12-02 13:54:35 +08:00
|
|
|
static int kbd_rate_helper(struct input_handle *handle, void *data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-12-02 13:54:35 +08:00
|
|
|
struct input_dev *dev = handle->dev;
|
|
|
|
|
struct kbd_repeat *rep = data;
|
|
|
|
|
|
|
|
|
|
if (test_bit(EV_REP, dev->evbit)) {
|
|
|
|
|
|
|
|
|
|
if (rep[0].delay > 0)
|
|
|
|
|
input_inject_event(handle,
|
|
|
|
|
EV_REP, REP_DELAY, rep[0].delay);
|
|
|
|
|
if (rep[0].period > 0)
|
|
|
|
|
input_inject_event(handle,
|
|
|
|
|
EV_REP, REP_PERIOD, rep[0].period);
|
|
|
|
|
|
|
|
|
|
rep[1].delay = dev->rep[REP_DELAY];
|
|
|
|
|
rep[1].period = dev->rep[REP_PERIOD];
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2009-12-02 13:54:35 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kbd_rate(struct kbd_repeat *rep)
|
|
|
|
|
{
|
|
|
|
|
struct kbd_repeat data[2] = { *rep };
|
|
|
|
|
|
|
|
|
|
input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
|
|
|
|
|
*rep = data[1]; /* Copy currently used settings */
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Helper Functions.
|
|
|
|
|
*/
|
|
|
|
|
static void put_queue(struct vc_data *vc, int ch)
|
|
|
|
|
{
|
2010-06-02 04:52:56 +08:00
|
|
|
struct tty_struct *tty = vc->port.tty;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
if (tty) {
|
|
|
|
|
tty_insert_flip_char(tty, ch, 0);
|
|
|
|
|
con_schedule_flip(tty);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void puts_queue(struct vc_data *vc, char *cp)
|
|
|
|
|
{
|
2010-06-02 04:52:56 +08:00
|
|
|
struct tty_struct *tty = vc->port.tty;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
if (!tty)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
while (*cp) {
|
|
|
|
|
tty_insert_flip_char(tty, *cp, 0);
|
|
|
|
|
cp++;
|
|
|
|
|
}
|
|
|
|
|
con_schedule_flip(tty);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void applkey(struct vc_data *vc, int key, char mode)
|
|
|
|
|
{
|
|
|
|
|
static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
|
|
|
|
|
|
|
|
|
|
buf[1] = (mode ? 'O' : '[');
|
|
|
|
|
buf[2] = key;
|
|
|
|
|
puts_queue(vc, buf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Many other routines do put_queue, but I think either
|
|
|
|
|
* they produce ASCII, or they produce some user-assigned
|
|
|
|
|
* string, and in both cases we might assume that it is
|
2007-07-16 14:40:40 +08:00
|
|
|
* in utf-8 already.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2007-07-16 14:40:40 +08:00
|
|
|
static void to_utf8(struct vc_data *vc, uint c)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
if (c < 0x80)
|
|
|
|
|
/* 0******* */
|
|
|
|
|
put_queue(vc, c);
|
2005-09-11 01:03:38 +08:00
|
|
|
else if (c < 0x800) {
|
2005-04-17 06:20:36 +08:00
|
|
|
/* 110***** 10****** */
|
2005-09-11 01:03:38 +08:00
|
|
|
put_queue(vc, 0xc0 | (c >> 6));
|
2005-04-17 06:20:36 +08:00
|
|
|
put_queue(vc, 0x80 | (c & 0x3f));
|
2010-03-22 13:31:26 +08:00
|
|
|
} else if (c < 0x10000) {
|
|
|
|
|
if (c >= 0xD800 && c < 0xE000)
|
2007-07-16 14:40:40 +08:00
|
|
|
return;
|
|
|
|
|
if (c == 0xFFFF)
|
|
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
/* 1110**** 10****** 10****** */
|
|
|
|
|
put_queue(vc, 0xe0 | (c >> 12));
|
|
|
|
|
put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
|
|
|
|
|
put_queue(vc, 0x80 | (c & 0x3f));
|
2010-03-22 13:31:26 +08:00
|
|
|
} else if (c < 0x110000) {
|
2007-07-16 14:40:40 +08:00
|
|
|
/* 11110*** 10****** 10****** 10****** */
|
|
|
|
|
put_queue(vc, 0xf0 | (c >> 18));
|
|
|
|
|
put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
|
|
|
|
|
put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
|
|
|
|
|
put_queue(vc, 0x80 | (c & 0x3f));
|
2005-09-11 01:03:38 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2005-09-11 01:03:38 +08:00
|
|
|
/*
|
2005-04-17 06:20:36 +08:00
|
|
|
* Called after returning from RAW mode or when changing consoles - recompute
|
|
|
|
|
* shift_down[] and shift_state from key_down[] maybe called when keymap is
|
|
|
|
|
* undefined, so that shiftkey release is seen
|
|
|
|
|
*/
|
|
|
|
|
void compute_shiftstate(void)
|
|
|
|
|
{
|
|
|
|
|
unsigned int i, j, k, sym, val;
|
|
|
|
|
|
|
|
|
|
shift_state = 0;
|
|
|
|
|
memset(shift_down, 0, sizeof(shift_down));
|
2005-09-11 01:03:38 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
for (i = 0; i < ARRAY_SIZE(key_down); i++) {
|
|
|
|
|
|
|
|
|
|
if (!key_down[i])
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
k = i * BITS_PER_LONG;
|
|
|
|
|
|
|
|
|
|
for (j = 0; j < BITS_PER_LONG; j++, k++) {
|
|
|
|
|
|
|
|
|
|
if (!test_bit(k, key_down))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
sym = U(key_maps[0][k]);
|
|
|
|
|
if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
val = KVAL(sym);
|
|
|
|
|
if (val == KVAL(K_CAPSSHIFT))
|
|
|
|
|
val = KVAL(K_SHIFT);
|
|
|
|
|
|
|
|
|
|
shift_down[val]++;
|
|
|
|
|
shift_state |= (1 << val);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We have a combining character DIACR here, followed by the character CH.
|
|
|
|
|
* If the combination occurs in the table, return the corresponding value.
|
|
|
|
|
* Otherwise, if CH is a space or equals DIACR, return DIACR.
|
|
|
|
|
* Otherwise, conclude that DIACR was not combining after all,
|
|
|
|
|
* queue it and return CH.
|
|
|
|
|
*/
|
2006-04-02 13:10:28 +08:00
|
|
|
static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-04-02 13:10:28 +08:00
|
|
|
unsigned int d = diacr;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
|
|
diacr = 0;
|
|
|
|
|
|
2006-04-02 13:10:28 +08:00
|
|
|
if ((d & ~0xff) == BRL_UC_ROW) {
|
|
|
|
|
if ((ch & ~0xff) == BRL_UC_ROW)
|
|
|
|
|
return d | ch;
|
|
|
|
|
} else {
|
|
|
|
|
for (i = 0; i < accent_table_size; i++)
|
|
|
|
|
if (accent_table[i].diacr == d && accent_table[i].base == ch)
|
|
|
|
|
return accent_table[i].result;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2006-04-02 13:10:28 +08:00
|
|
|
if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
|
2005-04-17 06:20:36 +08:00
|
|
|
return d;
|
|
|
|
|
|
2006-04-02 13:10:28 +08:00
|
|
|
if (kbd->kbdmode == VC_UNICODE)
|
2007-10-17 14:27:04 +08:00
|
|
|
to_utf8(vc, d);
|
|
|
|
|
else {
|
|
|
|
|
int c = conv_uni_to_8bit(d);
|
|
|
|
|
if (c != -1)
|
|
|
|
|
put_queue(vc, c);
|
|
|
|
|
}
|
2006-04-02 13:10:28 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return ch;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Special function handlers
|
|
|
|
|
*/
|
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 21:55:46 +08:00
|
|
|
static void fn_enter(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
if (diacr) {
|
2006-04-02 13:10:28 +08:00
|
|
|
if (kbd->kbdmode == VC_UNICODE)
|
2007-10-17 14:27:04 +08:00
|
|
|
to_utf8(vc, diacr);
|
|
|
|
|
else {
|
|
|
|
|
int c = conv_uni_to_8bit(diacr);
|
|
|
|
|
if (c != -1)
|
|
|
|
|
put_queue(vc, c);
|
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
diacr = 0;
|
|
|
|
|
}
|
2010-03-22 13:31:26 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
put_queue(vc, 13);
|
|
|
|
|
if (vc_kbd_mode(kbd, VC_CRLF))
|
|
|
|
|
put_queue(vc, 10);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_caps_toggle(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
if (rep)
|
|
|
|
|
return;
|
2010-03-22 13:31:26 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
chg_vc_kbd_led(kbd, VC_CAPSLOCK);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_caps_on(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
if (rep)
|
|
|
|
|
return;
|
2010-03-22 13:31:26 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
set_vc_kbd_led(kbd, VC_CAPSLOCK);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_show_ptregs(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
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 21:55:46 +08:00
|
|
|
struct pt_regs *regs = get_irq_regs();
|
2010-03-22 13:31:26 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (regs)
|
|
|
|
|
show_regs(regs);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_hold(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-06-02 04:52:56 +08:00
|
|
|
struct tty_struct *tty = vc->port.tty;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
if (rep || !tty)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
|
|
|
|
|
* these routines are also activated by ^S/^Q.
|
|
|
|
|
* (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
|
|
|
|
|
*/
|
|
|
|
|
if (tty->stopped)
|
|
|
|
|
start_tty(tty);
|
|
|
|
|
else
|
|
|
|
|
stop_tty(tty);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_num(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-03-22 13:31:26 +08:00
|
|
|
if (vc_kbd_mode(kbd, VC_APPLIC))
|
2005-04-17 06:20:36 +08:00
|
|
|
applkey(vc, 'P', 1);
|
|
|
|
|
else
|
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 21:55:46 +08:00
|
|
|
fn_bare_num(vc);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Bind this to Shift-NumLock if you work in application keypad mode
|
|
|
|
|
* but want to be able to change the NumLock flag.
|
|
|
|
|
* Bind this to NumLock if you prefer that the NumLock key always
|
|
|
|
|
* changes the NumLock flag.
|
|
|
|
|
*/
|
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 21:55:46 +08:00
|
|
|
static void fn_bare_num(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
if (!rep)
|
|
|
|
|
chg_vc_kbd_led(kbd, VC_NUMLOCK);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_lastcons(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
/* switch to the last used console, ChN */
|
|
|
|
|
set_console(last_console);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_dec_console(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
int i, cur = fg_console;
|
|
|
|
|
|
|
|
|
|
/* Currently switching? Queue this next switch relative to that. */
|
|
|
|
|
if (want_console != -1)
|
|
|
|
|
cur = want_console;
|
|
|
|
|
|
2005-09-11 01:03:38 +08:00
|
|
|
for (i = cur - 1; i != cur; i--) {
|
2005-04-17 06:20:36 +08:00
|
|
|
if (i == -1)
|
2005-09-11 01:03:38 +08:00
|
|
|
i = MAX_NR_CONSOLES - 1;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (vc_cons_allocated(i))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
set_console(i);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_inc_console(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
int i, cur = fg_console;
|
|
|
|
|
|
|
|
|
|
/* Currently switching? Queue this next switch relative to that. */
|
|
|
|
|
if (want_console != -1)
|
|
|
|
|
cur = want_console;
|
|
|
|
|
|
|
|
|
|
for (i = cur+1; i != cur; i++) {
|
|
|
|
|
if (i == MAX_NR_CONSOLES)
|
|
|
|
|
i = 0;
|
|
|
|
|
if (vc_cons_allocated(i))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
set_console(i);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_send_intr(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-06-02 04:52:56 +08:00
|
|
|
struct tty_struct *tty = vc->port.tty;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
if (!tty)
|
|
|
|
|
return;
|
|
|
|
|
tty_insert_flip_char(tty, 0, TTY_BREAK);
|
|
|
|
|
con_schedule_flip(tty);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_scroll_forw(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
scrollfront(vc, 0);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_scroll_back(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
scrollback(vc, 0);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_show_mem(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
show_mem();
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_show_state(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
show_state();
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_boot_it(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
ctrl_alt_del();
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_compose(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-03-22 13:31:26 +08:00
|
|
|
dead_key_next = true;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_spawn_con(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-10-02 17:17:13 +08:00
|
|
|
spin_lock(&vt_spawn_con.lock);
|
|
|
|
|
if (vt_spawn_con.pid)
|
|
|
|
|
if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
|
|
|
|
|
put_pid(vt_spawn_con.pid);
|
|
|
|
|
vt_spawn_con.pid = NULL;
|
|
|
|
|
}
|
|
|
|
|
spin_unlock(&vt_spawn_con.lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_SAK(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2007-02-10 17:44:34 +08:00
|
|
|
struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
|
|
|
|
|
schedule_work(SAK_work);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void fn_null(struct vc_data *vc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
compute_shiftstate();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Special key handlers
|
|
|
|
|
*/
|
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 21:55:46 +08:00
|
|
|
static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
if (up_flag)
|
|
|
|
|
return;
|
|
|
|
|
if (value >= ARRAY_SIZE(fn_handler))
|
|
|
|
|
return;
|
2005-09-11 01:03:38 +08:00
|
|
|
if ((kbd->kbdmode == VC_RAW ||
|
|
|
|
|
kbd->kbdmode == VC_MEDIUMRAW) &&
|
2005-04-17 06:20:36 +08:00
|
|
|
value != KVAL(K_SAK))
|
|
|
|
|
return; /* SAK is allowed even in raw mode */
|
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 21:55:46 +08:00
|
|
|
fn_handler[value](vc);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-03-22 13:31:26 +08:00
|
|
|
pr_err("k_lowercase was called - impossible\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
if (up_flag)
|
|
|
|
|
return; /* no action, if this is a key release */
|
|
|
|
|
|
|
|
|
|
if (diacr)
|
|
|
|
|
value = handle_diacr(vc, value);
|
|
|
|
|
|
|
|
|
|
if (dead_key_next) {
|
2010-03-22 13:31:26 +08:00
|
|
|
dead_key_next = false;
|
2005-04-17 06:20:36 +08:00
|
|
|
diacr = value;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2006-04-02 13:10:28 +08:00
|
|
|
if (kbd->kbdmode == VC_UNICODE)
|
2007-10-17 14:27:04 +08:00
|
|
|
to_utf8(vc, value);
|
|
|
|
|
else {
|
|
|
|
|
int c = conv_uni_to_8bit(value);
|
|
|
|
|
if (c != -1)
|
|
|
|
|
put_queue(vc, c);
|
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Handle dead key. Note that we now may have several
|
|
|
|
|
* dead keys modifying the same character. Very useful
|
|
|
|
|
* for Vietnamese.
|
|
|
|
|
*/
|
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 21:55:46 +08:00
|
|
|
static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
if (up_flag)
|
|
|
|
|
return;
|
2010-03-22 13:31:26 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
diacr = (diacr ? handle_diacr(vc, value) : value);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
|
2006-04-02 13:10:28 +08:00
|
|
|
{
|
2008-06-13 06:21:51 +08:00
|
|
|
k_unicode(vc, conv_8bit_to_uni(value), up_flag);
|
2006-04-02 13:10:28 +08:00
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
|
2006-04-02 13:10:28 +08:00
|
|
|
{
|
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 21:55:46 +08:00
|
|
|
k_deadunicode(vc, value, up_flag);
|
2006-04-02 13:10:28 +08:00
|
|
|
}
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* Obsolete - for backwards compatibility only
|
|
|
|
|
*/
|
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 21:55:46 +08:00
|
|
|
static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-06-05 12:18:00 +08:00
|
|
|
static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
|
2010-03-22 13:31:26 +08:00
|
|
|
|
|
|
|
|
k_deadunicode(vc, ret_diacr[value], up_flag);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
if (up_flag)
|
|
|
|
|
return;
|
2010-03-22 13:31:26 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
set_console(value);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
if (up_flag)
|
|
|
|
|
return;
|
2010-03-22 13:31:26 +08:00
|
|
|
|
|
|
|
|
if ((unsigned)value < ARRAY_SIZE(func_table)) {
|
2005-04-17 06:20:36 +08:00
|
|
|
if (func_table[value])
|
|
|
|
|
puts_queue(vc, func_table[value]);
|
|
|
|
|
} else
|
2010-03-22 13:31:26 +08:00
|
|
|
pr_err("k_fn called with value=%d\n", value);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-11-05 11:09:08 +08:00
|
|
|
static const char cur_chars[] = "BDCA";
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
if (up_flag)
|
|
|
|
|
return;
|
2010-03-22 13:31:26 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-06-05 12:18:00 +08:00
|
|
|
static const char pad_chars[] = "0123456789+-*/\015,.?()#";
|
|
|
|
|
static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
if (up_flag)
|
|
|
|
|
return; /* no action, if this is a key release */
|
|
|
|
|
|
|
|
|
|
/* kludge... shift forces cursor/number keys */
|
|
|
|
|
if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
|
|
|
|
|
applkey(vc, app_map[value], 1);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2010-03-22 13:31:26 +08:00
|
|
|
if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (value) {
|
2010-03-22 13:31:26 +08:00
|
|
|
case KVAL(K_PCOMMA):
|
|
|
|
|
case KVAL(K_PDOT):
|
|
|
|
|
k_fn(vc, KVAL(K_REMOVE), 0);
|
|
|
|
|
return;
|
|
|
|
|
case KVAL(K_P0):
|
|
|
|
|
k_fn(vc, KVAL(K_INSERT), 0);
|
|
|
|
|
return;
|
|
|
|
|
case KVAL(K_P1):
|
|
|
|
|
k_fn(vc, KVAL(K_SELECT), 0);
|
|
|
|
|
return;
|
|
|
|
|
case KVAL(K_P2):
|
|
|
|
|
k_cur(vc, KVAL(K_DOWN), 0);
|
|
|
|
|
return;
|
|
|
|
|
case KVAL(K_P3):
|
|
|
|
|
k_fn(vc, KVAL(K_PGDN), 0);
|
|
|
|
|
return;
|
|
|
|
|
case KVAL(K_P4):
|
|
|
|
|
k_cur(vc, KVAL(K_LEFT), 0);
|
|
|
|
|
return;
|
|
|
|
|
case KVAL(K_P6):
|
|
|
|
|
k_cur(vc, KVAL(K_RIGHT), 0);
|
|
|
|
|
return;
|
|
|
|
|
case KVAL(K_P7):
|
|
|
|
|
k_fn(vc, KVAL(K_FIND), 0);
|
|
|
|
|
return;
|
|
|
|
|
case KVAL(K_P8):
|
|
|
|
|
k_cur(vc, KVAL(K_UP), 0);
|
|
|
|
|
return;
|
|
|
|
|
case KVAL(K_P9):
|
|
|
|
|
k_fn(vc, KVAL(K_PGUP), 0);
|
|
|
|
|
return;
|
|
|
|
|
case KVAL(K_P5):
|
|
|
|
|
applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
|
|
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2010-03-22 13:31:26 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
put_queue(vc, pad_chars[value]);
|
|
|
|
|
if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
|
|
|
|
|
put_queue(vc, 10);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
int old_state = shift_state;
|
|
|
|
|
|
|
|
|
|
if (rep)
|
|
|
|
|
return;
|
|
|
|
|
/*
|
|
|
|
|
* Mimic typewriter:
|
|
|
|
|
* a CapsShift key acts like Shift but undoes CapsLock
|
|
|
|
|
*/
|
|
|
|
|
if (value == KVAL(K_CAPSSHIFT)) {
|
|
|
|
|
value = KVAL(K_SHIFT);
|
|
|
|
|
if (!up_flag)
|
|
|
|
|
clr_vc_kbd_led(kbd, VC_CAPSLOCK);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (up_flag) {
|
|
|
|
|
/*
|
|
|
|
|
* handle the case that two shift or control
|
|
|
|
|
* keys are depressed simultaneously
|
|
|
|
|
*/
|
|
|
|
|
if (shift_down[value])
|
|
|
|
|
shift_down[value]--;
|
|
|
|
|
} else
|
|
|
|
|
shift_down[value]++;
|
|
|
|
|
|
|
|
|
|
if (shift_down[value])
|
|
|
|
|
shift_state |= (1 << value);
|
|
|
|
|
else
|
|
|
|
|
shift_state &= ~(1 << value);
|
|
|
|
|
|
|
|
|
|
/* kludge */
|
|
|
|
|
if (up_flag && shift_state != old_state && npadch != -1) {
|
|
|
|
|
if (kbd->kbdmode == VC_UNICODE)
|
2007-07-16 14:40:40 +08:00
|
|
|
to_utf8(vc, npadch);
|
2005-04-17 06:20:36 +08:00
|
|
|
else
|
|
|
|
|
put_queue(vc, npadch & 0xff);
|
|
|
|
|
npadch = -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
if (up_flag)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (vc_kbd_mode(kbd, VC_META)) {
|
|
|
|
|
put_queue(vc, '\033');
|
|
|
|
|
put_queue(vc, value);
|
|
|
|
|
} else
|
|
|
|
|
put_queue(vc, value | 0x80);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
int base;
|
|
|
|
|
|
|
|
|
|
if (up_flag)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (value < 10) {
|
|
|
|
|
/* decimal input of code, while Alt depressed */
|
|
|
|
|
base = 10;
|
|
|
|
|
} else {
|
|
|
|
|
/* hexadecimal input of code, while AltGr depressed */
|
|
|
|
|
value -= 10;
|
|
|
|
|
base = 16;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (npadch == -1)
|
|
|
|
|
npadch = value;
|
|
|
|
|
else
|
|
|
|
|
npadch = npadch * base + value;
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
if (up_flag || rep)
|
|
|
|
|
return;
|
2010-03-22 13:31:26 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
chg_vc_kbd_lock(kbd, value);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
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 21:55:46 +08:00
|
|
|
k_shift(vc, value, up_flag);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (up_flag || rep)
|
|
|
|
|
return;
|
2010-03-22 13:31:26 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
chg_vc_kbd_slock(kbd, value);
|
|
|
|
|
/* try to make Alt, oops, AltGr and such work */
|
|
|
|
|
if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
|
|
|
|
|
kbd->slockstate = 0;
|
|
|
|
|
chg_vc_kbd_slock(kbd, value);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-04-02 13:10:28 +08:00
|
|
|
/* by default, 300ms interval for combination release */
|
2006-04-26 12:14:10 +08:00
|
|
|
static unsigned brl_timeout = 300;
|
|
|
|
|
MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
|
|
|
|
|
module_param(brl_timeout, uint, 0644);
|
|
|
|
|
|
|
|
|
|
static unsigned brl_nbchords = 1;
|
|
|
|
|
MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
|
|
|
|
|
module_param(brl_nbchords, uint, 0644);
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
|
2006-04-26 12:14:10 +08:00
|
|
|
{
|
|
|
|
|
static unsigned long chords;
|
|
|
|
|
static unsigned committed;
|
|
|
|
|
|
|
|
|
|
if (!brl_nbchords)
|
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 21:55:46 +08:00
|
|
|
k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
|
2006-04-26 12:14:10 +08:00
|
|
|
else {
|
|
|
|
|
committed |= pattern;
|
|
|
|
|
chords++;
|
|
|
|
|
if (chords == brl_nbchords) {
|
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 21:55:46 +08:00
|
|
|
k_unicode(vc, BRL_UC_ROW | committed, up_flag);
|
2006-04-26 12:14:10 +08:00
|
|
|
chords = 0;
|
|
|
|
|
committed = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
|
2006-04-02 13:10:28 +08:00
|
|
|
{
|
2010-03-22 13:31:26 +08:00
|
|
|
static unsigned pressed, committing;
|
2006-04-02 13:10:28 +08:00
|
|
|
static unsigned long releasestart;
|
|
|
|
|
|
|
|
|
|
if (kbd->kbdmode != VC_UNICODE) {
|
|
|
|
|
if (!up_flag)
|
2010-03-22 13:31:26 +08:00
|
|
|
pr_warning("keyboard mode must be unicode for braille patterns\n");
|
2006-04-02 13:10:28 +08:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!value) {
|
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 21:55:46 +08:00
|
|
|
k_unicode(vc, BRL_UC_ROW, up_flag);
|
2006-04-02 13:10:28 +08:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (value > 8)
|
|
|
|
|
return;
|
|
|
|
|
|
2010-03-22 13:31:26 +08:00
|
|
|
if (!up_flag) {
|
2006-04-02 13:10:28 +08:00
|
|
|
pressed |= 1 << (value - 1);
|
|
|
|
|
if (!brl_timeout)
|
|
|
|
|
committing = pressed;
|
2010-03-22 13:31:26 +08:00
|
|
|
} else if (brl_timeout) {
|
|
|
|
|
if (!committing ||
|
|
|
|
|
time_after(jiffies,
|
|
|
|
|
releasestart + msecs_to_jiffies(brl_timeout))) {
|
|
|
|
|
committing = pressed;
|
|
|
|
|
releasestart = jiffies;
|
|
|
|
|
}
|
|
|
|
|
pressed &= ~(1 << (value - 1));
|
|
|
|
|
if (!pressed && committing) {
|
|
|
|
|
k_brlcommit(vc, committing, 0);
|
|
|
|
|
committing = 0;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (committing) {
|
|
|
|
|
k_brlcommit(vc, committing, 0);
|
|
|
|
|
committing = 0;
|
|
|
|
|
}
|
|
|
|
|
pressed &= ~(1 << (value - 1));
|
2006-04-02 13:10:28 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
|
|
|
|
|
* or (ii) whatever pattern of lights people want to show using KDSETLED,
|
|
|
|
|
* or (iii) specified bits of specified words in kernel memory.
|
|
|
|
|
*/
|
|
|
|
|
unsigned char getledstate(void)
|
|
|
|
|
{
|
|
|
|
|
return ledstate;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void setledstate(struct kbd_struct *kbd, unsigned int led)
|
|
|
|
|
{
|
|
|
|
|
if (!(led & ~7)) {
|
|
|
|
|
ledioctl = led;
|
|
|
|
|
kbd->ledmode = LED_SHOW_IOCTL;
|
|
|
|
|
} else
|
|
|
|
|
kbd->ledmode = LED_SHOW_FLAGS;
|
2010-03-22 13:31:26 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
set_leds();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline unsigned char getleds(void)
|
|
|
|
|
{
|
|
|
|
|
struct kbd_struct *kbd = kbd_table + fg_console;
|
|
|
|
|
unsigned char leds;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (kbd->ledmode == LED_SHOW_IOCTL)
|
|
|
|
|
return ledioctl;
|
|
|
|
|
|
|
|
|
|
leds = kbd->ledflagstate;
|
|
|
|
|
|
|
|
|
|
if (kbd->ledmode == LED_SHOW_MEM) {
|
|
|
|
|
for (i = 0; i < 3; i++)
|
|
|
|
|
if (ledptrs[i].valid) {
|
|
|
|
|
if (*ledptrs[i].addr & ledptrs[i].mask)
|
|
|
|
|
leds |= (1 << i);
|
|
|
|
|
else
|
|
|
|
|
leds &= ~(1 << i);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return leds;
|
|
|
|
|
}
|
|
|
|
|
|
2009-12-02 13:54:35 +08:00
|
|
|
static int kbd_update_leds_helper(struct input_handle *handle, void *data)
|
|
|
|
|
{
|
|
|
|
|
unsigned char leds = *(unsigned char *)data;
|
|
|
|
|
|
|
|
|
|
if (test_bit(EV_LED, handle->dev->evbit)) {
|
|
|
|
|
input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
|
|
|
|
|
input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
|
|
|
|
|
input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
|
|
|
|
|
input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2009-12-02 13:54:35 +08:00
|
|
|
* This is the tasklet that updates LED state on all keyboards
|
|
|
|
|
* attached to the box. The reason we use tasklet is that we
|
|
|
|
|
* need to handle the scenario when keyboard handler is not
|
|
|
|
|
* registered yet but we already getting updates form VT to
|
|
|
|
|
* update led state.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
static void kbd_bh(unsigned long dummy)
|
|
|
|
|
{
|
|
|
|
|
unsigned char leds = getleds();
|
|
|
|
|
|
|
|
|
|
if (leds != ledstate) {
|
2009-12-02 13:54:35 +08:00
|
|
|
input_handler_for_each_handle(&kbd_handler, &leds,
|
|
|
|
|
kbd_update_leds_helper);
|
|
|
|
|
ledstate = leds;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
|
|
|
|
|
|
|
|
|
|
#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
|
2005-12-23 13:03:47 +08:00
|
|
|
defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
|
|
|
|
|
defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
|
2007-12-04 20:15:41 +08:00
|
|
|
(defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
|
|
|
|
|
defined(CONFIG_AVR32)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
|
|
|
|
|
((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
|
|
|
|
|
|
2006-06-05 12:18:00 +08:00
|
|
|
static const unsigned short x86_keycodes[256] =
|
2005-04-17 06:20:36 +08:00
|
|
|
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
|
|
|
|
|
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
|
|
|
|
|
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
|
|
|
|
|
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
|
|
|
|
|
64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
|
|
|
|
|
80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
|
2006-07-19 13:14:25 +08:00
|
|
|
284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
|
2005-04-17 06:20:36 +08:00
|
|
|
367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
|
|
|
|
|
360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
|
2007-07-03 13:55:18 +08:00
|
|
|
103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
|
|
|
|
|
291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
|
2005-04-17 06:20:36 +08:00
|
|
|
264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
|
|
|
|
|
377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
|
|
|
|
|
308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
|
|
|
|
|
332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
|
|
|
|
|
|
2005-12-23 13:03:47 +08:00
|
|
|
#ifdef CONFIG_SPARC
|
2010-03-22 13:31:26 +08:00
|
|
|
static int sparc_l1_a_state;
|
2005-04-17 06:20:36 +08:00
|
|
|
extern void sun_do_break(void);
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-09-11 01:03:38 +08:00
|
|
|
static int emulate_raw(struct vc_data *vc, unsigned int keycode,
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned char up_flag)
|
|
|
|
|
{
|
2006-07-19 13:14:25 +08:00
|
|
|
int code;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
switch (keycode) {
|
2006-07-19 13:14:25 +08:00
|
|
|
|
2010-03-22 13:31:26 +08:00
|
|
|
case KEY_PAUSE:
|
|
|
|
|
put_queue(vc, 0xe1);
|
|
|
|
|
put_queue(vc, 0x1d | up_flag);
|
|
|
|
|
put_queue(vc, 0x45 | up_flag);
|
|
|
|
|
break;
|
2006-07-19 13:14:25 +08:00
|
|
|
|
2010-03-22 13:31:26 +08:00
|
|
|
case KEY_HANGEUL:
|
|
|
|
|
if (!up_flag)
|
|
|
|
|
put_queue(vc, 0xf2);
|
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-03-22 13:31:26 +08:00
|
|
|
case KEY_HANJA:
|
|
|
|
|
if (!up_flag)
|
|
|
|
|
put_queue(vc, 0xf1);
|
|
|
|
|
break;
|
2006-07-19 13:14:25 +08:00
|
|
|
|
2010-03-22 13:31:26 +08:00
|
|
|
case KEY_SYSRQ:
|
|
|
|
|
/*
|
|
|
|
|
* Real AT keyboards (that's what we're trying
|
|
|
|
|
* to emulate here emit 0xe0 0x2a 0xe0 0x37 when
|
|
|
|
|
* pressing PrtSc/SysRq alone, but simply 0x54
|
|
|
|
|
* when pressing Alt+PrtSc/SysRq.
|
|
|
|
|
*/
|
|
|
|
|
if (test_bit(KEY_LEFTALT, key_down) ||
|
|
|
|
|
test_bit(KEY_RIGHTALT, key_down)) {
|
|
|
|
|
put_queue(vc, 0x54 | up_flag);
|
|
|
|
|
} else {
|
|
|
|
|
put_queue(vc, 0xe0);
|
|
|
|
|
put_queue(vc, 0x2a | up_flag);
|
|
|
|
|
put_queue(vc, 0xe0);
|
|
|
|
|
put_queue(vc, 0x37 | up_flag);
|
|
|
|
|
}
|
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-03-22 13:31:26 +08:00
|
|
|
default:
|
|
|
|
|
if (keycode > 255)
|
|
|
|
|
return -1;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-03-22 13:31:26 +08:00
|
|
|
code = x86_keycodes[keycode];
|
|
|
|
|
if (!code)
|
|
|
|
|
return -1;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-03-22 13:31:26 +08:00
|
|
|
if (code & 0x100)
|
|
|
|
|
put_queue(vc, 0xe0);
|
|
|
|
|
put_queue(vc, (code & 0x7f) | up_flag);
|
|
|
|
|
|
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
|
|
#define HW_RAW(dev) 0
|
|
|
|
|
|
|
|
|
|
static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
|
|
|
|
|
{
|
|
|
|
|
if (keycode > 127)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
put_queue(vc, keycode | up_flag);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
static void kbd_rawcode(unsigned char data)
|
|
|
|
|
{
|
|
|
|
|
struct vc_data *vc = vc_cons[fg_console].d;
|
2010-03-22 13:31:26 +08:00
|
|
|
|
2009-11-18 16:40:48 +08:00
|
|
|
kbd = kbd_table + vc->vc_num;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (kbd->kbdmode == VC_RAW)
|
|
|
|
|
put_queue(vc, data);
|
|
|
|
|
}
|
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
struct vc_data *vc = vc_cons[fg_console].d;
|
|
|
|
|
unsigned short keysym, *key_map;
|
2010-03-22 13:31:26 +08:00
|
|
|
unsigned char type;
|
|
|
|
|
bool raw_mode;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct tty_struct *tty;
|
|
|
|
|
int shift_final;
|
Console keyboard events and accessibility
Some blind people use a kernel engine called Speakup which uses hardware
synthesis to speak what gets displayed on the screen. They use the
PC keyboard to control this engine (start/stop, accelerate, ...) and
also need to get keyboard feedback (to make sure to know what they are
typing, the caps lock status, etc.)
Up to now, the way it was done was very ugly. Below is a patch to add a
notifier list for permitting a far better implementation, see ChangeLog
above for details.
You may wonder why this can't be done at the input layer. The problem
is that what people want to monitor is the console keyboard, i.e. all
input keyboards that got attached to the console, and with the currently
active keymap (i.e. keysyms, not only keycodes).
This adds a keyboard notifier that such modules can use to get the keyboard
events and possibly eat them, at several stages:
- keycodes: even before translation into keysym.
- unbound keycodes: when no keysym is bound.
- unicode: when the keycode would get translated into a unicode character.
- keysym: when the keycode would get translated into a keysym.
- post_keysym: after the keysym got interpreted, so as to see the result
(caps lock, etc.)
This also provides access to k_handler so as to permit simulation of
keypresses.
[akpm@linux-foundation.org: various fixes]
Signed-off-by: Samuel Thibault <samuel.thibault@ens-lyon.org>
Cc: Jiri Kosina <jkosina@suse.cz>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-19 14:39:12 +08:00
|
|
|
struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
|
2010-03-22 13:31:26 +08:00
|
|
|
int rc;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-06-02 04:52:56 +08:00
|
|
|
tty = vc->port.tty;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
if (tty && (!tty->driver_data)) {
|
|
|
|
|
/* No driver data? Strange. Okay we fix it then. */
|
|
|
|
|
tty->driver_data = vc;
|
|
|
|
|
}
|
|
|
|
|
|
2009-11-18 16:40:48 +08:00
|
|
|
kbd = kbd_table + vc->vc_num;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-12-23 13:03:47 +08:00
|
|
|
#ifdef CONFIG_SPARC
|
2005-04-17 06:20:36 +08:00
|
|
|
if (keycode == KEY_STOP)
|
|
|
|
|
sparc_l1_a_state = down;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
rep = (down == 2);
|
|
|
|
|
|
2010-03-22 13:31:26 +08:00
|
|
|
raw_mode = (kbd->kbdmode == VC_RAW);
|
|
|
|
|
if (raw_mode && !hw_raw)
|
2005-04-17 06:20:36 +08:00
|
|
|
if (emulate_raw(vc, keycode, !down << 7))
|
2007-04-12 13:30:52 +08:00
|
|
|
if (keycode < BTN_MISC && printk_ratelimit())
|
2010-03-22 13:31:26 +08:00
|
|
|
pr_warning("can't emulate rawmode for keycode %d\n",
|
|
|
|
|
keycode);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-12-23 13:03:47 +08:00
|
|
|
#ifdef CONFIG_SPARC
|
2005-04-17 06:20:36 +08:00
|
|
|
if (keycode == KEY_A && sparc_l1_a_state) {
|
2010-03-22 13:31:26 +08:00
|
|
|
sparc_l1_a_state = false;
|
2005-04-17 06:20:36 +08:00
|
|
|
sun_do_break();
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (kbd->kbdmode == VC_MEDIUMRAW) {
|
|
|
|
|
/*
|
|
|
|
|
* This is extended medium raw mode, with keys above 127
|
|
|
|
|
* encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
|
|
|
|
|
* the 'up' flag if needed. 0 is reserved, so this shouldn't
|
|
|
|
|
* interfere with anything else. The two bytes after 0 will
|
|
|
|
|
* always have the up flag set not to interfere with older
|
|
|
|
|
* applications. This allows for 16384 different keycodes,
|
|
|
|
|
* which should be enough.
|
|
|
|
|
*/
|
|
|
|
|
if (keycode < 128) {
|
|
|
|
|
put_queue(vc, keycode | (!down << 7));
|
|
|
|
|
} else {
|
|
|
|
|
put_queue(vc, !down << 7);
|
|
|
|
|
put_queue(vc, (keycode >> 7) | 0x80);
|
|
|
|
|
put_queue(vc, keycode | 0x80);
|
|
|
|
|
}
|
2010-03-22 13:31:26 +08:00
|
|
|
raw_mode = true;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (down)
|
|
|
|
|
set_bit(keycode, key_down);
|
|
|
|
|
else
|
|
|
|
|
clear_bit(keycode, key_down);
|
|
|
|
|
|
2005-09-11 01:03:38 +08:00
|
|
|
if (rep &&
|
|
|
|
|
(!vc_kbd_mode(kbd, VC_REPEAT) ||
|
2008-04-30 15:54:13 +08:00
|
|
|
(tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* Don't repeat a key if the input buffers are not empty and the
|
2005-09-11 01:03:38 +08:00
|
|
|
* characters get aren't echoed locally. This makes key repeat
|
2005-04-17 06:20:36 +08:00
|
|
|
* usable with slow applications and under heavy loads.
|
|
|
|
|
*/
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
Console keyboard events and accessibility
Some blind people use a kernel engine called Speakup which uses hardware
synthesis to speak what gets displayed on the screen. They use the
PC keyboard to control this engine (start/stop, accelerate, ...) and
also need to get keyboard feedback (to make sure to know what they are
typing, the caps lock status, etc.)
Up to now, the way it was done was very ugly. Below is a patch to add a
notifier list for permitting a far better implementation, see ChangeLog
above for details.
You may wonder why this can't be done at the input layer. The problem
is that what people want to monitor is the console keyboard, i.e. all
input keyboards that got attached to the console, and with the currently
active keymap (i.e. keysyms, not only keycodes).
This adds a keyboard notifier that such modules can use to get the keyboard
events and possibly eat them, at several stages:
- keycodes: even before translation into keysym.
- unbound keycodes: when no keysym is bound.
- unicode: when the keycode would get translated into a unicode character.
- keysym: when the keycode would get translated into a keysym.
- post_keysym: after the keysym got interpreted, so as to see the result
(caps lock, etc.)
This also provides access to k_handler so as to permit simulation of
keypresses.
[akpm@linux-foundation.org: various fixes]
Signed-off-by: Samuel Thibault <samuel.thibault@ens-lyon.org>
Cc: Jiri Kosina <jkosina@suse.cz>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-19 14:39:12 +08:00
|
|
|
param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
|
2008-04-15 13:30:32 +08:00
|
|
|
param.ledstate = kbd->ledflagstate;
|
2005-04-17 06:20:36 +08:00
|
|
|
key_map = key_maps[shift_final];
|
|
|
|
|
|
2010-03-22 13:31:26 +08:00
|
|
|
rc = atomic_notifier_call_chain(&keyboard_notifier_list,
|
|
|
|
|
KBD_KEYCODE, ¶m);
|
|
|
|
|
if (rc == NOTIFY_STOP || !key_map) {
|
|
|
|
|
atomic_notifier_call_chain(&keyboard_notifier_list,
|
|
|
|
|
KBD_UNBOUND_KEYCODE, ¶m);
|
2005-04-17 06:20:36 +08:00
|
|
|
compute_shiftstate();
|
|
|
|
|
kbd->slockstate = 0;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2010-03-22 13:31:26 +08:00
|
|
|
if (keycode < NR_KEYS)
|
2006-04-02 13:10:28 +08:00
|
|
|
keysym = key_map[keycode];
|
2010-03-22 13:31:26 +08:00
|
|
|
else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
|
|
|
|
|
keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
|
|
|
|
|
else
|
|
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
type = KTYP(keysym);
|
|
|
|
|
|
|
|
|
|
if (type < 0xf0) {
|
Console keyboard events and accessibility
Some blind people use a kernel engine called Speakup which uses hardware
synthesis to speak what gets displayed on the screen. They use the
PC keyboard to control this engine (start/stop, accelerate, ...) and
also need to get keyboard feedback (to make sure to know what they are
typing, the caps lock status, etc.)
Up to now, the way it was done was very ugly. Below is a patch to add a
notifier list for permitting a far better implementation, see ChangeLog
above for details.
You may wonder why this can't be done at the input layer. The problem
is that what people want to monitor is the console keyboard, i.e. all
input keyboards that got attached to the console, and with the currently
active keymap (i.e. keysyms, not only keycodes).
This adds a keyboard notifier that such modules can use to get the keyboard
events and possibly eat them, at several stages:
- keycodes: even before translation into keysym.
- unbound keycodes: when no keysym is bound.
- unicode: when the keycode would get translated into a unicode character.
- keysym: when the keycode would get translated into a keysym.
- post_keysym: after the keysym got interpreted, so as to see the result
(caps lock, etc.)
This also provides access to k_handler so as to permit simulation of
keypresses.
[akpm@linux-foundation.org: various fixes]
Signed-off-by: Samuel Thibault <samuel.thibault@ens-lyon.org>
Cc: Jiri Kosina <jkosina@suse.cz>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-19 14:39:12 +08:00
|
|
|
param.value = keysym;
|
2010-03-22 13:31:26 +08:00
|
|
|
rc = atomic_notifier_call_chain(&keyboard_notifier_list,
|
|
|
|
|
KBD_UNICODE, ¶m);
|
|
|
|
|
if (rc != NOTIFY_STOP)
|
|
|
|
|
if (down && !raw_mode)
|
|
|
|
|
to_utf8(vc, keysym);
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
type -= 0xf0;
|
|
|
|
|
|
|
|
|
|
if (type == KT_LETTER) {
|
|
|
|
|
type = KT_LATIN;
|
|
|
|
|
if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
|
|
|
|
|
key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
|
|
|
|
|
if (key_map)
|
|
|
|
|
keysym = key_map[keycode];
|
|
|
|
|
}
|
|
|
|
|
}
|
Console keyboard events and accessibility
Some blind people use a kernel engine called Speakup which uses hardware
synthesis to speak what gets displayed on the screen. They use the
PC keyboard to control this engine (start/stop, accelerate, ...) and
also need to get keyboard feedback (to make sure to know what they are
typing, the caps lock status, etc.)
Up to now, the way it was done was very ugly. Below is a patch to add a
notifier list for permitting a far better implementation, see ChangeLog
above for details.
You may wonder why this can't be done at the input layer. The problem
is that what people want to monitor is the console keyboard, i.e. all
input keyboards that got attached to the console, and with the currently
active keymap (i.e. keysyms, not only keycodes).
This adds a keyboard notifier that such modules can use to get the keyboard
events and possibly eat them, at several stages:
- keycodes: even before translation into keysym.
- unbound keycodes: when no keysym is bound.
- unicode: when the keycode would get translated into a unicode character.
- keysym: when the keycode would get translated into a keysym.
- post_keysym: after the keysym got interpreted, so as to see the result
(caps lock, etc.)
This also provides access to k_handler so as to permit simulation of
keypresses.
[akpm@linux-foundation.org: various fixes]
Signed-off-by: Samuel Thibault <samuel.thibault@ens-lyon.org>
Cc: Jiri Kosina <jkosina@suse.cz>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-19 14:39:12 +08:00
|
|
|
|
2010-03-22 13:31:26 +08:00
|
|
|
param.value = keysym;
|
|
|
|
|
rc = atomic_notifier_call_chain(&keyboard_notifier_list,
|
|
|
|
|
KBD_KEYSYM, ¶m);
|
|
|
|
|
if (rc == NOTIFY_STOP)
|
Console keyboard events and accessibility
Some blind people use a kernel engine called Speakup which uses hardware
synthesis to speak what gets displayed on the screen. They use the
PC keyboard to control this engine (start/stop, accelerate, ...) and
also need to get keyboard feedback (to make sure to know what they are
typing, the caps lock status, etc.)
Up to now, the way it was done was very ugly. Below is a patch to add a
notifier list for permitting a far better implementation, see ChangeLog
above for details.
You may wonder why this can't be done at the input layer. The problem
is that what people want to monitor is the console keyboard, i.e. all
input keyboards that got attached to the console, and with the currently
active keymap (i.e. keysyms, not only keycodes).
This adds a keyboard notifier that such modules can use to get the keyboard
events and possibly eat them, at several stages:
- keycodes: even before translation into keysym.
- unbound keycodes: when no keysym is bound.
- unicode: when the keycode would get translated into a unicode character.
- keysym: when the keycode would get translated into a keysym.
- post_keysym: after the keysym got interpreted, so as to see the result
(caps lock, etc.)
This also provides access to k_handler so as to permit simulation of
keypresses.
[akpm@linux-foundation.org: various fixes]
Signed-off-by: Samuel Thibault <samuel.thibault@ens-lyon.org>
Cc: Jiri Kosina <jkosina@suse.cz>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-19 14:39:12 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
|
|
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
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 21:55:46 +08:00
|
|
|
(*k_handler[type])(vc, keysym & 0xff, !down);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-04-15 13:30:32 +08:00
|
|
|
param.ledstate = kbd->ledflagstate;
|
Console keyboard events and accessibility
Some blind people use a kernel engine called Speakup which uses hardware
synthesis to speak what gets displayed on the screen. They use the
PC keyboard to control this engine (start/stop, accelerate, ...) and
also need to get keyboard feedback (to make sure to know what they are
typing, the caps lock status, etc.)
Up to now, the way it was done was very ugly. Below is a patch to add a
notifier list for permitting a far better implementation, see ChangeLog
above for details.
You may wonder why this can't be done at the input layer. The problem
is that what people want to monitor is the console keyboard, i.e. all
input keyboards that got attached to the console, and with the currently
active keymap (i.e. keysyms, not only keycodes).
This adds a keyboard notifier that such modules can use to get the keyboard
events and possibly eat them, at several stages:
- keycodes: even before translation into keysym.
- unbound keycodes: when no keysym is bound.
- unicode: when the keycode would get translated into a unicode character.
- keysym: when the keycode would get translated into a keysym.
- post_keysym: after the keysym got interpreted, so as to see the result
(caps lock, etc.)
This also provides access to k_handler so as to permit simulation of
keypresses.
[akpm@linux-foundation.org: various fixes]
Signed-off-by: Samuel Thibault <samuel.thibault@ens-lyon.org>
Cc: Jiri Kosina <jkosina@suse.cz>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-19 14:39:12 +08:00
|
|
|
atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, ¶m);
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (type != KT_SLOCK)
|
|
|
|
|
kbd->slockstate = 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-09-11 01:03:38 +08:00
|
|
|
static void kbd_event(struct input_handle *handle, unsigned int event_type,
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int event_code, int value)
|
|
|
|
|
{
|
2009-11-30 15:40:58 +08:00
|
|
|
/* We are called with interrupts disabled, just take the lock */
|
|
|
|
|
spin_lock(&kbd_event_lock);
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
|
|
|
|
|
kbd_rawcode(value);
|
|
|
|
|
if (event_type == EV_KEY)
|
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 21:55:46 +08:00
|
|
|
kbd_keycode(event_code, value, HW_RAW(handle->dev));
|
2009-11-30 15:40:58 +08:00
|
|
|
|
|
|
|
|
spin_unlock(&kbd_event_lock);
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
tasklet_schedule(&keyboard_tasklet);
|
|
|
|
|
do_poke_blanked_console = 1;
|
|
|
|
|
schedule_console_callback();
|
|
|
|
|
}
|
|
|
|
|
|
2010-02-03 13:08:26 +08:00
|
|
|
static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (test_bit(EV_SND, dev->evbit))
|
|
|
|
|
return true;
|
|
|
|
|
|
2010-07-31 17:28:51 +08:00
|
|
|
if (test_bit(EV_KEY, dev->evbit)) {
|
2010-02-03 13:08:26 +08:00
|
|
|
for (i = KEY_RESERVED; i < BTN_MISC; i++)
|
|
|
|
|
if (test_bit(i, dev->keybit))
|
|
|
|
|
return true;
|
2010-07-31 17:28:51 +08:00
|
|
|
for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
|
|
|
|
|
if (test_bit(i, dev->keybit))
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2010-02-03 13:08:26 +08:00
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* When a keyboard (or other input device) is found, the kbd_connect
|
|
|
|
|
* function is called. The function then looks at the device, and if it
|
|
|
|
|
* likes it, it can open it and get events from it. In this (kbd_connect)
|
|
|
|
|
* function, we should decide which VT to bind that keyboard to initially.
|
|
|
|
|
*/
|
2007-04-12 13:29:46 +08:00
|
|
|
static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
|
|
|
|
|
const struct input_device_id *id)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
struct input_handle *handle;
|
2007-04-12 13:29:46 +08:00
|
|
|
int error;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-08-05 10:51:51 +08:00
|
|
|
handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
|
|
|
|
|
if (!handle)
|
2007-04-12 13:29:46 +08:00
|
|
|
return -ENOMEM;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
handle->dev = dev;
|
|
|
|
|
handle->handler = handler;
|
2005-09-11 01:03:38 +08:00
|
|
|
handle->name = "kbd";
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-04-12 13:29:46 +08:00
|
|
|
error = input_register_handle(handle);
|
|
|
|
|
if (error)
|
|
|
|
|
goto err_free_handle;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-04-12 13:29:46 +08:00
|
|
|
error = input_open_device(handle);
|
|
|
|
|
if (error)
|
|
|
|
|
goto err_unregister_handle;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
err_unregister_handle:
|
|
|
|
|
input_unregister_handle(handle);
|
|
|
|
|
err_free_handle:
|
|
|
|
|
kfree(handle);
|
|
|
|
|
return error;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void kbd_disconnect(struct input_handle *handle)
|
|
|
|
|
{
|
|
|
|
|
input_close_device(handle);
|
2007-04-12 13:29:46 +08:00
|
|
|
input_unregister_handle(handle);
|
2005-04-17 06:20:36 +08:00
|
|
|
kfree(handle);
|
|
|
|
|
}
|
|
|
|
|
|
2006-07-06 12:21:03 +08:00
|
|
|
/*
|
|
|
|
|
* Start keyboard handler on the new keyboard by refreshing LED state to
|
|
|
|
|
* match the rest of the system.
|
|
|
|
|
*/
|
|
|
|
|
static void kbd_start(struct input_handle *handle)
|
|
|
|
|
{
|
|
|
|
|
tasklet_disable(&keyboard_tasklet);
|
2009-12-02 13:54:35 +08:00
|
|
|
|
|
|
|
|
if (ledstate != 0xff)
|
|
|
|
|
kbd_update_leds_helper(handle, &ledstate);
|
|
|
|
|
|
2006-07-06 12:21:03 +08:00
|
|
|
tasklet_enable(&keyboard_tasklet);
|
|
|
|
|
}
|
|
|
|
|
|
2006-09-14 13:31:59 +08:00
|
|
|
static const struct input_device_id kbd_ids[] = {
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
.flags = INPUT_DEVICE_ID_MATCH_EVBIT,
|
2007-10-19 14:40:32 +08:00
|
|
|
.evbit = { BIT_MASK(EV_KEY) },
|
2005-04-17 06:20:36 +08:00
|
|
|
},
|
2005-09-11 01:03:38 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
.flags = INPUT_DEVICE_ID_MATCH_EVBIT,
|
2007-10-19 14:40:32 +08:00
|
|
|
.evbit = { BIT_MASK(EV_SND) },
|
2005-09-11 01:03:38 +08:00
|
|
|
},
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
{ }, /* Terminating entry */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE(input, kbd_ids);
|
|
|
|
|
|
|
|
|
|
static struct input_handler kbd_handler = {
|
|
|
|
|
.event = kbd_event,
|
2010-02-03 13:08:26 +08:00
|
|
|
.match = kbd_match,
|
2005-04-17 06:20:36 +08:00
|
|
|
.connect = kbd_connect,
|
|
|
|
|
.disconnect = kbd_disconnect,
|
2006-07-06 12:21:03 +08:00
|
|
|
.start = kbd_start,
|
2005-04-17 06:20:36 +08:00
|
|
|
.name = "kbd",
|
|
|
|
|
.id_table = kbd_ids,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
int __init kbd_init(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
2006-09-14 13:32:39 +08:00
|
|
|
int error;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-19 13:13:26 +08:00
|
|
|
for (i = 0; i < MAX_NR_CONSOLES; i++) {
|
|
|
|
|
kbd_table[i].ledflagstate = KBD_DEFLEDS;
|
|
|
|
|
kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
|
|
|
|
|
kbd_table[i].ledmode = LED_SHOW_FLAGS;
|
|
|
|
|
kbd_table[i].lockstate = KBD_DEFLOCK;
|
|
|
|
|
kbd_table[i].slockstate = 0;
|
|
|
|
|
kbd_table[i].modeflags = KBD_DEFMODE;
|
2007-10-17 14:29:38 +08:00
|
|
|
kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
|
2006-07-19 13:13:26 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-09-14 13:32:39 +08:00
|
|
|
error = input_register_handler(&kbd_handler);
|
|
|
|
|
if (error)
|
|
|
|
|
return error;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
tasklet_enable(&keyboard_tasklet);
|
|
|
|
|
tasklet_schedule(&keyboard_tasklet);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|