mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-11-26 21:54:11 +08:00
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input: (40 commits) Input: psmouse - small formatting changes to better follow coding style Input: synaptics - set dimensions as reported by firmware Input: elantech - relax signature checks Input: elantech - enforce common prefix on messages Input: wistron_btns - switch to using kmemdup() Input: usbtouchscreen - switch to using kmemdup() Input: do not force selecting i8042 on Moorestown Input: Documentation/sysrq.txt - update KEY_SYSRQ info Input: 88pm860x_onkey - remove invalid irq number assignment Input: i8042 - add a PNP entry to the aux device list Input: i8042 - add some extra PNP keyboard types Input: wm9712 - fix wm97xx_set_gpio() logic Input: add keypad driver for keys interfaced to TCA6416 Input: remove obsolete {corgi,spitz,tosa}kbd.c Input: kbtab - do not advertise unsupported events Input: kbtab - simplify kbtab_disconnect() Input: kbtab - fix incorrect size parameter in usb_buffer_free Input: acecad - don't advertise mouse events Input: acecad - fix some formatting issues Input: acecad - simplify usb_acecad_disconnect() ... Trivial conflict in Documentation/feature-removal-schedule.txt
This commit is contained in:
commit
a0fe3cc5d3
@ -177,13 +177,13 @@ virtual console (ALT+Fn) and then back again should also help.
|
||||
|
||||
* I hit SysRq, but nothing seems to happen, what's wrong?
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
There are some keyboards that send different scancodes for SysRq than the
|
||||
pre-defined 0x54. So if SysRq doesn't work out of the box for a certain
|
||||
keyboard, run 'showkey -s' to find out the proper scancode sequence. Then
|
||||
use 'setkeycodes <sequence> 84' to define this sequence to the usual SysRq
|
||||
code (84 is decimal for 0x54). It's probably best to put this command in a
|
||||
boot script. Oh, and by the way, you exit 'showkey' by not typing anything
|
||||
for ten seconds.
|
||||
There are some keyboards that produce a different keycode for SysRq than the
|
||||
pre-defined value of 99 (see KEY_SYSRQ in include/linux/input.h), or which
|
||||
don't have a SysRq key at all. In these cases, run 'showkey -s' to find an
|
||||
appropriate scancode sequence, and use 'setkeycodes <sequence> 99' to map
|
||||
this sequence to the usual SysRq code (e.g., 'setkeycodes e05b 99'). It's
|
||||
probably best to put this command in a boot script. Oh, and by the way, you
|
||||
exit 'showkey' by not typing anything for ten seconds.
|
||||
|
||||
* I want to add SysRQ key events to a module, how does it work?
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
@ -24,6 +24,8 @@
|
||||
* 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
|
||||
*/
|
||||
|
||||
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
||||
|
||||
#include <linux/consolemap.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/sched.h>
|
||||
@ -38,7 +40,6 @@
|
||||
#include <linux/kbd_kern.h>
|
||||
#include <linux/kbd_diacr.h>
|
||||
#include <linux/vt_kern.h>
|
||||
#include <linux/sysrq.h>
|
||||
#include <linux/input.h>
|
||||
#include <linux/reboot.h>
|
||||
#include <linux/notifier.h>
|
||||
@ -82,8 +83,7 @@ void compute_shiftstate(void);
|
||||
typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
|
||||
char up_flag);
|
||||
static k_handler_fn K_HANDLERS;
|
||||
k_handler_fn *k_handler[16] = { K_HANDLERS };
|
||||
EXPORT_SYMBOL_GPL(k_handler);
|
||||
static k_handler_fn *k_handler[16] = { K_HANDLERS };
|
||||
|
||||
#define FN_HANDLERS\
|
||||
fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
|
||||
@ -133,7 +133,7 @@ static struct input_handler kbd_handler;
|
||||
static DEFINE_SPINLOCK(kbd_event_lock);
|
||||
static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
|
||||
static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
|
||||
static int dead_key_next;
|
||||
static bool dead_key_next;
|
||||
static int npadch = -1; /* -1 or number assembled on pad */
|
||||
static unsigned int diacr;
|
||||
static char rep; /* flag telling character repeat */
|
||||
@ -147,22 +147,6 @@ static struct ledptr {
|
||||
unsigned char valid:1;
|
||||
} ledptrs[3];
|
||||
|
||||
/* Simple translation table for the SysRq keys */
|
||||
|
||||
#ifdef CONFIG_MAGIC_SYSRQ
|
||||
unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
|
||||
"\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
|
||||
"qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
|
||||
"dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
|
||||
"bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
|
||||
"\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
|
||||
"230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
|
||||
"\r\000/"; /* 0x60 - 0x6f */
|
||||
static int sysrq_down;
|
||||
static int sysrq_alt_use;
|
||||
#endif
|
||||
static int sysrq_alt;
|
||||
|
||||
/*
|
||||
* Notifier list for console keyboard events
|
||||
*/
|
||||
@ -469,6 +453,7 @@ static void fn_enter(struct vc_data *vc)
|
||||
}
|
||||
diacr = 0;
|
||||
}
|
||||
|
||||
put_queue(vc, 13);
|
||||
if (vc_kbd_mode(kbd, VC_CRLF))
|
||||
put_queue(vc, 10);
|
||||
@ -478,6 +463,7 @@ static void fn_caps_toggle(struct vc_data *vc)
|
||||
{
|
||||
if (rep)
|
||||
return;
|
||||
|
||||
chg_vc_kbd_led(kbd, VC_CAPSLOCK);
|
||||
}
|
||||
|
||||
@ -485,12 +471,14 @@ static void fn_caps_on(struct vc_data *vc)
|
||||
{
|
||||
if (rep)
|
||||
return;
|
||||
|
||||
set_vc_kbd_led(kbd, VC_CAPSLOCK);
|
||||
}
|
||||
|
||||
static void fn_show_ptregs(struct vc_data *vc)
|
||||
{
|
||||
struct pt_regs *regs = get_irq_regs();
|
||||
|
||||
if (regs)
|
||||
show_regs(regs);
|
||||
}
|
||||
@ -610,7 +598,7 @@ static void fn_boot_it(struct vc_data *vc)
|
||||
|
||||
static void fn_compose(struct vc_data *vc)
|
||||
{
|
||||
dead_key_next = 1;
|
||||
dead_key_next = true;
|
||||
}
|
||||
|
||||
static void fn_spawn_con(struct vc_data *vc)
|
||||
@ -657,7 +645,7 @@ static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
|
||||
static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
{
|
||||
printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
|
||||
pr_err("k_lowercase was called - impossible\n");
|
||||
}
|
||||
|
||||
static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
|
||||
@ -669,7 +657,7 @@ static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
|
||||
value = handle_diacr(vc, value);
|
||||
|
||||
if (dead_key_next) {
|
||||
dead_key_next = 0;
|
||||
dead_key_next = false;
|
||||
diacr = value;
|
||||
return;
|
||||
}
|
||||
@ -691,6 +679,7 @@ static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
|
||||
{
|
||||
if (up_flag)
|
||||
return;
|
||||
|
||||
diacr = (diacr ? handle_diacr(vc, value) : value);
|
||||
}
|
||||
|
||||
@ -710,29 +699,28 @@ static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
{
|
||||
static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
|
||||
value = ret_diacr[value];
|
||||
k_deadunicode(vc, value, up_flag);
|
||||
|
||||
k_deadunicode(vc, ret_diacr[value], up_flag);
|
||||
}
|
||||
|
||||
static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
{
|
||||
if (up_flag)
|
||||
return;
|
||||
|
||||
set_console(value);
|
||||
}
|
||||
|
||||
static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
{
|
||||
unsigned v;
|
||||
|
||||
if (up_flag)
|
||||
return;
|
||||
v = value;
|
||||
if (v < ARRAY_SIZE(func_table)) {
|
||||
|
||||
if ((unsigned)value < ARRAY_SIZE(func_table)) {
|
||||
if (func_table[value])
|
||||
puts_queue(vc, func_table[value]);
|
||||
} else
|
||||
printk(KERN_ERR "k_fn called with value=%d\n", value);
|
||||
pr_err("k_fn called with value=%d\n", value);
|
||||
}
|
||||
|
||||
static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
@ -741,6 +729,7 @@ static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
|
||||
if (up_flag)
|
||||
return;
|
||||
|
||||
applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
|
||||
}
|
||||
|
||||
@ -758,7 +747,8 @@ static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
return;
|
||||
}
|
||||
|
||||
if (!vc_kbd_led(kbd, VC_NUMLOCK))
|
||||
if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
|
||||
|
||||
switch (value) {
|
||||
case KVAL(K_PCOMMA):
|
||||
case KVAL(K_PDOT):
|
||||
@ -795,6 +785,7 @@ static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
put_queue(vc, pad_chars[value]);
|
||||
if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
|
||||
@ -880,6 +871,7 @@ static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
{
|
||||
if (up_flag || rep)
|
||||
return;
|
||||
|
||||
chg_vc_kbd_lock(kbd, value);
|
||||
}
|
||||
|
||||
@ -888,6 +880,7 @@ static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
k_shift(vc, value, up_flag);
|
||||
if (up_flag || rep)
|
||||
return;
|
||||
|
||||
chg_vc_kbd_slock(kbd, value);
|
||||
/* try to make Alt, oops, AltGr and such work */
|
||||
if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
|
||||
@ -930,7 +923,7 @@ static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
|
||||
if (kbd->kbdmode != VC_UNICODE) {
|
||||
if (!up_flag)
|
||||
printk("keyboard mode must be unicode for braille patterns\n");
|
||||
pr_warning("keyboard mode must be unicode for braille patterns\n");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -942,8 +935,11 @@ static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
if (value > 8)
|
||||
return;
|
||||
|
||||
if (up_flag) {
|
||||
if (brl_timeout) {
|
||||
if (!up_flag) {
|
||||
pressed |= 1 << (value - 1);
|
||||
if (!brl_timeout)
|
||||
committing = pressed;
|
||||
} else if (brl_timeout) {
|
||||
if (!committing ||
|
||||
time_after(jiffies,
|
||||
releasestart + msecs_to_jiffies(brl_timeout))) {
|
||||
@ -951,12 +947,10 @@ static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
releasestart = jiffies;
|
||||
}
|
||||
pressed &= ~(1 << (value - 1));
|
||||
if (!pressed) {
|
||||
if (committing) {
|
||||
if (!pressed && committing) {
|
||||
k_brlcommit(vc, committing, 0);
|
||||
committing = 0;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (committing) {
|
||||
k_brlcommit(vc, committing, 0);
|
||||
@ -964,11 +958,6 @@ static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
|
||||
}
|
||||
pressed &= ~(1 << (value - 1));
|
||||
}
|
||||
} else {
|
||||
pressed |= 1 << (value - 1);
|
||||
if (!brl_timeout)
|
||||
committing = pressed;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
@ -988,6 +977,7 @@ void setledstate(struct kbd_struct *kbd, unsigned int led)
|
||||
kbd->ledmode = LED_SHOW_IOCTL;
|
||||
} else
|
||||
kbd->ledmode = LED_SHOW_FLAGS;
|
||||
|
||||
set_leds();
|
||||
}
|
||||
|
||||
@ -1075,7 +1065,7 @@ static const unsigned short x86_keycodes[256] =
|
||||
332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
|
||||
|
||||
#ifdef CONFIG_SPARC
|
||||
static int sparc_l1_a_state = 0;
|
||||
static int sparc_l1_a_state;
|
||||
extern void sun_do_break(void);
|
||||
#endif
|
||||
|
||||
@ -1085,6 +1075,7 @@ static int emulate_raw(struct vc_data *vc, unsigned int keycode,
|
||||
int code;
|
||||
|
||||
switch (keycode) {
|
||||
|
||||
case KEY_PAUSE:
|
||||
put_queue(vc, 0xe1);
|
||||
put_queue(vc, 0x1d | up_flag);
|
||||
@ -1108,7 +1099,8 @@ static int emulate_raw(struct vc_data *vc, unsigned int keycode,
|
||||
* pressing PrtSc/SysRq alone, but simply 0x54
|
||||
* when pressing Alt+PrtSc/SysRq.
|
||||
*/
|
||||
if (sysrq_alt) {
|
||||
if (test_bit(KEY_LEFTALT, key_down) ||
|
||||
test_bit(KEY_RIGHTALT, key_down)) {
|
||||
put_queue(vc, 0x54 | up_flag);
|
||||
} else {
|
||||
put_queue(vc, 0xe0);
|
||||
@ -1153,6 +1145,7 @@ static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char u
|
||||
static void kbd_rawcode(unsigned char data)
|
||||
{
|
||||
struct vc_data *vc = vc_cons[fg_console].d;
|
||||
|
||||
kbd = kbd_table + vc->vc_num;
|
||||
if (kbd->kbdmode == VC_RAW)
|
||||
put_queue(vc, data);
|
||||
@ -1162,10 +1155,12 @@ static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
|
||||
{
|
||||
struct vc_data *vc = vc_cons[fg_console].d;
|
||||
unsigned short keysym, *key_map;
|
||||
unsigned char type, raw_mode;
|
||||
unsigned char type;
|
||||
bool raw_mode;
|
||||
struct tty_struct *tty;
|
||||
int shift_final;
|
||||
struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
|
||||
int rc;
|
||||
|
||||
tty = vc->vc_tty;
|
||||
|
||||
@ -1176,8 +1171,6 @@ static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
|
||||
|
||||
kbd = kbd_table + vc->vc_num;
|
||||
|
||||
if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
|
||||
sysrq_alt = down ? keycode : 0;
|
||||
#ifdef CONFIG_SPARC
|
||||
if (keycode == KEY_STOP)
|
||||
sparc_l1_a_state = down;
|
||||
@ -1185,29 +1178,16 @@ static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
|
||||
|
||||
rep = (down == 2);
|
||||
|
||||
if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
|
||||
raw_mode = (kbd->kbdmode == VC_RAW);
|
||||
if (raw_mode && !hw_raw)
|
||||
if (emulate_raw(vc, keycode, !down << 7))
|
||||
if (keycode < BTN_MISC && printk_ratelimit())
|
||||
printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
|
||||
pr_warning("can't emulate rawmode for keycode %d\n",
|
||||
keycode);
|
||||
|
||||
#ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
|
||||
if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
|
||||
if (!sysrq_down) {
|
||||
sysrq_down = down;
|
||||
sysrq_alt_use = sysrq_alt;
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (sysrq_down && !down && keycode == sysrq_alt_use)
|
||||
sysrq_down = 0;
|
||||
if (sysrq_down && down && !rep) {
|
||||
handle_sysrq(kbd_sysrq_xlate[keycode], tty);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
#ifdef CONFIG_SPARC
|
||||
if (keycode == KEY_A && sparc_l1_a_state) {
|
||||
sparc_l1_a_state = 0;
|
||||
sparc_l1_a_state = false;
|
||||
sun_do_break();
|
||||
}
|
||||
#endif
|
||||
@ -1229,7 +1209,7 @@ static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
|
||||
put_queue(vc, (keycode >> 7) | 0x80);
|
||||
put_queue(vc, keycode | 0x80);
|
||||
}
|
||||
raw_mode = 1;
|
||||
raw_mode = true;
|
||||
}
|
||||
|
||||
if (down)
|
||||
@ -1252,27 +1232,30 @@ static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
|
||||
param.ledstate = kbd->ledflagstate;
|
||||
key_map = key_maps[shift_final];
|
||||
|
||||
if (atomic_notifier_call_chain(&keyboard_notifier_list, KBD_KEYCODE, ¶m) == NOTIFY_STOP || !key_map) {
|
||||
atomic_notifier_call_chain(&keyboard_notifier_list, KBD_UNBOUND_KEYCODE, ¶m);
|
||||
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);
|
||||
compute_shiftstate();
|
||||
kbd->slockstate = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
if (keycode >= NR_KEYS)
|
||||
if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
|
||||
if (keycode < NR_KEYS)
|
||||
keysym = key_map[keycode];
|
||||
else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
|
||||
keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
|
||||
else
|
||||
return;
|
||||
else
|
||||
keysym = key_map[keycode];
|
||||
|
||||
type = KTYP(keysym);
|
||||
|
||||
if (type < 0xf0) {
|
||||
param.value = keysym;
|
||||
if (atomic_notifier_call_chain(&keyboard_notifier_list, KBD_UNICODE, ¶m) == NOTIFY_STOP)
|
||||
return;
|
||||
rc = atomic_notifier_call_chain(&keyboard_notifier_list,
|
||||
KBD_UNICODE, ¶m);
|
||||
if (rc != NOTIFY_STOP)
|
||||
if (down && !raw_mode)
|
||||
to_utf8(vc, keysym);
|
||||
return;
|
||||
@ -1288,9 +1271,11 @@ static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
|
||||
keysym = key_map[keycode];
|
||||
}
|
||||
}
|
||||
param.value = keysym;
|
||||
|
||||
if (atomic_notifier_call_chain(&keyboard_notifier_list, KBD_KEYSYM, ¶m) == NOTIFY_STOP)
|
||||
param.value = keysym;
|
||||
rc = atomic_notifier_call_chain(&keyboard_notifier_list,
|
||||
KBD_KEYSYM, ¶m);
|
||||
if (rc == NOTIFY_STOP)
|
||||
return;
|
||||
|
||||
if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
|
||||
|
@ -1,7 +1,4 @@
|
||||
/* -*- linux-c -*-
|
||||
*
|
||||
* $Id: sysrq.c,v 1.15 1998/08/23 14:56:41 mj Exp $
|
||||
*
|
||||
/*
|
||||
* Linux Magic System Request Key Hacks
|
||||
*
|
||||
* (c) 1997 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
|
||||
@ -10,8 +7,13 @@
|
||||
* (c) 2000 Crutcher Dunnavant <crutcher+kernel@datastacks.com>
|
||||
* overhauled to use key registration
|
||||
* based upon discusions in irc://irc.openprojects.net/#kernelnewbies
|
||||
*
|
||||
* Copyright (c) 2010 Dmitry Torokhov
|
||||
* Input handler conversion
|
||||
*/
|
||||
|
||||
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
||||
|
||||
#include <linux/sched.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/mm.h>
|
||||
@ -39,33 +41,34 @@
|
||||
#include <linux/hrtimer.h>
|
||||
#include <linux/oom.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/input.h>
|
||||
|
||||
#include <asm/ptrace.h>
|
||||
#include <asm/irq_regs.h>
|
||||
|
||||
/* Whether we react on sysrq keys or just ignore them */
|
||||
int __read_mostly __sysrq_enabled = 1;
|
||||
static int __read_mostly sysrq_enabled = 1;
|
||||
static bool __read_mostly sysrq_always_enabled;
|
||||
|
||||
static int __read_mostly sysrq_always_enabled;
|
||||
|
||||
int sysrq_on(void)
|
||||
static bool sysrq_on(void)
|
||||
{
|
||||
return __sysrq_enabled || sysrq_always_enabled;
|
||||
return sysrq_enabled || sysrq_always_enabled;
|
||||
}
|
||||
|
||||
/*
|
||||
* A value of 1 means 'all', other nonzero values are an op mask:
|
||||
*/
|
||||
static inline int sysrq_on_mask(int mask)
|
||||
static bool sysrq_on_mask(int mask)
|
||||
{
|
||||
return sysrq_always_enabled || __sysrq_enabled == 1 ||
|
||||
(__sysrq_enabled & mask);
|
||||
return sysrq_always_enabled ||
|
||||
sysrq_enabled == 1 ||
|
||||
(sysrq_enabled & mask);
|
||||
}
|
||||
|
||||
static int __init sysrq_always_enabled_setup(char *str)
|
||||
{
|
||||
sysrq_always_enabled = 1;
|
||||
printk(KERN_INFO "debug: sysrq always enabled.\n");
|
||||
sysrq_always_enabled = true;
|
||||
pr_info("sysrq always enabled.\n");
|
||||
|
||||
return 1;
|
||||
}
|
||||
@ -76,6 +79,7 @@ __setup("sysrq_always_enabled", sysrq_always_enabled_setup);
|
||||
static void sysrq_handle_loglevel(int key, struct tty_struct *tty)
|
||||
{
|
||||
int i;
|
||||
|
||||
i = key - '0';
|
||||
console_loglevel = 7;
|
||||
printk("Loglevel set to %d\n", i);
|
||||
@ -101,7 +105,7 @@ static struct sysrq_key_op sysrq_SAK_op = {
|
||||
.enable_mask = SYSRQ_ENABLE_KEYBOARD,
|
||||
};
|
||||
#else
|
||||
#define sysrq_SAK_op (*(struct sysrq_key_op *)0)
|
||||
#define sysrq_SAK_op (*(struct sysrq_key_op *)NULL)
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_VT
|
||||
@ -119,7 +123,7 @@ static struct sysrq_key_op sysrq_unraw_op = {
|
||||
.enable_mask = SYSRQ_ENABLE_KEYBOARD,
|
||||
};
|
||||
#else
|
||||
#define sysrq_unraw_op (*(struct sysrq_key_op *)0)
|
||||
#define sysrq_unraw_op (*(struct sysrq_key_op *)NULL)
|
||||
#endif /* CONFIG_VT */
|
||||
|
||||
static void sysrq_handle_crash(int key, struct tty_struct *tty)
|
||||
@ -195,7 +199,7 @@ static struct sysrq_key_op sysrq_showlocks_op = {
|
||||
.action_msg = "Show Locks Held",
|
||||
};
|
||||
#else
|
||||
#define sysrq_showlocks_op (*(struct sysrq_key_op *)0)
|
||||
#define sysrq_showlocks_op (*(struct sysrq_key_op *)NULL)
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_SMP
|
||||
@ -298,7 +302,7 @@ static struct sysrq_key_op sysrq_ftrace_dump_op = {
|
||||
.enable_mask = SYSRQ_ENABLE_DUMP,
|
||||
};
|
||||
#else
|
||||
#define sysrq_ftrace_dump_op (*(struct sysrq_key_op *)0)
|
||||
#define sysrq_ftrace_dump_op (*(struct sysrq_key_op *)NULL)
|
||||
#endif
|
||||
|
||||
static void sysrq_handle_showmem(int key, struct tty_struct *tty)
|
||||
@ -477,6 +481,7 @@ struct sysrq_key_op *__sysrq_get_key_op(int key)
|
||||
i = sysrq_key_table_key2index(key);
|
||||
if (i != -1)
|
||||
op_p = sysrq_key_table[i];
|
||||
|
||||
return op_p;
|
||||
}
|
||||
|
||||
@ -488,11 +493,7 @@ static void __sysrq_put_key_op(int key, struct sysrq_key_op *op_p)
|
||||
sysrq_key_table[i] = op_p;
|
||||
}
|
||||
|
||||
/*
|
||||
* This is the non-locking version of handle_sysrq. It must/can only be called
|
||||
* by sysrq key handlers, as they are inside of the lock
|
||||
*/
|
||||
void __handle_sysrq(int key, struct tty_struct *tty, int check_mask)
|
||||
static void __handle_sysrq(int key, struct tty_struct *tty, int check_mask)
|
||||
{
|
||||
struct sysrq_key_op *op_p;
|
||||
int orig_log_level;
|
||||
@ -544,10 +545,6 @@ void __handle_sysrq(int key, struct tty_struct *tty, int check_mask)
|
||||
spin_unlock_irqrestore(&sysrq_key_table_lock, flags);
|
||||
}
|
||||
|
||||
/*
|
||||
* This function is called by the keyboard handler when SysRq is pressed
|
||||
* and any other keycode arrives.
|
||||
*/
|
||||
void handle_sysrq(int key, struct tty_struct *tty)
|
||||
{
|
||||
if (sysrq_on())
|
||||
@ -555,10 +552,177 @@ void handle_sysrq(int key, struct tty_struct *tty)
|
||||
}
|
||||
EXPORT_SYMBOL(handle_sysrq);
|
||||
|
||||
#ifdef CONFIG_INPUT
|
||||
|
||||
/* Simple translation table for the SysRq keys */
|
||||
static const unsigned char sysrq_xlate[KEY_MAX + 1] =
|
||||
"\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
|
||||
"qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
|
||||
"dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
|
||||
"bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
|
||||
"\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
|
||||
"230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
|
||||
"\r\000/"; /* 0x60 - 0x6f */
|
||||
|
||||
static bool sysrq_down;
|
||||
static int sysrq_alt_use;
|
||||
static int sysrq_alt;
|
||||
|
||||
static bool sysrq_filter(struct input_handle *handle, unsigned int type,
|
||||
unsigned int code, int value)
|
||||
{
|
||||
if (type != EV_KEY)
|
||||
goto out;
|
||||
|
||||
switch (code) {
|
||||
|
||||
case KEY_LEFTALT:
|
||||
case KEY_RIGHTALT:
|
||||
if (value)
|
||||
sysrq_alt = code;
|
||||
else if (sysrq_down && code == sysrq_alt_use)
|
||||
sysrq_down = false;
|
||||
break;
|
||||
|
||||
case KEY_SYSRQ:
|
||||
if (value == 1 && sysrq_alt) {
|
||||
sysrq_down = true;
|
||||
sysrq_alt_use = sysrq_alt;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
if (sysrq_down && value && value != 2)
|
||||
__handle_sysrq(sysrq_xlate[code], NULL, 1);
|
||||
break;
|
||||
}
|
||||
|
||||
out:
|
||||
return sysrq_down;
|
||||
}
|
||||
|
||||
static int sysrq_connect(struct input_handler *handler,
|
||||
struct input_dev *dev,
|
||||
const struct input_device_id *id)
|
||||
{
|
||||
struct input_handle *handle;
|
||||
int error;
|
||||
|
||||
sysrq_down = false;
|
||||
sysrq_alt = 0;
|
||||
|
||||
handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
|
||||
if (!handle)
|
||||
return -ENOMEM;
|
||||
|
||||
handle->dev = dev;
|
||||
handle->handler = handler;
|
||||
handle->name = "sysrq";
|
||||
|
||||
error = input_register_handle(handle);
|
||||
if (error) {
|
||||
pr_err("Failed to register input sysrq handler, error %d\n",
|
||||
error);
|
||||
goto err_free;
|
||||
}
|
||||
|
||||
error = input_open_device(handle);
|
||||
if (error) {
|
||||
pr_err("Failed to open input device, error %d\n", error);
|
||||
goto err_unregister;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
err_unregister:
|
||||
input_unregister_handle(handle);
|
||||
err_free:
|
||||
kfree(handle);
|
||||
return error;
|
||||
}
|
||||
|
||||
static void sysrq_disconnect(struct input_handle *handle)
|
||||
{
|
||||
input_close_device(handle);
|
||||
input_unregister_handle(handle);
|
||||
kfree(handle);
|
||||
}
|
||||
|
||||
/*
|
||||
* We are matching on KEY_LEFTALT insteard of KEY_SYSRQ because not all
|
||||
* keyboards have SysRq ikey predefined and so user may add it to keymap
|
||||
* later, but we expect all such keyboards to have left alt.
|
||||
*/
|
||||
static const struct input_device_id sysrq_ids[] = {
|
||||
{
|
||||
.flags = INPUT_DEVICE_ID_MATCH_EVBIT |
|
||||
INPUT_DEVICE_ID_MATCH_KEYBIT,
|
||||
.evbit = { BIT_MASK(EV_KEY) },
|
||||
.keybit = { BIT_MASK(KEY_LEFTALT) },
|
||||
},
|
||||
{ },
|
||||
};
|
||||
|
||||
static struct input_handler sysrq_handler = {
|
||||
.filter = sysrq_filter,
|
||||
.connect = sysrq_connect,
|
||||
.disconnect = sysrq_disconnect,
|
||||
.name = "sysrq",
|
||||
.id_table = sysrq_ids,
|
||||
};
|
||||
|
||||
static bool sysrq_handler_registered;
|
||||
|
||||
static inline void sysrq_register_handler(void)
|
||||
{
|
||||
int error;
|
||||
|
||||
error = input_register_handler(&sysrq_handler);
|
||||
if (error)
|
||||
pr_err("Failed to register input handler, error %d", error);
|
||||
else
|
||||
sysrq_handler_registered = true;
|
||||
}
|
||||
|
||||
static inline void sysrq_unregister_handler(void)
|
||||
{
|
||||
if (sysrq_handler_registered) {
|
||||
input_unregister_handler(&sysrq_handler);
|
||||
sysrq_handler_registered = false;
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
static inline void sysrq_register_handler(void)
|
||||
{
|
||||
}
|
||||
|
||||
static inline void sysrq_unregister_handler(void)
|
||||
{
|
||||
}
|
||||
|
||||
#endif /* CONFIG_INPUT */
|
||||
|
||||
int sysrq_toggle_support(int enable_mask)
|
||||
{
|
||||
bool was_enabled = sysrq_on();
|
||||
|
||||
sysrq_enabled = enable_mask;
|
||||
|
||||
if (was_enabled != sysrq_on()) {
|
||||
if (sysrq_on())
|
||||
sysrq_register_handler();
|
||||
else
|
||||
sysrq_unregister_handler();
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __sysrq_swap_key_ops(int key, struct sysrq_key_op *insert_op_p,
|
||||
struct sysrq_key_op *remove_op_p)
|
||||
{
|
||||
|
||||
int retval;
|
||||
unsigned long flags;
|
||||
|
||||
@ -599,6 +763,7 @@ static ssize_t write_sysrq_trigger(struct file *file, const char __user *buf,
|
||||
return -EFAULT;
|
||||
__handle_sysrq(c, NULL, 0);
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
@ -606,10 +771,28 @@ static const struct file_operations proc_sysrq_trigger_operations = {
|
||||
.write = write_sysrq_trigger,
|
||||
};
|
||||
|
||||
static void sysrq_init_procfs(void)
|
||||
{
|
||||
if (!proc_create("sysrq-trigger", S_IWUSR, NULL,
|
||||
&proc_sysrq_trigger_operations))
|
||||
pr_err("Failed to register proc interface\n");
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
static inline void sysrq_init_procfs(void)
|
||||
{
|
||||
}
|
||||
|
||||
#endif /* CONFIG_PROC_FS */
|
||||
|
||||
static int __init sysrq_init(void)
|
||||
{
|
||||
proc_create("sysrq-trigger", S_IWUSR, NULL, &proc_sysrq_trigger_operations);
|
||||
sysrq_init_procfs();
|
||||
|
||||
if (sysrq_on())
|
||||
sysrq_register_handler();
|
||||
|
||||
return 0;
|
||||
}
|
||||
module_init(sysrq_init);
|
||||
#endif
|
||||
|
@ -73,7 +73,7 @@ config KEYBOARD_ATKBD
|
||||
default y
|
||||
select SERIO
|
||||
select SERIO_LIBPS2
|
||||
select SERIO_I8042 if X86
|
||||
select SERIO_I8042 if X86 && !X86_MRST
|
||||
select SERIO_GSCPS2 if GSC
|
||||
help
|
||||
Say Y here if you want to use a standard AT or PS/2 keyboard. Usually
|
||||
@ -179,6 +179,22 @@ config KEYBOARD_GPIO
|
||||
To compile this driver as a module, choose M here: the
|
||||
module will be called gpio_keys.
|
||||
|
||||
config KEYBOARD_TCA6416
|
||||
tristate "TCA6416 Keypad Support"
|
||||
depends on I2C
|
||||
help
|
||||
This driver implements basic keypad functionality
|
||||
for keys connected through TCA6416 IO expander
|
||||
|
||||
Say Y here if your device has keys connected to
|
||||
TCA6416 IO expander. Your board-specific setup logic
|
||||
must also provide pin-mask details(of which TCA6416 pins
|
||||
are used for keypad).
|
||||
|
||||
If enabled the complete TCA6416 device will be managed through
|
||||
this driver.
|
||||
|
||||
|
||||
config KEYBOARD_MATRIX
|
||||
tristate "GPIO driven matrix keypad support"
|
||||
depends on GENERIC_GPIO
|
||||
|
@ -14,6 +14,7 @@ obj-$(CONFIG_KEYBOARD_BFIN) += bf54x-keys.o
|
||||
obj-$(CONFIG_KEYBOARD_DAVINCI) += davinci_keyscan.o
|
||||
obj-$(CONFIG_KEYBOARD_EP93XX) += ep93xx_keypad.o
|
||||
obj-$(CONFIG_KEYBOARD_GPIO) += gpio_keys.o
|
||||
obj-$(CONFIG_KEYBOARD_TCA6416) += tca6416-keypad.o
|
||||
obj-$(CONFIG_KEYBOARD_HIL) += hil_kbd.o
|
||||
obj-$(CONFIG_KEYBOARD_HIL_OLD) += hilkbd.o
|
||||
obj-$(CONFIG_KEYBOARD_IMX) += imx_keypad.o
|
||||
|
@ -670,8 +670,6 @@ static int __devinit lm8323_probe(struct i2c_client *client,
|
||||
goto fail1;
|
||||
}
|
||||
|
||||
i2c_set_clientdata(client, lm);
|
||||
|
||||
lm->client = client;
|
||||
lm->idev = idev;
|
||||
mutex_init(&lm->lock);
|
||||
@ -753,6 +751,8 @@ static int __devinit lm8323_probe(struct i2c_client *client,
|
||||
goto fail4;
|
||||
}
|
||||
|
||||
i2c_set_clientdata(client, lm);
|
||||
|
||||
device_init_wakeup(&client->dev, 1);
|
||||
enable_irq_wake(client->irq);
|
||||
|
||||
@ -778,6 +778,8 @@ static int __devexit lm8323_remove(struct i2c_client *client)
|
||||
struct lm8323_chip *lm = i2c_get_clientdata(client);
|
||||
int i;
|
||||
|
||||
i2c_set_clientdata(client, NULL);
|
||||
|
||||
disable_irq_wake(client->irq);
|
||||
free_irq(client->irq, lm);
|
||||
cancel_work_sync(&lm->work);
|
||||
|
349
drivers/input/keyboard/tca6416-keypad.c
Normal file
349
drivers/input/keyboard/tca6416-keypad.c
Normal file
@ -0,0 +1,349 @@
|
||||
/*
|
||||
* Driver for keys on TCA6416 I2C IO expander
|
||||
*
|
||||
* Copyright (C) 2010 Texas Instruments
|
||||
*
|
||||
* Author : Sriramakrishnan.A.G. <srk@ti.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*/
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/workqueue.h>
|
||||
#include <linux/gpio.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/input.h>
|
||||
#include <linux/tca6416_keypad.h>
|
||||
|
||||
#define TCA6416_INPUT 0
|
||||
#define TCA6416_OUTPUT 1
|
||||
#define TCA6416_INVERT 2
|
||||
#define TCA6416_DIRECTION 3
|
||||
|
||||
static const struct i2c_device_id tca6416_id[] = {
|
||||
{ "tca6416-keys", 16, },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(i2c, tca6416_id);
|
||||
|
||||
struct tca6416_drv_data {
|
||||
struct input_dev *input;
|
||||
struct tca6416_button data[0];
|
||||
};
|
||||
|
||||
struct tca6416_keypad_chip {
|
||||
uint16_t reg_output;
|
||||
uint16_t reg_direction;
|
||||
uint16_t reg_input;
|
||||
|
||||
struct i2c_client *client;
|
||||
struct input_dev *input;
|
||||
struct delayed_work dwork;
|
||||
u16 pinmask;
|
||||
int irqnum;
|
||||
bool use_polling;
|
||||
struct tca6416_button buttons[0];
|
||||
};
|
||||
|
||||
static int tca6416_write_reg(struct tca6416_keypad_chip *chip, int reg, u16 val)
|
||||
{
|
||||
int error;
|
||||
|
||||
error = i2c_smbus_write_word_data(chip->client, reg << 1, val);
|
||||
if (error < 0) {
|
||||
dev_err(&chip->client->dev,
|
||||
"%s failed, reg: %d, val: %d, error: %d\n",
|
||||
__func__, reg, val, error);
|
||||
return error;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int tca6416_read_reg(struct tca6416_keypad_chip *chip, int reg, u16 *val)
|
||||
{
|
||||
int retval;
|
||||
|
||||
retval = i2c_smbus_read_word_data(chip->client, reg << 1);
|
||||
if (retval < 0) {
|
||||
dev_err(&chip->client->dev, "%s failed, reg: %d, error: %d\n",
|
||||
__func__, reg, retval);
|
||||
return retval;
|
||||
}
|
||||
|
||||
*val = (u16)retval;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void tca6416_keys_scan(struct tca6416_keypad_chip *chip)
|
||||
{
|
||||
struct input_dev *input = chip->input;
|
||||
u16 reg_val, val;
|
||||
int error, i, pin_index;
|
||||
|
||||
error = tca6416_read_reg(chip, TCA6416_INPUT, ®_val);
|
||||
if (error)
|
||||
return;
|
||||
|
||||
reg_val &= chip->pinmask;
|
||||
|
||||
/* Figure out which lines have changed */
|
||||
val = reg_val ^ chip->reg_input;
|
||||
chip->reg_input = reg_val;
|
||||
|
||||
for (i = 0, pin_index = 0; i < 16; i++) {
|
||||
if (val & (1 << i)) {
|
||||
struct tca6416_button *button = &chip->buttons[pin_index];
|
||||
unsigned int type = button->type ?: EV_KEY;
|
||||
int state = ((reg_val & (1 << i)) ? 1 : 0)
|
||||
^ button->active_low;
|
||||
|
||||
input_event(input, type, button->code, !!state);
|
||||
input_sync(input);
|
||||
}
|
||||
|
||||
if (chip->pinmask & (1 << i))
|
||||
pin_index++;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* This is threaded IRQ handler and this can (and will) sleep.
|
||||
*/
|
||||
static irqreturn_t tca6416_keys_isr(int irq, void *dev_id)
|
||||
{
|
||||
struct tca6416_keypad_chip *chip = dev_id;
|
||||
|
||||
tca6416_keys_scan(chip);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static void tca6416_keys_work_func(struct work_struct *work)
|
||||
{
|
||||
struct tca6416_keypad_chip *chip =
|
||||
container_of(work, struct tca6416_keypad_chip, dwork.work);
|
||||
|
||||
tca6416_keys_scan(chip);
|
||||
schedule_delayed_work(&chip->dwork, msecs_to_jiffies(100));
|
||||
}
|
||||
|
||||
static int tca6416_keys_open(struct input_dev *dev)
|
||||
{
|
||||
struct tca6416_keypad_chip *chip = input_get_drvdata(dev);
|
||||
|
||||
/* Get initial device state in case it has switches */
|
||||
tca6416_keys_scan(chip);
|
||||
|
||||
if (chip->use_polling)
|
||||
schedule_delayed_work(&chip->dwork, msecs_to_jiffies(100));
|
||||
else
|
||||
enable_irq(chip->irqnum);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void tca6416_keys_close(struct input_dev *dev)
|
||||
{
|
||||
struct tca6416_keypad_chip *chip = input_get_drvdata(dev);
|
||||
|
||||
if (chip->use_polling)
|
||||
cancel_delayed_work_sync(&chip->dwork);
|
||||
else
|
||||
disable_irq(chip->irqnum);
|
||||
}
|
||||
|
||||
static int __devinit tca6416_setup_registers(struct tca6416_keypad_chip *chip)
|
||||
{
|
||||
int error;
|
||||
|
||||
error = tca6416_read_reg(chip, TCA6416_OUTPUT, &chip->reg_output);
|
||||
if (error)
|
||||
return error;
|
||||
|
||||
error = tca6416_read_reg(chip, TCA6416_DIRECTION, &chip->reg_direction);
|
||||
if (error)
|
||||
return error;
|
||||
|
||||
/* ensure that keypad pins are set to input */
|
||||
error = tca6416_write_reg(chip, TCA6416_DIRECTION,
|
||||
chip->reg_direction | chip->pinmask);
|
||||
if (error)
|
||||
return error;
|
||||
|
||||
error = tca6416_read_reg(chip, TCA6416_DIRECTION, &chip->reg_direction);
|
||||
if (error)
|
||||
return error;
|
||||
|
||||
error = tca6416_read_reg(chip, TCA6416_INPUT, &chip->reg_input);
|
||||
if (error)
|
||||
return error;
|
||||
|
||||
chip->reg_input &= chip->pinmask;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __devinit tca6416_keypad_probe(struct i2c_client *client,
|
||||
const struct i2c_device_id *id)
|
||||
{
|
||||
struct tca6416_keys_platform_data *pdata;
|
||||
struct tca6416_keypad_chip *chip;
|
||||
struct input_dev *input;
|
||||
int error;
|
||||
int i;
|
||||
|
||||
/* Check functionality */
|
||||
if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE)) {
|
||||
dev_err(&client->dev, "%s adapter not supported\n",
|
||||
dev_driver_string(&client->adapter->dev));
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
pdata = client->dev.platform_data;
|
||||
if (!pdata) {
|
||||
dev_dbg(&client->dev, "no platform data\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
chip = kzalloc(sizeof(struct tca6416_keypad_chip) +
|
||||
pdata->nbuttons * sizeof(struct tca6416_button),
|
||||
GFP_KERNEL);
|
||||
input = input_allocate_device();
|
||||
if (!chip || !input) {
|
||||
error = -ENOMEM;
|
||||
goto fail1;
|
||||
}
|
||||
|
||||
chip->client = client;
|
||||
chip->input = input;
|
||||
chip->pinmask = pdata->pinmask;
|
||||
chip->use_polling = pdata->use_polling;
|
||||
|
||||
INIT_DELAYED_WORK(&chip->dwork, tca6416_keys_work_func);
|
||||
|
||||
input->phys = "tca6416-keys/input0";
|
||||
input->name = client->name;
|
||||
input->dev.parent = &client->dev;
|
||||
|
||||
input->open = tca6416_keys_open;
|
||||
input->close = tca6416_keys_close;
|
||||
|
||||
input->id.bustype = BUS_HOST;
|
||||
input->id.vendor = 0x0001;
|
||||
input->id.product = 0x0001;
|
||||
input->id.version = 0x0100;
|
||||
|
||||
/* Enable auto repeat feature of Linux input subsystem */
|
||||
if (pdata->rep)
|
||||
__set_bit(EV_REP, input->evbit);
|
||||
|
||||
for (i = 0; i < pdata->nbuttons; i++) {
|
||||
unsigned int type;
|
||||
|
||||
chip->buttons[i] = pdata->buttons[i];
|
||||
type = (pdata->buttons[i].type) ?: EV_KEY;
|
||||
input_set_capability(input, type, pdata->buttons[i].code);
|
||||
}
|
||||
|
||||
input_set_drvdata(input, chip);
|
||||
|
||||
/*
|
||||
* Initialize cached registers from their original values.
|
||||
* we can't share this chip with another i2c master.
|
||||
*/
|
||||
error = tca6416_setup_registers(chip);
|
||||
if (error)
|
||||
goto fail1;
|
||||
|
||||
if (!chip->use_polling) {
|
||||
if (pdata->irq_is_gpio)
|
||||
chip->irqnum = gpio_to_irq(client->irq);
|
||||
else
|
||||
chip->irqnum = client->irq;
|
||||
|
||||
error = request_threaded_irq(chip->irqnum, NULL,
|
||||
tca6416_keys_isr,
|
||||
IRQF_TRIGGER_FALLING,
|
||||
"tca6416-keypad", chip);
|
||||
if (error) {
|
||||
dev_dbg(&client->dev,
|
||||
"Unable to claim irq %d; error %d\n",
|
||||
chip->irqnum, error);
|
||||
goto fail1;
|
||||
}
|
||||
disable_irq(chip->irqnum);
|
||||
}
|
||||
|
||||
error = input_register_device(input);
|
||||
if (error) {
|
||||
dev_dbg(&client->dev,
|
||||
"Unable to register input device, error: %d\n", error);
|
||||
goto fail2;
|
||||
}
|
||||
|
||||
i2c_set_clientdata(client, chip);
|
||||
|
||||
return 0;
|
||||
|
||||
fail2:
|
||||
if (!chip->use_polling) {
|
||||
free_irq(chip->irqnum, chip);
|
||||
enable_irq(chip->irqnum);
|
||||
}
|
||||
fail1:
|
||||
input_free_device(input);
|
||||
kfree(chip);
|
||||
return error;
|
||||
}
|
||||
|
||||
static int __devexit tca6416_keypad_remove(struct i2c_client *client)
|
||||
{
|
||||
struct tca6416_keypad_chip *chip = i2c_get_clientdata(client);
|
||||
|
||||
if (!chip->use_polling) {
|
||||
free_irq(chip->irqnum, chip);
|
||||
enable_irq(chip->irqnum);
|
||||
}
|
||||
|
||||
input_unregister_device(chip->input);
|
||||
kfree(chip);
|
||||
|
||||
i2c_set_clientdata(client, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static struct i2c_driver tca6416_keypad_driver = {
|
||||
.driver = {
|
||||
.name = "tca6416-keypad",
|
||||
},
|
||||
.probe = tca6416_keypad_probe,
|
||||
.remove = __devexit_p(tca6416_keypad_remove),
|
||||
.id_table = tca6416_id,
|
||||
};
|
||||
|
||||
static int __init tca6416_keypad_init(void)
|
||||
{
|
||||
return i2c_add_driver(&tca6416_keypad_driver);
|
||||
}
|
||||
|
||||
subsys_initcall(tca6416_keypad_init);
|
||||
|
||||
static void __exit tca6416_keypad_exit(void)
|
||||
{
|
||||
i2c_del_driver(&tca6416_keypad_driver);
|
||||
}
|
||||
module_exit(tca6416_keypad_exit);
|
||||
|
||||
MODULE_AUTHOR("Sriramakrishnan <srk@ti.com>");
|
||||
MODULE_DESCRIPTION("Keypad driver over tca6146 IO expander");
|
||||
MODULE_LICENSE("GPL");
|
@ -87,7 +87,6 @@ static int __devinit pm860x_onkey_probe(struct platform_device *pdev)
|
||||
info->idev->phys = "88pm860x_on/input0";
|
||||
info->idev->id.bustype = BUS_I2C;
|
||||
info->idev->dev.parent = &pdev->dev;
|
||||
info->irq = irq;
|
||||
info->idev->evbit[0] = BIT_MASK(EV_KEY);
|
||||
info->idev->keybit[BIT_WORD(KEY_POWER)] = BIT_MASK(KEY_POWER);
|
||||
|
||||
|
@ -22,6 +22,36 @@ config INPUT_88PM860X_ONKEY
|
||||
To compile this driver as a module, choose M here: the module
|
||||
will be called 88pm860x_onkey.
|
||||
|
||||
config INPUT_AD714X
|
||||
tristate "Analog Devices AD714x Capacitance Touch Sensor"
|
||||
help
|
||||
Say Y here if you want to support an AD7142/3/7/8/7A touch sensor.
|
||||
|
||||
You should select a bus connection too.
|
||||
|
||||
To compile this driver as a module, choose M here: the
|
||||
module will be called ad714x.
|
||||
|
||||
config INPUT_AD714X_I2C
|
||||
tristate "support I2C bus connection"
|
||||
depends on INPUT_AD714X && I2C
|
||||
default y
|
||||
help
|
||||
Say Y here if you have AD7142/AD7147 hooked to an I2C bus.
|
||||
|
||||
To compile this driver as a module, choose M here: the
|
||||
module will be called ad714x-i2c.
|
||||
|
||||
config INPUT_AD714X_SPI
|
||||
tristate "support SPI bus connection"
|
||||
depends on INPUT_AD714X && SPI
|
||||
default y
|
||||
help
|
||||
Say Y here if you have AD7142/AD7147 hooked to a SPI bus.
|
||||
|
||||
To compile this driver as a module, choose M here: the
|
||||
module will be called ad714x-spi.
|
||||
|
||||
config INPUT_PCSPKR
|
||||
tristate "PC Speaker support"
|
||||
depends on PCSPKR_PLATFORM
|
||||
@ -277,6 +307,16 @@ config INPUT_PCF50633_PMU
|
||||
Say Y to include support for delivering PMU events via input
|
||||
layer on NXP PCF50633.
|
||||
|
||||
config INPUT_PCF8574
|
||||
tristate "PCF8574 Keypad input device"
|
||||
depends on I2C && EXPERIMENTAL
|
||||
help
|
||||
Say Y here if you want to support a keypad connetced via I2C
|
||||
with a PCF8574.
|
||||
|
||||
To compile this driver as a module, choose M here: the
|
||||
module will be called pcf8574_keypad.
|
||||
|
||||
config INPUT_GPIO_ROTARY_ENCODER
|
||||
tristate "Rotary encoders connected to GPIO pins"
|
||||
depends on GPIOLIB && GENERIC_GPIO
|
||||
|
@ -5,6 +5,9 @@
|
||||
# Each configuration option enables a list of files.
|
||||
|
||||
obj-$(CONFIG_INPUT_88PM860X_ONKEY) += 88pm860x_onkey.o
|
||||
obj-$(CONFIG_INPUT_AD714X) += ad714x.o
|
||||
obj-$(CONFIG_INPUT_AD714X_I2C) += ad714x-i2c.o
|
||||
obj-$(CONFIG_INPUT_AD714X_SPI) += ad714x-spi.o
|
||||
obj-$(CONFIG_INPUT_APANEL) += apanel.o
|
||||
obj-$(CONFIG_INPUT_ATI_REMOTE) += ati_remote.o
|
||||
obj-$(CONFIG_INPUT_ATI_REMOTE2) += ati_remote2.o
|
||||
@ -19,6 +22,7 @@ obj-$(CONFIG_INPUT_KEYSPAN_REMOTE) += keyspan_remote.o
|
||||
obj-$(CONFIG_INPUT_M68K_BEEP) += m68kspkr.o
|
||||
obj-$(CONFIG_INPUT_PCAP) += pcap_keys.o
|
||||
obj-$(CONFIG_INPUT_PCF50633_PMU) += pcf50633-input.o
|
||||
obj-$(CONFIG_INPUT_PCF8574) += pcf8574_keypad.o
|
||||
obj-$(CONFIG_INPUT_PCSPKR) += pcspkr.o
|
||||
obj-$(CONFIG_INPUT_POWERMATE) += powermate.o
|
||||
obj-$(CONFIG_INPUT_RB532_BUTTON) += rb532_button.o
|
||||
|
140
drivers/input/misc/ad714x-i2c.c
Normal file
140
drivers/input/misc/ad714x-i2c.c
Normal file
@ -0,0 +1,140 @@
|
||||
/*
|
||||
* AD714X CapTouch Programmable Controller driver (I2C bus)
|
||||
*
|
||||
* Copyright 2009 Analog Devices Inc.
|
||||
*
|
||||
* Licensed under the GPL-2 or later.
|
||||
*/
|
||||
|
||||
#include <linux/input.h> /* BUS_I2C */
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/types.h>
|
||||
#include "ad714x.h"
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
static int ad714x_i2c_suspend(struct i2c_client *client, pm_message_t message)
|
||||
{
|
||||
return ad714x_disable(i2c_get_clientdata(client));
|
||||
}
|
||||
|
||||
static int ad714x_i2c_resume(struct i2c_client *client)
|
||||
{
|
||||
return ad714x_enable(i2c_get_clientdata(client));
|
||||
}
|
||||
#else
|
||||
# define ad714x_i2c_suspend NULL
|
||||
# define ad714x_i2c_resume NULL
|
||||
#endif
|
||||
|
||||
static int ad714x_i2c_write(struct device *dev, unsigned short reg,
|
||||
unsigned short data)
|
||||
{
|
||||
struct i2c_client *client = to_i2c_client(dev);
|
||||
int ret = 0;
|
||||
u8 *_reg = (u8 *)®
|
||||
u8 *_data = (u8 *)&data;
|
||||
|
||||
u8 tx[4] = {
|
||||
_reg[1],
|
||||
_reg[0],
|
||||
_data[1],
|
||||
_data[0]
|
||||
};
|
||||
|
||||
ret = i2c_master_send(client, tx, 4);
|
||||
if (ret < 0)
|
||||
dev_err(&client->dev, "I2C write error\n");
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int ad714x_i2c_read(struct device *dev, unsigned short reg,
|
||||
unsigned short *data)
|
||||
{
|
||||
struct i2c_client *client = to_i2c_client(dev);
|
||||
int ret = 0;
|
||||
u8 *_reg = (u8 *)®
|
||||
u8 *_data = (u8 *)data;
|
||||
|
||||
u8 tx[2] = {
|
||||
_reg[1],
|
||||
_reg[0]
|
||||
};
|
||||
u8 rx[2];
|
||||
|
||||
ret = i2c_master_send(client, tx, 2);
|
||||
if (ret >= 0)
|
||||
ret = i2c_master_recv(client, rx, 2);
|
||||
|
||||
if (unlikely(ret < 0)) {
|
||||
dev_err(&client->dev, "I2C read error\n");
|
||||
} else {
|
||||
_data[0] = rx[1];
|
||||
_data[1] = rx[0];
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int __devinit ad714x_i2c_probe(struct i2c_client *client,
|
||||
const struct i2c_device_id *id)
|
||||
{
|
||||
struct ad714x_chip *chip;
|
||||
|
||||
chip = ad714x_probe(&client->dev, BUS_I2C, client->irq,
|
||||
ad714x_i2c_read, ad714x_i2c_write);
|
||||
if (IS_ERR(chip))
|
||||
return PTR_ERR(chip);
|
||||
|
||||
i2c_set_clientdata(client, chip);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __devexit ad714x_i2c_remove(struct i2c_client *client)
|
||||
{
|
||||
struct ad714x_chip *chip = i2c_get_clientdata(client);
|
||||
|
||||
ad714x_remove(chip);
|
||||
i2c_set_clientdata(client, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct i2c_device_id ad714x_id[] = {
|
||||
{ "ad7142_captouch", 0 },
|
||||
{ "ad7143_captouch", 0 },
|
||||
{ "ad7147_captouch", 0 },
|
||||
{ "ad7147a_captouch", 0 },
|
||||
{ "ad7148_captouch", 0 },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(i2c, ad714x_id);
|
||||
|
||||
static struct i2c_driver ad714x_i2c_driver = {
|
||||
.driver = {
|
||||
.name = "ad714x_captouch",
|
||||
},
|
||||
.probe = ad714x_i2c_probe,
|
||||
.remove = __devexit_p(ad714x_i2c_remove),
|
||||
.suspend = ad714x_i2c_suspend,
|
||||
.resume = ad714x_i2c_resume,
|
||||
.id_table = ad714x_id,
|
||||
};
|
||||
|
||||
static __init int ad714x_i2c_init(void)
|
||||
{
|
||||
return i2c_add_driver(&ad714x_i2c_driver);
|
||||
}
|
||||
module_init(ad714x_i2c_init);
|
||||
|
||||
static __exit void ad714x_i2c_exit(void)
|
||||
{
|
||||
i2c_del_driver(&ad714x_i2c_driver);
|
||||
}
|
||||
module_exit(ad714x_i2c_exit);
|
||||
|
||||
MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor I2C Bus Driver");
|
||||
MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
|
||||
MODULE_LICENSE("GPL");
|
103
drivers/input/misc/ad714x-spi.c
Normal file
103
drivers/input/misc/ad714x-spi.c
Normal file
@ -0,0 +1,103 @@
|
||||
/*
|
||||
* AD714X CapTouch Programmable Controller driver (SPI bus)
|
||||
*
|
||||
* Copyright 2009 Analog Devices Inc.
|
||||
*
|
||||
* Licensed under the GPL-2 or later.
|
||||
*/
|
||||
|
||||
#include <linux/input.h> /* BUS_I2C */
|
||||
#include <linux/module.h>
|
||||
#include <linux/spi/spi.h>
|
||||
#include <linux/types.h>
|
||||
#include "ad714x.h"
|
||||
|
||||
#define AD714x_SPI_CMD_PREFIX 0xE000 /* bits 15:11 */
|
||||
#define AD714x_SPI_READ BIT(10)
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
static int ad714x_spi_suspend(struct spi_device *spi, pm_message_t message)
|
||||
{
|
||||
return ad714x_disable(spi_get_drvdata(spi));
|
||||
}
|
||||
|
||||
static int ad714x_spi_resume(struct spi_device *spi)
|
||||
{
|
||||
return ad714x_enable(spi_get_drvdata(spi));
|
||||
}
|
||||
#else
|
||||
# define ad714x_spi_suspend NULL
|
||||
# define ad714x_spi_resume NULL
|
||||
#endif
|
||||
|
||||
static int ad714x_spi_read(struct device *dev, unsigned short reg,
|
||||
unsigned short *data)
|
||||
{
|
||||
struct spi_device *spi = to_spi_device(dev);
|
||||
unsigned short tx = AD714x_SPI_CMD_PREFIX | AD714x_SPI_READ | reg;
|
||||
|
||||
return spi_write_then_read(spi, (u8 *)&tx, 2, (u8 *)data, 2);
|
||||
}
|
||||
|
||||
static int ad714x_spi_write(struct device *dev, unsigned short reg,
|
||||
unsigned short data)
|
||||
{
|
||||
struct spi_device *spi = to_spi_device(dev);
|
||||
unsigned short tx[2] = {
|
||||
AD714x_SPI_CMD_PREFIX | reg,
|
||||
data
|
||||
};
|
||||
|
||||
return spi_write(spi, (u8 *)tx, 4);
|
||||
}
|
||||
|
||||
static int __devinit ad714x_spi_probe(struct spi_device *spi)
|
||||
{
|
||||
struct ad714x_chip *chip;
|
||||
|
||||
chip = ad714x_probe(&spi->dev, BUS_SPI, spi->irq,
|
||||
ad714x_spi_read, ad714x_spi_write);
|
||||
if (IS_ERR(chip))
|
||||
return PTR_ERR(chip);
|
||||
|
||||
spi_set_drvdata(spi, chip);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __devexit ad714x_spi_remove(struct spi_device *spi)
|
||||
{
|
||||
struct ad714x_chip *chip = spi_get_drvdata(spi);
|
||||
|
||||
ad714x_remove(chip);
|
||||
spi_set_drvdata(spi, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct spi_driver ad714x_spi_driver = {
|
||||
.driver = {
|
||||
.name = "ad714x_captouch",
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
.probe = ad714x_spi_probe,
|
||||
.remove = __devexit_p(ad714x_spi_remove),
|
||||
.suspend = ad714x_spi_suspend,
|
||||
.resume = ad714x_spi_resume,
|
||||
};
|
||||
|
||||
static __init int ad714x_spi_init(void)
|
||||
{
|
||||
return spi_register_driver(&ad714x_spi_driver);
|
||||
}
|
||||
module_init(ad714x_spi_init);
|
||||
|
||||
static __exit void ad714x_spi_exit(void)
|
||||
{
|
||||
spi_unregister_driver(&ad714x_spi_driver);
|
||||
}
|
||||
module_exit(ad714x_spi_exit);
|
||||
|
||||
MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor SPI Bus Driver");
|
||||
MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
|
||||
MODULE_LICENSE("GPL");
|
1347
drivers/input/misc/ad714x.c
Normal file
1347
drivers/input/misc/ad714x.c
Normal file
File diff suppressed because it is too large
Load Diff
26
drivers/input/misc/ad714x.h
Normal file
26
drivers/input/misc/ad714x.h
Normal file
@ -0,0 +1,26 @@
|
||||
/*
|
||||
* AD714X CapTouch Programmable Controller driver (bus interfaces)
|
||||
*
|
||||
* Copyright 2009 Analog Devices Inc.
|
||||
*
|
||||
* Licensed under the GPL-2 or later.
|
||||
*/
|
||||
|
||||
#ifndef _AD714X_H_
|
||||
#define _AD714X_H_
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
struct device;
|
||||
struct ad714x_chip;
|
||||
|
||||
typedef int (*ad714x_read_t)(struct device *, unsigned short, unsigned short *);
|
||||
typedef int (*ad714x_write_t)(struct device *, unsigned short, unsigned short);
|
||||
|
||||
int ad714x_disable(struct ad714x_chip *ad714x);
|
||||
int ad714x_enable(struct ad714x_chip *ad714x);
|
||||
struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
|
||||
ad714x_read_t read, ad714x_write_t write);
|
||||
void ad714x_remove(struct ad714x_chip *ad714x);
|
||||
|
||||
#endif
|
227
drivers/input/misc/pcf8574_keypad.c
Normal file
227
drivers/input/misc/pcf8574_keypad.c
Normal file
@ -0,0 +1,227 @@
|
||||
/*
|
||||
* Driver for a keypad w/16 buttons connected to a PCF8574 I2C I/O expander
|
||||
*
|
||||
* Copyright 2005-2008 Analog Devices Inc.
|
||||
*
|
||||
* Licensed under the GPL-2 or later.
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/input.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/workqueue.h>
|
||||
|
||||
#define DRV_NAME "pcf8574_keypad"
|
||||
|
||||
static const unsigned char pcf8574_kp_btncode[] = {
|
||||
[0] = KEY_RESERVED,
|
||||
[1] = KEY_ENTER,
|
||||
[2] = KEY_BACKSLASH,
|
||||
[3] = KEY_0,
|
||||
[4] = KEY_RIGHTBRACE,
|
||||
[5] = KEY_C,
|
||||
[6] = KEY_9,
|
||||
[7] = KEY_8,
|
||||
[8] = KEY_7,
|
||||
[9] = KEY_B,
|
||||
[10] = KEY_6,
|
||||
[11] = KEY_5,
|
||||
[12] = KEY_4,
|
||||
[13] = KEY_A,
|
||||
[14] = KEY_3,
|
||||
[15] = KEY_2,
|
||||
[16] = KEY_1
|
||||
};
|
||||
|
||||
struct kp_data {
|
||||
unsigned short btncode[ARRAY_SIZE(pcf8574_kp_btncode)];
|
||||
struct input_dev *idev;
|
||||
struct i2c_client *client;
|
||||
char name[64];
|
||||
char phys[32];
|
||||
unsigned char laststate;
|
||||
};
|
||||
|
||||
static short read_state(struct kp_data *lp)
|
||||
{
|
||||
unsigned char x, y, a, b;
|
||||
|
||||
i2c_smbus_write_byte(lp->client, 240);
|
||||
x = 0xF & (~(i2c_smbus_read_byte(lp->client) >> 4));
|
||||
|
||||
i2c_smbus_write_byte(lp->client, 15);
|
||||
y = 0xF & (~i2c_smbus_read_byte(lp->client));
|
||||
|
||||
for (a = 0; x > 0; a++)
|
||||
x = x >> 1;
|
||||
for (b = 0; y > 0; b++)
|
||||
y = y >> 1;
|
||||
|
||||
return ((a - 1) * 4) + b;
|
||||
}
|
||||
|
||||
static irqreturn_t pcf8574_kp_irq_handler(int irq, void *dev_id)
|
||||
{
|
||||
struct kp_data *lp = dev_id;
|
||||
unsigned char nextstate = read_state(lp);
|
||||
|
||||
if (lp->laststate != nextstate) {
|
||||
int key_down = nextstate <= ARRAY_SIZE(lp->btncode);
|
||||
unsigned short keycode = key_down ?
|
||||
lp->btncode[nextstate] : lp->btncode[lp->laststate];
|
||||
|
||||
input_report_key(lp->idev, keycode, key_down);
|
||||
input_sync(lp->idev);
|
||||
|
||||
lp->laststate = nextstate;
|
||||
}
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static int __devinit pcf8574_kp_probe(struct i2c_client *client, const struct i2c_device_id *id)
|
||||
{
|
||||
int i, ret;
|
||||
struct input_dev *idev;
|
||||
struct kp_data *lp;
|
||||
|
||||
if (i2c_smbus_write_byte(client, 240) < 0) {
|
||||
dev_err(&client->dev, "probe: write fail\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
lp = kzalloc(sizeof(*lp), GFP_KERNEL);
|
||||
if (!lp)
|
||||
return -ENOMEM;
|
||||
|
||||
idev = input_allocate_device();
|
||||
if (!idev) {
|
||||
dev_err(&client->dev, "Can't allocate input device\n");
|
||||
ret = -ENOMEM;
|
||||
goto fail_allocate;
|
||||
}
|
||||
|
||||
lp->idev = idev;
|
||||
lp->client = client;
|
||||
|
||||
idev->evbit[0] = BIT_MASK(EV_KEY);
|
||||
idev->keycode = lp->btncode;
|
||||
idev->keycodesize = sizeof(lp->btncode[0]);
|
||||
idev->keycodemax = ARRAY_SIZE(lp->btncode);
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(pcf8574_kp_btncode); i++) {
|
||||
lp->btncode[i] = pcf8574_kp_btncode[i];
|
||||
__set_bit(lp->btncode[i] & KEY_MAX, idev->keybit);
|
||||
}
|
||||
|
||||
sprintf(lp->name, DRV_NAME);
|
||||
sprintf(lp->phys, "kp_data/input0");
|
||||
|
||||
idev->name = lp->name;
|
||||
idev->phys = lp->phys;
|
||||
idev->id.bustype = BUS_I2C;
|
||||
idev->id.vendor = 0x0001;
|
||||
idev->id.product = 0x0001;
|
||||
idev->id.version = 0x0100;
|
||||
|
||||
input_set_drvdata(idev, lp);
|
||||
|
||||
ret = input_register_device(idev);
|
||||
if (ret) {
|
||||
dev_err(&client->dev, "input_register_device() failed\n");
|
||||
goto fail_register;
|
||||
}
|
||||
|
||||
lp->laststate = read_state(lp);
|
||||
|
||||
ret = request_threaded_irq(client->irq, NULL, pcf8574_kp_irq_handler,
|
||||
IRQF_TRIGGER_LOW | IRQF_ONESHOT,
|
||||
DRV_NAME, lp);
|
||||
if (ret) {
|
||||
dev_err(&client->dev, "IRQ %d is not free\n", client->irq);
|
||||
goto fail_irq;
|
||||
}
|
||||
|
||||
i2c_set_clientdata(client, lp);
|
||||
return 0;
|
||||
|
||||
fail_irq:
|
||||
input_unregister_device(idev);
|
||||
fail_register:
|
||||
input_set_drvdata(idev, NULL);
|
||||
input_free_device(idev);
|
||||
fail_allocate:
|
||||
kfree(lp);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int __devexit pcf8574_kp_remove(struct i2c_client *client)
|
||||
{
|
||||
struct kp_data *lp = i2c_get_clientdata(client);
|
||||
|
||||
free_irq(client->irq, lp);
|
||||
|
||||
input_unregister_device(lp->idev);
|
||||
kfree(lp);
|
||||
|
||||
i2c_set_clientdata(client, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
static int pcf8574_kp_resume(struct i2c_client *client)
|
||||
{
|
||||
enable_irq(client->irq);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int pcf8574_kp_suspend(struct i2c_client *client, pm_message_t mesg)
|
||||
{
|
||||
disable_irq(client->irq);
|
||||
|
||||
return 0;
|
||||
}
|
||||
#else
|
||||
# define pcf8574_kp_resume NULL
|
||||
# define pcf8574_kp_suspend NULL
|
||||
#endif
|
||||
|
||||
static const struct i2c_device_id pcf8574_kp_id[] = {
|
||||
{ DRV_NAME, 0 },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(i2c, pcf8574_kp_id);
|
||||
|
||||
static struct i2c_driver pcf8574_kp_driver = {
|
||||
.driver = {
|
||||
.name = DRV_NAME,
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
.probe = pcf8574_kp_probe,
|
||||
.remove = __devexit_p(pcf8574_kp_remove),
|
||||
.suspend = pcf8574_kp_suspend,
|
||||
.resume = pcf8574_kp_resume,
|
||||
.id_table = pcf8574_kp_id,
|
||||
};
|
||||
|
||||
static int __init pcf8574_kp_init(void)
|
||||
{
|
||||
return i2c_add_driver(&pcf8574_kp_driver);
|
||||
}
|
||||
module_init(pcf8574_kp_init);
|
||||
|
||||
static void __exit pcf8574_kp_exit(void)
|
||||
{
|
||||
i2c_del_driver(&pcf8574_kp_driver);
|
||||
}
|
||||
module_exit(pcf8574_kp_exit);
|
||||
|
||||
MODULE_AUTHOR("Michael Hennerich");
|
||||
MODULE_DESCRIPTION("Keypad input driver for 16 keys connected to PCF8574");
|
||||
MODULE_LICENSE("GPL");
|
@ -983,11 +983,11 @@ static int __init copy_keymap(void)
|
||||
for (key = keymap; key->type != KE_END; key++)
|
||||
length++;
|
||||
|
||||
new_keymap = kmalloc(length * sizeof(struct key_entry), GFP_KERNEL);
|
||||
new_keymap = kmemdup(keymap, length * sizeof(struct key_entry),
|
||||
GFP_KERNEL);
|
||||
if (!new_keymap)
|
||||
return -ENOMEM;
|
||||
|
||||
memcpy(new_keymap, keymap, length * sizeof(struct key_entry));
|
||||
keymap = new_keymap;
|
||||
|
||||
return 0;
|
||||
|
@ -17,7 +17,7 @@ config MOUSE_PS2
|
||||
default y
|
||||
select SERIO
|
||||
select SERIO_LIBPS2
|
||||
select SERIO_I8042 if X86
|
||||
select SERIO_I8042 if X86 && !X86_MRST
|
||||
select SERIO_GSCPS2 if GSC
|
||||
help
|
||||
Say Y here if you have a PS/2 mouse connected to your system. This
|
||||
|
@ -10,6 +10,8 @@
|
||||
* Trademarks are the property of their respective owners.
|
||||
*/
|
||||
|
||||
#define pr_fmt(fmt) KBUILD_BASENAME ": " fmt
|
||||
|
||||
#include <linux/delay.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/module.h>
|
||||
@ -19,10 +21,10 @@
|
||||
#include "psmouse.h"
|
||||
#include "elantech.h"
|
||||
|
||||
#define elantech_debug(format, arg...) \
|
||||
#define elantech_debug(fmt, ...) \
|
||||
do { \
|
||||
if (etd->debug) \
|
||||
printk(KERN_DEBUG format, ##arg); \
|
||||
printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__); \
|
||||
} while (0)
|
||||
|
||||
static bool force_elantech;
|
||||
@ -37,7 +39,7 @@ static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c,
|
||||
{
|
||||
if (psmouse_sliced_command(psmouse, c) ||
|
||||
ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
|
||||
pr_err("elantech.c: synaptics_send_cmd query 0x%02x failed.\n", c);
|
||||
pr_err("synaptics_send_cmd query 0x%02x failed.\n", c);
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -60,13 +62,13 @@ static int elantech_ps2_command(struct psmouse *psmouse,
|
||||
if (rc == 0)
|
||||
break;
|
||||
tries--;
|
||||
elantech_debug("elantech.c: retrying ps2 command 0x%02x (%d).\n",
|
||||
elantech_debug("retrying ps2 command 0x%02x (%d).\n",
|
||||
command, tries);
|
||||
msleep(ETP_PS2_COMMAND_DELAY);
|
||||
} while (tries > 0);
|
||||
|
||||
if (rc)
|
||||
pr_err("elantech.c: ps2 command 0x%02x failed.\n", command);
|
||||
pr_err("ps2 command 0x%02x failed.\n", command);
|
||||
|
||||
return rc;
|
||||
}
|
||||
@ -108,7 +110,7 @@ static int elantech_read_reg(struct psmouse *psmouse, unsigned char reg,
|
||||
}
|
||||
|
||||
if (rc)
|
||||
pr_err("elantech.c: failed to read register 0x%02x.\n", reg);
|
||||
pr_err("failed to read register 0x%02x.\n", reg);
|
||||
else
|
||||
*val = param[0];
|
||||
|
||||
@ -154,7 +156,7 @@ static int elantech_write_reg(struct psmouse *psmouse, unsigned char reg,
|
||||
}
|
||||
|
||||
if (rc)
|
||||
pr_err("elantech.c: failed to write register 0x%02x with value 0x%02x.\n",
|
||||
pr_err("failed to write register 0x%02x with value 0x%02x.\n",
|
||||
reg, val);
|
||||
|
||||
return rc;
|
||||
@ -167,7 +169,7 @@ static void elantech_packet_dump(unsigned char *packet, int size)
|
||||
{
|
||||
int i;
|
||||
|
||||
printk(KERN_DEBUG "elantech.c: PS/2 packet [");
|
||||
printk(KERN_DEBUG pr_fmt("PS/2 packet ["));
|
||||
for (i = 0; i < size; i++)
|
||||
printk("%s0x%02x ", (i) ? ", " : " ", packet[i]);
|
||||
printk("]\n");
|
||||
@ -203,7 +205,7 @@ static void elantech_report_absolute_v1(struct psmouse *psmouse)
|
||||
if (etd->jumpy_cursor) {
|
||||
/* Discard packets that are likely to have bogus coordinates */
|
||||
if (fingers > old_fingers) {
|
||||
elantech_debug("elantech.c: discarding packet\n");
|
||||
elantech_debug("discarding packet\n");
|
||||
goto discard_packet_v1;
|
||||
}
|
||||
}
|
||||
@ -413,23 +415,21 @@ static int elantech_set_absolute_mode(struct psmouse *psmouse)
|
||||
if (rc == 0)
|
||||
break;
|
||||
tries--;
|
||||
elantech_debug("elantech.c: retrying read (%d).\n",
|
||||
tries);
|
||||
elantech_debug("retrying read (%d).\n", tries);
|
||||
msleep(ETP_READ_BACK_DELAY);
|
||||
} while (tries > 0);
|
||||
|
||||
if (rc) {
|
||||
pr_err("elantech.c: failed to read back register 0x10.\n");
|
||||
pr_err("failed to read back register 0x10.\n");
|
||||
} else if (etd->hw_version == 1 &&
|
||||
!(val & ETP_R10_ABSOLUTE_MODE)) {
|
||||
pr_err("elantech.c: touchpad refuses "
|
||||
"to switch to absolute mode.\n");
|
||||
pr_err("touchpad refuses to switch to absolute mode.\n");
|
||||
rc = -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (rc)
|
||||
pr_err("elantech.c: failed to initialise registers.\n");
|
||||
pr_err("failed to initialise registers.\n");
|
||||
|
||||
return rc;
|
||||
}
|
||||
@ -575,6 +575,24 @@ static struct attribute_group elantech_attr_group = {
|
||||
.attrs = elantech_attrs,
|
||||
};
|
||||
|
||||
static bool elantech_is_signature_valid(const unsigned char *param)
|
||||
{
|
||||
static const unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10 };
|
||||
int i;
|
||||
|
||||
if (param[0] == 0)
|
||||
return false;
|
||||
|
||||
if (param[1] == 0)
|
||||
return true;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(rates); i++)
|
||||
if (param[2] == rates[i])
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
* Use magic knock to detect Elantech touchpad
|
||||
*/
|
||||
@ -590,7 +608,7 @@ int elantech_detect(struct psmouse *psmouse, bool set_properties)
|
||||
ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
|
||||
ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
|
||||
ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
|
||||
pr_debug("elantech.c: sending Elantech magic knock failed.\n");
|
||||
pr_debug("sending Elantech magic knock failed.\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -599,8 +617,7 @@ int elantech_detect(struct psmouse *psmouse, bool set_properties)
|
||||
* set of magic numbers
|
||||
*/
|
||||
if (param[0] != 0x3c || param[1] != 0x03 || param[2] != 0xc8) {
|
||||
pr_debug("elantech.c: "
|
||||
"unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n",
|
||||
pr_debug("unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n",
|
||||
param[0], param[1], param[2]);
|
||||
return -1;
|
||||
}
|
||||
@ -611,20 +628,20 @@ int elantech_detect(struct psmouse *psmouse, bool set_properties)
|
||||
* to Elantech magic knock and there might be more.
|
||||
*/
|
||||
if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
|
||||
pr_debug("elantech.c: failed to query firmware version.\n");
|
||||
pr_debug("failed to query firmware version.\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
pr_debug("elantech.c: Elantech version query result 0x%02x, 0x%02x, 0x%02x.\n",
|
||||
pr_debug("Elantech version query result 0x%02x, 0x%02x, 0x%02x.\n",
|
||||
param[0], param[1], param[2]);
|
||||
|
||||
if (param[0] == 0 || param[1] != 0) {
|
||||
if (!elantech_is_signature_valid(param)) {
|
||||
if (!force_elantech) {
|
||||
pr_debug("elantech.c: Probably not a real Elantech touchpad. Aborting.\n");
|
||||
pr_debug("Probably not a real Elantech touchpad. Aborting.\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
pr_debug("elantech.c: Probably not a real Elantech touchpad. Enabling anyway due to force_elantech.\n");
|
||||
pr_debug("Probably not a real Elantech touchpad. Enabling anyway due to force_elantech.\n");
|
||||
}
|
||||
|
||||
if (set_properties) {
|
||||
@ -655,7 +672,7 @@ static int elantech_reconnect(struct psmouse *psmouse)
|
||||
return -1;
|
||||
|
||||
if (elantech_set_absolute_mode(psmouse)) {
|
||||
pr_err("elantech.c: failed to put touchpad back into absolute mode.\n");
|
||||
pr_err("failed to put touchpad back into absolute mode.\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -683,7 +700,7 @@ int elantech_init(struct psmouse *psmouse)
|
||||
* Do the version query again so we can store the result
|
||||
*/
|
||||
if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
|
||||
pr_err("elantech.c: failed to query firmware version.\n");
|
||||
pr_err("failed to query firmware version.\n");
|
||||
goto init_fail;
|
||||
}
|
||||
|
||||
@ -704,14 +721,14 @@ int elantech_init(struct psmouse *psmouse)
|
||||
etd->paritycheck = 1;
|
||||
}
|
||||
|
||||
pr_info("elantech.c: assuming hardware version %d, firmware version %d.%d.%d\n",
|
||||
pr_info("assuming hardware version %d, firmware version %d.%d.%d\n",
|
||||
etd->hw_version, param[0], param[1], param[2]);
|
||||
|
||||
if (synaptics_send_cmd(psmouse, ETP_CAPABILITIES_QUERY, param)) {
|
||||
pr_err("elantech.c: failed to query capabilities.\n");
|
||||
pr_err("failed to query capabilities.\n");
|
||||
goto init_fail;
|
||||
}
|
||||
pr_info("elantech.c: Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n",
|
||||
pr_info("Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n",
|
||||
param[0], param[1], param[2]);
|
||||
etd->capabilities = param[0];
|
||||
|
||||
@ -721,13 +738,12 @@ int elantech_init(struct psmouse *psmouse)
|
||||
* to jump. Enable a workaround.
|
||||
*/
|
||||
if (etd->fw_version == 0x020022) {
|
||||
pr_info("elantech.c: firmware version 2.0.34 detected, "
|
||||
"enabling jumpy cursor workaround\n");
|
||||
pr_info("firmware version 2.0.34 detected, enabling jumpy cursor workaround\n");
|
||||
etd->jumpy_cursor = 1;
|
||||
}
|
||||
|
||||
if (elantech_set_absolute_mode(psmouse)) {
|
||||
pr_err("elantech.c: failed to put touchpad into absolute mode.\n");
|
||||
pr_err("failed to put touchpad into absolute mode.\n");
|
||||
goto init_fail;
|
||||
}
|
||||
|
||||
@ -736,8 +752,7 @@ int elantech_init(struct psmouse *psmouse)
|
||||
error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
|
||||
&elantech_attr_group);
|
||||
if (error) {
|
||||
pr_err("elantech.c: failed to create sysfs attributes, error: %d.\n",
|
||||
error);
|
||||
pr_err("failed to create sysfs attributes, error: %d.\n", error);
|
||||
goto init_fail;
|
||||
}
|
||||
|
||||
|
@ -40,8 +40,8 @@
|
||||
#include "psmouse.h"
|
||||
#include "hgpk.h"
|
||||
|
||||
static int tpdebug;
|
||||
module_param(tpdebug, int, 0644);
|
||||
static bool tpdebug;
|
||||
module_param(tpdebug, bool, 0644);
|
||||
MODULE_PARM_DESC(tpdebug, "enable debugging, dumping packets to KERN_DEBUG.");
|
||||
|
||||
static int recalib_delta = 100;
|
||||
|
@ -250,7 +250,6 @@ static const struct ps2pp_info *get_model_info(unsigned char model)
|
||||
if (model == ps2pp_list[i].model)
|
||||
return &ps2pp_list[i];
|
||||
|
||||
printk(KERN_WARNING "logips2pp: Detected unknown logitech mouse model %d\n", model);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -285,6 +284,7 @@ static void ps2pp_set_model_properties(struct psmouse *psmouse,
|
||||
__set_bit(REL_HWHEEL, input_dev->relbit);
|
||||
|
||||
switch (model_info->kind) {
|
||||
|
||||
case PS2PP_KIND_WHEEL:
|
||||
psmouse->name = "Wheel Mouse";
|
||||
break;
|
||||
@ -343,7 +343,8 @@ int ps2pp_init(struct psmouse *psmouse, bool set_properties)
|
||||
if (!model || !buttons)
|
||||
return -1;
|
||||
|
||||
if ((model_info = get_model_info(model)) != NULL) {
|
||||
model_info = get_model_info(model);
|
||||
if (model_info) {
|
||||
|
||||
/*
|
||||
* Do Logitech PS2++ / PS2T++ magic init.
|
||||
@ -379,6 +380,9 @@ int ps2pp_init(struct psmouse *psmouse, bool set_properties)
|
||||
use_ps2pp = true;
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
printk(KERN_WARNING "logips2pp: Detected unknown logitech mouse model %d\n", model);
|
||||
}
|
||||
|
||||
if (set_properties) {
|
||||
|
@ -1245,7 +1245,7 @@ static int psmouse_switch_protocol(struct psmouse *psmouse,
|
||||
psmouse->pktsize = 3;
|
||||
|
||||
if (proto && (proto->detect || proto->init)) {
|
||||
if (proto->detect && proto->detect(psmouse, 1) < 0)
|
||||
if (proto->detect && proto->detect(psmouse, true) < 0)
|
||||
return -1;
|
||||
|
||||
if (proto->init && proto->init(psmouse) < 0)
|
||||
|
@ -36,6 +36,8 @@
|
||||
* The x/y limits are taken from the Synaptics TouchPad interfacing Guide,
|
||||
* section 2.3.2, which says that they should be valid regardless of the
|
||||
* actual size of the sensor.
|
||||
* Note that newer firmware allows querying device for maximum useable
|
||||
* coordinates.
|
||||
*/
|
||||
#define XMIN_NOMINAL 1472
|
||||
#define XMAX_NOMINAL 5472
|
||||
@ -194,24 +196,34 @@ static int synaptics_identify(struct psmouse *psmouse)
|
||||
}
|
||||
|
||||
/*
|
||||
* Read touchpad resolution
|
||||
* Read touchpad resolution and maximum reported coordinates
|
||||
* Resolution is left zero if touchpad does not support the query
|
||||
*/
|
||||
static int synaptics_resolution(struct psmouse *psmouse)
|
||||
{
|
||||
struct synaptics_data *priv = psmouse->private;
|
||||
unsigned char res[3];
|
||||
unsigned char max[3];
|
||||
|
||||
if (SYN_ID_MAJOR(priv->identity) < 4)
|
||||
return 0;
|
||||
|
||||
if (synaptics_send_cmd(psmouse, SYN_QUE_RESOLUTION, res))
|
||||
return 0;
|
||||
|
||||
if ((res[0] != 0) && (res[1] & 0x80) && (res[2] != 0)) {
|
||||
if (synaptics_send_cmd(psmouse, SYN_QUE_RESOLUTION, res) == 0) {
|
||||
if (res[0] != 0 && (res[1] & 0x80) && res[2] != 0) {
|
||||
priv->x_res = res[0]; /* x resolution in units/mm */
|
||||
priv->y_res = res[2]; /* y resolution in units/mm */
|
||||
}
|
||||
}
|
||||
|
||||
if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 5 &&
|
||||
SYN_CAP_MAX_DIMENSIONS(priv->ext_cap_0c)) {
|
||||
if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_DIMENSIONS, max)) {
|
||||
printk(KERN_ERR "Synaptics claims to have dimensions query,"
|
||||
" but I'm not able to read it.\n");
|
||||
} else {
|
||||
priv->x_max = (max[0] << 5) | ((max[1] & 0x0f) << 1);
|
||||
priv->y_max = (max[2] << 5) | ((max[1] & 0xf0) >> 3);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -520,6 +532,7 @@ static int synaptics_validate_byte(unsigned char packet[], int idx, unsigned cha
|
||||
return 0;
|
||||
|
||||
switch (pkt_type) {
|
||||
|
||||
case SYN_NEWABS:
|
||||
case SYN_NEWABS_RELAXED:
|
||||
return (packet[idx] & newabs_rel_mask[idx]) == newabs_rslt[idx];
|
||||
@ -578,8 +591,10 @@ static void set_input_params(struct input_dev *dev, struct synaptics_data *priv)
|
||||
int i;
|
||||
|
||||
__set_bit(EV_ABS, dev->evbit);
|
||||
input_set_abs_params(dev, ABS_X, XMIN_NOMINAL, XMAX_NOMINAL, 0, 0);
|
||||
input_set_abs_params(dev, ABS_Y, YMIN_NOMINAL, YMAX_NOMINAL, 0, 0);
|
||||
input_set_abs_params(dev, ABS_X,
|
||||
XMIN_NOMINAL, priv->x_max ?: XMAX_NOMINAL, 0, 0);
|
||||
input_set_abs_params(dev, ABS_Y,
|
||||
YMIN_NOMINAL, priv->y_max ?: YMAX_NOMINAL, 0, 0);
|
||||
input_set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0);
|
||||
__set_bit(ABS_TOOL_WIDTH, dev->absbit);
|
||||
|
||||
|
@ -19,6 +19,7 @@
|
||||
#define SYN_QUE_RESOLUTION 0x08
|
||||
#define SYN_QUE_EXT_CAPAB 0x09
|
||||
#define SYN_QUE_EXT_CAPAB_0C 0x0c
|
||||
#define SYN_QUE_EXT_DIMENSIONS 0x0d
|
||||
|
||||
/* synatics modes */
|
||||
#define SYN_BIT_ABSOLUTE_MODE (1 << 7)
|
||||
@ -51,6 +52,7 @@
|
||||
#define SYN_CAP_MULTI_BUTTON_NO(ec) (((ec) & 0x00f000) >> 12)
|
||||
#define SYN_CAP_PRODUCT_ID(ec) (((ec) & 0xff0000) >> 16)
|
||||
#define SYN_CAP_CLICKPAD(ex0c) ((ex0c) & 0x100100)
|
||||
#define SYN_CAP_MAX_DIMENSIONS(ex0c) ((ex0c) & 0x020000)
|
||||
|
||||
/* synaptics modes query bits */
|
||||
#define SYN_MODE_ABSOLUTE(m) ((m) & (1 << 7))
|
||||
@ -101,8 +103,8 @@ struct synaptics_data {
|
||||
unsigned long int ext_cap; /* Extended Capabilities */
|
||||
unsigned long int ext_cap_0c; /* Ext Caps from 0x0c query */
|
||||
unsigned long int identity; /* Identification */
|
||||
int x_res; /* X resolution in units/mm */
|
||||
int y_res; /* Y resolution in units/mm */
|
||||
unsigned int x_res, y_res; /* X/Y resolution in units/mm */
|
||||
unsigned int x_max, y_max; /* Max dimensions (from FW) */
|
||||
|
||||
unsigned char pkt_type; /* packet type - old, new, etc */
|
||||
unsigned char mode; /* current mode byte */
|
||||
|
@ -660,8 +660,21 @@ static int i8042_pnp_aux_probe(struct pnp_dev *dev, const struct pnp_device_id *
|
||||
}
|
||||
|
||||
static struct pnp_device_id pnp_kbd_devids[] = {
|
||||
{ .id = "PNP0300", .driver_data = 0 },
|
||||
{ .id = "PNP0301", .driver_data = 0 },
|
||||
{ .id = "PNP0302", .driver_data = 0 },
|
||||
{ .id = "PNP0303", .driver_data = 0 },
|
||||
{ .id = "PNP0304", .driver_data = 0 },
|
||||
{ .id = "PNP0305", .driver_data = 0 },
|
||||
{ .id = "PNP0306", .driver_data = 0 },
|
||||
{ .id = "PNP0309", .driver_data = 0 },
|
||||
{ .id = "PNP030a", .driver_data = 0 },
|
||||
{ .id = "PNP030b", .driver_data = 0 },
|
||||
{ .id = "PNP0320", .driver_data = 0 },
|
||||
{ .id = "PNP0343", .driver_data = 0 },
|
||||
{ .id = "PNP0344", .driver_data = 0 },
|
||||
{ .id = "PNP0345", .driver_data = 0 },
|
||||
{ .id = "CPQA0D7", .driver_data = 0 },
|
||||
{ .id = "", },
|
||||
};
|
||||
|
||||
@ -672,6 +685,7 @@ static struct pnp_driver i8042_pnp_kbd_driver = {
|
||||
};
|
||||
|
||||
static struct pnp_device_id pnp_aux_devids[] = {
|
||||
{ .id = "AUI0200", .driver_data = 0 },
|
||||
{ .id = "FJC6000", .driver_data = 0 },
|
||||
{ .id = "FJC6001", .driver_data = 0 },
|
||||
{ .id = "PNP0f03", .driver_data = 0 },
|
||||
|
@ -135,7 +135,7 @@ static int usb_acecad_probe(struct usb_interface *intf, const struct usb_device_
|
||||
struct usb_acecad *acecad;
|
||||
struct input_dev *input_dev;
|
||||
int pipe, maxp;
|
||||
int err = -ENOMEM;
|
||||
int err;
|
||||
|
||||
if (interface->desc.bNumEndpoints != 1)
|
||||
return -ENODEV;
|
||||
@ -193,29 +193,26 @@ static int usb_acecad_probe(struct usb_interface *intf, const struct usb_device_
|
||||
input_dev->close = usb_acecad_close;
|
||||
|
||||
input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
|
||||
input_dev->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
|
||||
BIT_MASK(ABS_PRESSURE);
|
||||
input_dev->keybit[BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) |
|
||||
BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
|
||||
input_dev->keybit[BIT_WORD(BTN_DIGI)] = BIT_MASK(BTN_TOOL_PEN) |
|
||||
BIT_MASK(BTN_TOUCH) | BIT_MASK(BTN_STYLUS) |
|
||||
BIT_MASK(BTN_STYLUS2);
|
||||
|
||||
switch (id->driver_info) {
|
||||
case 0:
|
||||
input_dev->absmax[ABS_X] = 5000;
|
||||
input_dev->absmax[ABS_Y] = 3750;
|
||||
input_dev->absmax[ABS_PRESSURE] = 512;
|
||||
input_set_abs_params(input_dev, ABS_X, 0, 5000, 4, 0);
|
||||
input_set_abs_params(input_dev, ABS_Y, 0, 3750, 4, 0);
|
||||
input_set_abs_params(input_dev, ABS_PRESSURE, 0, 512, 0, 0);
|
||||
if (!strlen(acecad->name))
|
||||
snprintf(acecad->name, sizeof(acecad->name),
|
||||
"USB Acecad Flair Tablet %04x:%04x",
|
||||
le16_to_cpu(dev->descriptor.idVendor),
|
||||
le16_to_cpu(dev->descriptor.idProduct));
|
||||
break;
|
||||
|
||||
case 1:
|
||||
input_dev->absmax[ABS_X] = 3000;
|
||||
input_dev->absmax[ABS_Y] = 2250;
|
||||
input_dev->absmax[ABS_PRESSURE] = 1024;
|
||||
input_set_abs_params(input_dev, ABS_X, 0, 53000, 4, 0);
|
||||
input_set_abs_params(input_dev, ABS_Y, 0, 2250, 4, 0);
|
||||
input_set_abs_params(input_dev, ABS_PRESSURE, 0, 1024, 0, 0);
|
||||
if (!strlen(acecad->name))
|
||||
snprintf(acecad->name, sizeof(acecad->name),
|
||||
"USB Acecad 302 Tablet %04x:%04x",
|
||||
@ -224,9 +221,6 @@ static int usb_acecad_probe(struct usb_interface *intf, const struct usb_device_
|
||||
break;
|
||||
}
|
||||
|
||||
input_dev->absfuzz[ABS_X] = 4;
|
||||
input_dev->absfuzz[ABS_Y] = 4;
|
||||
|
||||
usb_fill_int_urb(acecad->irq, dev, pipe,
|
||||
acecad->data, maxp > 8 ? 8 : maxp,
|
||||
usb_acecad_irq, acecad, endpoint->bInterval);
|
||||
@ -252,14 +246,12 @@ static void usb_acecad_disconnect(struct usb_interface *intf)
|
||||
struct usb_acecad *acecad = usb_get_intfdata(intf);
|
||||
|
||||
usb_set_intfdata(intf, NULL);
|
||||
if (acecad) {
|
||||
usb_kill_urb(acecad->irq);
|
||||
|
||||
input_unregister_device(acecad->input);
|
||||
usb_free_urb(acecad->irq);
|
||||
usb_buffer_free(interface_to_usbdev(intf), 10, acecad->data, acecad->data_dma);
|
||||
usb_buffer_free(acecad->usbdev, 8, acecad->data, acecad->data_dma);
|
||||
kfree(acecad);
|
||||
}
|
||||
}
|
||||
|
||||
static struct usb_device_id usb_acecad_id_table [] = {
|
||||
{ USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_FLAIR), .driver_info = 0 },
|
||||
|
@ -34,10 +34,6 @@ struct kbtab {
|
||||
struct input_dev *dev;
|
||||
struct usb_device *usbdev;
|
||||
struct urb *irq;
|
||||
int x, y;
|
||||
int button;
|
||||
int pressure;
|
||||
__u32 serial[2];
|
||||
char phys[32];
|
||||
};
|
||||
|
||||
@ -46,6 +42,7 @@ static void kbtab_irq(struct urb *urb)
|
||||
struct kbtab *kbtab = urb->context;
|
||||
unsigned char *data = kbtab->data;
|
||||
struct input_dev *dev = kbtab->dev;
|
||||
int pressure;
|
||||
int retval;
|
||||
|
||||
switch (urb->status) {
|
||||
@ -63,24 +60,20 @@ static void kbtab_irq(struct urb *urb)
|
||||
goto exit;
|
||||
}
|
||||
|
||||
kbtab->x = get_unaligned_le16(&data[1]);
|
||||
kbtab->y = get_unaligned_le16(&data[3]);
|
||||
|
||||
kbtab->pressure = (data[5]);
|
||||
|
||||
input_report_key(dev, BTN_TOOL_PEN, 1);
|
||||
|
||||
input_report_abs(dev, ABS_X, kbtab->x);
|
||||
input_report_abs(dev, ABS_Y, kbtab->y);
|
||||
input_report_abs(dev, ABS_X, get_unaligned_le16(&data[1]));
|
||||
input_report_abs(dev, ABS_Y, get_unaligned_le16(&data[3]));
|
||||
|
||||
/*input_report_key(dev, BTN_TOUCH , data[0] & 0x01);*/
|
||||
input_report_key(dev, BTN_RIGHT, data[0] & 0x02);
|
||||
|
||||
if (-1 == kb_pressure_click) {
|
||||
input_report_abs(dev, ABS_PRESSURE, kbtab->pressure);
|
||||
} else {
|
||||
input_report_key(dev, BTN_LEFT, (kbtab->pressure > kb_pressure_click) ? 1 : 0);
|
||||
};
|
||||
pressure = data[5];
|
||||
if (kb_pressure_click == -1)
|
||||
input_report_abs(dev, ABS_PRESSURE, pressure);
|
||||
else
|
||||
input_report_key(dev, BTN_LEFT, pressure > kb_pressure_click ? 1 : 0);
|
||||
|
||||
input_sync(dev);
|
||||
|
||||
@ -153,13 +146,11 @@ static int kbtab_probe(struct usb_interface *intf, const struct usb_device_id *i
|
||||
input_dev->open = kbtab_open;
|
||||
input_dev->close = kbtab_close;
|
||||
|
||||
input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
|
||||
BIT_MASK(EV_MSC);
|
||||
input_dev->keybit[BIT_WORD(BTN_LEFT)] |= BIT_MASK(BTN_LEFT) |
|
||||
BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
|
||||
input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_PEN) |
|
||||
BIT_MASK(BTN_TOUCH);
|
||||
input_dev->mscbit[0] |= BIT_MASK(MSC_SERIAL);
|
||||
input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
|
||||
input_dev->keybit[BIT_WORD(BTN_LEFT)] |=
|
||||
BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_RIGHT);
|
||||
input_dev->keybit[BIT_WORD(BTN_DIGI)] |=
|
||||
BIT_MASK(BTN_TOOL_PEN) | BIT_MASK(BTN_TOUCH);
|
||||
input_set_abs_params(input_dev, ABS_X, 0, 0x2000, 4, 0);
|
||||
input_set_abs_params(input_dev, ABS_Y, 0, 0x1750, 4, 0);
|
||||
input_set_abs_params(input_dev, ABS_PRESSURE, 0, 0xff, 0, 0);
|
||||
@ -182,7 +173,7 @@ static int kbtab_probe(struct usb_interface *intf, const struct usb_device_id *i
|
||||
return 0;
|
||||
|
||||
fail3: usb_free_urb(kbtab->irq);
|
||||
fail2: usb_buffer_free(dev, 10, kbtab->data, kbtab->data_dma);
|
||||
fail2: usb_buffer_free(dev, 8, kbtab->data, kbtab->data_dma);
|
||||
fail1: input_free_device(input_dev);
|
||||
kfree(kbtab);
|
||||
return error;
|
||||
@ -193,14 +184,12 @@ static void kbtab_disconnect(struct usb_interface *intf)
|
||||
struct kbtab *kbtab = usb_get_intfdata(intf);
|
||||
|
||||
usb_set_intfdata(intf, NULL);
|
||||
if (kbtab) {
|
||||
usb_kill_urb(kbtab->irq);
|
||||
|
||||
input_unregister_device(kbtab->dev);
|
||||
usb_free_urb(kbtab->irq);
|
||||
usb_buffer_free(interface_to_usbdev(intf), 10, kbtab->data, kbtab->data_dma);
|
||||
usb_buffer_free(kbtab->usbdev, 8, kbtab->data, kbtab->data_dma);
|
||||
kfree(kbtab);
|
||||
}
|
||||
}
|
||||
|
||||
static struct usb_driver kbtab_driver = {
|
||||
.name = "kbtab",
|
||||
|
@ -106,44 +106,18 @@ MODULE_LICENSE(DRIVER_LICENSE);
|
||||
|
||||
struct wacom {
|
||||
dma_addr_t data_dma;
|
||||
struct input_dev *dev;
|
||||
struct usb_device *usbdev;
|
||||
struct usb_interface *intf;
|
||||
struct urb *irq;
|
||||
struct wacom_wac *wacom_wac;
|
||||
struct wacom_wac wacom_wac;
|
||||
struct mutex lock;
|
||||
unsigned int open:1;
|
||||
bool open;
|
||||
char phys[32];
|
||||
};
|
||||
|
||||
struct wacom_combo {
|
||||
struct wacom *wacom;
|
||||
struct urb *urb;
|
||||
};
|
||||
|
||||
extern const struct usb_device_id wacom_ids[];
|
||||
|
||||
extern int wacom_wac_irq(struct wacom_wac * wacom_wac, void * wcombo);
|
||||
extern void wacom_report_abs(void *wcombo, unsigned int abs_type, int abs_data);
|
||||
extern void wacom_report_rel(void *wcombo, unsigned int rel_type, int rel_data);
|
||||
extern void wacom_report_key(void *wcombo, unsigned int key_type, int key_data);
|
||||
extern void wacom_input_event(void *wcombo, unsigned int type, unsigned int code, int value);
|
||||
extern void wacom_input_sync(void *wcombo);
|
||||
extern void wacom_init_input_dev(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
|
||||
extern void input_dev_g4(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
|
||||
extern void input_dev_g(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
|
||||
extern void input_dev_i3s(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
|
||||
extern void input_dev_i3(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
|
||||
extern void input_dev_i(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
|
||||
extern void input_dev_i4s(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
|
||||
extern void input_dev_i4(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
|
||||
extern void input_dev_pl(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
|
||||
extern void input_dev_pt(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
|
||||
extern void input_dev_tpc(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
|
||||
extern void input_dev_tpc2fg(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
|
||||
extern void input_dev_mo(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
|
||||
extern void input_dev_bee(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
|
||||
extern __u16 wacom_le16_to_cpu(unsigned char *data);
|
||||
extern __u16 wacom_be16_to_cpu(unsigned char *data);
|
||||
|
||||
void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len);
|
||||
void wacom_setup_input_capabilities(struct input_dev *input_dev,
|
||||
struct wacom_wac *wacom_wac);
|
||||
#endif
|
||||
|
@ -11,8 +11,8 @@
|
||||
* (at your option) any later version.
|
||||
*/
|
||||
|
||||
#include "wacom.h"
|
||||
#include "wacom_wac.h"
|
||||
#include "wacom.h"
|
||||
|
||||
/* defines to get HID report descriptor */
|
||||
#define HID_DEVICET_HID (USB_TYPE_CLASS | 0x01)
|
||||
@ -70,15 +70,9 @@ static int usb_set_report(struct usb_interface *intf, unsigned char type,
|
||||
buf, size, 1000);
|
||||
}
|
||||
|
||||
static struct input_dev * get_input_dev(struct wacom_combo *wcombo)
|
||||
{
|
||||
return wcombo->wacom->dev;
|
||||
}
|
||||
|
||||
static void wacom_sys_irq(struct urb *urb)
|
||||
{
|
||||
struct wacom *wacom = urb->context;
|
||||
struct wacom_combo wcombo;
|
||||
int retval;
|
||||
|
||||
switch (urb->status) {
|
||||
@ -96,11 +90,7 @@ static void wacom_sys_irq(struct urb *urb)
|
||||
goto exit;
|
||||
}
|
||||
|
||||
wcombo.wacom = wacom;
|
||||
wcombo.urb = urb;
|
||||
|
||||
if (wacom_wac_irq(wacom->wacom_wac, (void *)&wcombo))
|
||||
input_sync(get_input_dev(&wcombo));
|
||||
wacom_wac_irq(&wacom->wacom_wac, urb->actual_length);
|
||||
|
||||
exit:
|
||||
usb_mark_last_busy(wacom->usbdev);
|
||||
@ -110,45 +100,6 @@ static void wacom_sys_irq(struct urb *urb)
|
||||
__func__, retval);
|
||||
}
|
||||
|
||||
void wacom_report_key(void *wcombo, unsigned int key_type, int key_data)
|
||||
{
|
||||
input_report_key(get_input_dev((struct wacom_combo *)wcombo), key_type, key_data);
|
||||
}
|
||||
|
||||
void wacom_report_abs(void *wcombo, unsigned int abs_type, int abs_data)
|
||||
{
|
||||
input_report_abs(get_input_dev((struct wacom_combo *)wcombo), abs_type, abs_data);
|
||||
}
|
||||
|
||||
void wacom_report_rel(void *wcombo, unsigned int rel_type, int rel_data)
|
||||
{
|
||||
input_report_rel(get_input_dev((struct wacom_combo *)wcombo), rel_type, rel_data);
|
||||
}
|
||||
|
||||
void wacom_input_event(void *wcombo, unsigned int type, unsigned int code, int value)
|
||||
{
|
||||
input_event(get_input_dev((struct wacom_combo *)wcombo), type, code, value);
|
||||
}
|
||||
|
||||
__u16 wacom_be16_to_cpu(unsigned char *data)
|
||||
{
|
||||
__u16 value;
|
||||
value = be16_to_cpu(*(__be16 *) data);
|
||||
return value;
|
||||
}
|
||||
|
||||
__u16 wacom_le16_to_cpu(unsigned char *data)
|
||||
{
|
||||
__u16 value;
|
||||
value = le16_to_cpu(*(__le16 *) data);
|
||||
return value;
|
||||
}
|
||||
|
||||
void wacom_input_sync(void *wcombo)
|
||||
{
|
||||
input_sync(get_input_dev((struct wacom_combo *)wcombo));
|
||||
}
|
||||
|
||||
static int wacom_open(struct input_dev *dev)
|
||||
{
|
||||
struct wacom *wacom = input_get_drvdata(dev);
|
||||
@ -168,7 +119,7 @@ static int wacom_open(struct input_dev *dev)
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
wacom->open = 1;
|
||||
wacom->open = true;
|
||||
wacom->intf->needs_remote_wakeup = 1;
|
||||
|
||||
mutex_unlock(&wacom->lock);
|
||||
@ -181,128 +132,11 @@ static void wacom_close(struct input_dev *dev)
|
||||
|
||||
mutex_lock(&wacom->lock);
|
||||
usb_kill_urb(wacom->irq);
|
||||
wacom->open = 0;
|
||||
wacom->open = false;
|
||||
wacom->intf->needs_remote_wakeup = 0;
|
||||
mutex_unlock(&wacom->lock);
|
||||
}
|
||||
|
||||
void input_dev_mo(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
|
||||
{
|
||||
input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_1) |
|
||||
BIT_MASK(BTN_5);
|
||||
input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
|
||||
}
|
||||
|
||||
void input_dev_g4(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
|
||||
{
|
||||
input_dev->evbit[0] |= BIT_MASK(EV_MSC);
|
||||
input_dev->mscbit[0] |= BIT_MASK(MSC_SERIAL);
|
||||
input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_FINGER);
|
||||
input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_0) |
|
||||
BIT_MASK(BTN_4);
|
||||
}
|
||||
|
||||
void input_dev_g(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
|
||||
{
|
||||
input_dev->evbit[0] |= BIT_MASK(EV_REL);
|
||||
input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);
|
||||
input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_LEFT) |
|
||||
BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
|
||||
input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_RUBBER) |
|
||||
BIT_MASK(BTN_TOOL_PEN) | BIT_MASK(BTN_STYLUS) |
|
||||
BIT_MASK(BTN_TOOL_MOUSE) | BIT_MASK(BTN_STYLUS2);
|
||||
input_set_abs_params(input_dev, ABS_DISTANCE,
|
||||
0, wacom_wac->features.distance_max, 0, 0);
|
||||
}
|
||||
|
||||
void input_dev_i3s(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
|
||||
{
|
||||
input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_FINGER);
|
||||
input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_0) |
|
||||
BIT_MASK(BTN_1) | BIT_MASK(BTN_2) | BIT_MASK(BTN_3);
|
||||
input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
|
||||
input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
|
||||
}
|
||||
|
||||
void input_dev_i3(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
|
||||
{
|
||||
input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_4) |
|
||||
BIT_MASK(BTN_5) | BIT_MASK(BTN_6) | BIT_MASK(BTN_7);
|
||||
input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
|
||||
}
|
||||
|
||||
void input_dev_i4s(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
|
||||
{
|
||||
input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_FINGER);
|
||||
input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_0) | BIT_MASK(BTN_1) | BIT_MASK(BTN_2) | BIT_MASK(BTN_3);
|
||||
input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_4) | BIT_MASK(BTN_5) | BIT_MASK(BTN_6);
|
||||
input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
|
||||
}
|
||||
|
||||
void input_dev_i4(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
|
||||
{
|
||||
input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_7) | BIT_MASK(BTN_8);
|
||||
}
|
||||
|
||||
void input_dev_bee(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
|
||||
{
|
||||
input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_8) | BIT_MASK(BTN_9);
|
||||
}
|
||||
|
||||
void input_dev_i(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
|
||||
{
|
||||
input_dev->evbit[0] |= BIT_MASK(EV_MSC) | BIT_MASK(EV_REL);
|
||||
input_dev->mscbit[0] |= BIT_MASK(MSC_SERIAL);
|
||||
input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);
|
||||
input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_LEFT) |
|
||||
BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE) |
|
||||
BIT_MASK(BTN_SIDE) | BIT_MASK(BTN_EXTRA);
|
||||
input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_RUBBER) |
|
||||
BIT_MASK(BTN_TOOL_PEN) | BIT_MASK(BTN_STYLUS) |
|
||||
BIT_MASK(BTN_TOOL_MOUSE) | BIT_MASK(BTN_TOOL_BRUSH) |
|
||||
BIT_MASK(BTN_TOOL_PENCIL) | BIT_MASK(BTN_TOOL_AIRBRUSH) |
|
||||
BIT_MASK(BTN_TOOL_LENS) | BIT_MASK(BTN_STYLUS2);
|
||||
input_set_abs_params(input_dev, ABS_DISTANCE,
|
||||
0, wacom_wac->features.distance_max, 0, 0);
|
||||
input_set_abs_params(input_dev, ABS_WHEEL, 0, 1023, 0, 0);
|
||||
input_set_abs_params(input_dev, ABS_TILT_X, 0, 127, 0, 0);
|
||||
input_set_abs_params(input_dev, ABS_TILT_Y, 0, 127, 0, 0);
|
||||
input_set_abs_params(input_dev, ABS_RZ, -900, 899, 0, 0);
|
||||
input_set_abs_params(input_dev, ABS_THROTTLE, -1023, 1023, 0, 0);
|
||||
}
|
||||
|
||||
void input_dev_pl(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
|
||||
{
|
||||
input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_PEN) |
|
||||
BIT_MASK(BTN_STYLUS) | BIT_MASK(BTN_STYLUS2);
|
||||
}
|
||||
|
||||
void input_dev_pt(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
|
||||
{
|
||||
input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_RUBBER);
|
||||
}
|
||||
|
||||
void input_dev_tpc(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
|
||||
{
|
||||
struct wacom_features *features = &wacom_wac->features;
|
||||
|
||||
if (features->device_type == BTN_TOOL_DOUBLETAP ||
|
||||
features->device_type == BTN_TOOL_TRIPLETAP) {
|
||||
input_set_abs_params(input_dev, ABS_RX, 0, features->x_phy, 0, 0);
|
||||
input_set_abs_params(input_dev, ABS_RY, 0, features->y_phy, 0, 0);
|
||||
__set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
|
||||
}
|
||||
}
|
||||
|
||||
void input_dev_tpc2fg(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
|
||||
{
|
||||
if (wacom_wac->features.device_type == BTN_TOOL_TRIPLETAP) {
|
||||
input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_TRIPLETAP);
|
||||
input_dev->evbit[0] |= BIT_MASK(EV_MSC);
|
||||
input_dev->mscbit[0] |= BIT_MASK(MSC_SERIAL);
|
||||
}
|
||||
}
|
||||
|
||||
static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hid_desc,
|
||||
struct wacom_features *features)
|
||||
{
|
||||
@ -362,9 +196,9 @@ static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hi
|
||||
features->device_type = BTN_TOOL_TRIPLETAP;
|
||||
}
|
||||
features->x_max =
|
||||
wacom_le16_to_cpu(&report[i + 3]);
|
||||
get_unaligned_le16(&report[i + 3]);
|
||||
features->x_phy =
|
||||
wacom_le16_to_cpu(&report[i + 6]);
|
||||
get_unaligned_le16(&report[i + 6]);
|
||||
features->unit = report[i + 9];
|
||||
features->unitExpo = report[i + 11];
|
||||
i += 12;
|
||||
@ -374,7 +208,7 @@ static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hi
|
||||
features->pktlen = WACOM_PKGLEN_GRAPHIRE;
|
||||
features->device_type = BTN_TOOL_PEN;
|
||||
features->x_max =
|
||||
wacom_le16_to_cpu(&report[i + 3]);
|
||||
get_unaligned_le16(&report[i + 3]);
|
||||
i += 4;
|
||||
}
|
||||
} else if (usage == WCM_DIGITIZER) {
|
||||
@ -396,15 +230,15 @@ static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hi
|
||||
features->pktlen = WACOM_PKGLEN_TPC2FG;
|
||||
features->device_type = BTN_TOOL_TRIPLETAP;
|
||||
features->y_max =
|
||||
wacom_le16_to_cpu(&report[i + 3]);
|
||||
get_unaligned_le16(&report[i + 3]);
|
||||
features->y_phy =
|
||||
wacom_le16_to_cpu(&report[i + 6]);
|
||||
get_unaligned_le16(&report[i + 6]);
|
||||
i += 7;
|
||||
} else {
|
||||
features->y_max =
|
||||
features->x_max;
|
||||
features->y_phy =
|
||||
wacom_le16_to_cpu(&report[i + 3]);
|
||||
get_unaligned_le16(&report[i + 3]);
|
||||
i += 4;
|
||||
}
|
||||
} else if (pen) {
|
||||
@ -413,7 +247,7 @@ static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hi
|
||||
features->pktlen = WACOM_PKGLEN_GRAPHIRE;
|
||||
features->device_type = BTN_TOOL_PEN;
|
||||
features->y_max =
|
||||
wacom_le16_to_cpu(&report[i + 3]);
|
||||
get_unaligned_le16(&report[i + 3]);
|
||||
i += 4;
|
||||
}
|
||||
}
|
||||
@ -432,7 +266,7 @@ static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hi
|
||||
case HID_USAGE_UNDEFINED:
|
||||
if (usage == WCM_DESKTOP && finger) /* capacity */
|
||||
features->pressure_max =
|
||||
wacom_le16_to_cpu(&report[i + 3]);
|
||||
get_unaligned_le16(&report[i + 3]);
|
||||
i += 4;
|
||||
break;
|
||||
}
|
||||
@ -528,6 +362,81 @@ static int wacom_retrieve_hid_descriptor(struct usb_interface *intf,
|
||||
return error;
|
||||
}
|
||||
|
||||
struct wacom_usbdev_data {
|
||||
struct list_head list;
|
||||
struct kref kref;
|
||||
struct usb_device *dev;
|
||||
struct wacom_shared shared;
|
||||
};
|
||||
|
||||
static LIST_HEAD(wacom_udev_list);
|
||||
static DEFINE_MUTEX(wacom_udev_list_lock);
|
||||
|
||||
static struct wacom_usbdev_data *wacom_get_usbdev_data(struct usb_device *dev)
|
||||
{
|
||||
struct wacom_usbdev_data *data;
|
||||
|
||||
list_for_each_entry(data, &wacom_udev_list, list) {
|
||||
if (data->dev == dev) {
|
||||
kref_get(&data->kref);
|
||||
return data;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int wacom_add_shared_data(struct wacom_wac *wacom,
|
||||
struct usb_device *dev)
|
||||
{
|
||||
struct wacom_usbdev_data *data;
|
||||
int retval = 0;
|
||||
|
||||
mutex_lock(&wacom_udev_list_lock);
|
||||
|
||||
data = wacom_get_usbdev_data(dev);
|
||||
if (!data) {
|
||||
data = kzalloc(sizeof(struct wacom_usbdev_data), GFP_KERNEL);
|
||||
if (!data) {
|
||||
retval = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
|
||||
kref_init(&data->kref);
|
||||
data->dev = dev;
|
||||
list_add_tail(&data->list, &wacom_udev_list);
|
||||
}
|
||||
|
||||
wacom->shared = &data->shared;
|
||||
|
||||
out:
|
||||
mutex_unlock(&wacom_udev_list_lock);
|
||||
return retval;
|
||||
}
|
||||
|
||||
static void wacom_release_shared_data(struct kref *kref)
|
||||
{
|
||||
struct wacom_usbdev_data *data =
|
||||
container_of(kref, struct wacom_usbdev_data, kref);
|
||||
|
||||
mutex_lock(&wacom_udev_list_lock);
|
||||
list_del(&data->list);
|
||||
mutex_unlock(&wacom_udev_list_lock);
|
||||
|
||||
kfree(data);
|
||||
}
|
||||
|
||||
static void wacom_remove_shared_data(struct wacom_wac *wacom)
|
||||
{
|
||||
struct wacom_usbdev_data *data;
|
||||
|
||||
if (wacom->shared) {
|
||||
data = container_of(wacom->shared, struct wacom_usbdev_data, shared);
|
||||
kref_put(&data->kref, wacom_release_shared_data);
|
||||
wacom->shared = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *id)
|
||||
{
|
||||
struct usb_device *dev = interface_to_usbdev(intf);
|
||||
@ -542,13 +451,13 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
|
||||
return -EINVAL;
|
||||
|
||||
wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL);
|
||||
wacom_wac = kzalloc(sizeof(struct wacom_wac), GFP_KERNEL);
|
||||
input_dev = input_allocate_device();
|
||||
if (!wacom || !input_dev || !wacom_wac) {
|
||||
if (!wacom || !input_dev) {
|
||||
error = -ENOMEM;
|
||||
goto fail1;
|
||||
}
|
||||
|
||||
wacom_wac = &wacom->wacom_wac;
|
||||
wacom_wac->features = *((struct wacom_features *)id->driver_info);
|
||||
features = &wacom_wac->features;
|
||||
if (features->pktlen > WACOM_PKGLEN_MAX) {
|
||||
@ -570,20 +479,12 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
|
||||
}
|
||||
|
||||
wacom->usbdev = dev;
|
||||
wacom->dev = input_dev;
|
||||
wacom->intf = intf;
|
||||
mutex_init(&wacom->lock);
|
||||
usb_make_path(dev, wacom->phys, sizeof(wacom->phys));
|
||||
strlcat(wacom->phys, "/input0", sizeof(wacom->phys));
|
||||
|
||||
usb_to_input_id(dev, &input_dev->id);
|
||||
|
||||
input_dev->dev.parent = &intf->dev;
|
||||
|
||||
input_set_drvdata(input_dev, wacom);
|
||||
|
||||
input_dev->open = wacom_open;
|
||||
input_dev->close = wacom_close;
|
||||
wacom_wac->input = input_dev;
|
||||
|
||||
endpoint = &intf->cur_altsetting->endpoint[0].desc;
|
||||
|
||||
@ -600,20 +501,21 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
|
||||
features->device_type == BTN_TOOL_PEN ?
|
||||
" Pen" : " Finger",
|
||||
sizeof(wacom_wac->name));
|
||||
|
||||
error = wacom_add_shared_data(wacom_wac, dev);
|
||||
if (error)
|
||||
goto fail3;
|
||||
}
|
||||
|
||||
input_dev->name = wacom_wac->name;
|
||||
wacom->wacom_wac = wacom_wac;
|
||||
input_dev->name = wacom_wac->name;
|
||||
input_dev->dev.parent = &intf->dev;
|
||||
input_dev->open = wacom_open;
|
||||
input_dev->close = wacom_close;
|
||||
usb_to_input_id(dev, &input_dev->id);
|
||||
input_set_drvdata(input_dev, wacom);
|
||||
|
||||
input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
|
||||
input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOUCH);
|
||||
|
||||
input_set_abs_params(input_dev, ABS_X, 0, features->x_max, 4, 0);
|
||||
input_set_abs_params(input_dev, ABS_Y, 0, features->y_max, 4, 0);
|
||||
input_set_abs_params(input_dev, ABS_PRESSURE, 0, features->pressure_max, 0, 0);
|
||||
input_dev->absbit[BIT_WORD(ABS_MISC)] |= BIT_MASK(ABS_MISC);
|
||||
|
||||
wacom_init_input_dev(input_dev, wacom_wac);
|
||||
wacom_setup_input_capabilities(input_dev, wacom_wac);
|
||||
|
||||
usb_fill_int_urb(wacom->irq, dev,
|
||||
usb_rcvintpipe(dev, endpoint->bEndpointAddress),
|
||||
@ -622,9 +524,9 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
|
||||
wacom->irq->transfer_dma = wacom->data_dma;
|
||||
wacom->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
|
||||
|
||||
error = input_register_device(wacom->dev);
|
||||
error = input_register_device(input_dev);
|
||||
if (error)
|
||||
goto fail3;
|
||||
goto fail4;
|
||||
|
||||
/* Note that if query fails it is not a hard failure */
|
||||
wacom_query_tablet_data(intf, features);
|
||||
@ -632,11 +534,11 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
|
||||
usb_set_intfdata(intf, wacom);
|
||||
return 0;
|
||||
|
||||
fail4: wacom_remove_shared_data(wacom_wac);
|
||||
fail3: usb_free_urb(wacom->irq);
|
||||
fail2: usb_buffer_free(dev, WACOM_PKGLEN_MAX, wacom_wac->data, wacom->data_dma);
|
||||
fail1: input_free_device(input_dev);
|
||||
kfree(wacom);
|
||||
kfree(wacom_wac);
|
||||
return error;
|
||||
}
|
||||
|
||||
@ -647,11 +549,11 @@ static void wacom_disconnect(struct usb_interface *intf)
|
||||
usb_set_intfdata(intf, NULL);
|
||||
|
||||
usb_kill_urb(wacom->irq);
|
||||
input_unregister_device(wacom->dev);
|
||||
input_unregister_device(wacom->wacom_wac.input);
|
||||
usb_free_urb(wacom->irq);
|
||||
usb_buffer_free(interface_to_usbdev(intf), WACOM_PKGLEN_MAX,
|
||||
wacom->wacom_wac->data, wacom->data_dma);
|
||||
kfree(wacom->wacom_wac);
|
||||
wacom->wacom_wac.data, wacom->data_dma);
|
||||
wacom_remove_shared_data(&wacom->wacom_wac);
|
||||
kfree(wacom);
|
||||
}
|
||||
|
||||
@ -669,7 +571,7 @@ static int wacom_suspend(struct usb_interface *intf, pm_message_t message)
|
||||
static int wacom_resume(struct usb_interface *intf)
|
||||
{
|
||||
struct wacom *wacom = usb_get_intfdata(intf);
|
||||
struct wacom_features *features = &wacom->wacom_wac->features;
|
||||
struct wacom_features *features = &wacom->wacom_wac.features;
|
||||
int rv;
|
||||
|
||||
mutex_lock(&wacom->lock);
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -9,6 +9,8 @@
|
||||
#ifndef WACOM_WAC_H
|
||||
#define WACOM_WAC_H
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
/* maximum packet length for USB devices */
|
||||
#define WACOM_PKGLEN_MAX 32
|
||||
|
||||
@ -71,13 +73,20 @@ struct wacom_features {
|
||||
unsigned char unitExpo;
|
||||
};
|
||||
|
||||
struct wacom_shared {
|
||||
bool stylus_in_proximity;
|
||||
};
|
||||
|
||||
struct wacom_wac {
|
||||
char name[64];
|
||||
unsigned char *data;
|
||||
int tool[2];
|
||||
int id[2];
|
||||
int tool[3];
|
||||
int id[3];
|
||||
__u32 serial[2];
|
||||
int last_finger;
|
||||
struct wacom_features features;
|
||||
struct wacom_shared *shared;
|
||||
struct input_dev *input;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
@ -119,6 +119,18 @@ config TOUCHSCREEN_DYNAPRO
|
||||
To compile this driver as a module, choose M here: the
|
||||
module will be called dynapro.
|
||||
|
||||
config TOUCHSCREEN_HAMPSHIRE
|
||||
tristate "Hampshire serial touchscreen"
|
||||
select SERIO
|
||||
help
|
||||
Say Y here if you have a Hampshire serial touchscreen connected to
|
||||
your system.
|
||||
|
||||
If unsure, say N.
|
||||
|
||||
To compile this driver as a module, choose M here: the
|
||||
module will be called hampshire.
|
||||
|
||||
config TOUCHSCREEN_EETI
|
||||
tristate "EETI touchscreen panel support"
|
||||
depends on I2C
|
||||
|
@ -13,6 +13,7 @@ obj-$(CONFIG_TOUCHSCREEN_ADS7846) += ads7846.o
|
||||
obj-$(CONFIG_TOUCHSCREEN_ATMEL_TSADCC) += atmel_tsadcc.o
|
||||
obj-$(CONFIG_TOUCHSCREEN_BITSY) += h3600_ts_input.o
|
||||
obj-$(CONFIG_TOUCHSCREEN_DYNAPRO) += dynapro.o
|
||||
obj-$(CONFIG_TOUCHSCREEN_HAMPSHIRE) += hampshire.o
|
||||
obj-$(CONFIG_TOUCHSCREEN_GUNZE) += gunze.o
|
||||
obj-$(CONFIG_TOUCHSCREEN_EETI) += eeti_ts.o
|
||||
obj-$(CONFIG_TOUCHSCREEN_ELO) += elo.o
|
||||
|
205
drivers/input/touchscreen/hampshire.c
Normal file
205
drivers/input/touchscreen/hampshire.c
Normal file
@ -0,0 +1,205 @@
|
||||
/*
|
||||
* Hampshire serial touchscreen driver
|
||||
*
|
||||
* Copyright (c) 2010 Adam Bennett
|
||||
* Based on the dynapro driver (c) Tias Guns
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 as published by
|
||||
* the Free Software Foundation.
|
||||
*/
|
||||
|
||||
/*
|
||||
* 2010/04/08 Adam Bennett <abennett72@gmail.com>
|
||||
* Copied dynapro.c and edited for Hampshire 4-byte protocol
|
||||
*/
|
||||
|
||||
#include <linux/errno.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/input.h>
|
||||
#include <linux/serio.h>
|
||||
#include <linux/init.h>
|
||||
|
||||
#define DRIVER_DESC "Hampshire serial touchscreen driver"
|
||||
|
||||
MODULE_AUTHOR("Adam Bennett <abennett72@gmail.com>");
|
||||
MODULE_DESCRIPTION(DRIVER_DESC);
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
/*
|
||||
* Definitions & global arrays.
|
||||
*/
|
||||
|
||||
#define HAMPSHIRE_FORMAT_TOUCH_BIT 0x40
|
||||
#define HAMPSHIRE_FORMAT_LENGTH 4
|
||||
#define HAMPSHIRE_RESPONSE_BEGIN_BYTE 0x80
|
||||
|
||||
#define HAMPSHIRE_MIN_XC 0
|
||||
#define HAMPSHIRE_MAX_XC 0x1000
|
||||
#define HAMPSHIRE_MIN_YC 0
|
||||
#define HAMPSHIRE_MAX_YC 0x1000
|
||||
|
||||
#define HAMPSHIRE_GET_XC(data) (((data[3] & 0x0c) >> 2) | (data[1] << 2) | ((data[0] & 0x38) << 6))
|
||||
#define HAMPSHIRE_GET_YC(data) ((data[3] & 0x03) | (data[2] << 2) | ((data[0] & 0x07) << 9))
|
||||
#define HAMPSHIRE_GET_TOUCHED(data) (HAMPSHIRE_FORMAT_TOUCH_BIT & data[0])
|
||||
|
||||
/*
|
||||
* Per-touchscreen data.
|
||||
*/
|
||||
|
||||
struct hampshire {
|
||||
struct input_dev *dev;
|
||||
struct serio *serio;
|
||||
int idx;
|
||||
unsigned char data[HAMPSHIRE_FORMAT_LENGTH];
|
||||
char phys[32];
|
||||
};
|
||||
|
||||
static void hampshire_process_data(struct hampshire *phampshire)
|
||||
{
|
||||
struct input_dev *dev = phampshire->dev;
|
||||
|
||||
if (HAMPSHIRE_FORMAT_LENGTH == ++phampshire->idx) {
|
||||
input_report_abs(dev, ABS_X, HAMPSHIRE_GET_XC(phampshire->data));
|
||||
input_report_abs(dev, ABS_Y, HAMPSHIRE_GET_YC(phampshire->data));
|
||||
input_report_key(dev, BTN_TOUCH,
|
||||
HAMPSHIRE_GET_TOUCHED(phampshire->data));
|
||||
input_sync(dev);
|
||||
|
||||
phampshire->idx = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static irqreturn_t hampshire_interrupt(struct serio *serio,
|
||||
unsigned char data, unsigned int flags)
|
||||
{
|
||||
struct hampshire *phampshire = serio_get_drvdata(serio);
|
||||
|
||||
phampshire->data[phampshire->idx] = data;
|
||||
|
||||
if (HAMPSHIRE_RESPONSE_BEGIN_BYTE & phampshire->data[0])
|
||||
hampshire_process_data(phampshire);
|
||||
else
|
||||
dev_dbg(&serio->dev, "unknown/unsynchronized data: %x\n",
|
||||
phampshire->data[0]);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static void hampshire_disconnect(struct serio *serio)
|
||||
{
|
||||
struct hampshire *phampshire = serio_get_drvdata(serio);
|
||||
|
||||
input_get_device(phampshire->dev);
|
||||
input_unregister_device(phampshire->dev);
|
||||
serio_close(serio);
|
||||
serio_set_drvdata(serio, NULL);
|
||||
input_put_device(phampshire->dev);
|
||||
kfree(phampshire);
|
||||
}
|
||||
|
||||
/*
|
||||
* hampshire_connect() is the routine that is called when someone adds a
|
||||
* new serio device that supports hampshire protocol and registers it as
|
||||
* an input device. This is usually accomplished using inputattach.
|
||||
*/
|
||||
|
||||
static int hampshire_connect(struct serio *serio, struct serio_driver *drv)
|
||||
{
|
||||
struct hampshire *phampshire;
|
||||
struct input_dev *input_dev;
|
||||
int err;
|
||||
|
||||
phampshire = kzalloc(sizeof(struct hampshire), GFP_KERNEL);
|
||||
input_dev = input_allocate_device();
|
||||
if (!phampshire || !input_dev) {
|
||||
err = -ENOMEM;
|
||||
goto fail1;
|
||||
}
|
||||
|
||||
phampshire->serio = serio;
|
||||
phampshire->dev = input_dev;
|
||||
snprintf(phampshire->phys, sizeof(phampshire->phys),
|
||||
"%s/input0", serio->phys);
|
||||
|
||||
input_dev->name = "Hampshire Serial TouchScreen";
|
||||
input_dev->phys = phampshire->phys;
|
||||
input_dev->id.bustype = BUS_RS232;
|
||||
input_dev->id.vendor = SERIO_HAMPSHIRE;
|
||||
input_dev->id.product = 0;
|
||||
input_dev->id.version = 0x0001;
|
||||
input_dev->dev.parent = &serio->dev;
|
||||
input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
|
||||
input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
|
||||
input_set_abs_params(phampshire->dev, ABS_X,
|
||||
HAMPSHIRE_MIN_XC, HAMPSHIRE_MAX_XC, 0, 0);
|
||||
input_set_abs_params(phampshire->dev, ABS_Y,
|
||||
HAMPSHIRE_MIN_YC, HAMPSHIRE_MAX_YC, 0, 0);
|
||||
|
||||
serio_set_drvdata(serio, phampshire);
|
||||
|
||||
err = serio_open(serio, drv);
|
||||
if (err)
|
||||
goto fail2;
|
||||
|
||||
err = input_register_device(phampshire->dev);
|
||||
if (err)
|
||||
goto fail3;
|
||||
|
||||
return 0;
|
||||
|
||||
fail3: serio_close(serio);
|
||||
fail2: serio_set_drvdata(serio, NULL);
|
||||
fail1: input_free_device(input_dev);
|
||||
kfree(phampshire);
|
||||
return err;
|
||||
}
|
||||
|
||||
/*
|
||||
* The serio driver structure.
|
||||
*/
|
||||
|
||||
static struct serio_device_id hampshire_serio_ids[] = {
|
||||
{
|
||||
.type = SERIO_RS232,
|
||||
.proto = SERIO_HAMPSHIRE,
|
||||
.id = SERIO_ANY,
|
||||
.extra = SERIO_ANY,
|
||||
},
|
||||
{ 0 }
|
||||
};
|
||||
|
||||
MODULE_DEVICE_TABLE(serio, hampshire_serio_ids);
|
||||
|
||||
static struct serio_driver hampshire_drv = {
|
||||
.driver = {
|
||||
.name = "hampshire",
|
||||
},
|
||||
.description = DRIVER_DESC,
|
||||
.id_table = hampshire_serio_ids,
|
||||
.interrupt = hampshire_interrupt,
|
||||
.connect = hampshire_connect,
|
||||
.disconnect = hampshire_disconnect,
|
||||
};
|
||||
|
||||
/*
|
||||
* The functions for inserting/removing us as a module.
|
||||
*/
|
||||
|
||||
static int __init hampshire_init(void)
|
||||
{
|
||||
return serio_register_driver(&hampshire_drv);
|
||||
}
|
||||
|
||||
static void __exit hampshire_exit(void)
|
||||
{
|
||||
serio_unregister_driver(&hampshire_drv);
|
||||
}
|
||||
|
||||
module_init(hampshire_init);
|
||||
module_exit(hampshire_exit);
|
@ -347,6 +347,8 @@ static int __devexit tsc2007_remove(struct i2c_client *client)
|
||||
struct tsc2007 *ts = i2c_get_clientdata(client);
|
||||
struct tsc2007_platform_data *pdata = client->dev.platform_data;
|
||||
|
||||
i2c_set_clientdata(client, NULL);
|
||||
|
||||
tsc2007_free_irq(ts);
|
||||
|
||||
if (pdata->exit_platform_hw)
|
||||
|
@ -811,12 +811,11 @@ static int nexio_init(struct usbtouch_usb *usbtouch)
|
||||
|
||||
priv = usbtouch->priv;
|
||||
|
||||
priv->ack_buf = kmalloc(sizeof(nexio_ack_pkt), GFP_KERNEL);
|
||||
priv->ack_buf = kmemdup(nexio_ack_pkt, sizeof(nexio_ack_pkt),
|
||||
GFP_KERNEL);
|
||||
if (!priv->ack_buf)
|
||||
goto err_priv;
|
||||
|
||||
memcpy(priv->ack_buf, nexio_ack_pkt, sizeof(nexio_ack_pkt));
|
||||
|
||||
priv->ack = usb_alloc_urb(0, GFP_KERNEL);
|
||||
if (!priv->ack) {
|
||||
dbg("%s - usb_alloc_urb failed: usbtouch->ack", __func__);
|
||||
|
@ -200,7 +200,7 @@ void wm97xx_set_gpio(struct wm97xx *wm, u32 gpio,
|
||||
mutex_lock(&wm->codec_mutex);
|
||||
reg = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
|
||||
|
||||
if (status & WM97XX_GPIO_HIGH)
|
||||
if (status == WM97XX_GPIO_HIGH)
|
||||
reg |= gpio;
|
||||
else
|
||||
reg &= ~gpio;
|
||||
|
@ -806,6 +806,7 @@ struct input_absinfo {
|
||||
#define BUS_HOST 0x19
|
||||
#define BUS_GSC 0x1A
|
||||
#define BUS_ATARI 0x1B
|
||||
#define BUS_SPI 0x1C
|
||||
|
||||
/*
|
||||
* MT_TOOL types
|
||||
|
63
include/linux/input/ad714x.h
Normal file
63
include/linux/input/ad714x.h
Normal file
@ -0,0 +1,63 @@
|
||||
/*
|
||||
* include/linux/input/ad714x.h
|
||||
*
|
||||
* AD714x is very flexible, it can be used as buttons, scrollwheel,
|
||||
* slider, touchpad at the same time. That depends on the boards.
|
||||
* The platform_data for the device's "struct device" holds this
|
||||
* information.
|
||||
*
|
||||
* Copyright 2009 Analog Devices Inc.
|
||||
*
|
||||
* Licensed under the GPL-2 or later.
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_INPUT_AD714X_H__
|
||||
#define __LINUX_INPUT_AD714X_H__
|
||||
|
||||
#define STAGE_NUM 12
|
||||
#define STAGE_CFGREG_NUM 8
|
||||
#define SYS_CFGREG_NUM 8
|
||||
|
||||
/* board information which need be initialized in arch/mach... */
|
||||
struct ad714x_slider_plat {
|
||||
int start_stage;
|
||||
int end_stage;
|
||||
int max_coord;
|
||||
};
|
||||
|
||||
struct ad714x_wheel_plat {
|
||||
int start_stage;
|
||||
int end_stage;
|
||||
int max_coord;
|
||||
};
|
||||
|
||||
struct ad714x_touchpad_plat {
|
||||
int x_start_stage;
|
||||
int x_end_stage;
|
||||
int x_max_coord;
|
||||
|
||||
int y_start_stage;
|
||||
int y_end_stage;
|
||||
int y_max_coord;
|
||||
};
|
||||
|
||||
struct ad714x_button_plat {
|
||||
int keycode;
|
||||
unsigned short l_mask;
|
||||
unsigned short h_mask;
|
||||
};
|
||||
|
||||
struct ad714x_platform_data {
|
||||
int slider_num;
|
||||
int wheel_num;
|
||||
int touchpad_num;
|
||||
int button_num;
|
||||
struct ad714x_slider_plat *slider;
|
||||
struct ad714x_wheel_plat *wheel;
|
||||
struct ad714x_touchpad_plat *touchpad;
|
||||
struct ad714x_button_plat *button;
|
||||
unsigned short stage_cfg_reg[STAGE_NUM][STAGE_CFGREG_NUM];
|
||||
unsigned short sys_cfg_reg[SYS_CFGREG_NUM];
|
||||
};
|
||||
|
||||
#endif
|
@ -196,5 +196,6 @@ static inline void serio_continue_rx(struct serio *serio)
|
||||
#define SERIO_TOUCHIT213 0x38
|
||||
#define SERIO_W8001 0x39
|
||||
#define SERIO_DYNAPRO 0x3a
|
||||
#define SERIO_HAMPSHIRE 0x3b
|
||||
|
||||
#endif
|
||||
|
@ -39,40 +39,33 @@ struct sysrq_key_op {
|
||||
|
||||
#ifdef CONFIG_MAGIC_SYSRQ
|
||||
|
||||
extern int sysrq_on(void);
|
||||
|
||||
/*
|
||||
* Do not use this one directly:
|
||||
*/
|
||||
extern int __sysrq_enabled;
|
||||
|
||||
/* Generic SysRq interface -- you may call it from any device driver, supplying
|
||||
* ASCII code of the key, pointer to registers and kbd/tty structs (if they
|
||||
* are available -- else NULL's).
|
||||
*/
|
||||
|
||||
void handle_sysrq(int key, struct tty_struct *tty);
|
||||
void __handle_sysrq(int key, struct tty_struct *tty, int check_mask);
|
||||
int register_sysrq_key(int key, struct sysrq_key_op *op);
|
||||
int unregister_sysrq_key(int key, struct sysrq_key_op *op);
|
||||
struct sysrq_key_op *__sysrq_get_key_op(int key);
|
||||
|
||||
int sysrq_toggle_support(int enable_mask);
|
||||
|
||||
#else
|
||||
|
||||
static inline int sysrq_on(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
static inline int __reterr(void)
|
||||
{
|
||||
return -EINVAL;
|
||||
}
|
||||
static inline void handle_sysrq(int key, struct tty_struct *tty)
|
||||
{
|
||||
}
|
||||
|
||||
#define register_sysrq_key(ig,nore) __reterr()
|
||||
#define unregister_sysrq_key(ig,nore) __reterr()
|
||||
static inline int register_sysrq_key(int key, struct sysrq_key_op *op)
|
||||
{
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static inline int unregister_sysrq_key(int key, struct sysrq_key_op *op)
|
||||
{
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
34
include/linux/tca6416_keypad.h
Normal file
34
include/linux/tca6416_keypad.h
Normal file
@ -0,0 +1,34 @@
|
||||
/*
|
||||
* tca6416 keypad platform support
|
||||
*
|
||||
* Copyright (C) 2010 Texas Instruments
|
||||
*
|
||||
* Author: Sriramakrishnan <srk@ti.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*/
|
||||
|
||||
#ifndef _TCA6416_KEYS_H
|
||||
#define _TCA6416_KEYS_H
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
struct tca6416_button {
|
||||
/* Configuration parameters */
|
||||
int code; /* input event code (KEY_*, SW_*) */
|
||||
int active_low;
|
||||
int type; /* input event type (EV_KEY, EV_SW) */
|
||||
};
|
||||
|
||||
struct tca6416_keys_platform_data {
|
||||
struct tca6416_button *buttons;
|
||||
int nbuttons;
|
||||
unsigned int rep:1; /* enable input subsystem auto repeat */
|
||||
uint16_t pinmask;
|
||||
uint16_t invert;
|
||||
int irq_is_gpio;
|
||||
int use_polling; /* use polling if Interrupt is not connected*/
|
||||
};
|
||||
#endif
|
@ -163,6 +163,27 @@ static int proc_taint(struct ctl_table *table, int write,
|
||||
void __user *buffer, size_t *lenp, loff_t *ppos);
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_MAGIC_SYSRQ
|
||||
static int __sysrq_enabled; /* Note: sysrq code ises it's own private copy */
|
||||
|
||||
static int sysrq_sysctl_handler(ctl_table *table, int write,
|
||||
void __user *buffer, size_t *lenp,
|
||||
loff_t *ppos)
|
||||
{
|
||||
int error;
|
||||
|
||||
error = proc_dointvec(table, write, buffer, lenp, ppos);
|
||||
if (error)
|
||||
return error;
|
||||
|
||||
if (write)
|
||||
sysrq_toggle_support(__sysrq_enabled);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static struct ctl_table root_table[];
|
||||
static struct ctl_table_root sysctl_table_root;
|
||||
static struct ctl_table_header root_table_header = {
|
||||
@ -567,7 +588,7 @@ static struct ctl_table kern_table[] = {
|
||||
.data = &__sysrq_enabled,
|
||||
.maxlen = sizeof (int),
|
||||
.mode = 0644,
|
||||
.proc_handler = proc_dointvec,
|
||||
.proc_handler = sysrq_sysctl_handler,
|
||||
},
|
||||
#endif
|
||||
#ifdef CONFIG_PROC_SYSCTL
|
||||
|
Loading…
Reference in New Issue
Block a user