Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
imon.c
Go to the documentation of this file.
1 /*
2  * imon.c: input and display driver for SoundGraph iMON IR/VFD/LCD
3  *
4  * Copyright(C) 2010 Jarod Wilson <[email protected]>
5  * Portions based on the original lirc_imon driver,
6  * Copyright(C) 2004 Venky Raju([email protected])
7  *
8  * Huge thanks to R. Geoff Newbury for invaluable debugging on the
9  * 0xffdc iMON devices, and for sending me one to hack on, without
10  * which the support for them wouldn't be nearly as good. Thanks
11  * also to the numerous 0xffdc device owners that tested auto-config
12  * support for me and provided debug dumps from their devices.
13  *
14  * imon is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27  */
28 
29 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
30 
31 #include <linux/errno.h>
32 #include <linux/init.h>
33 #include <linux/kernel.h>
34 #include <linux/module.h>
35 #include <linux/slab.h>
36 #include <linux/uaccess.h>
37 #include <linux/ratelimit.h>
38 
39 #include <linux/input.h>
40 #include <linux/usb.h>
41 #include <linux/usb/input.h>
42 #include <media/rc-core.h>
43 
44 #include <linux/time.h>
45 #include <linux/timer.h>
46 
47 #define MOD_AUTHOR "Jarod Wilson <[email protected]>"
48 #define MOD_DESC "Driver for SoundGraph iMON MultiMedia IR/Display"
49 #define MOD_NAME "imon"
50 #define MOD_VERSION "0.9.4"
51 
52 #define DISPLAY_MINOR_BASE 144
53 #define DEVICE_NAME "lcd%d"
54 
55 #define BUF_CHUNK_SIZE 8
56 #define BUF_SIZE 128
57 
58 #define BIT_DURATION 250 /* each bit received is 250us */
59 
60 #define IMON_CLOCK_ENABLE_PACKETS 2
61 
62 /*** P R O T O T Y P E S ***/
63 
64 /* USB Callback prototypes */
65 static int imon_probe(struct usb_interface *interface,
66  const struct usb_device_id *id);
67 static void imon_disconnect(struct usb_interface *interface);
68 static void usb_rx_callback_intf0(struct urb *urb);
69 static void usb_rx_callback_intf1(struct urb *urb);
70 static void usb_tx_callback(struct urb *urb);
71 
72 /* suspend/resume support */
73 static int imon_resume(struct usb_interface *intf);
74 static int imon_suspend(struct usb_interface *intf, pm_message_t message);
75 
76 /* Display file_operations function prototypes */
77 static int display_open(struct inode *inode, struct file *file);
78 static int display_close(struct inode *inode, struct file *file);
79 
80 /* VFD write operation */
81 static ssize_t vfd_write(struct file *file, const char *buf,
82  size_t n_bytes, loff_t *pos);
83 
84 /* LCD file_operations override function prototypes */
85 static ssize_t lcd_write(struct file *file, const char *buf,
86  size_t n_bytes, loff_t *pos);
87 
88 /*** G L O B A L S ***/
89 
90 struct imon_context {
91  struct device *dev;
92  /* Newer devices have two interfaces */
93  struct usb_device *usbdev_intf0;
94  struct usb_device *usbdev_intf1;
95 
96  bool display_supported; /* not all controllers do */
97  bool display_isopen; /* display port has been opened */
98  bool rf_device; /* true if iMON 2.4G LT/DT RF device */
99  bool rf_isassociating; /* RF remote associating */
100  bool dev_present_intf0; /* USB device presence, interface 0 */
101  bool dev_present_intf1; /* USB device presence, interface 1 */
102 
103  struct mutex lock; /* to lock this object */
104  wait_queue_head_t remove_ok; /* For unexpected USB disconnects */
105 
106  struct usb_endpoint_descriptor *rx_endpoint_intf0;
107  struct usb_endpoint_descriptor *rx_endpoint_intf1;
108  struct usb_endpoint_descriptor *tx_endpoint;
109  struct urb *rx_urb_intf0;
110  struct urb *rx_urb_intf1;
111  struct urb *tx_urb;
112  bool tx_control;
113  unsigned char usb_rx_buf[8];
114  unsigned char usb_tx_buf[8];
115 
116  struct tx_t {
117  unsigned char data_buf[35]; /* user data buffer */
118  struct completion finished; /* wait for write to finish */
119  bool busy; /* write in progress */
120  int status; /* status of tx completion */
121  } tx;
122 
123  u16 vendor; /* usb vendor ID */
124  u16 product; /* usb product ID */
125 
126  struct rc_dev *rdev; /* rc-core device for remote */
127  struct input_dev *idev; /* input device for panel & IR mouse */
128  struct input_dev *touch; /* input device for touchscreen */
129 
130  spinlock_t kc_lock; /* make sure we get keycodes right */
131  u32 kc; /* current input keycode */
132  u32 last_keycode; /* last reported input keycode */
133  u32 rc_scancode; /* the computed remote scancode */
134  u8 rc_toggle; /* the computed remote toggle bit */
135  u64 rc_type; /* iMON or MCE (RC6) IR protocol? */
136  bool release_code; /* some keys send a release code */
137 
138  u8 display_type; /* store the display type */
139  bool pad_mouse; /* toggle kbd(0)/mouse(1) mode */
140 
141  char name_rdev[128]; /* rc input device name */
142  char phys_rdev[64]; /* rc input device phys path */
143 
144  char name_idev[128]; /* input device name */
145  char phys_idev[64]; /* input device phys path */
146 
147  char name_touch[128]; /* touch screen name */
148  char phys_touch[64]; /* touch screen phys path */
149  struct timer_list ttimer; /* touch screen timer */
150  int touch_x; /* x coordinate on touchscreen */
151  int touch_y; /* y coordinate on touchscreen */
152 };
153 
154 #define TOUCH_TIMEOUT (HZ/30)
155 
156 /* vfd character device file operations */
157 static const struct file_operations vfd_fops = {
158  .owner = THIS_MODULE,
159  .open = &display_open,
160  .write = &vfd_write,
161  .release = &display_close,
162  .llseek = noop_llseek,
163 };
164 
165 /* lcd character device file operations */
166 static const struct file_operations lcd_fops = {
167  .owner = THIS_MODULE,
168  .open = &display_open,
169  .write = &lcd_write,
170  .release = &display_close,
171  .llseek = noop_llseek,
172 };
173 
174 enum {
175  IMON_DISPLAY_TYPE_AUTO = 0,
176  IMON_DISPLAY_TYPE_VFD = 1,
177  IMON_DISPLAY_TYPE_LCD = 2,
178  IMON_DISPLAY_TYPE_VGA = 3,
179  IMON_DISPLAY_TYPE_NONE = 4,
180 };
181 
182 enum {
183  IMON_KEY_IMON = 0,
184  IMON_KEY_MCE = 1,
185  IMON_KEY_PANEL = 2,
186 };
187 
188 /*
189  * USB Device ID for iMON USB Control Boards
190  *
191  * The Windows drivers contain 6 different inf files, more or less one for
192  * each new device until the 0x0034-0x0046 devices, which all use the same
193  * driver. Some of the devices in the 34-46 range haven't been definitively
194  * identified yet. Early devices have either a TriGem Computer, Inc. or a
195  * Samsung vendor ID (0x0aa8 and 0x04e8 respectively), while all later
196  * devices use the SoundGraph vendor ID (0x15c2). This driver only supports
197  * the ffdc and later devices, which do onboard decoding.
198  */
199 static struct usb_device_id imon_usb_id_table[] = {
200  /*
201  * Several devices with this same device ID, all use iMON_PAD.inf
202  * SoundGraph iMON PAD (IR & VFD)
203  * SoundGraph iMON PAD (IR & LCD)
204  * SoundGraph iMON Knob (IR only)
205  */
206  { USB_DEVICE(0x15c2, 0xffdc) },
207 
208  /*
209  * Newer devices, all driven by the latest iMON Windows driver, full
210  * list of device IDs extracted via 'strings Setup/data1.hdr |grep 15c2'
211  * Need user input to fill in details on unknown devices.
212  */
213  /* SoundGraph iMON OEM Touch LCD (IR & 7" VGA LCD) */
214  { USB_DEVICE(0x15c2, 0x0034) },
215  /* SoundGraph iMON OEM Touch LCD (IR & 4.3" VGA LCD) */
216  { USB_DEVICE(0x15c2, 0x0035) },
217  /* SoundGraph iMON OEM VFD (IR & VFD) */
218  { USB_DEVICE(0x15c2, 0x0036) },
219  /* device specifics unknown */
220  { USB_DEVICE(0x15c2, 0x0037) },
221  /* SoundGraph iMON OEM LCD (IR & LCD) */
222  { USB_DEVICE(0x15c2, 0x0038) },
223  /* SoundGraph iMON UltraBay (IR & LCD) */
224  { USB_DEVICE(0x15c2, 0x0039) },
225  /* device specifics unknown */
226  { USB_DEVICE(0x15c2, 0x003a) },
227  /* device specifics unknown */
228  { USB_DEVICE(0x15c2, 0x003b) },
229  /* SoundGraph iMON OEM Inside (IR only) */
230  { USB_DEVICE(0x15c2, 0x003c) },
231  /* device specifics unknown */
232  { USB_DEVICE(0x15c2, 0x003d) },
233  /* device specifics unknown */
234  { USB_DEVICE(0x15c2, 0x003e) },
235  /* device specifics unknown */
236  { USB_DEVICE(0x15c2, 0x003f) },
237  /* device specifics unknown */
238  { USB_DEVICE(0x15c2, 0x0040) },
239  /* SoundGraph iMON MINI (IR only) */
240  { USB_DEVICE(0x15c2, 0x0041) },
241  /* Antec Veris Multimedia Station EZ External (IR only) */
242  { USB_DEVICE(0x15c2, 0x0042) },
243  /* Antec Veris Multimedia Station Basic Internal (IR only) */
244  { USB_DEVICE(0x15c2, 0x0043) },
245  /* Antec Veris Multimedia Station Elite (IR & VFD) */
246  { USB_DEVICE(0x15c2, 0x0044) },
247  /* Antec Veris Multimedia Station Premiere (IR & LCD) */
248  { USB_DEVICE(0x15c2, 0x0045) },
249  /* device specifics unknown */
250  { USB_DEVICE(0x15c2, 0x0046) },
251  {}
252 };
253 
254 /* USB Device data */
255 static struct usb_driver imon_driver = {
256  .name = MOD_NAME,
257  .probe = imon_probe,
258  .disconnect = __devexit_p(imon_disconnect),
259  .suspend = imon_suspend,
260  .resume = imon_resume,
261  .id_table = imon_usb_id_table,
262 };
263 
264 static struct usb_class_driver imon_vfd_class = {
265  .name = DEVICE_NAME,
266  .fops = &vfd_fops,
267  .minor_base = DISPLAY_MINOR_BASE,
268 };
269 
270 static struct usb_class_driver imon_lcd_class = {
271  .name = DEVICE_NAME,
272  .fops = &lcd_fops,
273  .minor_base = DISPLAY_MINOR_BASE,
274 };
275 
276 /* imon receiver front panel/knob key table */
277 static const struct {
278  u64 hw_code;
279  u32 keycode;
280 } imon_panel_key_table[] = {
281  { 0x000000000f00ffeell, KEY_MEDIA }, /* Go */
282  { 0x000000001200ffeell, KEY_UP },
283  { 0x000000001300ffeell, KEY_DOWN },
284  { 0x000000001400ffeell, KEY_LEFT },
285  { 0x000000001500ffeell, KEY_RIGHT },
286  { 0x000000001600ffeell, KEY_ENTER },
287  { 0x000000001700ffeell, KEY_ESC },
288  { 0x000000001f00ffeell, KEY_AUDIO },
289  { 0x000000002000ffeell, KEY_VIDEO },
290  { 0x000000002100ffeell, KEY_CAMERA },
291  { 0x000000002700ffeell, KEY_DVD },
292  { 0x000000002300ffeell, KEY_TV },
293  { 0x000000002b00ffeell, KEY_EXIT },
294  { 0x000000002c00ffeell, KEY_SELECT },
295  { 0x000000002d00ffeell, KEY_MENU },
296  { 0x000000000500ffeell, KEY_PREVIOUS },
297  { 0x000000000700ffeell, KEY_REWIND },
298  { 0x000000000400ffeell, KEY_STOP },
299  { 0x000000003c00ffeell, KEY_PLAYPAUSE },
300  { 0x000000000800ffeell, KEY_FASTFORWARD },
301  { 0x000000000600ffeell, KEY_NEXT },
302  { 0x000000010000ffeell, KEY_RIGHT },
303  { 0x000001000000ffeell, KEY_LEFT },
304  { 0x000000003d00ffeell, KEY_SELECT },
305  { 0x000100000000ffeell, KEY_VOLUMEUP },
306  { 0x010000000000ffeell, KEY_VOLUMEDOWN },
307  { 0x000000000100ffeell, KEY_MUTE },
308  /* 0xffdc iMON MCE VFD */
309  { 0x00010000ffffffeell, KEY_VOLUMEUP },
310  { 0x01000000ffffffeell, KEY_VOLUMEDOWN },
311  { 0x00000001ffffffeell, KEY_MUTE },
312  { 0x0000000fffffffeell, KEY_MEDIA },
313  { 0x00000012ffffffeell, KEY_UP },
314  { 0x00000013ffffffeell, KEY_DOWN },
315  { 0x00000014ffffffeell, KEY_LEFT },
316  { 0x00000015ffffffeell, KEY_RIGHT },
317  { 0x00000016ffffffeell, KEY_ENTER },
318  { 0x00000017ffffffeell, KEY_ESC },
319  /* iMON Knob values */
320  { 0x000100ffffffffeell, KEY_VOLUMEUP },
321  { 0x010000ffffffffeell, KEY_VOLUMEDOWN },
322  { 0x000008ffffffffeell, KEY_MUTE },
323 };
324 
325 /* to prevent races between open() and disconnect(), probing, etc */
326 static DEFINE_MUTEX(driver_lock);
327 
328 /* Module bookkeeping bits */
329 MODULE_AUTHOR(MOD_AUTHOR);
330 MODULE_DESCRIPTION(MOD_DESC);
331 MODULE_VERSION(MOD_VERSION);
332 MODULE_LICENSE("GPL");
333 MODULE_DEVICE_TABLE(usb, imon_usb_id_table);
334 
335 static bool debug;
336 module_param(debug, bool, S_IRUGO | S_IWUSR);
337 MODULE_PARM_DESC(debug, "Debug messages: 0=no, 1=yes (default: no)");
338 
339 /* lcd, vfd, vga or none? should be auto-detected, but can be overridden... */
340 static int display_type;
341 module_param(display_type, int, S_IRUGO);
342 MODULE_PARM_DESC(display_type, "Type of attached display. 0=autodetect, "
343  "1=vfd, 2=lcd, 3=vga, 4=none (default: autodetect)");
344 
345 static int pad_stabilize = 1;
346 module_param(pad_stabilize, int, S_IRUGO | S_IWUSR);
347 MODULE_PARM_DESC(pad_stabilize, "Apply stabilization algorithm to iMON PAD "
348  "presses in arrow key mode. 0=disable, 1=enable (default).");
349 
350 /*
351  * In certain use cases, mouse mode isn't really helpful, and could actually
352  * cause confusion, so allow disabling it when the IR device is open.
353  */
354 static bool nomouse;
355 module_param(nomouse, bool, S_IRUGO | S_IWUSR);
356 MODULE_PARM_DESC(nomouse, "Disable mouse input device mode when IR device is "
357  "open. 0=don't disable, 1=disable. (default: don't disable)");
358 
359 /* threshold at which a pad push registers as an arrow key in kbd mode */
360 static int pad_thresh;
361 module_param(pad_thresh, int, S_IRUGO | S_IWUSR);
362 MODULE_PARM_DESC(pad_thresh, "Threshold at which a pad push registers as an "
363  "arrow key in kbd mode (default: 28)");
364 
365 
366 static void free_imon_context(struct imon_context *ictx)
367 {
368  struct device *dev = ictx->dev;
369 
370  usb_free_urb(ictx->tx_urb);
371  usb_free_urb(ictx->rx_urb_intf0);
372  usb_free_urb(ictx->rx_urb_intf1);
373  kfree(ictx);
374 
375  dev_dbg(dev, "%s: iMON context freed\n", __func__);
376 }
377 
382 static int display_open(struct inode *inode, struct file *file)
383 {
384  struct usb_interface *interface;
385  struct imon_context *ictx = NULL;
386  int subminor;
387  int retval = 0;
388 
389  /* prevent races with disconnect */
390  mutex_lock(&driver_lock);
391 
392  subminor = iminor(inode);
393  interface = usb_find_interface(&imon_driver, subminor);
394  if (!interface) {
395  pr_err("could not find interface for minor %d\n", subminor);
396  retval = -ENODEV;
397  goto exit;
398  }
399  ictx = usb_get_intfdata(interface);
400 
401  if (!ictx) {
402  pr_err("no context found for minor %d\n", subminor);
403  retval = -ENODEV;
404  goto exit;
405  }
406 
407  mutex_lock(&ictx->lock);
408 
409  if (!ictx->display_supported) {
410  pr_err("display not supported by device\n");
411  retval = -ENODEV;
412  } else if (ictx->display_isopen) {
413  pr_err("display port is already open\n");
414  retval = -EBUSY;
415  } else {
416  ictx->display_isopen = true;
417  file->private_data = ictx;
418  dev_dbg(ictx->dev, "display port opened\n");
419  }
420 
421  mutex_unlock(&ictx->lock);
422 
423 exit:
424  mutex_unlock(&driver_lock);
425  return retval;
426 }
427 
432 static int display_close(struct inode *inode, struct file *file)
433 {
434  struct imon_context *ictx = NULL;
435  int retval = 0;
436 
437  ictx = file->private_data;
438 
439  if (!ictx) {
440  pr_err("no context for device\n");
441  return -ENODEV;
442  }
443 
444  mutex_lock(&ictx->lock);
445 
446  if (!ictx->display_supported) {
447  pr_err("display not supported by device\n");
448  retval = -ENODEV;
449  } else if (!ictx->display_isopen) {
450  pr_err("display is not open\n");
451  retval = -EIO;
452  } else {
453  ictx->display_isopen = false;
454  dev_dbg(ictx->dev, "display port closed\n");
455  }
456 
457  mutex_unlock(&ictx->lock);
458  return retval;
459 }
460 
466 static int send_packet(struct imon_context *ictx)
467 {
468  unsigned int pipe;
469  unsigned long timeout;
470  int interval = 0;
471  int retval = 0;
472  struct usb_ctrlrequest *control_req = NULL;
473 
474  /* Check if we need to use control or interrupt urb */
475  if (!ictx->tx_control) {
476  pipe = usb_sndintpipe(ictx->usbdev_intf0,
477  ictx->tx_endpoint->bEndpointAddress);
478  interval = ictx->tx_endpoint->bInterval;
479 
480  usb_fill_int_urb(ictx->tx_urb, ictx->usbdev_intf0, pipe,
481  ictx->usb_tx_buf,
482  sizeof(ictx->usb_tx_buf),
483  usb_tx_callback, ictx, interval);
484 
485  ictx->tx_urb->actual_length = 0;
486  } else {
487  /* fill request into kmalloc'ed space: */
488  control_req = kmalloc(sizeof(struct usb_ctrlrequest),
489  GFP_KERNEL);
490  if (control_req == NULL)
491  return -ENOMEM;
492 
493  /* setup packet is '21 09 0200 0001 0008' */
494  control_req->bRequestType = 0x21;
495  control_req->bRequest = 0x09;
496  control_req->wValue = cpu_to_le16(0x0200);
497  control_req->wIndex = cpu_to_le16(0x0001);
498  control_req->wLength = cpu_to_le16(0x0008);
499 
500  /* control pipe is endpoint 0x00 */
501  pipe = usb_sndctrlpipe(ictx->usbdev_intf0, 0);
502 
503  /* build the control urb */
504  usb_fill_control_urb(ictx->tx_urb, ictx->usbdev_intf0,
505  pipe, (unsigned char *)control_req,
506  ictx->usb_tx_buf,
507  sizeof(ictx->usb_tx_buf),
508  usb_tx_callback, ictx);
509  ictx->tx_urb->actual_length = 0;
510  }
511 
512  init_completion(&ictx->tx.finished);
513  ictx->tx.busy = true;
514  smp_rmb(); /* ensure later readers know we're busy */
515 
516  retval = usb_submit_urb(ictx->tx_urb, GFP_KERNEL);
517  if (retval) {
518  ictx->tx.busy = false;
519  smp_rmb(); /* ensure later readers know we're not busy */
520  pr_err_ratelimited("error submitting urb(%d)\n", retval);
521  } else {
522  /* Wait for transmission to complete (or abort) */
523  mutex_unlock(&ictx->lock);
524  retval = wait_for_completion_interruptible(
525  &ictx->tx.finished);
526  if (retval)
527  pr_err_ratelimited("task interrupted\n");
528  mutex_lock(&ictx->lock);
529 
530  retval = ictx->tx.status;
531  if (retval)
532  pr_err_ratelimited("packet tx failed (%d)\n", retval);
533  }
534 
535  kfree(control_req);
536 
537  /*
538  * Induce a mandatory 5ms delay before returning, as otherwise,
539  * send_packet can get called so rapidly as to overwhelm the device,
540  * particularly on faster systems and/or those with quirky usb.
541  */
542  timeout = msecs_to_jiffies(5);
543  set_current_state(TASK_UNINTERRUPTIBLE);
544  schedule_timeout(timeout);
545 
546  return retval;
547 }
548 
557 static int send_associate_24g(struct imon_context *ictx)
558 {
559  int retval;
560  const unsigned char packet[8] = { 0x01, 0x00, 0x00, 0x00,
561  0x00, 0x00, 0x00, 0x20 };
562 
563  if (!ictx) {
564  pr_err("no context for device\n");
565  return -ENODEV;
566  }
567 
568  if (!ictx->dev_present_intf0) {
569  pr_err("no iMON device present\n");
570  return -ENODEV;
571  }
572 
573  memcpy(ictx->usb_tx_buf, packet, sizeof(packet));
574  retval = send_packet(ictx);
575 
576  return retval;
577 }
578 
586 static int send_set_imon_clock(struct imon_context *ictx,
587  unsigned int year, unsigned int month,
588  unsigned int day, unsigned int dow,
589  unsigned int hour, unsigned int minute,
590  unsigned int second)
591 {
592  unsigned char clock_enable_pkt[IMON_CLOCK_ENABLE_PACKETS][8];
593  int retval = 0;
594  int i;
595 
596  if (!ictx) {
597  pr_err("no context for device\n");
598  return -ENODEV;
599  }
600 
601  switch (ictx->display_type) {
602  case IMON_DISPLAY_TYPE_LCD:
603  clock_enable_pkt[0][0] = 0x80;
604  clock_enable_pkt[0][1] = year;
605  clock_enable_pkt[0][2] = month-1;
606  clock_enable_pkt[0][3] = day;
607  clock_enable_pkt[0][4] = hour;
608  clock_enable_pkt[0][5] = minute;
609  clock_enable_pkt[0][6] = second;
610 
611  clock_enable_pkt[1][0] = 0x80;
612  clock_enable_pkt[1][1] = 0;
613  clock_enable_pkt[1][2] = 0;
614  clock_enable_pkt[1][3] = 0;
615  clock_enable_pkt[1][4] = 0;
616  clock_enable_pkt[1][5] = 0;
617  clock_enable_pkt[1][6] = 0;
618 
619  if (ictx->product == 0xffdc) {
620  clock_enable_pkt[0][7] = 0x50;
621  clock_enable_pkt[1][7] = 0x51;
622  } else {
623  clock_enable_pkt[0][7] = 0x88;
624  clock_enable_pkt[1][7] = 0x8a;
625  }
626 
627  break;
628 
629  case IMON_DISPLAY_TYPE_VFD:
630  clock_enable_pkt[0][0] = year;
631  clock_enable_pkt[0][1] = month-1;
632  clock_enable_pkt[0][2] = day;
633  clock_enable_pkt[0][3] = dow;
634  clock_enable_pkt[0][4] = hour;
635  clock_enable_pkt[0][5] = minute;
636  clock_enable_pkt[0][6] = second;
637  clock_enable_pkt[0][7] = 0x40;
638 
639  clock_enable_pkt[1][0] = 0;
640  clock_enable_pkt[1][1] = 0;
641  clock_enable_pkt[1][2] = 1;
642  clock_enable_pkt[1][3] = 0;
643  clock_enable_pkt[1][4] = 0;
644  clock_enable_pkt[1][5] = 0;
645  clock_enable_pkt[1][6] = 0;
646  clock_enable_pkt[1][7] = 0x42;
647 
648  break;
649 
650  default:
651  return -ENODEV;
652  }
653 
654  for (i = 0; i < IMON_CLOCK_ENABLE_PACKETS; i++) {
655  memcpy(ictx->usb_tx_buf, clock_enable_pkt[i], 8);
656  retval = send_packet(ictx);
657  if (retval) {
658  pr_err("send_packet failed for packet %d\n", i);
659  break;
660  }
661  }
662 
663  return retval;
664 }
665 
669 static ssize_t show_associate_remote(struct device *d,
670  struct device_attribute *attr,
671  char *buf)
672 {
673  struct imon_context *ictx = dev_get_drvdata(d);
674 
675  if (!ictx)
676  return -ENODEV;
677 
678  mutex_lock(&ictx->lock);
679  if (ictx->rf_isassociating)
680  strcpy(buf, "associating\n");
681  else
682  strcpy(buf, "closed\n");
683 
684  dev_info(d, "Visit http://www.lirc.org/html/imon-24g.html for "
685  "instructions on how to associate your iMON 2.4G DT/LT "
686  "remote\n");
687  mutex_unlock(&ictx->lock);
688  return strlen(buf);
689 }
690 
691 static ssize_t store_associate_remote(struct device *d,
692  struct device_attribute *attr,
693  const char *buf, size_t count)
694 {
695  struct imon_context *ictx;
696 
697  ictx = dev_get_drvdata(d);
698 
699  if (!ictx)
700  return -ENODEV;
701 
702  mutex_lock(&ictx->lock);
703  ictx->rf_isassociating = true;
704  send_associate_24g(ictx);
705  mutex_unlock(&ictx->lock);
706 
707  return count;
708 }
709 
713 static ssize_t show_imon_clock(struct device *d,
714  struct device_attribute *attr, char *buf)
715 {
716  struct imon_context *ictx = dev_get_drvdata(d);
717  size_t len;
718 
719  if (!ictx)
720  return -ENODEV;
721 
722  mutex_lock(&ictx->lock);
723 
724  if (!ictx->display_supported) {
725  len = snprintf(buf, PAGE_SIZE, "Not supported.");
726  } else {
727  len = snprintf(buf, PAGE_SIZE,
728  "To set the clock on your iMON display:\n"
729  "# date \"+%%y %%m %%d %%w %%H %%M %%S\" > imon_clock\n"
730  "%s", ictx->display_isopen ?
731  "\nNOTE: imon device must be closed\n" : "");
732  }
733 
734  mutex_unlock(&ictx->lock);
735 
736  return len;
737 }
738 
739 static ssize_t store_imon_clock(struct device *d,
740  struct device_attribute *attr,
741  const char *buf, size_t count)
742 {
743  struct imon_context *ictx = dev_get_drvdata(d);
744  ssize_t retval;
745  unsigned int year, month, day, dow, hour, minute, second;
746 
747  if (!ictx)
748  return -ENODEV;
749 
750  mutex_lock(&ictx->lock);
751 
752  if (!ictx->display_supported) {
753  retval = -ENODEV;
754  goto exit;
755  } else if (ictx->display_isopen) {
756  retval = -EBUSY;
757  goto exit;
758  }
759 
760  if (sscanf(buf, "%u %u %u %u %u %u %u", &year, &month, &day, &dow,
761  &hour, &minute, &second) != 7) {
762  retval = -EINVAL;
763  goto exit;
764  }
765 
766  if ((month < 1 || month > 12) ||
767  (day < 1 || day > 31) || (dow > 6) ||
768  (hour > 23) || (minute > 59) || (second > 59)) {
769  retval = -EINVAL;
770  goto exit;
771  }
772 
773  retval = send_set_imon_clock(ictx, year, month, day, dow,
774  hour, minute, second);
775  if (retval)
776  goto exit;
777 
778  retval = count;
779 exit:
780  mutex_unlock(&ictx->lock);
781 
782  return retval;
783 }
784 
785 
786 static DEVICE_ATTR(imon_clock, S_IWUSR | S_IRUGO, show_imon_clock,
787  store_imon_clock);
788 
789 static DEVICE_ATTR(associate_remote, S_IWUSR | S_IRUGO, show_associate_remote,
790  store_associate_remote);
791 
792 static struct attribute *imon_display_sysfs_entries[] = {
793  &dev_attr_imon_clock.attr,
794  NULL
795 };
796 
797 static struct attribute_group imon_display_attr_group = {
798  .attrs = imon_display_sysfs_entries
799 };
800 
801 static struct attribute *imon_rf_sysfs_entries[] = {
802  &dev_attr_associate_remote.attr,
803  NULL
804 };
805 
806 static struct attribute_group imon_rf_attr_group = {
807  .attrs = imon_rf_sysfs_entries
808 };
809 
821 static ssize_t vfd_write(struct file *file, const char *buf,
822  size_t n_bytes, loff_t *pos)
823 {
824  int i;
825  int offset;
826  int seq;
827  int retval = 0;
828  struct imon_context *ictx;
829  const unsigned char vfd_packet6[] = {
830  0x01, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF };
831 
832  ictx = file->private_data;
833  if (!ictx) {
834  pr_err_ratelimited("no context for device\n");
835  return -ENODEV;
836  }
837 
838  mutex_lock(&ictx->lock);
839 
840  if (!ictx->dev_present_intf0) {
841  pr_err_ratelimited("no iMON device present\n");
842  retval = -ENODEV;
843  goto exit;
844  }
845 
846  if (n_bytes <= 0 || n_bytes > 32) {
847  pr_err_ratelimited("invalid payload size\n");
848  retval = -EINVAL;
849  goto exit;
850  }
851 
852  if (copy_from_user(ictx->tx.data_buf, buf, n_bytes)) {
853  retval = -EFAULT;
854  goto exit;
855  }
856 
857  /* Pad with spaces */
858  for (i = n_bytes; i < 32; ++i)
859  ictx->tx.data_buf[i] = ' ';
860 
861  for (i = 32; i < 35; ++i)
862  ictx->tx.data_buf[i] = 0xFF;
863 
864  offset = 0;
865  seq = 0;
866 
867  do {
868  memcpy(ictx->usb_tx_buf, ictx->tx.data_buf + offset, 7);
869  ictx->usb_tx_buf[7] = (unsigned char) seq;
870 
871  retval = send_packet(ictx);
872  if (retval) {
873  pr_err_ratelimited("send packet #%d failed\n", seq / 2);
874  goto exit;
875  } else {
876  seq += 2;
877  offset += 7;
878  }
879 
880  } while (offset < 35);
881 
882  /* Send packet #6 */
883  memcpy(ictx->usb_tx_buf, &vfd_packet6, sizeof(vfd_packet6));
884  ictx->usb_tx_buf[7] = (unsigned char) seq;
885  retval = send_packet(ictx);
886  if (retval)
887  pr_err_ratelimited("send packet #%d failed\n", seq / 2);
888 
889 exit:
890  mutex_unlock(&ictx->lock);
891 
892  return (!retval) ? n_bytes : retval;
893 }
894 
908 static ssize_t lcd_write(struct file *file, const char *buf,
909  size_t n_bytes, loff_t *pos)
910 {
911  int retval = 0;
912  struct imon_context *ictx;
913 
914  ictx = file->private_data;
915  if (!ictx) {
916  pr_err_ratelimited("no context for device\n");
917  return -ENODEV;
918  }
919 
920  mutex_lock(&ictx->lock);
921 
922  if (!ictx->display_supported) {
923  pr_err_ratelimited("no iMON display present\n");
924  retval = -ENODEV;
925  goto exit;
926  }
927 
928  if (n_bytes != 8) {
929  pr_err_ratelimited("invalid payload size: %d (expected 8)\n",
930  (int)n_bytes);
931  retval = -EINVAL;
932  goto exit;
933  }
934 
935  if (copy_from_user(ictx->usb_tx_buf, buf, 8)) {
936  retval = -EFAULT;
937  goto exit;
938  }
939 
940  retval = send_packet(ictx);
941  if (retval) {
942  pr_err_ratelimited("send packet failed!\n");
943  goto exit;
944  } else {
945  dev_dbg(ictx->dev, "%s: write %d bytes to LCD\n",
946  __func__, (int) n_bytes);
947  }
948 exit:
949  mutex_unlock(&ictx->lock);
950  return (!retval) ? n_bytes : retval;
951 }
952 
956 static void usb_tx_callback(struct urb *urb)
957 {
958  struct imon_context *ictx;
959 
960  if (!urb)
961  return;
962  ictx = (struct imon_context *)urb->context;
963  if (!ictx)
964  return;
965 
966  ictx->tx.status = urb->status;
967 
968  /* notify waiters that write has finished */
969  ictx->tx.busy = false;
970  smp_rmb(); /* ensure later readers know we're not busy */
971  complete(&ictx->tx.finished);
972 }
973 
977 static void imon_touch_display_timeout(unsigned long data)
978 {
979  struct imon_context *ictx = (struct imon_context *)data;
980 
981  if (ictx->display_type != IMON_DISPLAY_TYPE_VGA)
982  return;
983 
984  input_report_abs(ictx->touch, ABS_X, ictx->touch_x);
985  input_report_abs(ictx->touch, ABS_Y, ictx->touch_y);
986  input_report_key(ictx->touch, BTN_TOUCH, 0x00);
987  input_sync(ictx->touch);
988 }
989 
1004 static int imon_ir_change_protocol(struct rc_dev *rc, u64 rc_type)
1005 {
1006  int retval;
1007  struct imon_context *ictx = rc->priv;
1008  struct device *dev = ictx->dev;
1009  bool unlock = false;
1010  unsigned char ir_proto_packet[] = {
1011  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86 };
1012 
1013  if (rc_type && !(rc_type & rc->allowed_protos))
1014  dev_warn(dev, "Looks like you're trying to use an IR protocol "
1015  "this device does not support\n");
1016 
1017  switch (rc_type) {
1018  case RC_TYPE_RC6:
1019  dev_dbg(dev, "Configuring IR receiver for MCE protocol\n");
1020  ir_proto_packet[0] = 0x01;
1021  break;
1022  case RC_TYPE_UNKNOWN:
1023  case RC_TYPE_OTHER:
1024  dev_dbg(dev, "Configuring IR receiver for iMON protocol\n");
1025  if (!pad_stabilize)
1026  dev_dbg(dev, "PAD stabilize functionality disabled\n");
1027  /* ir_proto_packet[0] = 0x00; // already the default */
1028  rc_type = RC_TYPE_OTHER;
1029  break;
1030  default:
1031  dev_warn(dev, "Unsupported IR protocol specified, overriding "
1032  "to iMON IR protocol\n");
1033  if (!pad_stabilize)
1034  dev_dbg(dev, "PAD stabilize functionality disabled\n");
1035  /* ir_proto_packet[0] = 0x00; // already the default */
1036  rc_type = RC_TYPE_OTHER;
1037  break;
1038  }
1039 
1040  memcpy(ictx->usb_tx_buf, &ir_proto_packet, sizeof(ir_proto_packet));
1041 
1042  if (!mutex_is_locked(&ictx->lock)) {
1043  unlock = true;
1044  mutex_lock(&ictx->lock);
1045  }
1046 
1047  retval = send_packet(ictx);
1048  if (retval)
1049  goto out;
1050 
1051  ictx->rc_type = rc_type;
1052  ictx->pad_mouse = false;
1053 
1054 out:
1055  if (unlock)
1056  mutex_unlock(&ictx->lock);
1057 
1058  return retval;
1059 }
1060 
1061 static inline int tv2int(const struct timeval *a, const struct timeval *b)
1062 {
1063  int usecs = 0;
1064  int sec = 0;
1065 
1066  if (b->tv_usec > a->tv_usec) {
1067  usecs = 1000000;
1068  sec--;
1069  }
1070 
1071  usecs += a->tv_usec - b->tv_usec;
1072 
1073  sec += a->tv_sec - b->tv_sec;
1074  sec *= 1000;
1075  usecs /= 1000;
1076  sec += usecs;
1077 
1078  if (sec < 0)
1079  sec = 1000;
1080 
1081  return sec;
1082 }
1083 
1092 static int stabilize(int a, int b, u16 timeout, u16 threshold)
1093 {
1094  struct timeval ct;
1095  static struct timeval prev_time = {0, 0};
1096  static struct timeval hit_time = {0, 0};
1097  static int x, y, prev_result, hits;
1098  int result = 0;
1099  int msec, msec_hit;
1100 
1101  do_gettimeofday(&ct);
1102  msec = tv2int(&ct, &prev_time);
1103  msec_hit = tv2int(&ct, &hit_time);
1104 
1105  if (msec > 100) {
1106  x = 0;
1107  y = 0;
1108  hits = 0;
1109  }
1110 
1111  x += a;
1112  y += b;
1113 
1114  prev_time = ct;
1115 
1116  if (abs(x) > threshold || abs(y) > threshold) {
1117  if (abs(y) > abs(x))
1118  result = (y > 0) ? 0x7F : 0x80;
1119  else
1120  result = (x > 0) ? 0x7F00 : 0x8000;
1121 
1122  x = 0;
1123  y = 0;
1124 
1125  if (result == prev_result) {
1126  hits++;
1127 
1128  if (hits > 3) {
1129  switch (result) {
1130  case 0x7F:
1131  y = 17 * threshold / 30;
1132  break;
1133  case 0x80:
1134  y -= 17 * threshold / 30;
1135  break;
1136  case 0x7F00:
1137  x = 17 * threshold / 30;
1138  break;
1139  case 0x8000:
1140  x -= 17 * threshold / 30;
1141  break;
1142  }
1143  }
1144 
1145  if (hits == 2 && msec_hit < timeout) {
1146  result = 0;
1147  hits = 1;
1148  }
1149  } else {
1150  prev_result = result;
1151  hits = 1;
1152  hit_time = ct;
1153  }
1154  }
1155 
1156  return result;
1157 }
1158 
1159 static u32 imon_remote_key_lookup(struct imon_context *ictx, u32 scancode)
1160 {
1161  u32 keycode;
1162  u32 release;
1163  bool is_release_code = false;
1164 
1165  /* Look for the initial press of a button */
1166  keycode = rc_g_keycode_from_table(ictx->rdev, scancode);
1167  ictx->rc_toggle = 0x0;
1168  ictx->rc_scancode = scancode;
1169 
1170  /* Look for the release of a button */
1171  if (keycode == KEY_RESERVED) {
1172  release = scancode & ~0x4000;
1173  keycode = rc_g_keycode_from_table(ictx->rdev, release);
1174  if (keycode != KEY_RESERVED)
1175  is_release_code = true;
1176  }
1177 
1178  ictx->release_code = is_release_code;
1179 
1180  return keycode;
1181 }
1182 
1183 static u32 imon_mce_key_lookup(struct imon_context *ictx, u32 scancode)
1184 {
1185  u32 keycode;
1186 
1187 #define MCE_KEY_MASK 0x7000
1188 #define MCE_TOGGLE_BIT 0x8000
1189 
1190  /*
1191  * On some receivers, mce keys decode to 0x8000f04xx and 0x8000f84xx
1192  * (the toggle bit flipping between alternating key presses), while
1193  * on other receivers, we see 0x8000f74xx and 0x8000ff4xx. To keep
1194  * the table trim, we always or in the bits to look up 0x8000ff4xx,
1195  * but we can't or them into all codes, as some keys are decoded in
1196  * a different way w/o the same use of the toggle bit...
1197  */
1198  if (scancode & 0x80000000)
1199  scancode = scancode | MCE_KEY_MASK | MCE_TOGGLE_BIT;
1200 
1201  ictx->rc_scancode = scancode;
1202  keycode = rc_g_keycode_from_table(ictx->rdev, scancode);
1203 
1204  /* not used in mce mode, but make sure we know its false */
1205  ictx->release_code = false;
1206 
1207  return keycode;
1208 }
1209 
1210 static u32 imon_panel_key_lookup(u64 code)
1211 {
1212  int i;
1213  u32 keycode = KEY_RESERVED;
1214 
1215  for (i = 0; i < ARRAY_SIZE(imon_panel_key_table); i++) {
1216  if (imon_panel_key_table[i].hw_code == (code | 0xffee)) {
1217  keycode = imon_panel_key_table[i].keycode;
1218  break;
1219  }
1220  }
1221 
1222  return keycode;
1223 }
1224 
1225 static bool imon_mouse_event(struct imon_context *ictx,
1226  unsigned char *buf, int len)
1227 {
1228  char rel_x = 0x00, rel_y = 0x00;
1229  u8 right_shift = 1;
1230  bool mouse_input = true;
1231  int dir = 0;
1232  unsigned long flags;
1233 
1234  spin_lock_irqsave(&ictx->kc_lock, flags);
1235 
1236  /* newer iMON device PAD or mouse button */
1237  if (ictx->product != 0xffdc && (buf[0] & 0x01) && len == 5) {
1238  rel_x = buf[2];
1239  rel_y = buf[3];
1240  right_shift = 1;
1241  /* 0xffdc iMON PAD or mouse button input */
1242  } else if (ictx->product == 0xffdc && (buf[0] & 0x40) &&
1243  !((buf[1] & 0x01) || ((buf[1] >> 2) & 0x01))) {
1244  rel_x = (buf[1] & 0x08) | (buf[1] & 0x10) >> 2 |
1245  (buf[1] & 0x20) >> 4 | (buf[1] & 0x40) >> 6;
1246  if (buf[0] & 0x02)
1247  rel_x |= ~0x0f;
1248  rel_x = rel_x + rel_x / 2;
1249  rel_y = (buf[2] & 0x08) | (buf[2] & 0x10) >> 2 |
1250  (buf[2] & 0x20) >> 4 | (buf[2] & 0x40) >> 6;
1251  if (buf[0] & 0x01)
1252  rel_y |= ~0x0f;
1253  rel_y = rel_y + rel_y / 2;
1254  right_shift = 2;
1255  /* some ffdc devices decode mouse buttons differently... */
1256  } else if (ictx->product == 0xffdc && (buf[0] == 0x68)) {
1257  right_shift = 2;
1258  /* ch+/- buttons, which we use for an emulated scroll wheel */
1259  } else if (ictx->kc == KEY_CHANNELUP && (buf[2] & 0x40) != 0x40) {
1260  dir = 1;
1261  } else if (ictx->kc == KEY_CHANNELDOWN && (buf[2] & 0x40) != 0x40) {
1262  dir = -1;
1263  } else
1264  mouse_input = false;
1265 
1266  spin_unlock_irqrestore(&ictx->kc_lock, flags);
1267 
1268  if (mouse_input) {
1269  dev_dbg(ictx->dev, "sending mouse data via input subsystem\n");
1270 
1271  if (dir) {
1272  input_report_rel(ictx->idev, REL_WHEEL, dir);
1273  } else if (rel_x || rel_y) {
1274  input_report_rel(ictx->idev, REL_X, rel_x);
1275  input_report_rel(ictx->idev, REL_Y, rel_y);
1276  } else {
1277  input_report_key(ictx->idev, BTN_LEFT, buf[1] & 0x1);
1278  input_report_key(ictx->idev, BTN_RIGHT,
1279  buf[1] >> right_shift & 0x1);
1280  }
1281  input_sync(ictx->idev);
1282  spin_lock_irqsave(&ictx->kc_lock, flags);
1283  ictx->last_keycode = ictx->kc;
1284  spin_unlock_irqrestore(&ictx->kc_lock, flags);
1285  }
1286 
1287  return mouse_input;
1288 }
1289 
1290 static void imon_touch_event(struct imon_context *ictx, unsigned char *buf)
1291 {
1292  mod_timer(&ictx->ttimer, jiffies + TOUCH_TIMEOUT);
1293  ictx->touch_x = (buf[0] << 4) | (buf[1] >> 4);
1294  ictx->touch_y = 0xfff - ((buf[2] << 4) | (buf[1] & 0xf));
1295  input_report_abs(ictx->touch, ABS_X, ictx->touch_x);
1296  input_report_abs(ictx->touch, ABS_Y, ictx->touch_y);
1297  input_report_key(ictx->touch, BTN_TOUCH, 0x01);
1298  input_sync(ictx->touch);
1299 }
1300 
1301 static void imon_pad_to_keys(struct imon_context *ictx, unsigned char *buf)
1302 {
1303  int dir = 0;
1304  char rel_x = 0x00, rel_y = 0x00;
1305  u16 timeout, threshold;
1306  u32 scancode = KEY_RESERVED;
1307  unsigned long flags;
1308 
1309  /*
1310  * The imon directional pad functions more like a touchpad. Bytes 3 & 4
1311  * contain a position coordinate (x,y), with each component ranging
1312  * from -14 to 14. We want to down-sample this to only 4 discrete values
1313  * for up/down/left/right arrow keys. Also, when you get too close to
1314  * diagonals, it has a tendency to jump back and forth, so lets try to
1315  * ignore when they get too close.
1316  */
1317  if (ictx->product != 0xffdc) {
1318  /* first, pad to 8 bytes so it conforms with everything else */
1319  buf[5] = buf[6] = buf[7] = 0;
1320  timeout = 500; /* in msecs */
1321  /* (2*threshold) x (2*threshold) square */
1322  threshold = pad_thresh ? pad_thresh : 28;
1323  rel_x = buf[2];
1324  rel_y = buf[3];
1325 
1326  if (ictx->rc_type == RC_TYPE_OTHER && pad_stabilize) {
1327  if ((buf[1] == 0) && ((rel_x != 0) || (rel_y != 0))) {
1328  dir = stabilize((int)rel_x, (int)rel_y,
1329  timeout, threshold);
1330  if (!dir) {
1331  spin_lock_irqsave(&ictx->kc_lock,
1332  flags);
1333  ictx->kc = KEY_UNKNOWN;
1334  spin_unlock_irqrestore(&ictx->kc_lock,
1335  flags);
1336  return;
1337  }
1338  buf[2] = dir & 0xFF;
1339  buf[3] = (dir >> 8) & 0xFF;
1340  scancode = be32_to_cpu(*((u32 *)buf));
1341  }
1342  } else {
1343  /*
1344  * Hack alert: instead of using keycodes, we have
1345  * to use hard-coded scancodes here...
1346  */
1347  if (abs(rel_y) > abs(rel_x)) {
1348  buf[2] = (rel_y > 0) ? 0x7F : 0x80;
1349  buf[3] = 0;
1350  if (rel_y > 0)
1351  scancode = 0x01007f00; /* KEY_DOWN */
1352  else
1353  scancode = 0x01008000; /* KEY_UP */
1354  } else {
1355  buf[2] = 0;
1356  buf[3] = (rel_x > 0) ? 0x7F : 0x80;
1357  if (rel_x > 0)
1358  scancode = 0x0100007f; /* KEY_RIGHT */
1359  else
1360  scancode = 0x01000080; /* KEY_LEFT */
1361  }
1362  }
1363 
1364  /*
1365  * Handle on-board decoded pad events for e.g. older VFD/iMON-Pad
1366  * device (15c2:ffdc). The remote generates various codes from
1367  * 0x68nnnnB7 to 0x6AnnnnB7, the left mouse button generates
1368  * 0x688301b7 and the right one 0x688481b7. All other keys generate
1369  * 0x2nnnnnnn. Position coordinate is encoded in buf[1] and buf[2] with
1370  * reversed endianess. Extract direction from buffer, rotate endianess,
1371  * adjust sign and feed the values into stabilize(). The resulting codes
1372  * will be 0x01008000, 0x01007F00, which match the newer devices.
1373  */
1374  } else {
1375  timeout = 10; /* in msecs */
1376  /* (2*threshold) x (2*threshold) square */
1377  threshold = pad_thresh ? pad_thresh : 15;
1378 
1379  /* buf[1] is x */
1380  rel_x = (buf[1] & 0x08) | (buf[1] & 0x10) >> 2 |
1381  (buf[1] & 0x20) >> 4 | (buf[1] & 0x40) >> 6;
1382  if (buf[0] & 0x02)
1383  rel_x |= ~0x10+1;
1384  /* buf[2] is y */
1385  rel_y = (buf[2] & 0x08) | (buf[2] & 0x10) >> 2 |
1386  (buf[2] & 0x20) >> 4 | (buf[2] & 0x40) >> 6;
1387  if (buf[0] & 0x01)
1388  rel_y |= ~0x10+1;
1389 
1390  buf[0] = 0x01;
1391  buf[1] = buf[4] = buf[5] = buf[6] = buf[7] = 0;
1392 
1393  if (ictx->rc_type == RC_TYPE_OTHER && pad_stabilize) {
1394  dir = stabilize((int)rel_x, (int)rel_y,
1395  timeout, threshold);
1396  if (!dir) {
1397  spin_lock_irqsave(&ictx->kc_lock, flags);
1398  ictx->kc = KEY_UNKNOWN;
1399  spin_unlock_irqrestore(&ictx->kc_lock, flags);
1400  return;
1401  }
1402  buf[2] = dir & 0xFF;
1403  buf[3] = (dir >> 8) & 0xFF;
1404  scancode = be32_to_cpu(*((u32 *)buf));
1405  } else {
1406  /*
1407  * Hack alert: instead of using keycodes, we have
1408  * to use hard-coded scancodes here...
1409  */
1410  if (abs(rel_y) > abs(rel_x)) {
1411  buf[2] = (rel_y > 0) ? 0x7F : 0x80;
1412  buf[3] = 0;
1413  if (rel_y > 0)
1414  scancode = 0x01007f00; /* KEY_DOWN */
1415  else
1416  scancode = 0x01008000; /* KEY_UP */
1417  } else {
1418  buf[2] = 0;
1419  buf[3] = (rel_x > 0) ? 0x7F : 0x80;
1420  if (rel_x > 0)
1421  scancode = 0x0100007f; /* KEY_RIGHT */
1422  else
1423  scancode = 0x01000080; /* KEY_LEFT */
1424  }
1425  }
1426  }
1427 
1428  if (scancode) {
1429  spin_lock_irqsave(&ictx->kc_lock, flags);
1430  ictx->kc = imon_remote_key_lookup(ictx, scancode);
1431  spin_unlock_irqrestore(&ictx->kc_lock, flags);
1432  }
1433 }
1434 
1440 static int imon_parse_press_type(struct imon_context *ictx,
1441  unsigned char *buf, u8 ktype)
1442 {
1443  int press_type = 0;
1444  unsigned long flags;
1445 
1446  spin_lock_irqsave(&ictx->kc_lock, flags);
1447 
1448  /* key release of 0x02XXXXXX key */
1449  if (ictx->kc == KEY_RESERVED && buf[0] == 0x02 && buf[3] == 0x00)
1450  ictx->kc = ictx->last_keycode;
1451 
1452  /* mouse button release on (some) 0xffdc devices */
1453  else if (ictx->kc == KEY_RESERVED && buf[0] == 0x68 && buf[1] == 0x82 &&
1454  buf[2] == 0x81 && buf[3] == 0xb7)
1455  ictx->kc = ictx->last_keycode;
1456 
1457  /* mouse button release on (some other) 0xffdc devices */
1458  else if (ictx->kc == KEY_RESERVED && buf[0] == 0x01 && buf[1] == 0x00 &&
1459  buf[2] == 0x81 && buf[3] == 0xb7)
1460  ictx->kc = ictx->last_keycode;
1461 
1462  /* mce-specific button handling, no keyup events */
1463  else if (ktype == IMON_KEY_MCE) {
1464  ictx->rc_toggle = buf[2];
1465  press_type = 1;
1466 
1467  /* incoherent or irrelevant data */
1468  } else if (ictx->kc == KEY_RESERVED)
1469  press_type = -EINVAL;
1470 
1471  /* key release of 0xXXXXXXb7 key */
1472  else if (ictx->release_code)
1473  press_type = 0;
1474 
1475  /* this is a button press */
1476  else
1477  press_type = 1;
1478 
1479  spin_unlock_irqrestore(&ictx->kc_lock, flags);
1480 
1481  return press_type;
1482 }
1483 
1487 static void imon_incoming_packet(struct imon_context *ictx,
1488  struct urb *urb, int intf)
1489 {
1490  int len = urb->actual_length;
1491  unsigned char *buf = urb->transfer_buffer;
1492  struct device *dev = ictx->dev;
1493  unsigned long flags;
1494  u32 kc;
1495  int i;
1496  u64 scancode;
1497  int press_type = 0;
1498  int msec;
1499  struct timeval t;
1500  static struct timeval prev_time = { 0, 0 };
1501  u8 ktype;
1502 
1503  /* filter out junk data on the older 0xffdc imon devices */
1504  if ((buf[0] == 0xff) && (buf[1] == 0xff) && (buf[2] == 0xff))
1505  return;
1506 
1507  /* Figure out what key was pressed */
1508  if (len == 8 && buf[7] == 0xee) {
1509  scancode = be64_to_cpu(*((u64 *)buf));
1510  ktype = IMON_KEY_PANEL;
1511  kc = imon_panel_key_lookup(scancode);
1512  } else {
1513  scancode = be32_to_cpu(*((u32 *)buf));
1514  if (ictx->rc_type == RC_TYPE_RC6) {
1515  ktype = IMON_KEY_IMON;
1516  if (buf[0] == 0x80)
1517  ktype = IMON_KEY_MCE;
1518  kc = imon_mce_key_lookup(ictx, scancode);
1519  } else {
1520  ktype = IMON_KEY_IMON;
1521  kc = imon_remote_key_lookup(ictx, scancode);
1522  }
1523  }
1524 
1525  spin_lock_irqsave(&ictx->kc_lock, flags);
1526  /* keyboard/mouse mode toggle button */
1527  if (kc == KEY_KEYBOARD && !ictx->release_code) {
1528  ictx->last_keycode = kc;
1529  if (!nomouse) {
1530  ictx->pad_mouse = ~(ictx->pad_mouse) & 0x1;
1531  dev_dbg(dev, "toggling to %s mode\n",
1532  ictx->pad_mouse ? "mouse" : "keyboard");
1533  spin_unlock_irqrestore(&ictx->kc_lock, flags);
1534  return;
1535  } else {
1536  ictx->pad_mouse = false;
1537  dev_dbg(dev, "mouse mode disabled, passing key value\n");
1538  }
1539  }
1540 
1541  ictx->kc = kc;
1542  spin_unlock_irqrestore(&ictx->kc_lock, flags);
1543 
1544  /* send touchscreen events through input subsystem if touchpad data */
1545  if (ictx->display_type == IMON_DISPLAY_TYPE_VGA && len == 8 &&
1546  buf[7] == 0x86) {
1547  imon_touch_event(ictx, buf);
1548  return;
1549 
1550  /* look for mouse events with pad in mouse mode */
1551  } else if (ictx->pad_mouse) {
1552  if (imon_mouse_event(ictx, buf, len))
1553  return;
1554  }
1555 
1556  /* Now for some special handling to convert pad input to arrow keys */
1557  if (((len == 5) && (buf[0] == 0x01) && (buf[4] == 0x00)) ||
1558  ((len == 8) && (buf[0] & 0x40) &&
1559  !(buf[1] & 0x1 || buf[1] >> 2 & 0x1))) {
1560  len = 8;
1561  imon_pad_to_keys(ictx, buf);
1562  }
1563 
1564  if (debug) {
1565  printk(KERN_INFO "intf%d decoded packet: ", intf);
1566  for (i = 0; i < len; ++i)
1567  printk("%02x ", buf[i]);
1568  printk("\n");
1569  }
1570 
1571  press_type = imon_parse_press_type(ictx, buf, ktype);
1572  if (press_type < 0)
1573  goto not_input_data;
1574 
1575  spin_lock_irqsave(&ictx->kc_lock, flags);
1576  if (ictx->kc == KEY_UNKNOWN)
1577  goto unknown_key;
1578  spin_unlock_irqrestore(&ictx->kc_lock, flags);
1579 
1580  if (ktype != IMON_KEY_PANEL) {
1581  if (press_type == 0)
1582  rc_keyup(ictx->rdev);
1583  else {
1584  rc_keydown(ictx->rdev, ictx->rc_scancode, ictx->rc_toggle);
1585  spin_lock_irqsave(&ictx->kc_lock, flags);
1586  ictx->last_keycode = ictx->kc;
1587  spin_unlock_irqrestore(&ictx->kc_lock, flags);
1588  }
1589  return;
1590  }
1591 
1592  /* Only panel type events left to process now */
1593  spin_lock_irqsave(&ictx->kc_lock, flags);
1594 
1595  do_gettimeofday(&t);
1596  /* KEY_MUTE repeats from knob need to be suppressed */
1597  if (ictx->kc == KEY_MUTE && ictx->kc == ictx->last_keycode) {
1598  msec = tv2int(&t, &prev_time);
1599  if (msec < ictx->idev->rep[REP_DELAY]) {
1600  spin_unlock_irqrestore(&ictx->kc_lock, flags);
1601  return;
1602  }
1603  }
1604  prev_time = t;
1605  kc = ictx->kc;
1606 
1607  spin_unlock_irqrestore(&ictx->kc_lock, flags);
1608 
1609  input_report_key(ictx->idev, kc, press_type);
1610  input_sync(ictx->idev);
1611 
1612  /* panel keys don't generate a release */
1613  input_report_key(ictx->idev, kc, 0);
1614  input_sync(ictx->idev);
1615 
1616  spin_lock_irqsave(&ictx->kc_lock, flags);
1617  ictx->last_keycode = kc;
1618  spin_unlock_irqrestore(&ictx->kc_lock, flags);
1619 
1620  return;
1621 
1622 unknown_key:
1623  spin_unlock_irqrestore(&ictx->kc_lock, flags);
1624  dev_info(dev, "%s: unknown keypress, code 0x%llx\n", __func__,
1625  (long long)scancode);
1626  return;
1627 
1628 not_input_data:
1629  if (len != 8) {
1630  dev_warn(dev, "imon %s: invalid incoming packet "
1631  "size (len = %d, intf%d)\n", __func__, len, intf);
1632  return;
1633  }
1634 
1635  /* iMON 2.4G associate frame */
1636  if (buf[0] == 0x00 &&
1637  buf[2] == 0xFF && /* REFID */
1638  buf[3] == 0xFF &&
1639  buf[4] == 0xFF &&
1640  buf[5] == 0xFF && /* iMON 2.4G */
1641  ((buf[6] == 0x4E && buf[7] == 0xDF) || /* LT */
1642  (buf[6] == 0x5E && buf[7] == 0xDF))) { /* DT */
1643  dev_warn(dev, "%s: remote associated refid=%02X\n",
1644  __func__, buf[1]);
1645  ictx->rf_isassociating = false;
1646  }
1647 }
1648 
1652 static void usb_rx_callback_intf0(struct urb *urb)
1653 {
1654  struct imon_context *ictx;
1655  int intfnum = 0;
1656 
1657  if (!urb)
1658  return;
1659 
1660  ictx = (struct imon_context *)urb->context;
1661  if (!ictx)
1662  return;
1663 
1664  /*
1665  * if we get a callback before we're done configuring the hardware, we
1666  * can't yet process the data, as there's nowhere to send it, but we
1667  * still need to submit a new rx URB to avoid wedging the hardware
1668  */
1669  if (!ictx->dev_present_intf0)
1670  goto out;
1671 
1672  switch (urb->status) {
1673  case -ENOENT: /* usbcore unlink successful! */
1674  return;
1675 
1676  case -ESHUTDOWN: /* transport endpoint was shut down */
1677  break;
1678 
1679  case 0:
1680  imon_incoming_packet(ictx, urb, intfnum);
1681  break;
1682 
1683  default:
1684  dev_warn(ictx->dev, "imon %s: status(%d): ignored\n",
1685  __func__, urb->status);
1686  break;
1687  }
1688 
1689 out:
1690  usb_submit_urb(ictx->rx_urb_intf0, GFP_ATOMIC);
1691 }
1692 
1693 static void usb_rx_callback_intf1(struct urb *urb)
1694 {
1695  struct imon_context *ictx;
1696  int intfnum = 1;
1697 
1698  if (!urb)
1699  return;
1700 
1701  ictx = (struct imon_context *)urb->context;
1702  if (!ictx)
1703  return;
1704 
1705  /*
1706  * if we get a callback before we're done configuring the hardware, we
1707  * can't yet process the data, as there's nowhere to send it, but we
1708  * still need to submit a new rx URB to avoid wedging the hardware
1709  */
1710  if (!ictx->dev_present_intf1)
1711  goto out;
1712 
1713  switch (urb->status) {
1714  case -ENOENT: /* usbcore unlink successful! */
1715  return;
1716 
1717  case -ESHUTDOWN: /* transport endpoint was shut down */
1718  break;
1719 
1720  case 0:
1721  imon_incoming_packet(ictx, urb, intfnum);
1722  break;
1723 
1724  default:
1725  dev_warn(ictx->dev, "imon %s: status(%d): ignored\n",
1726  __func__, urb->status);
1727  break;
1728  }
1729 
1730 out:
1731  usb_submit_urb(ictx->rx_urb_intf1, GFP_ATOMIC);
1732 }
1733 
1734 /*
1735  * The 0x15c2:0xffdc device ID was used for umpteen different imon
1736  * devices, and all of them constantly spew interrupts, even when there
1737  * is no actual data to report. However, byte 6 of this buffer looks like
1738  * its unique across device variants, so we're trying to key off that to
1739  * figure out which display type (if any) and what IR protocol the device
1740  * actually supports. These devices have their IR protocol hard-coded into
1741  * their firmware, they can't be changed on the fly like the newer hardware.
1742  */
1743 static void imon_get_ffdc_type(struct imon_context *ictx)
1744 {
1745  u8 ffdc_cfg_byte = ictx->usb_rx_buf[6];
1746  u8 detected_display_type = IMON_DISPLAY_TYPE_NONE;
1747  u64 allowed_protos = RC_TYPE_OTHER;
1748 
1749  switch (ffdc_cfg_byte) {
1750  /* iMON Knob, no display, iMON IR + vol knob */
1751  case 0x21:
1752  dev_info(ictx->dev, "0xffdc iMON Knob, iMON IR");
1753  ictx->display_supported = false;
1754  break;
1755  /* iMON 2.4G LT (usb stick), no display, iMON RF */
1756  case 0x4e:
1757  dev_info(ictx->dev, "0xffdc iMON 2.4G LT, iMON RF");
1758  ictx->display_supported = false;
1759  ictx->rf_device = true;
1760  break;
1761  /* iMON VFD, no IR (does have vol knob tho) */
1762  case 0x35:
1763  dev_info(ictx->dev, "0xffdc iMON VFD + knob, no IR");
1764  detected_display_type = IMON_DISPLAY_TYPE_VFD;
1765  break;
1766  /* iMON VFD, iMON IR */
1767  case 0x24:
1768  case 0x85:
1769  dev_info(ictx->dev, "0xffdc iMON VFD, iMON IR");
1770  detected_display_type = IMON_DISPLAY_TYPE_VFD;
1771  break;
1772  /* iMON VFD, MCE IR */
1773  case 0x46:
1774  case 0x7e:
1775  case 0x9e:
1776  dev_info(ictx->dev, "0xffdc iMON VFD, MCE IR");
1777  detected_display_type = IMON_DISPLAY_TYPE_VFD;
1778  allowed_protos = RC_TYPE_RC6;
1779  break;
1780  /* iMON LCD, MCE IR */
1781  case 0x9f:
1782  dev_info(ictx->dev, "0xffdc iMON LCD, MCE IR");
1783  detected_display_type = IMON_DISPLAY_TYPE_LCD;
1784  allowed_protos = RC_TYPE_RC6;
1785  break;
1786  default:
1787  dev_info(ictx->dev, "Unknown 0xffdc device, "
1788  "defaulting to VFD and iMON IR");
1789  detected_display_type = IMON_DISPLAY_TYPE_VFD;
1790  /* We don't know which one it is, allow user to set the
1791  * RC6 one from userspace if OTHER wasn't correct. */
1792  allowed_protos |= RC_TYPE_RC6;
1793  break;
1794  }
1795 
1796  printk(KERN_CONT " (id 0x%02x)\n", ffdc_cfg_byte);
1797 
1798  ictx->display_type = detected_display_type;
1799  ictx->rc_type = allowed_protos;
1800 }
1801 
1802 static void imon_set_display_type(struct imon_context *ictx)
1803 {
1804  u8 configured_display_type = IMON_DISPLAY_TYPE_VFD;
1805 
1806  /*
1807  * Try to auto-detect the type of display if the user hasn't set
1808  * it by hand via the display_type modparam. Default is VFD.
1809  */
1810 
1811  if (display_type == IMON_DISPLAY_TYPE_AUTO) {
1812  switch (ictx->product) {
1813  case 0xffdc:
1814  /* set in imon_get_ffdc_type() */
1815  configured_display_type = ictx->display_type;
1816  break;
1817  case 0x0034:
1818  case 0x0035:
1819  configured_display_type = IMON_DISPLAY_TYPE_VGA;
1820  break;
1821  case 0x0038:
1822  case 0x0039:
1823  case 0x0045:
1824  configured_display_type = IMON_DISPLAY_TYPE_LCD;
1825  break;
1826  case 0x003c:
1827  case 0x0041:
1828  case 0x0042:
1829  case 0x0043:
1830  configured_display_type = IMON_DISPLAY_TYPE_NONE;
1831  ictx->display_supported = false;
1832  break;
1833  case 0x0036:
1834  case 0x0044:
1835  default:
1836  configured_display_type = IMON_DISPLAY_TYPE_VFD;
1837  break;
1838  }
1839  } else {
1840  configured_display_type = display_type;
1841  if (display_type == IMON_DISPLAY_TYPE_NONE)
1842  ictx->display_supported = false;
1843  else
1844  ictx->display_supported = true;
1845  dev_info(ictx->dev, "%s: overriding display type to %d via "
1846  "modparam\n", __func__, display_type);
1847  }
1848 
1849  ictx->display_type = configured_display_type;
1850 }
1851 
1852 static struct rc_dev *imon_init_rdev(struct imon_context *ictx)
1853 {
1854  struct rc_dev *rdev;
1855  int ret;
1856  const unsigned char fp_packet[] = { 0x40, 0x00, 0x00, 0x00,
1857  0x00, 0x00, 0x00, 0x88 };
1858 
1859  rdev = rc_allocate_device();
1860  if (!rdev) {
1861  dev_err(ictx->dev, "remote control dev allocation failed\n");
1862  goto out;
1863  }
1864 
1865  snprintf(ictx->name_rdev, sizeof(ictx->name_rdev),
1866  "iMON Remote (%04x:%04x)", ictx->vendor, ictx->product);
1867  usb_make_path(ictx->usbdev_intf0, ictx->phys_rdev,
1868  sizeof(ictx->phys_rdev));
1869  strlcat(ictx->phys_rdev, "/input0", sizeof(ictx->phys_rdev));
1870 
1871  rdev->input_name = ictx->name_rdev;
1872  rdev->input_phys = ictx->phys_rdev;
1873  usb_to_input_id(ictx->usbdev_intf0, &rdev->input_id);
1874  rdev->dev.parent = ictx->dev;
1875 
1876  rdev->priv = ictx;
1877  rdev->driver_type = RC_DRIVER_SCANCODE;
1878  rdev->allowed_protos = RC_TYPE_OTHER | RC_TYPE_RC6; /* iMON PAD or MCE */
1879  rdev->change_protocol = imon_ir_change_protocol;
1880  rdev->driver_name = MOD_NAME;
1881 
1882  /* Enable front-panel buttons and/or knobs */
1883  memcpy(ictx->usb_tx_buf, &fp_packet, sizeof(fp_packet));
1884  ret = send_packet(ictx);
1885  /* Not fatal, but warn about it */
1886  if (ret)
1887  dev_info(ictx->dev, "panel buttons/knobs setup failed\n");
1888 
1889  if (ictx->product == 0xffdc) {
1890  imon_get_ffdc_type(ictx);
1891  rdev->allowed_protos = ictx->rc_type;
1892  }
1893 
1894  imon_set_display_type(ictx);
1895 
1896  if (ictx->rc_type == RC_TYPE_RC6)
1897  rdev->map_name = RC_MAP_IMON_MCE;
1898  else
1899  rdev->map_name = RC_MAP_IMON_PAD;
1900 
1901  ret = rc_register_device(rdev);
1902  if (ret < 0) {
1903  dev_err(ictx->dev, "remote input dev register failed\n");
1904  goto out;
1905  }
1906 
1907  return rdev;
1908 
1909 out:
1910  rc_free_device(rdev);
1911  return NULL;
1912 }
1913 
1914 static struct input_dev *imon_init_idev(struct imon_context *ictx)
1915 {
1916  struct input_dev *idev;
1917  int ret, i;
1918 
1919  idev = input_allocate_device();
1920  if (!idev) {
1921  dev_err(ictx->dev, "input dev allocation failed\n");
1922  goto out;
1923  }
1924 
1925  snprintf(ictx->name_idev, sizeof(ictx->name_idev),
1926  "iMON Panel, Knob and Mouse(%04x:%04x)",
1927  ictx->vendor, ictx->product);
1928  idev->name = ictx->name_idev;
1929 
1930  usb_make_path(ictx->usbdev_intf0, ictx->phys_idev,
1931  sizeof(ictx->phys_idev));
1932  strlcat(ictx->phys_idev, "/input1", sizeof(ictx->phys_idev));
1933  idev->phys = ictx->phys_idev;
1934 
1935  idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) | BIT_MASK(EV_REL);
1936 
1937  idev->keybit[BIT_WORD(BTN_MOUSE)] =
1938  BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_RIGHT);
1939  idev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y) |
1940  BIT_MASK(REL_WHEEL);
1941 
1942  /* panel and/or knob code support */
1943  for (i = 0; i < ARRAY_SIZE(imon_panel_key_table); i++) {
1944  u32 kc = imon_panel_key_table[i].keycode;
1945  __set_bit(kc, idev->keybit);
1946  }
1947 
1948  usb_to_input_id(ictx->usbdev_intf0, &idev->id);
1949  idev->dev.parent = ictx->dev;
1950  input_set_drvdata(idev, ictx);
1951 
1952  ret = input_register_device(idev);
1953  if (ret < 0) {
1954  dev_err(ictx->dev, "input dev register failed\n");
1955  goto out;
1956  }
1957 
1958  return idev;
1959 
1960 out:
1961  input_free_device(idev);
1962  return NULL;
1963 }
1964 
1965 static struct input_dev *imon_init_touch(struct imon_context *ictx)
1966 {
1967  struct input_dev *touch;
1968  int ret;
1969 
1970  touch = input_allocate_device();
1971  if (!touch) {
1972  dev_err(ictx->dev, "touchscreen input dev allocation failed\n");
1973  goto touch_alloc_failed;
1974  }
1975 
1976  snprintf(ictx->name_touch, sizeof(ictx->name_touch),
1977  "iMON USB Touchscreen (%04x:%04x)",
1978  ictx->vendor, ictx->product);
1979  touch->name = ictx->name_touch;
1980 
1981  usb_make_path(ictx->usbdev_intf1, ictx->phys_touch,
1982  sizeof(ictx->phys_touch));
1983  strlcat(ictx->phys_touch, "/input2", sizeof(ictx->phys_touch));
1984  touch->phys = ictx->phys_touch;
1985 
1986  touch->evbit[0] =
1987  BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
1988  touch->keybit[BIT_WORD(BTN_TOUCH)] =
1989  BIT_MASK(BTN_TOUCH);
1990  input_set_abs_params(touch, ABS_X,
1991  0x00, 0xfff, 0, 0);
1992  input_set_abs_params(touch, ABS_Y,
1993  0x00, 0xfff, 0, 0);
1994 
1995  input_set_drvdata(touch, ictx);
1996 
1997  usb_to_input_id(ictx->usbdev_intf1, &touch->id);
1998  touch->dev.parent = ictx->dev;
1999  ret = input_register_device(touch);
2000  if (ret < 0) {
2001  dev_info(ictx->dev, "touchscreen input dev register failed\n");
2002  goto touch_register_failed;
2003  }
2004 
2005  return touch;
2006 
2007 touch_register_failed:
2008  input_free_device(touch);
2009 
2010 touch_alloc_failed:
2011  return NULL;
2012 }
2013 
2014 static bool imon_find_endpoints(struct imon_context *ictx,
2015  struct usb_host_interface *iface_desc)
2016 {
2017  struct usb_endpoint_descriptor *ep;
2018  struct usb_endpoint_descriptor *rx_endpoint = NULL;
2019  struct usb_endpoint_descriptor *tx_endpoint = NULL;
2020  int ifnum = iface_desc->desc.bInterfaceNumber;
2021  int num_endpts = iface_desc->desc.bNumEndpoints;
2022  int i, ep_dir, ep_type;
2023  bool ir_ep_found = false;
2024  bool display_ep_found = false;
2025  bool tx_control = false;
2026 
2027  /*
2028  * Scan the endpoint list and set:
2029  * first input endpoint = IR endpoint
2030  * first output endpoint = display endpoint
2031  */
2032  for (i = 0; i < num_endpts && !(ir_ep_found && display_ep_found); ++i) {
2033  ep = &iface_desc->endpoint[i].desc;
2034  ep_dir = ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK;
2035  ep_type = ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
2036 
2037  if (!ir_ep_found && ep_dir == USB_DIR_IN &&
2038  ep_type == USB_ENDPOINT_XFER_INT) {
2039 
2040  rx_endpoint = ep;
2041  ir_ep_found = true;
2042  dev_dbg(ictx->dev, "%s: found IR endpoint\n", __func__);
2043 
2044  } else if (!display_ep_found && ep_dir == USB_DIR_OUT &&
2045  ep_type == USB_ENDPOINT_XFER_INT) {
2046  tx_endpoint = ep;
2047  display_ep_found = true;
2048  dev_dbg(ictx->dev, "%s: found display endpoint\n", __func__);
2049  }
2050  }
2051 
2052  if (ifnum == 0) {
2053  ictx->rx_endpoint_intf0 = rx_endpoint;
2054  /*
2055  * tx is used to send characters to lcd/vfd, associate RF
2056  * remotes, set IR protocol, and maybe more...
2057  */
2058  ictx->tx_endpoint = tx_endpoint;
2059  } else {
2060  ictx->rx_endpoint_intf1 = rx_endpoint;
2061  }
2062 
2063  /*
2064  * If we didn't find a display endpoint, this is probably one of the
2065  * newer iMON devices that use control urb instead of interrupt
2066  */
2067  if (!display_ep_found) {
2068  tx_control = true;
2069  display_ep_found = true;
2070  dev_dbg(ictx->dev, "%s: device uses control endpoint, not "
2071  "interface OUT endpoint\n", __func__);
2072  }
2073 
2074  /*
2075  * Some iMON receivers have no display. Unfortunately, it seems
2076  * that SoundGraph recycles device IDs between devices both with
2077  * and without... :\
2078  */
2079  if (ictx->display_type == IMON_DISPLAY_TYPE_NONE) {
2080  display_ep_found = false;
2081  dev_dbg(ictx->dev, "%s: device has no display\n", __func__);
2082  }
2083 
2084  /*
2085  * iMON Touch devices have a VGA touchscreen, but no "display", as
2086  * that refers to e.g. /dev/lcd0 (a character device LCD or VFD).
2087  */
2088  if (ictx->display_type == IMON_DISPLAY_TYPE_VGA) {
2089  display_ep_found = false;
2090  dev_dbg(ictx->dev, "%s: iMON Touch device found\n", __func__);
2091  }
2092 
2093  /* Input endpoint is mandatory */
2094  if (!ir_ep_found)
2095  pr_err("no valid input (IR) endpoint found\n");
2096 
2097  ictx->tx_control = tx_control;
2098 
2099  if (display_ep_found)
2100  ictx->display_supported = true;
2101 
2102  return ir_ep_found;
2103 
2104 }
2105 
2106 static struct imon_context *imon_init_intf0(struct usb_interface *intf)
2107 {
2108  struct imon_context *ictx;
2109  struct urb *rx_urb;
2110  struct urb *tx_urb;
2111  struct device *dev = &intf->dev;
2112  struct usb_host_interface *iface_desc;
2113  int ret = -ENOMEM;
2114 
2115  ictx = kzalloc(sizeof(struct imon_context), GFP_KERNEL);
2116  if (!ictx) {
2117  dev_err(dev, "%s: kzalloc failed for context", __func__);
2118  goto exit;
2119  }
2120  rx_urb = usb_alloc_urb(0, GFP_KERNEL);
2121  if (!rx_urb) {
2122  dev_err(dev, "%s: usb_alloc_urb failed for IR urb", __func__);
2123  goto rx_urb_alloc_failed;
2124  }
2125  tx_urb = usb_alloc_urb(0, GFP_KERNEL);
2126  if (!tx_urb) {
2127  dev_err(dev, "%s: usb_alloc_urb failed for display urb",
2128  __func__);
2129  goto tx_urb_alloc_failed;
2130  }
2131 
2132  mutex_init(&ictx->lock);
2133  spin_lock_init(&ictx->kc_lock);
2134 
2135  mutex_lock(&ictx->lock);
2136 
2137  ictx->dev = dev;
2138  ictx->usbdev_intf0 = usb_get_dev(interface_to_usbdev(intf));
2139  ictx->rx_urb_intf0 = rx_urb;
2140  ictx->tx_urb = tx_urb;
2141  ictx->rf_device = false;
2142 
2143  ictx->vendor = le16_to_cpu(ictx->usbdev_intf0->descriptor.idVendor);
2144  ictx->product = le16_to_cpu(ictx->usbdev_intf0->descriptor.idProduct);
2145 
2146  ret = -ENODEV;
2147  iface_desc = intf->cur_altsetting;
2148  if (!imon_find_endpoints(ictx, iface_desc)) {
2149  goto find_endpoint_failed;
2150  }
2151 
2152  usb_fill_int_urb(ictx->rx_urb_intf0, ictx->usbdev_intf0,
2153  usb_rcvintpipe(ictx->usbdev_intf0,
2154  ictx->rx_endpoint_intf0->bEndpointAddress),
2155  ictx->usb_rx_buf, sizeof(ictx->usb_rx_buf),
2156  usb_rx_callback_intf0, ictx,
2157  ictx->rx_endpoint_intf0->bInterval);
2158 
2159  ret = usb_submit_urb(ictx->rx_urb_intf0, GFP_KERNEL);
2160  if (ret) {
2161  pr_err("usb_submit_urb failed for intf0 (%d)\n", ret);
2162  goto urb_submit_failed;
2163  }
2164 
2165  ictx->idev = imon_init_idev(ictx);
2166  if (!ictx->idev) {
2167  dev_err(dev, "%s: input device setup failed\n", __func__);
2168  goto idev_setup_failed;
2169  }
2170 
2171  ictx->rdev = imon_init_rdev(ictx);
2172  if (!ictx->rdev) {
2173  dev_err(dev, "%s: rc device setup failed\n", __func__);
2174  goto rdev_setup_failed;
2175  }
2176 
2177  ictx->dev_present_intf0 = true;
2178 
2179  mutex_unlock(&ictx->lock);
2180  return ictx;
2181 
2182 rdev_setup_failed:
2183  input_unregister_device(ictx->idev);
2184 idev_setup_failed:
2185  usb_kill_urb(ictx->rx_urb_intf0);
2186 urb_submit_failed:
2187 find_endpoint_failed:
2188  mutex_unlock(&ictx->lock);
2189  usb_free_urb(tx_urb);
2190 tx_urb_alloc_failed:
2191  usb_free_urb(rx_urb);
2192 rx_urb_alloc_failed:
2193  kfree(ictx);
2194 exit:
2195  dev_err(dev, "unable to initialize intf0, err %d\n", ret);
2196 
2197  return NULL;
2198 }
2199 
2200 static struct imon_context *imon_init_intf1(struct usb_interface *intf,
2201  struct imon_context *ictx)
2202 {
2203  struct urb *rx_urb;
2204  struct usb_host_interface *iface_desc;
2205  int ret = -ENOMEM;
2206 
2207  rx_urb = usb_alloc_urb(0, GFP_KERNEL);
2208  if (!rx_urb) {
2209  pr_err("usb_alloc_urb failed for IR urb\n");
2210  goto rx_urb_alloc_failed;
2211  }
2212 
2213  mutex_lock(&ictx->lock);
2214 
2215  if (ictx->display_type == IMON_DISPLAY_TYPE_VGA) {
2216  init_timer(&ictx->ttimer);
2217  ictx->ttimer.data = (unsigned long)ictx;
2218  ictx->ttimer.function = imon_touch_display_timeout;
2219  }
2220 
2221  ictx->usbdev_intf1 = usb_get_dev(interface_to_usbdev(intf));
2222  ictx->rx_urb_intf1 = rx_urb;
2223 
2224  ret = -ENODEV;
2225  iface_desc = intf->cur_altsetting;
2226  if (!imon_find_endpoints(ictx, iface_desc))
2227  goto find_endpoint_failed;
2228 
2229  if (ictx->display_type == IMON_DISPLAY_TYPE_VGA) {
2230  ictx->touch = imon_init_touch(ictx);
2231  if (!ictx->touch)
2232  goto touch_setup_failed;
2233  } else
2234  ictx->touch = NULL;
2235 
2236  usb_fill_int_urb(ictx->rx_urb_intf1, ictx->usbdev_intf1,
2237  usb_rcvintpipe(ictx->usbdev_intf1,
2238  ictx->rx_endpoint_intf1->bEndpointAddress),
2239  ictx->usb_rx_buf, sizeof(ictx->usb_rx_buf),
2240  usb_rx_callback_intf1, ictx,
2241  ictx->rx_endpoint_intf1->bInterval);
2242 
2243  ret = usb_submit_urb(ictx->rx_urb_intf1, GFP_KERNEL);
2244 
2245  if (ret) {
2246  pr_err("usb_submit_urb failed for intf1 (%d)\n", ret);
2247  goto urb_submit_failed;
2248  }
2249 
2250  ictx->dev_present_intf1 = true;
2251 
2252  mutex_unlock(&ictx->lock);
2253  return ictx;
2254 
2255 urb_submit_failed:
2256  if (ictx->touch)
2257  input_unregister_device(ictx->touch);
2258 touch_setup_failed:
2259 find_endpoint_failed:
2260  mutex_unlock(&ictx->lock);
2261  usb_free_urb(rx_urb);
2262 rx_urb_alloc_failed:
2263  dev_err(ictx->dev, "unable to initialize intf1, err %d\n", ret);
2264 
2265  return NULL;
2266 }
2267 
2268 static void imon_init_display(struct imon_context *ictx,
2269  struct usb_interface *intf)
2270 {
2271  int ret;
2272 
2273  dev_dbg(ictx->dev, "Registering iMON display with sysfs\n");
2274 
2275  /* set up sysfs entry for built-in clock */
2276  ret = sysfs_create_group(&intf->dev.kobj, &imon_display_attr_group);
2277  if (ret)
2278  dev_err(ictx->dev, "Could not create display sysfs "
2279  "entries(%d)", ret);
2280 
2281  if (ictx->display_type == IMON_DISPLAY_TYPE_LCD)
2282  ret = usb_register_dev(intf, &imon_lcd_class);
2283  else
2284  ret = usb_register_dev(intf, &imon_vfd_class);
2285  if (ret)
2286  /* Not a fatal error, so ignore */
2287  dev_info(ictx->dev, "could not get a minor number for "
2288  "display\n");
2289 
2290 }
2291 
2295 static int __devinit imon_probe(struct usb_interface *interface,
2296  const struct usb_device_id *id)
2297 {
2298  struct usb_device *usbdev = NULL;
2299  struct usb_host_interface *iface_desc = NULL;
2300  struct usb_interface *first_if;
2301  struct device *dev = &interface->dev;
2302  int ifnum, sysfs_err;
2303  int ret = 0;
2304  struct imon_context *ictx = NULL;
2305  struct imon_context *first_if_ctx = NULL;
2306  u16 vendor, product;
2307 
2308  usbdev = usb_get_dev(interface_to_usbdev(interface));
2309  iface_desc = interface->cur_altsetting;
2310  ifnum = iface_desc->desc.bInterfaceNumber;
2311  vendor = le16_to_cpu(usbdev->descriptor.idVendor);
2312  product = le16_to_cpu(usbdev->descriptor.idProduct);
2313 
2314  dev_dbg(dev, "%s: found iMON device (%04x:%04x, intf%d)\n",
2315  __func__, vendor, product, ifnum);
2316 
2317  /* prevent races probing devices w/multiple interfaces */
2318  mutex_lock(&driver_lock);
2319 
2320  first_if = usb_ifnum_to_if(usbdev, 0);
2321  first_if_ctx = usb_get_intfdata(first_if);
2322 
2323  if (ifnum == 0) {
2324  ictx = imon_init_intf0(interface);
2325  if (!ictx) {
2326  pr_err("failed to initialize context!\n");
2327  ret = -ENODEV;
2328  goto fail;
2329  }
2330 
2331  } else {
2332  /* this is the secondary interface on the device */
2333  ictx = imon_init_intf1(interface, first_if_ctx);
2334  if (!ictx) {
2335  pr_err("failed to attach to context!\n");
2336  ret = -ENODEV;
2337  goto fail;
2338  }
2339 
2340  }
2341 
2342  usb_set_intfdata(interface, ictx);
2343 
2344  if (ifnum == 0) {
2345  mutex_lock(&ictx->lock);
2346 
2347  if (product == 0xffdc && ictx->rf_device) {
2348  sysfs_err = sysfs_create_group(&interface->dev.kobj,
2349  &imon_rf_attr_group);
2350  if (sysfs_err)
2351  pr_err("Could not create RF sysfs entries(%d)\n",
2352  sysfs_err);
2353  }
2354 
2355  if (ictx->display_supported)
2356  imon_init_display(ictx, interface);
2357 
2358  mutex_unlock(&ictx->lock);
2359  }
2360 
2361  dev_info(dev, "iMON device (%04x:%04x, intf%d) on "
2362  "usb<%d:%d> initialized\n", vendor, product, ifnum,
2363  usbdev->bus->busnum, usbdev->devnum);
2364 
2365  mutex_unlock(&driver_lock);
2366 
2367  return 0;
2368 
2369 fail:
2370  mutex_unlock(&driver_lock);
2371  dev_err(dev, "unable to register, err %d\n", ret);
2372 
2373  return ret;
2374 }
2375 
2379 static void __devexit imon_disconnect(struct usb_interface *interface)
2380 {
2381  struct imon_context *ictx;
2382  struct device *dev;
2383  int ifnum;
2384 
2385  /* prevent races with multi-interface device probing and display_open */
2386  mutex_lock(&driver_lock);
2387 
2388  ictx = usb_get_intfdata(interface);
2389  dev = ictx->dev;
2390  ifnum = interface->cur_altsetting->desc.bInterfaceNumber;
2391 
2392  /*
2393  * sysfs_remove_group is safe to call even if sysfs_create_group
2394  * hasn't been called
2395  */
2396  sysfs_remove_group(&interface->dev.kobj, &imon_display_attr_group);
2397  sysfs_remove_group(&interface->dev.kobj, &imon_rf_attr_group);
2398 
2399  usb_set_intfdata(interface, NULL);
2400 
2401  /* Abort ongoing write */
2402  if (ictx->tx.busy) {
2403  usb_kill_urb(ictx->tx_urb);
2404  complete_all(&ictx->tx.finished);
2405  }
2406 
2407  if (ifnum == 0) {
2408  ictx->dev_present_intf0 = false;
2409  usb_kill_urb(ictx->rx_urb_intf0);
2410  input_unregister_device(ictx->idev);
2411  rc_unregister_device(ictx->rdev);
2412  if (ictx->display_supported) {
2413  if (ictx->display_type == IMON_DISPLAY_TYPE_LCD)
2414  usb_deregister_dev(interface, &imon_lcd_class);
2415  else if (ictx->display_type == IMON_DISPLAY_TYPE_VFD)
2416  usb_deregister_dev(interface, &imon_vfd_class);
2417  }
2418  } else {
2419  ictx->dev_present_intf1 = false;
2420  usb_kill_urb(ictx->rx_urb_intf1);
2421  if (ictx->display_type == IMON_DISPLAY_TYPE_VGA) {
2422  input_unregister_device(ictx->touch);
2423  del_timer_sync(&ictx->ttimer);
2424  }
2425  }
2426 
2427  if (!ictx->dev_present_intf0 && !ictx->dev_present_intf1)
2428  free_imon_context(ictx);
2429 
2430  mutex_unlock(&driver_lock);
2431 
2432  dev_dbg(dev, "%s: iMON device (intf%d) disconnected\n",
2433  __func__, ifnum);
2434 }
2435 
2436 static int imon_suspend(struct usb_interface *intf, pm_message_t message)
2437 {
2438  struct imon_context *ictx = usb_get_intfdata(intf);
2439  int ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
2440 
2441  if (ifnum == 0)
2442  usb_kill_urb(ictx->rx_urb_intf0);
2443  else
2444  usb_kill_urb(ictx->rx_urb_intf1);
2445 
2446  return 0;
2447 }
2448 
2449 static int imon_resume(struct usb_interface *intf)
2450 {
2451  int rc = 0;
2452  struct imon_context *ictx = usb_get_intfdata(intf);
2453  int ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
2454 
2455  if (ifnum == 0) {
2456  usb_fill_int_urb(ictx->rx_urb_intf0, ictx->usbdev_intf0,
2457  usb_rcvintpipe(ictx->usbdev_intf0,
2458  ictx->rx_endpoint_intf0->bEndpointAddress),
2459  ictx->usb_rx_buf, sizeof(ictx->usb_rx_buf),
2460  usb_rx_callback_intf0, ictx,
2461  ictx->rx_endpoint_intf0->bInterval);
2462 
2463  rc = usb_submit_urb(ictx->rx_urb_intf0, GFP_ATOMIC);
2464 
2465  } else {
2466  usb_fill_int_urb(ictx->rx_urb_intf1, ictx->usbdev_intf1,
2467  usb_rcvintpipe(ictx->usbdev_intf1,
2468  ictx->rx_endpoint_intf1->bEndpointAddress),
2469  ictx->usb_rx_buf, sizeof(ictx->usb_rx_buf),
2470  usb_rx_callback_intf1, ictx,
2471  ictx->rx_endpoint_intf1->bInterval);
2472 
2473  rc = usb_submit_urb(ictx->rx_urb_intf1, GFP_ATOMIC);
2474  }
2475 
2476  return rc;
2477 }
2478 
2479 module_usb_driver(imon_driver);
Generated on Thu Jan 10 2013 13:50:18 for Linux Kernel by   doxygen 1.8.2