aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/input/misc
diff options
context:
space:
mode:
authorDmitry Torokhov <dmitry.torokhov@gmail.com>2011-11-29 04:51:07 -0500
committerDmitry Torokhov <dmitry.torokhov@gmail.com>2011-11-29 04:51:07 -0500
commit0d2cd91bf7b1a7cc1d638296111fcc2bcf5c0bb4 (patch)
treed2ca69347816c27f9dc352581f5d0fe76811cd49 /drivers/input/misc
parent3d95fd6ad8d3cf582a70ed65660017114b6e4065 (diff)
parentcaca6a03d365883564885f2c1da3e88dcf65d139 (diff)
Merge commit 'v3.2-rc3' into next
Diffstat (limited to 'drivers/input/misc')
-rw-r--r--drivers/input/misc/Kconfig26
-rw-r--r--drivers/input/misc/Makefile2
-rw-r--r--drivers/input/misc/ad714x.c1
-rw-r--r--drivers/input/misc/adxl34x.c1
-rw-r--r--drivers/input/misc/ati_remote.c867
-rw-r--r--drivers/input/misc/ati_remote2.c1
-rw-r--r--drivers/input/misc/cm109.c2
-rw-r--r--drivers/input/misc/cma3000_d0x.c1
-rw-r--r--drivers/input/misc/dm355evm_keys.c1
-rw-r--r--drivers/input/misc/mc13783-pwrbutton.c282
-rw-r--r--drivers/input/misc/rotary_encoder.c2
-rw-r--r--drivers/input/misc/twl6040-vibra.c21
12 files changed, 314 insertions, 893 deletions
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index a1aa35a053b7..22d875fde53a 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -134,6 +134,16 @@ config INPUT_MAX8925_ONKEY
134 To compile this driver as a module, choose M here: the module 134 To compile this driver as a module, choose M here: the module
135 will be called max8925_onkey. 135 will be called max8925_onkey.
136 136
137config INPUT_MC13783_PWRBUTTON
138 tristate "MC13783 ON buttons"
139 depends on MFD_MC13783
140 help
141 Support the ON buttons of MC13783 PMIC as an input device
142 reporting power button status.
143
144 To compile this driver as a module, choose M here: the module
145 will be called mc13783-pwrbutton.
146
137config INPUT_MMA8450 147config INPUT_MMA8450
138 tristate "MMA8450 - Freescale's 3-Axis, 8/12-bit Digital Accelerometer" 148 tristate "MMA8450 - Freescale's 3-Axis, 8/12-bit Digital Accelerometer"
139 depends on I2C 149 depends on I2C
@@ -217,22 +227,6 @@ config INPUT_ATLAS_BTNS
217 To compile this driver as a module, choose M here: the module will 227 To compile this driver as a module, choose M here: the module will
218 be called atlas_btns. 228 be called atlas_btns.
219 229
220config INPUT_ATI_REMOTE
221 tristate "ATI / X10 USB RF remote control"
222 depends on USB_ARCH_HAS_HCD
223 select USB
224 help
225 Say Y here if you want to use an ATI or X10 "Lola" USB remote control.
226 These are RF remotes with USB receivers.
227 The ATI remote comes with many of ATI's All-In-Wonder video cards.
228 The X10 "Lola" remote is available at:
229 <http://www.x10.com/products/lola_sg1.htm>
230 This driver provides mouse pointer, left and right mouse buttons,
231 and maps all the other remote buttons to keypress events.
232
233 To compile this driver as a module, choose M here: the module will be
234 called ati_remote.
235
236config INPUT_ATI_REMOTE2 230config INPUT_ATI_REMOTE2
237 tristate "ATI / Philips USB RF remote control" 231 tristate "ATI / Philips USB RF remote control"
238 depends on USB_ARCH_HAS_HCD 232 depends on USB_ARCH_HAS_HCD
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
index 53a8d0faad52..a244fc6a781c 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -13,7 +13,6 @@ obj-$(CONFIG_INPUT_ADXL34X) += adxl34x.o
13obj-$(CONFIG_INPUT_ADXL34X_I2C) += adxl34x-i2c.o 13obj-$(CONFIG_INPUT_ADXL34X_I2C) += adxl34x-i2c.o
14obj-$(CONFIG_INPUT_ADXL34X_SPI) += adxl34x-spi.o 14obj-$(CONFIG_INPUT_ADXL34X_SPI) += adxl34x-spi.o
15obj-$(CONFIG_INPUT_APANEL) += apanel.o 15obj-$(CONFIG_INPUT_APANEL) += apanel.o
16obj-$(CONFIG_INPUT_ATI_REMOTE) += ati_remote.o
17obj-$(CONFIG_INPUT_ATI_REMOTE2) += ati_remote2.o 16obj-$(CONFIG_INPUT_ATI_REMOTE2) += ati_remote2.o
18obj-$(CONFIG_INPUT_ATLAS_BTNS) += atlas_btns.o 17obj-$(CONFIG_INPUT_ATLAS_BTNS) += atlas_btns.o
19obj-$(CONFIG_INPUT_BFIN_ROTARY) += bfin_rotary.o 18obj-$(CONFIG_INPUT_BFIN_ROTARY) += bfin_rotary.o
@@ -29,6 +28,7 @@ obj-$(CONFIG_INPUT_KEYSPAN_REMOTE) += keyspan_remote.o
29obj-$(CONFIG_INPUT_KXTJ9) += kxtj9.o 28obj-$(CONFIG_INPUT_KXTJ9) += kxtj9.o
30obj-$(CONFIG_INPUT_M68K_BEEP) += m68kspkr.o 29obj-$(CONFIG_INPUT_M68K_BEEP) += m68kspkr.o
31obj-$(CONFIG_INPUT_MAX8925_ONKEY) += max8925_onkey.o 30obj-$(CONFIG_INPUT_MAX8925_ONKEY) += max8925_onkey.o
31obj-$(CONFIG_INPUT_MC13783_PWRBUTTON) += mc13783-pwrbutton.o
32obj-$(CONFIG_INPUT_MMA8450) += mma8450.o 32obj-$(CONFIG_INPUT_MMA8450) += mma8450.o
33obj-$(CONFIG_INPUT_MPU3050) += mpu3050.o 33obj-$(CONFIG_INPUT_MPU3050) += mpu3050.o
34obj-$(CONFIG_INPUT_PCAP) += pcap_keys.o 34obj-$(CONFIG_INPUT_PCAP) += pcap_keys.o
diff --git a/drivers/input/misc/ad714x.c b/drivers/input/misc/ad714x.c
index ca42c7d2a3c7..0ac75bbad4d6 100644
--- a/drivers/input/misc/ad714x.c
+++ b/drivers/input/misc/ad714x.c
@@ -12,6 +12,7 @@
12#include <linux/interrupt.h> 12#include <linux/interrupt.h>
13#include <linux/slab.h> 13#include <linux/slab.h>
14#include <linux/input/ad714x.h> 14#include <linux/input/ad714x.h>
15#include <linux/module.h>
15#include "ad714x.h" 16#include "ad714x.h"
16 17
17#define AD714X_PWR_CTRL 0x0 18#define AD714X_PWR_CTRL 0x0
diff --git a/drivers/input/misc/adxl34x.c b/drivers/input/misc/adxl34x.c
index 87918592993c..1cf72fe513e6 100644
--- a/drivers/input/misc/adxl34x.c
+++ b/drivers/input/misc/adxl34x.c
@@ -16,6 +16,7 @@
16#include <linux/slab.h> 16#include <linux/slab.h>
17#include <linux/workqueue.h> 17#include <linux/workqueue.h>
18#include <linux/input/adxl34x.h> 18#include <linux/input/adxl34x.h>
19#include <linux/module.h>
19 20
20#include "adxl34x.h" 21#include "adxl34x.h"
21 22
diff --git a/drivers/input/misc/ati_remote.c b/drivers/input/misc/ati_remote.c
deleted file mode 100644
index bce57129afba..000000000000
--- a/drivers/input/misc/ati_remote.c
+++ /dev/null
@@ -1,867 +0,0 @@
1/*
2 * USB ATI Remote support
3 *
4 * Version 2.2.0 Copyright (c) 2004 Torrey Hoffman <thoffman@arnor.net>
5 * Version 2.1.1 Copyright (c) 2002 Vladimir Dergachev
6 *
7 * This 2.2.0 version is a rewrite / cleanup of the 2.1.1 driver, including
8 * porting to the 2.6 kernel interfaces, along with other modification
9 * to better match the style of the existing usb/input drivers. However, the
10 * protocol and hardware handling is essentially unchanged from 2.1.1.
11 *
12 * The 2.1.1 driver was derived from the usbati_remote and usbkbd drivers by
13 * Vojtech Pavlik.
14 *
15 * Changes:
16 *
17 * Feb 2004: Torrey Hoffman <thoffman@arnor.net>
18 * Version 2.2.0
19 * Jun 2004: Torrey Hoffman <thoffman@arnor.net>
20 * Version 2.2.1
21 * Added key repeat support contributed by:
22 * Vincent Vanackere <vanackere@lif.univ-mrs.fr>
23 * Added support for the "Lola" remote contributed by:
24 * Seth Cohn <sethcohn@yahoo.com>
25 *
26 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
27 *
28 * This program is free software; you can redistribute it and/or modify
29 * it under the terms of the GNU General Public License as published by
30 * the Free Software Foundation; either version 2 of the License, or
31 * (at your option) any later version.
32 *
33 * This program is distributed in the hope that it will be useful,
34 * but WITHOUT ANY WARRANTY; without even the implied warranty of
35 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
36 * GNU General Public License for more details.
37 *
38 * You should have received a copy of the GNU General Public License
39 * along with this program; if not, write to the Free Software
40 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
41 *
42 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
43 *
44 * Hardware & software notes
45 *
46 * These remote controls are distributed by ATI as part of their
47 * "All-In-Wonder" video card packages. The receiver self-identifies as a
48 * "USB Receiver" with manufacturer "X10 Wireless Technology Inc".
49 *
50 * The "Lola" remote is available from X10. See:
51 * http://www.x10.com/products/lola_sg1.htm
52 * The Lola is similar to the ATI remote but has no mouse support, and slightly
53 * different keys.
54 *
55 * It is possible to use multiple receivers and remotes on multiple computers
56 * simultaneously by configuring them to use specific channels.
57 *
58 * The RF protocol used by the remote supports 16 distinct channels, 1 to 16.
59 * Actually, it may even support more, at least in some revisions of the
60 * hardware.
61 *
62 * Each remote can be configured to transmit on one channel as follows:
63 * - Press and hold the "hand icon" button.
64 * - When the red LED starts to blink, let go of the "hand icon" button.
65 * - When it stops blinking, input the channel code as two digits, from 01
66 * to 16, and press the hand icon again.
67 *
68 * The timing can be a little tricky. Try loading the module with debug=1
69 * to have the kernel print out messages about the remote control number
70 * and mask. Note: debugging prints remote numbers as zero-based hexadecimal.
71 *
72 * The driver has a "channel_mask" parameter. This bitmask specifies which
73 * channels will be ignored by the module. To mask out channels, just add
74 * all the 2^channel_number values together.
75 *
76 * For instance, set channel_mask = 2^4 = 16 (binary 10000) to make ati_remote
77 * ignore signals coming from remote controls transmitting on channel 4, but
78 * accept all other channels.
79 *
80 * Or, set channel_mask = 65533, (0xFFFD), and all channels except 1 will be
81 * ignored.
82 *
83 * The default is 0 (respond to all channels). Bit 0 and bits 17-32 of this
84 * parameter are unused.
85 *
86 */
87
88#include <linux/kernel.h>
89#include <linux/errno.h>
90#include <linux/init.h>
91#include <linux/slab.h>
92#include <linux/module.h>
93#include <linux/usb/input.h>
94#include <linux/wait.h>
95#include <linux/jiffies.h>
96
97/*
98 * Module and Version Information, Module Parameters
99 */
100
101#define ATI_REMOTE_VENDOR_ID 0x0bc7
102#define LOLA_REMOTE_PRODUCT_ID 0x0002
103#define LOLA2_REMOTE_PRODUCT_ID 0x0003
104#define ATI_REMOTE_PRODUCT_ID 0x0004
105#define NVIDIA_REMOTE_PRODUCT_ID 0x0005
106#define MEDION_REMOTE_PRODUCT_ID 0x0006
107
108#define DRIVER_VERSION "2.2.1"
109#define DRIVER_AUTHOR "Torrey Hoffman <thoffman@arnor.net>"
110#define DRIVER_DESC "ATI/X10 RF USB Remote Control"
111
112#define NAME_BUFSIZE 80 /* size of product name, path buffers */
113#define DATA_BUFSIZE 63 /* size of URB data buffers */
114
115/*
116 * Duplicate event filtering time.
117 * Sequential, identical KIND_FILTERED inputs with less than
118 * FILTER_TIME milliseconds between them are considered as repeat
119 * events. The hardware generates 5 events for the first keypress
120 * and we have to take this into account for an accurate repeat
121 * behaviour.
122 */
123#define FILTER_TIME 60 /* msec */
124#define REPEAT_DELAY 500 /* msec */
125
126static unsigned long channel_mask;
127module_param(channel_mask, ulong, 0644);
128MODULE_PARM_DESC(channel_mask, "Bitmask of remote control channels to ignore");
129
130static int debug;
131module_param(debug, int, 0644);
132MODULE_PARM_DESC(debug, "Enable extra debug messages and information");
133
134static int repeat_filter = FILTER_TIME;
135module_param(repeat_filter, int, 0644);
136MODULE_PARM_DESC(repeat_filter, "Repeat filter time, default = 60 msec");
137
138static int repeat_delay = REPEAT_DELAY;
139module_param(repeat_delay, int, 0644);
140MODULE_PARM_DESC(repeat_delay, "Delay before sending repeats, default = 500 msec");
141
142#define dbginfo(dev, format, arg...) do { if (debug) dev_info(dev , format , ## arg); } while (0)
143#undef err
144#define err(format, arg...) printk(KERN_ERR format , ## arg)
145
146static struct usb_device_id ati_remote_table[] = {
147 { USB_DEVICE(ATI_REMOTE_VENDOR_ID, LOLA_REMOTE_PRODUCT_ID) },
148 { USB_DEVICE(ATI_REMOTE_VENDOR_ID, LOLA2_REMOTE_PRODUCT_ID) },
149 { USB_DEVICE(ATI_REMOTE_VENDOR_ID, ATI_REMOTE_PRODUCT_ID) },
150 { USB_DEVICE(ATI_REMOTE_VENDOR_ID, NVIDIA_REMOTE_PRODUCT_ID) },
151 { USB_DEVICE(ATI_REMOTE_VENDOR_ID, MEDION_REMOTE_PRODUCT_ID) },
152 {} /* Terminating entry */
153};
154
155MODULE_DEVICE_TABLE(usb, ati_remote_table);
156
157/* Get hi and low bytes of a 16-bits int */
158#define HI(a) ((unsigned char)((a) >> 8))
159#define LO(a) ((unsigned char)((a) & 0xff))
160
161#define SEND_FLAG_IN_PROGRESS 1
162#define SEND_FLAG_COMPLETE 2
163
164/* Device initialization strings */
165static char init1[] = { 0x01, 0x00, 0x20, 0x14 };
166static char init2[] = { 0x01, 0x00, 0x20, 0x14, 0x20, 0x20, 0x20 };
167
168struct ati_remote {
169 struct input_dev *idev;
170 struct usb_device *udev;
171 struct usb_interface *interface;
172
173 struct urb *irq_urb;
174 struct urb *out_urb;
175 struct usb_endpoint_descriptor *endpoint_in;
176 struct usb_endpoint_descriptor *endpoint_out;
177 unsigned char *inbuf;
178 unsigned char *outbuf;
179 dma_addr_t inbuf_dma;
180 dma_addr_t outbuf_dma;
181
182 unsigned char old_data[2]; /* Detect duplicate events */
183 unsigned long old_jiffies;
184 unsigned long acc_jiffies; /* handle acceleration */
185 unsigned long first_jiffies;
186
187 unsigned int repeat_count;
188
189 char name[NAME_BUFSIZE];
190 char phys[NAME_BUFSIZE];
191
192 wait_queue_head_t wait;
193 int send_flags;
194};
195
196/* "Kinds" of messages sent from the hardware to the driver. */
197#define KIND_END 0
198#define KIND_LITERAL 1 /* Simply pass to input system */
199#define KIND_FILTERED 2 /* Add artificial key-up events, drop keyrepeats */
200#define KIND_LU 3 /* Directional keypad diagonals - left up, */
201#define KIND_RU 4 /* right up, */
202#define KIND_LD 5 /* left down, */
203#define KIND_RD 6 /* right down */
204#define KIND_ACCEL 7 /* Directional keypad - left, right, up, down.*/
205
206/* Translation table from hardware messages to input events. */
207static const struct {
208 short kind;
209 unsigned char data1, data2;
210 int type;
211 unsigned int code;
212 int value;
213} ati_remote_tbl[] = {
214 /* Directional control pad axes */
215 {KIND_ACCEL, 0x35, 0x70, EV_REL, REL_X, -1}, /* left */
216 {KIND_ACCEL, 0x36, 0x71, EV_REL, REL_X, 1}, /* right */
217 {KIND_ACCEL, 0x37, 0x72, EV_REL, REL_Y, -1}, /* up */
218 {KIND_ACCEL, 0x38, 0x73, EV_REL, REL_Y, 1}, /* down */
219 /* Directional control pad diagonals */
220 {KIND_LU, 0x39, 0x74, EV_REL, 0, 0}, /* left up */
221 {KIND_RU, 0x3a, 0x75, EV_REL, 0, 0}, /* right up */
222 {KIND_LD, 0x3c, 0x77, EV_REL, 0, 0}, /* left down */
223 {KIND_RD, 0x3b, 0x76, EV_REL, 0, 0}, /* right down */
224
225 /* "Mouse button" buttons */
226 {KIND_LITERAL, 0x3d, 0x78, EV_KEY, BTN_LEFT, 1}, /* left btn down */
227 {KIND_LITERAL, 0x3e, 0x79, EV_KEY, BTN_LEFT, 0}, /* left btn up */
228 {KIND_LITERAL, 0x41, 0x7c, EV_KEY, BTN_RIGHT, 1},/* right btn down */
229 {KIND_LITERAL, 0x42, 0x7d, EV_KEY, BTN_RIGHT, 0},/* right btn up */
230
231 /* Artificial "doubleclick" events are generated by the hardware.
232 * They are mapped to the "side" and "extra" mouse buttons here. */
233 {KIND_FILTERED, 0x3f, 0x7a, EV_KEY, BTN_SIDE, 1}, /* left dblclick */
234 {KIND_FILTERED, 0x43, 0x7e, EV_KEY, BTN_EXTRA, 1},/* right dblclick */
235
236 /* keyboard. */
237 {KIND_FILTERED, 0xd2, 0x0d, EV_KEY, KEY_1, 1},
238 {KIND_FILTERED, 0xd3, 0x0e, EV_KEY, KEY_2, 1},
239 {KIND_FILTERED, 0xd4, 0x0f, EV_KEY, KEY_3, 1},
240 {KIND_FILTERED, 0xd5, 0x10, EV_KEY, KEY_4, 1},
241 {KIND_FILTERED, 0xd6, 0x11, EV_KEY, KEY_5, 1},
242 {KIND_FILTERED, 0xd7, 0x12, EV_KEY, KEY_6, 1},
243 {KIND_FILTERED, 0xd8, 0x13, EV_KEY, KEY_7, 1},
244 {KIND_FILTERED, 0xd9, 0x14, EV_KEY, KEY_8, 1},
245 {KIND_FILTERED, 0xda, 0x15, EV_KEY, KEY_9, 1},
246 {KIND_FILTERED, 0xdc, 0x17, EV_KEY, KEY_0, 1},
247 {KIND_FILTERED, 0xc5, 0x00, EV_KEY, KEY_A, 1},
248 {KIND_FILTERED, 0xc6, 0x01, EV_KEY, KEY_B, 1},
249 {KIND_FILTERED, 0xde, 0x19, EV_KEY, KEY_C, 1},
250 {KIND_FILTERED, 0xe0, 0x1b, EV_KEY, KEY_D, 1},
251 {KIND_FILTERED, 0xe6, 0x21, EV_KEY, KEY_E, 1},
252 {KIND_FILTERED, 0xe8, 0x23, EV_KEY, KEY_F, 1},
253
254 /* "special" keys */
255 {KIND_FILTERED, 0xdd, 0x18, EV_KEY, KEY_KPENTER, 1}, /* "check" */
256 {KIND_FILTERED, 0xdb, 0x16, EV_KEY, KEY_MENU, 1}, /* "menu" */
257 {KIND_FILTERED, 0xc7, 0x02, EV_KEY, KEY_POWER, 1}, /* Power */
258 {KIND_FILTERED, 0xc8, 0x03, EV_KEY, KEY_TV, 1}, /* TV */
259 {KIND_FILTERED, 0xc9, 0x04, EV_KEY, KEY_DVD, 1}, /* DVD */
260 {KIND_FILTERED, 0xca, 0x05, EV_KEY, KEY_WWW, 1}, /* WEB */
261 {KIND_FILTERED, 0xcb, 0x06, EV_KEY, KEY_BOOKMARKS, 1}, /* "book" */
262 {KIND_FILTERED, 0xcc, 0x07, EV_KEY, KEY_EDIT, 1}, /* "hand" */
263 {KIND_FILTERED, 0xe1, 0x1c, EV_KEY, KEY_COFFEE, 1}, /* "timer" */
264 {KIND_FILTERED, 0xe5, 0x20, EV_KEY, KEY_FRONT, 1}, /* "max" */
265 {KIND_FILTERED, 0xe2, 0x1d, EV_KEY, KEY_LEFT, 1}, /* left */
266 {KIND_FILTERED, 0xe4, 0x1f, EV_KEY, KEY_RIGHT, 1}, /* right */
267 {KIND_FILTERED, 0xe7, 0x22, EV_KEY, KEY_DOWN, 1}, /* down */
268 {KIND_FILTERED, 0xdf, 0x1a, EV_KEY, KEY_UP, 1}, /* up */
269 {KIND_FILTERED, 0xe3, 0x1e, EV_KEY, KEY_OK, 1}, /* "OK" */
270 {KIND_FILTERED, 0xce, 0x09, EV_KEY, KEY_VOLUMEDOWN, 1}, /* VOL + */
271 {KIND_FILTERED, 0xcd, 0x08, EV_KEY, KEY_VOLUMEUP, 1}, /* VOL - */
272 {KIND_FILTERED, 0xcf, 0x0a, EV_KEY, KEY_MUTE, 1}, /* MUTE */
273 {KIND_FILTERED, 0xd0, 0x0b, EV_KEY, KEY_CHANNELUP, 1}, /* CH + */
274 {KIND_FILTERED, 0xd1, 0x0c, EV_KEY, KEY_CHANNELDOWN, 1},/* CH - */
275 {KIND_FILTERED, 0xec, 0x27, EV_KEY, KEY_RECORD, 1}, /* ( o) red */
276 {KIND_FILTERED, 0xea, 0x25, EV_KEY, KEY_PLAY, 1}, /* ( >) */
277 {KIND_FILTERED, 0xe9, 0x24, EV_KEY, KEY_REWIND, 1}, /* (<<) */
278 {KIND_FILTERED, 0xeb, 0x26, EV_KEY, KEY_FORWARD, 1}, /* (>>) */
279 {KIND_FILTERED, 0xed, 0x28, EV_KEY, KEY_STOP, 1}, /* ([]) */
280 {KIND_FILTERED, 0xee, 0x29, EV_KEY, KEY_PAUSE, 1}, /* ('') */
281 {KIND_FILTERED, 0xf0, 0x2b, EV_KEY, KEY_PREVIOUS, 1}, /* (<-) */
282 {KIND_FILTERED, 0xef, 0x2a, EV_KEY, KEY_NEXT, 1}, /* (>+) */
283 {KIND_FILTERED, 0xf2, 0x2D, EV_KEY, KEY_INFO, 1}, /* PLAYING */
284 {KIND_FILTERED, 0xf3, 0x2E, EV_KEY, KEY_HOME, 1}, /* TOP */
285 {KIND_FILTERED, 0xf4, 0x2F, EV_KEY, KEY_END, 1}, /* END */
286 {KIND_FILTERED, 0xf5, 0x30, EV_KEY, KEY_SELECT, 1}, /* SELECT */
287
288 {KIND_END, 0x00, 0x00, EV_MAX + 1, 0, 0}
289};
290
291/* Local function prototypes */
292static int ati_remote_open (struct input_dev *inputdev);
293static void ati_remote_close (struct input_dev *inputdev);
294static int ati_remote_sendpacket (struct ati_remote *ati_remote, u16 cmd, unsigned char *data);
295static void ati_remote_irq_out (struct urb *urb);
296static void ati_remote_irq_in (struct urb *urb);
297static void ati_remote_input_report (struct urb *urb);
298static int ati_remote_initialize (struct ati_remote *ati_remote);
299static int ati_remote_probe (struct usb_interface *interface, const struct usb_device_id *id);
300static void ati_remote_disconnect (struct usb_interface *interface);
301
302/* usb specific object to register with the usb subsystem */
303static struct usb_driver ati_remote_driver = {
304 .name = "ati_remote",
305 .probe = ati_remote_probe,
306 .disconnect = ati_remote_disconnect,
307 .id_table = ati_remote_table,
308};
309
310/*
311 * ati_remote_dump_input
312 */
313static void ati_remote_dump(struct device *dev, unsigned char *data,
314 unsigned int len)
315{
316 if ((len == 1) && (data[0] != (unsigned char)0xff) && (data[0] != 0x00))
317 dev_warn(dev, "Weird byte 0x%02x\n", data[0]);
318 else if (len == 4)
319 dev_warn(dev, "Weird key %02x %02x %02x %02x\n",
320 data[0], data[1], data[2], data[3]);
321 else
322 dev_warn(dev, "Weird data, len=%d %02x %02x %02x %02x %02x %02x ...\n",
323 len, data[0], data[1], data[2], data[3], data[4], data[5]);
324}
325
326/*
327 * ati_remote_open
328 */
329static int ati_remote_open(struct input_dev *inputdev)
330{
331 struct ati_remote *ati_remote = input_get_drvdata(inputdev);
332
333 /* On first open, submit the read urb which was set up previously. */
334 ati_remote->irq_urb->dev = ati_remote->udev;
335 if (usb_submit_urb(ati_remote->irq_urb, GFP_KERNEL)) {
336 dev_err(&ati_remote->interface->dev,
337 "%s: usb_submit_urb failed!\n", __func__);
338 return -EIO;
339 }
340
341 return 0;
342}
343
344/*
345 * ati_remote_close
346 */
347static void ati_remote_close(struct input_dev *inputdev)
348{
349 struct ati_remote *ati_remote = input_get_drvdata(inputdev);
350
351 usb_kill_urb(ati_remote->irq_urb);
352}
353
354/*
355 * ati_remote_irq_out
356 */
357static void ati_remote_irq_out(struct urb *urb)
358{
359 struct ati_remote *ati_remote = urb->context;
360
361 if (urb->status) {
362 dev_dbg(&ati_remote->interface->dev, "%s: status %d\n",
363 __func__, urb->status);
364 return;
365 }
366
367 ati_remote->send_flags |= SEND_FLAG_COMPLETE;
368 wmb();
369 wake_up(&ati_remote->wait);
370}
371
372/*
373 * ati_remote_sendpacket
374 *
375 * Used to send device initialization strings
376 */
377static int ati_remote_sendpacket(struct ati_remote *ati_remote, u16 cmd, unsigned char *data)
378{
379 int retval = 0;
380
381 /* Set up out_urb */
382 memcpy(ati_remote->out_urb->transfer_buffer + 1, data, LO(cmd));
383 ((char *) ati_remote->out_urb->transfer_buffer)[0] = HI(cmd);
384
385 ati_remote->out_urb->transfer_buffer_length = LO(cmd) + 1;
386 ati_remote->out_urb->dev = ati_remote->udev;
387 ati_remote->send_flags = SEND_FLAG_IN_PROGRESS;
388
389 retval = usb_submit_urb(ati_remote->out_urb, GFP_ATOMIC);
390 if (retval) {
391 dev_dbg(&ati_remote->interface->dev,
392 "sendpacket: usb_submit_urb failed: %d\n", retval);
393 return retval;
394 }
395
396 wait_event_timeout(ati_remote->wait,
397 ((ati_remote->out_urb->status != -EINPROGRESS) ||
398 (ati_remote->send_flags & SEND_FLAG_COMPLETE)),
399 HZ);
400 usb_kill_urb(ati_remote->out_urb);
401
402 return retval;
403}
404
405/*
406 * ati_remote_event_lookup
407 */
408static int ati_remote_event_lookup(int rem, unsigned char d1, unsigned char d2)
409{
410 int i;
411
412 for (i = 0; ati_remote_tbl[i].kind != KIND_END; i++) {
413 /*
414 * Decide if the table entry matches the remote input.
415 */
416 if ((((ati_remote_tbl[i].data1 & 0x0f) == (d1 & 0x0f))) &&
417 ((((ati_remote_tbl[i].data1 >> 4) -
418 (d1 >> 4) + rem) & 0x0f) == 0x0f) &&
419 (ati_remote_tbl[i].data2 == d2))
420 return i;
421
422 }
423 return -1;
424}
425
426/*
427 * ati_remote_compute_accel
428 *
429 * Implements acceleration curve for directional control pad
430 * If elapsed time since last event is > 1/4 second, user "stopped",
431 * so reset acceleration. Otherwise, user is probably holding the control
432 * pad down, so we increase acceleration, ramping up over two seconds to
433 * a maximum speed.
434 */
435static int ati_remote_compute_accel(struct ati_remote *ati_remote)
436{
437 static const char accel[] = { 1, 2, 4, 6, 9, 13, 20 };
438 unsigned long now = jiffies;
439 int acc;
440
441 if (time_after(now, ati_remote->old_jiffies + msecs_to_jiffies(250))) {
442 acc = 1;
443 ati_remote->acc_jiffies = now;
444 }
445 else if (time_before(now, ati_remote->acc_jiffies + msecs_to_jiffies(125)))
446 acc = accel[0];
447 else if (time_before(now, ati_remote->acc_jiffies + msecs_to_jiffies(250)))
448 acc = accel[1];
449 else if (time_before(now, ati_remote->acc_jiffies + msecs_to_jiffies(500)))
450 acc = accel[2];
451 else if (time_before(now, ati_remote->acc_jiffies + msecs_to_jiffies(1000)))
452 acc = accel[3];
453 else if (time_before(now, ati_remote->acc_jiffies + msecs_to_jiffies(1500)))
454 acc = accel[4];
455 else if (time_before(now, ati_remote->acc_jiffies + msecs_to_jiffies(2000)))
456 acc = accel[5];
457 else
458 acc = accel[6];
459
460 return acc;
461}
462
463/*
464 * ati_remote_report_input
465 */
466static void ati_remote_input_report(struct urb *urb)
467{
468 struct ati_remote *ati_remote = urb->context;
469 unsigned char *data= ati_remote->inbuf;
470 struct input_dev *dev = ati_remote->idev;
471 int index, acc;
472 int remote_num;
473
474 /* Deal with strange looking inputs */
475 if ( (urb->actual_length != 4) || (data[0] != 0x14) ||
476 ((data[3] & 0x0f) != 0x00) ) {
477 ati_remote_dump(&urb->dev->dev, data, urb->actual_length);
478 return;
479 }
480
481 /* Mask unwanted remote channels. */
482 /* note: remote_num is 0-based, channel 1 on remote == 0 here */
483 remote_num = (data[3] >> 4) & 0x0f;
484 if (channel_mask & (1 << (remote_num + 1))) {
485 dbginfo(&ati_remote->interface->dev,
486 "Masked input from channel 0x%02x: data %02x,%02x, mask= 0x%02lx\n",
487 remote_num, data[1], data[2], channel_mask);
488 return;
489 }
490
491 /* Look up event code index in translation table */
492 index = ati_remote_event_lookup(remote_num, data[1], data[2]);
493 if (index < 0) {
494 dev_warn(&ati_remote->interface->dev,
495 "Unknown input from channel 0x%02x: data %02x,%02x\n",
496 remote_num, data[1], data[2]);
497 return;
498 }
499 dbginfo(&ati_remote->interface->dev,
500 "channel 0x%02x; data %02x,%02x; index %d; keycode %d\n",
501 remote_num, data[1], data[2], index, ati_remote_tbl[index].code);
502
503 if (ati_remote_tbl[index].kind == KIND_LITERAL) {
504 input_event(dev, ati_remote_tbl[index].type,
505 ati_remote_tbl[index].code,
506 ati_remote_tbl[index].value);
507 input_sync(dev);
508
509 ati_remote->old_jiffies = jiffies;
510 return;
511 }
512
513 if (ati_remote_tbl[index].kind == KIND_FILTERED) {
514 unsigned long now = jiffies;
515
516 /* Filter duplicate events which happen "too close" together. */
517 if (ati_remote->old_data[0] == data[1] &&
518 ati_remote->old_data[1] == data[2] &&
519 time_before(now, ati_remote->old_jiffies +
520 msecs_to_jiffies(repeat_filter))) {
521 ati_remote->repeat_count++;
522 } else {
523 ati_remote->repeat_count = 0;
524 ati_remote->first_jiffies = now;
525 }
526
527 ati_remote->old_data[0] = data[1];
528 ati_remote->old_data[1] = data[2];
529 ati_remote->old_jiffies = now;
530
531 /* Ensure we skip at least the 4 first duplicate events (generated
532 * by a single keypress), and continue skipping until repeat_delay
533 * msecs have passed
534 */
535 if (ati_remote->repeat_count > 0 &&
536 (ati_remote->repeat_count < 5 ||
537 time_before(now, ati_remote->first_jiffies +
538 msecs_to_jiffies(repeat_delay))))
539 return;
540
541
542 input_event(dev, ati_remote_tbl[index].type,
543 ati_remote_tbl[index].code, 1);
544 input_sync(dev);
545 input_event(dev, ati_remote_tbl[index].type,
546 ati_remote_tbl[index].code, 0);
547 input_sync(dev);
548
549 } else {
550
551 /*
552 * Other event kinds are from the directional control pad, and have an
553 * acceleration factor applied to them. Without this acceleration, the
554 * control pad is mostly unusable.
555 */
556 acc = ati_remote_compute_accel(ati_remote);
557
558 switch (ati_remote_tbl[index].kind) {
559 case KIND_ACCEL:
560 input_event(dev, ati_remote_tbl[index].type,
561 ati_remote_tbl[index].code,
562 ati_remote_tbl[index].value * acc);
563 break;
564 case KIND_LU:
565 input_report_rel(dev, REL_X, -acc);
566 input_report_rel(dev, REL_Y, -acc);
567 break;
568 case KIND_RU:
569 input_report_rel(dev, REL_X, acc);
570 input_report_rel(dev, REL_Y, -acc);
571 break;
572 case KIND_LD:
573 input_report_rel(dev, REL_X, -acc);
574 input_report_rel(dev, REL_Y, acc);
575 break;
576 case KIND_RD:
577 input_report_rel(dev, REL_X, acc);
578 input_report_rel(dev, REL_Y, acc);
579 break;
580 default:
581 dev_dbg(&ati_remote->interface->dev, "ati_remote kind=%d\n",
582 ati_remote_tbl[index].kind);
583 }
584 input_sync(dev);
585
586 ati_remote->old_jiffies = jiffies;
587 ati_remote->old_data[0] = data[1];
588 ati_remote->old_data[1] = data[2];
589 }
590}
591
592/*
593 * ati_remote_irq_in
594 */
595static void ati_remote_irq_in(struct urb *urb)
596{
597 struct ati_remote *ati_remote = urb->context;
598 int retval;
599
600 switch (urb->status) {
601 case 0: /* success */
602 ati_remote_input_report(urb);
603 break;
604 case -ECONNRESET: /* unlink */
605 case -ENOENT:
606 case -ESHUTDOWN:
607 dev_dbg(&ati_remote->interface->dev, "%s: urb error status, unlink? \n",
608 __func__);
609 return;
610 default: /* error */
611 dev_dbg(&ati_remote->interface->dev, "%s: Nonzero urb status %d\n",
612 __func__, urb->status);
613 }
614
615 retval = usb_submit_urb(urb, GFP_ATOMIC);
616 if (retval)
617 dev_err(&ati_remote->interface->dev, "%s: usb_submit_urb()=%d\n",
618 __func__, retval);
619}
620
621/*
622 * ati_remote_alloc_buffers
623 */
624static int ati_remote_alloc_buffers(struct usb_device *udev,
625 struct ati_remote *ati_remote)
626{
627 ati_remote->inbuf = usb_alloc_coherent(udev, DATA_BUFSIZE, GFP_ATOMIC,
628 &ati_remote->inbuf_dma);
629 if (!ati_remote->inbuf)
630 return -1;
631
632 ati_remote->outbuf = usb_alloc_coherent(udev, DATA_BUFSIZE, GFP_ATOMIC,
633 &ati_remote->outbuf_dma);
634 if (!ati_remote->outbuf)
635 return -1;
636
637 ati_remote->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
638 if (!ati_remote->irq_urb)
639 return -1;
640
641 ati_remote->out_urb = usb_alloc_urb(0, GFP_KERNEL);
642 if (!ati_remote->out_urb)
643 return -1;
644
645 return 0;
646}
647
648/*
649 * ati_remote_free_buffers
650 */
651static void ati_remote_free_buffers(struct ati_remote *ati_remote)
652{
653 usb_free_urb(ati_remote->irq_urb);
654 usb_free_urb(ati_remote->out_urb);
655
656 usb_free_coherent(ati_remote->udev, DATA_BUFSIZE,
657 ati_remote->inbuf, ati_remote->inbuf_dma);
658
659 usb_free_coherent(ati_remote->udev, DATA_BUFSIZE,
660 ati_remote->outbuf, ati_remote->outbuf_dma);
661}
662
663static void ati_remote_input_init(struct ati_remote *ati_remote)
664{
665 struct input_dev *idev = ati_remote->idev;
666 int i;
667
668 idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
669 idev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
670 BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_SIDE) | BIT_MASK(BTN_EXTRA);
671 idev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
672 for (i = 0; ati_remote_tbl[i].kind != KIND_END; i++)
673 if (ati_remote_tbl[i].type == EV_KEY)
674 set_bit(ati_remote_tbl[i].code, idev->keybit);
675
676 input_set_drvdata(idev, ati_remote);
677
678 idev->open = ati_remote_open;
679 idev->close = ati_remote_close;
680
681 idev->name = ati_remote->name;
682 idev->phys = ati_remote->phys;
683
684 usb_to_input_id(ati_remote->udev, &idev->id);
685 idev->dev.parent = &ati_remote->udev->dev;
686}
687
688static int ati_remote_initialize(struct ati_remote *ati_remote)
689{
690 struct usb_device *udev = ati_remote->udev;
691 int pipe, maxp;
692
693 init_waitqueue_head(&ati_remote->wait);
694
695 /* Set up irq_urb */
696 pipe = usb_rcvintpipe(udev, ati_remote->endpoint_in->bEndpointAddress);
697 maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
698 maxp = (maxp > DATA_BUFSIZE) ? DATA_BUFSIZE : maxp;
699
700 usb_fill_int_urb(ati_remote->irq_urb, udev, pipe, ati_remote->inbuf,
701 maxp, ati_remote_irq_in, ati_remote,
702 ati_remote->endpoint_in->bInterval);
703 ati_remote->irq_urb->transfer_dma = ati_remote->inbuf_dma;
704 ati_remote->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
705
706 /* Set up out_urb */
707 pipe = usb_sndintpipe(udev, ati_remote->endpoint_out->bEndpointAddress);
708 maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
709 maxp = (maxp > DATA_BUFSIZE) ? DATA_BUFSIZE : maxp;
710
711 usb_fill_int_urb(ati_remote->out_urb, udev, pipe, ati_remote->outbuf,
712 maxp, ati_remote_irq_out, ati_remote,
713 ati_remote->endpoint_out->bInterval);
714 ati_remote->out_urb->transfer_dma = ati_remote->outbuf_dma;
715 ati_remote->out_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
716
717 /* send initialization strings */
718 if ((ati_remote_sendpacket(ati_remote, 0x8004, init1)) ||
719 (ati_remote_sendpacket(ati_remote, 0x8007, init2))) {
720 dev_err(&ati_remote->interface->dev,
721 "Initializing ati_remote hardware failed.\n");
722 return -EIO;
723 }
724
725 return 0;
726}
727
728/*
729 * ati_remote_probe
730 */
731static int ati_remote_probe(struct usb_interface *interface, const struct usb_device_id *id)
732{
733 struct usb_device *udev = interface_to_usbdev(interface);
734 struct usb_host_interface *iface_host = interface->cur_altsetting;
735 struct usb_endpoint_descriptor *endpoint_in, *endpoint_out;
736 struct ati_remote *ati_remote;
737 struct input_dev *input_dev;
738 int err = -ENOMEM;
739
740 if (iface_host->desc.bNumEndpoints != 2) {
741 err("%s: Unexpected desc.bNumEndpoints\n", __func__);
742 return -ENODEV;
743 }
744
745 endpoint_in = &iface_host->endpoint[0].desc;
746 endpoint_out = &iface_host->endpoint[1].desc;
747
748 if (!usb_endpoint_is_int_in(endpoint_in)) {
749 err("%s: Unexpected endpoint_in\n", __func__);
750 return -ENODEV;
751 }
752 if (le16_to_cpu(endpoint_in->wMaxPacketSize) == 0) {
753 err("%s: endpoint_in message size==0? \n", __func__);
754 return -ENODEV;
755 }
756
757 ati_remote = kzalloc(sizeof (struct ati_remote), GFP_KERNEL);
758 input_dev = input_allocate_device();
759 if (!ati_remote || !input_dev)
760 goto fail1;
761
762 /* Allocate URB buffers, URBs */
763 if (ati_remote_alloc_buffers(udev, ati_remote))
764 goto fail2;
765
766 ati_remote->endpoint_in = endpoint_in;
767 ati_remote->endpoint_out = endpoint_out;
768 ati_remote->udev = udev;
769 ati_remote->idev = input_dev;
770 ati_remote->interface = interface;
771
772 usb_make_path(udev, ati_remote->phys, sizeof(ati_remote->phys));
773 strlcat(ati_remote->phys, "/input0", sizeof(ati_remote->phys));
774
775 if (udev->manufacturer)
776 strlcpy(ati_remote->name, udev->manufacturer, sizeof(ati_remote->name));
777
778 if (udev->product)
779 snprintf(ati_remote->name, sizeof(ati_remote->name),
780 "%s %s", ati_remote->name, udev->product);
781
782 if (!strlen(ati_remote->name))
783 snprintf(ati_remote->name, sizeof(ati_remote->name),
784 DRIVER_DESC "(%04x,%04x)",
785 le16_to_cpu(ati_remote->udev->descriptor.idVendor),
786 le16_to_cpu(ati_remote->udev->descriptor.idProduct));
787
788 ati_remote_input_init(ati_remote);
789
790 /* Device Hardware Initialization - fills in ati_remote->idev from udev. */
791 err = ati_remote_initialize(ati_remote);
792 if (err)
793 goto fail3;
794
795 /* Set up and register input device */
796 err = input_register_device(ati_remote->idev);
797 if (err)
798 goto fail3;
799
800 usb_set_intfdata(interface, ati_remote);
801 return 0;
802
803 fail3: usb_kill_urb(ati_remote->irq_urb);
804 usb_kill_urb(ati_remote->out_urb);
805 fail2: ati_remote_free_buffers(ati_remote);
806 fail1: input_free_device(input_dev);
807 kfree(ati_remote);
808 return err;
809}
810
811/*
812 * ati_remote_disconnect
813 */
814static void ati_remote_disconnect(struct usb_interface *interface)
815{
816 struct ati_remote *ati_remote;
817
818 ati_remote = usb_get_intfdata(interface);
819 usb_set_intfdata(interface, NULL);
820 if (!ati_remote) {
821 dev_warn(&interface->dev, "%s - null device?\n", __func__);
822 return;
823 }
824
825 usb_kill_urb(ati_remote->irq_urb);
826 usb_kill_urb(ati_remote->out_urb);
827 input_unregister_device(ati_remote->idev);
828 ati_remote_free_buffers(ati_remote);
829 kfree(ati_remote);
830}
831
832/*
833 * ati_remote_init
834 */
835static int __init ati_remote_init(void)
836{
837 int result;
838
839 result = usb_register(&ati_remote_driver);
840 if (result)
841 printk(KERN_ERR KBUILD_MODNAME
842 ": usb_register error #%d\n", result);
843 else
844 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
845 DRIVER_DESC "\n");
846
847 return result;
848}
849
850/*
851 * ati_remote_exit
852 */
853static void __exit ati_remote_exit(void)
854{
855 usb_deregister(&ati_remote_driver);
856}
857
858/*
859 * module specification
860 */
861
862module_init(ati_remote_init);
863module_exit(ati_remote_exit);
864
865MODULE_AUTHOR(DRIVER_AUTHOR);
866MODULE_DESCRIPTION(DRIVER_DESC);
867MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/ati_remote2.c b/drivers/input/misc/ati_remote2.c
index afbe3e760551..a34896ed7ed3 100644
--- a/drivers/input/misc/ati_remote2.c
+++ b/drivers/input/misc/ati_remote2.c
@@ -11,6 +11,7 @@
11 11
12#include <linux/usb/input.h> 12#include <linux/usb/input.h>
13#include <linux/slab.h> 13#include <linux/slab.h>
14#include <linux/module.h>
14 15
15#define DRIVER_DESC "ATI/Philips USB RF remote driver" 16#define DRIVER_DESC "ATI/Philips USB RF remote driver"
16#define DRIVER_VERSION "0.3" 17#define DRIVER_VERSION "0.3"
diff --git a/drivers/input/misc/cm109.c b/drivers/input/misc/cm109.c
index b09c7d127219..ab860511f016 100644
--- a/drivers/input/misc/cm109.c
+++ b/drivers/input/misc/cm109.c
@@ -475,7 +475,7 @@ static void cm109_toggle_buzzer_sync(struct cm109_dev *dev, int on)
475 le16_to_cpu(dev->ctl_req->wIndex), 475 le16_to_cpu(dev->ctl_req->wIndex),
476 dev->ctl_data, 476 dev->ctl_data,
477 USB_PKT_LEN, USB_CTRL_SET_TIMEOUT); 477 USB_PKT_LEN, USB_CTRL_SET_TIMEOUT);
478 if (error && error != EINTR) 478 if (error < 0 && error != -EINTR)
479 err("%s: usb_control_msg() failed %d", __func__, error); 479 err("%s: usb_control_msg() failed %d", __func__, error);
480} 480}
481 481
diff --git a/drivers/input/misc/cma3000_d0x.c b/drivers/input/misc/cma3000_d0x.c
index 1633b6342267..80793f1608eb 100644
--- a/drivers/input/misc/cma3000_d0x.c
+++ b/drivers/input/misc/cma3000_d0x.c
@@ -23,6 +23,7 @@
23#include <linux/slab.h> 23#include <linux/slab.h>
24#include <linux/input.h> 24#include <linux/input.h>
25#include <linux/input/cma3000.h> 25#include <linux/input/cma3000.h>
26#include <linux/module.h>
26 27
27#include "cma3000_d0x.h" 28#include "cma3000_d0x.h"
28 29
diff --git a/drivers/input/misc/dm355evm_keys.c b/drivers/input/misc/dm355evm_keys.c
index 19af682c24fb..7283dd2a1ad3 100644
--- a/drivers/input/misc/dm355evm_keys.c
+++ b/drivers/input/misc/dm355evm_keys.c
@@ -17,6 +17,7 @@
17#include <linux/interrupt.h> 17#include <linux/interrupt.h>
18 18
19#include <linux/i2c/dm355evm_msp.h> 19#include <linux/i2c/dm355evm_msp.h>
20#include <linux/module.h>
20 21
21 22
22/* 23/*
diff --git a/drivers/input/misc/mc13783-pwrbutton.c b/drivers/input/misc/mc13783-pwrbutton.c
new file mode 100644
index 000000000000..09b052288657
--- /dev/null
+++ b/drivers/input/misc/mc13783-pwrbutton.c
@@ -0,0 +1,282 @@
1/**
2 * Copyright (C) 2011 Philippe Rétornaz
3 *
4 * Based on twl4030-pwrbutton driver by:
5 * Peter De Schrijver <peter.de-schrijver@nokia.com>
6 * Felipe Balbi <felipe.balbi@nokia.com>
7 *
8 * This file is subject to the terms and conditions of the GNU General
9 * Public License. See the file "COPYING" in the main directory of this
10 * archive for more details.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA
20 */
21
22#include <linux/module.h>
23#include <linux/init.h>
24#include <linux/kernel.h>
25#include <linux/errno.h>
26#include <linux/input.h>
27#include <linux/interrupt.h>
28#include <linux/platform_device.h>
29#include <linux/mfd/mc13783.h>
30#include <linux/sched.h>
31#include <linux/slab.h>
32
33struct mc13783_pwrb {
34 struct input_dev *pwr;
35 struct mc13xxx *mc13783;
36#define MC13783_PWRB_B1_POL_INVERT (1 << 0)
37#define MC13783_PWRB_B2_POL_INVERT (1 << 1)
38#define MC13783_PWRB_B3_POL_INVERT (1 << 2)
39 int flags;
40 unsigned short keymap[3];
41};
42
43#define MC13783_REG_INTERRUPT_SENSE_1 5
44#define MC13783_IRQSENSE1_ONOFD1S (1 << 3)
45#define MC13783_IRQSENSE1_ONOFD2S (1 << 4)
46#define MC13783_IRQSENSE1_ONOFD3S (1 << 5)
47
48#define MC13783_REG_POWER_CONTROL_2 15
49#define MC13783_POWER_CONTROL_2_ON1BDBNC 4
50#define MC13783_POWER_CONTROL_2_ON2BDBNC 6
51#define MC13783_POWER_CONTROL_2_ON3BDBNC 8
52#define MC13783_POWER_CONTROL_2_ON1BRSTEN (1 << 1)
53#define MC13783_POWER_CONTROL_2_ON2BRSTEN (1 << 2)
54#define MC13783_POWER_CONTROL_2_ON3BRSTEN (1 << 3)
55
56static irqreturn_t button_irq(int irq, void *_priv)
57{
58 struct mc13783_pwrb *priv = _priv;
59 int val;
60
61 mc13xxx_irq_ack(priv->mc13783, irq);
62 mc13xxx_reg_read(priv->mc13783, MC13783_REG_INTERRUPT_SENSE_1, &val);
63
64 switch (irq) {
65 case MC13783_IRQ_ONOFD1:
66 val = val & MC13783_IRQSENSE1_ONOFD1S ? 1 : 0;
67 if (priv->flags & MC13783_PWRB_B1_POL_INVERT)
68 val ^= 1;
69 input_report_key(priv->pwr, priv->keymap[0], val);
70 break;
71
72 case MC13783_IRQ_ONOFD2:
73 val = val & MC13783_IRQSENSE1_ONOFD2S ? 1 : 0;
74 if (priv->flags & MC13783_PWRB_B2_POL_INVERT)
75 val ^= 1;
76 input_report_key(priv->pwr, priv->keymap[1], val);
77 break;
78
79 case MC13783_IRQ_ONOFD3:
80 val = val & MC13783_IRQSENSE1_ONOFD3S ? 1 : 0;
81 if (priv->flags & MC13783_PWRB_B3_POL_INVERT)
82 val ^= 1;
83 input_report_key(priv->pwr, priv->keymap[2], val);
84 break;
85 }
86
87 input_sync(priv->pwr);
88
89 return IRQ_HANDLED;
90}
91
92static int __devinit mc13783_pwrbutton_probe(struct platform_device *pdev)
93{
94 const struct mc13xxx_buttons_platform_data *pdata;
95 struct mc13xxx *mc13783 = dev_get_drvdata(pdev->dev.parent);
96 struct input_dev *pwr;
97 struct mc13783_pwrb *priv;
98 int err = 0;
99 int reg = 0;
100
101 pdata = dev_get_platdata(&pdev->dev);
102 if (!pdata) {
103 dev_err(&pdev->dev, "missing platform data\n");
104 return -ENODEV;
105 }
106
107 pwr = input_allocate_device();
108 if (!pwr) {
109 dev_dbg(&pdev->dev, "Can't allocate power button\n");
110 return -ENOMEM;
111 }
112
113 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
114 if (!priv) {
115 err = -ENOMEM;
116 dev_dbg(&pdev->dev, "Can't allocate power button\n");
117 goto free_input_dev;
118 }
119
120 reg |= (pdata->b1on_flags & 0x3) << MC13783_POWER_CONTROL_2_ON1BDBNC;
121 reg |= (pdata->b2on_flags & 0x3) << MC13783_POWER_CONTROL_2_ON2BDBNC;
122 reg |= (pdata->b3on_flags & 0x3) << MC13783_POWER_CONTROL_2_ON3BDBNC;
123
124 priv->pwr = pwr;
125 priv->mc13783 = mc13783;
126
127 mc13xxx_lock(mc13783);
128
129 if (pdata->b1on_flags & MC13783_BUTTON_ENABLE) {
130 priv->keymap[0] = pdata->b1on_key;
131 if (pdata->b1on_key != KEY_RESERVED)
132 __set_bit(pdata->b1on_key, pwr->keybit);
133
134 if (pdata->b1on_flags & MC13783_BUTTON_POL_INVERT)
135 priv->flags |= MC13783_PWRB_B1_POL_INVERT;
136
137 if (pdata->b1on_flags & MC13783_BUTTON_RESET_EN)
138 reg |= MC13783_POWER_CONTROL_2_ON1BRSTEN;
139
140 err = mc13xxx_irq_request(mc13783, MC13783_IRQ_ONOFD1,
141 button_irq, "b1on", priv);
142 if (err) {
143 dev_dbg(&pdev->dev, "Can't request irq\n");
144 goto free_priv;
145 }
146 }
147
148 if (pdata->b2on_flags & MC13783_BUTTON_ENABLE) {
149 priv->keymap[1] = pdata->b2on_key;
150 if (pdata->b2on_key != KEY_RESERVED)
151 __set_bit(pdata->b2on_key, pwr->keybit);
152
153 if (pdata->b2on_flags & MC13783_BUTTON_POL_INVERT)
154 priv->flags |= MC13783_PWRB_B2_POL_INVERT;
155
156 if (pdata->b2on_flags & MC13783_BUTTON_RESET_EN)
157 reg |= MC13783_POWER_CONTROL_2_ON2BRSTEN;
158
159 err = mc13xxx_irq_request(mc13783, MC13783_IRQ_ONOFD2,
160 button_irq, "b2on", priv);
161 if (err) {
162 dev_dbg(&pdev->dev, "Can't request irq\n");
163 goto free_irq_b1;
164 }
165 }
166
167 if (pdata->b3on_flags & MC13783_BUTTON_ENABLE) {
168 priv->keymap[2] = pdata->b3on_key;
169 if (pdata->b3on_key != KEY_RESERVED)
170 __set_bit(pdata->b3on_key, pwr->keybit);
171
172 if (pdata->b3on_flags & MC13783_BUTTON_POL_INVERT)
173 priv->flags |= MC13783_PWRB_B3_POL_INVERT;
174
175 if (pdata->b3on_flags & MC13783_BUTTON_RESET_EN)
176 reg |= MC13783_POWER_CONTROL_2_ON3BRSTEN;
177
178 err = mc13xxx_irq_request(mc13783, MC13783_IRQ_ONOFD3,
179 button_irq, "b3on", priv);
180 if (err) {
181 dev_dbg(&pdev->dev, "Can't request irq: %d\n", err);
182 goto free_irq_b2;
183 }
184 }
185
186 mc13xxx_reg_rmw(mc13783, MC13783_REG_POWER_CONTROL_2, 0x3FE, reg);
187
188 mc13xxx_unlock(mc13783);
189
190 pwr->name = "mc13783_pwrbutton";
191 pwr->phys = "mc13783_pwrbutton/input0";
192 pwr->dev.parent = &pdev->dev;
193
194 pwr->keycode = priv->keymap;
195 pwr->keycodemax = ARRAY_SIZE(priv->keymap);
196 pwr->keycodesize = sizeof(priv->keymap[0]);
197 __set_bit(EV_KEY, pwr->evbit);
198
199 err = input_register_device(pwr);
200 if (err) {
201 dev_dbg(&pdev->dev, "Can't register power button: %d\n", err);
202 goto free_irq;
203 }
204
205 platform_set_drvdata(pdev, priv);
206
207 return 0;
208
209free_irq:
210 mc13xxx_lock(mc13783);
211
212 if (pdata->b3on_flags & MC13783_BUTTON_ENABLE)
213 mc13xxx_irq_free(mc13783, MC13783_IRQ_ONOFD3, priv);
214
215free_irq_b2:
216 if (pdata->b2on_flags & MC13783_BUTTON_ENABLE)
217 mc13xxx_irq_free(mc13783, MC13783_IRQ_ONOFD2, priv);
218
219free_irq_b1:
220 if (pdata->b1on_flags & MC13783_BUTTON_ENABLE)
221 mc13xxx_irq_free(mc13783, MC13783_IRQ_ONOFD1, priv);
222
223free_priv:
224 mc13xxx_unlock(mc13783);
225 kfree(priv);
226
227free_input_dev:
228 input_free_device(pwr);
229
230 return err;
231}
232
233static int __devexit mc13783_pwrbutton_remove(struct platform_device *pdev)
234{
235 struct mc13783_pwrb *priv = platform_get_drvdata(pdev);
236 const struct mc13xxx_buttons_platform_data *pdata;
237
238 pdata = dev_get_platdata(&pdev->dev);
239
240 mc13xxx_lock(priv->mc13783);
241
242 if (pdata->b3on_flags & MC13783_BUTTON_ENABLE)
243 mc13xxx_irq_free(priv->mc13783, MC13783_IRQ_ONOFD3, priv);
244 if (pdata->b2on_flags & MC13783_BUTTON_ENABLE)
245 mc13xxx_irq_free(priv->mc13783, MC13783_IRQ_ONOFD2, priv);
246 if (pdata->b1on_flags & MC13783_BUTTON_ENABLE)
247 mc13xxx_irq_free(priv->mc13783, MC13783_IRQ_ONOFD1, priv);
248
249 mc13xxx_unlock(priv->mc13783);
250
251 input_unregister_device(priv->pwr);
252 kfree(priv);
253 platform_set_drvdata(pdev, NULL);
254
255 return 0;
256}
257
258struct platform_driver mc13783_pwrbutton_driver = {
259 .probe = mc13783_pwrbutton_probe,
260 .remove = __devexit_p(mc13783_pwrbutton_remove),
261 .driver = {
262 .name = "mc13783-pwrbutton",
263 .owner = THIS_MODULE,
264 },
265};
266
267static int __init mc13783_pwrbutton_init(void)
268{
269 return platform_driver_register(&mc13783_pwrbutton_driver);
270}
271module_init(mc13783_pwrbutton_init);
272
273static void __exit mc13783_pwrbutton_exit(void)
274{
275 platform_driver_unregister(&mc13783_pwrbutton_driver);
276}
277module_exit(mc13783_pwrbutton_exit);
278
279MODULE_ALIAS("platform:mc13783-pwrbutton");
280MODULE_DESCRIPTION("MC13783 Power Button");
281MODULE_LICENSE("GPL v2");
282MODULE_AUTHOR("Philippe Retornaz");
diff --git a/drivers/input/misc/rotary_encoder.c b/drivers/input/misc/rotary_encoder.c
index 2c8b84dd9dac..2be21694fac1 100644
--- a/drivers/input/misc/rotary_encoder.c
+++ b/drivers/input/misc/rotary_encoder.c
@@ -7,7 +7,7 @@
7 * state machine code inspired by code from Tim Ruetz 7 * state machine code inspired by code from Tim Ruetz
8 * 8 *
9 * A generic driver for rotary encoders connected to GPIO lines. 9 * A generic driver for rotary encoders connected to GPIO lines.
10 * See file:Documentation/input/rotary_encoder.txt for more information 10 * See file:Documentation/input/rotary-encoder.txt for more information
11 * 11 *
12 * This program is free software; you can redistribute it and/or modify 12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2 as 13 * it under the terms of the GNU General Public License version 2 as
diff --git a/drivers/input/misc/twl6040-vibra.c b/drivers/input/misc/twl6040-vibra.c
index 23855e12a30b..ad153a417eed 100644
--- a/drivers/input/misc/twl6040-vibra.c
+++ b/drivers/input/misc/twl6040-vibra.c
@@ -74,12 +74,12 @@ static irqreturn_t twl6040_vib_irq_handler(int irq, void *data)
74 if (status & TWL6040_VIBLOCDET) { 74 if (status & TWL6040_VIBLOCDET) {
75 dev_warn(info->dev, "Left Vibrator overcurrent detected\n"); 75 dev_warn(info->dev, "Left Vibrator overcurrent detected\n");
76 twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLL, 76 twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLL,
77 TWL6040_VIBENAL); 77 TWL6040_VIBENA);
78 } 78 }
79 if (status & TWL6040_VIBROCDET) { 79 if (status & TWL6040_VIBROCDET) {
80 dev_warn(info->dev, "Right Vibrator overcurrent detected\n"); 80 dev_warn(info->dev, "Right Vibrator overcurrent detected\n");
81 twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLR, 81 twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLR,
82 TWL6040_VIBENAR); 82 TWL6040_VIBENA);
83 } 83 }
84 84
85 return IRQ_HANDLED; 85 return IRQ_HANDLED;
@@ -97,23 +97,23 @@ static void twl6040_vibra_enable(struct vibra_info *info)
97 } 97 }
98 98
99 twl6040_power(info->twl6040, 1); 99 twl6040_power(info->twl6040, 1);
100 if (twl6040->rev <= TWL6040_REV_ES1_1) { 100 if (twl6040_get_revid(twl6040) <= TWL6040_REV_ES1_1) {
101 /* 101 /*
102 * ERRATA: Disable overcurrent protection for at least 102 * ERRATA: Disable overcurrent protection for at least
103 * 3ms when enabling vibrator drivers to avoid false 103 * 3ms when enabling vibrator drivers to avoid false
104 * overcurrent detection 104 * overcurrent detection
105 */ 105 */
106 twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLL, 106 twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLL,
107 TWL6040_VIBENAL | TWL6040_VIBCTRLL); 107 TWL6040_VIBENA | TWL6040_VIBCTRL);
108 twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLR, 108 twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLR,
109 TWL6040_VIBENAR | TWL6040_VIBCTRLR); 109 TWL6040_VIBENA | TWL6040_VIBCTRL);
110 usleep_range(3000, 3500); 110 usleep_range(3000, 3500);
111 } 111 }
112 112
113 twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLL, 113 twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLL,
114 TWL6040_VIBENAL); 114 TWL6040_VIBENA);
115 twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLR, 115 twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLR,
116 TWL6040_VIBENAR); 116 TWL6040_VIBENA);
117 117
118 info->enabled = true; 118 info->enabled = true;
119} 119}
@@ -201,6 +201,13 @@ static int vibra_play(struct input_dev *input, void *data,
201 struct vibra_info *info = input_get_drvdata(input); 201 struct vibra_info *info = input_get_drvdata(input);
202 int ret; 202 int ret;
203 203
204 /* Do not allow effect, while the routing is set to use audio */
205 ret = twl6040_get_vibralr_status(info->twl6040);
206 if (ret & TWL6040_VIBSEL) {
207 dev_info(&input->dev, "Vibra is configured for audio\n");
208 return -EBUSY;
209 }
210
204 info->weak_speed = effect->u.rumble.weak_magnitude; 211 info->weak_speed = effect->u.rumble.weak_magnitude;
205 info->strong_speed = effect->u.rumble.strong_magnitude; 212 info->strong_speed = effect->u.rumble.strong_magnitude;
206 info->direction = effect->direction < EFFECT_DIR_180_DEG ? 1 : -1; 213 info->direction = effect->direction < EFFECT_DIR_180_DEG ? 1 : -1;
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-12 15:25:49 -0500