diff options
Diffstat (limited to 'drivers/input')
-rw-r--r-- | drivers/input/Kconfig | 6 | ||||
-rw-r--r-- | drivers/input/gameport/gameport.c | 2 | ||||
-rw-r--r-- | drivers/input/input.c | 1 | ||||
-rw-r--r-- | drivers/input/keyboard/Kconfig | 14 | ||||
-rw-r--r-- | drivers/input/keyboard/Makefile | 1 | ||||
-rw-r--r-- | drivers/input/keyboard/omap-keypad.c | 41 | ||||
-rw-r--r-- | drivers/input/keyboard/tc3589x-keypad.c | 472 | ||||
-rw-r--r-- | drivers/input/misc/Kconfig | 18 | ||||
-rw-r--r-- | drivers/input/misc/Makefile | 1 | ||||
-rw-r--r-- | drivers/input/misc/winbond-cir.c | 1608 | ||||
-rw-r--r-- | drivers/input/mouse/Kconfig | 10 | ||||
-rw-r--r-- | drivers/input/mouse/bcm5974.c | 40 | ||||
-rw-r--r-- | drivers/input/serio/Kconfig | 9 | ||||
-rw-r--r-- | drivers/input/serio/gscps2.c | 2 | ||||
-rw-r--r-- | drivers/input/serio/serio_raw.c | 1 | ||||
-rw-r--r-- | drivers/input/touchscreen/Kconfig | 30 |
16 files changed, 573 insertions, 1683 deletions
diff --git a/drivers/input/Kconfig b/drivers/input/Kconfig index 07c2cd43109c..1903c0f5b925 100644 --- a/drivers/input/Kconfig +++ b/drivers/input/Kconfig | |||
@@ -6,7 +6,7 @@ menu "Input device support" | |||
6 | depends on !S390 | 6 | depends on !S390 |
7 | 7 | ||
8 | config INPUT | 8 | config INPUT |
9 | tristate "Generic input layer (needed for keyboard, mouse, ...)" if EMBEDDED | 9 | tristate "Generic input layer (needed for keyboard, mouse, ...)" if EXPERT |
10 | default y | 10 | default y |
11 | help | 11 | help |
12 | Say Y here if you have any input device (mouse, keyboard, tablet, | 12 | Say Y here if you have any input device (mouse, keyboard, tablet, |
@@ -67,7 +67,7 @@ config INPUT_SPARSEKMAP | |||
67 | comment "Userland interfaces" | 67 | comment "Userland interfaces" |
68 | 68 | ||
69 | config INPUT_MOUSEDEV | 69 | config INPUT_MOUSEDEV |
70 | tristate "Mouse interface" if EMBEDDED | 70 | tristate "Mouse interface" if EXPERT |
71 | default y | 71 | default y |
72 | help | 72 | help |
73 | Say Y here if you want your mouse to be accessible as char devices | 73 | Say Y here if you want your mouse to be accessible as char devices |
@@ -150,7 +150,7 @@ config INPUT_EVBUG | |||
150 | module will be called evbug. | 150 | module will be called evbug. |
151 | 151 | ||
152 | config INPUT_APMPOWER | 152 | config INPUT_APMPOWER |
153 | tristate "Input Power Event -> APM Bridge" if EMBEDDED | 153 | tristate "Input Power Event -> APM Bridge" if EXPERT |
154 | depends on INPUT && APM_EMULATION | 154 | depends on INPUT && APM_EMULATION |
155 | help | 155 | help |
156 | Say Y here if you want suspend key events to trigger a user | 156 | Say Y here if you want suspend key events to trigger a user |
diff --git a/drivers/input/gameport/gameport.c b/drivers/input/gameport/gameport.c index dbf741c95835..23cf8fc933ec 100644 --- a/drivers/input/gameport/gameport.c +++ b/drivers/input/gameport/gameport.c | |||
@@ -121,7 +121,7 @@ static int gameport_measure_speed(struct gameport *gameport) | |||
121 | } | 121 | } |
122 | 122 | ||
123 | gameport_close(gameport); | 123 | gameport_close(gameport); |
124 | return (cpu_data(raw_smp_processor_id()).loops_per_jiffy * | 124 | return (this_cpu_read(cpu_info.loops_per_jiffy) * |
125 | (unsigned long)HZ / (1000 / 50)) / (tx < 1 ? 1 : tx); | 125 | (unsigned long)HZ / (1000 / 50)) / (tx < 1 ? 1 : tx); |
126 | 126 | ||
127 | #else | 127 | #else |
diff --git a/drivers/input/input.c b/drivers/input/input.c index f37da09a5e4c..7985114beac7 100644 --- a/drivers/input/input.c +++ b/drivers/input/input.c | |||
@@ -26,7 +26,6 @@ | |||
26 | #include <linux/device.h> | 26 | #include <linux/device.h> |
27 | #include <linux/mutex.h> | 27 | #include <linux/mutex.h> |
28 | #include <linux/rcupdate.h> | 28 | #include <linux/rcupdate.h> |
29 | #include <linux/smp_lock.h> | ||
30 | #include "input-compat.h" | 29 | #include "input-compat.h" |
31 | 30 | ||
32 | MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>"); | 31 | MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>"); |
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig index b7dca74eb9be..c7a92028f450 100644 --- a/drivers/input/keyboard/Kconfig +++ b/drivers/input/keyboard/Kconfig | |||
@@ -2,7 +2,7 @@ | |||
2 | # Input core configuration | 2 | # Input core configuration |
3 | # | 3 | # |
4 | menuconfig INPUT_KEYBOARD | 4 | menuconfig INPUT_KEYBOARD |
5 | bool "Keyboards" if EMBEDDED || !X86 | 5 | bool "Keyboards" if EXPERT || !X86 |
6 | default y | 6 | default y |
7 | help | 7 | help |
8 | Say Y here, and a list of supported keyboards will be displayed. | 8 | Say Y here, and a list of supported keyboards will be displayed. |
@@ -57,7 +57,7 @@ config KEYBOARD_ATARI | |||
57 | module will be called atakbd. | 57 | module will be called atakbd. |
58 | 58 | ||
59 | config KEYBOARD_ATKBD | 59 | config KEYBOARD_ATKBD |
60 | tristate "AT keyboard" if EMBEDDED || !X86 | 60 | tristate "AT keyboard" if EXPERT || !X86 |
61 | default y | 61 | default y |
62 | select SERIO | 62 | select SERIO |
63 | select SERIO_LIBPS2 | 63 | select SERIO_LIBPS2 |
@@ -468,6 +468,16 @@ config KEYBOARD_SPEAR | |||
468 | To compile this driver as a module, choose M here: the | 468 | To compile this driver as a module, choose M here: the |
469 | module will be called spear-keboard. | 469 | module will be called spear-keboard. |
470 | 470 | ||
471 | config KEYBOARD_TC3589X | ||
472 | tristate "TC3589X Keypad support" | ||
473 | depends on MFD_TC3589X | ||
474 | help | ||
475 | Say Y here if you want to use the keypad controller on | ||
476 | TC35892/3 I/O expander. | ||
477 | |||
478 | To compile this driver as a module, choose M here: the | ||
479 | module will be called tc3589x-keypad. | ||
480 | |||
471 | config KEYBOARD_TNETV107X | 481 | config KEYBOARD_TNETV107X |
472 | tristate "TI TNETV107X keypad support" | 482 | tristate "TI TNETV107X keypad support" |
473 | depends on ARCH_DAVINCI_TNETV107X | 483 | depends on ARCH_DAVINCI_TNETV107X |
diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile index 3456b931e254..468c627a2844 100644 --- a/drivers/input/keyboard/Makefile +++ b/drivers/input/keyboard/Makefile | |||
@@ -41,6 +41,7 @@ obj-$(CONFIG_KEYBOARD_SPEAR) += spear-keyboard.o | |||
41 | obj-$(CONFIG_KEYBOARD_STMPE) += stmpe-keypad.o | 41 | obj-$(CONFIG_KEYBOARD_STMPE) += stmpe-keypad.o |
42 | obj-$(CONFIG_KEYBOARD_STOWAWAY) += stowaway.o | 42 | obj-$(CONFIG_KEYBOARD_STOWAWAY) += stowaway.o |
43 | obj-$(CONFIG_KEYBOARD_SUNKBD) += sunkbd.o | 43 | obj-$(CONFIG_KEYBOARD_SUNKBD) += sunkbd.o |
44 | obj-$(CONFIG_KEYBOARD_TC3589X) += tc3589x-keypad.o | ||
44 | obj-$(CONFIG_KEYBOARD_TEGRA) += tegra-kbc.o | 45 | obj-$(CONFIG_KEYBOARD_TEGRA) += tegra-kbc.o |
45 | obj-$(CONFIG_KEYBOARD_TNETV107X) += tnetv107x-keypad.o | 46 | obj-$(CONFIG_KEYBOARD_TNETV107X) += tnetv107x-keypad.o |
46 | obj-$(CONFIG_KEYBOARD_TWL4030) += twl4030_keypad.o | 47 | obj-$(CONFIG_KEYBOARD_TWL4030) += twl4030_keypad.o |
diff --git a/drivers/input/keyboard/omap-keypad.c b/drivers/input/keyboard/omap-keypad.c index a72e61ddca91..0e2a19cb43d8 100644 --- a/drivers/input/keyboard/omap-keypad.c +++ b/drivers/input/keyboard/omap-keypad.c | |||
@@ -65,7 +65,6 @@ struct omap_kp { | |||
65 | 65 | ||
66 | static DECLARE_TASKLET_DISABLED(kp_tasklet, omap_kp_tasklet, 0); | 66 | static DECLARE_TASKLET_DISABLED(kp_tasklet, omap_kp_tasklet, 0); |
67 | 67 | ||
68 | static int *keymap; | ||
69 | static unsigned int *row_gpios; | 68 | static unsigned int *row_gpios; |
70 | static unsigned int *col_gpios; | 69 | static unsigned int *col_gpios; |
71 | 70 | ||
@@ -162,20 +161,11 @@ static void omap_kp_scan_keypad(struct omap_kp *omap_kp, unsigned char *state) | |||
162 | } | 161 | } |
163 | } | 162 | } |
164 | 163 | ||
165 | static inline int omap_kp_find_key(int col, int row) | ||
166 | { | ||
167 | int i, key; | ||
168 | |||
169 | key = KEY(col, row, 0); | ||
170 | for (i = 0; keymap[i] != 0; i++) | ||
171 | if ((keymap[i] & 0xff000000) == key) | ||
172 | return keymap[i] & 0x00ffffff; | ||
173 | return -1; | ||
174 | } | ||
175 | |||
176 | static void omap_kp_tasklet(unsigned long data) | 164 | static void omap_kp_tasklet(unsigned long data) |
177 | { | 165 | { |
178 | struct omap_kp *omap_kp_data = (struct omap_kp *) data; | 166 | struct omap_kp *omap_kp_data = (struct omap_kp *) data; |
167 | unsigned short *keycodes = omap_kp_data->input->keycode; | ||
168 | unsigned int row_shift = get_count_order(omap_kp_data->cols); | ||
179 | unsigned char new_state[8], changed, key_down = 0; | 169 | unsigned char new_state[8], changed, key_down = 0; |
180 | int col, row; | 170 | int col, row; |
181 | int spurious = 0; | 171 | int spurious = 0; |
@@ -199,7 +189,7 @@ static void omap_kp_tasklet(unsigned long data) | |||
199 | row, (new_state[col] & (1 << row)) ? | 189 | row, (new_state[col] & (1 << row)) ? |
200 | "pressed" : "released"); | 190 | "pressed" : "released"); |
201 | #else | 191 | #else |
202 | key = omap_kp_find_key(col, row); | 192 | key = keycodes[MATRIX_SCAN_CODE(row, col, row_shift)]; |
203 | if (key < 0) { | 193 | if (key < 0) { |
204 | printk(KERN_WARNING | 194 | printk(KERN_WARNING |
205 | "omap-keypad: Spurious key event %d-%d\n", | 195 | "omap-keypad: Spurious key event %d-%d\n", |
@@ -298,13 +288,18 @@ static int __devinit omap_kp_probe(struct platform_device *pdev) | |||
298 | struct input_dev *input_dev; | 288 | struct input_dev *input_dev; |
299 | struct omap_kp_platform_data *pdata = pdev->dev.platform_data; | 289 | struct omap_kp_platform_data *pdata = pdev->dev.platform_data; |
300 | int i, col_idx, row_idx, irq_idx, ret; | 290 | int i, col_idx, row_idx, irq_idx, ret; |
291 | unsigned int row_shift, keycodemax; | ||
301 | 292 | ||
302 | if (!pdata->rows || !pdata->cols || !pdata->keymap) { | 293 | if (!pdata->rows || !pdata->cols || !pdata->keymap_data) { |
303 | printk(KERN_ERR "No rows, cols or keymap from pdata\n"); | 294 | printk(KERN_ERR "No rows, cols or keymap_data from pdata\n"); |
304 | return -EINVAL; | 295 | return -EINVAL; |
305 | } | 296 | } |
306 | 297 | ||
307 | omap_kp = kzalloc(sizeof(struct omap_kp), GFP_KERNEL); | 298 | row_shift = get_count_order(pdata->cols); |
299 | keycodemax = pdata->rows << row_shift; | ||
300 | |||
301 | omap_kp = kzalloc(sizeof(struct omap_kp) + | ||
302 | keycodemax * sizeof(unsigned short), GFP_KERNEL); | ||
308 | input_dev = input_allocate_device(); | 303 | input_dev = input_allocate_device(); |
309 | if (!omap_kp || !input_dev) { | 304 | if (!omap_kp || !input_dev) { |
310 | kfree(omap_kp); | 305 | kfree(omap_kp); |
@@ -320,7 +315,9 @@ static int __devinit omap_kp_probe(struct platform_device *pdev) | |||
320 | if (!cpu_is_omap24xx()) | 315 | if (!cpu_is_omap24xx()) |
321 | omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); | 316 | omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); |
322 | 317 | ||
323 | keymap = pdata->keymap; | 318 | input_dev->keycode = &omap_kp[1]; |
319 | input_dev->keycodesize = sizeof(unsigned short); | ||
320 | input_dev->keycodemax = keycodemax; | ||
324 | 321 | ||
325 | if (pdata->rep) | 322 | if (pdata->rep) |
326 | __set_bit(EV_REP, input_dev->evbit); | 323 | __set_bit(EV_REP, input_dev->evbit); |
@@ -374,8 +371,8 @@ static int __devinit omap_kp_probe(struct platform_device *pdev) | |||
374 | 371 | ||
375 | /* setup input device */ | 372 | /* setup input device */ |
376 | __set_bit(EV_KEY, input_dev->evbit); | 373 | __set_bit(EV_KEY, input_dev->evbit); |
377 | for (i = 0; keymap[i] != 0; i++) | 374 | matrix_keypad_build_keymap(pdata->keymap_data, row_shift, |
378 | __set_bit(keymap[i] & KEY_MAX, input_dev->keybit); | 375 | input_dev->keycode, input_dev->keybit); |
379 | input_dev->name = "omap-keypad"; | 376 | input_dev->name = "omap-keypad"; |
380 | input_dev->phys = "omap-keypad/input0"; | 377 | input_dev->phys = "omap-keypad/input0"; |
381 | input_dev->dev.parent = &pdev->dev; | 378 | input_dev->dev.parent = &pdev->dev; |
@@ -416,7 +413,7 @@ static int __devinit omap_kp_probe(struct platform_device *pdev) | |||
416 | return 0; | 413 | return 0; |
417 | err5: | 414 | err5: |
418 | for (i = irq_idx - 1; i >=0; i--) | 415 | for (i = irq_idx - 1; i >=0; i--) |
419 | free_irq(row_gpios[i], 0); | 416 | free_irq(row_gpios[i], NULL); |
420 | err4: | 417 | err4: |
421 | input_unregister_device(omap_kp->input); | 418 | input_unregister_device(omap_kp->input); |
422 | input_dev = NULL; | 419 | input_dev = NULL; |
@@ -447,11 +444,11 @@ static int __devexit omap_kp_remove(struct platform_device *pdev) | |||
447 | gpio_free(col_gpios[i]); | 444 | gpio_free(col_gpios[i]); |
448 | for (i = 0; i < omap_kp->rows; i++) { | 445 | for (i = 0; i < omap_kp->rows; i++) { |
449 | gpio_free(row_gpios[i]); | 446 | gpio_free(row_gpios[i]); |
450 | free_irq(gpio_to_irq(row_gpios[i]), 0); | 447 | free_irq(gpio_to_irq(row_gpios[i]), NULL); |
451 | } | 448 | } |
452 | } else { | 449 | } else { |
453 | omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); | 450 | omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); |
454 | free_irq(omap_kp->irq, 0); | 451 | free_irq(omap_kp->irq, NULL); |
455 | } | 452 | } |
456 | 453 | ||
457 | del_timer_sync(&omap_kp->timer); | 454 | del_timer_sync(&omap_kp->timer); |
diff --git a/drivers/input/keyboard/tc3589x-keypad.c b/drivers/input/keyboard/tc3589x-keypad.c new file mode 100644 index 000000000000..dbbe761778d2 --- /dev/null +++ b/drivers/input/keyboard/tc3589x-keypad.c | |||
@@ -0,0 +1,472 @@ | |||
1 | /* | ||
2 | * Copyright (C) ST-Ericsson SA 2010 | ||
3 | * | ||
4 | * Author: Jayeeta Banerjee <jayeeta.banerjee@stericsson.com> | ||
5 | * Author: Sundar Iyer <sundar.iyer@stericsson.com> | ||
6 | * | ||
7 | * License Terms: GNU General Public License, version 2 | ||
8 | * | ||
9 | * TC35893 MFD Keypad Controller driver | ||
10 | */ | ||
11 | |||
12 | #include <linux/module.h> | ||
13 | #include <linux/init.h> | ||
14 | #include <linux/interrupt.h> | ||
15 | #include <linux/input.h> | ||
16 | #include <linux/platform_device.h> | ||
17 | #include <linux/input/matrix_keypad.h> | ||
18 | #include <linux/i2c.h> | ||
19 | #include <linux/slab.h> | ||
20 | #include <linux/mfd/tc3589x.h> | ||
21 | |||
22 | /* Maximum supported keypad matrix row/columns size */ | ||
23 | #define TC3589x_MAX_KPROW 8 | ||
24 | #define TC3589x_MAX_KPCOL 12 | ||
25 | |||
26 | /* keypad related Constants */ | ||
27 | #define TC3589x_MAX_DEBOUNCE_SETTLE 0xFF | ||
28 | #define DEDICATED_KEY_VAL 0xFF | ||
29 | |||
30 | /* Pull up/down masks */ | ||
31 | #define TC3589x_NO_PULL_MASK 0x0 | ||
32 | #define TC3589x_PULL_DOWN_MASK 0x1 | ||
33 | #define TC3589x_PULL_UP_MASK 0x2 | ||
34 | #define TC3589x_PULLUP_ALL_MASK 0xAA | ||
35 | #define TC3589x_IO_PULL_VAL(index, mask) ((mask)<<((index)%4)*2)) | ||
36 | |||
37 | /* Bit masks for IOCFG register */ | ||
38 | #define IOCFG_BALLCFG 0x01 | ||
39 | #define IOCFG_IG 0x08 | ||
40 | |||
41 | #define KP_EVCODE_COL_MASK 0x0F | ||
42 | #define KP_EVCODE_ROW_MASK 0x70 | ||
43 | #define KP_RELEASE_EVT_MASK 0x80 | ||
44 | |||
45 | #define KP_ROW_SHIFT 4 | ||
46 | |||
47 | #define KP_NO_VALID_KEY_MASK 0x7F | ||
48 | |||
49 | /* bit masks for RESTCTRL register */ | ||
50 | #define TC3589x_KBDRST 0x2 | ||
51 | #define TC3589x_IRQRST 0x10 | ||
52 | #define TC3589x_RESET_ALL 0x1B | ||
53 | |||
54 | /* KBDMFS register bit mask */ | ||
55 | #define TC3589x_KBDMFS_EN 0x1 | ||
56 | |||
57 | /* CLKEN register bitmask */ | ||
58 | #define KPD_CLK_EN 0x1 | ||
59 | |||
60 | /* RSTINTCLR register bit mask */ | ||
61 | #define IRQ_CLEAR 0x1 | ||
62 | |||
63 | /* bit masks for keyboard interrupts*/ | ||
64 | #define TC3589x_EVT_LOSS_INT 0x8 | ||
65 | #define TC3589x_EVT_INT 0x4 | ||
66 | #define TC3589x_KBD_LOSS_INT 0x2 | ||
67 | #define TC3589x_KBD_INT 0x1 | ||
68 | |||
69 | /* bit masks for keyboard interrupt clear*/ | ||
70 | #define TC3589x_EVT_INT_CLR 0x2 | ||
71 | #define TC3589x_KBD_INT_CLR 0x1 | ||
72 | |||
73 | #define TC3589x_KBD_KEYMAP_SIZE 64 | ||
74 | |||
75 | /** | ||
76 | * struct tc_keypad - data structure used by keypad driver | ||
77 | * @input: pointer to input device object | ||
78 | * @board: keypad platform device | ||
79 | * @krow: number of rows | ||
80 | * @kcol: number of coloumns | ||
81 | * @keymap: matrix scan code table for keycodes | ||
82 | */ | ||
83 | struct tc_keypad { | ||
84 | struct tc3589x *tc3589x; | ||
85 | struct input_dev *input; | ||
86 | const struct tc3589x_keypad_platform_data *board; | ||
87 | unsigned int krow; | ||
88 | unsigned int kcol; | ||
89 | unsigned short keymap[TC3589x_KBD_KEYMAP_SIZE]; | ||
90 | bool keypad_stopped; | ||
91 | }; | ||
92 | |||
93 | static int __devinit tc3589x_keypad_init_key_hardware(struct tc_keypad *keypad) | ||
94 | { | ||
95 | int ret; | ||
96 | struct tc3589x *tc3589x = keypad->tc3589x; | ||
97 | u8 settle_time = keypad->board->settle_time; | ||
98 | u8 dbounce_period = keypad->board->debounce_period; | ||
99 | u8 rows = keypad->board->krow & 0xf; /* mask out the nibble */ | ||
100 | u8 column = keypad->board->kcol & 0xf; /* mask out the nibble */ | ||
101 | |||
102 | /* validate platform configurations */ | ||
103 | if (keypad->board->kcol > TC3589x_MAX_KPCOL || | ||
104 | keypad->board->krow > TC3589x_MAX_KPROW || | ||
105 | keypad->board->debounce_period > TC3589x_MAX_DEBOUNCE_SETTLE || | ||
106 | keypad->board->settle_time > TC3589x_MAX_DEBOUNCE_SETTLE) | ||
107 | return -EINVAL; | ||
108 | |||
109 | /* configure KBDSIZE 4 LSbits for cols and 4 MSbits for rows */ | ||
110 | ret = tc3589x_reg_write(tc3589x, TC3589x_KBDSIZE, | ||
111 | (rows << KP_ROW_SHIFT) | column); | ||
112 | if (ret < 0) | ||
113 | return ret; | ||
114 | |||
115 | /* configure dedicated key config, no dedicated key selected */ | ||
116 | ret = tc3589x_reg_write(tc3589x, TC3589x_KBCFG_LSB, DEDICATED_KEY_VAL); | ||
117 | if (ret < 0) | ||
118 | return ret; | ||
119 | |||
120 | ret = tc3589x_reg_write(tc3589x, TC3589x_KBCFG_MSB, DEDICATED_KEY_VAL); | ||
121 | if (ret < 0) | ||
122 | return ret; | ||
123 | |||
124 | /* Configure settle time */ | ||
125 | ret = tc3589x_reg_write(tc3589x, TC3589x_KBDSETTLE_REG, settle_time); | ||
126 | if (ret < 0) | ||
127 | return ret; | ||
128 | |||
129 | /* Configure debounce time */ | ||
130 | ret = tc3589x_reg_write(tc3589x, TC3589x_KBDBOUNCE, dbounce_period); | ||
131 | if (ret < 0) | ||
132 | return ret; | ||
133 | |||
134 | /* Start of initialise keypad GPIOs */ | ||
135 | ret = tc3589x_set_bits(tc3589x, TC3589x_IOCFG, 0x0, IOCFG_IG); | ||
136 | if (ret < 0) | ||
137 | return ret; | ||
138 | |||
139 | /* Configure pull-up resistors for all row GPIOs */ | ||
140 | ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG0_LSB, | ||
141 | TC3589x_PULLUP_ALL_MASK); | ||
142 | if (ret < 0) | ||
143 | return ret; | ||
144 | |||
145 | ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG0_MSB, | ||
146 | TC3589x_PULLUP_ALL_MASK); | ||
147 | if (ret < 0) | ||
148 | return ret; | ||
149 | |||
150 | /* Configure pull-up resistors for all column GPIOs */ | ||
151 | ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG1_LSB, | ||
152 | TC3589x_PULLUP_ALL_MASK); | ||
153 | if (ret < 0) | ||
154 | return ret; | ||
155 | |||
156 | ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG1_MSB, | ||
157 | TC3589x_PULLUP_ALL_MASK); | ||
158 | if (ret < 0) | ||
159 | return ret; | ||
160 | |||
161 | ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG2_LSB, | ||
162 | TC3589x_PULLUP_ALL_MASK); | ||
163 | |||
164 | return ret; | ||
165 | } | ||
166 | |||
167 | #define TC35893_DATA_REGS 4 | ||
168 | #define TC35893_KEYCODE_FIFO_EMPTY 0x7f | ||
169 | #define TC35893_KEYCODE_FIFO_CLEAR 0xff | ||
170 | #define TC35893_KEYPAD_ROW_SHIFT 0x3 | ||
171 | |||
172 | static irqreturn_t tc3589x_keypad_irq(int irq, void *dev) | ||
173 | { | ||
174 | struct tc_keypad *keypad = dev; | ||
175 | struct tc3589x *tc3589x = keypad->tc3589x; | ||
176 | u8 i, row_index, col_index, kbd_code, up; | ||
177 | u8 code; | ||
178 | |||
179 | for (i = 0; i < TC35893_DATA_REGS * 2; i++) { | ||
180 | kbd_code = tc3589x_reg_read(tc3589x, TC3589x_EVTCODE_FIFO); | ||
181 | |||
182 | /* loop till fifo is empty and no more keys are pressed */ | ||
183 | if (kbd_code == TC35893_KEYCODE_FIFO_EMPTY || | ||
184 | kbd_code == TC35893_KEYCODE_FIFO_CLEAR) | ||
185 | continue; | ||
186 | |||
187 | /* valid key is found */ | ||
188 | col_index = kbd_code & KP_EVCODE_COL_MASK; | ||
189 | row_index = (kbd_code & KP_EVCODE_ROW_MASK) >> KP_ROW_SHIFT; | ||
190 | code = MATRIX_SCAN_CODE(row_index, col_index, | ||
191 | TC35893_KEYPAD_ROW_SHIFT); | ||
192 | up = kbd_code & KP_RELEASE_EVT_MASK; | ||
193 | |||
194 | input_event(keypad->input, EV_MSC, MSC_SCAN, code); | ||
195 | input_report_key(keypad->input, keypad->keymap[code], !up); | ||
196 | input_sync(keypad->input); | ||
197 | } | ||
198 | |||
199 | /* clear IRQ */ | ||
200 | tc3589x_set_bits(tc3589x, TC3589x_KBDIC, | ||
201 | 0x0, TC3589x_EVT_INT_CLR | TC3589x_KBD_INT_CLR); | ||
202 | /* enable IRQ */ | ||
203 | tc3589x_set_bits(tc3589x, TC3589x_KBDMSK, | ||
204 | 0x0, TC3589x_EVT_LOSS_INT | TC3589x_EVT_INT); | ||
205 | |||
206 | return IRQ_HANDLED; | ||
207 | } | ||
208 | |||
209 | static int tc3589x_keypad_enable(struct tc_keypad *keypad) | ||
210 | { | ||
211 | struct tc3589x *tc3589x = keypad->tc3589x; | ||
212 | int ret; | ||
213 | |||
214 | /* pull the keypad module out of reset */ | ||
215 | ret = tc3589x_set_bits(tc3589x, TC3589x_RSTCTRL, TC3589x_KBDRST, 0x0); | ||
216 | if (ret < 0) | ||
217 | return ret; | ||
218 | |||
219 | /* configure KBDMFS */ | ||
220 | ret = tc3589x_set_bits(tc3589x, TC3589x_KBDMFS, 0x0, TC3589x_KBDMFS_EN); | ||
221 | if (ret < 0) | ||
222 | return ret; | ||
223 | |||
224 | /* enable the keypad clock */ | ||
225 | ret = tc3589x_set_bits(tc3589x, TC3589x_CLKEN, 0x0, KPD_CLK_EN); | ||
226 | if (ret < 0) | ||
227 | return ret; | ||
228 | |||
229 | /* clear pending IRQs */ | ||
230 | ret = tc3589x_set_bits(tc3589x, TC3589x_RSTINTCLR, 0x0, 0x1); | ||
231 | if (ret < 0) | ||
232 | return ret; | ||
233 | |||
234 | /* enable the IRQs */ | ||
235 | ret = tc3589x_set_bits(tc3589x, TC3589x_KBDMSK, 0x0, | ||
236 | TC3589x_EVT_LOSS_INT | TC3589x_EVT_INT); | ||
237 | if (ret < 0) | ||
238 | return ret; | ||
239 | |||
240 | keypad->keypad_stopped = false; | ||
241 | |||
242 | return ret; | ||
243 | } | ||
244 | |||
245 | static int tc3589x_keypad_disable(struct tc_keypad *keypad) | ||
246 | { | ||
247 | struct tc3589x *tc3589x = keypad->tc3589x; | ||
248 | int ret; | ||
249 | |||
250 | /* clear IRQ */ | ||
251 | ret = tc3589x_set_bits(tc3589x, TC3589x_KBDIC, | ||
252 | 0x0, TC3589x_EVT_INT_CLR | TC3589x_KBD_INT_CLR); | ||
253 | if (ret < 0) | ||
254 | return ret; | ||
255 | |||
256 | /* disable all interrupts */ | ||
257 | ret = tc3589x_set_bits(tc3589x, TC3589x_KBDMSK, | ||
258 | ~(TC3589x_EVT_LOSS_INT | TC3589x_EVT_INT), 0x0); | ||
259 | if (ret < 0) | ||
260 | return ret; | ||
261 | |||
262 | /* disable the keypad module */ | ||
263 | ret = tc3589x_set_bits(tc3589x, TC3589x_CLKEN, 0x1, 0x0); | ||
264 | if (ret < 0) | ||
265 | return ret; | ||
266 | |||
267 | /* put the keypad module into reset */ | ||
268 | ret = tc3589x_set_bits(tc3589x, TC3589x_RSTCTRL, TC3589x_KBDRST, 0x1); | ||
269 | |||
270 | keypad->keypad_stopped = true; | ||
271 | |||
272 | return ret; | ||
273 | } | ||
274 | |||
275 | static int tc3589x_keypad_open(struct input_dev *input) | ||
276 | { | ||
277 | int error; | ||
278 | struct tc_keypad *keypad = input_get_drvdata(input); | ||
279 | |||
280 | /* enable the keypad module */ | ||
281 | error = tc3589x_keypad_enable(keypad); | ||
282 | if (error < 0) { | ||
283 | dev_err(&input->dev, "failed to enable keypad module\n"); | ||
284 | return error; | ||
285 | } | ||
286 | |||
287 | error = tc3589x_keypad_init_key_hardware(keypad); | ||
288 | if (error < 0) { | ||
289 | dev_err(&input->dev, "failed to configure keypad module\n"); | ||
290 | return error; | ||
291 | } | ||
292 | |||
293 | return 0; | ||
294 | } | ||
295 | |||
296 | static void tc3589x_keypad_close(struct input_dev *input) | ||
297 | { | ||
298 | struct tc_keypad *keypad = input_get_drvdata(input); | ||
299 | |||
300 | /* disable the keypad module */ | ||
301 | tc3589x_keypad_disable(keypad); | ||
302 | } | ||
303 | |||
304 | static int __devinit tc3589x_keypad_probe(struct platform_device *pdev) | ||
305 | { | ||
306 | struct tc3589x *tc3589x = dev_get_drvdata(pdev->dev.parent); | ||
307 | struct tc_keypad *keypad; | ||
308 | struct input_dev *input; | ||
309 | const struct tc3589x_keypad_platform_data *plat; | ||
310 | int error, irq; | ||
311 | |||
312 | plat = tc3589x->pdata->keypad; | ||
313 | if (!plat) { | ||
314 | dev_err(&pdev->dev, "invalid keypad platform data\n"); | ||
315 | return -EINVAL; | ||
316 | } | ||
317 | |||
318 | irq = platform_get_irq(pdev, 0); | ||
319 | if (irq < 0) | ||
320 | return irq; | ||
321 | |||
322 | keypad = kzalloc(sizeof(struct tc_keypad), GFP_KERNEL); | ||
323 | input = input_allocate_device(); | ||
324 | if (!keypad || !input) { | ||
325 | dev_err(&pdev->dev, "failed to allocate keypad memory\n"); | ||
326 | error = -ENOMEM; | ||
327 | goto err_free_mem; | ||
328 | } | ||
329 | |||
330 | keypad->board = plat; | ||
331 | keypad->input = input; | ||
332 | keypad->tc3589x = tc3589x; | ||
333 | |||
334 | input->id.bustype = BUS_I2C; | ||
335 | input->name = pdev->name; | ||
336 | input->dev.parent = &pdev->dev; | ||
337 | |||
338 | input->keycode = keypad->keymap; | ||
339 | input->keycodesize = sizeof(keypad->keymap[0]); | ||
340 | input->keycodemax = ARRAY_SIZE(keypad->keymap); | ||
341 | |||
342 | input->open = tc3589x_keypad_open; | ||
343 | input->close = tc3589x_keypad_close; | ||
344 | |||
345 | input_set_drvdata(input, keypad); | ||
346 | |||
347 | input_set_capability(input, EV_MSC, MSC_SCAN); | ||
348 | |||
349 | __set_bit(EV_KEY, input->evbit); | ||
350 | if (!plat->no_autorepeat) | ||
351 | __set_bit(EV_REP, input->evbit); | ||
352 | |||
353 | matrix_keypad_build_keymap(plat->keymap_data, 0x3, | ||
354 | input->keycode, input->keybit); | ||
355 | |||
356 | error = request_threaded_irq(irq, NULL, | ||
357 | tc3589x_keypad_irq, plat->irqtype, | ||
358 | "tc3589x-keypad", keypad); | ||
359 | if (error < 0) { | ||
360 | dev_err(&pdev->dev, | ||
361 | "Could not allocate irq %d,error %d\n", | ||
362 | irq, error); | ||
363 | goto err_free_mem; | ||
364 | } | ||
365 | |||
366 | error = input_register_device(input); | ||
367 | if (error) { | ||
368 | dev_err(&pdev->dev, "Could not register input device\n"); | ||
369 | goto err_free_irq; | ||
370 | } | ||
371 | |||
372 | /* let platform decide if keypad is a wakeup source or not */ | ||
373 | device_init_wakeup(&pdev->dev, plat->enable_wakeup); | ||
374 | device_set_wakeup_capable(&pdev->dev, plat->enable_wakeup); | ||
375 | |||
376 | platform_set_drvdata(pdev, keypad); | ||
377 | |||
378 | return 0; | ||
379 | |||
380 | err_free_irq: | ||
381 | free_irq(irq, keypad); | ||
382 | err_free_mem: | ||
383 | input_free_device(input); | ||
384 | kfree(keypad); | ||
385 | return error; | ||
386 | } | ||
387 | |||
388 | static int __devexit tc3589x_keypad_remove(struct platform_device *pdev) | ||
389 | { | ||
390 | struct tc_keypad *keypad = platform_get_drvdata(pdev); | ||
391 | int irq = platform_get_irq(pdev, 0); | ||
392 | |||
393 | if (!keypad->keypad_stopped) | ||
394 | tc3589x_keypad_disable(keypad); | ||
395 | |||
396 | free_irq(irq, keypad); | ||
397 | |||
398 | input_unregister_device(keypad->input); | ||
399 | |||
400 | kfree(keypad); | ||
401 | |||
402 | return 0; | ||
403 | } | ||
404 | |||
405 | #ifdef CONFIG_PM | ||
406 | static int tc3589x_keypad_suspend(struct device *dev) | ||
407 | { | ||
408 | struct platform_device *pdev = to_platform_device(dev); | ||
409 | struct tc_keypad *keypad = platform_get_drvdata(pdev); | ||
410 | int irq = platform_get_irq(pdev, 0); | ||
411 | |||
412 | /* keypad is already off; we do nothing */ | ||
413 | if (keypad->keypad_stopped) | ||
414 | return 0; | ||
415 | |||
416 | /* if device is not a wakeup source, disable it for powersave */ | ||
417 | if (!device_may_wakeup(&pdev->dev)) | ||
418 | tc3589x_keypad_disable(keypad); | ||
419 | else | ||
420 | enable_irq_wake(irq); | ||
421 | |||
422 | return 0; | ||
423 | } | ||
424 | |||
425 | static int tc3589x_keypad_resume(struct device *dev) | ||
426 | { | ||
427 | struct platform_device *pdev = to_platform_device(dev); | ||
428 | struct tc_keypad *keypad = platform_get_drvdata(pdev); | ||
429 | int irq = platform_get_irq(pdev, 0); | ||
430 | |||
431 | if (!keypad->keypad_stopped) | ||
432 | return 0; | ||
433 | |||
434 | /* enable the device to resume normal operations */ | ||
435 | if (!device_may_wakeup(&pdev->dev)) | ||
436 | tc3589x_keypad_enable(keypad); | ||
437 | else | ||
438 | disable_irq_wake(irq); | ||
439 | |||
440 | return 0; | ||
441 | } | ||
442 | |||
443 | static const SIMPLE_DEV_PM_OPS(tc3589x_keypad_dev_pm_ops, | ||
444 | tc3589x_keypad_suspend, tc3589x_keypad_resume); | ||
445 | #endif | ||
446 | |||
447 | static struct platform_driver tc3589x_keypad_driver = { | ||
448 | .driver.name = "tc3589x-keypad", | ||
449 | .driver.owner = THIS_MODULE, | ||
450 | #ifdef CONFIG_PM | ||
451 | .driver.pm = &tc3589x_keypad_dev_pm_ops, | ||
452 | #endif | ||
453 | .probe = tc3589x_keypad_probe, | ||
454 | .remove = __devexit_p(tc3589x_keypad_remove), | ||
455 | }; | ||
456 | |||
457 | static int __init tc3589x_keypad_init(void) | ||
458 | { | ||
459 | return platform_driver_register(&tc3589x_keypad_driver); | ||
460 | } | ||
461 | module_init(tc3589x_keypad_init); | ||
462 | |||
463 | static void __exit tc3589x_keypad_exit(void) | ||
464 | { | ||
465 | return platform_driver_unregister(&tc3589x_keypad_driver); | ||
466 | } | ||
467 | module_exit(tc3589x_keypad_exit); | ||
468 | |||
469 | MODULE_LICENSE("GPL v2"); | ||
470 | MODULE_AUTHOR("Jayeeta Banerjee/Sundar Iyer"); | ||
471 | MODULE_DESCRIPTION("TC35893 Keypad Driver"); | ||
472 | MODULE_ALIAS("platform:tc3589x-keypad"); | ||
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig index f0d90172a65f..b0c6772851a9 100644 --- a/drivers/input/misc/Kconfig +++ b/drivers/input/misc/Kconfig | |||
@@ -294,24 +294,6 @@ config INPUT_SGI_BTNS | |||
294 | To compile this driver as a module, choose M here: the | 294 | To compile this driver as a module, choose M here: the |
295 | module will be called sgi_btns. | 295 | module will be called sgi_btns. |
296 | 296 | ||
297 | config INPUT_WINBOND_CIR | ||
298 | tristate "Winbond IR remote control" | ||
299 | depends on X86 && PNP | ||
300 | select NEW_LEDS | ||
301 | select LEDS_CLASS | ||
302 | select LEDS_TRIGGERS | ||
303 | select BITREVERSE | ||
304 | help | ||
305 | Say Y here if you want to use the IR remote functionality found | ||
306 | in some Winbond SuperI/O chips. Currently only the WPCD376I | ||
307 | chip is supported (included in some Intel Media series motherboards). | ||
308 | |||
309 | IR Receive and wake-on-IR from suspend and power-off is currently | ||
310 | supported. | ||
311 | |||
312 | To compile this driver as a module, choose M here: the module will be | ||
313 | called winbond_cir. | ||
314 | |||
315 | config HP_SDC_RTC | 297 | config HP_SDC_RTC |
316 | tristate "HP SDC Real Time Clock" | 298 | tristate "HP SDC Real Time Clock" |
317 | depends on (GSC || HP300) && SERIO | 299 | depends on (GSC || HP300) && SERIO |
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile index 35bcfe46555e..9b4797112c9a 100644 --- a/drivers/input/misc/Makefile +++ b/drivers/input/misc/Makefile | |||
@@ -40,7 +40,6 @@ obj-$(CONFIG_INPUT_SPARCSPKR) += sparcspkr.o | |||
40 | obj-$(CONFIG_INPUT_TWL4030_PWRBUTTON) += twl4030-pwrbutton.o | 40 | obj-$(CONFIG_INPUT_TWL4030_PWRBUTTON) += twl4030-pwrbutton.o |
41 | obj-$(CONFIG_INPUT_TWL4030_VIBRA) += twl4030-vibra.o | 41 | obj-$(CONFIG_INPUT_TWL4030_VIBRA) += twl4030-vibra.o |
42 | obj-$(CONFIG_INPUT_UINPUT) += uinput.o | 42 | obj-$(CONFIG_INPUT_UINPUT) += uinput.o |
43 | obj-$(CONFIG_INPUT_WINBOND_CIR) += winbond-cir.o | ||
44 | obj-$(CONFIG_INPUT_WISTRON_BTNS) += wistron_btns.o | 43 | obj-$(CONFIG_INPUT_WISTRON_BTNS) += wistron_btns.o |
45 | obj-$(CONFIG_INPUT_WM831X_ON) += wm831x-on.o | 44 | obj-$(CONFIG_INPUT_WM831X_ON) += wm831x-on.o |
46 | obj-$(CONFIG_INPUT_YEALINK) += yealink.o | 45 | obj-$(CONFIG_INPUT_YEALINK) += yealink.o |
diff --git a/drivers/input/misc/winbond-cir.c b/drivers/input/misc/winbond-cir.c deleted file mode 100644 index 64f1de7960c6..000000000000 --- a/drivers/input/misc/winbond-cir.c +++ /dev/null | |||
@@ -1,1608 +0,0 @@ | |||
1 | /* | ||
2 | * winbond-cir.c - Driver for the Consumer IR functionality of Winbond | ||
3 | * SuperI/O chips. | ||
4 | * | ||
5 | * Currently supports the Winbond WPCD376i chip (PNP id WEC1022), but | ||
6 | * could probably support others (Winbond WEC102X, NatSemi, etc) | ||
7 | * with minor modifications. | ||
8 | * | ||
9 | * Original Author: David Härdeman <david@hardeman.nu> | ||
10 | * Copyright (C) 2009 David Härdeman <david@hardeman.nu> | ||
11 | * | ||
12 | * Dedicated to Matilda, my newborn daughter, without whose loving attention | ||
13 | * this driver would have been finished in half the time and with a fraction | ||
14 | * of the bugs. | ||
15 | * | ||
16 | * Written using: | ||
17 | * o Winbond WPCD376I datasheet helpfully provided by Jesse Barnes at Intel | ||
18 | * o NatSemi PC87338/PC97338 datasheet (for the serial port stuff) | ||
19 | * o DSDT dumps | ||
20 | * | ||
21 | * Supported features: | ||
22 | * o RC6 | ||
23 | * o Wake-On-CIR functionality | ||
24 | * | ||
25 | * To do: | ||
26 | * o Test NEC and RC5 | ||
27 | * | ||
28 | * Left as an exercise for the reader: | ||
29 | * o Learning (I have neither the hardware, nor the need) | ||
30 | * o IR Transmit (ibid) | ||
31 | * | ||
32 | * This program is free software; you can redistribute it and/or modify | ||
33 | * it under the terms of the GNU General Public License as published by | ||
34 | * the Free Software Foundation; either version 2 of the License, or | ||
35 | * (at your option) any later version. | ||
36 | * | ||
37 | * This program is distributed in the hope that it will be useful, | ||
38 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
39 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
40 | * GNU General Public License for more details. | ||
41 | * | ||
42 | * You should have received a copy of the GNU General Public License | ||
43 | * along with this program; if not, write to the Free Software | ||
44 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
45 | */ | ||
46 | |||
47 | #include <linux/module.h> | ||
48 | #include <linux/pnp.h> | ||
49 | #include <linux/interrupt.h> | ||
50 | #include <linux/timer.h> | ||
51 | #include <linux/input.h> | ||
52 | #include <linux/leds.h> | ||
53 | #include <linux/list.h> | ||
54 | #include <linux/spinlock.h> | ||
55 | #include <linux/pci_ids.h> | ||
56 | #include <linux/io.h> | ||
57 | #include <linux/bitrev.h> | ||
58 | #include <linux/bitops.h> | ||
59 | #include <linux/slab.h> | ||
60 | |||
61 | #define DRVNAME "winbond-cir" | ||
62 | |||
63 | /* CEIR Wake-Up Registers, relative to data->wbase */ | ||
64 | #define WBCIR_REG_WCEIR_CTL 0x03 /* CEIR Receiver Control */ | ||
65 | #define WBCIR_REG_WCEIR_STS 0x04 /* CEIR Receiver Status */ | ||
66 | #define WBCIR_REG_WCEIR_EV_EN 0x05 /* CEIR Receiver Event Enable */ | ||
67 | #define WBCIR_REG_WCEIR_CNTL 0x06 /* CEIR Receiver Counter Low */ | ||
68 | #define WBCIR_REG_WCEIR_CNTH 0x07 /* CEIR Receiver Counter High */ | ||
69 | #define WBCIR_REG_WCEIR_INDEX 0x08 /* CEIR Receiver Index */ | ||
70 | #define WBCIR_REG_WCEIR_DATA 0x09 /* CEIR Receiver Data */ | ||
71 | #define WBCIR_REG_WCEIR_CSL 0x0A /* CEIR Re. Compare Strlen */ | ||
72 | #define WBCIR_REG_WCEIR_CFG1 0x0B /* CEIR Re. Configuration 1 */ | ||
73 | #define WBCIR_REG_WCEIR_CFG2 0x0C /* CEIR Re. Configuration 2 */ | ||
74 | |||
75 | /* CEIR Enhanced Functionality Registers, relative to data->ebase */ | ||
76 | #define WBCIR_REG_ECEIR_CTS 0x00 /* Enhanced IR Control Status */ | ||
77 | #define WBCIR_REG_ECEIR_CCTL 0x01 /* Infrared Counter Control */ | ||
78 | #define WBCIR_REG_ECEIR_CNT_LO 0x02 /* Infrared Counter LSB */ | ||
79 | #define WBCIR_REG_ECEIR_CNT_HI 0x03 /* Infrared Counter MSB */ | ||
80 | #define WBCIR_REG_ECEIR_IREM 0x04 /* Infrared Emitter Status */ | ||
81 | |||
82 | /* SP3 Banked Registers, relative to data->sbase */ | ||
83 | #define WBCIR_REG_SP3_BSR 0x03 /* Bank Select, all banks */ | ||
84 | /* Bank 0 */ | ||
85 | #define WBCIR_REG_SP3_RXDATA 0x00 /* FIFO RX data (r) */ | ||
86 | #define WBCIR_REG_SP3_TXDATA 0x00 /* FIFO TX data (w) */ | ||
87 | #define WBCIR_REG_SP3_IER 0x01 /* Interrupt Enable */ | ||
88 | #define WBCIR_REG_SP3_EIR 0x02 /* Event Identification (r) */ | ||
89 | #define WBCIR_REG_SP3_FCR 0x02 /* FIFO Control (w) */ | ||
90 | #define WBCIR_REG_SP3_MCR 0x04 /* Mode Control */ | ||
91 | #define WBCIR_REG_SP3_LSR 0x05 /* Link Status */ | ||
92 | #define WBCIR_REG_SP3_MSR 0x06 /* Modem Status */ | ||
93 | #define WBCIR_REG_SP3_ASCR 0x07 /* Aux Status and Control */ | ||
94 | /* Bank 2 */ | ||
95 | #define WBCIR_REG_SP3_BGDL 0x00 /* Baud Divisor LSB */ | ||
96 | #define WBCIR_REG_SP3_BGDH 0x01 /* Baud Divisor MSB */ | ||
97 | #define WBCIR_REG_SP3_EXCR1 0x02 /* Extended Control 1 */ | ||
98 | #define WBCIR_REG_SP3_EXCR2 0x04 /* Extended Control 2 */ | ||
99 | #define WBCIR_REG_SP3_TXFLV 0x06 /* TX FIFO Level */ | ||
100 | #define WBCIR_REG_SP3_RXFLV 0x07 /* RX FIFO Level */ | ||
101 | /* Bank 3 */ | ||
102 | #define WBCIR_REG_SP3_MRID 0x00 /* Module Identification */ | ||
103 | #define WBCIR_REG_SP3_SH_LCR 0x01 /* LCR Shadow */ | ||
104 | #define WBCIR_REG_SP3_SH_FCR 0x02 /* FCR Shadow */ | ||
105 | /* Bank 4 */ | ||
106 | #define WBCIR_REG_SP3_IRCR1 0x02 /* Infrared Control 1 */ | ||
107 | /* Bank 5 */ | ||
108 | #define WBCIR_REG_SP3_IRCR2 0x04 /* Infrared Control 2 */ | ||
109 | /* Bank 6 */ | ||
110 | #define WBCIR_REG_SP3_IRCR3 0x00 /* Infrared Control 3 */ | ||
111 | #define WBCIR_REG_SP3_SIR_PW 0x02 /* SIR Pulse Width */ | ||
112 | /* Bank 7 */ | ||
113 | #define WBCIR_REG_SP3_IRRXDC 0x00 /* IR RX Demod Control */ | ||
114 | #define WBCIR_REG_SP3_IRTXMC 0x01 /* IR TX Mod Control */ | ||
115 | #define WBCIR_REG_SP3_RCCFG 0x02 /* CEIR Config */ | ||
116 | #define WBCIR_REG_SP3_IRCFG1 0x04 /* Infrared Config 1 */ | ||
117 | #define WBCIR_REG_SP3_IRCFG4 0x07 /* Infrared Config 4 */ | ||
118 | |||
119 | /* | ||
120 | * Magic values follow | ||
121 | */ | ||
122 | |||
123 | /* No interrupts for WBCIR_REG_SP3_IER and WBCIR_REG_SP3_EIR */ | ||
124 | #define WBCIR_IRQ_NONE 0x00 | ||
125 | /* RX data bit for WBCIR_REG_SP3_IER and WBCIR_REG_SP3_EIR */ | ||
126 | #define WBCIR_IRQ_RX 0x01 | ||
127 | /* Over/Under-flow bit for WBCIR_REG_SP3_IER and WBCIR_REG_SP3_EIR */ | ||
128 | #define WBCIR_IRQ_ERR 0x04 | ||
129 | /* Led enable/disable bit for WBCIR_REG_ECEIR_CTS */ | ||
130 | #define WBCIR_LED_ENABLE 0x80 | ||
131 | /* RX data available bit for WBCIR_REG_SP3_LSR */ | ||
132 | #define WBCIR_RX_AVAIL 0x01 | ||
133 | /* RX disable bit for WBCIR_REG_SP3_ASCR */ | ||
134 | #define WBCIR_RX_DISABLE 0x20 | ||
135 | /* Extended mode enable bit for WBCIR_REG_SP3_EXCR1 */ | ||
136 | #define WBCIR_EXT_ENABLE 0x01 | ||
137 | /* Select compare register in WBCIR_REG_WCEIR_INDEX (bits 5 & 6) */ | ||
138 | #define WBCIR_REGSEL_COMPARE 0x10 | ||
139 | /* Select mask register in WBCIR_REG_WCEIR_INDEX (bits 5 & 6) */ | ||
140 | #define WBCIR_REGSEL_MASK 0x20 | ||
141 | /* Starting address of selected register in WBCIR_REG_WCEIR_INDEX */ | ||
142 | #define WBCIR_REG_ADDR0 0x00 | ||
143 | |||
144 | /* Valid banks for the SP3 UART */ | ||
145 | enum wbcir_bank { | ||
146 | WBCIR_BANK_0 = 0x00, | ||
147 | WBCIR_BANK_1 = 0x80, | ||
148 | WBCIR_BANK_2 = 0xE0, | ||
149 | WBCIR_BANK_3 = 0xE4, | ||
150 | WBCIR_BANK_4 = 0xE8, | ||
151 | WBCIR_BANK_5 = 0xEC, | ||
152 | WBCIR_BANK_6 = 0xF0, | ||
153 | WBCIR_BANK_7 = 0xF4, | ||
154 | }; | ||
155 | |||
156 | /* Supported IR Protocols */ | ||
157 | enum wbcir_protocol { | ||
158 | IR_PROTOCOL_RC5 = 0x0, | ||
159 | IR_PROTOCOL_NEC = 0x1, | ||
160 | IR_PROTOCOL_RC6 = 0x2, | ||
161 | }; | ||
162 | |||
163 | /* Misc */ | ||
164 | #define WBCIR_NAME "Winbond CIR" | ||
165 | #define WBCIR_ID_FAMILY 0xF1 /* Family ID for the WPCD376I */ | ||
166 | #define WBCIR_ID_CHIP 0x04 /* Chip ID for the WPCD376I */ | ||
167 | #define IR_KEYPRESS_TIMEOUT 250 /* FIXME: should be per-protocol? */ | ||
168 | #define INVALID_SCANCODE 0x7FFFFFFF /* Invalid with all protos */ | ||
169 | #define WAKEUP_IOMEM_LEN 0x10 /* Wake-Up I/O Reg Len */ | ||
170 | #define EHFUNC_IOMEM_LEN 0x10 /* Enhanced Func I/O Reg Len */ | ||
171 | #define SP_IOMEM_LEN 0x08 /* Serial Port 3 (IR) Reg Len */ | ||
172 | #define WBCIR_MAX_IDLE_BYTES 10 | ||
173 | |||
174 | static DEFINE_SPINLOCK(wbcir_lock); | ||
175 | static DEFINE_RWLOCK(keytable_lock); | ||
176 | |||
177 | struct wbcir_key { | ||
178 | u32 scancode; | ||
179 | unsigned int keycode; | ||
180 | }; | ||
181 | |||
182 | struct wbcir_keyentry { | ||
183 | struct wbcir_key key; | ||
184 | struct list_head list; | ||
185 | }; | ||
186 | |||
187 | static struct wbcir_key rc6_def_keymap[] = { | ||
188 | { 0x800F0400, KEY_NUMERIC_0 }, | ||
189 | { 0x800F0401, KEY_NUMERIC_1 }, | ||
190 | { 0x800F0402, KEY_NUMERIC_2 }, | ||
191 | { 0x800F0403, KEY_NUMERIC_3 }, | ||
192 | { 0x800F0404, KEY_NUMERIC_4 }, | ||
193 | { 0x800F0405, KEY_NUMERIC_5 }, | ||
194 | { 0x800F0406, KEY_NUMERIC_6 }, | ||
195 | { 0x800F0407, KEY_NUMERIC_7 }, | ||
196 | { 0x800F0408, KEY_NUMERIC_8 }, | ||
197 | { 0x800F0409, KEY_NUMERIC_9 }, | ||
198 | { 0x800F041D, KEY_NUMERIC_STAR }, | ||
199 | { 0x800F041C, KEY_NUMERIC_POUND }, | ||
200 | { 0x800F0410, KEY_VOLUMEUP }, | ||
201 | { 0x800F0411, KEY_VOLUMEDOWN }, | ||
202 | { 0x800F0412, KEY_CHANNELUP }, | ||
203 | { 0x800F0413, KEY_CHANNELDOWN }, | ||
204 | { 0x800F040E, KEY_MUTE }, | ||
205 | { 0x800F040D, KEY_VENDOR }, /* Vista Logo Key */ | ||
206 | { 0x800F041E, KEY_UP }, | ||
207 | { 0x800F041F, KEY_DOWN }, | ||
208 | { 0x800F0420, KEY_LEFT }, | ||
209 | { 0x800F0421, KEY_RIGHT }, | ||
210 | { 0x800F0422, KEY_OK }, | ||
211 | { 0x800F0423, KEY_ESC }, | ||
212 | { 0x800F040F, KEY_INFO }, | ||
213 | { 0x800F040A, KEY_CLEAR }, | ||
214 | { 0x800F040B, KEY_ENTER }, | ||
215 | { 0x800F045B, KEY_RED }, | ||
216 | { 0x800F045C, KEY_GREEN }, | ||
217 | { 0x800F045D, KEY_YELLOW }, | ||
218 | { 0x800F045E, KEY_BLUE }, | ||
219 | { 0x800F045A, KEY_TEXT }, | ||
220 | { 0x800F0427, KEY_SWITCHVIDEOMODE }, | ||
221 | { 0x800F040C, KEY_POWER }, | ||
222 | { 0x800F0450, KEY_RADIO }, | ||
223 | { 0x800F0448, KEY_PVR }, | ||
224 | { 0x800F0447, KEY_AUDIO }, | ||
225 | { 0x800F0426, KEY_EPG }, | ||
226 | { 0x800F0449, KEY_CAMERA }, | ||
227 | { 0x800F0425, KEY_TV }, | ||
228 | { 0x800F044A, KEY_VIDEO }, | ||
229 | { 0x800F0424, KEY_DVD }, | ||
230 | { 0x800F0416, KEY_PLAY }, | ||
231 | { 0x800F0418, KEY_PAUSE }, | ||
232 | { 0x800F0419, KEY_STOP }, | ||
233 | { 0x800F0414, KEY_FASTFORWARD }, | ||
234 | { 0x800F041A, KEY_NEXT }, | ||
235 | { 0x800F041B, KEY_PREVIOUS }, | ||
236 | { 0x800F0415, KEY_REWIND }, | ||
237 | { 0x800F0417, KEY_RECORD }, | ||
238 | }; | ||
239 | |||
240 | /* Registers and other state is protected by wbcir_lock */ | ||
241 | struct wbcir_data { | ||
242 | unsigned long wbase; /* Wake-Up Baseaddr */ | ||
243 | unsigned long ebase; /* Enhanced Func. Baseaddr */ | ||
244 | unsigned long sbase; /* Serial Port Baseaddr */ | ||
245 | unsigned int irq; /* Serial Port IRQ */ | ||
246 | |||
247 | struct input_dev *input_dev; | ||
248 | struct timer_list timer_keyup; | ||
249 | struct led_trigger *rxtrigger; | ||
250 | struct led_trigger *txtrigger; | ||
251 | struct led_classdev led; | ||
252 | |||
253 | u32 last_scancode; | ||
254 | unsigned int last_keycode; | ||
255 | u8 last_toggle; | ||
256 | u8 keypressed; | ||
257 | unsigned long keyup_jiffies; | ||
258 | unsigned int idle_count; | ||
259 | |||
260 | /* RX irdata and parsing state */ | ||
261 | unsigned long irdata[30]; | ||
262 | unsigned int irdata_count; | ||
263 | unsigned int irdata_idle; | ||
264 | unsigned int irdata_off; | ||
265 | unsigned int irdata_error; | ||
266 | |||
267 | /* Protected by keytable_lock */ | ||
268 | struct list_head keytable; | ||
269 | }; | ||
270 | |||
271 | static enum wbcir_protocol protocol = IR_PROTOCOL_RC6; | ||
272 | module_param(protocol, uint, 0444); | ||
273 | MODULE_PARM_DESC(protocol, "IR protocol to use " | ||
274 | "(0 = RC5, 1 = NEC, 2 = RC6A, default)"); | ||
275 | |||
276 | static int invert; /* default = 0 */ | ||
277 | module_param(invert, bool, 0444); | ||
278 | MODULE_PARM_DESC(invert, "Invert the signal from the IR receiver"); | ||
279 | |||
280 | static unsigned int wake_sc = 0x800F040C; | ||
281 | module_param(wake_sc, uint, 0644); | ||
282 | MODULE_PARM_DESC(wake_sc, "Scancode of the power-on IR command"); | ||
283 | |||
284 | static unsigned int wake_rc6mode = 6; | ||
285 | module_param(wake_rc6mode, uint, 0644); | ||
286 | MODULE_PARM_DESC(wake_rc6mode, "RC6 mode for the power-on command " | ||
287 | "(0 = 0, 6 = 6A, default)"); | ||
288 | |||
289 | |||
290 | |||
291 | /***************************************************************************** | ||
292 | * | ||
293 | * UTILITY FUNCTIONS | ||
294 | * | ||
295 | *****************************************************************************/ | ||
296 | |||
297 | /* Caller needs to hold wbcir_lock */ | ||
298 | static void | ||
299 | wbcir_set_bits(unsigned long addr, u8 bits, u8 mask) | ||
300 | { | ||
301 | u8 val; | ||
302 | |||
303 | val = inb(addr); | ||
304 | val = ((val & ~mask) | (bits & mask)); | ||
305 | outb(val, addr); | ||
306 | } | ||
307 | |||
308 | /* Selects the register bank for the serial port */ | ||
309 | static inline void | ||
310 | wbcir_select_bank(struct wbcir_data *data, enum wbcir_bank bank) | ||
311 | { | ||
312 | outb(bank, data->sbase + WBCIR_REG_SP3_BSR); | ||
313 | } | ||
314 | |||
315 | static enum led_brightness | ||
316 | wbcir_led_brightness_get(struct led_classdev *led_cdev) | ||
317 | { | ||
318 | struct wbcir_data *data = container_of(led_cdev, | ||
319 | struct wbcir_data, | ||
320 | led); | ||
321 | |||
322 | if (inb(data->ebase + WBCIR_REG_ECEIR_CTS) & WBCIR_LED_ENABLE) | ||
323 | return LED_FULL; | ||
324 | else | ||
325 | return LED_OFF; | ||
326 | } | ||
327 | |||
328 | static void | ||
329 | wbcir_led_brightness_set(struct led_classdev *led_cdev, | ||
330 | enum led_brightness brightness) | ||
331 | { | ||
332 | struct wbcir_data *data = container_of(led_cdev, | ||
333 | struct wbcir_data, | ||
334 | led); | ||
335 | |||
336 | wbcir_set_bits(data->ebase + WBCIR_REG_ECEIR_CTS, | ||
337 | brightness == LED_OFF ? 0x00 : WBCIR_LED_ENABLE, | ||
338 | WBCIR_LED_ENABLE); | ||
339 | } | ||
340 | |||
341 | /* Manchester encodes bits to RC6 message cells (see wbcir_parse_rc6) */ | ||
342 | static u8 | ||
343 | wbcir_to_rc6cells(u8 val) | ||
344 | { | ||
345 | u8 coded = 0x00; | ||
346 | int i; | ||
347 | |||
348 | val &= 0x0F; | ||
349 | for (i = 0; i < 4; i++) { | ||
350 | if (val & 0x01) | ||
351 | coded |= 0x02 << (i * 2); | ||
352 | else | ||
353 | coded |= 0x01 << (i * 2); | ||
354 | val >>= 1; | ||
355 | } | ||
356 | |||
357 | return coded; | ||
358 | } | ||
359 | |||
360 | |||
361 | |||
362 | /***************************************************************************** | ||
363 | * | ||
364 | * INPUT FUNCTIONS | ||
365 | * | ||
366 | *****************************************************************************/ | ||
367 | |||
368 | static unsigned int | ||
369 | wbcir_do_getkeycode(struct wbcir_data *data, u32 scancode) | ||
370 | { | ||
371 | struct wbcir_keyentry *keyentry; | ||
372 | unsigned int keycode = KEY_RESERVED; | ||
373 | unsigned long flags; | ||
374 | |||
375 | read_lock_irqsave(&keytable_lock, flags); | ||
376 | |||
377 | list_for_each_entry(keyentry, &data->keytable, list) { | ||
378 | if (keyentry->key.scancode == scancode) { | ||
379 | keycode = keyentry->key.keycode; | ||
380 | break; | ||
381 | } | ||
382 | } | ||
383 | |||
384 | read_unlock_irqrestore(&keytable_lock, flags); | ||
385 | return keycode; | ||
386 | } | ||
387 | |||
388 | static int | ||
389 | wbcir_getkeycode(struct input_dev *dev, | ||
390 | unsigned int scancode, unsigned int *keycode) | ||
391 | { | ||
392 | struct wbcir_data *data = input_get_drvdata(dev); | ||
393 | |||
394 | *keycode = wbcir_do_getkeycode(data, scancode); | ||
395 | return 0; | ||
396 | } | ||
397 | |||
398 | static int | ||
399 | wbcir_setkeycode(struct input_dev *dev, | ||
400 | unsigned int scancode, unsigned int keycode) | ||
401 | { | ||
402 | struct wbcir_data *data = input_get_drvdata(dev); | ||
403 | struct wbcir_keyentry *keyentry; | ||
404 | struct wbcir_keyentry *new_keyentry; | ||
405 | unsigned long flags; | ||
406 | unsigned int old_keycode = KEY_RESERVED; | ||
407 | |||
408 | new_keyentry = kmalloc(sizeof(*new_keyentry), GFP_KERNEL); | ||
409 | if (!new_keyentry) | ||
410 | return -ENOMEM; | ||
411 | |||
412 | write_lock_irqsave(&keytable_lock, flags); | ||
413 | |||
414 | list_for_each_entry(keyentry, &data->keytable, list) { | ||
415 | if (keyentry->key.scancode != scancode) | ||
416 | continue; | ||
417 | |||
418 | old_keycode = keyentry->key.keycode; | ||
419 | keyentry->key.keycode = keycode; | ||
420 | |||
421 | if (keyentry->key.keycode == KEY_RESERVED) { | ||
422 | list_del(&keyentry->list); | ||
423 | kfree(keyentry); | ||
424 | } | ||
425 | |||
426 | break; | ||
427 | } | ||
428 | |||
429 | set_bit(keycode, dev->keybit); | ||
430 | |||
431 | if (old_keycode == KEY_RESERVED) { | ||
432 | new_keyentry->key.scancode = scancode; | ||
433 | new_keyentry->key.keycode = keycode; | ||
434 | list_add(&new_keyentry->list, &data->keytable); | ||
435 | } else { | ||
436 | kfree(new_keyentry); | ||
437 | clear_bit(old_keycode, dev->keybit); | ||
438 | list_for_each_entry(keyentry, &data->keytable, list) { | ||
439 | if (keyentry->key.keycode == old_keycode) { | ||
440 | set_bit(old_keycode, dev->keybit); | ||
441 | break; | ||
442 | } | ||
443 | } | ||
444 | } | ||
445 | |||
446 | write_unlock_irqrestore(&keytable_lock, flags); | ||
447 | return 0; | ||
448 | } | ||
449 | |||
450 | /* | ||
451 | * Timer function to report keyup event some time after keydown is | ||
452 | * reported by the ISR. | ||
453 | */ | ||
454 | static void | ||
455 | wbcir_keyup(unsigned long cookie) | ||
456 | { | ||
457 | struct wbcir_data *data = (struct wbcir_data *)cookie; | ||
458 | unsigned long flags; | ||
459 | |||
460 | /* | ||
461 | * data->keyup_jiffies is used to prevent a race condition if a | ||
462 | * hardware interrupt occurs at this point and the keyup timer | ||
463 | * event is moved further into the future as a result. | ||
464 | * | ||
465 | * The timer will then be reactivated and this function called | ||
466 | * again in the future. We need to exit gracefully in that case | ||
467 | * to allow the input subsystem to do its auto-repeat magic or | ||
468 | * a keyup event might follow immediately after the keydown. | ||
469 | */ | ||
470 | |||
471 | spin_lock_irqsave(&wbcir_lock, flags); | ||
472 | |||
473 | if (time_is_after_eq_jiffies(data->keyup_jiffies) && data->keypressed) { | ||
474 | data->keypressed = 0; | ||
475 | led_trigger_event(data->rxtrigger, LED_OFF); | ||
476 | input_report_key(data->input_dev, data->last_keycode, 0); | ||
477 | input_sync(data->input_dev); | ||
478 | } | ||
479 | |||
480 | spin_unlock_irqrestore(&wbcir_lock, flags); | ||
481 | } | ||
482 | |||
483 | static void | ||
484 | wbcir_keydown(struct wbcir_data *data, u32 scancode, u8 toggle) | ||
485 | { | ||
486 | unsigned int keycode; | ||
487 | |||
488 | /* Repeat? */ | ||
489 | if (data->last_scancode == scancode && | ||
490 | data->last_toggle == toggle && | ||
491 | data->keypressed) | ||
492 | goto set_timer; | ||
493 | data->last_scancode = scancode; | ||
494 | |||
495 | /* Do we need to release an old keypress? */ | ||
496 | if (data->keypressed) { | ||
497 | input_report_key(data->input_dev, data->last_keycode, 0); | ||
498 | input_sync(data->input_dev); | ||
499 | data->keypressed = 0; | ||
500 | } | ||
501 | |||
502 | /* Report scancode */ | ||
503 | input_event(data->input_dev, EV_MSC, MSC_SCAN, (int)scancode); | ||
504 | |||
505 | /* Do we know this scancode? */ | ||
506 | keycode = wbcir_do_getkeycode(data, scancode); | ||
507 | if (keycode == KEY_RESERVED) | ||
508 | goto set_timer; | ||
509 | |||
510 | /* Register a keypress */ | ||
511 | input_report_key(data->input_dev, keycode, 1); | ||
512 | data->keypressed = 1; | ||
513 | data->last_keycode = keycode; | ||
514 | data->last_toggle = toggle; | ||
515 | |||
516 | set_timer: | ||
517 | input_sync(data->input_dev); | ||
518 | led_trigger_event(data->rxtrigger, | ||
519 | data->keypressed ? LED_FULL : LED_OFF); | ||
520 | data->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT); | ||
521 | mod_timer(&data->timer_keyup, data->keyup_jiffies); | ||
522 | } | ||
523 | |||
524 | |||
525 | |||
526 | /***************************************************************************** | ||
527 | * | ||
528 | * IR PARSING FUNCTIONS | ||
529 | * | ||
530 | *****************************************************************************/ | ||
531 | |||
532 | /* Resets all irdata */ | ||
533 | static void | ||
534 | wbcir_reset_irdata(struct wbcir_data *data) | ||
535 | { | ||
536 | memset(data->irdata, 0, sizeof(data->irdata)); | ||
537 | data->irdata_count = 0; | ||
538 | data->irdata_off = 0; | ||
539 | data->irdata_error = 0; | ||
540 | data->idle_count = 0; | ||
541 | } | ||
542 | |||
543 | /* Adds one bit of irdata */ | ||
544 | static void | ||
545 | add_irdata_bit(struct wbcir_data *data, int set) | ||
546 | { | ||
547 | if (data->irdata_count >= sizeof(data->irdata) * 8) { | ||
548 | data->irdata_error = 1; | ||
549 | return; | ||
550 | } | ||
551 | |||
552 | if (set) | ||
553 | __set_bit(data->irdata_count, data->irdata); | ||
554 | data->irdata_count++; | ||
555 | } | ||
556 | |||
557 | /* Gets count bits of irdata */ | ||
558 | static u16 | ||
559 | get_bits(struct wbcir_data *data, int count) | ||
560 | { | ||
561 | u16 val = 0x0; | ||
562 | |||
563 | if (data->irdata_count - data->irdata_off < count) { | ||
564 | data->irdata_error = 1; | ||
565 | return 0x0; | ||
566 | } | ||
567 | |||
568 | while (count > 0) { | ||
569 | val <<= 1; | ||
570 | if (test_bit(data->irdata_off, data->irdata)) | ||
571 | val |= 0x1; | ||
572 | count--; | ||
573 | data->irdata_off++; | ||
574 | } | ||
575 | |||
576 | return val; | ||
577 | } | ||
578 | |||
579 | /* Reads 16 cells and converts them to a byte */ | ||
580 | static u8 | ||
581 | wbcir_rc6cells_to_byte(struct wbcir_data *data) | ||
582 | { | ||
583 | u16 raw = get_bits(data, 16); | ||
584 | u8 val = 0x00; | ||
585 | int bit; | ||
586 | |||
587 | for (bit = 0; bit < 8; bit++) { | ||
588 | switch (raw & 0x03) { | ||
589 | case 0x01: | ||
590 | break; | ||
591 | case 0x02: | ||
592 | val |= (0x01 << bit); | ||
593 | break; | ||
594 | default: | ||
595 | data->irdata_error = 1; | ||
596 | break; | ||
597 | } | ||
598 | raw >>= 2; | ||
599 | } | ||
600 | |||
601 | return val; | ||
602 | } | ||
603 | |||
604 | /* Decodes a number of bits from raw RC5 data */ | ||
605 | static u8 | ||
606 | wbcir_get_rc5bits(struct wbcir_data *data, unsigned int count) | ||
607 | { | ||
608 | u16 raw = get_bits(data, count * 2); | ||
609 | u8 val = 0x00; | ||
610 | int bit; | ||
611 | |||
612 | for (bit = 0; bit < count; bit++) { | ||
613 | switch (raw & 0x03) { | ||
614 | case 0x01: | ||
615 | val |= (0x01 << bit); | ||
616 | break; | ||
617 | case 0x02: | ||
618 | break; | ||
619 | default: | ||
620 | data->irdata_error = 1; | ||
621 | break; | ||
622 | } | ||
623 | raw >>= 2; | ||
624 | } | ||
625 | |||
626 | return val; | ||
627 | } | ||
628 | |||
629 | static void | ||
630 | wbcir_parse_rc6(struct device *dev, struct wbcir_data *data) | ||
631 | { | ||
632 | /* | ||
633 | * Normal bits are manchester coded as follows: | ||
634 | * cell0 + cell1 = logic "0" | ||
635 | * cell1 + cell0 = logic "1" | ||
636 | * | ||
637 | * The IR pulse has the following components: | ||
638 | * | ||
639 | * Leader - 6 * cell1 - discarded | ||
640 | * Gap - 2 * cell0 - discarded | ||
641 | * Start bit - Normal Coding - always "1" | ||
642 | * Mode Bit 2 - 0 - Normal Coding | ||
643 | * Toggle bit - Normal Coding with double bit time, | ||
644 | * e.g. cell0 + cell0 + cell1 + cell1 | ||
645 | * means logic "0". | ||
646 | * | ||
647 | * The rest depends on the mode, the following modes are known: | ||
648 | * | ||
649 | * MODE 0: | ||
650 | * Address Bit 7 - 0 - Normal Coding | ||
651 | * Command Bit 7 - 0 - Normal Coding | ||
652 | * | ||
653 | * MODE 6: | ||
654 | * The above Toggle Bit is used as a submode bit, 0 = A, 1 = B. | ||
655 | * Submode B is for pointing devices, only remotes using submode A | ||
656 | * are supported. | ||
657 | * | ||
658 | * Customer range bit - 0 => Customer = 7 bits, 0...127 | ||
659 | * 1 => Customer = 15 bits, 32768...65535 | ||
660 | * Customer Bits - Normal Coding | ||
661 | * | ||
662 | * Customer codes are allocated by Philips. The rest of the bits | ||
663 | * are customer dependent. The following is commonly used (and the | ||
664 | * only supported config): | ||
665 | * | ||
666 | * Toggle Bit - Normal Coding | ||
667 | * Address Bit 6 - 0 - Normal Coding | ||
668 | * Command Bit 7 - 0 - Normal Coding | ||
669 | * | ||
670 | * All modes are followed by at least 6 * cell0. | ||
671 | * | ||
672 | * MODE 0 msglen: | ||
673 | * 1 * 2 (start bit) + 3 * 2 (mode) + 2 * 2 (toggle) + | ||
674 | * 8 * 2 (address) + 8 * 2 (command) = | ||
675 | * 44 cells | ||
676 | * | ||
677 | * MODE 6A msglen: | ||
678 | * 1 * 2 (start bit) + 3 * 2 (mode) + 2 * 2 (submode) + | ||
679 | * 1 * 2 (customer range bit) + 7/15 * 2 (customer bits) + | ||
680 | * 1 * 2 (toggle bit) + 7 * 2 (address) + 8 * 2 (command) = | ||
681 | * 60 - 76 cells | ||
682 | */ | ||
683 | u8 mode; | ||
684 | u8 toggle; | ||
685 | u16 customer = 0x0; | ||
686 | u8 address; | ||
687 | u8 command; | ||
688 | u32 scancode; | ||
689 | |||
690 | /* Leader mark */ | ||
691 | while (get_bits(data, 1) && !data->irdata_error) | ||
692 | /* Do nothing */; | ||
693 | |||
694 | /* Leader space */ | ||
695 | if (get_bits(data, 1)) { | ||
696 | dev_dbg(dev, "RC6 - Invalid leader space\n"); | ||
697 | return; | ||
698 | } | ||
699 | |||
700 | /* Start bit */ | ||
701 | if (get_bits(data, 2) != 0x02) { | ||
702 | dev_dbg(dev, "RC6 - Invalid start bit\n"); | ||
703 | return; | ||
704 | } | ||
705 | |||
706 | /* Mode */ | ||
707 | mode = get_bits(data, 6); | ||
708 | switch (mode) { | ||
709 | case 0x15: /* 010101 = b000 */ | ||
710 | mode = 0; | ||
711 | break; | ||
712 | case 0x29: /* 101001 = b110 */ | ||
713 | mode = 6; | ||
714 | break; | ||
715 | default: | ||
716 | dev_dbg(dev, "RC6 - Invalid mode\n"); | ||
717 | return; | ||
718 | } | ||
719 | |||
720 | /* Toggle bit / Submode bit */ | ||
721 | toggle = get_bits(data, 4); | ||
722 | switch (toggle) { | ||
723 | case 0x03: | ||
724 | toggle = 0; | ||
725 | break; | ||
726 | case 0x0C: | ||
727 | toggle = 1; | ||
728 | break; | ||
729 | default: | ||
730 | dev_dbg(dev, "RC6 - Toggle bit error\n"); | ||
731 | break; | ||
732 | } | ||
733 | |||
734 | /* Customer */ | ||
735 | if (mode == 6) { | ||
736 | if (toggle != 0) { | ||
737 | dev_dbg(dev, "RC6B - Not Supported\n"); | ||
738 | return; | ||
739 | } | ||
740 | |||
741 | customer = wbcir_rc6cells_to_byte(data); | ||
742 | |||
743 | if (customer & 0x80) { | ||
744 | /* 15 bit customer value */ | ||
745 | customer <<= 8; | ||
746 | customer |= wbcir_rc6cells_to_byte(data); | ||
747 | } | ||
748 | } | ||
749 | |||
750 | /* Address */ | ||
751 | address = wbcir_rc6cells_to_byte(data); | ||
752 | if (mode == 6) { | ||
753 | toggle = address >> 7; | ||
754 | address &= 0x7F; | ||
755 | } | ||
756 | |||
757 | /* Command */ | ||
758 | command = wbcir_rc6cells_to_byte(data); | ||
759 | |||
760 | /* Create scancode */ | ||
761 | scancode = command; | ||
762 | scancode |= address << 8; | ||
763 | scancode |= customer << 16; | ||
764 | |||
765 | /* Last sanity check */ | ||
766 | if (data->irdata_error) { | ||
767 | dev_dbg(dev, "RC6 - Cell error(s)\n"); | ||
768 | return; | ||
769 | } | ||
770 | |||
771 | dev_dbg(dev, "IR-RC6 ad 0x%02X cm 0x%02X cu 0x%04X " | ||
772 | "toggle %u mode %u scan 0x%08X\n", | ||
773 | address, | ||
774 | command, | ||
775 | customer, | ||
776 | (unsigned int)toggle, | ||
777 | (unsigned int)mode, | ||
778 | scancode); | ||
779 | |||
780 | wbcir_keydown(data, scancode, toggle); | ||
781 | } | ||
782 | |||
783 | static void | ||
784 | wbcir_parse_rc5(struct device *dev, struct wbcir_data *data) | ||
785 | { | ||
786 | /* | ||
787 | * Bits are manchester coded as follows: | ||
788 | * cell1 + cell0 = logic "0" | ||
789 | * cell0 + cell1 = logic "1" | ||
790 | * (i.e. the reverse of RC6) | ||
791 | * | ||
792 | * Start bit 1 - "1" - discarded | ||
793 | * Start bit 2 - Must be inverted to get command bit 6 | ||
794 | * Toggle bit | ||
795 | * Address Bit 4 - 0 | ||
796 | * Command Bit 5 - 0 | ||
797 | */ | ||
798 | u8 toggle; | ||
799 | u8 address; | ||
800 | u8 command; | ||
801 | u32 scancode; | ||
802 | |||
803 | /* Start bit 1 */ | ||
804 | if (!get_bits(data, 1)) { | ||
805 | dev_dbg(dev, "RC5 - Invalid start bit\n"); | ||
806 | return; | ||
807 | } | ||
808 | |||
809 | /* Start bit 2 */ | ||
810 | if (!wbcir_get_rc5bits(data, 1)) | ||
811 | command = 0x40; | ||
812 | else | ||
813 | command = 0x00; | ||
814 | |||
815 | toggle = wbcir_get_rc5bits(data, 1); | ||
816 | address = wbcir_get_rc5bits(data, 5); | ||
817 | command |= wbcir_get_rc5bits(data, 6); | ||
818 | scancode = address << 7 | command; | ||
819 | |||
820 | /* Last sanity check */ | ||
821 | if (data->irdata_error) { | ||
822 | dev_dbg(dev, "RC5 - Invalid message\n"); | ||
823 | return; | ||
824 | } | ||
825 | |||
826 | dev_dbg(dev, "IR-RC5 ad %u cm %u t %u s %u\n", | ||
827 | (unsigned int)address, | ||
828 | (unsigned int)command, | ||
829 | (unsigned int)toggle, | ||
830 | (unsigned int)scancode); | ||
831 | |||
832 | wbcir_keydown(data, scancode, toggle); | ||
833 | } | ||
834 | |||
835 | static void | ||
836 | wbcir_parse_nec(struct device *dev, struct wbcir_data *data) | ||
837 | { | ||
838 | /* | ||
839 | * Each bit represents 560 us. | ||
840 | * | ||
841 | * Leader - 9 ms burst | ||
842 | * Gap - 4.5 ms silence | ||
843 | * Address1 bit 0 - 7 - Address 1 | ||
844 | * Address2 bit 0 - 7 - Address 2 | ||
845 | * Command1 bit 0 - 7 - Command 1 | ||
846 | * Command2 bit 0 - 7 - Command 2 | ||
847 | * | ||
848 | * Note the bit order! | ||
849 | * | ||
850 | * With the old NEC protocol, Address2 was the inverse of Address1 | ||
851 | * and Command2 was the inverse of Command1 and were used as | ||
852 | * an error check. | ||
853 | * | ||
854 | * With NEC extended, Address1 is the LSB of the Address and | ||
855 | * Address2 is the MSB, Command parsing remains unchanged. | ||
856 | * | ||
857 | * A repeat message is coded as: | ||
858 | * Leader - 9 ms burst | ||
859 | * Gap - 2.25 ms silence | ||
860 | * Repeat - 560 us active | ||
861 | */ | ||
862 | u8 address1; | ||
863 | u8 address2; | ||
864 | u8 command1; | ||
865 | u8 command2; | ||
866 | u16 address; | ||
867 | u32 scancode; | ||
868 | |||
869 | /* Leader mark */ | ||
870 | while (get_bits(data, 1) && !data->irdata_error) | ||
871 | /* Do nothing */; | ||
872 | |||
873 | /* Leader space */ | ||
874 | if (get_bits(data, 4)) { | ||
875 | dev_dbg(dev, "NEC - Invalid leader space\n"); | ||
876 | return; | ||
877 | } | ||
878 | |||
879 | /* Repeat? */ | ||
880 | if (get_bits(data, 1)) { | ||
881 | if (!data->keypressed) { | ||
882 | dev_dbg(dev, "NEC - Stray repeat message\n"); | ||
883 | return; | ||
884 | } | ||
885 | |||
886 | dev_dbg(dev, "IR-NEC repeat s %u\n", | ||
887 | (unsigned int)data->last_scancode); | ||
888 | |||
889 | wbcir_keydown(data, data->last_scancode, data->last_toggle); | ||
890 | return; | ||
891 | } | ||
892 | |||
893 | /* Remaining leader space */ | ||
894 | if (get_bits(data, 3)) { | ||
895 | dev_dbg(dev, "NEC - Invalid leader space\n"); | ||
896 | return; | ||
897 | } | ||
898 | |||
899 | address1 = bitrev8(get_bits(data, 8)); | ||
900 | address2 = bitrev8(get_bits(data, 8)); | ||
901 | command1 = bitrev8(get_bits(data, 8)); | ||
902 | command2 = bitrev8(get_bits(data, 8)); | ||
903 | |||
904 | /* Sanity check */ | ||
905 | if (data->irdata_error) { | ||
906 | dev_dbg(dev, "NEC - Invalid message\n"); | ||
907 | return; | ||
908 | } | ||
909 | |||
910 | /* Check command validity */ | ||
911 | if (command1 != ~command2) { | ||
912 | dev_dbg(dev, "NEC - Command bytes mismatch\n"); | ||
913 | return; | ||
914 | } | ||
915 | |||
916 | /* Check for extended NEC protocol */ | ||
917 | address = address1; | ||
918 | if (address1 != ~address2) | ||
919 | address |= address2 << 8; | ||
920 | |||
921 | scancode = address << 8 | command1; | ||
922 | |||
923 | dev_dbg(dev, "IR-NEC ad %u cm %u s %u\n", | ||
924 | (unsigned int)address, | ||
925 | (unsigned int)command1, | ||
926 | (unsigned int)scancode); | ||
927 | |||
928 | wbcir_keydown(data, scancode, !data->last_toggle); | ||
929 | } | ||
930 | |||
931 | |||
932 | |||
933 | /***************************************************************************** | ||
934 | * | ||
935 | * INTERRUPT FUNCTIONS | ||
936 | * | ||
937 | *****************************************************************************/ | ||
938 | |||
939 | static irqreturn_t | ||
940 | wbcir_irq_handler(int irqno, void *cookie) | ||
941 | { | ||
942 | struct pnp_dev *device = cookie; | ||
943 | struct wbcir_data *data = pnp_get_drvdata(device); | ||
944 | struct device *dev = &device->dev; | ||
945 | u8 status; | ||
946 | unsigned long flags; | ||
947 | u8 irdata[8]; | ||
948 | int i; | ||
949 | unsigned int hw; | ||
950 | |||
951 | spin_lock_irqsave(&wbcir_lock, flags); | ||
952 | |||
953 | wbcir_select_bank(data, WBCIR_BANK_0); | ||
954 | |||
955 | status = inb(data->sbase + WBCIR_REG_SP3_EIR); | ||
956 | |||
957 | if (!(status & (WBCIR_IRQ_RX | WBCIR_IRQ_ERR))) { | ||
958 | spin_unlock_irqrestore(&wbcir_lock, flags); | ||
959 | return IRQ_NONE; | ||
960 | } | ||
961 | |||
962 | if (status & WBCIR_IRQ_ERR) | ||
963 | data->irdata_error = 1; | ||
964 | |||
965 | if (!(status & WBCIR_IRQ_RX)) | ||
966 | goto out; | ||
967 | |||
968 | /* Since RXHDLEV is set, at least 8 bytes are in the FIFO */ | ||
969 | insb(data->sbase + WBCIR_REG_SP3_RXDATA, &irdata[0], 8); | ||
970 | |||
971 | for (i = 0; i < sizeof(irdata); i++) { | ||
972 | hw = hweight8(irdata[i]); | ||
973 | if (hw > 4) | ||
974 | add_irdata_bit(data, 0); | ||
975 | else | ||
976 | add_irdata_bit(data, 1); | ||
977 | |||
978 | if (hw == 8) | ||
979 | data->idle_count++; | ||
980 | else | ||
981 | data->idle_count = 0; | ||
982 | } | ||
983 | |||
984 | if (data->idle_count > WBCIR_MAX_IDLE_BYTES) { | ||
985 | /* Set RXINACTIVE... */ | ||
986 | outb(WBCIR_RX_DISABLE, data->sbase + WBCIR_REG_SP3_ASCR); | ||
987 | |||
988 | /* ...and drain the FIFO */ | ||
989 | while (inb(data->sbase + WBCIR_REG_SP3_LSR) & WBCIR_RX_AVAIL) | ||
990 | inb(data->sbase + WBCIR_REG_SP3_RXDATA); | ||
991 | |||
992 | dev_dbg(dev, "IRDATA:\n"); | ||
993 | for (i = 0; i < data->irdata_count; i += BITS_PER_LONG) | ||
994 | dev_dbg(dev, "0x%08lX\n", data->irdata[i/BITS_PER_LONG]); | ||
995 | |||
996 | switch (protocol) { | ||
997 | case IR_PROTOCOL_RC5: | ||
998 | wbcir_parse_rc5(dev, data); | ||
999 | break; | ||
1000 | case IR_PROTOCOL_RC6: | ||
1001 | wbcir_parse_rc6(dev, data); | ||
1002 | break; | ||
1003 | case IR_PROTOCOL_NEC: | ||
1004 | wbcir_parse_nec(dev, data); | ||
1005 | break; | ||
1006 | } | ||
1007 | |||
1008 | wbcir_reset_irdata(data); | ||
1009 | } | ||
1010 | |||
1011 | out: | ||
1012 | spin_unlock_irqrestore(&wbcir_lock, flags); | ||
1013 | return IRQ_HANDLED; | ||
1014 | } | ||
1015 | |||
1016 | |||
1017 | |||
1018 | /***************************************************************************** | ||
1019 | * | ||
1020 | * SETUP/INIT/SUSPEND/RESUME FUNCTIONS | ||
1021 | * | ||
1022 | *****************************************************************************/ | ||
1023 | |||
1024 | static void | ||
1025 | wbcir_shutdown(struct pnp_dev *device) | ||
1026 | { | ||
1027 | struct device *dev = &device->dev; | ||
1028 | struct wbcir_data *data = pnp_get_drvdata(device); | ||
1029 | int do_wake = 1; | ||
1030 | u8 match[11]; | ||
1031 | u8 mask[11]; | ||
1032 | u8 rc6_csl = 0; | ||
1033 | int i; | ||
1034 | |||
1035 | memset(match, 0, sizeof(match)); | ||
1036 | memset(mask, 0, sizeof(mask)); | ||
1037 | |||
1038 | if (wake_sc == INVALID_SCANCODE || !device_may_wakeup(dev)) { | ||
1039 | do_wake = 0; | ||
1040 | goto finish; | ||
1041 | } | ||
1042 | |||
1043 | switch (protocol) { | ||
1044 | case IR_PROTOCOL_RC5: | ||
1045 | if (wake_sc > 0xFFF) { | ||
1046 | do_wake = 0; | ||
1047 | dev_err(dev, "RC5 - Invalid wake scancode\n"); | ||
1048 | break; | ||
1049 | } | ||
1050 | |||
1051 | /* Mask = 13 bits, ex toggle */ | ||
1052 | mask[0] = 0xFF; | ||
1053 | mask[1] = 0x17; | ||
1054 | |||
1055 | match[0] = (wake_sc & 0x003F); /* 6 command bits */ | ||
1056 | match[0] |= (wake_sc & 0x0180) >> 1; /* 2 address bits */ | ||
1057 | match[1] = (wake_sc & 0x0E00) >> 9; /* 3 address bits */ | ||
1058 | if (!(wake_sc & 0x0040)) /* 2nd start bit */ | ||
1059 | match[1] |= 0x10; | ||
1060 | |||
1061 | break; | ||
1062 | |||
1063 | case IR_PROTOCOL_NEC: | ||
1064 | if (wake_sc > 0xFFFFFF) { | ||
1065 | do_wake = 0; | ||
1066 | dev_err(dev, "NEC - Invalid wake scancode\n"); | ||
1067 | break; | ||
1068 | } | ||
1069 | |||
1070 | mask[0] = mask[1] = mask[2] = mask[3] = 0xFF; | ||
1071 | |||
1072 | match[1] = bitrev8((wake_sc & 0xFF)); | ||
1073 | match[0] = ~match[1]; | ||
1074 | |||
1075 | match[3] = bitrev8((wake_sc & 0xFF00) >> 8); | ||
1076 | if (wake_sc > 0xFFFF) | ||
1077 | match[2] = bitrev8((wake_sc & 0xFF0000) >> 16); | ||
1078 | else | ||
1079 | match[2] = ~match[3]; | ||
1080 | |||
1081 | break; | ||
1082 | |||
1083 | case IR_PROTOCOL_RC6: | ||
1084 | |||
1085 | if (wake_rc6mode == 0) { | ||
1086 | if (wake_sc > 0xFFFF) { | ||
1087 | do_wake = 0; | ||
1088 | dev_err(dev, "RC6 - Invalid wake scancode\n"); | ||
1089 | break; | ||
1090 | } | ||
1091 | |||
1092 | /* Command */ | ||
1093 | match[0] = wbcir_to_rc6cells(wake_sc >> 0); | ||
1094 | mask[0] = 0xFF; | ||
1095 | match[1] = wbcir_to_rc6cells(wake_sc >> 4); | ||
1096 | mask[1] = 0xFF; | ||
1097 | |||
1098 | /* Address */ | ||
1099 | match[2] = wbcir_to_rc6cells(wake_sc >> 8); | ||
1100 | mask[2] = 0xFF; | ||
1101 | match[3] = wbcir_to_rc6cells(wake_sc >> 12); | ||
1102 | mask[3] = 0xFF; | ||
1103 | |||
1104 | /* Header */ | ||
1105 | match[4] = 0x50; /* mode1 = mode0 = 0, ignore toggle */ | ||
1106 | mask[4] = 0xF0; | ||
1107 | match[5] = 0x09; /* start bit = 1, mode2 = 0 */ | ||
1108 | mask[5] = 0x0F; | ||
1109 | |||
1110 | rc6_csl = 44; | ||
1111 | |||
1112 | } else if (wake_rc6mode == 6) { | ||
1113 | i = 0; | ||
1114 | |||
1115 | /* Command */ | ||
1116 | match[i] = wbcir_to_rc6cells(wake_sc >> 0); | ||
1117 | mask[i++] = 0xFF; | ||
1118 | match[i] = wbcir_to_rc6cells(wake_sc >> 4); | ||
1119 | mask[i++] = 0xFF; | ||
1120 | |||
1121 | /* Address + Toggle */ | ||
1122 | match[i] = wbcir_to_rc6cells(wake_sc >> 8); | ||
1123 | mask[i++] = 0xFF; | ||
1124 | match[i] = wbcir_to_rc6cells(wake_sc >> 12); | ||
1125 | mask[i++] = 0x3F; | ||
1126 | |||
1127 | /* Customer bits 7 - 0 */ | ||
1128 | match[i] = wbcir_to_rc6cells(wake_sc >> 16); | ||
1129 | mask[i++] = 0xFF; | ||
1130 | match[i] = wbcir_to_rc6cells(wake_sc >> 20); | ||
1131 | mask[i++] = 0xFF; | ||
1132 | |||
1133 | if (wake_sc & 0x80000000) { | ||
1134 | /* Customer range bit and bits 15 - 8 */ | ||
1135 | match[i] = wbcir_to_rc6cells(wake_sc >> 24); | ||
1136 | mask[i++] = 0xFF; | ||
1137 | match[i] = wbcir_to_rc6cells(wake_sc >> 28); | ||
1138 | mask[i++] = 0xFF; | ||
1139 | rc6_csl = 76; | ||
1140 | } else if (wake_sc <= 0x007FFFFF) { | ||
1141 | rc6_csl = 60; | ||
1142 | } else { | ||
1143 | do_wake = 0; | ||
1144 | dev_err(dev, "RC6 - Invalid wake scancode\n"); | ||
1145 | break; | ||
1146 | } | ||
1147 | |||
1148 | /* Header */ | ||
1149 | match[i] = 0x93; /* mode1 = mode0 = 1, submode = 0 */ | ||
1150 | mask[i++] = 0xFF; | ||
1151 | match[i] = 0x0A; /* start bit = 1, mode2 = 1 */ | ||
1152 | mask[i++] = 0x0F; | ||
1153 | |||
1154 | } else { | ||
1155 | do_wake = 0; | ||
1156 | dev_err(dev, "RC6 - Invalid wake mode\n"); | ||
1157 | } | ||
1158 | |||
1159 | break; | ||
1160 | |||
1161 | default: | ||
1162 | do_wake = 0; | ||
1163 | break; | ||
1164 | } | ||
1165 | |||
1166 | finish: | ||
1167 | if (do_wake) { | ||
1168 | /* Set compare and compare mask */ | ||
1169 | wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_INDEX, | ||
1170 | WBCIR_REGSEL_COMPARE | WBCIR_REG_ADDR0, | ||
1171 | 0x3F); | ||
1172 | outsb(data->wbase + WBCIR_REG_WCEIR_DATA, match, 11); | ||
1173 | wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_INDEX, | ||
1174 | WBCIR_REGSEL_MASK | WBCIR_REG_ADDR0, | ||
1175 | 0x3F); | ||
1176 | outsb(data->wbase + WBCIR_REG_WCEIR_DATA, mask, 11); | ||
1177 | |||
1178 | /* RC6 Compare String Len */ | ||
1179 | outb(rc6_csl, data->wbase + WBCIR_REG_WCEIR_CSL); | ||
1180 | |||
1181 | /* Clear status bits NEC_REP, BUFF, MSG_END, MATCH */ | ||
1182 | wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_STS, 0x17, 0x17); | ||
1183 | |||
1184 | /* Clear BUFF_EN, Clear END_EN, Set MATCH_EN */ | ||
1185 | wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x01, 0x07); | ||
1186 | |||
1187 | /* Set CEIR_EN */ | ||
1188 | wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CTL, 0x01, 0x01); | ||
1189 | |||
1190 | } else { | ||
1191 | /* Clear BUFF_EN, Clear END_EN, Clear MATCH_EN */ | ||
1192 | wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x00, 0x07); | ||
1193 | |||
1194 | /* Clear CEIR_EN */ | ||
1195 | wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CTL, 0x00, 0x01); | ||
1196 | } | ||
1197 | |||
1198 | /* Disable interrupts */ | ||
1199 | wbcir_select_bank(data, WBCIR_BANK_0); | ||
1200 | outb(WBCIR_IRQ_NONE, data->sbase + WBCIR_REG_SP3_IER); | ||
1201 | |||
1202 | /* | ||
1203 | * ACPI will set the HW disable bit for SP3 which means that the | ||
1204 | * output signals are left in an undefined state which may cause | ||
1205 | * spurious interrupts which we need to ignore until the hardware | ||
1206 | * is reinitialized. | ||
1207 | */ | ||
1208 | disable_irq(data->irq); | ||
1209 | } | ||
1210 | |||
1211 | static int | ||
1212 | wbcir_suspend(struct pnp_dev *device, pm_message_t state) | ||
1213 | { | ||
1214 | wbcir_shutdown(device); | ||
1215 | return 0; | ||
1216 | } | ||
1217 | |||
1218 | static void | ||
1219 | wbcir_init_hw(struct wbcir_data *data) | ||
1220 | { | ||
1221 | u8 tmp; | ||
1222 | |||
1223 | /* Disable interrupts */ | ||
1224 | wbcir_select_bank(data, WBCIR_BANK_0); | ||
1225 | outb(WBCIR_IRQ_NONE, data->sbase + WBCIR_REG_SP3_IER); | ||
1226 | |||
1227 | /* Set PROT_SEL, RX_INV, Clear CEIR_EN (needed for the led) */ | ||
1228 | tmp = protocol << 4; | ||
1229 | if (invert) | ||
1230 | tmp |= 0x08; | ||
1231 | outb(tmp, data->wbase + WBCIR_REG_WCEIR_CTL); | ||
1232 | |||
1233 | /* Clear status bits NEC_REP, BUFF, MSG_END, MATCH */ | ||
1234 | wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_STS, 0x17, 0x17); | ||
1235 | |||
1236 | /* Clear BUFF_EN, Clear END_EN, Clear MATCH_EN */ | ||
1237 | wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x00, 0x07); | ||
1238 | |||
1239 | /* Set RC5 cell time to correspond to 36 kHz */ | ||
1240 | wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CFG1, 0x4A, 0x7F); | ||
1241 | |||
1242 | /* Set IRTX_INV */ | ||
1243 | if (invert) | ||
1244 | outb(0x04, data->ebase + WBCIR_REG_ECEIR_CCTL); | ||
1245 | else | ||
1246 | outb(0x00, data->ebase + WBCIR_REG_ECEIR_CCTL); | ||
1247 | |||
1248 | /* | ||
1249 | * Clear IR LED, set SP3 clock to 24Mhz | ||
1250 | * set SP3_IRRX_SW to binary 01, helpfully not documented | ||
1251 | */ | ||
1252 | outb(0x10, data->ebase + WBCIR_REG_ECEIR_CTS); | ||
1253 | |||
1254 | /* Enable extended mode */ | ||
1255 | wbcir_select_bank(data, WBCIR_BANK_2); | ||
1256 | outb(WBCIR_EXT_ENABLE, data->sbase + WBCIR_REG_SP3_EXCR1); | ||
1257 | |||
1258 | /* | ||
1259 | * Configure baud generator, IR data will be sampled at | ||
1260 | * a bitrate of: (24Mhz * prescaler) / (divisor * 16). | ||
1261 | * | ||
1262 | * The ECIR registers include a flag to change the | ||
1263 | * 24Mhz clock freq to 48Mhz. | ||
1264 | * | ||
1265 | * It's not documented in the specs, but fifo levels | ||
1266 | * other than 16 seems to be unsupported. | ||
1267 | */ | ||
1268 | |||
1269 | /* prescaler 1.0, tx/rx fifo lvl 16 */ | ||
1270 | outb(0x30, data->sbase + WBCIR_REG_SP3_EXCR2); | ||
1271 | |||
1272 | /* Set baud divisor to generate one byte per bit/cell */ | ||
1273 | switch (protocol) { | ||
1274 | case IR_PROTOCOL_RC5: | ||
1275 | outb(0xA7, data->sbase + WBCIR_REG_SP3_BGDL); | ||
1276 | break; | ||
1277 | case IR_PROTOCOL_RC6: | ||
1278 | outb(0x53, data->sbase + WBCIR_REG_SP3_BGDL); | ||
1279 | break; | ||
1280 | case IR_PROTOCOL_NEC: | ||
1281 | outb(0x69, data->sbase + WBCIR_REG_SP3_BGDL); | ||
1282 | break; | ||
1283 | } | ||
1284 | outb(0x00, data->sbase + WBCIR_REG_SP3_BGDH); | ||
1285 | |||
1286 | /* Set CEIR mode */ | ||
1287 | wbcir_select_bank(data, WBCIR_BANK_0); | ||
1288 | outb(0xC0, data->sbase + WBCIR_REG_SP3_MCR); | ||
1289 | inb(data->sbase + WBCIR_REG_SP3_LSR); /* Clear LSR */ | ||
1290 | inb(data->sbase + WBCIR_REG_SP3_MSR); /* Clear MSR */ | ||
1291 | |||
1292 | /* Disable RX demod, run-length encoding/decoding, set freq span */ | ||
1293 | wbcir_select_bank(data, WBCIR_BANK_7); | ||
1294 | outb(0x10, data->sbase + WBCIR_REG_SP3_RCCFG); | ||
1295 | |||
1296 | /* Disable timer */ | ||
1297 | wbcir_select_bank(data, WBCIR_BANK_4); | ||
1298 | outb(0x00, data->sbase + WBCIR_REG_SP3_IRCR1); | ||
1299 | |||
1300 | /* Enable MSR interrupt, Clear AUX_IRX */ | ||
1301 | wbcir_select_bank(data, WBCIR_BANK_5); | ||
1302 | outb(0x00, data->sbase + WBCIR_REG_SP3_IRCR2); | ||
1303 | |||
1304 | /* Disable CRC */ | ||
1305 | wbcir_select_bank(data, WBCIR_BANK_6); | ||
1306 | outb(0x20, data->sbase + WBCIR_REG_SP3_IRCR3); | ||
1307 | |||
1308 | /* Set RX/TX (de)modulation freq, not really used */ | ||
1309 | wbcir_select_bank(data, WBCIR_BANK_7); | ||
1310 | outb(0xF2, data->sbase + WBCIR_REG_SP3_IRRXDC); | ||
1311 | outb(0x69, data->sbase + WBCIR_REG_SP3_IRTXMC); | ||
1312 | |||
1313 | /* Set invert and pin direction */ | ||
1314 | if (invert) | ||
1315 | outb(0x10, data->sbase + WBCIR_REG_SP3_IRCFG4); | ||
1316 | else | ||
1317 | outb(0x00, data->sbase + WBCIR_REG_SP3_IRCFG4); | ||
1318 | |||
1319 | /* Set FIFO thresholds (RX = 8, TX = 3), reset RX/TX */ | ||
1320 | wbcir_select_bank(data, WBCIR_BANK_0); | ||
1321 | outb(0x97, data->sbase + WBCIR_REG_SP3_FCR); | ||
1322 | |||
1323 | /* Clear AUX status bits */ | ||
1324 | outb(0xE0, data->sbase + WBCIR_REG_SP3_ASCR); | ||
1325 | |||
1326 | /* Enable interrupts */ | ||
1327 | wbcir_reset_irdata(data); | ||
1328 | outb(WBCIR_IRQ_RX | WBCIR_IRQ_ERR, data->sbase + WBCIR_REG_SP3_IER); | ||
1329 | } | ||
1330 | |||
1331 | static int | ||
1332 | wbcir_resume(struct pnp_dev *device) | ||
1333 | { | ||
1334 | struct wbcir_data *data = pnp_get_drvdata(device); | ||
1335 | |||
1336 | wbcir_init_hw(data); | ||
1337 | enable_irq(data->irq); | ||
1338 | |||
1339 | return 0; | ||
1340 | } | ||
1341 | |||
1342 | static int __devinit | ||
1343 | wbcir_probe(struct pnp_dev *device, const struct pnp_device_id *dev_id) | ||
1344 | { | ||
1345 | struct device *dev = &device->dev; | ||
1346 | struct wbcir_data *data; | ||
1347 | int err; | ||
1348 | |||
1349 | if (!(pnp_port_len(device, 0) == EHFUNC_IOMEM_LEN && | ||
1350 | pnp_port_len(device, 1) == WAKEUP_IOMEM_LEN && | ||
1351 | pnp_port_len(device, 2) == SP_IOMEM_LEN)) { | ||
1352 | dev_err(dev, "Invalid resources\n"); | ||
1353 | return -ENODEV; | ||
1354 | } | ||
1355 | |||
1356 | data = kzalloc(sizeof(*data), GFP_KERNEL); | ||
1357 | if (!data) { | ||
1358 | err = -ENOMEM; | ||
1359 | goto exit; | ||
1360 | } | ||
1361 | |||
1362 | pnp_set_drvdata(device, data); | ||
1363 | |||
1364 | data->ebase = pnp_port_start(device, 0); | ||
1365 | data->wbase = pnp_port_start(device, 1); | ||
1366 | data->sbase = pnp_port_start(device, 2); | ||
1367 | data->irq = pnp_irq(device, 0); | ||
1368 | |||
1369 | if (data->wbase == 0 || data->ebase == 0 || | ||
1370 | data->sbase == 0 || data->irq == 0) { | ||
1371 | err = -ENODEV; | ||
1372 | dev_err(dev, "Invalid resources\n"); | ||
1373 | goto exit_free_data; | ||
1374 | } | ||
1375 | |||
1376 | dev_dbg(&device->dev, "Found device " | ||
1377 | "(w: 0x%lX, e: 0x%lX, s: 0x%lX, i: %u)\n", | ||
1378 | data->wbase, data->ebase, data->sbase, data->irq); | ||
1379 | |||
1380 | if (!request_region(data->wbase, WAKEUP_IOMEM_LEN, DRVNAME)) { | ||
1381 | dev_err(dev, "Region 0x%lx-0x%lx already in use!\n", | ||
1382 | data->wbase, data->wbase + WAKEUP_IOMEM_LEN - 1); | ||
1383 | err = -EBUSY; | ||
1384 | goto exit_free_data; | ||
1385 | } | ||
1386 | |||
1387 | if (!request_region(data->ebase, EHFUNC_IOMEM_LEN, DRVNAME)) { | ||
1388 | dev_err(dev, "Region 0x%lx-0x%lx already in use!\n", | ||
1389 | data->ebase, data->ebase + EHFUNC_IOMEM_LEN - 1); | ||
1390 | err = -EBUSY; | ||
1391 | goto exit_release_wbase; | ||
1392 | } | ||
1393 | |||
1394 | if (!request_region(data->sbase, SP_IOMEM_LEN, DRVNAME)) { | ||
1395 | dev_err(dev, "Region 0x%lx-0x%lx already in use!\n", | ||
1396 | data->sbase, data->sbase + SP_IOMEM_LEN - 1); | ||
1397 | err = -EBUSY; | ||
1398 | goto exit_release_ebase; | ||
1399 | } | ||
1400 | |||
1401 | err = request_irq(data->irq, wbcir_irq_handler, | ||
1402 | IRQF_DISABLED, DRVNAME, device); | ||
1403 | if (err) { | ||
1404 | dev_err(dev, "Failed to claim IRQ %u\n", data->irq); | ||
1405 | err = -EBUSY; | ||
1406 | goto exit_release_sbase; | ||
1407 | } | ||
1408 | |||
1409 | led_trigger_register_simple("cir-tx", &data->txtrigger); | ||
1410 | if (!data->txtrigger) { | ||
1411 | err = -ENOMEM; | ||
1412 | goto exit_free_irq; | ||
1413 | } | ||
1414 | |||
1415 | led_trigger_register_simple("cir-rx", &data->rxtrigger); | ||
1416 | if (!data->rxtrigger) { | ||
1417 | err = -ENOMEM; | ||
1418 | goto exit_unregister_txtrigger; | ||
1419 | } | ||
1420 | |||
1421 | data->led.name = "cir::activity"; | ||
1422 | data->led.default_trigger = "cir-rx"; | ||
1423 | data->led.brightness_set = wbcir_led_brightness_set; | ||
1424 | data->led.brightness_get = wbcir_led_brightness_get; | ||
1425 | err = led_classdev_register(&device->dev, &data->led); | ||
1426 | if (err) | ||
1427 | goto exit_unregister_rxtrigger; | ||
1428 | |||
1429 | data->input_dev = input_allocate_device(); | ||
1430 | if (!data->input_dev) { | ||
1431 | err = -ENOMEM; | ||
1432 | goto exit_unregister_led; | ||
1433 | } | ||
1434 | |||
1435 | data->input_dev->evbit[0] = BIT(EV_KEY); | ||
1436 | data->input_dev->name = WBCIR_NAME; | ||
1437 | data->input_dev->phys = "wbcir/cir0"; | ||
1438 | data->input_dev->id.bustype = BUS_HOST; | ||
1439 | data->input_dev->id.vendor = PCI_VENDOR_ID_WINBOND; | ||
1440 | data->input_dev->id.product = WBCIR_ID_FAMILY; | ||
1441 | data->input_dev->id.version = WBCIR_ID_CHIP; | ||
1442 | data->input_dev->getkeycode = wbcir_getkeycode; | ||
1443 | data->input_dev->setkeycode = wbcir_setkeycode; | ||
1444 | input_set_capability(data->input_dev, EV_MSC, MSC_SCAN); | ||
1445 | input_set_drvdata(data->input_dev, data); | ||
1446 | |||
1447 | err = input_register_device(data->input_dev); | ||
1448 | if (err) | ||
1449 | goto exit_free_input; | ||
1450 | |||
1451 | data->last_scancode = INVALID_SCANCODE; | ||
1452 | INIT_LIST_HEAD(&data->keytable); | ||
1453 | setup_timer(&data->timer_keyup, wbcir_keyup, (unsigned long)data); | ||
1454 | |||
1455 | /* Load default keymaps */ | ||
1456 | if (protocol == IR_PROTOCOL_RC6) { | ||
1457 | int i; | ||
1458 | for (i = 0; i < ARRAY_SIZE(rc6_def_keymap); i++) { | ||
1459 | err = wbcir_setkeycode(data->input_dev, | ||
1460 | (int)rc6_def_keymap[i].scancode, | ||
1461 | (int)rc6_def_keymap[i].keycode); | ||
1462 | if (err) | ||
1463 | goto exit_unregister_keys; | ||
1464 | } | ||
1465 | } | ||
1466 | |||
1467 | device_init_wakeup(&device->dev, 1); | ||
1468 | |||
1469 | wbcir_init_hw(data); | ||
1470 | |||
1471 | return 0; | ||
1472 | |||
1473 | exit_unregister_keys: | ||
1474 | if (!list_empty(&data->keytable)) { | ||
1475 | struct wbcir_keyentry *key; | ||
1476 | struct wbcir_keyentry *keytmp; | ||
1477 | |||
1478 | list_for_each_entry_safe(key, keytmp, &data->keytable, list) { | ||
1479 | list_del(&key->list); | ||
1480 | kfree(key); | ||
1481 | } | ||
1482 | } | ||
1483 | input_unregister_device(data->input_dev); | ||
1484 | /* Can't call input_free_device on an unregistered device */ | ||
1485 | data->input_dev = NULL; | ||
1486 | exit_free_input: | ||
1487 | input_free_device(data->input_dev); | ||
1488 | exit_unregister_led: | ||
1489 | led_classdev_unregister(&data->led); | ||
1490 | exit_unregister_rxtrigger: | ||
1491 | led_trigger_unregister_simple(data->rxtrigger); | ||
1492 | exit_unregister_txtrigger: | ||
1493 | led_trigger_unregister_simple(data->txtrigger); | ||
1494 | exit_free_irq: | ||
1495 | free_irq(data->irq, device); | ||
1496 | exit_release_sbase: | ||
1497 | release_region(data->sbase, SP_IOMEM_LEN); | ||
1498 | exit_release_ebase: | ||
1499 | release_region(data->ebase, EHFUNC_IOMEM_LEN); | ||
1500 | exit_release_wbase: | ||
1501 | release_region(data->wbase, WAKEUP_IOMEM_LEN); | ||
1502 | exit_free_data: | ||
1503 | kfree(data); | ||
1504 | pnp_set_drvdata(device, NULL); | ||
1505 | exit: | ||
1506 | return err; | ||
1507 | } | ||
1508 | |||
1509 | static void __devexit | ||
1510 | wbcir_remove(struct pnp_dev *device) | ||
1511 | { | ||
1512 | struct wbcir_data *data = pnp_get_drvdata(device); | ||
1513 | struct wbcir_keyentry *key; | ||
1514 | struct wbcir_keyentry *keytmp; | ||
1515 | |||
1516 | /* Disable interrupts */ | ||
1517 | wbcir_select_bank(data, WBCIR_BANK_0); | ||
1518 | outb(WBCIR_IRQ_NONE, data->sbase + WBCIR_REG_SP3_IER); | ||
1519 | |||
1520 | del_timer_sync(&data->timer_keyup); | ||
1521 | |||
1522 | free_irq(data->irq, device); | ||
1523 | |||
1524 | /* Clear status bits NEC_REP, BUFF, MSG_END, MATCH */ | ||
1525 | wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_STS, 0x17, 0x17); | ||
1526 | |||
1527 | /* Clear CEIR_EN */ | ||
1528 | wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CTL, 0x00, 0x01); | ||
1529 | |||
1530 | /* Clear BUFF_EN, END_EN, MATCH_EN */ | ||
1531 | wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x00, 0x07); | ||
1532 | |||
1533 | /* This will generate a keyup event if necessary */ | ||
1534 | input_unregister_device(data->input_dev); | ||
1535 | |||
1536 | led_trigger_unregister_simple(data->rxtrigger); | ||
1537 | led_trigger_unregister_simple(data->txtrigger); | ||
1538 | led_classdev_unregister(&data->led); | ||
1539 | |||
1540 | /* This is ok since &data->led isn't actually used */ | ||
1541 | wbcir_led_brightness_set(&data->led, LED_OFF); | ||
1542 | |||
1543 | release_region(data->wbase, WAKEUP_IOMEM_LEN); | ||
1544 | release_region(data->ebase, EHFUNC_IOMEM_LEN); | ||
1545 | release_region(data->sbase, SP_IOMEM_LEN); | ||
1546 | |||
1547 | list_for_each_entry_safe(key, keytmp, &data->keytable, list) { | ||
1548 | list_del(&key->list); | ||
1549 | kfree(key); | ||
1550 | } | ||
1551 | |||
1552 | kfree(data); | ||
1553 | |||
1554 | pnp_set_drvdata(device, NULL); | ||
1555 | } | ||
1556 | |||
1557 | static const struct pnp_device_id wbcir_ids[] = { | ||
1558 | { "WEC1022", 0 }, | ||
1559 | { "", 0 } | ||
1560 | }; | ||
1561 | MODULE_DEVICE_TABLE(pnp, wbcir_ids); | ||
1562 | |||
1563 | static struct pnp_driver wbcir_driver = { | ||
1564 | .name = WBCIR_NAME, | ||
1565 | .id_table = wbcir_ids, | ||
1566 | .probe = wbcir_probe, | ||
1567 | .remove = __devexit_p(wbcir_remove), | ||
1568 | .suspend = wbcir_suspend, | ||
1569 | .resume = wbcir_resume, | ||
1570 | .shutdown = wbcir_shutdown | ||
1571 | }; | ||
1572 | |||
1573 | static int __init | ||
1574 | wbcir_init(void) | ||
1575 | { | ||
1576 | int ret; | ||
1577 | |||
1578 | switch (protocol) { | ||
1579 | case IR_PROTOCOL_RC5: | ||
1580 | case IR_PROTOCOL_NEC: | ||
1581 | case IR_PROTOCOL_RC6: | ||
1582 | break; | ||
1583 | default: | ||
1584 | printk(KERN_ERR DRVNAME ": Invalid protocol argument\n"); | ||
1585 | return -EINVAL; | ||
1586 | } | ||
1587 | |||
1588 | ret = pnp_register_driver(&wbcir_driver); | ||
1589 | if (ret) | ||
1590 | printk(KERN_ERR DRVNAME ": Unable to register driver\n"); | ||
1591 | |||
1592 | return ret; | ||
1593 | } | ||
1594 | |||
1595 | static void __exit | ||
1596 | wbcir_exit(void) | ||
1597 | { | ||
1598 | pnp_unregister_driver(&wbcir_driver); | ||
1599 | } | ||
1600 | |||
1601 | MODULE_AUTHOR("David Härdeman <david@hardeman.nu>"); | ||
1602 | MODULE_DESCRIPTION("Winbond SuperI/O Consumer IR Driver"); | ||
1603 | MODULE_LICENSE("GPL"); | ||
1604 | |||
1605 | module_init(wbcir_init); | ||
1606 | module_exit(wbcir_exit); | ||
1607 | |||
1608 | |||
diff --git a/drivers/input/mouse/Kconfig b/drivers/input/mouse/Kconfig index bf5fd7f6a313..9c1e6ee83531 100644 --- a/drivers/input/mouse/Kconfig +++ b/drivers/input/mouse/Kconfig | |||
@@ -39,7 +39,7 @@ config MOUSE_PS2 | |||
39 | module will be called psmouse. | 39 | module will be called psmouse. |
40 | 40 | ||
41 | config MOUSE_PS2_ALPS | 41 | config MOUSE_PS2_ALPS |
42 | bool "ALPS PS/2 mouse protocol extension" if EMBEDDED | 42 | bool "ALPS PS/2 mouse protocol extension" if EXPERT |
43 | default y | 43 | default y |
44 | depends on MOUSE_PS2 | 44 | depends on MOUSE_PS2 |
45 | help | 45 | help |
@@ -49,7 +49,7 @@ config MOUSE_PS2_ALPS | |||
49 | If unsure, say Y. | 49 | If unsure, say Y. |
50 | 50 | ||
51 | config MOUSE_PS2_LOGIPS2PP | 51 | config MOUSE_PS2_LOGIPS2PP |
52 | bool "Logitech PS/2++ mouse protocol extension" if EMBEDDED | 52 | bool "Logitech PS/2++ mouse protocol extension" if EXPERT |
53 | default y | 53 | default y |
54 | depends on MOUSE_PS2 | 54 | depends on MOUSE_PS2 |
55 | help | 55 | help |
@@ -59,7 +59,7 @@ config MOUSE_PS2_LOGIPS2PP | |||
59 | If unsure, say Y. | 59 | If unsure, say Y. |
60 | 60 | ||
61 | config MOUSE_PS2_SYNAPTICS | 61 | config MOUSE_PS2_SYNAPTICS |
62 | bool "Synaptics PS/2 mouse protocol extension" if EMBEDDED | 62 | bool "Synaptics PS/2 mouse protocol extension" if EXPERT |
63 | default y | 63 | default y |
64 | depends on MOUSE_PS2 | 64 | depends on MOUSE_PS2 |
65 | help | 65 | help |
@@ -69,7 +69,7 @@ config MOUSE_PS2_SYNAPTICS | |||
69 | If unsure, say Y. | 69 | If unsure, say Y. |
70 | 70 | ||
71 | config MOUSE_PS2_LIFEBOOK | 71 | config MOUSE_PS2_LIFEBOOK |
72 | bool "Fujitsu Lifebook PS/2 mouse protocol extension" if EMBEDDED | 72 | bool "Fujitsu Lifebook PS/2 mouse protocol extension" if EXPERT |
73 | default y | 73 | default y |
74 | depends on MOUSE_PS2 && X86 && DMI | 74 | depends on MOUSE_PS2 && X86 && DMI |
75 | help | 75 | help |
@@ -79,7 +79,7 @@ config MOUSE_PS2_LIFEBOOK | |||
79 | If unsure, say Y. | 79 | If unsure, say Y. |
80 | 80 | ||
81 | config MOUSE_PS2_TRACKPOINT | 81 | config MOUSE_PS2_TRACKPOINT |
82 | bool "IBM Trackpoint PS/2 mouse protocol extension" if EMBEDDED | 82 | bool "IBM Trackpoint PS/2 mouse protocol extension" if EXPERT |
83 | default y | 83 | default y |
84 | depends on MOUSE_PS2 | 84 | depends on MOUSE_PS2 |
85 | help | 85 | help |
diff --git a/drivers/input/mouse/bcm5974.c b/drivers/input/mouse/bcm5974.c index b95231763911..ee82851afe3e 100644 --- a/drivers/input/mouse/bcm5974.c +++ b/drivers/input/mouse/bcm5974.c | |||
@@ -55,6 +55,14 @@ | |||
55 | #define USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI 0x0236 | 55 | #define USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI 0x0236 |
56 | #define USB_DEVICE_ID_APPLE_WELLSPRING3_ISO 0x0237 | 56 | #define USB_DEVICE_ID_APPLE_WELLSPRING3_ISO 0x0237 |
57 | #define USB_DEVICE_ID_APPLE_WELLSPRING3_JIS 0x0238 | 57 | #define USB_DEVICE_ID_APPLE_WELLSPRING3_JIS 0x0238 |
58 | /* MacbookAir3,2 (unibody), aka wellspring5 */ | ||
59 | #define USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI 0x023f | ||
60 | #define USB_DEVICE_ID_APPLE_WELLSPRING4_ISO 0x0240 | ||
61 | #define USB_DEVICE_ID_APPLE_WELLSPRING4_JIS 0x0241 | ||
62 | /* MacbookAir3,1 (unibody), aka wellspring4 */ | ||
63 | #define USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI 0x0242 | ||
64 | #define USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO 0x0243 | ||
65 | #define USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS 0x0244 | ||
58 | 66 | ||
59 | #define BCM5974_DEVICE(prod) { \ | 67 | #define BCM5974_DEVICE(prod) { \ |
60 | .match_flags = (USB_DEVICE_ID_MATCH_DEVICE | \ | 68 | .match_flags = (USB_DEVICE_ID_MATCH_DEVICE | \ |
@@ -80,6 +88,14 @@ static const struct usb_device_id bcm5974_table[] = { | |||
80 | BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI), | 88 | BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI), |
81 | BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING3_ISO), | 89 | BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING3_ISO), |
82 | BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING3_JIS), | 90 | BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING3_JIS), |
91 | /* MacbookAir3,2 */ | ||
92 | BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI), | ||
93 | BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4_ISO), | ||
94 | BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4_JIS), | ||
95 | /* MacbookAir3,1 */ | ||
96 | BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI), | ||
97 | BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO), | ||
98 | BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS), | ||
83 | /* Terminating entry */ | 99 | /* Terminating entry */ |
84 | {} | 100 | {} |
85 | }; | 101 | }; |
@@ -234,6 +250,30 @@ static const struct bcm5974_config bcm5974_config_table[] = { | |||
234 | { DIM_X, DIM_X / SN_COORD, -4460, 5166 }, | 250 | { DIM_X, DIM_X / SN_COORD, -4460, 5166 }, |
235 | { DIM_Y, DIM_Y / SN_COORD, -75, 6700 } | 251 | { DIM_Y, DIM_Y / SN_COORD, -75, 6700 } |
236 | }, | 252 | }, |
253 | { | ||
254 | USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI, | ||
255 | USB_DEVICE_ID_APPLE_WELLSPRING4_ISO, | ||
256 | USB_DEVICE_ID_APPLE_WELLSPRING4_JIS, | ||
257 | HAS_INTEGRATED_BUTTON, | ||
258 | 0x84, sizeof(struct bt_data), | ||
259 | 0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS, | ||
260 | { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 }, | ||
261 | { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 }, | ||
262 | { DIM_X, DIM_X / SN_COORD, -4620, 5140 }, | ||
263 | { DIM_Y, DIM_Y / SN_COORD, -150, 6600 } | ||
264 | }, | ||
265 | { | ||
266 | USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI, | ||
267 | USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO, | ||
268 | USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS, | ||
269 | HAS_INTEGRATED_BUTTON, | ||
270 | 0x84, sizeof(struct bt_data), | ||
271 | 0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS, | ||
272 | { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 }, | ||
273 | { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 }, | ||
274 | { DIM_X, DIM_X / SN_COORD, -4616, 5112 }, | ||
275 | { DIM_Y, DIM_Y / SN_COORD, -142, 5234 } | ||
276 | }, | ||
237 | {} | 277 | {} |
238 | }; | 278 | }; |
239 | 279 | ||
diff --git a/drivers/input/serio/Kconfig b/drivers/input/serio/Kconfig index 6256233d2bfb..55f2c2293ec6 100644 --- a/drivers/input/serio/Kconfig +++ b/drivers/input/serio/Kconfig | |||
@@ -2,7 +2,7 @@ | |||
2 | # Input core configuration | 2 | # Input core configuration |
3 | # | 3 | # |
4 | config SERIO | 4 | config SERIO |
5 | tristate "Serial I/O support" if EMBEDDED || !X86 | 5 | tristate "Serial I/O support" if EXPERT || !X86 |
6 | default y | 6 | default y |
7 | help | 7 | help |
8 | Say Yes here if you have any input device that uses serial I/O to | 8 | Say Yes here if you have any input device that uses serial I/O to |
@@ -19,7 +19,7 @@ config SERIO | |||
19 | if SERIO | 19 | if SERIO |
20 | 20 | ||
21 | config SERIO_I8042 | 21 | config SERIO_I8042 |
22 | tristate "i8042 PC Keyboard controller" if EMBEDDED || !X86 | 22 | tristate "i8042 PC Keyboard controller" if EXPERT || !X86 |
23 | default y | 23 | default y |
24 | depends on !PARISC && (!ARM || ARCH_SHARK || FOOTBRIDGE_HOST) && \ | 24 | depends on !PARISC && (!ARM || ARCH_SHARK || FOOTBRIDGE_HOST) && \ |
25 | (!SUPERH || SH_CAYMAN) && !M68K && !BLACKFIN | 25 | (!SUPERH || SH_CAYMAN) && !M68K && !BLACKFIN |
@@ -168,7 +168,7 @@ config SERIO_MACEPS2 | |||
168 | module will be called maceps2. | 168 | module will be called maceps2. |
169 | 169 | ||
170 | config SERIO_LIBPS2 | 170 | config SERIO_LIBPS2 |
171 | tristate "PS/2 driver library" if EMBEDDED | 171 | tristate "PS/2 driver library" if EXPERT |
172 | depends on SERIO_I8042 || SERIO_I8042=n | 172 | depends on SERIO_I8042 || SERIO_I8042=n |
173 | help | 173 | help |
174 | Say Y here if you are using a driver for device connected | 174 | Say Y here if you are using a driver for device connected |
@@ -214,7 +214,6 @@ config SERIO_AMS_DELTA | |||
214 | tristate "Amstrad Delta (E3) mailboard support" | 214 | tristate "Amstrad Delta (E3) mailboard support" |
215 | depends on MACH_AMS_DELTA | 215 | depends on MACH_AMS_DELTA |
216 | default y | 216 | default y |
217 | select AMS_DELTA_FIQ | ||
218 | ---help--- | 217 | ---help--- |
219 | Say Y here if you have an E3 and want to use its mailboard, | 218 | Say Y here if you have an E3 and want to use its mailboard, |
220 | or any standard AT keyboard connected to the mailboard port. | 219 | or any standard AT keyboard connected to the mailboard port. |
@@ -230,7 +229,7 @@ config SERIO_PS2MULT | |||
230 | tristate "TQC PS/2 multiplexer" | 229 | tristate "TQC PS/2 multiplexer" |
231 | help | 230 | help |
232 | Say Y here if you have the PS/2 line multiplexer like the one | 231 | Say Y here if you have the PS/2 line multiplexer like the one |
233 | present on TQC boads. | 232 | present on TQC boards. |
234 | 233 | ||
235 | To compile this driver as a module, choose M here: the | 234 | To compile this driver as a module, choose M here: the |
236 | module will be called ps2mult. | 235 | module will be called ps2mult. |
diff --git a/drivers/input/serio/gscps2.c b/drivers/input/serio/gscps2.c index 3c287dd879d3..4225f5d6b15f 100644 --- a/drivers/input/serio/gscps2.c +++ b/drivers/input/serio/gscps2.c | |||
@@ -358,7 +358,7 @@ static int __devinit gscps2_probe(struct parisc_device *dev) | |||
358 | gscps2_reset(ps2port); | 358 | gscps2_reset(ps2port); |
359 | ps2port->id = readb(ps2port->addr + GSC_ID) & 0x0f; | 359 | ps2port->id = readb(ps2port->addr + GSC_ID) & 0x0f; |
360 | 360 | ||
361 | snprintf(serio->name, sizeof(serio->name), "GSC PS/2 %s", | 361 | snprintf(serio->name, sizeof(serio->name), "gsc-ps2-%s", |
362 | (ps2port->id == GSC_ID_KEYBOARD) ? "keyboard" : "mouse"); | 362 | (ps2port->id == GSC_ID_KEYBOARD) ? "keyboard" : "mouse"); |
363 | strlcpy(serio->phys, dev_name(&dev->dev), sizeof(serio->phys)); | 363 | strlcpy(serio->phys, dev_name(&dev->dev), sizeof(serio->phys)); |
364 | serio->id.type = SERIO_8042; | 364 | serio->id.type = SERIO_8042; |
diff --git a/drivers/input/serio/serio_raw.c b/drivers/input/serio/serio_raw.c index cd82bb125915..b7ba4597f7f0 100644 --- a/drivers/input/serio/serio_raw.c +++ b/drivers/input/serio/serio_raw.c | |||
@@ -11,7 +11,6 @@ | |||
11 | 11 | ||
12 | #include <linux/sched.h> | 12 | #include <linux/sched.h> |
13 | #include <linux/slab.h> | 13 | #include <linux/slab.h> |
14 | #include <linux/smp_lock.h> | ||
15 | #include <linux/poll.h> | 14 | #include <linux/poll.h> |
16 | #include <linux/module.h> | 15 | #include <linux/module.h> |
17 | #include <linux/serio.h> | 16 | #include <linux/serio.h> |
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig index 07ac77d393a4..61834ae282e1 100644 --- a/drivers/input/touchscreen/Kconfig +++ b/drivers/input/touchscreen/Kconfig | |||
@@ -540,62 +540,62 @@ config TOUCHSCREEN_MC13783 | |||
540 | 540 | ||
541 | config TOUCHSCREEN_USB_EGALAX | 541 | config TOUCHSCREEN_USB_EGALAX |
542 | default y | 542 | default y |
543 | bool "eGalax, eTurboTouch CT-410/510/700 device support" if EMBEDDED | 543 | bool "eGalax, eTurboTouch CT-410/510/700 device support" if EXPERT |
544 | depends on TOUCHSCREEN_USB_COMPOSITE | 544 | depends on TOUCHSCREEN_USB_COMPOSITE |
545 | 545 | ||
546 | config TOUCHSCREEN_USB_PANJIT | 546 | config TOUCHSCREEN_USB_PANJIT |
547 | default y | 547 | default y |
548 | bool "PanJit device support" if EMBEDDED | 548 | bool "PanJit device support" if EXPERT |
549 | depends on TOUCHSCREEN_USB_COMPOSITE | 549 | depends on TOUCHSCREEN_USB_COMPOSITE |
550 | 550 | ||
551 | config TOUCHSCREEN_USB_3M | 551 | config TOUCHSCREEN_USB_3M |
552 | default y | 552 | default y |
553 | bool "3M/Microtouch EX II series device support" if EMBEDDED | 553 | bool "3M/Microtouch EX II series device support" if EXPERT |
554 | depends on TOUCHSCREEN_USB_COMPOSITE | 554 | depends on TOUCHSCREEN_USB_COMPOSITE |
555 | 555 | ||
556 | config TOUCHSCREEN_USB_ITM | 556 | config TOUCHSCREEN_USB_ITM |
557 | default y | 557 | default y |
558 | bool "ITM device support" if EMBEDDED | 558 | bool "ITM device support" if EXPERT |
559 | depends on TOUCHSCREEN_USB_COMPOSITE | 559 | depends on TOUCHSCREEN_USB_COMPOSITE |
560 | 560 | ||
561 | config TOUCHSCREEN_USB_ETURBO | 561 | config TOUCHSCREEN_USB_ETURBO |
562 | default y | 562 | default y |
563 | bool "eTurboTouch (non-eGalax compatible) device support" if EMBEDDED | 563 | bool "eTurboTouch (non-eGalax compatible) device support" if EXPERT |
564 | depends on TOUCHSCREEN_USB_COMPOSITE | 564 | depends on TOUCHSCREEN_USB_COMPOSITE |
565 | 565 | ||
566 | config TOUCHSCREEN_USB_GUNZE | 566 | config TOUCHSCREEN_USB_GUNZE |
567 | default y | 567 | default y |
568 | bool "Gunze AHL61 device support" if EMBEDDED | 568 | bool "Gunze AHL61 device support" if EXPERT |
569 | depends on TOUCHSCREEN_USB_COMPOSITE | 569 | depends on TOUCHSCREEN_USB_COMPOSITE |
570 | 570 | ||
571 | config TOUCHSCREEN_USB_DMC_TSC10 | 571 | config TOUCHSCREEN_USB_DMC_TSC10 |
572 | default y | 572 | default y |
573 | bool "DMC TSC-10/25 device support" if EMBEDDED | 573 | bool "DMC TSC-10/25 device support" if EXPERT |
574 | depends on TOUCHSCREEN_USB_COMPOSITE | 574 | depends on TOUCHSCREEN_USB_COMPOSITE |
575 | 575 | ||
576 | config TOUCHSCREEN_USB_IRTOUCH | 576 | config TOUCHSCREEN_USB_IRTOUCH |
577 | default y | 577 | default y |
578 | bool "IRTOUCHSYSTEMS/UNITOP device support" if EMBEDDED | 578 | bool "IRTOUCHSYSTEMS/UNITOP device support" if EXPERT |
579 | depends on TOUCHSCREEN_USB_COMPOSITE | 579 | depends on TOUCHSCREEN_USB_COMPOSITE |
580 | 580 | ||
581 | config TOUCHSCREEN_USB_IDEALTEK | 581 | config TOUCHSCREEN_USB_IDEALTEK |
582 | default y | 582 | default y |
583 | bool "IdealTEK URTC1000 device support" if EMBEDDED | 583 | bool "IdealTEK URTC1000 device support" if EXPERT |
584 | depends on TOUCHSCREEN_USB_COMPOSITE | 584 | depends on TOUCHSCREEN_USB_COMPOSITE |
585 | 585 | ||
586 | config TOUCHSCREEN_USB_GENERAL_TOUCH | 586 | config TOUCHSCREEN_USB_GENERAL_TOUCH |
587 | default y | 587 | default y |
588 | bool "GeneralTouch Touchscreen device support" if EMBEDDED | 588 | bool "GeneralTouch Touchscreen device support" if EXPERT |
589 | depends on TOUCHSCREEN_USB_COMPOSITE | 589 | depends on TOUCHSCREEN_USB_COMPOSITE |
590 | 590 | ||
591 | config TOUCHSCREEN_USB_GOTOP | 591 | config TOUCHSCREEN_USB_GOTOP |
592 | default y | 592 | default y |
593 | bool "GoTop Super_Q2/GogoPen/PenPower tablet device support" if EMBEDDED | 593 | bool "GoTop Super_Q2/GogoPen/PenPower tablet device support" if EXPERT |
594 | depends on TOUCHSCREEN_USB_COMPOSITE | 594 | depends on TOUCHSCREEN_USB_COMPOSITE |
595 | 595 | ||
596 | config TOUCHSCREEN_USB_JASTEC | 596 | config TOUCHSCREEN_USB_JASTEC |
597 | default y | 597 | default y |
598 | bool "JASTEC/DigiTech DTR-02U USB touch controller device support" if EMBEDDED | 598 | bool "JASTEC/DigiTech DTR-02U USB touch controller device support" if EXPERT |
599 | depends on TOUCHSCREEN_USB_COMPOSITE | 599 | depends on TOUCHSCREEN_USB_COMPOSITE |
600 | 600 | ||
601 | config TOUCHSCREEN_USB_E2I | 601 | config TOUCHSCREEN_USB_E2I |
@@ -605,17 +605,17 @@ config TOUCHSCREEN_USB_E2I | |||
605 | 605 | ||
606 | config TOUCHSCREEN_USB_ZYTRONIC | 606 | config TOUCHSCREEN_USB_ZYTRONIC |
607 | default y | 607 | default y |
608 | bool "Zytronic controller" if EMBEDDED | 608 | bool "Zytronic controller" if EXPERT |
609 | depends on TOUCHSCREEN_USB_COMPOSITE | 609 | depends on TOUCHSCREEN_USB_COMPOSITE |
610 | 610 | ||
611 | config TOUCHSCREEN_USB_ETT_TC45USB | 611 | config TOUCHSCREEN_USB_ETT_TC45USB |
612 | default y | 612 | default y |
613 | bool "ET&T USB series TC4UM/TC5UH touchscreen controler support" if EMBEDDED | 613 | bool "ET&T USB series TC4UM/TC5UH touchscreen controller support" if EXPERT |
614 | depends on TOUCHSCREEN_USB_COMPOSITE | 614 | depends on TOUCHSCREEN_USB_COMPOSITE |
615 | 615 | ||
616 | config TOUCHSCREEN_USB_NEXIO | 616 | config TOUCHSCREEN_USB_NEXIO |
617 | default y | 617 | default y |
618 | bool "NEXIO/iNexio device support" if EMBEDDED | 618 | bool "NEXIO/iNexio device support" if EXPERT |
619 | depends on TOUCHSCREEN_USB_COMPOSITE | 619 | depends on TOUCHSCREEN_USB_COMPOSITE |
620 | 620 | ||
621 | config TOUCHSCREEN_TOUCHIT213 | 621 | config TOUCHSCREEN_TOUCHIT213 |