drivers/media/IR/imon.c

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