drivers/media/rc/mceusb.c

   1 /*
   2  * Driver for USB Windows Media Center Ed. eHome Infrared Transceivers
   3  *
   4  * Copyright (c) 2010-2011, Jarod Wilson <jarod@redhat.com>
   5  *
   6  * Based on the original lirc_mceusb and lirc_mceusb2 drivers, by Dan
   7  * Conti, Martin Blatter and Daniel Melander, the latter of which was
   8  * in turn also based on the lirc_atiusb driver by Paul Miller. The
   9  * two mce drivers were merged into one by Jarod Wilson, with transmit
  10  * support for the 1st-gen device added primarily by Patrick Calhoun,
  11  * with a bit of tweaks by Jarod. Debugging improvements and proper
  12  * support for what appears to be 3rd-gen hardware added by Jarod.
  13  * Initial port from lirc driver to ir-core drivery by Jarod, based
  14  * partially on a port to an earlier proposed IR infrastructure by
  15  * Jon Smirl, which included enhancements and simplifications to the
  16  * incoming IR buffer parsing routines.
  17  *
  18  * Updated in July of 2011 with the aid of Microsoft's official
  19  * remote/transceiver requirements and specification document, found at
  20  * download.microsoft.com, title
  21  * Windows-Media-Center-RC-IR-Collection-Green-Button-Specification-03-08-2011-V2.pdf
  22  *
  23  *
  24  * This program is free software; you can redistribute it and/or modify
  25  * it under the terms of the GNU General Public License as published by
  26  * the Free Software Foundation; either version 2 of the License, or
  27  * (at your option) any later version.
  28  *
  29  * This program is distributed in the hope that it will be useful,
  30  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  31  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  32  * GNU General Public License for more details.
  33  *
  34  */
  35
  36 #include <linux/device.h>
  37 #include <linux/module.h>
  38 #include <linux/slab.h>
  39 #include <linux/workqueue.h>
  40 #include <linux/usb.h>
  41 #include <linux/usb/input.h>
  42 #include <linux/pm_wakeup.h>
  43 #include <media/rc-core.h>
  44
  45 #define DRIVER_VERSION  "1.93"
  46 #define DRIVER_AUTHOR   "Jarod Wilson <jarod@redhat.com>"
  47 #define DRIVER_DESC     "Windows Media Center Ed. eHome Infrared Transceiver " \
  48                         "device driver"
  49 #define DRIVER_NAME     "mceusb"
  50
  51 #define USB_CTRL_MSG_SZ         2  /* Size of usb ctrl msg on gen1 hw */
  52 #define MCE_G1_INIT_MSGS        40 /* Init messages on gen1 hw to throw out */
  53
  54 /* MCE constants */
  55 #define MCE_CMDBUF_SIZE         384  /* MCE Command buffer length */
  56 #define MCE_TIME_UNIT           50   /* Approx 50us resolution */
  57 #define MCE_CODE_LENGTH         5    /* Normal length of packet (with header) */
  58 #define MCE_PACKET_SIZE         4    /* Normal length of packet (without header) */
  59 #define MCE_IRDATA_HEADER       0x84 /* Actual header format is 0x80 + num_bytes */
  60 #define MCE_IRDATA_TRAILER      0x80 /* End of IR data */
  61 #define MCE_MAX_CHANNELS        2    /* Two transmitters, hardware dependent? */
  62 #define MCE_DEFAULT_TX_MASK     0x03 /* Vals: TX1=0x01, TX2=0x02, ALL=0x03 */
  63 #define MCE_PULSE_BIT           0x80 /* Pulse bit, MSB set == PULSE else SPACE */
  64 #define MCE_PULSE_MASK          0x7f /* Pulse mask */
  65 #define MCE_MAX_PULSE_LENGTH    0x7f /* Longest transmittable pulse symbol */
  66
  67 /*
  68  * The interface between the host and the IR hardware is command-response
  69  * based. All commands and responses have a consistent format, where a lead
  70  * byte always identifies the type of data following it. The lead byte has
  71  * a port value in the 3 highest bits and a length value in the 5 lowest
  72  * bits.
  73  *
  74  * The length field is overloaded, with a value of 11111 indicating that the
  75  * following byte is a command or response code, and the length of the entire
  76  * message is determined by the code. If the length field is not 11111, then
  77  * it specifies the number of bytes of port data that follow.
  78  */
  79 #define MCE_CMD                 0x1f
  80 #define MCE_PORT_IR             0x4     /* (0x4 << 5) | MCE_CMD = 0x9f */
  81 #define MCE_PORT_SYS            0x7     /* (0x7 << 5) | MCE_CMD = 0xff */
  82 #define MCE_PORT_SER            0x6     /* 0xc0 thru 0xdf flush & 0x1f bytes */
  83 #define MCE_PORT_MASK           0xe0    /* Mask out command bits */
  84
  85 /* Command port headers */
  86 #define MCE_CMD_PORT_IR         0x9f    /* IR-related cmd/rsp */
  87 #define MCE_CMD_PORT_SYS        0xff    /* System (non-IR) device cmd/rsp */
  88
  89 /* Commands that set device state  (2-4 bytes in length) */
  90 #define MCE_CMD_RESET           0xfe    /* Reset device, 2 bytes */
  91 #define MCE_CMD_RESUME          0xaa    /* Resume device after error, 2 bytes */
  92 #define MCE_CMD_SETIRCFS        0x06    /* Set tx carrier, 4 bytes */
  93 #define MCE_CMD_SETIRTIMEOUT    0x0c    /* Set timeout, 4 bytes */
  94 #define MCE_CMD_SETIRTXPORTS    0x08    /* Set tx ports, 3 bytes */
  95 #define MCE_CMD_SETIRRXPORTEN   0x14    /* Set rx ports, 3 bytes */
  96 #define MCE_CMD_FLASHLED        0x23    /* Flash receiver LED, 2 bytes */
  97
  98 /* Commands that query device state (all 2 bytes, unless noted) */
  99 #define MCE_CMD_GETIRCFS        0x07    /* Get carrier */
 100 #define MCE_CMD_GETIRTIMEOUT    0x0d    /* Get timeout */
 101 #define MCE_CMD_GETIRTXPORTS    0x13    /* Get tx ports */
 102 #define MCE_CMD_GETIRRXPORTEN   0x15    /* Get rx ports */
 103 #define MCE_CMD_GETPORTSTATUS   0x11    /* Get tx port status, 3 bytes */
 104 #define MCE_CMD_GETIRNUMPORTS   0x16    /* Get number of ports */
 105 #define MCE_CMD_GETWAKESOURCE   0x17    /* Get wake source */
 106 #define MCE_CMD_GETEMVER        0x22    /* Get emulator interface version */
 107 #define MCE_CMD_GETDEVDETAILS   0x21    /* Get device details (em ver2 only) */
 108 #define MCE_CMD_GETWAKESUPPORT  0x20    /* Get wake details (em ver2 only) */
 109 #define MCE_CMD_GETWAKEVERSION  0x18    /* Get wake pattern (em ver2 only) */
 110
 111 /* Misc commands */
 112 #define MCE_CMD_NOP             0xff    /* No operation */
 113
 114 /* Responses to commands (non-error cases) */
 115 #define MCE_RSP_EQIRCFS         0x06    /* tx carrier, 4 bytes */
 116 #define MCE_RSP_EQIRTIMEOUT     0x0c    /* rx timeout, 4 bytes */
 117 #define MCE_RSP_GETWAKESOURCE   0x17    /* wake source, 3 bytes */
 118 #define MCE_RSP_EQIRTXPORTS     0x08    /* tx port mask, 3 bytes */
 119 #define MCE_RSP_EQIRRXPORTEN    0x14    /* rx port mask, 3 bytes */
 120 #define MCE_RSP_GETPORTSTATUS   0x11    /* tx port status, 7 bytes */
 121 #define MCE_RSP_EQIRRXCFCNT     0x15    /* rx carrier count, 4 bytes */
 122 #define MCE_RSP_EQIRNUMPORTS    0x16    /* number of ports, 4 bytes */
 123 #define MCE_RSP_EQWAKESUPPORT   0x20    /* wake capabilities, 3 bytes */
 124 #define MCE_RSP_EQWAKEVERSION   0x18    /* wake pattern details, 6 bytes */
 125 #define MCE_RSP_EQDEVDETAILS    0x21    /* device capabilities, 3 bytes */
 126 #define MCE_RSP_EQEMVER         0x22    /* emulator interface ver, 3 bytes */
 127 #define MCE_RSP_FLASHLED        0x23    /* success flashing LED, 2 bytes */
 128
 129 /* Responses to error cases, must send MCE_CMD_RESUME to clear them */
 130 #define MCE_RSP_CMD_ILLEGAL     0xfe    /* illegal command for port, 2 bytes */
 131 #define MCE_RSP_TX_TIMEOUT      0x81    /* tx timed out, 2 bytes */
 132
 133 /* Misc commands/responses not defined in the MCE remote/transceiver spec */
 134 #define MCE_CMD_SIG_END         0x01    /* End of signal */
 135 #define MCE_CMD_PING            0x03    /* Ping device */
 136 #define MCE_CMD_UNKNOWN         0x04    /* Unknown */
 137 #define MCE_CMD_UNKNOWN2        0x05    /* Unknown */
 138 #define MCE_CMD_UNKNOWN3        0x09    /* Unknown */
 139 #define MCE_CMD_UNKNOWN4        0x0a    /* Unknown */
 140 #define MCE_CMD_G_REVISION      0x0b    /* Get hw/sw revision */
 141 #define MCE_CMD_UNKNOWN5        0x0e    /* Unknown */
 142 #define MCE_CMD_UNKNOWN6        0x0f    /* Unknown */
 143 #define MCE_CMD_UNKNOWN8        0x19    /* Unknown */
 144 #define MCE_CMD_UNKNOWN9        0x1b    /* Unknown */
 145 #define MCE_CMD_NULL            0x00    /* These show up various places... */
 146
 147 /* if buf[i] & MCE_PORT_MASK == 0x80 and buf[i] != MCE_CMD_PORT_IR,
 148  * then we're looking at a raw IR data sample */
 149 #define MCE_COMMAND_IRDATA      0x80
 150 #define MCE_PACKET_LENGTH_MASK  0x1f /* Packet length mask */
 151
 152 #define VENDOR_PHILIPS          0x0471
 153 #define VENDOR_SMK              0x0609
 154 #define VENDOR_TATUNG           0x1460
 155 #define VENDOR_GATEWAY          0x107b
 156 #define VENDOR_SHUTTLE          0x1308
 157 #define VENDOR_SHUTTLE2         0x051c
 158 #define VENDOR_MITSUMI          0x03ee
 159 #define VENDOR_TOPSEED          0x1784
 160 #define VENDOR_RICAVISION       0x179d
 161 #define VENDOR_ITRON            0x195d
 162 #define VENDOR_FIC              0x1509
 163 #define VENDOR_LG               0x043e
 164 #define VENDOR_MICROSOFT        0x045e
 165 #define VENDOR_FORMOSA          0x147a
 166 #define VENDOR_FINTEK           0x1934
 167 #define VENDOR_PINNACLE         0x2304
 168 #define VENDOR_ECS              0x1019
 169 #define VENDOR_WISTRON          0x0fb8
 170 #define VENDOR_COMPRO           0x185b
 171 #define VENDOR_NORTHSTAR        0x04eb
 172 #define VENDOR_REALTEK          0x0bda
 173 #define VENDOR_TIVO             0x105a
 174 #define VENDOR_CONEXANT         0x0572
 175 #define VENDOR_TWISTEDMELON     0x2596
 176 #define VENDOR_HAUPPAUGE        0x2040
 177 #define VENDOR_PCTV             0x2013
 178 #define VENDOR_ADAPTEC          0x03f3
 179
 180 enum mceusb_model_type {
 181         MCE_GEN2 = 0,           /* Most boards */
 182         MCE_GEN1,
 183         MCE_GEN3,
 184         MCE_GEN2_TX_INV,
 185         POLARIS_EVK,
 186         CX_HYBRID_TV,
 187         MULTIFUNCTION,
 188         TIVO_KIT,
 189         MCE_GEN2_NO_TX,
 190         HAUPPAUGE_CX_HYBRID_TV,
 191 };
 192
 193 struct mceusb_model {
 194         u32 mce_gen1:1;
 195         u32 mce_gen2:1;
 196         u32 mce_gen3:1;
 197         u32 tx_mask_normal:1;
 198         u32 no_tx:1;
 199
 200         int ir_intfnum;
 201
 202         const char *rc_map;     /* Allow specify a per-board map */
 203         const char *name;       /* per-board name */
 204 };
 205
 206 static const struct mceusb_model mceusb_model[] = {
 207         [MCE_GEN1] = {
 208                 .mce_gen1 = 1,
 209                 .tx_mask_normal = 1,
 210         },
 211         [MCE_GEN2] = {
 212                 .mce_gen2 = 1,
 213         },
 214         [MCE_GEN2_NO_TX] = {
 215                 .mce_gen2 = 1,
 216                 .no_tx = 1,
 217         },
 218         [MCE_GEN2_TX_INV] = {
 219                 .mce_gen2 = 1,
 220                 .tx_mask_normal = 1,
 221         },
 222         [MCE_GEN3] = {
 223                 .mce_gen3 = 1,
 224                 .tx_mask_normal = 1,
 225         },
 226         [POLARIS_EVK] = {
 227                 /*
 228                  * In fact, the EVK is shipped without
 229                  * remotes, but we should have something handy,
 230                  * to allow testing it
 231                  */
 232                 .name = "Conexant Hybrid TV (cx231xx) MCE IR",
 233         },
 234         [CX_HYBRID_TV] = {
 235                 .no_tx = 1, /* tx isn't wired up at all */
 236                 .name = "Conexant Hybrid TV (cx231xx) MCE IR",
 237         },
 238         [HAUPPAUGE_CX_HYBRID_TV] = {
 239                 .no_tx = 1, /* eeprom says it has no tx */
 240                 .name = "Conexant Hybrid TV (cx231xx) MCE IR no TX",
 241         },
 242         [MULTIFUNCTION] = {
 243                 .mce_gen2 = 1,
 244                 .ir_intfnum = 2,
 245         },
 246         [TIVO_KIT] = {
 247                 .mce_gen2 = 1,
 248                 .rc_map = RC_MAP_TIVO,
 249         },
 250 };
 251
 252 static struct usb_device_id mceusb_dev_table[] = {
 253         /* Original Microsoft MCE IR Transceiver (often HP-branded) */
 254         { USB_DEVICE(VENDOR_MICROSOFT, 0x006d),
 255           .driver_info = MCE_GEN1 },
 256         /* Philips Infrared Transceiver - Sahara branded */
 257         { USB_DEVICE(VENDOR_PHILIPS, 0x0608) },
 258         /* Philips Infrared Transceiver - HP branded */
 259         { USB_DEVICE(VENDOR_PHILIPS, 0x060c),
 260           .driver_info = MCE_GEN2_TX_INV },
 261         /* Philips SRM5100 */
 262         { USB_DEVICE(VENDOR_PHILIPS, 0x060d) },
 263         /* Philips Infrared Transceiver - Omaura */
 264         { USB_DEVICE(VENDOR_PHILIPS, 0x060f) },
 265         /* Philips Infrared Transceiver - Spinel plus */
 266         { USB_DEVICE(VENDOR_PHILIPS, 0x0613) },
 267         /* Philips eHome Infrared Transceiver */
 268         { USB_DEVICE(VENDOR_PHILIPS, 0x0815) },
 269         /* Philips/Spinel plus IR transceiver for ASUS */
 270         { USB_DEVICE(VENDOR_PHILIPS, 0x206c) },
 271         /* Philips/Spinel plus IR transceiver for ASUS */
 272         { USB_DEVICE(VENDOR_PHILIPS, 0x2088) },
 273         /* Philips IR transceiver (Dell branded) */
 274         { USB_DEVICE(VENDOR_PHILIPS, 0x2093),
 275           .driver_info = MCE_GEN2_TX_INV },
 276         /* Realtek MCE IR Receiver and card reader */
 277         { USB_DEVICE(VENDOR_REALTEK, 0x0161),
 278           .driver_info = MULTIFUNCTION },
 279         /* SMK/Toshiba G83C0004D410 */
 280         { USB_DEVICE(VENDOR_SMK, 0x031d),
 281           .driver_info = MCE_GEN2_TX_INV },
 282         /* SMK eHome Infrared Transceiver (Sony VAIO) */
 283         { USB_DEVICE(VENDOR_SMK, 0x0322),
 284           .driver_info = MCE_GEN2_TX_INV },
 285         /* bundled with Hauppauge PVR-150 */
 286         { USB_DEVICE(VENDOR_SMK, 0x0334),
 287           .driver_info = MCE_GEN2_TX_INV },
 288         /* SMK eHome Infrared Transceiver */
 289         { USB_DEVICE(VENDOR_SMK, 0x0338) },
 290         /* SMK/I-O Data GV-MC7/RCKIT Receiver */
 291         { USB_DEVICE(VENDOR_SMK, 0x0353),
 292           .driver_info = MCE_GEN2_NO_TX },
 293         /* SMK RXX6000 Infrared Receiver */
 294         { USB_DEVICE(VENDOR_SMK, 0x0357),
 295           .driver_info = MCE_GEN2_NO_TX },
 296         /* Tatung eHome Infrared Transceiver */
 297         { USB_DEVICE(VENDOR_TATUNG, 0x9150) },
 298         /* Shuttle eHome Infrared Transceiver */
 299         { USB_DEVICE(VENDOR_SHUTTLE, 0xc001) },
 300         /* Shuttle eHome Infrared Transceiver */
 301         { USB_DEVICE(VENDOR_SHUTTLE2, 0xc001) },
 302         /* Gateway eHome Infrared Transceiver */
 303         { USB_DEVICE(VENDOR_GATEWAY, 0x3009) },
 304         /* Mitsumi */
 305         { USB_DEVICE(VENDOR_MITSUMI, 0x2501) },
 306         /* Topseed eHome Infrared Transceiver */
 307         { USB_DEVICE(VENDOR_TOPSEED, 0x0001),
 308           .driver_info = MCE_GEN2_TX_INV },
 309         /* Topseed HP eHome Infrared Transceiver */
 310         { USB_DEVICE(VENDOR_TOPSEED, 0x0006),
 311           .driver_info = MCE_GEN2_TX_INV },
 312         /* Topseed eHome Infrared Transceiver */
 313         { USB_DEVICE(VENDOR_TOPSEED, 0x0007),
 314           .driver_info = MCE_GEN2_TX_INV },
 315         /* Topseed eHome Infrared Transceiver */
 316         { USB_DEVICE(VENDOR_TOPSEED, 0x0008),
 317           .driver_info = MCE_GEN3 },
 318         /* Topseed eHome Infrared Transceiver */
 319         { USB_DEVICE(VENDOR_TOPSEED, 0x000a),
 320           .driver_info = MCE_GEN2_TX_INV },
 321         /* Topseed eHome Infrared Transceiver */
 322         { USB_DEVICE(VENDOR_TOPSEED, 0x0011),
 323           .driver_info = MCE_GEN3 },
 324         /* Ricavision internal Infrared Transceiver */
 325         { USB_DEVICE(VENDOR_RICAVISION, 0x0010) },
 326         /* Itron ione Libra Q-11 */
 327         { USB_DEVICE(VENDOR_ITRON, 0x7002) },
 328         /* FIC eHome Infrared Transceiver */
 329         { USB_DEVICE(VENDOR_FIC, 0x9242) },
 330         /* LG eHome Infrared Transceiver */
 331         { USB_DEVICE(VENDOR_LG, 0x9803) },
 332         /* Microsoft MCE Infrared Transceiver */
 333         { USB_DEVICE(VENDOR_MICROSOFT, 0x00a0) },
 334         /* Formosa eHome Infrared Transceiver */
 335         { USB_DEVICE(VENDOR_FORMOSA, 0xe015) },
 336         /* Formosa21 / eHome Infrared Receiver */
 337         { USB_DEVICE(VENDOR_FORMOSA, 0xe016) },
 338         /* Formosa aim / Trust MCE Infrared Receiver */
 339         { USB_DEVICE(VENDOR_FORMOSA, 0xe017),
 340           .driver_info = MCE_GEN2_NO_TX },
 341         /* Formosa Industrial Computing / Beanbag Emulation Device */
 342         { USB_DEVICE(VENDOR_FORMOSA, 0xe018) },
 343         /* Formosa21 / eHome Infrared Receiver */
 344         { USB_DEVICE(VENDOR_FORMOSA, 0xe03a) },
 345         /* Formosa Industrial Computing AIM IR605/A */
 346         { USB_DEVICE(VENDOR_FORMOSA, 0xe03c) },
 347         /* Formosa Industrial Computing */
 348         { USB_DEVICE(VENDOR_FORMOSA, 0xe03e) },
 349         /* Formosa Industrial Computing */
 350         { USB_DEVICE(VENDOR_FORMOSA, 0xe042) },
 351         /* Fintek eHome Infrared Transceiver (HP branded) */
 352         { USB_DEVICE(VENDOR_FINTEK, 0x5168),
 353           .driver_info = MCE_GEN2_TX_INV },
 354         /* Fintek eHome Infrared Transceiver */
 355         { USB_DEVICE(VENDOR_FINTEK, 0x0602) },
 356         /* Fintek eHome Infrared Transceiver (in the AOpen MP45) */
 357         { USB_DEVICE(VENDOR_FINTEK, 0x0702) },
 358         /* Pinnacle Remote Kit */
 359         { USB_DEVICE(VENDOR_PINNACLE, 0x0225),
 360           .driver_info = MCE_GEN3 },
 361         /* Elitegroup Computer Systems IR */
 362         { USB_DEVICE(VENDOR_ECS, 0x0f38) },
 363         /* Wistron Corp. eHome Infrared Receiver */
 364         { USB_DEVICE(VENDOR_WISTRON, 0x0002) },
 365         /* Compro K100 */
 366         { USB_DEVICE(VENDOR_COMPRO, 0x3020) },
 367         /* Compro K100 v2 */
 368         { USB_DEVICE(VENDOR_COMPRO, 0x3082) },
 369         /* Northstar Systems, Inc. eHome Infrared Transceiver */
 370         { USB_DEVICE(VENDOR_NORTHSTAR, 0xe004) },
 371         /* TiVo PC IR Receiver */
 372         { USB_DEVICE(VENDOR_TIVO, 0x2000),
 373           .driver_info = TIVO_KIT },
 374         /* Conexant Hybrid TV "Shelby" Polaris SDK */
 375         { USB_DEVICE(VENDOR_CONEXANT, 0x58a1),
 376           .driver_info = POLARIS_EVK },
 377         /* Conexant Hybrid TV RDU253S Polaris */
 378         { USB_DEVICE(VENDOR_CONEXANT, 0x58a5),
 379           .driver_info = CX_HYBRID_TV },
 380         /* Twisted Melon Inc. - Manta Mini Receiver */
 381         { USB_DEVICE(VENDOR_TWISTEDMELON, 0x8008) },
 382         /* Twisted Melon Inc. - Manta Pico Receiver */
 383         { USB_DEVICE(VENDOR_TWISTEDMELON, 0x8016) },
 384         /* Twisted Melon Inc. - Manta Transceiver */
 385         { USB_DEVICE(VENDOR_TWISTEDMELON, 0x8042) },
 386         /* Hauppauge WINTV-HVR-HVR 930C-HD - based on cx231xx */
 387         { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb130),
 388           .driver_info = HAUPPAUGE_CX_HYBRID_TV },
 389         { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb131),
 390           .driver_info = HAUPPAUGE_CX_HYBRID_TV },
 391         { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb138),
 392           .driver_info = HAUPPAUGE_CX_HYBRID_TV },
 393         { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb139),
 394           .driver_info = HAUPPAUGE_CX_HYBRID_TV },
 395         { USB_DEVICE(VENDOR_PCTV, 0x0259),
 396           .driver_info = HAUPPAUGE_CX_HYBRID_TV },
 397         { USB_DEVICE(VENDOR_PCTV, 0x025e),
 398           .driver_info = HAUPPAUGE_CX_HYBRID_TV },
 399         /* Adaptec / HP eHome Receiver */
 400         { USB_DEVICE(VENDOR_ADAPTEC, 0x0094) },
 401
 402         /* Terminating entry */
 403         { }
 404 };
 405
 406 /* data structure for each usb transceiver */
 407 struct mceusb_dev {
 408         /* ir-core bits */
 409         struct rc_dev *rc;
 410
 411         /* optional features we can enable */
 412         bool learning_enabled;
 413
 414         /* core device bits */
 415         struct device *dev;
 416
 417         /* usb */
 418         struct usb_device *usbdev;
 419         struct urb *urb_in;
 420         unsigned int pipe_in;
 421         struct usb_endpoint_descriptor *usb_ep_out;
 422         unsigned int pipe_out;
 423
 424         /* buffers and dma */
 425         unsigned char *buf_in;
 426         unsigned int len_in;
 427         dma_addr_t dma_in;
 428
 429         enum {
 430                 CMD_HEADER = 0,
 431                 SUBCMD,
 432                 CMD_DATA,
 433                 PARSE_IRDATA,
 434         } parser_state;
 435
 436         u8 cmd, rem;            /* Remaining IR data bytes in packet */
 437
 438         struct {
 439                 u32 connected:1;
 440                 u32 tx_mask_normal:1;
 441                 u32 microsoft_gen1:1;
 442                 u32 no_tx:1;
 443         } flags;
 444
 445         /* transmit support */
 446         u32 carrier;
 447         unsigned char tx_mask;
 448
 449         char name[128];
 450         char phys[64];
 451         enum mceusb_model_type model;
 452
 453         bool need_reset;        /* flag to issue a device resume cmd */
 454         u8 emver;               /* emulator interface version */
 455         u8 num_txports;         /* number of transmit ports */
 456         u8 num_rxports;         /* number of receive sensors */
 457         u8 txports_cabled;      /* bitmask of transmitters with cable */
 458         u8 rxports_active;      /* bitmask of active receive sensors */
 459
 460         /*
 461          * support for async error handler mceusb_deferred_kevent()
 462          * where usb_clear_halt(), usb_reset_configuration(),
 463          * usb_reset_device(), etc. must be done in process context
 464          */
 465         struct work_struct kevent;
 466         unsigned long kevent_flags;
 467 #               define EVENT_TX_HALT    0
 468 #               define EVENT_RX_HALT    1
 469 };
 470
 471 /* MCE Device Command Strings, generally a port and command pair */
 472 static char DEVICE_RESUME[]     = {MCE_CMD_NULL, MCE_CMD_PORT_SYS,
 473                                    MCE_CMD_RESUME};
 474 static char GET_REVISION[]      = {MCE_CMD_PORT_SYS, MCE_CMD_G_REVISION};
 475 static char GET_EMVER[]         = {MCE_CMD_PORT_SYS, MCE_CMD_GETEMVER};
 476 static char GET_WAKEVERSION[]   = {MCE_CMD_PORT_SYS, MCE_CMD_GETWAKEVERSION};
 477 static char FLASH_LED[]         = {MCE_CMD_PORT_SYS, MCE_CMD_FLASHLED};
 478 static char GET_UNKNOWN2[]      = {MCE_CMD_PORT_IR, MCE_CMD_UNKNOWN2};
 479 static char GET_CARRIER_FREQ[]  = {MCE_CMD_PORT_IR, MCE_CMD_GETIRCFS};
 480 static char GET_RX_TIMEOUT[]    = {MCE_CMD_PORT_IR, MCE_CMD_GETIRTIMEOUT};
 481 static char GET_NUM_PORTS[]     = {MCE_CMD_PORT_IR, MCE_CMD_GETIRNUMPORTS};
 482 static char GET_TX_BITMASK[]    = {MCE_CMD_PORT_IR, MCE_CMD_GETIRTXPORTS};
 483 static char GET_RX_SENSOR[]     = {MCE_CMD_PORT_IR, MCE_CMD_GETIRRXPORTEN};
 484 /* sub in desired values in lower byte or bytes for full command */
 485 /* FIXME: make use of these for transmit.
 486 static char SET_CARRIER_FREQ[]  = {MCE_CMD_PORT_IR,
 487                                    MCE_CMD_SETIRCFS, 0x00, 0x00};
 488 static char SET_TX_BITMASK[]    = {MCE_CMD_PORT_IR, MCE_CMD_SETIRTXPORTS, 0x00};
 489 static char SET_RX_TIMEOUT[]    = {MCE_CMD_PORT_IR,
 490                                    MCE_CMD_SETIRTIMEOUT, 0x00, 0x00};
 491 static char SET_RX_SENSOR[]     = {MCE_CMD_PORT_IR,
 492                                    MCE_RSP_EQIRRXPORTEN, 0x00};
 493 */
 494
 495 static int mceusb_cmd_datasize(u8 cmd, u8 subcmd)
 496 {
 497         int datasize = 0;
 498
 499         switch (cmd) {
 500         case MCE_CMD_NULL:
 501                 if (subcmd == MCE_CMD_PORT_SYS)
 502                         datasize = 1;
 503                 break;
 504         case MCE_CMD_PORT_SYS:
 505                 switch (subcmd) {
 506                 case MCE_RSP_GETPORTSTATUS:
 507                         datasize = 5;
 508                         break;
 509                 case MCE_RSP_EQWAKEVERSION:
 510                         datasize = 4;
 511                         break;
 512                 case MCE_CMD_G_REVISION:
 513                         datasize = 2;
 514                         break;
 515                 case MCE_RSP_EQWAKESUPPORT:
 516                 case MCE_RSP_GETWAKESOURCE:
 517                 case MCE_RSP_EQDEVDETAILS:
 518                 case MCE_RSP_EQEMVER:
 519                         datasize = 1;
 520                         break;
 521                 }
 522         case MCE_CMD_PORT_IR:
 523                 switch (subcmd) {
 524                 case MCE_CMD_UNKNOWN:
 525                 case MCE_RSP_EQIRCFS:
 526                 case MCE_RSP_EQIRTIMEOUT:
 527                 case MCE_RSP_EQIRRXCFCNT:
 528                 case MCE_RSP_EQIRNUMPORTS:
 529                         datasize = 2;
 530                         break;
 531                 case MCE_CMD_SIG_END:
 532                 case MCE_RSP_EQIRTXPORTS:
 533                 case MCE_RSP_EQIRRXPORTEN:
 534                         datasize = 1;
 535                         break;
 536                 }
 537         }
 538         return datasize;
 539 }
 540
 541 static void mceusb_dev_printdata(struct mceusb_dev *ir, u8 *buf, int buf_len,
 542                                  int offset, int len, bool out)
 543 {
 544 #if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
 545         char *inout;
 546         u8 cmd, subcmd, *data;
 547         struct device *dev = ir->dev;
 548         int start, skip = 0;
 549         u32 carrier, period;
 550
 551         /* skip meaningless 0xb1 0x60 header bytes on orig receiver */
 552         if (ir->flags.microsoft_gen1 && !out && !offset)
 553                 skip = 2;
 554
 555         if (len <= skip)
 556                 return;
 557
 558         dev_dbg(dev, "%cx data: %*ph (length=%d)",
 559                 (out ? 't' : 'r'),
 560                 min(len, buf_len - offset), buf + offset, len);
 561
 562         inout = out ? "Request" : "Got";
 563
 564         start  = offset + skip;
 565         cmd    = buf[start] & 0xff;
 566         subcmd = buf[start + 1] & 0xff;
 567         data = buf + start + 2;
 568
 569         switch (cmd) {
 570         case MCE_CMD_NULL:
 571                 if (subcmd == MCE_CMD_NULL)
 572                         break;
 573                 if ((subcmd == MCE_CMD_PORT_SYS) &&
 574                     (data[0] == MCE_CMD_RESUME))
 575                         dev_dbg(dev, "Device resume requested");
 576                 else
 577                         dev_dbg(dev, "Unknown command 0x%02x 0x%02x",
 578                                  cmd, subcmd);
 579                 break;
 580         case MCE_CMD_PORT_SYS:
 581                 switch (subcmd) {
 582                 case MCE_RSP_EQEMVER:
 583                         if (!out)
 584                                 dev_dbg(dev, "Emulator interface version %x",
 585                                          data[0]);
 586                         break;
 587                 case MCE_CMD_G_REVISION:
 588                         if (len == 2)
 589                                 dev_dbg(dev, "Get hw/sw rev?");
 590                         else
 591                                 dev_dbg(dev, "hw/sw rev %*ph",
 592                                         4, &buf[start + 2]);
 593                         break;
 594                 case MCE_CMD_RESUME:
 595                         dev_dbg(dev, "Device resume requested");
 596                         break;
 597                 case MCE_RSP_CMD_ILLEGAL:
 598                         dev_dbg(dev, "Illegal PORT_SYS command");
 599                         break;
 600                 case MCE_RSP_EQWAKEVERSION:
 601                         if (!out)
 602                                 dev_dbg(dev, "Wake version, proto: 0x%02x, payload: 0x%02x, address: 0x%02x, version: 0x%02x",
 603                                         data[0], data[1], data[2], data[3]);
 604                         break;
 605                 case MCE_RSP_GETPORTSTATUS:
 606                         if (!out)
 607                                 /* We use data1 + 1 here, to match hw labels */
 608                                 dev_dbg(dev, "TX port %d: blaster is%s connected",
 609                                          data[0] + 1, data[3] ? " not" : "");
 610                         break;
 611                 case MCE_CMD_FLASHLED:
 612                         dev_dbg(dev, "Attempting to flash LED");
 613                         break;
 614                 default:
 615                         dev_dbg(dev, "Unknown command 0x%02x 0x%02x",
 616                                  cmd, subcmd);
 617                         break;
 618                 }
 619                 break;
 620         case MCE_CMD_PORT_IR:
 621                 switch (subcmd) {
 622                 case MCE_CMD_SIG_END:
 623                         dev_dbg(dev, "End of signal");
 624                         break;
 625                 case MCE_CMD_PING:
 626                         dev_dbg(dev, "Ping");
 627                         break;
 628                 case MCE_CMD_UNKNOWN:
 629                         dev_dbg(dev, "Resp to 9f 05 of 0x%02x 0x%02x",
 630                                 data[0], data[1]);
 631                         break;
 632                 case MCE_RSP_EQIRCFS:
 633                         if (!data[0] && !data[1]) {
 634                                 dev_dbg(dev, "%s: no carrier", inout);
 635                                 break;
 636                         }
 637                         // prescaler should make sense
 638                         if (data[0] > 8)
 639                                 break;
 640                         period = DIV_ROUND_CLOSEST((1U << data[0] * 2) *
 641                                                    (data[1] + 1), 10);
 642                         if (!period)
 643                                 break;
 644                         carrier = USEC_PER_SEC / period;
 645                         dev_dbg(dev, "%s carrier of %u Hz (period %uus)",
 646                                  inout, carrier, period);
 647                         break;
 648                 case MCE_CMD_GETIRCFS:
 649                         dev_dbg(dev, "Get carrier mode and freq");
 650                         break;
 651                 case MCE_RSP_EQIRTXPORTS:
 652                         dev_dbg(dev, "%s transmit blaster mask of 0x%02x",
 653                                  inout, data[0]);
 654                         break;
 655                 case MCE_RSP_EQIRTIMEOUT:
 656                         /* value is in units of 50us, so x*50/1000 ms */
 657                         period = ((data[0] << 8) | data[1]) *
 658                                   MCE_TIME_UNIT / 1000;
 659                         dev_dbg(dev, "%s receive timeout of %d ms",
 660                                  inout, period);
 661                         break;
 662                 case MCE_CMD_GETIRTIMEOUT:
 663                         dev_dbg(dev, "Get receive timeout");
 664                         break;
 665                 case MCE_CMD_GETIRTXPORTS:
 666                         dev_dbg(dev, "Get transmit blaster mask");
 667                         break;
 668                 case MCE_RSP_EQIRRXPORTEN:
 669                         dev_dbg(dev, "%s %s-range receive sensor in use",
 670                                  inout, data[0] == 0x02 ? "short" : "long");
 671                         break;
 672                 case MCE_CMD_GETIRRXPORTEN:
 673                 /* aka MCE_RSP_EQIRRXCFCNT */
 674                         if (out)
 675                                 dev_dbg(dev, "Get receive sensor");
 676                         else if (ir->learning_enabled)
 677                                 dev_dbg(dev, "RX pulse count: %d",
 678                                         ((data[0] << 8) | data[1]));
 679                         break;
 680                 case MCE_RSP_EQIRNUMPORTS:
 681                         if (out)
 682                                 break;
 683                         dev_dbg(dev, "Num TX ports: %x, num RX ports: %x",
 684                                 data[0], data[1]);
 685                         break;
 686                 case MCE_RSP_CMD_ILLEGAL:
 687                         dev_dbg(dev, "Illegal PORT_IR command");
 688                         break;
 689                 default:
 690                         dev_dbg(dev, "Unknown command 0x%02x 0x%02x",
 691                                  cmd, subcmd);
 692                         break;
 693                 }
 694                 break;
 695         default:
 696                 break;
 697         }
 698
 699         if (cmd == MCE_IRDATA_TRAILER)
 700                 dev_dbg(dev, "End of raw IR data");
 701         else if ((cmd != MCE_CMD_PORT_IR) &&
 702                  ((cmd & MCE_PORT_MASK) == MCE_COMMAND_IRDATA))
 703                 dev_dbg(dev, "Raw IR data, %d pulse/space samples", ir->rem);
 704 #endif
 705 }
 706
 707 /*
 708  * Schedule work that can't be done in interrupt handlers
 709  * (mceusb_dev_recv() and mce_async_callback()) nor tasklets.
 710  * Invokes mceusb_deferred_kevent() for recovering from
 711  * error events specified by the kevent bit field.
 712  */
 713 static void mceusb_defer_kevent(struct mceusb_dev *ir, int kevent)
 714 {
 715         set_bit(kevent, &ir->kevent_flags);
 716         if (!schedule_work(&ir->kevent))
 717                 dev_err(ir->dev, "kevent %d may have been dropped", kevent);
 718         else
 719                 dev_dbg(ir->dev, "kevent %d scheduled", kevent);
 720 }
 721
 722 static void mce_async_callback(struct urb *urb)
 723 {
 724         struct mceusb_dev *ir;
 725         int len;
 726
 727         if (!urb)
 728                 return;
 729
 730         ir = urb->context;
 731
 732         switch (urb->status) {
 733         /* success */
 734         case 0:
 735                 len = urb->actual_length;
 736
 737                 mceusb_dev_printdata(ir, urb->transfer_buffer, len,
 738                                      0, len, true);
 739                 break;
 740
 741         case -ECONNRESET:
 742         case -ENOENT:
 743         case -EILSEQ:
 744         case -ESHUTDOWN:
 745                 break;
 746
 747         case -EPIPE:
 748                 dev_err(ir->dev, "Error: request urb status = %d (TX HALT)",
 749                         urb->status);
 750                 mceusb_defer_kevent(ir, EVENT_TX_HALT);
 751                 break;
 752
 753         default:
 754                 dev_err(ir->dev, "Error: request urb status = %d", urb->status);
 755                 break;
 756         }
 757
 758         /* the transfer buffer and urb were allocated in mce_request_packet */
 759         kfree(urb->transfer_buffer);
 760         usb_free_urb(urb);
 761 }
 762
 763 /* request outgoing (send) usb packet - used to initialize remote */
 764 static void mce_request_packet(struct mceusb_dev *ir, unsigned char *data,
 765                                                                 int size)
 766 {
 767         int res;
 768         struct urb *async_urb;
 769         struct device *dev = ir->dev;
 770         unsigned char *async_buf;
 771
 772         async_urb = usb_alloc_urb(0, GFP_KERNEL);
 773         if (unlikely(!async_urb)) {
 774                 dev_err(dev, "Error, couldn't allocate urb!");
 775                 return;
 776         }
 777
 778         async_buf = kmalloc(size, GFP_KERNEL);
 779         if (!async_buf) {
 780                 usb_free_urb(async_urb);
 781                 return;
 782         }
 783
 784         /* outbound data */
 785         if (usb_endpoint_xfer_int(ir->usb_ep_out))
 786                 usb_fill_int_urb(async_urb, ir->usbdev, ir->pipe_out,
 787                                  async_buf, size, mce_async_callback, ir,
 788                                  ir->usb_ep_out->bInterval);
 789         else
 790                 usb_fill_bulk_urb(async_urb, ir->usbdev, ir->pipe_out,
 791                                   async_buf, size, mce_async_callback, ir);
 792
 793         memcpy(async_buf, data, size);
 794
 795         dev_dbg(dev, "send request called (size=%#x)", size);
 796
 797         res = usb_submit_urb(async_urb, GFP_ATOMIC);
 798         if (res) {
 799                 dev_err(dev, "send request FAILED! (res=%d)", res);
 800                 kfree(async_buf);
 801                 usb_free_urb(async_urb);
 802                 return;
 803         }
 804         dev_dbg(dev, "send request complete (res=%d)", res);
 805 }
 806
 807 static void mce_async_out(struct mceusb_dev *ir, unsigned char *data, int size)
 808 {
 809         int rsize = sizeof(DEVICE_RESUME);
 810
 811         if (ir->need_reset) {
 812                 ir->need_reset = false;
 813                 mce_request_packet(ir, DEVICE_RESUME, rsize);
 814                 msleep(10);
 815         }
 816
 817         mce_request_packet(ir, data, size);
 818         msleep(10);
 819 }
 820
 821 /* Send data out the IR blaster port(s) */
 822 static int mceusb_tx_ir(struct rc_dev *dev, unsigned *txbuf, unsigned count)
 823 {
 824         struct mceusb_dev *ir = dev->priv;
 825         int i, length, ret = 0;
 826         int cmdcount = 0;
 827         unsigned char cmdbuf[MCE_CMDBUF_SIZE];
 828
 829         /* MCE tx init header */
 830         cmdbuf[cmdcount++] = MCE_CMD_PORT_IR;
 831         cmdbuf[cmdcount++] = MCE_CMD_SETIRTXPORTS;
 832         cmdbuf[cmdcount++] = ir->tx_mask;
 833
 834         /* Send the set TX ports command */
 835         mce_async_out(ir, cmdbuf, cmdcount);
 836         cmdcount = 0;
 837
 838         /* Generate mce packet data */
 839         for (i = 0; (i < count) && (cmdcount < MCE_CMDBUF_SIZE); i++) {
 840                 txbuf[i] = txbuf[i] / MCE_TIME_UNIT;
 841
 842                 do { /* loop to support long pulses/spaces > 127*50us=6.35ms */
 843
 844                         /* Insert mce packet header every 4th entry */
 845                         if ((cmdcount < MCE_CMDBUF_SIZE) &&
 846                             (cmdcount % MCE_CODE_LENGTH) == 0)
 847                                 cmdbuf[cmdcount++] = MCE_IRDATA_HEADER;
 848
 849                         /* Insert mce packet data */
 850                         if (cmdcount < MCE_CMDBUF_SIZE)
 851                                 cmdbuf[cmdcount++] =
 852                                         (txbuf[i] < MCE_PULSE_BIT ?
 853                                          txbuf[i] : MCE_MAX_PULSE_LENGTH) |
 854                                          (i & 1 ? 0x00 : MCE_PULSE_BIT);
 855                         else {
 856                                 ret = -EINVAL;
 857                                 goto out;
 858                         }
 859
 860                 } while ((txbuf[i] > MCE_MAX_PULSE_LENGTH) &&
 861                          (txbuf[i] -= MCE_MAX_PULSE_LENGTH));
 862         }
 863
 864         /* Check if we have room for the empty packet at the end */
 865         if (cmdcount >= MCE_CMDBUF_SIZE) {
 866                 ret = -EINVAL;
 867                 goto out;
 868         }
 869
 870         /* Fix packet length in last header */
 871         length = cmdcount % MCE_CODE_LENGTH;
 872         cmdbuf[cmdcount - length] -= MCE_CODE_LENGTH - length;
 873
 874         /* All mce commands end with an empty packet (0x80) */
 875         cmdbuf[cmdcount++] = MCE_IRDATA_TRAILER;
 876
 877         /* Transmit the command to the mce device */
 878         mce_async_out(ir, cmdbuf, cmdcount);
 879
 880 out:
 881         return ret ? ret : count;
 882 }
 883
 884 /* Sets active IR outputs -- mce devices typically have two */
 885 static int mceusb_set_tx_mask(struct rc_dev *dev, u32 mask)
 886 {
 887         struct mceusb_dev *ir = dev->priv;
 888
 889         /* return number of transmitters */
 890         int emitters = ir->num_txports ? ir->num_txports : 2;
 891
 892         if (mask >= (1 << emitters))
 893                 return emitters;
 894
 895         if (ir->flags.tx_mask_normal)
 896                 ir->tx_mask = mask;
 897         else
 898                 ir->tx_mask = (mask != MCE_DEFAULT_TX_MASK ?
 899                                 mask ^ MCE_DEFAULT_TX_MASK : mask) << 1;
 900
 901         return 0;
 902 }
 903
 904 /* Sets the send carrier frequency and mode */
 905 static int mceusb_set_tx_carrier(struct rc_dev *dev, u32 carrier)
 906 {
 907         struct mceusb_dev *ir = dev->priv;
 908         int clk = 10000000;
 909         int prescaler = 0, divisor = 0;
 910         unsigned char cmdbuf[4] = { MCE_CMD_PORT_IR,
 911                                     MCE_CMD_SETIRCFS, 0x00, 0x00 };
 912
 913         /* Carrier has changed */
 914         if (ir->carrier != carrier) {
 915
 916                 if (carrier == 0) {
 917                         ir->carrier = carrier;
 918                         cmdbuf[2] = MCE_CMD_SIG_END;
 919                         cmdbuf[3] = MCE_IRDATA_TRAILER;
 920                         dev_dbg(ir->dev, "disabling carrier modulation");
 921                         mce_async_out(ir, cmdbuf, sizeof(cmdbuf));
 922                         return 0;
 923                 }
 924
 925                 for (prescaler = 0; prescaler < 4; ++prescaler) {
 926                         divisor = (clk >> (2 * prescaler)) / carrier;
 927                         if (divisor <= 0xff) {
 928                                 ir->carrier = carrier;
 929                                 cmdbuf[2] = prescaler;
 930                                 cmdbuf[3] = divisor;
 931                                 dev_dbg(ir->dev, "requesting %u HZ carrier",
 932                                                                 carrier);
 933
 934                                 /* Transmit new carrier to mce device */
 935                                 mce_async_out(ir, cmdbuf, sizeof(cmdbuf));
 936                                 return 0;
 937                         }
 938                 }
 939
 940                 return -EINVAL;
 941
 942         }
 943
 944         return 0;
 945 }
 946
 947 /*
 948  * We don't do anything but print debug spew for many of the command bits
 949  * we receive from the hardware, but some of them are useful information
 950  * we want to store so that we can use them.
 951  */
 952 static void mceusb_handle_command(struct mceusb_dev *ir, int index)
 953 {
 954         u8 hi = ir->buf_in[index + 1] & 0xff;
 955         u8 lo = ir->buf_in[index + 2] & 0xff;
 956
 957         switch (ir->buf_in[index]) {
 958         /* the one and only 5-byte return value command */
 959         case MCE_RSP_GETPORTSTATUS:
 960                 if ((ir->buf_in[index + 4] & 0xff) == 0x00)
 961                         ir->txports_cabled |= 1 << hi;
 962                 break;
 963
 964         /* 2-byte return value commands */
 965         case MCE_RSP_EQIRTIMEOUT:
 966                 ir->rc->timeout = US_TO_NS((hi << 8 | lo) * MCE_TIME_UNIT);
 967                 break;
 968         case MCE_RSP_EQIRNUMPORTS:
 969                 ir->num_txports = hi;
 970                 ir->num_rxports = lo;
 971                 break;
 972
 973         /* 1-byte return value commands */
 974         case MCE_RSP_EQEMVER:
 975                 ir->emver = hi;
 976                 break;
 977         case MCE_RSP_EQIRTXPORTS:
 978                 ir->tx_mask = hi;
 979                 break;
 980         case MCE_RSP_EQIRRXPORTEN:
 981                 ir->learning_enabled = ((hi & 0x02) == 0x02);
 982                 ir->rxports_active = hi;
 983                 break;
 984         case MCE_RSP_CMD_ILLEGAL:
 985                 ir->need_reset = true;
 986                 break;
 987         default:
 988                 break;
 989         }
 990 }
 991
 992 static void mceusb_process_ir_data(struct mceusb_dev *ir, int buf_len)
 993 {
 994         DEFINE_IR_RAW_EVENT(rawir);
 995         bool event = false;
 996         int i = 0;
 997
 998         /* skip meaningless 0xb1 0x60 header bytes on orig receiver */
 999         if (ir->flags.microsoft_gen1)
1000                 i = 2;
1001
1002         /* if there's no data, just return now */
1003         if (buf_len <= i)
1004                 return;
1005
1006         for (; i < buf_len; i++) {
1007                 switch (ir->parser_state) {
1008                 case SUBCMD:
1009                         ir->rem = mceusb_cmd_datasize(ir->cmd, ir->buf_in[i]);
1010                         mceusb_dev_printdata(ir, ir->buf_in, buf_len, i - 1,
1011                                              ir->rem + 2, false);
1012                         mceusb_handle_command(ir, i);
1013                         ir->parser_state = CMD_DATA;
1014                         break;
1015                 case PARSE_IRDATA:
1016                         ir->rem--;
1017                         init_ir_raw_event(&rawir);
1018                         rawir.pulse = ((ir->buf_in[i] & MCE_PULSE_BIT) != 0);
1019                         rawir.duration = (ir->buf_in[i] & MCE_PULSE_MASK)
1020                                          * US_TO_NS(MCE_TIME_UNIT);
1021
1022                         dev_dbg(ir->dev, "Storing %s with duration %u",
1023                                 rawir.pulse ? "pulse" : "space",
1024                                 rawir.duration);
1025
1026                         if (ir_raw_event_store_with_filter(ir->rc, &rawir))
1027                                 event = true;
1028                         break;
1029                 case CMD_DATA:
1030                         ir->rem--;
1031                         break;
1032                 case CMD_HEADER:
1033                         /* decode mce packets of the form (84),AA,BB,CC,DD */
1034                         /* IR data packets can span USB messages - rem */
1035                         ir->cmd = ir->buf_in[i];
1036                         if ((ir->cmd == MCE_CMD_PORT_IR) ||
1037                             ((ir->cmd & MCE_PORT_MASK) !=
1038                              MCE_COMMAND_IRDATA)) {
1039                                 ir->parser_state = SUBCMD;
1040                                 continue;
1041                         }
1042                         ir->rem = (ir->cmd & MCE_PACKET_LENGTH_MASK);
1043                         mceusb_dev_printdata(ir, ir->buf_in, buf_len,
1044                                              i, ir->rem + 1, false);
1045                         if (ir->rem)
1046                                 ir->parser_state = PARSE_IRDATA;
1047                         else
1048                                 ir_raw_event_reset(ir->rc);
1049                         break;
1050                 }
1051
1052                 if (ir->parser_state != CMD_HEADER && !ir->rem)
1053                         ir->parser_state = CMD_HEADER;
1054         }
1055         if (event) {
1056                 dev_dbg(ir->dev, "processed IR data");
1057                 ir_raw_event_handle(ir->rc);
1058         }
1059 }
1060
1061 static void mceusb_dev_recv(struct urb *urb)
1062 {
1063         struct mceusb_dev *ir;
1064
1065         if (!urb)
1066                 return;
1067
1068         ir = urb->context;
1069         if (!ir) {
1070                 usb_unlink_urb(urb);
1071                 return;
1072         }
1073
1074         switch (urb->status) {
1075         /* success */
1076         case 0:
1077                 mceusb_process_ir_data(ir, urb->actual_length);
1078                 break;
1079
1080         case -ECONNRESET:
1081         case -ENOENT:
1082         case -EILSEQ:
1083         case -EPROTO:
1084         case -ESHUTDOWN:
1085                 usb_unlink_urb(urb);
1086                 return;
1087
1088         case -EPIPE:
1089                 dev_err(ir->dev, "Error: urb status = %d (RX HALT)",
1090                         urb->status);
1091                 mceusb_defer_kevent(ir, EVENT_RX_HALT);
1092                 return;
1093
1094         default:
1095                 dev_err(ir->dev, "Error: urb status = %d", urb->status);
1096                 break;
1097         }
1098
1099         usb_submit_urb(urb, GFP_ATOMIC);
1100 }
1101
1102 static void mceusb_get_emulator_version(struct mceusb_dev *ir)
1103 {
1104         /* If we get no reply or an illegal command reply, its ver 1, says MS */
1105         ir->emver = 1;
1106         mce_async_out(ir, GET_EMVER, sizeof(GET_EMVER));
1107 }
1108
1109 static void mceusb_gen1_init(struct mceusb_dev *ir)
1110 {
1111         int ret;
1112         struct device *dev = ir->dev;
1113         char *data;
1114
1115         data = kzalloc(USB_CTRL_MSG_SZ, GFP_KERNEL);
1116         if (!data) {
1117                 dev_err(dev, "%s: memory allocation failed!", __func__);
1118                 return;
1119         }
1120
1121         /*
1122          * This is a strange one. Windows issues a set address to the device
1123          * on the receive control pipe and expect a certain value pair back
1124          */
1125         ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
1126                               USB_REQ_SET_ADDRESS, USB_TYPE_VENDOR, 0, 0,
1127                               data, USB_CTRL_MSG_SZ, 3000);
1128         dev_dbg(dev, "set address - ret = %d", ret);
1129         dev_dbg(dev, "set address - data[0] = %d, data[1] = %d",
1130                                                 data[0], data[1]);
1131
1132         /* set feature: bit rate 38400 bps */
1133         ret = usb_control_msg(ir->usbdev, usb_sndctrlpipe(ir->usbdev, 0),
1134                               USB_REQ_SET_FEATURE, USB_TYPE_VENDOR,
1135                               0xc04e, 0x0000, NULL, 0, 3000);
1136
1137         dev_dbg(dev, "set feature - ret = %d", ret);
1138
1139         /* bRequest 4: set char length to 8 bits */
1140         ret = usb_control_msg(ir->usbdev, usb_sndctrlpipe(ir->usbdev, 0),
1141                               4, USB_TYPE_VENDOR,
1142                               0x0808, 0x0000, NULL, 0, 3000);
1143         dev_dbg(dev, "set char length - retB = %d", ret);
1144
1145         /* bRequest 2: set handshaking to use DTR/DSR */
1146         ret = usb_control_msg(ir->usbdev, usb_sndctrlpipe(ir->usbdev, 0),
1147                               2, USB_TYPE_VENDOR,
1148                               0x0000, 0x0100, NULL, 0, 3000);
1149         dev_dbg(dev, "set handshake  - retC = %d", ret);
1150
1151         /* device resume */
1152         mce_async_out(ir, DEVICE_RESUME, sizeof(DEVICE_RESUME));
1153
1154         /* get hw/sw revision? */
1155         mce_async_out(ir, GET_REVISION, sizeof(GET_REVISION));
1156
1157         kfree(data);
1158 }
1159
1160 static void mceusb_gen2_init(struct mceusb_dev *ir)
1161 {
1162         /* device resume */
1163         mce_async_out(ir, DEVICE_RESUME, sizeof(DEVICE_RESUME));
1164
1165         /* get wake version (protocol, key, address) */
1166         mce_async_out(ir, GET_WAKEVERSION, sizeof(GET_WAKEVERSION));
1167
1168         /* unknown what this one actually returns... */
1169         mce_async_out(ir, GET_UNKNOWN2, sizeof(GET_UNKNOWN2));
1170 }
1171
1172 static void mceusb_get_parameters(struct mceusb_dev *ir)
1173 {
1174         int i;
1175         unsigned char cmdbuf[3] = { MCE_CMD_PORT_SYS,
1176                                     MCE_CMD_GETPORTSTATUS, 0x00 };
1177
1178         /* defaults, if the hardware doesn't support querying */
1179         ir->num_txports = 2;
1180         ir->num_rxports = 2;
1181
1182         /* get number of tx and rx ports */
1183         mce_async_out(ir, GET_NUM_PORTS, sizeof(GET_NUM_PORTS));
1184
1185         /* get the carrier and frequency */
1186         mce_async_out(ir, GET_CARRIER_FREQ, sizeof(GET_CARRIER_FREQ));
1187
1188         if (ir->num_txports && !ir->flags.no_tx)
1189                 /* get the transmitter bitmask */
1190                 mce_async_out(ir, GET_TX_BITMASK, sizeof(GET_TX_BITMASK));
1191
1192         /* get receiver timeout value */
1193         mce_async_out(ir, GET_RX_TIMEOUT, sizeof(GET_RX_TIMEOUT));
1194
1195         /* get receiver sensor setting */
1196         mce_async_out(ir, GET_RX_SENSOR, sizeof(GET_RX_SENSOR));
1197
1198         for (i = 0; i < ir->num_txports; i++) {
1199                 cmdbuf[2] = i;
1200                 mce_async_out(ir, cmdbuf, sizeof(cmdbuf));
1201         }
1202 }
1203
1204 static void mceusb_flash_led(struct mceusb_dev *ir)
1205 {
1206         if (ir->emver < 2)
1207                 return;
1208
1209         mce_async_out(ir, FLASH_LED, sizeof(FLASH_LED));
1210 }
1211
1212 /*
1213  * Workqueue function
1214  * for resetting or recovering device after occurrence of error events
1215  * specified in ir->kevent bit field.
1216  * Function runs (via schedule_work()) in non-interrupt context, for
1217  * calls here (such as usb_clear_halt()) requiring non-interrupt context.
1218  */
1219 static void mceusb_deferred_kevent(struct work_struct *work)
1220 {
1221         struct mceusb_dev *ir =
1222                 container_of(work, struct mceusb_dev, kevent);
1223         int status;
1224
1225         if (test_bit(EVENT_RX_HALT, &ir->kevent_flags)) {
1226                 usb_unlink_urb(ir->urb_in);
1227                 status = usb_clear_halt(ir->usbdev, ir->pipe_in);
1228                 if (status < 0) {
1229                         dev_err(ir->dev, "rx clear halt error %d",
1230                                 status);
1231                 }
1232                 clear_bit(EVENT_RX_HALT, &ir->kevent_flags);
1233                 if (status == 0) {
1234                         status = usb_submit_urb(ir->urb_in, GFP_KERNEL);
1235                         if (status < 0) {
1236                                 dev_err(ir->dev,
1237                                         "rx unhalt submit urb error %d",
1238                                         status);
1239                         }
1240                 }
1241         }
1242
1243         if (test_bit(EVENT_TX_HALT, &ir->kevent_flags)) {
1244                 status = usb_clear_halt(ir->usbdev, ir->pipe_out);
1245                 if (status < 0)
1246                         dev_err(ir->dev, "tx clear halt error %d", status);
1247                 clear_bit(EVENT_TX_HALT, &ir->kevent_flags);
1248         }
1249 }
1250
1251 static struct rc_dev *mceusb_init_rc_dev(struct mceusb_dev *ir)
1252 {
1253         struct usb_device *udev = ir->usbdev;
1254         struct device *dev = ir->dev;
1255         struct rc_dev *rc;
1256         int ret;
1257
1258         rc = rc_allocate_device(RC_DRIVER_IR_RAW);
1259         if (!rc) {
1260                 dev_err(dev, "remote dev allocation failed");
1261                 goto out;
1262         }
1263
1264         snprintf(ir->name, sizeof(ir->name), "%s (%04x:%04x)",
1265                  mceusb_model[ir->model].name ?
1266                         mceusb_model[ir->model].name :
1267                         "Media Center Ed. eHome Infrared Remote Transceiver",
1268                  le16_to_cpu(ir->usbdev->descriptor.idVendor),
1269                  le16_to_cpu(ir->usbdev->descriptor.idProduct));
1270
1271         usb_make_path(ir->usbdev, ir->phys, sizeof(ir->phys));
1272
1273         rc->device_name = ir->name;
1274         rc->input_phys = ir->phys;
1275         usb_to_input_id(ir->usbdev, &rc->input_id);
1276         rc->dev.parent = dev;
1277         rc->priv = ir;
1278         rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
1279         rc->timeout = MS_TO_NS(100);
1280         if (!ir->flags.no_tx) {
1281                 rc->s_tx_mask = mceusb_set_tx_mask;
1282                 rc->s_tx_carrier = mceusb_set_tx_carrier;
1283                 rc->tx_ir = mceusb_tx_ir;
1284         }
1285         rc->driver_name = DRIVER_NAME;
1286
1287         switch (le16_to_cpu(udev->descriptor.idVendor)) {
1288         case VENDOR_HAUPPAUGE:
1289                 rc->map_name = RC_MAP_HAUPPAUGE;
1290                 break;
1291         case VENDOR_PCTV:
1292                 rc->map_name = RC_MAP_PINNACLE_PCTV_HD;
1293                 break;
1294         default:
1295                 rc->map_name = RC_MAP_RC6_MCE;
1296         }
1297         if (mceusb_model[ir->model].rc_map)
1298                 rc->map_name = mceusb_model[ir->model].rc_map;
1299
1300         ret = rc_register_device(rc);
1301         if (ret < 0) {
1302                 dev_err(dev, "remote dev registration failed");
1303                 goto out;
1304         }
1305
1306         return rc;
1307
1308 out:
1309         rc_free_device(rc);
1310         return NULL;
1311 }
1312
1313 static int mceusb_dev_probe(struct usb_interface *intf,
1314                             const struct usb_device_id *id)
1315 {
1316         struct usb_device *dev = interface_to_usbdev(intf);
1317         struct usb_host_interface *idesc;
1318         struct usb_endpoint_descriptor *ep = NULL;
1319         struct usb_endpoint_descriptor *ep_in = NULL;
1320         struct usb_endpoint_descriptor *ep_out = NULL;
1321         struct mceusb_dev *ir = NULL;
1322         int pipe, maxp, i, res;
1323         char buf[63], name[128] = "";
1324         enum mceusb_model_type model = id->driver_info;
1325         bool is_gen3;
1326         bool is_microsoft_gen1;
1327         bool tx_mask_normal;
1328         int ir_intfnum;
1329
1330         dev_dbg(&intf->dev, "%s called", __func__);
1331
1332         idesc  = intf->cur_altsetting;
1333
1334         is_gen3 = mceusb_model[model].mce_gen3;
1335         is_microsoft_gen1 = mceusb_model[model].mce_gen1;
1336         tx_mask_normal = mceusb_model[model].tx_mask_normal;
1337         ir_intfnum = mceusb_model[model].ir_intfnum;
1338
1339         /* There are multi-function devices with non-IR interfaces */
1340         if (idesc->desc.bInterfaceNumber != ir_intfnum)
1341                 return -ENODEV;
1342
1343         /* step through the endpoints to find first bulk in and out endpoint */
1344         for (i = 0; i < idesc->desc.bNumEndpoints; ++i) {
1345                 ep = &idesc->endpoint[i].desc;
1346
1347                 if (ep_in == NULL) {
1348                         if (usb_endpoint_is_bulk_in(ep)) {
1349                                 ep_in = ep;
1350                                 dev_dbg(&intf->dev, "acceptable bulk inbound endpoint found\n");
1351                         } else if (usb_endpoint_is_int_in(ep)) {
1352                                 ep_in = ep;
1353                                 ep_in->bInterval = 1;
1354                                 dev_dbg(&intf->dev, "acceptable interrupt inbound endpoint found\n");
1355                         }
1356                 }
1357
1358                 if (ep_out == NULL) {
1359                         if (usb_endpoint_is_bulk_out(ep)) {
1360                                 ep_out = ep;
1361                                 dev_dbg(&intf->dev, "acceptable bulk outbound endpoint found\n");
1362                         } else if (usb_endpoint_is_int_out(ep)) {
1363                                 ep_out = ep;
1364                                 ep_out->bInterval = 1;
1365                                 dev_dbg(&intf->dev, "acceptable interrupt outbound endpoint found\n");
1366                         }
1367                 }
1368         }
1369         if (!ep_in || !ep_out) {
1370                 dev_dbg(&intf->dev, "required endpoints not found\n");
1371                 return -ENODEV;
1372         }
1373
1374         if (usb_endpoint_xfer_int(ep_in))
1375                 pipe = usb_rcvintpipe(dev, ep_in->bEndpointAddress);
1376         else
1377                 pipe = usb_rcvbulkpipe(dev, ep_in->bEndpointAddress);
1378         maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
1379
1380         ir = kzalloc(sizeof(struct mceusb_dev), GFP_KERNEL);
1381         if (!ir)
1382                 goto mem_alloc_fail;
1383
1384         ir->pipe_in = pipe;
1385         ir->buf_in = usb_alloc_coherent(dev, maxp, GFP_ATOMIC, &ir->dma_in);
1386         if (!ir->buf_in)
1387                 goto buf_in_alloc_fail;
1388
1389         ir->urb_in = usb_alloc_urb(0, GFP_KERNEL);
1390         if (!ir->urb_in)
1391                 goto urb_in_alloc_fail;
1392
1393         ir->usbdev = usb_get_dev(dev);
1394         ir->dev = &intf->dev;
1395         ir->len_in = maxp;
1396         ir->flags.microsoft_gen1 = is_microsoft_gen1;
1397         ir->flags.tx_mask_normal = tx_mask_normal;
1398         ir->flags.no_tx = mceusb_model[model].no_tx;
1399         ir->model = model;
1400
1401         /* Saving usb interface data for use by the transmitter routine */
1402         ir->usb_ep_out = ep_out;
1403         if (usb_endpoint_xfer_int(ep_out))
1404                 ir->pipe_out = usb_sndintpipe(ir->usbdev,
1405                                               ep_out->bEndpointAddress);
1406         else
1407                 ir->pipe_out = usb_sndbulkpipe(ir->usbdev,
1408                                                ep_out->bEndpointAddress);
1409
1410         if (dev->descriptor.iManufacturer
1411             && usb_string(dev, dev->descriptor.iManufacturer,
1412                           buf, sizeof(buf)) > 0)
1413                 strlcpy(name, buf, sizeof(name));
1414         if (dev->descriptor.iProduct
1415             && usb_string(dev, dev->descriptor.iProduct,
1416                           buf, sizeof(buf)) > 0)
1417                 snprintf(name + strlen(name), sizeof(name) - strlen(name),
1418                          " %s", buf);
1419
1420         /*
1421          * Initialize async USB error handler before registering
1422          * or activating any mceusb RX and TX functions
1423          */
1424         INIT_WORK(&ir->kevent, mceusb_deferred_kevent);
1425
1426         ir->rc = mceusb_init_rc_dev(ir);
1427         if (!ir->rc)
1428                 goto rc_dev_fail;
1429
1430         /* wire up inbound data handler */
1431         if (usb_endpoint_xfer_int(ep_in))
1432                 usb_fill_int_urb(ir->urb_in, dev, pipe, ir->buf_in, maxp,
1433                                  mceusb_dev_recv, ir, ep_in->bInterval);
1434         else
1435                 usb_fill_bulk_urb(ir->urb_in, dev, pipe, ir->buf_in, maxp,
1436                                   mceusb_dev_recv, ir);
1437
1438         ir->urb_in->transfer_dma = ir->dma_in;
1439         ir->urb_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1440
1441         /* flush buffers on the device */
1442         dev_dbg(&intf->dev, "Flushing receive buffers");
1443         res = usb_submit_urb(ir->urb_in, GFP_KERNEL);
1444         if (res)
1445                 dev_err(&intf->dev, "failed to flush buffers: %d", res);
1446
1447         /* figure out which firmware/emulator version this hardware has */
1448         mceusb_get_emulator_version(ir);
1449
1450         /* initialize device */
1451         if (ir->flags.microsoft_gen1)
1452                 mceusb_gen1_init(ir);
1453         else if (!is_gen3)
1454                 mceusb_gen2_init(ir);
1455
1456         mceusb_get_parameters(ir);
1457
1458         mceusb_flash_led(ir);
1459
1460         if (!ir->flags.no_tx)
1461                 mceusb_set_tx_mask(ir->rc, MCE_DEFAULT_TX_MASK);
1462
1463         usb_set_intfdata(intf, ir);
1464
1465         /* enable wake via this device */
1466         device_set_wakeup_capable(ir->dev, true);
1467         device_set_wakeup_enable(ir->dev, true);
1468
1469         dev_info(&intf->dev, "Registered %s with mce emulator interface version %x",
1470                 name, ir->emver);
1471         dev_info(&intf->dev, "%x tx ports (0x%x cabled) and %x rx sensors (0x%x active)",
1472                  ir->num_txports, ir->txports_cabled,
1473                  ir->num_rxports, ir->rxports_active);
1474
1475         return 0;
1476
1477         /* Error-handling path */
1478 rc_dev_fail:
1479         cancel_work_sync(&ir->kevent);
1480         usb_put_dev(ir->usbdev);
1481         usb_kill_urb(ir->urb_in);
1482         usb_free_urb(ir->urb_in);
1483 urb_in_alloc_fail:
1484         usb_free_coherent(dev, maxp, ir->buf_in, ir->dma_in);
1485 buf_in_alloc_fail:
1486         kfree(ir);
1487 mem_alloc_fail:
1488         dev_err(&intf->dev, "%s: device setup failed!", __func__);
1489
1490         return -ENOMEM;
1491 }
1492
1493
1494 static void mceusb_dev_disconnect(struct usb_interface *intf)
1495 {
1496         struct usb_device *dev = interface_to_usbdev(intf);
1497         struct mceusb_dev *ir = usb_get_intfdata(intf);
1498
1499         usb_set_intfdata(intf, NULL);
1500
1501         if (!ir)
1502                 return;
1503
1504         ir->usbdev = NULL;
1505         cancel_work_sync(&ir->kevent);
1506         rc_unregister_device(ir->rc);
1507         usb_kill_urb(ir->urb_in);
1508         usb_free_urb(ir->urb_in);
1509         usb_free_coherent(dev, ir->len_in, ir->buf_in, ir->dma_in);
1510         usb_put_dev(dev);
1511
1512         kfree(ir);
1513 }
1514
1515 static int mceusb_dev_suspend(struct usb_interface *intf, pm_message_t message)
1516 {
1517         struct mceusb_dev *ir = usb_get_intfdata(intf);
1518         dev_info(ir->dev, "suspend");
1519         usb_kill_urb(ir->urb_in);
1520         return 0;
1521 }
1522
1523 static int mceusb_dev_resume(struct usb_interface *intf)
1524 {
1525         struct mceusb_dev *ir = usb_get_intfdata(intf);
1526         dev_info(ir->dev, "resume");
1527         if (usb_submit_urb(ir->urb_in, GFP_ATOMIC))
1528                 return -EIO;
1529         return 0;
1530 }
1531
1532 static struct usb_driver mceusb_dev_driver = {
1533         .name =         DRIVER_NAME,
1534         .probe =        mceusb_dev_probe,
1535         .disconnect =   mceusb_dev_disconnect,
1536         .suspend =      mceusb_dev_suspend,
1537         .resume =       mceusb_dev_resume,
1538         .reset_resume = mceusb_dev_resume,
1539         .id_table =     mceusb_dev_table
1540 };
1541
1542 module_usb_driver(mceusb_dev_driver);
1543
1544 MODULE_DESCRIPTION(DRIVER_DESC);
1545 MODULE_AUTHOR(DRIVER_AUTHOR);
1546 MODULE_LICENSE("GPL");
1547 MODULE_DEVICE_TABLE(usb, mceusb_dev_table);