2 * keyspan_remote: USB driver for the Keyspan DMR
4 * Copyright (C) 2005 Zymeta Corporation - Michael Downey (downey@zymeta.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation, version 2.
10 * This driver has been put together with the support of Innosys, Inc.
11 * and Keyspan, Inc the manufacturers of the Keyspan USB DMR product.
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/slab.h>
17 #include <linux/module.h>
18 #include <linux/usb/input.h>
20 #define DRIVER_VERSION "v0.1"
21 #define DRIVER_AUTHOR "Michael Downey <downey@zymeta.com>"
22 #define DRIVER_DESC "Driver for the USB Keyspan remote control."
23 #define DRIVER_LICENSE "GPL"
25 /* Parameters that can be passed to the driver. */
27 module_param(debug
, int, 0444);
28 MODULE_PARM_DESC(debug
, "Enable extra debug messages and information");
30 /* Vendor and product ids */
31 #define USB_KEYSPAN_VENDOR_ID 0x06CD
32 #define USB_KEYSPAN_PRODUCT_UIA11 0x0202
34 /* Defines for converting the data from the remote. */
36 #define ZERO_MASK 0x1F /* 5 bits for a 0 */
38 #define ONE_MASK 0x3F /* 6 bits for a 1 */
40 #define SYNC_MASK 0x3FFF /* 14 bits for a SYNC sequence */
42 #define STOP_MASK 0x1F /* 5 bits for the STOP sequence */
45 #define RECV_SIZE 8 /* The UIA-11 type have a 8 byte limit. */
48 * Table that maps the 31 possible keycodes to input keys.
49 * Currently there are 15 and 17 button models so RESERVED codes
50 * are blank areas in the mapping.
52 static const unsigned short keyspan_key_table
[] = {
53 KEY_RESERVED
, /* 0 is just a place holder. */
87 /* table of devices that work with this driver */
88 static const struct usb_device_id keyspan_table
[] = {
89 { USB_DEVICE(USB_KEYSPAN_VENDOR_ID
, USB_KEYSPAN_PRODUCT_UIA11
) },
90 { } /* Terminating entry */
93 /* Structure to store all the real stuff that a remote sends to us. */
94 struct keyspan_message
{
100 /* Structure used for all the bit testing magic needed to be done. */
109 /* Structure to hold all of our driver specific stuff */
113 unsigned short keymap
[ARRAY_SIZE(keyspan_key_table
)];
114 struct usb_device
*udev
;
115 struct input_dev
*input
;
116 struct usb_interface
*interface
;
117 struct usb_endpoint_descriptor
*in_endpoint
;
121 unsigned char *in_buffer
;
123 /* variables used to parse messages from remote. */
124 struct bit_tester data
;
129 static struct usb_driver keyspan_driver
;
132 * Debug routine that prints out what we've received from the remote.
134 static void keyspan_print(struct usb_keyspan
* dev
) /*unsigned char* data)*/
136 char codes
[4 * RECV_SIZE
];
139 for (i
= 0; i
< RECV_SIZE
; i
++)
140 snprintf(codes
+ i
* 3, 4, "%02x ", dev
->in_buffer
[i
]);
142 dev_info(&dev
->udev
->dev
, "%s\n", codes
);
146 * Routine that manages the bit_tester structure. It makes sure that there are
147 * at least bits_needed bits loaded into the tester.
149 static int keyspan_load_tester(struct usb_keyspan
* dev
, int bits_needed
)
151 if (dev
->data
.bits_left
>= bits_needed
)
155 * Somehow we've missed the last message. The message will be repeated
156 * though so it's not too big a deal
158 if (dev
->data
.pos
>= dev
->data
.len
) {
159 dev_dbg(&dev
->interface
->dev
,
160 "%s - Error ran out of data. pos: %d, len: %d\n",
161 __func__
, dev
->data
.pos
, dev
->data
.len
);
165 /* Load as much as we can into the tester. */
166 while ((dev
->data
.bits_left
+ 7 < (sizeof(dev
->data
.tester
) * 8)) &&
167 (dev
->data
.pos
< dev
->data
.len
)) {
168 dev
->data
.tester
+= (dev
->data
.buffer
[dev
->data
.pos
++] << dev
->data
.bits_left
);
169 dev
->data
.bits_left
+= 8;
175 static void keyspan_report_button(struct usb_keyspan
*remote
, int button
, int press
)
177 struct input_dev
*input
= remote
->input
;
179 input_event(input
, EV_MSC
, MSC_SCAN
, button
);
180 input_report_key(input
, remote
->keymap
[button
], press
);
185 * Routine that handles all the logic needed to parse out the message from the remote.
187 static void keyspan_check_data(struct usb_keyspan
*remote
)
191 struct keyspan_message message
;
193 switch(remote
->stage
) {
196 * In stage 0 we want to find the start of a message. The remote sends a 0xFF as filler.
197 * So the first byte that isn't a FF should be the start of a new message.
199 for (i
= 0; i
< RECV_SIZE
&& remote
->in_buffer
[i
] == GAP
; ++i
);
202 memcpy(remote
->data
.buffer
, remote
->in_buffer
, RECV_SIZE
);
203 remote
->data
.len
= RECV_SIZE
;
204 remote
->data
.pos
= 0;
205 remote
->data
.tester
= 0;
206 remote
->data
.bits_left
= 0;
213 * Stage 1 we should have 16 bytes and should be able to detect a
214 * SYNC. The SYNC is 14 bits, 7 0's and then 7 1's.
216 memcpy(remote
->data
.buffer
+ remote
->data
.len
, remote
->in_buffer
, RECV_SIZE
);
217 remote
->data
.len
+= RECV_SIZE
;
220 while ((remote
->data
.bits_left
>= 14 || remote
->data
.pos
< remote
->data
.len
) && !found
) {
221 for (i
= 0; i
< 8; ++i
) {
222 if (keyspan_load_tester(remote
, 14) != 0) {
227 if ((remote
->data
.tester
& SYNC_MASK
) == SYNC
) {
228 remote
->data
.tester
= remote
->data
.tester
>> 14;
229 remote
->data
.bits_left
-= 14;
233 remote
->data
.tester
= remote
->data
.tester
>> 1;
234 --remote
->data
.bits_left
;
241 remote
->data
.len
= 0;
249 * Stage 2 we should have 24 bytes which will be enough for a full
250 * message. We need to parse out the system code, button code,
251 * toggle code, and stop.
253 memcpy(remote
->data
.buffer
+ remote
->data
.len
, remote
->in_buffer
, RECV_SIZE
);
254 remote
->data
.len
+= RECV_SIZE
;
257 for (i
= 0; i
< 9; i
++) {
258 keyspan_load_tester(remote
, 6);
260 if ((remote
->data
.tester
& ZERO_MASK
) == ZERO
) {
261 message
.system
= message
.system
<< 1;
262 remote
->data
.tester
= remote
->data
.tester
>> 5;
263 remote
->data
.bits_left
-= 5;
264 } else if ((remote
->data
.tester
& ONE_MASK
) == ONE
) {
265 message
.system
= (message
.system
<< 1) + 1;
266 remote
->data
.tester
= remote
->data
.tester
>> 6;
267 remote
->data
.bits_left
-= 6;
269 dev_err(&remote
->interface
->dev
,
270 "%s - Unknown sequence found in system data.\n",
278 for (i
= 0; i
< 5; i
++) {
279 keyspan_load_tester(remote
, 6);
281 if ((remote
->data
.tester
& ZERO_MASK
) == ZERO
) {
282 message
.button
= message
.button
<< 1;
283 remote
->data
.tester
= remote
->data
.tester
>> 5;
284 remote
->data
.bits_left
-= 5;
285 } else if ((remote
->data
.tester
& ONE_MASK
) == ONE
) {
286 message
.button
= (message
.button
<< 1) + 1;
287 remote
->data
.tester
= remote
->data
.tester
>> 6;
288 remote
->data
.bits_left
-= 6;
290 dev_err(&remote
->interface
->dev
,
291 "%s - Unknown sequence found in button data.\n",
298 keyspan_load_tester(remote
, 6);
299 if ((remote
->data
.tester
& ZERO_MASK
) == ZERO
) {
301 remote
->data
.tester
= remote
->data
.tester
>> 5;
302 remote
->data
.bits_left
-= 5;
303 } else if ((remote
->data
.tester
& ONE_MASK
) == ONE
) {
305 remote
->data
.tester
= remote
->data
.tester
>> 6;
306 remote
->data
.bits_left
-= 6;
308 dev_err(&remote
->interface
->dev
,
309 "%s - Error in message, invalid toggle.\n",
315 keyspan_load_tester(remote
, 5);
316 if ((remote
->data
.tester
& STOP_MASK
) == STOP
) {
317 remote
->data
.tester
= remote
->data
.tester
>> 5;
318 remote
->data
.bits_left
-= 5;
320 dev_err(&remote
->interface
->dev
,
321 "Bad message received, no stop bit found.\n");
324 dev_dbg(&remote
->interface
->dev
,
325 "%s found valid message: system: %d, button: %d, toggle: %d\n",
326 __func__
, message
.system
, message
.button
, message
.toggle
);
328 if (message
.toggle
!= remote
->toggle
) {
329 keyspan_report_button(remote
, message
.button
, 1);
330 keyspan_report_button(remote
, message
.button
, 0);
331 remote
->toggle
= message
.toggle
;
340 * Routine for sending all the initialization messages to the remote.
342 static int keyspan_setup(struct usb_device
* dev
)
346 retval
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
347 0x11, 0x40, 0x5601, 0x0, NULL
, 0,
348 USB_CTRL_SET_TIMEOUT
);
350 dev_dbg(&dev
->dev
, "%s - failed to set bit rate due to error: %d\n",
355 retval
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
356 0x44, 0x40, 0x0, 0x0, NULL
, 0,
357 USB_CTRL_SET_TIMEOUT
);
359 dev_dbg(&dev
->dev
, "%s - failed to set resume sensitivity due to error: %d\n",
364 retval
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
365 0x22, 0x40, 0x0, 0x0, NULL
, 0,
366 USB_CTRL_SET_TIMEOUT
);
368 dev_dbg(&dev
->dev
, "%s - failed to turn receive on due to error: %d\n",
373 dev_dbg(&dev
->dev
, "%s - Setup complete.\n", __func__
);
378 * Routine used to handle a new message that has come in.
380 static void keyspan_irq_recv(struct urb
*urb
)
382 struct usb_keyspan
*dev
= urb
->context
;
385 /* Check our status in case we need to bail out early. */
386 switch (urb
->status
) {
390 /* Device went away so don't keep trying to read from it. */
403 keyspan_check_data(dev
);
406 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
408 dev_err(&dev
->interface
->dev
,
409 "%s - usb_submit_urb failed with result: %d\n",
413 static int keyspan_open(struct input_dev
*dev
)
415 struct usb_keyspan
*remote
= input_get_drvdata(dev
);
417 remote
->irq_urb
->dev
= remote
->udev
;
418 if (usb_submit_urb(remote
->irq_urb
, GFP_KERNEL
))
424 static void keyspan_close(struct input_dev
*dev
)
426 struct usb_keyspan
*remote
= input_get_drvdata(dev
);
428 usb_kill_urb(remote
->irq_urb
);
431 static struct usb_endpoint_descriptor
*keyspan_get_in_endpoint(struct usb_host_interface
*iface
)
434 struct usb_endpoint_descriptor
*endpoint
;
437 for (i
= 0; i
< iface
->desc
.bNumEndpoints
; ++i
) {
438 endpoint
= &iface
->endpoint
[i
].desc
;
440 if (usb_endpoint_is_int_in(endpoint
)) {
441 /* we found our interrupt in endpoint */
450 * Routine that sets up the driver to handle a specific USB device detected on the bus.
452 static int keyspan_probe(struct usb_interface
*interface
, const struct usb_device_id
*id
)
454 struct usb_device
*udev
= interface_to_usbdev(interface
);
455 struct usb_endpoint_descriptor
*endpoint
;
456 struct usb_keyspan
*remote
;
457 struct input_dev
*input_dev
;
460 endpoint
= keyspan_get_in_endpoint(interface
->cur_altsetting
);
464 remote
= kzalloc(sizeof(*remote
), GFP_KERNEL
);
465 input_dev
= input_allocate_device();
466 if (!remote
|| !input_dev
) {
472 remote
->input
= input_dev
;
473 remote
->interface
= interface
;
474 remote
->in_endpoint
= endpoint
;
475 remote
->toggle
= -1; /* Set to -1 so we will always not match the toggle from the first remote message. */
477 remote
->in_buffer
= usb_alloc_coherent(udev
, RECV_SIZE
, GFP_ATOMIC
, &remote
->in_dma
);
478 if (!remote
->in_buffer
) {
483 remote
->irq_urb
= usb_alloc_urb(0, GFP_KERNEL
);
484 if (!remote
->irq_urb
) {
489 error
= keyspan_setup(udev
);
495 if (udev
->manufacturer
)
496 strlcpy(remote
->name
, udev
->manufacturer
, sizeof(remote
->name
));
499 if (udev
->manufacturer
)
500 strlcat(remote
->name
, " ", sizeof(remote
->name
));
501 strlcat(remote
->name
, udev
->product
, sizeof(remote
->name
));
504 if (!strlen(remote
->name
))
505 snprintf(remote
->name
, sizeof(remote
->name
),
506 "USB Keyspan Remote %04x:%04x",
507 le16_to_cpu(udev
->descriptor
.idVendor
),
508 le16_to_cpu(udev
->descriptor
.idProduct
));
510 usb_make_path(udev
, remote
->phys
, sizeof(remote
->phys
));
511 strlcat(remote
->phys
, "/input0", sizeof(remote
->phys
));
512 memcpy(remote
->keymap
, keyspan_key_table
, sizeof(remote
->keymap
));
514 input_dev
->name
= remote
->name
;
515 input_dev
->phys
= remote
->phys
;
516 usb_to_input_id(udev
, &input_dev
->id
);
517 input_dev
->dev
.parent
= &interface
->dev
;
518 input_dev
->keycode
= remote
->keymap
;
519 input_dev
->keycodesize
= sizeof(unsigned short);
520 input_dev
->keycodemax
= ARRAY_SIZE(remote
->keymap
);
522 input_set_capability(input_dev
, EV_MSC
, MSC_SCAN
);
523 __set_bit(EV_KEY
, input_dev
->evbit
);
524 for (i
= 0; i
< ARRAY_SIZE(keyspan_key_table
); i
++)
525 __set_bit(keyspan_key_table
[i
], input_dev
->keybit
);
526 __clear_bit(KEY_RESERVED
, input_dev
->keybit
);
528 input_set_drvdata(input_dev
, remote
);
530 input_dev
->open
= keyspan_open
;
531 input_dev
->close
= keyspan_close
;
534 * Initialize the URB to access the device.
535 * The urb gets sent to the device in keyspan_open()
537 usb_fill_int_urb(remote
->irq_urb
,
539 usb_rcvintpipe(remote
->udev
, endpoint
->bEndpointAddress
),
540 remote
->in_buffer
, RECV_SIZE
, keyspan_irq_recv
, remote
,
541 endpoint
->bInterval
);
542 remote
->irq_urb
->transfer_dma
= remote
->in_dma
;
543 remote
->irq_urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
545 /* we can register the device now, as it is ready */
546 error
= input_register_device(remote
->input
);
550 /* save our data pointer in this interface device */
551 usb_set_intfdata(interface
, remote
);
555 fail3
: usb_free_urb(remote
->irq_urb
);
556 fail2
: usb_free_coherent(udev
, RECV_SIZE
, remote
->in_buffer
, remote
->in_dma
);
557 fail1
: kfree(remote
);
558 input_free_device(input_dev
);
564 * Routine called when a device is disconnected from the USB.
566 static void keyspan_disconnect(struct usb_interface
*interface
)
568 struct usb_keyspan
*remote
;
570 remote
= usb_get_intfdata(interface
);
571 usb_set_intfdata(interface
, NULL
);
573 if (remote
) { /* We have a valid driver structure so clean up everything we allocated. */
574 input_unregister_device(remote
->input
);
575 usb_kill_urb(remote
->irq_urb
);
576 usb_free_urb(remote
->irq_urb
);
577 usb_free_coherent(remote
->udev
, RECV_SIZE
, remote
->in_buffer
, remote
->in_dma
);
583 * Standard driver set up sections
585 static struct usb_driver keyspan_driver
=
587 .name
= "keyspan_remote",
588 .probe
= keyspan_probe
,
589 .disconnect
= keyspan_disconnect
,
590 .id_table
= keyspan_table
593 module_usb_driver(keyspan_driver
);
595 MODULE_DEVICE_TABLE(usb
, keyspan_table
);
596 MODULE_AUTHOR(DRIVER_AUTHOR
);
597 MODULE_DESCRIPTION(DRIVER_DESC
);
598 MODULE_LICENSE(DRIVER_LICENSE
);