Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/staging/media/lirc/lirc_igorplugusb.c

  1 /*
  2  * lirc_igorplugusb - USB remote support for LIRC
  3  *
  4  * Supports the standard homebrew IgorPlugUSB receiver with Igor's firmware.
  5  * See http://www.cesko.host.sk/IgorPlugUSB/IgorPlug-USB%20(AVR)_eng.htm
  6  *
  7  * The device can only record bursts of up to 36 pulses/spaces.
  8  * Works fine with RC5. Longer commands lead to device buffer overrun.
  9  * (Maybe a better firmware or a microcontroller with more ram can help?)
 10  *
 11  * Version 0.1  [beta status]
 12  *
 13  * Copyright (C) 2004 Jan M. Hochstein
 14  *      <hochstein@algo.informatik.tu-darmstadt.de>
 15  *
 16  * This driver was derived from:
 17  *   Paul Miller <pmiller9@users.sourceforge.net>
 18  *      "lirc_atiusb" module
 19  *   Vladimir Dergachev <volodya@minspring.com>'s 2002
 20  *      "USB ATI Remote support" (input device)
 21  *   Adrian Dewhurst <sailor-lk@sailorfrag.net>'s 2002
 22  *      "USB StreamZap remote driver" (LIRC)
 23  *   Artur Lipowski <alipowski@kki.net.pl>'s 2002
 24  *      "lirc_dev" and "lirc_gpio" LIRC modules
 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 #include <linux/module.h>
 44 #include <linux/kernel.h>
 45 #include <linux/kmod.h>
 46 #include <linux/sched.h>
 47 #include <linux/errno.h>
 48 #include <linux/fs.h>
 49 #include <linux/usb.h>
 50 #include <linux/time.h>
 51 
 52 #include <media/lirc.h>
 53 #include <media/lirc_dev.h>
 54 
 55 
 56 /* module identification */
 57 #define DRIVER_VERSION          "0.2"
 58 #define DRIVER_AUTHOR           \
 59         "Jan M. Hochstein <hochstein@algo.informatik.tu-darmstadt.de>"
 60 #define DRIVER_DESC             "Igorplug USB remote driver for LIRC"
 61 #define DRIVER_NAME             "lirc_igorplugusb"
 62 
 63 /* debugging support */
 64 #ifdef CONFIG_USB_DEBUG
 65 static bool debug = true;
 66 #else
 67 static bool debug;
 68 #endif
 69 
 70 #define dprintk(fmt, args...)                                   \
 71         do {                                                    \
 72                 if (debug)                                      \
 73                         printk(KERN_DEBUG fmt, ## args);        \
 74         } while (0)
 75 
 76 /* One mode2 pulse/space has 4 bytes. */
 77 #define CODE_LENGTH          sizeof(int)
 78 
 79 /* Igor's firmware cannot record bursts longer than 36. */
 80 #define DEVICE_BUFLEN      36
 81 
 82 /*
 83  * Header at the beginning of the device's buffer:
 84  *      unsigned char data_length
 85  *      unsigned char data_start    (!=0 means ring-buffer overrun)
 86  *      unsigned char counter       (incremented by each burst)
 87  */
 88 #define DEVICE_HEADERLEN        3
 89 
 90 /* This is for the gap */
 91 #define ADDITIONAL_LIRC_BYTES   2
 92 
 93 /* times to poll per second */
 94 #define SAMPLE_RATE          100
 95 static int sample_rate = SAMPLE_RATE;
 96 
 97 
 98 /**** Igor's USB Request Codes */
 99 
100 #define SET_INFRABUFFER_EMPTY   1
101 /**
102  * Params: none
103  * Answer: empty
104  */
105 
106 #define GET_INFRACODE      2
107 /**
108  * Params:
109  *   wValue: offset to begin reading infra buffer
110  *
111  * Answer: infra data
112  */
113 
114 #define SET_DATAPORT_DIRECTION  3
115 /**
116  * Params:
117  *   wValue: (byte) 1 bit for each data port pin (0=in, 1=out)
118  *
119  * Answer: empty
120  */
121 
122 #define GET_DATAPORT_DIRECTION  4
123 /**
124  * Params: none
125  *
126  * Answer: (byte) 1 bit for each data port pin (0=in, 1=out)
127  */
128 
129 #define SET_OUT_DATAPORT        5
130 /**
131  * Params:
132  *   wValue: byte to write to output data port
133  *
134  * Answer: empty
135  */
136 
137 #define GET_OUT_DATAPORT        6
138 /**
139  * Params: none
140  *
141  * Answer: least significant 3 bits read from output data port
142  */
143 
144 #define GET_IN_DATAPORT  7
145 /**
146  * Params: none
147  *
148  * Answer: least significant 3 bits read from input data port
149  */
150 
151 #define READ_EEPROM          8
152 /**
153  * Params:
154  *   wValue: offset to begin reading EEPROM
155  *
156  * Answer: EEPROM bytes
157  */
158 
159 #define WRITE_EEPROM        9
160 /**
161  * Params:
162  *   wValue: offset to EEPROM byte
163  *   wIndex: byte to write
164  *
165  * Answer: empty
166  */
167 
168 #define SEND_RS232            10
169 /**
170  * Params:
171  *   wValue: byte to send
172  *
173  * Answer: empty
174  */
175 
176 #define RECV_RS232            11
177 /**
178  * Params: none
179  *
180  * Answer: byte received
181  */
182 
183 #define SET_RS232_BAUD    12
184 /**
185  * Params:
186  *   wValue: byte to write to UART bit rate register (UBRR)
187  *
188  * Answer: empty
189  */
190 
191 #define GET_RS232_BAUD    13
192 /**
193  * Params: none
194  *
195  * Answer: byte read from UART bit rate register (UBRR)
196  */
197 
198 
199 /* data structure for each usb remote */
200 struct igorplug {
201 
202         /* usb */
203         struct usb_device *usbdev;
204         int devnum;
205 
206         unsigned char *buf_in;
207         unsigned int len_in;
208         int in_space;
209         struct timeval last_time;
210 
211         dma_addr_t dma_in;
212 
213         /* lirc */
214         struct lirc_driver *d;
215 
216         /* handle sending (init strings) */
217         int send_flags;
218 };
219 
220 static int unregister_from_lirc(struct igorplug *ir)
221 {
222         struct lirc_driver *d;
223         int devnum;
224 
225         if (!ir) {
226                 dev_err(&ir->usbdev->dev,
227                         "%s: called with NULL device struct!\n", __func__);
228                 return -EINVAL;
229         }
230 
231         devnum = ir->devnum;
232         d = ir->d;
233 
234         if (!d) {
235                 dev_err(&ir->usbdev->dev,
236                         "%s: called with NULL lirc driver struct!\n", __func__);
237                 return -EINVAL;
238         }
239 
240         dprintk(DRIVER_NAME "[%d]: calling lirc_unregister_driver\n", devnum);
241         lirc_unregister_driver(d->minor);
242 
243         return devnum;
244 }
245 
246 static int set_use_inc(void *data)
247 {
248         struct igorplug *ir = data;
249 
250         if (!ir) {
251                 printk(DRIVER_NAME "[?]: set_use_inc called with no context\n");
252                 return -EIO;
253         }
254 
255         dprintk(DRIVER_NAME "[%d]: set use inc\n", ir->devnum);
256 
257         if (!ir->usbdev)
258                 return -ENODEV;
259 
260         return 0;
261 }
262 
263 static void set_use_dec(void *data)
264 {
265         struct igorplug *ir = data;
266 
267         if (!ir) {
268                 printk(DRIVER_NAME "[?]: set_use_dec called with no context\n");
269                 return;
270         }
271 
272         dprintk(DRIVER_NAME "[%d]: set use dec\n", ir->devnum);
273 }
274 
275 static void send_fragment(struct igorplug *ir, struct lirc_buffer *buf,
276                            int i, int max)
277 {
278         int code;
279 
280         /* MODE2: pulse/space (PULSE_BIT) in 1us units */
281         while (i < max) {
282                 /* 1 Igor-tick = 85.333333 us */
283                 code = (unsigned int)ir->buf_in[i] * 85 +
284                         (unsigned int)ir->buf_in[i] / 3;
285                 ir->last_time.tv_usec += code;
286                 if (ir->in_space)
287                         code |= PULSE_BIT;
288                 lirc_buffer_write(buf, (unsigned char *)&code);
289                 /* 1 chunk = CODE_LENGTH bytes */
290                 ir->in_space ^= 1;
291                 ++i;
292         }
293 }
294 
295 /**
296  * Called in user context.
297  * return 0 if data was added to the buffer and
298  * -ENODATA if none was available. This should add some number of bits
299  * evenly divisible by code_length to the buffer
300  */
301 static int igorplugusb_remote_poll(void *data, struct lirc_buffer *buf)
302 {
303         int ret;
304         struct igorplug *ir = (struct igorplug *)data;
305 
306         if (!ir || !ir->usbdev)  /* Has the device been removed? */
307                 return -ENODEV;
308 
309         memset(ir->buf_in, 0, ir->len_in);
310 
311         ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
312                               GET_INFRACODE, USB_TYPE_VENDOR | USB_DIR_IN,
313                               0/* offset */, /*unused*/0,
314                               ir->buf_in, ir->len_in,
315                               /*timeout*/HZ * USB_CTRL_GET_TIMEOUT);
316         if (ret > 0) {
317                 int code, timediff;
318                 struct timeval now;
319 
320                 /* ACK packet has 1 byte --> ignore */
321                 if (ret < DEVICE_HEADERLEN)
322                         return -ENODATA;
323 
324                 dprintk(DRIVER_NAME ": Got %d bytes. Header: %*ph\n",
325                         ret, 3, ir->buf_in);
326 
327                 do_gettimeofday(&now);
328                 timediff = now.tv_sec - ir->last_time.tv_sec;
329                 if (timediff + 1 > PULSE_MASK / 1000000)
330                         timediff = PULSE_MASK;
331                 else {
332                         timediff *= 1000000;
333                         timediff += now.tv_usec - ir->last_time.tv_usec;
334                 }
335                 ir->last_time.tv_sec = now.tv_sec;
336                 ir->last_time.tv_usec = now.tv_usec;
337 
338                 /* create leading gap  */
339                 code = timediff;
340                 lirc_buffer_write(buf, (unsigned char *)&code);
341                 ir->in_space = 1;   /* next comes a pulse */
342 
343                 if (ir->buf_in[2] == 0)
344                         send_fragment(ir, buf, DEVICE_HEADERLEN, ret);
345                 else {
346                         dev_warn(&ir->usbdev->dev,
347                                  "[%d]: Device buffer overrun.\n", ir->devnum);
348                         /* HHHNNNNNNNNNNNOOOOOOOO H = header
349                               <---[2]--->         N = newer
350                            <---------ret--------> O = older */
351                         ir->buf_in[2] %= ret - DEVICE_HEADERLEN; /* sanitize */
352                         /* keep even-ness to not desync pulse/pause */
353                         send_fragment(ir, buf, DEVICE_HEADERLEN +
354                                       ir->buf_in[2] - (ir->buf_in[2] & 1), ret);
355                         send_fragment(ir, buf, DEVICE_HEADERLEN,
356                                       DEVICE_HEADERLEN + ir->buf_in[2]);
357                 }
358 
359                 ret = usb_control_msg(
360                       ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
361                       SET_INFRABUFFER_EMPTY, USB_TYPE_VENDOR|USB_DIR_IN,
362                       /*unused*/0, /*unused*/0,
363                       /*dummy*/ir->buf_in, /*dummy*/ir->len_in,
364                       /*timeout*/HZ * USB_CTRL_GET_TIMEOUT);
365                 if (ret < 0)
366                         printk(DRIVER_NAME "[%d]: SET_INFRABUFFER_EMPTY: error %d\n",
367                                ir->devnum, ret);
368                 return 0;
369         } else if (ret < 0)
370                 printk(DRIVER_NAME "[%d]: GET_INFRACODE: error %d\n",
371                         ir->devnum, ret);
372 
373         return -ENODATA;
374 }
375 
376 static int igorplugusb_remote_probe(struct usb_interface *intf,
377                                     const struct usb_device_id *id)
378 {
379         struct usb_device *dev;
380         struct usb_host_interface *idesc = NULL;
381         struct usb_endpoint_descriptor *ep;
382         struct igorplug *ir = NULL;
383         struct lirc_driver *driver = NULL;
384         int devnum, pipe, maxp;
385         char buf[63], name[128] = "";
386         int ret;
387 
388         dprintk(DRIVER_NAME ": usb probe called.\n");
389 
390         dev = interface_to_usbdev(intf);
391 
392         idesc = intf->cur_altsetting;
393 
394         if (idesc->desc.bNumEndpoints != 1)
395                 return -ENODEV;
396 
397         ep = &idesc->endpoint->desc;
398         if (((ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
399             != USB_DIR_IN)
400             || (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
401             != USB_ENDPOINT_XFER_CONTROL)
402                 return -ENODEV;
403 
404         pipe = usb_rcvctrlpipe(dev, ep->bEndpointAddress);
405         devnum = dev->devnum;
406         maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
407 
408         dprintk(DRIVER_NAME "[%d]: bytes_in_key=%zu maxp=%d\n",
409                 devnum, CODE_LENGTH, maxp);
410 
411         ir = devm_kzalloc(&intf->dev, sizeof(*ir), GFP_KERNEL);
412         if (!ir)
413                 return -ENOMEM;
414 
415         driver = devm_kzalloc(&intf->dev, sizeof(*driver), GFP_KERNEL);
416         if (!driver)
417                 return -ENOMEM;
418 
419         ir->buf_in = usb_alloc_coherent(dev, DEVICE_BUFLEN + DEVICE_HEADERLEN,
420                                         GFP_ATOMIC, &ir->dma_in);
421         if (!ir->buf_in)
422                 return -ENOMEM;
423 
424         strcpy(driver->name, DRIVER_NAME " ");
425         driver->minor = -1;
426         driver->code_length = CODE_LENGTH * 8; /* in bits */
427         driver->features = LIRC_CAN_REC_MODE2;
428         driver->data = ir;
429         driver->chunk_size = CODE_LENGTH;
430         driver->buffer_size = DEVICE_BUFLEN + ADDITIONAL_LIRC_BYTES;
431         driver->set_use_inc = &set_use_inc;
432         driver->set_use_dec = &set_use_dec;
433         driver->sample_rate = sample_rate;    /* per second */
434         driver->add_to_buf = &igorplugusb_remote_poll;
435         driver->dev = &intf->dev;
436         driver->owner = THIS_MODULE;
437 
438         ret = lirc_register_driver(driver);
439         if (ret < 0) {
440                 usb_free_coherent(dev, DEVICE_BUFLEN + DEVICE_HEADERLEN,
441                         ir->buf_in, ir->dma_in);
442                 return ret;
443         }
444 
445         driver->minor = ret;
446         ir->d = driver;
447         ir->devnum = devnum;
448         ir->usbdev = dev;
449         ir->len_in = DEVICE_BUFLEN + DEVICE_HEADERLEN;
450         ir->in_space = 1; /* First mode2 event is a space. */
451         do_gettimeofday(&ir->last_time);
452 
453         if (dev->descriptor.iManufacturer
454             && usb_string(dev, dev->descriptor.iManufacturer,
455                           buf, sizeof(buf)) > 0)
456                 strlcpy(name, buf, sizeof(name));
457         if (dev->descriptor.iProduct
458             && usb_string(dev, dev->descriptor.iProduct, buf, sizeof(buf)) > 0)
459                 snprintf(name + strlen(name), sizeof(name) - strlen(name),
460                          " %s", buf);
461         printk(DRIVER_NAME "[%d]: %s on usb%d:%d\n", devnum, name,
462                dev->bus->busnum, devnum);
463 
464         /* clear device buffer */
465         ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
466                 SET_INFRABUFFER_EMPTY, USB_TYPE_VENDOR|USB_DIR_IN,
467                 /*unused*/0, /*unused*/0,
468                 /*dummy*/ir->buf_in, /*dummy*/ir->len_in,
469                 /*timeout*/HZ * USB_CTRL_GET_TIMEOUT);
470         if (ret < 0)
471                 printk(DRIVER_NAME "[%d]: SET_INFRABUFFER_EMPTY: error %d\n",
472                         devnum, ret);
473 
474         usb_set_intfdata(intf, ir);
475         return 0;
476 }
477 
478 static void igorplugusb_remote_disconnect(struct usb_interface *intf)
479 {
480         struct usb_device *usbdev = interface_to_usbdev(intf);
481         struct igorplug *ir = usb_get_intfdata(intf);
482         struct device *dev = &intf->dev;
483         int devnum;
484 
485         usb_set_intfdata(intf, NULL);
486 
487         if (!ir || !ir->d)
488                 return;
489 
490         ir->usbdev = NULL;
491 
492         usb_free_coherent(usbdev, ir->len_in, ir->buf_in, ir->dma_in);
493 
494         devnum = unregister_from_lirc(ir);
495 
496         dev_info(dev, DRIVER_NAME "[%d]: %s done\n", devnum, __func__);
497 }
498 
499 static struct usb_device_id igorplugusb_remote_id_table[] = {
500         /* Igor Plug USB (Atmel's Manufact. ID) */
501         { USB_DEVICE(0x03eb, 0x0002) },
502         /* Fit PC2 Infrared Adapter */
503         { USB_DEVICE(0x03eb, 0x21fe) },
504 
505         /* Terminating entry */
506         { }
507 };
508 
509 static struct usb_driver igorplugusb_remote_driver = {
510         .name =         DRIVER_NAME,
511         .probe =        igorplugusb_remote_probe,
512         .disconnect =   igorplugusb_remote_disconnect,
513         .id_table =     igorplugusb_remote_id_table
514 };
515 
516 module_usb_driver(igorplugusb_remote_driver);
517 
518 #include <linux/vermagic.h>
519 MODULE_INFO(vermagic, VERMAGIC_STRING);
520 
521 MODULE_DESCRIPTION(DRIVER_DESC);
522 MODULE_AUTHOR(DRIVER_AUTHOR);
523 MODULE_LICENSE("GPL");
524 MODULE_DEVICE_TABLE(usb, igorplugusb_remote_id_table);
525 
526 module_param(sample_rate, int, S_IRUGO | S_IWUSR);
527 MODULE_PARM_DESC(sample_rate, "Sampling rate in Hz (default: 100)");
528 
529 module_param(debug, bool, S_IRUGO | S_IWUSR);
530 MODULE_PARM_DESC(debug, "Debug enabled or not");
531 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us