2 * USB ATI Remote support
4 * Version 2.2.0 Copyright (c) 2004 Torrey Hoffman <thoffman@arnor.net>
5 * Version 2.1.1 Copyright (c) 2002 Vladimir Dergachev
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.
12 * The 2.1.1 driver was derived from the usbati_remote and usbkbd drivers by
17 * Feb 2004: Torrey Hoffman <thoffman@arnor.net>
19 * Jun 2004: Torrey Hoffman <thoffman@arnor.net>
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>
26 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
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.
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.
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
42 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
44 * Hardware & software notes
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".
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
55 * It is possible to use multiple receivers and remotes on multiple computers
56 * simultaneously by configuring them to use specific channels.
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
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.
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.
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.
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.
80 * Or, set channel_mask = 65533, (0xFFFD), and all channels except 1 will be
83 * The default is 0 (respond to all channels). Bit 0 and bits 17-32 of this
84 * parameter are unused.
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/moduleparam.h>
94 #include <linux/usb/input.h>
95 #include <linux/wait.h>
96 #include <linux/jiffies.h>
99 * Module and Version Information, Module Parameters
102 #define ATI_REMOTE_VENDOR_ID 0x0bc7
103 #define ATI_REMOTE_PRODUCT_ID 0x004
104 #define LOLA_REMOTE_PRODUCT_ID 0x002
105 #define MEDION_REMOTE_PRODUCT_ID 0x006
107 #define DRIVER_VERSION "2.2.1"
108 #define DRIVER_AUTHOR "Torrey Hoffman <thoffman@arnor.net>"
109 #define DRIVER_DESC "ATI/X10 RF USB Remote Control"
111 #define NAME_BUFSIZE 80 /* size of product name, path buffers */
112 #define DATA_BUFSIZE 63 /* size of URB data buffers */
115 * Duplicate event filtering time.
116 * Sequential, identical KIND_FILTERED inputs with less than
117 * FILTER_TIME milliseconds between them are considered as repeat
118 * events. The hardware generates 5 events for the first keypress
119 * and we have to take this into account for an accurate repeat
122 #define FILTER_TIME 60 /* msec */
124 static unsigned long channel_mask
;
125 module_param(channel_mask
, ulong
, 0644);
126 MODULE_PARM_DESC(channel_mask
, "Bitmask of remote control channels to ignore");
129 module_param(debug
, int, 0644);
130 MODULE_PARM_DESC(debug
, "Enable extra debug messages and information");
132 static int repeat_filter
= FILTER_TIME
;
133 module_param(repeat_filter
, int, 0644);
134 MODULE_PARM_DESC(repeat_filter
, "Repeat filter time, default = 60 msec");
136 #define dbginfo(dev, format, arg...) do { if (debug) dev_info(dev , format , ## arg); } while (0)
138 #define err(format, arg...) printk(KERN_ERR format , ## arg)
140 static struct usb_device_id ati_remote_table
[] = {
141 { USB_DEVICE(ATI_REMOTE_VENDOR_ID
, ATI_REMOTE_PRODUCT_ID
) },
142 { USB_DEVICE(ATI_REMOTE_VENDOR_ID
, LOLA_REMOTE_PRODUCT_ID
) },
143 { USB_DEVICE(ATI_REMOTE_VENDOR_ID
, MEDION_REMOTE_PRODUCT_ID
) },
144 {} /* Terminating entry */
147 MODULE_DEVICE_TABLE(usb
, ati_remote_table
);
149 /* Get hi and low bytes of a 16-bits int */
150 #define HI(a) ((unsigned char)((a) >> 8))
151 #define LO(a) ((unsigned char)((a) & 0xff))
153 #define SEND_FLAG_IN_PROGRESS 1
154 #define SEND_FLAG_COMPLETE 2
156 /* Device initialization strings */
157 static char init1
[] = { 0x01, 0x00, 0x20, 0x14 };
158 static char init2
[] = { 0x01, 0x00, 0x20, 0x14, 0x20, 0x20, 0x20 };
161 struct input_dev
*idev
;
162 struct usb_device
*udev
;
163 struct usb_interface
*interface
;
167 struct usb_endpoint_descriptor
*endpoint_in
;
168 struct usb_endpoint_descriptor
*endpoint_out
;
169 unsigned char *inbuf
;
170 unsigned char *outbuf
;
171 dma_addr_t inbuf_dma
;
172 dma_addr_t outbuf_dma
;
174 unsigned char old_data
[2]; /* Detect duplicate events */
175 unsigned long old_jiffies
;
176 unsigned long acc_jiffies
; /* handle acceleration */
177 unsigned int repeat_count
;
179 char name
[NAME_BUFSIZE
];
180 char phys
[NAME_BUFSIZE
];
182 wait_queue_head_t wait
;
186 /* "Kinds" of messages sent from the hardware to the driver. */
188 #define KIND_LITERAL 1 /* Simply pass to input system */
189 #define KIND_FILTERED 2 /* Add artificial key-up events, drop keyrepeats */
190 #define KIND_LU 3 /* Directional keypad diagonals - left up, */
191 #define KIND_RU 4 /* right up, */
192 #define KIND_LD 5 /* left down, */
193 #define KIND_RD 6 /* right down */
194 #define KIND_ACCEL 7 /* Directional keypad - left, right, up, down.*/
196 /* Translation table from hardware messages to input events. */
197 static const struct {
199 unsigned char data1
, data2
;
203 } ati_remote_tbl
[] = {
204 /* Directional control pad axes */
205 {KIND_ACCEL
, 0x35, 0x70, EV_REL
, REL_X
, -1}, /* left */
206 {KIND_ACCEL
, 0x36, 0x71, EV_REL
, REL_X
, 1}, /* right */
207 {KIND_ACCEL
, 0x37, 0x72, EV_REL
, REL_Y
, -1}, /* up */
208 {KIND_ACCEL
, 0x38, 0x73, EV_REL
, REL_Y
, 1}, /* down */
209 /* Directional control pad diagonals */
210 {KIND_LU
, 0x39, 0x74, EV_REL
, 0, 0}, /* left up */
211 {KIND_RU
, 0x3a, 0x75, EV_REL
, 0, 0}, /* right up */
212 {KIND_LD
, 0x3c, 0x77, EV_REL
, 0, 0}, /* left down */
213 {KIND_RD
, 0x3b, 0x76, EV_REL
, 0, 0}, /* right down */
215 /* "Mouse button" buttons */
216 {KIND_LITERAL
, 0x3d, 0x78, EV_KEY
, BTN_LEFT
, 1}, /* left btn down */
217 {KIND_LITERAL
, 0x3e, 0x79, EV_KEY
, BTN_LEFT
, 0}, /* left btn up */
218 {KIND_LITERAL
, 0x41, 0x7c, EV_KEY
, BTN_RIGHT
, 1},/* right btn down */
219 {KIND_LITERAL
, 0x42, 0x7d, EV_KEY
, BTN_RIGHT
, 0},/* right btn up */
221 /* Artificial "doubleclick" events are generated by the hardware.
222 * They are mapped to the "side" and "extra" mouse buttons here. */
223 {KIND_FILTERED
, 0x3f, 0x7a, EV_KEY
, BTN_SIDE
, 1}, /* left dblclick */
224 {KIND_FILTERED
, 0x43, 0x7e, EV_KEY
, BTN_EXTRA
, 1},/* right dblclick */
227 {KIND_FILTERED
, 0xd2, 0x0d, EV_KEY
, KEY_1
, 1},
228 {KIND_FILTERED
, 0xd3, 0x0e, EV_KEY
, KEY_2
, 1},
229 {KIND_FILTERED
, 0xd4, 0x0f, EV_KEY
, KEY_3
, 1},
230 {KIND_FILTERED
, 0xd5, 0x10, EV_KEY
, KEY_4
, 1},
231 {KIND_FILTERED
, 0xd6, 0x11, EV_KEY
, KEY_5
, 1},
232 {KIND_FILTERED
, 0xd7, 0x12, EV_KEY
, KEY_6
, 1},
233 {KIND_FILTERED
, 0xd8, 0x13, EV_KEY
, KEY_7
, 1},
234 {KIND_FILTERED
, 0xd9, 0x14, EV_KEY
, KEY_8
, 1},
235 {KIND_FILTERED
, 0xda, 0x15, EV_KEY
, KEY_9
, 1},
236 {KIND_FILTERED
, 0xdc, 0x17, EV_KEY
, KEY_0
, 1},
237 {KIND_FILTERED
, 0xc5, 0x00, EV_KEY
, KEY_A
, 1},
238 {KIND_FILTERED
, 0xc6, 0x01, EV_KEY
, KEY_B
, 1},
239 {KIND_FILTERED
, 0xde, 0x19, EV_KEY
, KEY_C
, 1},
240 {KIND_FILTERED
, 0xe0, 0x1b, EV_KEY
, KEY_D
, 1},
241 {KIND_FILTERED
, 0xe6, 0x21, EV_KEY
, KEY_E
, 1},
242 {KIND_FILTERED
, 0xe8, 0x23, EV_KEY
, KEY_F
, 1},
245 {KIND_FILTERED
, 0xdd, 0x18, EV_KEY
, KEY_KPENTER
, 1}, /* "check" */
246 {KIND_FILTERED
, 0xdb, 0x16, EV_KEY
, KEY_MENU
, 1}, /* "menu" */
247 {KIND_FILTERED
, 0xc7, 0x02, EV_KEY
, KEY_POWER
, 1}, /* Power */
248 {KIND_FILTERED
, 0xc8, 0x03, EV_KEY
, KEY_TV
, 1}, /* TV */
249 {KIND_FILTERED
, 0xc9, 0x04, EV_KEY
, KEY_DVD
, 1}, /* DVD */
250 {KIND_FILTERED
, 0xca, 0x05, EV_KEY
, KEY_WWW
, 1}, /* WEB */
251 {KIND_FILTERED
, 0xcb, 0x06, EV_KEY
, KEY_BOOKMARKS
, 1}, /* "book" */
252 {KIND_FILTERED
, 0xcc, 0x07, EV_KEY
, KEY_EDIT
, 1}, /* "hand" */
253 {KIND_FILTERED
, 0xe1, 0x1c, EV_KEY
, KEY_COFFEE
, 1}, /* "timer" */
254 {KIND_FILTERED
, 0xe5, 0x20, EV_KEY
, KEY_FRONT
, 1}, /* "max" */
255 {KIND_FILTERED
, 0xe2, 0x1d, EV_KEY
, KEY_LEFT
, 1}, /* left */
256 {KIND_FILTERED
, 0xe4, 0x1f, EV_KEY
, KEY_RIGHT
, 1}, /* right */
257 {KIND_FILTERED
, 0xe7, 0x22, EV_KEY
, KEY_DOWN
, 1}, /* down */
258 {KIND_FILTERED
, 0xdf, 0x1a, EV_KEY
, KEY_UP
, 1}, /* up */
259 {KIND_FILTERED
, 0xe3, 0x1e, EV_KEY
, KEY_OK
, 1}, /* "OK" */
260 {KIND_FILTERED
, 0xce, 0x09, EV_KEY
, KEY_VOLUMEDOWN
, 1}, /* VOL + */
261 {KIND_FILTERED
, 0xcd, 0x08, EV_KEY
, KEY_VOLUMEUP
, 1}, /* VOL - */
262 {KIND_FILTERED
, 0xcf, 0x0a, EV_KEY
, KEY_MUTE
, 1}, /* MUTE */
263 {KIND_FILTERED
, 0xd0, 0x0b, EV_KEY
, KEY_CHANNELUP
, 1}, /* CH + */
264 {KIND_FILTERED
, 0xd1, 0x0c, EV_KEY
, KEY_CHANNELDOWN
, 1},/* CH - */
265 {KIND_FILTERED
, 0xec, 0x27, EV_KEY
, KEY_RECORD
, 1}, /* ( o) red */
266 {KIND_FILTERED
, 0xea, 0x25, EV_KEY
, KEY_PLAY
, 1}, /* ( >) */
267 {KIND_FILTERED
, 0xe9, 0x24, EV_KEY
, KEY_REWIND
, 1}, /* (<<) */
268 {KIND_FILTERED
, 0xeb, 0x26, EV_KEY
, KEY_FORWARD
, 1}, /* (>>) */
269 {KIND_FILTERED
, 0xed, 0x28, EV_KEY
, KEY_STOP
, 1}, /* ([]) */
270 {KIND_FILTERED
, 0xee, 0x29, EV_KEY
, KEY_PAUSE
, 1}, /* ('') */
271 {KIND_FILTERED
, 0xf0, 0x2b, EV_KEY
, KEY_PREVIOUS
, 1}, /* (<-) */
272 {KIND_FILTERED
, 0xef, 0x2a, EV_KEY
, KEY_NEXT
, 1}, /* (>+) */
273 {KIND_FILTERED
, 0xf2, 0x2D, EV_KEY
, KEY_INFO
, 1}, /* PLAYING */
274 {KIND_FILTERED
, 0xf3, 0x2E, EV_KEY
, KEY_HOME
, 1}, /* TOP */
275 {KIND_FILTERED
, 0xf4, 0x2F, EV_KEY
, KEY_END
, 1}, /* END */
276 {KIND_FILTERED
, 0xf5, 0x30, EV_KEY
, KEY_SELECT
, 1}, /* SELECT */
278 {KIND_END
, 0x00, 0x00, EV_MAX
+ 1, 0, 0}
281 /* Local function prototypes */
282 static void ati_remote_dump (unsigned char *data
, unsigned int actual_length
);
283 static int ati_remote_open (struct input_dev
*inputdev
);
284 static void ati_remote_close (struct input_dev
*inputdev
);
285 static int ati_remote_sendpacket (struct ati_remote
*ati_remote
, u16 cmd
, unsigned char *data
);
286 static void ati_remote_irq_out (struct urb
*urb
);
287 static void ati_remote_irq_in (struct urb
*urb
);
288 static void ati_remote_input_report (struct urb
*urb
);
289 static int ati_remote_initialize (struct ati_remote
*ati_remote
);
290 static int ati_remote_probe (struct usb_interface
*interface
, const struct usb_device_id
*id
);
291 static void ati_remote_disconnect (struct usb_interface
*interface
);
293 /* usb specific object to register with the usb subsystem */
294 static struct usb_driver ati_remote_driver
= {
295 .name
= "ati_remote",
296 .probe
= ati_remote_probe
,
297 .disconnect
= ati_remote_disconnect
,
298 .id_table
= ati_remote_table
,
302 * ati_remote_dump_input
304 static void ati_remote_dump(unsigned char *data
, unsigned int len
)
306 if ((len
== 1) && (data
[0] != (unsigned char)0xff) && (data
[0] != 0x00))
307 warn("Weird byte 0x%02x", data
[0]);
309 warn("Weird key %02x %02x %02x %02x",
310 data
[0], data
[1], data
[2], data
[3]);
312 warn("Weird data, len=%d %02x %02x %02x %02x %02x %02x ...",
313 len
, data
[0], data
[1], data
[2], data
[3], data
[4], data
[5]);
319 static int ati_remote_open(struct input_dev
*inputdev
)
321 struct ati_remote
*ati_remote
= inputdev
->private;
323 /* On first open, submit the read urb which was set up previously. */
324 ati_remote
->irq_urb
->dev
= ati_remote
->udev
;
325 if (usb_submit_urb(ati_remote
->irq_urb
, GFP_KERNEL
)) {
326 dev_err(&ati_remote
->interface
->dev
,
327 "%s: usb_submit_urb failed!\n", __FUNCTION__
);
337 static void ati_remote_close(struct input_dev
*inputdev
)
339 struct ati_remote
*ati_remote
= inputdev
->private;
341 usb_kill_urb(ati_remote
->irq_urb
);
347 static void ati_remote_irq_out(struct urb
*urb
)
349 struct ati_remote
*ati_remote
= urb
->context
;
352 dev_dbg(&ati_remote
->interface
->dev
, "%s: status %d\n",
353 __FUNCTION__
, urb
->status
);
357 ati_remote
->send_flags
|= SEND_FLAG_COMPLETE
;
359 wake_up(&ati_remote
->wait
);
363 * ati_remote_sendpacket
365 * Used to send device initialization strings
367 static int ati_remote_sendpacket(struct ati_remote
*ati_remote
, u16 cmd
, unsigned char *data
)
372 memcpy(ati_remote
->out_urb
->transfer_buffer
+ 1, data
, LO(cmd
));
373 ((char *) ati_remote
->out_urb
->transfer_buffer
)[0] = HI(cmd
);
375 ati_remote
->out_urb
->transfer_buffer_length
= LO(cmd
) + 1;
376 ati_remote
->out_urb
->dev
= ati_remote
->udev
;
377 ati_remote
->send_flags
= SEND_FLAG_IN_PROGRESS
;
379 retval
= usb_submit_urb(ati_remote
->out_urb
, GFP_ATOMIC
);
381 dev_dbg(&ati_remote
->interface
->dev
,
382 "sendpacket: usb_submit_urb failed: %d\n", retval
);
386 wait_event_timeout(ati_remote
->wait
,
387 ((ati_remote
->out_urb
->status
!= -EINPROGRESS
) ||
388 (ati_remote
->send_flags
& SEND_FLAG_COMPLETE
)),
390 usb_kill_urb(ati_remote
->out_urb
);
396 * ati_remote_event_lookup
398 static int ati_remote_event_lookup(int rem
, unsigned char d1
, unsigned char d2
)
402 for (i
= 0; ati_remote_tbl
[i
].kind
!= KIND_END
; i
++) {
404 * Decide if the table entry matches the remote input.
406 if ((((ati_remote_tbl
[i
].data1
& 0x0f) == (d1
& 0x0f))) &&
407 ((((ati_remote_tbl
[i
].data1
>> 4) -
408 (d1
>> 4) + rem
) & 0x0f) == 0x0f) &&
409 (ati_remote_tbl
[i
].data2
== d2
))
417 * ati_remote_compute_accel
419 * Implements acceleration curve for directional control pad
420 * If elapsed time since last event is > 1/4 second, user "stopped",
421 * so reset acceleration. Otherwise, user is probably holding the control
422 * pad down, so we increase acceleration, ramping up over two seconds to
425 static int ati_remote_compute_accel(struct ati_remote
*ati_remote
)
427 static const char accel
[] = { 1, 2, 4, 6, 9, 13, 20 };
428 unsigned long now
= jiffies
;
431 if (time_after(now
, ati_remote
->old_jiffies
+ msecs_to_jiffies(250))) {
433 ati_remote
->acc_jiffies
= now
;
435 else if (time_before(now
, ati_remote
->acc_jiffies
+ msecs_to_jiffies(125)))
437 else if (time_before(now
, ati_remote
->acc_jiffies
+ msecs_to_jiffies(250)))
439 else if (time_before(now
, ati_remote
->acc_jiffies
+ msecs_to_jiffies(500)))
441 else if (time_before(now
, ati_remote
->acc_jiffies
+ msecs_to_jiffies(1000)))
443 else if (time_before(now
, ati_remote
->acc_jiffies
+ msecs_to_jiffies(1500)))
445 else if (time_before(now
, ati_remote
->acc_jiffies
+ msecs_to_jiffies(2000)))
454 * ati_remote_report_input
456 static void ati_remote_input_report(struct urb
*urb
)
458 struct ati_remote
*ati_remote
= urb
->context
;
459 unsigned char *data
= ati_remote
->inbuf
;
460 struct input_dev
*dev
= ati_remote
->idev
;
464 /* Deal with strange looking inputs */
465 if ( (urb
->actual_length
!= 4) || (data
[0] != 0x14) ||
466 ((data
[3] & 0x0f) != 0x00) ) {
467 ati_remote_dump(data
, urb
->actual_length
);
471 /* Mask unwanted remote channels. */
472 /* note: remote_num is 0-based, channel 1 on remote == 0 here */
473 remote_num
= (data
[3] >> 4) & 0x0f;
474 if (channel_mask
& (1 << (remote_num
+ 1))) {
475 dbginfo(&ati_remote
->interface
->dev
,
476 "Masked input from channel 0x%02x: data %02x,%02x, mask= 0x%02lx\n",
477 remote_num
, data
[1], data
[2], channel_mask
);
481 /* Look up event code index in translation table */
482 index
= ati_remote_event_lookup(remote_num
, data
[1], data
[2]);
484 dev_warn(&ati_remote
->interface
->dev
,
485 "Unknown input from channel 0x%02x: data %02x,%02x\n",
486 remote_num
, data
[1], data
[2]);
489 dbginfo(&ati_remote
->interface
->dev
,
490 "channel 0x%02x; data %02x,%02x; index %d; keycode %d\n",
491 remote_num
, data
[1], data
[2], index
, ati_remote_tbl
[index
].code
);
493 if (ati_remote_tbl
[index
].kind
== KIND_LITERAL
) {
494 input_event(dev
, ati_remote_tbl
[index
].type
,
495 ati_remote_tbl
[index
].code
,
496 ati_remote_tbl
[index
].value
);
499 ati_remote
->old_jiffies
= jiffies
;
503 if (ati_remote_tbl
[index
].kind
== KIND_FILTERED
) {
504 /* Filter duplicate events which happen "too close" together. */
505 if (ati_remote
->old_data
[0] == data
[1] &&
506 ati_remote
->old_data
[1] == data
[2] &&
507 time_before(jiffies
, ati_remote
->old_jiffies
+ msecs_to_jiffies(repeat_filter
))) {
508 ati_remote
->repeat_count
++;
510 ati_remote
->repeat_count
= 0;
513 ati_remote
->old_data
[0] = data
[1];
514 ati_remote
->old_data
[1] = data
[2];
515 ati_remote
->old_jiffies
= jiffies
;
517 if (ati_remote
->repeat_count
> 0 &&
518 ati_remote
->repeat_count
< 5)
522 input_event(dev
, ati_remote_tbl
[index
].type
,
523 ati_remote_tbl
[index
].code
, 1);
525 input_event(dev
, ati_remote_tbl
[index
].type
,
526 ati_remote_tbl
[index
].code
, 0);
532 * Other event kinds are from the directional control pad, and have an
533 * acceleration factor applied to them. Without this acceleration, the
534 * control pad is mostly unusable.
536 acc
= ati_remote_compute_accel(ati_remote
);
538 switch (ati_remote_tbl
[index
].kind
) {
540 input_event(dev
, ati_remote_tbl
[index
].type
,
541 ati_remote_tbl
[index
].code
,
542 ati_remote_tbl
[index
].value
* acc
);
545 input_report_rel(dev
, REL_X
, -acc
);
546 input_report_rel(dev
, REL_Y
, -acc
);
549 input_report_rel(dev
, REL_X
, acc
);
550 input_report_rel(dev
, REL_Y
, -acc
);
553 input_report_rel(dev
, REL_X
, -acc
);
554 input_report_rel(dev
, REL_Y
, acc
);
557 input_report_rel(dev
, REL_X
, acc
);
558 input_report_rel(dev
, REL_Y
, acc
);
561 dev_dbg(&ati_remote
->interface
->dev
, "ati_remote kind=%d\n",
562 ati_remote_tbl
[index
].kind
);
566 ati_remote
->old_jiffies
= jiffies
;
567 ati_remote
->old_data
[0] = data
[1];
568 ati_remote
->old_data
[1] = data
[2];
575 static void ati_remote_irq_in(struct urb
*urb
)
577 struct ati_remote
*ati_remote
= urb
->context
;
580 switch (urb
->status
) {
581 case 0: /* success */
582 ati_remote_input_report(urb
);
584 case -ECONNRESET
: /* unlink */
587 dev_dbg(&ati_remote
->interface
->dev
, "%s: urb error status, unlink? \n",
591 dev_dbg(&ati_remote
->interface
->dev
, "%s: Nonzero urb status %d\n",
592 __FUNCTION__
, urb
->status
);
595 retval
= usb_submit_urb(urb
, SLAB_ATOMIC
);
597 dev_err(&ati_remote
->interface
->dev
, "%s: usb_submit_urb()=%d\n",
598 __FUNCTION__
, retval
);
602 * ati_remote_alloc_buffers
604 static int ati_remote_alloc_buffers(struct usb_device
*udev
,
605 struct ati_remote
*ati_remote
)
607 ati_remote
->inbuf
= usb_buffer_alloc(udev
, DATA_BUFSIZE
, SLAB_ATOMIC
,
608 &ati_remote
->inbuf_dma
);
609 if (!ati_remote
->inbuf
)
612 ati_remote
->outbuf
= usb_buffer_alloc(udev
, DATA_BUFSIZE
, SLAB_ATOMIC
,
613 &ati_remote
->outbuf_dma
);
614 if (!ati_remote
->outbuf
)
617 ati_remote
->irq_urb
= usb_alloc_urb(0, GFP_KERNEL
);
618 if (!ati_remote
->irq_urb
)
621 ati_remote
->out_urb
= usb_alloc_urb(0, GFP_KERNEL
);
622 if (!ati_remote
->out_urb
)
629 * ati_remote_free_buffers
631 static void ati_remote_free_buffers(struct ati_remote
*ati_remote
)
633 if (ati_remote
->irq_urb
)
634 usb_free_urb(ati_remote
->irq_urb
);
636 if (ati_remote
->out_urb
)
637 usb_free_urb(ati_remote
->out_urb
);
639 if (ati_remote
->inbuf
)
640 usb_buffer_free(ati_remote
->udev
, DATA_BUFSIZE
,
641 ati_remote
->inbuf
, ati_remote
->inbuf_dma
);
643 if (ati_remote
->outbuf
)
644 usb_buffer_free(ati_remote
->udev
, DATA_BUFSIZE
,
645 ati_remote
->inbuf
, ati_remote
->outbuf_dma
);
648 static void ati_remote_input_init(struct ati_remote
*ati_remote
)
650 struct input_dev
*idev
= ati_remote
->idev
;
653 idev
->evbit
[0] = BIT(EV_KEY
) | BIT(EV_REL
);
654 idev
->keybit
[LONG(BTN_MOUSE
)] = ( BIT(BTN_LEFT
) | BIT(BTN_RIGHT
) |
655 BIT(BTN_SIDE
) | BIT(BTN_EXTRA
) );
656 idev
->relbit
[0] = BIT(REL_X
) | BIT(REL_Y
);
657 for (i
= 0; ati_remote_tbl
[i
].kind
!= KIND_END
; i
++)
658 if (ati_remote_tbl
[i
].type
== EV_KEY
)
659 set_bit(ati_remote_tbl
[i
].code
, idev
->keybit
);
661 idev
->private = ati_remote
;
662 idev
->open
= ati_remote_open
;
663 idev
->close
= ati_remote_close
;
665 idev
->name
= ati_remote
->name
;
666 idev
->phys
= ati_remote
->phys
;
668 usb_to_input_id(ati_remote
->udev
, &idev
->id
);
669 idev
->cdev
.dev
= &ati_remote
->udev
->dev
;
672 static int ati_remote_initialize(struct ati_remote
*ati_remote
)
674 struct usb_device
*udev
= ati_remote
->udev
;
677 init_waitqueue_head(&ati_remote
->wait
);
680 pipe
= usb_rcvintpipe(udev
, ati_remote
->endpoint_in
->bEndpointAddress
);
681 maxp
= usb_maxpacket(udev
, pipe
, usb_pipeout(pipe
));
682 maxp
= (maxp
> DATA_BUFSIZE
) ? DATA_BUFSIZE
: maxp
;
684 usb_fill_int_urb(ati_remote
->irq_urb
, udev
, pipe
, ati_remote
->inbuf
,
685 maxp
, ati_remote_irq_in
, ati_remote
,
686 ati_remote
->endpoint_in
->bInterval
);
687 ati_remote
->irq_urb
->transfer_dma
= ati_remote
->inbuf_dma
;
688 ati_remote
->irq_urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
691 pipe
= usb_sndintpipe(udev
, ati_remote
->endpoint_out
->bEndpointAddress
);
692 maxp
= usb_maxpacket(udev
, pipe
, usb_pipeout(pipe
));
693 maxp
= (maxp
> DATA_BUFSIZE
) ? DATA_BUFSIZE
: maxp
;
695 usb_fill_int_urb(ati_remote
->out_urb
, udev
, pipe
, ati_remote
->outbuf
,
696 maxp
, ati_remote_irq_out
, ati_remote
,
697 ati_remote
->endpoint_out
->bInterval
);
698 ati_remote
->out_urb
->transfer_dma
= ati_remote
->outbuf_dma
;
699 ati_remote
->out_urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
701 /* send initialization strings */
702 if ((ati_remote_sendpacket(ati_remote
, 0x8004, init1
)) ||
703 (ati_remote_sendpacket(ati_remote
, 0x8007, init2
))) {
704 dev_err(&ati_remote
->interface
->dev
,
705 "Initializing ati_remote hardware failed.\n");
715 static int ati_remote_probe(struct usb_interface
*interface
, const struct usb_device_id
*id
)
717 struct usb_device
*udev
= interface_to_usbdev(interface
);
718 struct usb_host_interface
*iface_host
= interface
->cur_altsetting
;
719 struct usb_endpoint_descriptor
*endpoint_in
, *endpoint_out
;
720 struct ati_remote
*ati_remote
;
721 struct input_dev
*input_dev
;
724 if (iface_host
->desc
.bNumEndpoints
!= 2) {
725 err("%s: Unexpected desc.bNumEndpoints\n", __FUNCTION__
);
729 endpoint_in
= &iface_host
->endpoint
[0].desc
;
730 endpoint_out
= &iface_host
->endpoint
[1].desc
;
732 if (!usb_endpoint_is_int_in(endpoint_in
)) {
733 err("%s: Unexpected endpoint_in\n", __FUNCTION__
);
736 if (le16_to_cpu(endpoint_in
->wMaxPacketSize
) == 0) {
737 err("%s: endpoint_in message size==0? \n", __FUNCTION__
);
741 ati_remote
= kzalloc(sizeof (struct ati_remote
), GFP_KERNEL
);
742 input_dev
= input_allocate_device();
743 if (!ati_remote
|| !input_dev
)
746 /* Allocate URB buffers, URBs */
747 if (ati_remote_alloc_buffers(udev
, ati_remote
))
750 ati_remote
->endpoint_in
= endpoint_in
;
751 ati_remote
->endpoint_out
= endpoint_out
;
752 ati_remote
->udev
= udev
;
753 ati_remote
->idev
= input_dev
;
754 ati_remote
->interface
= interface
;
756 usb_make_path(udev
, ati_remote
->phys
, sizeof(ati_remote
->phys
));
757 strlcpy(ati_remote
->phys
, "/input0", sizeof(ati_remote
->phys
));
759 if (udev
->manufacturer
)
760 strlcpy(ati_remote
->name
, udev
->manufacturer
, sizeof(ati_remote
->name
));
763 snprintf(ati_remote
->name
, sizeof(ati_remote
->name
),
764 "%s %s", ati_remote
->name
, udev
->product
);
766 if (!strlen(ati_remote
->name
))
767 snprintf(ati_remote
->name
, sizeof(ati_remote
->name
),
768 DRIVER_DESC
"(%04x,%04x)",
769 le16_to_cpu(ati_remote
->udev
->descriptor
.idVendor
),
770 le16_to_cpu(ati_remote
->udev
->descriptor
.idProduct
));
772 ati_remote_input_init(ati_remote
);
774 /* Device Hardware Initialization - fills in ati_remote->idev from udev. */
775 err
= ati_remote_initialize(ati_remote
);
779 /* Set up and register input device */
780 input_register_device(ati_remote
->idev
);
782 usb_set_intfdata(interface
, ati_remote
);
785 fail3
: usb_kill_urb(ati_remote
->irq_urb
);
786 usb_kill_urb(ati_remote
->out_urb
);
787 fail2
: ati_remote_free_buffers(ati_remote
);
788 fail1
: input_free_device(input_dev
);
794 * ati_remote_disconnect
796 static void ati_remote_disconnect(struct usb_interface
*interface
)
798 struct ati_remote
*ati_remote
;
800 ati_remote
= usb_get_intfdata(interface
);
801 usb_set_intfdata(interface
, NULL
);
803 warn("%s - null device?\n", __FUNCTION__
);
807 usb_kill_urb(ati_remote
->irq_urb
);
808 usb_kill_urb(ati_remote
->out_urb
);
809 input_unregister_device(ati_remote
->idev
);
810 ati_remote_free_buffers(ati_remote
);
817 static int __init
ati_remote_init(void)
821 result
= usb_register(&ati_remote_driver
);
823 err("usb_register error #%d\n", result
);
825 info("Registered USB driver " DRIVER_DESC
" v. " DRIVER_VERSION
);
833 static void __exit
ati_remote_exit(void)
835 usb_deregister(&ati_remote_driver
);
839 * module specification
842 module_init(ati_remote_init
);
843 module_exit(ati_remote_exit
);
845 MODULE_AUTHOR(DRIVER_AUTHOR
);
846 MODULE_DESCRIPTION(DRIVER_DESC
);
847 MODULE_LICENSE("GPL");