Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Driver for USB Windows Media Center Ed. eHome Infrared Transceivers
0004  *
0005  * Copyright (c) 2010-2011, Jarod Wilson <jarod@redhat.com>
0006  *
0007  * Based on the original lirc_mceusb and lirc_mceusb2 drivers, by Dan
0008  * Conti, Martin Blatter and Daniel Melander, the latter of which was
0009  * in turn also based on the lirc_atiusb driver by Paul Miller. The
0010  * two mce drivers were merged into one by Jarod Wilson, with transmit
0011  * support for the 1st-gen device added primarily by Patrick Calhoun,
0012  * with a bit of tweaks by Jarod. Debugging improvements and proper
0013  * support for what appears to be 3rd-gen hardware added by Jarod.
0014  * Initial port from lirc driver to ir-core drivery by Jarod, based
0015  * partially on a port to an earlier proposed IR infrastructure by
0016  * Jon Smirl, which included enhancements and simplifications to the
0017  * incoming IR buffer parsing routines.
0018  *
0019  * Updated in July of 2011 with the aid of Microsoft's official
0020  * remote/transceiver requirements and specification document, found at
0021  * download.microsoft.com, title
0022  * Windows-Media-Center-RC-IR-Collection-Green-Button-Specification-03-08-2011-V2.pdf
0023  */
0024 
0025 #include <linux/device.h>
0026 #include <linux/module.h>
0027 #include <linux/slab.h>
0028 #include <linux/workqueue.h>
0029 #include <linux/usb.h>
0030 #include <linux/usb/input.h>
0031 #include <linux/pm_wakeup.h>
0032 #include <media/rc-core.h>
0033 
0034 #define DRIVER_VERSION  "1.95"
0035 #define DRIVER_AUTHOR   "Jarod Wilson <jarod@redhat.com>"
0036 #define DRIVER_DESC "Windows Media Center Ed. eHome Infrared Transceiver " \
0037             "device driver"
0038 #define DRIVER_NAME "mceusb"
0039 
0040 #define USB_TX_TIMEOUT      1000 /* in milliseconds */
0041 #define USB_CTRL_MSG_SZ     2  /* Size of usb ctrl msg on gen1 hw */
0042 #define MCE_G1_INIT_MSGS    40 /* Init messages on gen1 hw to throw out */
0043 
0044 /* MCE constants */
0045 #define MCE_IRBUF_SIZE      128  /* TX IR buffer length */
0046 #define MCE_TIME_UNIT       50   /* Approx 50us resolution */
0047 #define MCE_PACKET_SIZE     31   /* Max length of packet (with header) */
0048 #define MCE_IRDATA_HEADER   (0x80 + MCE_PACKET_SIZE - 1)
0049                      /* Actual format is 0x80 + num_bytes */
0050 #define MCE_IRDATA_TRAILER  0x80 /* End of IR data */
0051 #define MCE_MAX_CHANNELS    2    /* Two transmitters, hardware dependent? */
0052 #define MCE_DEFAULT_TX_MASK 0x03 /* Vals: TX1=0x01, TX2=0x02, ALL=0x03 */
0053 #define MCE_PULSE_BIT       0x80 /* Pulse bit, MSB set == PULSE else SPACE */
0054 #define MCE_PULSE_MASK      0x7f /* Pulse mask */
0055 #define MCE_MAX_PULSE_LENGTH    0x7f /* Longest transmittable pulse symbol */
0056 
0057 /*
0058  * The interface between the host and the IR hardware is command-response
0059  * based. All commands and responses have a consistent format, where a lead
0060  * byte always identifies the type of data following it. The lead byte has
0061  * a port value in the 3 highest bits and a length value in the 5 lowest
0062  * bits.
0063  *
0064  * The length field is overloaded, with a value of 11111 indicating that the
0065  * following byte is a command or response code, and the length of the entire
0066  * message is determined by the code. If the length field is not 11111, then
0067  * it specifies the number of bytes of port data that follow.
0068  */
0069 #define MCE_CMD         0x1f
0070 #define MCE_PORT_IR     0x4 /* (0x4 << 5) | MCE_CMD = 0x9f */
0071 #define MCE_PORT_SYS        0x7 /* (0x7 << 5) | MCE_CMD = 0xff */
0072 #define MCE_PORT_SER        0x6 /* 0xc0 through 0xdf flush & 0x1f bytes */
0073 #define MCE_PORT_MASK       0xe0    /* Mask out command bits */
0074 
0075 /* Command port headers */
0076 #define MCE_CMD_PORT_IR     0x9f    /* IR-related cmd/rsp */
0077 #define MCE_CMD_PORT_SYS    0xff    /* System (non-IR) device cmd/rsp */
0078 
0079 /* Commands that set device state  (2-4 bytes in length) */
0080 #define MCE_CMD_RESET       0xfe    /* Reset device, 2 bytes */
0081 #define MCE_CMD_RESUME      0xaa    /* Resume device after error, 2 bytes */
0082 #define MCE_CMD_SETIRCFS    0x06    /* Set tx carrier, 4 bytes */
0083 #define MCE_CMD_SETIRTIMEOUT    0x0c    /* Set timeout, 4 bytes */
0084 #define MCE_CMD_SETIRTXPORTS    0x08    /* Set tx ports, 3 bytes */
0085 #define MCE_CMD_SETIRRXPORTEN   0x14    /* Set rx ports, 3 bytes */
0086 #define MCE_CMD_FLASHLED    0x23    /* Flash receiver LED, 2 bytes */
0087 
0088 /* Commands that query device state (all 2 bytes, unless noted) */
0089 #define MCE_CMD_GETIRCFS    0x07    /* Get carrier */
0090 #define MCE_CMD_GETIRTIMEOUT    0x0d    /* Get timeout */
0091 #define MCE_CMD_GETIRTXPORTS    0x13    /* Get tx ports */
0092 #define MCE_CMD_GETIRRXPORTEN   0x15    /* Get rx ports */
0093 #define MCE_CMD_GETPORTSTATUS   0x11    /* Get tx port status, 3 bytes */
0094 #define MCE_CMD_GETIRNUMPORTS   0x16    /* Get number of ports */
0095 #define MCE_CMD_GETWAKESOURCE   0x17    /* Get wake source */
0096 #define MCE_CMD_GETEMVER    0x22    /* Get emulator interface version */
0097 #define MCE_CMD_GETDEVDETAILS   0x21    /* Get device details (em ver2 only) */
0098 #define MCE_CMD_GETWAKESUPPORT  0x20    /* Get wake details (em ver2 only) */
0099 #define MCE_CMD_GETWAKEVERSION  0x18    /* Get wake pattern (em ver2 only) */
0100 
0101 /* Misc commands */
0102 #define MCE_CMD_NOP     0xff    /* No operation */
0103 
0104 /* Responses to commands (non-error cases) */
0105 #define MCE_RSP_EQIRCFS     0x06    /* tx carrier, 4 bytes */
0106 #define MCE_RSP_EQIRTIMEOUT 0x0c    /* rx timeout, 4 bytes */
0107 #define MCE_RSP_GETWAKESOURCE   0x17    /* wake source, 3 bytes */
0108 #define MCE_RSP_EQIRTXPORTS 0x08    /* tx port mask, 3 bytes */
0109 #define MCE_RSP_EQIRRXPORTEN    0x14    /* rx port mask, 3 bytes */
0110 #define MCE_RSP_GETPORTSTATUS   0x11    /* tx port status, 7 bytes */
0111 #define MCE_RSP_EQIRRXCFCNT 0x15    /* rx carrier count, 4 bytes */
0112 #define MCE_RSP_EQIRNUMPORTS    0x16    /* number of ports, 4 bytes */
0113 #define MCE_RSP_EQWAKESUPPORT   0x20    /* wake capabilities, 3 bytes */
0114 #define MCE_RSP_EQWAKEVERSION   0x18    /* wake pattern details, 6 bytes */
0115 #define MCE_RSP_EQDEVDETAILS    0x21    /* device capabilities, 3 bytes */
0116 #define MCE_RSP_EQEMVER     0x22    /* emulator interface ver, 3 bytes */
0117 #define MCE_RSP_FLASHLED    0x23    /* success flashing LED, 2 bytes */
0118 
0119 /* Responses to error cases, must send MCE_CMD_RESUME to clear them */
0120 #define MCE_RSP_CMD_ILLEGAL 0xfe    /* illegal command for port, 2 bytes */
0121 #define MCE_RSP_TX_TIMEOUT  0x81    /* tx timed out, 2 bytes */
0122 
0123 /* Misc commands/responses not defined in the MCE remote/transceiver spec */
0124 #define MCE_CMD_SIG_END     0x01    /* End of signal */
0125 #define MCE_CMD_PING        0x03    /* Ping device */
0126 #define MCE_CMD_UNKNOWN     0x04    /* Unknown */
0127 #define MCE_CMD_UNKNOWN2    0x05    /* Unknown */
0128 #define MCE_CMD_UNKNOWN3    0x09    /* Unknown */
0129 #define MCE_CMD_UNKNOWN4    0x0a    /* Unknown */
0130 #define MCE_CMD_G_REVISION  0x0b    /* Get hw/sw revision */
0131 #define MCE_CMD_UNKNOWN5    0x0e    /* Unknown */
0132 #define MCE_CMD_UNKNOWN6    0x0f    /* Unknown */
0133 #define MCE_CMD_UNKNOWN8    0x19    /* Unknown */
0134 #define MCE_CMD_UNKNOWN9    0x1b    /* Unknown */
0135 #define MCE_CMD_NULL        0x00    /* These show up various places... */
0136 
0137 /* if buf[i] & MCE_PORT_MASK == 0x80 and buf[i] != MCE_CMD_PORT_IR,
0138  * then we're looking at a raw IR data sample */
0139 #define MCE_COMMAND_IRDATA  0x80
0140 #define MCE_PACKET_LENGTH_MASK  0x1f /* Packet length mask */
0141 
0142 #define VENDOR_PHILIPS      0x0471
0143 #define VENDOR_SMK      0x0609
0144 #define VENDOR_TATUNG       0x1460
0145 #define VENDOR_GATEWAY      0x107b
0146 #define VENDOR_SHUTTLE      0x1308
0147 #define VENDOR_SHUTTLE2     0x051c
0148 #define VENDOR_MITSUMI      0x03ee
0149 #define VENDOR_TOPSEED      0x1784
0150 #define VENDOR_RICAVISION   0x179d
0151 #define VENDOR_ITRON        0x195d
0152 #define VENDOR_FIC      0x1509
0153 #define VENDOR_LG       0x043e
0154 #define VENDOR_MICROSOFT    0x045e
0155 #define VENDOR_FORMOSA      0x147a
0156 #define VENDOR_FINTEK       0x1934
0157 #define VENDOR_PINNACLE     0x2304
0158 #define VENDOR_ECS      0x1019
0159 #define VENDOR_WISTRON      0x0fb8
0160 #define VENDOR_COMPRO       0x185b
0161 #define VENDOR_NORTHSTAR    0x04eb
0162 #define VENDOR_REALTEK      0x0bda
0163 #define VENDOR_TIVO     0x105a
0164 #define VENDOR_CONEXANT     0x0572
0165 #define VENDOR_TWISTEDMELON 0x2596
0166 #define VENDOR_HAUPPAUGE    0x2040
0167 #define VENDOR_PCTV     0x2013
0168 #define VENDOR_ADAPTEC      0x03f3
0169 
0170 enum mceusb_model_type {
0171     MCE_GEN2 = 0,       /* Most boards */
0172     MCE_GEN1,
0173     MCE_GEN3,
0174     MCE_GEN3_BROKEN_IRTIMEOUT,
0175     MCE_GEN2_TX_INV,
0176     MCE_GEN2_TX_INV_RX_GOOD,
0177     POLARIS_EVK,
0178     CX_HYBRID_TV,
0179     MULTIFUNCTION,
0180     TIVO_KIT,
0181     MCE_GEN2_NO_TX,
0182     HAUPPAUGE_CX_HYBRID_TV,
0183     EVROMEDIA_FULL_HYBRID_FULLHD,
0184     ASTROMETA_T2HYBRID,
0185 };
0186 
0187 struct mceusb_model {
0188     u32 mce_gen1:1;
0189     u32 mce_gen2:1;
0190     u32 mce_gen3:1;
0191     u32 tx_mask_normal:1;
0192     u32 no_tx:1;
0193     u32 broken_irtimeout:1;
0194     /*
0195      * 2nd IR receiver (short-range, wideband) for learning mode:
0196      *     0, absent 2nd receiver (rx2)
0197      *     1, rx2 present
0198      *     2, rx2 which under counts IR carrier cycles
0199      */
0200     u32 rx2;
0201 
0202     int ir_intfnum;
0203 
0204     const char *rc_map; /* Allow specify a per-board map */
0205     const char *name;   /* per-board name */
0206 };
0207 
0208 static const struct mceusb_model mceusb_model[] = {
0209     [MCE_GEN1] = {
0210         .mce_gen1 = 1,
0211         .tx_mask_normal = 1,
0212         .rx2 = 2,
0213     },
0214     [MCE_GEN2] = {
0215         .mce_gen2 = 1,
0216         .rx2 = 2,
0217     },
0218     [MCE_GEN2_NO_TX] = {
0219         .mce_gen2 = 1,
0220         .no_tx = 1,
0221     },
0222     [MCE_GEN2_TX_INV] = {
0223         .mce_gen2 = 1,
0224         .tx_mask_normal = 1,
0225         .rx2 = 1,
0226     },
0227     [MCE_GEN2_TX_INV_RX_GOOD] = {
0228         .mce_gen2 = 1,
0229         .tx_mask_normal = 1,
0230         .rx2 = 2,
0231     },
0232     [MCE_GEN3] = {
0233         .mce_gen3 = 1,
0234         .tx_mask_normal = 1,
0235         .rx2 = 2,
0236     },
0237     [MCE_GEN3_BROKEN_IRTIMEOUT] = {
0238         .mce_gen3 = 1,
0239         .tx_mask_normal = 1,
0240         .rx2 = 2,
0241         .broken_irtimeout = 1
0242     },
0243     [POLARIS_EVK] = {
0244         /*
0245          * In fact, the EVK is shipped without
0246          * remotes, but we should have something handy,
0247          * to allow testing it
0248          */
0249         .name = "Conexant Hybrid TV (cx231xx) MCE IR",
0250         .rx2 = 2,
0251     },
0252     [CX_HYBRID_TV] = {
0253         .no_tx = 1, /* tx isn't wired up at all */
0254         .name = "Conexant Hybrid TV (cx231xx) MCE IR",
0255     },
0256     [HAUPPAUGE_CX_HYBRID_TV] = {
0257         .no_tx = 1, /* eeprom says it has no tx */
0258         .name = "Conexant Hybrid TV (cx231xx) MCE IR no TX",
0259     },
0260     [MULTIFUNCTION] = {
0261         .mce_gen2 = 1,
0262         .ir_intfnum = 2,
0263         .rx2 = 2,
0264     },
0265     [TIVO_KIT] = {
0266         .mce_gen2 = 1,
0267         .rc_map = RC_MAP_TIVO,
0268         .rx2 = 2,
0269     },
0270     [EVROMEDIA_FULL_HYBRID_FULLHD] = {
0271         .name = "Evromedia USB Full Hybrid Full HD",
0272         .no_tx = 1,
0273         .rc_map = RC_MAP_MSI_DIGIVOX_III,
0274     },
0275     [ASTROMETA_T2HYBRID] = {
0276         .name = "Astrometa T2Hybrid",
0277         .no_tx = 1,
0278         .rc_map = RC_MAP_ASTROMETA_T2HYBRID,
0279     }
0280 };
0281 
0282 static const struct usb_device_id mceusb_dev_table[] = {
0283     /* Original Microsoft MCE IR Transceiver (often HP-branded) */
0284     { USB_DEVICE(VENDOR_MICROSOFT, 0x006d),
0285       .driver_info = MCE_GEN1 },
0286     /* Philips Infrared Transceiver - Sahara branded */
0287     { USB_DEVICE(VENDOR_PHILIPS, 0x0608) },
0288     /* Philips Infrared Transceiver - HP branded */
0289     { USB_DEVICE(VENDOR_PHILIPS, 0x060c),
0290       .driver_info = MCE_GEN2_TX_INV },
0291     /* Philips SRM5100 */
0292     { USB_DEVICE(VENDOR_PHILIPS, 0x060d) },
0293     /* Philips Infrared Transceiver - Omaura */
0294     { USB_DEVICE(VENDOR_PHILIPS, 0x060f) },
0295     /* Philips Infrared Transceiver - Spinel plus */
0296     { USB_DEVICE(VENDOR_PHILIPS, 0x0613) },
0297     /* Philips eHome Infrared Transceiver */
0298     { USB_DEVICE(VENDOR_PHILIPS, 0x0815) },
0299     /* Philips/Spinel plus IR transceiver for ASUS */
0300     { USB_DEVICE(VENDOR_PHILIPS, 0x206c) },
0301     /* Philips/Spinel plus IR transceiver for ASUS */
0302     { USB_DEVICE(VENDOR_PHILIPS, 0x2088) },
0303     /* Philips IR transceiver (Dell branded) */
0304     { USB_DEVICE(VENDOR_PHILIPS, 0x2093),
0305       .driver_info = MCE_GEN2_TX_INV },
0306     /* Realtek MCE IR Receiver and card reader */
0307     { USB_DEVICE(VENDOR_REALTEK, 0x0161),
0308       .driver_info = MULTIFUNCTION },
0309     /* SMK/Toshiba G83C0004D410 */
0310     { USB_DEVICE(VENDOR_SMK, 0x031d),
0311       .driver_info = MCE_GEN2_TX_INV_RX_GOOD },
0312     /* SMK eHome Infrared Transceiver (Sony VAIO) */
0313     { USB_DEVICE(VENDOR_SMK, 0x0322),
0314       .driver_info = MCE_GEN2_TX_INV },
0315     /* bundled with Hauppauge PVR-150 */
0316     { USB_DEVICE(VENDOR_SMK, 0x0334),
0317       .driver_info = MCE_GEN2_TX_INV },
0318     /* SMK eHome Infrared Transceiver */
0319     { USB_DEVICE(VENDOR_SMK, 0x0338) },
0320     /* SMK/I-O Data GV-MC7/RCKIT Receiver */
0321     { USB_DEVICE(VENDOR_SMK, 0x0353),
0322       .driver_info = MCE_GEN2_NO_TX },
0323     /* SMK RXX6000 Infrared Receiver */
0324     { USB_DEVICE(VENDOR_SMK, 0x0357),
0325       .driver_info = MCE_GEN2_NO_TX },
0326     /* Tatung eHome Infrared Transceiver */
0327     { USB_DEVICE(VENDOR_TATUNG, 0x9150) },
0328     /* Shuttle eHome Infrared Transceiver */
0329     { USB_DEVICE(VENDOR_SHUTTLE, 0xc001) },
0330     /* Shuttle eHome Infrared Transceiver */
0331     { USB_DEVICE(VENDOR_SHUTTLE2, 0xc001) },
0332     /* Gateway eHome Infrared Transceiver */
0333     { USB_DEVICE(VENDOR_GATEWAY, 0x3009) },
0334     /* Mitsumi */
0335     { USB_DEVICE(VENDOR_MITSUMI, 0x2501) },
0336     /* Topseed eHome Infrared Transceiver */
0337     { USB_DEVICE(VENDOR_TOPSEED, 0x0001),
0338       .driver_info = MCE_GEN2_TX_INV },
0339     /* Topseed HP eHome Infrared Transceiver */
0340     { USB_DEVICE(VENDOR_TOPSEED, 0x0006),
0341       .driver_info = MCE_GEN2_TX_INV },
0342     /* Topseed eHome Infrared Transceiver */
0343     { USB_DEVICE(VENDOR_TOPSEED, 0x0007),
0344       .driver_info = MCE_GEN2_TX_INV },
0345     /* Topseed eHome Infrared Transceiver */
0346     { USB_DEVICE(VENDOR_TOPSEED, 0x0008),
0347       .driver_info = MCE_GEN3 },
0348     /* Topseed eHome Infrared Transceiver */
0349     { USB_DEVICE(VENDOR_TOPSEED, 0x000a),
0350       .driver_info = MCE_GEN2_TX_INV },
0351     /* Topseed eHome Infrared Transceiver */
0352     { USB_DEVICE(VENDOR_TOPSEED, 0x0011),
0353       .driver_info = MCE_GEN3_BROKEN_IRTIMEOUT },
0354     /* Ricavision internal Infrared Transceiver */
0355     { USB_DEVICE(VENDOR_RICAVISION, 0x0010) },
0356     /* Itron ione Libra Q-11 */
0357     { USB_DEVICE(VENDOR_ITRON, 0x7002) },
0358     /* FIC eHome Infrared Transceiver */
0359     { USB_DEVICE(VENDOR_FIC, 0x9242) },
0360     /* LG eHome Infrared Transceiver */
0361     { USB_DEVICE(VENDOR_LG, 0x9803) },
0362     /* Microsoft MCE Infrared Transceiver */
0363     { USB_DEVICE(VENDOR_MICROSOFT, 0x00a0) },
0364     /* Formosa eHome Infrared Transceiver */
0365     { USB_DEVICE(VENDOR_FORMOSA, 0xe015) },
0366     /* Formosa21 / eHome Infrared Receiver */
0367     { USB_DEVICE(VENDOR_FORMOSA, 0xe016) },
0368     /* Formosa aim / Trust MCE Infrared Receiver */
0369     { USB_DEVICE(VENDOR_FORMOSA, 0xe017),
0370       .driver_info = MCE_GEN2_NO_TX },
0371     /* Formosa Industrial Computing / Beanbag Emulation Device */
0372     { USB_DEVICE(VENDOR_FORMOSA, 0xe018) },
0373     /* Formosa21 / eHome Infrared Receiver */
0374     { USB_DEVICE(VENDOR_FORMOSA, 0xe03a) },
0375     /* Formosa Industrial Computing AIM IR605/A */
0376     { USB_DEVICE(VENDOR_FORMOSA, 0xe03c) },
0377     /* Formosa Industrial Computing */
0378     { USB_DEVICE(VENDOR_FORMOSA, 0xe03e) },
0379     /* Formosa Industrial Computing */
0380     { USB_DEVICE(VENDOR_FORMOSA, 0xe042) },
0381     /* Fintek eHome Infrared Transceiver (HP branded) */
0382     { USB_DEVICE(VENDOR_FINTEK, 0x5168),
0383       .driver_info = MCE_GEN2_TX_INV },
0384     /* Fintek eHome Infrared Transceiver */
0385     { USB_DEVICE(VENDOR_FINTEK, 0x0602) },
0386     /* Fintek eHome Infrared Transceiver (in the AOpen MP45) */
0387     { USB_DEVICE(VENDOR_FINTEK, 0x0702) },
0388     /* Pinnacle Remote Kit */
0389     { USB_DEVICE(VENDOR_PINNACLE, 0x0225),
0390       .driver_info = MCE_GEN3 },
0391     /* Elitegroup Computer Systems IR */
0392     { USB_DEVICE(VENDOR_ECS, 0x0f38) },
0393     /* Wistron Corp. eHome Infrared Receiver */
0394     { USB_DEVICE(VENDOR_WISTRON, 0x0002) },
0395     /* Compro K100 */
0396     { USB_DEVICE(VENDOR_COMPRO, 0x3020) },
0397     /* Compro K100 v2 */
0398     { USB_DEVICE(VENDOR_COMPRO, 0x3082) },
0399     /* Northstar Systems, Inc. eHome Infrared Transceiver */
0400     { USB_DEVICE(VENDOR_NORTHSTAR, 0xe004) },
0401     /* TiVo PC IR Receiver */
0402     { USB_DEVICE(VENDOR_TIVO, 0x2000),
0403       .driver_info = TIVO_KIT },
0404     /* Conexant Hybrid TV "Shelby" Polaris SDK */
0405     { USB_DEVICE(VENDOR_CONEXANT, 0x58a1),
0406       .driver_info = POLARIS_EVK },
0407     /* Conexant Hybrid TV RDU253S Polaris */
0408     { USB_DEVICE(VENDOR_CONEXANT, 0x58a5),
0409       .driver_info = CX_HYBRID_TV },
0410     /* Twisted Melon Inc. - Manta Mini Receiver */
0411     { USB_DEVICE(VENDOR_TWISTEDMELON, 0x8008) },
0412     /* Twisted Melon Inc. - Manta Pico Receiver */
0413     { USB_DEVICE(VENDOR_TWISTEDMELON, 0x8016) },
0414     /* Twisted Melon Inc. - Manta Transceiver */
0415     { USB_DEVICE(VENDOR_TWISTEDMELON, 0x8042) },
0416     /* Hauppauge WINTV-HVR-HVR 930C-HD - based on cx231xx */
0417     { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb130),
0418       .driver_info = HAUPPAUGE_CX_HYBRID_TV },
0419     { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb131),
0420       .driver_info = HAUPPAUGE_CX_HYBRID_TV },
0421     { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb138),
0422       .driver_info = HAUPPAUGE_CX_HYBRID_TV },
0423     { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb139),
0424       .driver_info = HAUPPAUGE_CX_HYBRID_TV },
0425     /* Hauppauge WinTV-HVR-935C - based on cx231xx */
0426     { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb151),
0427       .driver_info = HAUPPAUGE_CX_HYBRID_TV },
0428     /* Hauppauge WinTV-HVR-955Q - based on cx231xx */
0429     { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb123),
0430       .driver_info = HAUPPAUGE_CX_HYBRID_TV },
0431     /* Hauppauge WinTV-HVR-975 - based on cx231xx */
0432     { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb150),
0433       .driver_info = HAUPPAUGE_CX_HYBRID_TV },
0434     { USB_DEVICE(VENDOR_PCTV, 0x0259),
0435       .driver_info = HAUPPAUGE_CX_HYBRID_TV },
0436     { USB_DEVICE(VENDOR_PCTV, 0x025e),
0437       .driver_info = HAUPPAUGE_CX_HYBRID_TV },
0438     /* Adaptec / HP eHome Receiver */
0439     { USB_DEVICE(VENDOR_ADAPTEC, 0x0094) },
0440     /* Evromedia USB Full Hybrid Full HD */
0441     { USB_DEVICE(0x1b80, 0xd3b2),
0442       .driver_info = EVROMEDIA_FULL_HYBRID_FULLHD },
0443     /* Astrometa T2hybrid */
0444     { USB_DEVICE(0x15f4, 0x0135),
0445       .driver_info = ASTROMETA_T2HYBRID },
0446 
0447     /* Terminating entry */
0448     { }
0449 };
0450 
0451 /* data structure for each usb transceiver */
0452 struct mceusb_dev {
0453     /* ir-core bits */
0454     struct rc_dev *rc;
0455 
0456     /* optional features we can enable */
0457     bool carrier_report_enabled;
0458     bool wideband_rx_enabled;   /* aka learning mode, short-range rx */
0459 
0460     /* core device bits */
0461     struct device *dev;
0462 
0463     /* usb */
0464     struct usb_device *usbdev;
0465     struct usb_interface *usbintf;
0466     struct urb *urb_in;
0467     unsigned int pipe_in;
0468     struct usb_endpoint_descriptor *usb_ep_out;
0469     unsigned int pipe_out;
0470 
0471     /* buffers and dma */
0472     unsigned char *buf_in;
0473     unsigned int len_in;
0474     dma_addr_t dma_in;
0475 
0476     enum {
0477         CMD_HEADER = 0,
0478         SUBCMD,
0479         CMD_DATA,
0480         PARSE_IRDATA,
0481     } parser_state;
0482 
0483     u8 cmd, rem;        /* Remaining IR data bytes in packet */
0484 
0485     struct {
0486         u32 connected:1;
0487         u32 tx_mask_normal:1;
0488         u32 microsoft_gen1:1;
0489         u32 no_tx:1;
0490         u32 rx2;
0491     } flags;
0492 
0493     /* transmit support */
0494     u32 carrier;
0495     unsigned char tx_mask;
0496 
0497     char name[128];
0498     char phys[64];
0499     enum mceusb_model_type model;
0500 
0501     bool need_reset;    /* flag to issue a device resume cmd */
0502     u8 emver;       /* emulator interface version */
0503     u8 num_txports;     /* number of transmit ports */
0504     u8 num_rxports;     /* number of receive sensors */
0505     u8 txports_cabled;  /* bitmask of transmitters with cable */
0506     u8 rxports_active;  /* bitmask of active receive sensors */
0507     bool learning_active;   /* wideband rx is active */
0508 
0509     /* receiver carrier frequency detection support */
0510     u32 pulse_tunit;    /* IR pulse "on" cumulative time units */
0511     u32 pulse_count;    /* pulse "on" count in measurement interval */
0512 
0513     /*
0514      * support for async error handler mceusb_deferred_kevent()
0515      * where usb_clear_halt(), usb_reset_configuration(),
0516      * usb_reset_device(), etc. must be done in process context
0517      */
0518     struct work_struct kevent;
0519     unsigned long kevent_flags;
0520 #       define EVENT_TX_HALT    0
0521 #       define EVENT_RX_HALT    1
0522 #       define EVENT_RST_PEND   31
0523 };
0524 
0525 /* MCE Device Command Strings, generally a port and command pair */
0526 static char DEVICE_RESUME[] = {MCE_CMD_NULL, MCE_CMD_PORT_SYS,
0527                    MCE_CMD_RESUME};
0528 static char GET_REVISION[]  = {MCE_CMD_PORT_SYS, MCE_CMD_G_REVISION};
0529 static char GET_EMVER[]     = {MCE_CMD_PORT_SYS, MCE_CMD_GETEMVER};
0530 static char GET_WAKEVERSION[]   = {MCE_CMD_PORT_SYS, MCE_CMD_GETWAKEVERSION};
0531 static char FLASH_LED[]     = {MCE_CMD_PORT_SYS, MCE_CMD_FLASHLED};
0532 static char GET_UNKNOWN2[]  = {MCE_CMD_PORT_IR, MCE_CMD_UNKNOWN2};
0533 static char GET_CARRIER_FREQ[]  = {MCE_CMD_PORT_IR, MCE_CMD_GETIRCFS};
0534 static char GET_RX_TIMEOUT[]    = {MCE_CMD_PORT_IR, MCE_CMD_GETIRTIMEOUT};
0535 static char GET_NUM_PORTS[] = {MCE_CMD_PORT_IR, MCE_CMD_GETIRNUMPORTS};
0536 static char GET_TX_BITMASK[]    = {MCE_CMD_PORT_IR, MCE_CMD_GETIRTXPORTS};
0537 static char GET_RX_SENSOR[] = {MCE_CMD_PORT_IR, MCE_CMD_GETIRRXPORTEN};
0538 /* sub in desired values in lower byte or bytes for full command */
0539 /* FIXME: make use of these for transmit.
0540 static char SET_CARRIER_FREQ[]  = {MCE_CMD_PORT_IR,
0541                    MCE_CMD_SETIRCFS, 0x00, 0x00};
0542 static char SET_TX_BITMASK[]    = {MCE_CMD_PORT_IR, MCE_CMD_SETIRTXPORTS, 0x00};
0543 static char SET_RX_TIMEOUT[]    = {MCE_CMD_PORT_IR,
0544                    MCE_CMD_SETIRTIMEOUT, 0x00, 0x00};
0545 static char SET_RX_SENSOR[] = {MCE_CMD_PORT_IR,
0546                    MCE_RSP_EQIRRXPORTEN, 0x00};
0547 */
0548 
0549 static int mceusb_cmd_datasize(u8 cmd, u8 subcmd)
0550 {
0551     int datasize = 0;
0552 
0553     switch (cmd) {
0554     case MCE_CMD_NULL:
0555         if (subcmd == MCE_CMD_PORT_SYS)
0556             datasize = 1;
0557         break;
0558     case MCE_CMD_PORT_SYS:
0559         switch (subcmd) {
0560         case MCE_RSP_GETPORTSTATUS:
0561             datasize = 5;
0562             break;
0563         case MCE_RSP_EQWAKEVERSION:
0564             datasize = 4;
0565             break;
0566         case MCE_CMD_G_REVISION:
0567             datasize = 4;
0568             break;
0569         case MCE_RSP_EQWAKESUPPORT:
0570         case MCE_RSP_GETWAKESOURCE:
0571         case MCE_RSP_EQDEVDETAILS:
0572         case MCE_RSP_EQEMVER:
0573             datasize = 1;
0574             break;
0575         }
0576         break;
0577     case MCE_CMD_PORT_IR:
0578         switch (subcmd) {
0579         case MCE_CMD_UNKNOWN:
0580         case MCE_RSP_EQIRCFS:
0581         case MCE_RSP_EQIRTIMEOUT:
0582         case MCE_RSP_EQIRRXCFCNT:
0583         case MCE_RSP_EQIRNUMPORTS:
0584             datasize = 2;
0585             break;
0586         case MCE_CMD_SIG_END:
0587         case MCE_RSP_EQIRTXPORTS:
0588         case MCE_RSP_EQIRRXPORTEN:
0589             datasize = 1;
0590             break;
0591         }
0592     }
0593     return datasize;
0594 }
0595 
0596 static void mceusb_dev_printdata(struct mceusb_dev *ir, u8 *buf, int buf_len,
0597                  int offset, int len, bool out)
0598 {
0599 #if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
0600     char *inout;
0601     u8 cmd, subcmd, *data;
0602     struct device *dev = ir->dev;
0603     u32 carrier, period;
0604 
0605     if (offset < 0 || offset >= buf_len)
0606         return;
0607 
0608     dev_dbg(dev, "%cx data[%d]: %*ph (len=%d sz=%d)",
0609         (out ? 't' : 'r'), offset,
0610         min(len, buf_len - offset), buf + offset, len, buf_len);
0611 
0612     inout = out ? "Request" : "Got";
0613 
0614     cmd    = buf[offset];
0615     subcmd = (offset + 1 < buf_len) ? buf[offset + 1] : 0;
0616     data   = &buf[offset] + 2;
0617 
0618     /* Trace meaningless 0xb1 0x60 header bytes on original receiver */
0619     if (ir->flags.microsoft_gen1 && !out && !offset) {
0620         dev_dbg(dev, "MCE gen 1 header");
0621         return;
0622     }
0623 
0624     /* Trace IR data header or trailer */
0625     if (cmd != MCE_CMD_PORT_IR &&
0626         (cmd & MCE_PORT_MASK) == MCE_COMMAND_IRDATA) {
0627         if (cmd == MCE_IRDATA_TRAILER)
0628             dev_dbg(dev, "End of raw IR data");
0629         else
0630             dev_dbg(dev, "Raw IR data, %d pulse/space samples",
0631                 cmd & MCE_PACKET_LENGTH_MASK);
0632         return;
0633     }
0634 
0635     /* Unexpected end of buffer? */
0636     if (offset + len > buf_len)
0637         return;
0638 
0639     /* Decode MCE command/response */
0640     switch (cmd) {
0641     case MCE_CMD_NULL:
0642         if (subcmd == MCE_CMD_NULL)
0643             break;
0644         if ((subcmd == MCE_CMD_PORT_SYS) &&
0645             (data[0] == MCE_CMD_RESUME))
0646             dev_dbg(dev, "Device resume requested");
0647         else
0648             dev_dbg(dev, "Unknown command 0x%02x 0x%02x",
0649                  cmd, subcmd);
0650         break;
0651     case MCE_CMD_PORT_SYS:
0652         switch (subcmd) {
0653         case MCE_RSP_EQEMVER:
0654             if (!out)
0655                 dev_dbg(dev, "Emulator interface version %x",
0656                      data[0]);
0657             break;
0658         case MCE_CMD_G_REVISION:
0659             if (len == 2)
0660                 dev_dbg(dev, "Get hw/sw rev?");
0661             else
0662                 dev_dbg(dev, "hw/sw rev %*ph",
0663                     4, &buf[offset + 2]);
0664             break;
0665         case MCE_CMD_RESUME:
0666             dev_dbg(dev, "Device resume requested");
0667             break;
0668         case MCE_RSP_CMD_ILLEGAL:
0669             dev_dbg(dev, "Illegal PORT_SYS command");
0670             break;
0671         case MCE_RSP_EQWAKEVERSION:
0672             if (!out)
0673                 dev_dbg(dev, "Wake version, proto: 0x%02x, payload: 0x%02x, address: 0x%02x, version: 0x%02x",
0674                     data[0], data[1], data[2], data[3]);
0675             break;
0676         case MCE_RSP_GETPORTSTATUS:
0677             if (!out)
0678                 /* We use data1 + 1 here, to match hw labels */
0679                 dev_dbg(dev, "TX port %d: blaster is%s connected",
0680                      data[0] + 1, data[3] ? " not" : "");
0681             break;
0682         case MCE_CMD_FLASHLED:
0683             dev_dbg(dev, "Attempting to flash LED");
0684             break;
0685         default:
0686             dev_dbg(dev, "Unknown command 0x%02x 0x%02x",
0687                  cmd, subcmd);
0688             break;
0689         }
0690         break;
0691     case MCE_CMD_PORT_IR:
0692         switch (subcmd) {
0693         case MCE_CMD_SIG_END:
0694             dev_dbg(dev, "End of signal");
0695             break;
0696         case MCE_CMD_PING:
0697             dev_dbg(dev, "Ping");
0698             break;
0699         case MCE_CMD_UNKNOWN:
0700             dev_dbg(dev, "Resp to 9f 05 of 0x%02x 0x%02x",
0701                 data[0], data[1]);
0702             break;
0703         case MCE_RSP_EQIRCFS:
0704             if (!data[0] && !data[1]) {
0705                 dev_dbg(dev, "%s: no carrier", inout);
0706                 break;
0707             }
0708             // prescaler should make sense
0709             if (data[0] > 8)
0710                 break;
0711             period = DIV_ROUND_CLOSEST((1U << data[0] * 2) *
0712                            (data[1] + 1), 10);
0713             if (!period)
0714                 break;
0715             carrier = USEC_PER_SEC / period;
0716             dev_dbg(dev, "%s carrier of %u Hz (period %uus)",
0717                  inout, carrier, period);
0718             break;
0719         case MCE_CMD_GETIRCFS:
0720             dev_dbg(dev, "Get carrier mode and freq");
0721             break;
0722         case MCE_RSP_EQIRTXPORTS:
0723             dev_dbg(dev, "%s transmit blaster mask of 0x%02x",
0724                  inout, data[0]);
0725             break;
0726         case MCE_RSP_EQIRTIMEOUT:
0727             /* value is in units of 50us, so x*50/1000 ms */
0728             period = ((data[0] << 8) | data[1]) *
0729                   MCE_TIME_UNIT / 1000;
0730             dev_dbg(dev, "%s receive timeout of %d ms",
0731                  inout, period);
0732             break;
0733         case MCE_CMD_GETIRTIMEOUT:
0734             dev_dbg(dev, "Get receive timeout");
0735             break;
0736         case MCE_CMD_GETIRTXPORTS:
0737             dev_dbg(dev, "Get transmit blaster mask");
0738             break;
0739         case MCE_RSP_EQIRRXPORTEN:
0740             dev_dbg(dev, "%s %s-range receive sensor in use",
0741                  inout, data[0] == 0x02 ? "short" : "long");
0742             break;
0743         case MCE_CMD_GETIRRXPORTEN:
0744         /* aka MCE_RSP_EQIRRXCFCNT */
0745             if (out)
0746                 dev_dbg(dev, "Get receive sensor");
0747             else
0748                 dev_dbg(dev, "RX carrier cycle count: %d",
0749                     ((data[0] << 8) | data[1]));
0750             break;
0751         case MCE_RSP_EQIRNUMPORTS:
0752             if (out)
0753                 break;
0754             dev_dbg(dev, "Num TX ports: %x, num RX ports: %x",
0755                 data[0], data[1]);
0756             break;
0757         case MCE_RSP_CMD_ILLEGAL:
0758             dev_dbg(dev, "Illegal PORT_IR command");
0759             break;
0760         case MCE_RSP_TX_TIMEOUT:
0761             dev_dbg(dev, "IR TX timeout (TX buffer underrun)");
0762             break;
0763         default:
0764             dev_dbg(dev, "Unknown command 0x%02x 0x%02x",
0765                  cmd, subcmd);
0766             break;
0767         }
0768         break;
0769     default:
0770         break;
0771     }
0772 #endif
0773 }
0774 
0775 /*
0776  * Schedule work that can't be done in interrupt handlers
0777  * (mceusb_dev_recv() and mce_write_callback()) nor tasklets.
0778  * Invokes mceusb_deferred_kevent() for recovering from
0779  * error events specified by the kevent bit field.
0780  */
0781 static void mceusb_defer_kevent(struct mceusb_dev *ir, int kevent)
0782 {
0783     set_bit(kevent, &ir->kevent_flags);
0784 
0785     if (test_bit(EVENT_RST_PEND, &ir->kevent_flags)) {
0786         dev_dbg(ir->dev, "kevent %d dropped pending USB Reset Device",
0787             kevent);
0788         return;
0789     }
0790 
0791     if (!schedule_work(&ir->kevent))
0792         dev_dbg(ir->dev, "kevent %d already scheduled", kevent);
0793     else
0794         dev_dbg(ir->dev, "kevent %d scheduled", kevent);
0795 }
0796 
0797 static void mce_write_callback(struct urb *urb)
0798 {
0799     if (!urb)
0800         return;
0801 
0802     complete(urb->context);
0803 }
0804 
0805 /*
0806  * Write (TX/send) data to MCE device USB endpoint out.
0807  * Used for IR blaster TX and MCE device commands.
0808  *
0809  * Return: The number of bytes written (> 0) or errno (< 0).
0810  */
0811 static int mce_write(struct mceusb_dev *ir, u8 *data, int size)
0812 {
0813     int ret;
0814     struct urb *urb;
0815     struct device *dev = ir->dev;
0816     unsigned char *buf_out;
0817     struct completion tx_done;
0818     unsigned long expire;
0819     unsigned long ret_wait;
0820 
0821     mceusb_dev_printdata(ir, data, size, 0, size, true);
0822 
0823     urb = usb_alloc_urb(0, GFP_KERNEL);
0824     if (unlikely(!urb)) {
0825         dev_err(dev, "Error: mce write couldn't allocate urb");
0826         return -ENOMEM;
0827     }
0828 
0829     buf_out = kmalloc(size, GFP_KERNEL);
0830     if (!buf_out) {
0831         usb_free_urb(urb);
0832         return -ENOMEM;
0833     }
0834 
0835     init_completion(&tx_done);
0836 
0837     /* outbound data */
0838     if (usb_endpoint_xfer_int(ir->usb_ep_out))
0839         usb_fill_int_urb(urb, ir->usbdev, ir->pipe_out,
0840                  buf_out, size, mce_write_callback, &tx_done,
0841                  ir->usb_ep_out->bInterval);
0842     else
0843         usb_fill_bulk_urb(urb, ir->usbdev, ir->pipe_out,
0844                   buf_out, size, mce_write_callback, &tx_done);
0845     memcpy(buf_out, data, size);
0846 
0847     ret = usb_submit_urb(urb, GFP_KERNEL);
0848     if (ret) {
0849         dev_err(dev, "Error: mce write submit urb error = %d", ret);
0850         kfree(buf_out);
0851         usb_free_urb(urb);
0852         return ret;
0853     }
0854 
0855     expire = msecs_to_jiffies(USB_TX_TIMEOUT);
0856     ret_wait = wait_for_completion_timeout(&tx_done, expire);
0857     if (!ret_wait) {
0858         dev_err(dev, "Error: mce write timed out (expire = %lu (%dms))",
0859             expire, USB_TX_TIMEOUT);
0860         usb_kill_urb(urb);
0861         ret = (urb->status == -ENOENT ? -ETIMEDOUT : urb->status);
0862     } else {
0863         ret = urb->status;
0864     }
0865     if (ret >= 0)
0866         ret = urb->actual_length;   /* bytes written */
0867 
0868     switch (urb->status) {
0869     /* success */
0870     case 0:
0871         break;
0872 
0873     case -ECONNRESET:
0874     case -ENOENT:
0875     case -EILSEQ:
0876     case -ESHUTDOWN:
0877         break;
0878 
0879     case -EPIPE:
0880         dev_err(ir->dev, "Error: mce write urb status = %d (TX HALT)",
0881             urb->status);
0882         mceusb_defer_kevent(ir, EVENT_TX_HALT);
0883         break;
0884 
0885     default:
0886         dev_err(ir->dev, "Error: mce write urb status = %d",
0887             urb->status);
0888         break;
0889     }
0890 
0891     dev_dbg(dev, "tx done status = %d (wait = %lu, expire = %lu (%dms), urb->actual_length = %d, urb->status = %d)",
0892         ret, ret_wait, expire, USB_TX_TIMEOUT,
0893         urb->actual_length, urb->status);
0894 
0895     kfree(buf_out);
0896     usb_free_urb(urb);
0897 
0898     return ret;
0899 }
0900 
0901 static void mce_command_out(struct mceusb_dev *ir, u8 *data, int size)
0902 {
0903     int rsize = sizeof(DEVICE_RESUME);
0904 
0905     if (ir->need_reset) {
0906         ir->need_reset = false;
0907         mce_write(ir, DEVICE_RESUME, rsize);
0908         msleep(10);
0909     }
0910 
0911     mce_write(ir, data, size);
0912     msleep(10);
0913 }
0914 
0915 /*
0916  * Transmit IR out the MCE device IR blaster port(s).
0917  *
0918  * Convert IR pulse/space sequence from LIRC to MCE format.
0919  * Break up a long IR sequence into multiple parts (MCE IR data packets).
0920  *
0921  * u32 txbuf[] consists of IR pulse, space, ..., and pulse times in usec.
0922  * Pulses and spaces are implicit by their position.
0923  * The first IR sample, txbuf[0], is always a pulse.
0924  *
0925  * u8 irbuf[] consists of multiple IR data packets for the MCE device.
0926  * A packet is 1 u8 MCE_IRDATA_HEADER and up to 30 u8 IR samples.
0927  * An IR sample is 1-bit pulse/space flag with 7-bit time
0928  * in MCE time units (50usec).
0929  *
0930  * Return: The number of IR samples sent (> 0) or errno (< 0).
0931  */
0932 static int mceusb_tx_ir(struct rc_dev *dev, unsigned *txbuf, unsigned count)
0933 {
0934     struct mceusb_dev *ir = dev->priv;
0935     u8 cmdbuf[3] = { MCE_CMD_PORT_IR, MCE_CMD_SETIRTXPORTS, 0x00 };
0936     u8 irbuf[MCE_IRBUF_SIZE];
0937     int ircount = 0;
0938     unsigned int irsample;
0939     int i, length, ret;
0940 
0941     /* Send the set TX ports command */
0942     cmdbuf[2] = ir->tx_mask;
0943     mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
0944 
0945     /* Generate mce IR data packet */
0946     for (i = 0; i < count; i++) {
0947         irsample = txbuf[i] / MCE_TIME_UNIT;
0948 
0949         /* loop to support long pulses/spaces > 6350us (127*50us) */
0950         while (irsample > 0) {
0951             /* Insert IR header every 30th entry */
0952             if (ircount % MCE_PACKET_SIZE == 0) {
0953                 /* Room for IR header and one IR sample? */
0954                 if (ircount >= MCE_IRBUF_SIZE - 1) {
0955                     /* Send near full buffer */
0956                     ret = mce_write(ir, irbuf, ircount);
0957                     if (ret < 0)
0958                         return ret;
0959                     ircount = 0;
0960                 }
0961                 irbuf[ircount++] = MCE_IRDATA_HEADER;
0962             }
0963 
0964             /* Insert IR sample */
0965             if (irsample <= MCE_MAX_PULSE_LENGTH) {
0966                 irbuf[ircount] = irsample;
0967                 irsample = 0;
0968             } else {
0969                 irbuf[ircount] = MCE_MAX_PULSE_LENGTH;
0970                 irsample -= MCE_MAX_PULSE_LENGTH;
0971             }
0972             /*
0973              * Even i = IR pulse
0974              * Odd  i = IR space
0975              */
0976             irbuf[ircount] |= (i & 1 ? 0 : MCE_PULSE_BIT);
0977             ircount++;
0978 
0979             /* IR buffer full? */
0980             if (ircount >= MCE_IRBUF_SIZE) {
0981                 /* Fix packet length in last header */
0982                 length = ircount % MCE_PACKET_SIZE;
0983                 if (length > 0)
0984                     irbuf[ircount - length] -=
0985                         MCE_PACKET_SIZE - length;
0986                 /* Send full buffer */
0987                 ret = mce_write(ir, irbuf, ircount);
0988                 if (ret < 0)
0989                     return ret;
0990                 ircount = 0;
0991             }
0992         }
0993     } /* after for loop, 0 <= ircount < MCE_IRBUF_SIZE */
0994 
0995     /* Fix packet length in last header */
0996     length = ircount % MCE_PACKET_SIZE;
0997     if (length > 0)
0998         irbuf[ircount - length] -= MCE_PACKET_SIZE - length;
0999 
1000     /* Append IR trailer (0x80) to final partial (or empty) IR buffer */
1001     irbuf[ircount++] = MCE_IRDATA_TRAILER;
1002 
1003     /* Send final buffer */
1004     ret = mce_write(ir, irbuf, ircount);
1005     if (ret < 0)
1006         return ret;
1007 
1008     return count;
1009 }
1010 
1011 /* Sets active IR outputs -- mce devices typically have two */
1012 static int mceusb_set_tx_mask(struct rc_dev *dev, u32 mask)
1013 {
1014     struct mceusb_dev *ir = dev->priv;
1015 
1016     /* return number of transmitters */
1017     int emitters = ir->num_txports ? ir->num_txports : 2;
1018 
1019     if (mask >= (1 << emitters))
1020         return emitters;
1021 
1022     if (ir->flags.tx_mask_normal)
1023         ir->tx_mask = mask;
1024     else
1025         ir->tx_mask = (mask != MCE_DEFAULT_TX_MASK ?
1026                 mask ^ MCE_DEFAULT_TX_MASK : mask) << 1;
1027 
1028     return 0;
1029 }
1030 
1031 /* Sets the send carrier frequency and mode */
1032 static int mceusb_set_tx_carrier(struct rc_dev *dev, u32 carrier)
1033 {
1034     struct mceusb_dev *ir = dev->priv;
1035     int clk = 10000000;
1036     int prescaler = 0, divisor = 0;
1037     unsigned char cmdbuf[4] = { MCE_CMD_PORT_IR,
1038                     MCE_CMD_SETIRCFS, 0x00, 0x00 };
1039 
1040     /* Carrier has changed */
1041     if (ir->carrier != carrier) {
1042 
1043         if (carrier == 0) {
1044             ir->carrier = carrier;
1045             cmdbuf[2] = MCE_CMD_SIG_END;
1046             cmdbuf[3] = MCE_IRDATA_TRAILER;
1047             dev_dbg(ir->dev, "disabling carrier modulation");
1048             mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
1049             return 0;
1050         }
1051 
1052         for (prescaler = 0; prescaler < 4; ++prescaler) {
1053             divisor = (clk >> (2 * prescaler)) / carrier;
1054             if (divisor <= 0xff) {
1055                 ir->carrier = carrier;
1056                 cmdbuf[2] = prescaler;
1057                 cmdbuf[3] = divisor;
1058                 dev_dbg(ir->dev, "requesting %u HZ carrier",
1059                                 carrier);
1060 
1061                 /* Transmit new carrier to mce device */
1062                 mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
1063                 return 0;
1064             }
1065         }
1066 
1067         return -EINVAL;
1068 
1069     }
1070 
1071     return 0;
1072 }
1073 
1074 static int mceusb_set_timeout(struct rc_dev *dev, unsigned int timeout)
1075 {
1076     u8 cmdbuf[4] = { MCE_CMD_PORT_IR, MCE_CMD_SETIRTIMEOUT, 0, 0 };
1077     struct mceusb_dev *ir = dev->priv;
1078     unsigned int units;
1079 
1080     units = DIV_ROUND_CLOSEST(timeout, MCE_TIME_UNIT);
1081 
1082     cmdbuf[2] = units >> 8;
1083     cmdbuf[3] = units;
1084 
1085     mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
1086 
1087     /* get receiver timeout value */
1088     mce_command_out(ir, GET_RX_TIMEOUT, sizeof(GET_RX_TIMEOUT));
1089 
1090     return 0;
1091 }
1092 
1093 /*
1094  * Select or deselect the 2nd receiver port.
1095  * Second receiver is learning mode, wide-band, short-range receiver.
1096  * Only one receiver (long or short range) may be active at a time.
1097  */
1098 static int mceusb_set_rx_wideband(struct rc_dev *dev, int enable)
1099 {
1100     struct mceusb_dev *ir = dev->priv;
1101     unsigned char cmdbuf[3] = { MCE_CMD_PORT_IR,
1102                     MCE_CMD_SETIRRXPORTEN, 0x00 };
1103 
1104     dev_dbg(ir->dev, "select %s-range receive sensor",
1105         enable ? "short" : "long");
1106     if (enable) {
1107         ir->wideband_rx_enabled = true;
1108         cmdbuf[2] = 2;  /* port 2 is short range receiver */
1109     } else {
1110         ir->wideband_rx_enabled = false;
1111         cmdbuf[2] = 1;  /* port 1 is long range receiver */
1112     }
1113     mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
1114     /* response from device sets ir->learning_active */
1115 
1116     return 0;
1117 }
1118 
1119 /*
1120  * Enable/disable receiver carrier frequency pass through reporting.
1121  * Only the short-range receiver has carrier frequency measuring capability.
1122  * Implicitly select this receiver when enabling carrier frequency reporting.
1123  */
1124 static int mceusb_set_rx_carrier_report(struct rc_dev *dev, int enable)
1125 {
1126     struct mceusb_dev *ir = dev->priv;
1127     unsigned char cmdbuf[3] = { MCE_CMD_PORT_IR,
1128                     MCE_CMD_SETIRRXPORTEN, 0x00 };
1129 
1130     dev_dbg(ir->dev, "%s short-range receiver carrier reporting",
1131         enable ? "enable" : "disable");
1132     if (enable) {
1133         ir->carrier_report_enabled = true;
1134         if (!ir->learning_active) {
1135             cmdbuf[2] = 2;  /* port 2 is short range receiver */
1136             mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
1137         }
1138     } else {
1139         ir->carrier_report_enabled = false;
1140         /*
1141          * Revert to normal (long-range) receiver only if the
1142          * wideband (short-range) receiver wasn't explicitly
1143          * enabled.
1144          */
1145         if (ir->learning_active && !ir->wideband_rx_enabled) {
1146             cmdbuf[2] = 1;  /* port 1 is long range receiver */
1147             mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
1148         }
1149     }
1150 
1151     return 0;
1152 }
1153 
1154 /*
1155  * Handle PORT_SYS/IR command response received from the MCE device.
1156  *
1157  * Assumes single response with all its data (not truncated)
1158  * in buf_in[]. The response itself determines its total length
1159  * (mceusb_cmd_datasize() + 2) and hence the minimum size of buf_in[].
1160  *
1161  * We don't do anything but print debug spew for many of the command bits
1162  * we receive from the hardware, but some of them are useful information
1163  * we want to store so that we can use them.
1164  */
1165 static void mceusb_handle_command(struct mceusb_dev *ir, u8 *buf_in)
1166 {
1167     u8 cmd = buf_in[0];
1168     u8 subcmd = buf_in[1];
1169     u8 *hi = &buf_in[2];        /* read only when required */
1170     u8 *lo = &buf_in[3];        /* read only when required */
1171     struct ir_raw_event rawir = {};
1172     u32 carrier_cycles;
1173     u32 cycles_fix;
1174 
1175     if (cmd == MCE_CMD_PORT_SYS) {
1176         switch (subcmd) {
1177         /* the one and only 5-byte return value command */
1178         case MCE_RSP_GETPORTSTATUS:
1179             if (buf_in[5] == 0 && *hi < 8)
1180                 ir->txports_cabled |= 1 << *hi;
1181             break;
1182 
1183         /* 1-byte return value commands */
1184         case MCE_RSP_EQEMVER:
1185             ir->emver = *hi;
1186             break;
1187 
1188         /* No return value commands */
1189         case MCE_RSP_CMD_ILLEGAL:
1190             ir->need_reset = true;
1191             break;
1192 
1193         default:
1194             break;
1195         }
1196 
1197         return;
1198     }
1199 
1200     if (cmd != MCE_CMD_PORT_IR)
1201         return;
1202 
1203     switch (subcmd) {
1204     /* 2-byte return value commands */
1205     case MCE_RSP_EQIRTIMEOUT:
1206         ir->rc->timeout = (*hi << 8 | *lo) * MCE_TIME_UNIT;
1207         break;
1208     case MCE_RSP_EQIRNUMPORTS:
1209         ir->num_txports = *hi;
1210         ir->num_rxports = *lo;
1211         break;
1212     case MCE_RSP_EQIRRXCFCNT:
1213         /*
1214          * The carrier cycle counter can overflow and wrap around
1215          * without notice from the device. So frequency measurement
1216          * will be inaccurate with long duration IR.
1217          *
1218          * The long-range (non learning) receiver always reports
1219          * zero count so we always ignore its report.
1220          */
1221         if (ir->carrier_report_enabled && ir->learning_active &&
1222             ir->pulse_tunit > 0) {
1223             carrier_cycles = (*hi << 8 | *lo);
1224             /*
1225              * Adjust carrier cycle count by adding
1226              * 1 missed count per pulse "on"
1227              */
1228             cycles_fix = ir->flags.rx2 == 2 ? ir->pulse_count : 0;
1229             rawir.carrier_report = 1;
1230             rawir.carrier = (1000000u / MCE_TIME_UNIT) *
1231                     (carrier_cycles + cycles_fix) /
1232                     ir->pulse_tunit;
1233             dev_dbg(ir->dev, "RX carrier frequency %u Hz (pulse count = %u, cycles = %u, duration = %u, rx2 = %u)",
1234                 rawir.carrier, ir->pulse_count, carrier_cycles,
1235                 ir->pulse_tunit, ir->flags.rx2);
1236             ir_raw_event_store(ir->rc, &rawir);
1237         }
1238         break;
1239 
1240     /* 1-byte return value commands */
1241     case MCE_RSP_EQIRTXPORTS:
1242         ir->tx_mask = *hi;
1243         break;
1244     case MCE_RSP_EQIRRXPORTEN:
1245         ir->learning_active = ((*hi & 0x02) == 0x02);
1246         if (ir->rxports_active != *hi) {
1247             dev_info(ir->dev, "%s-range (0x%x) receiver active",
1248                  ir->learning_active ? "short" : "long", *hi);
1249             ir->rxports_active = *hi;
1250         }
1251         break;
1252 
1253     /* No return value commands */
1254     case MCE_RSP_CMD_ILLEGAL:
1255     case MCE_RSP_TX_TIMEOUT:
1256         ir->need_reset = true;
1257         break;
1258 
1259     default:
1260         break;
1261     }
1262 }
1263 
1264 static void mceusb_process_ir_data(struct mceusb_dev *ir, int buf_len)
1265 {
1266     struct ir_raw_event rawir = {};
1267     bool event = false;
1268     int i = 0;
1269 
1270     /* skip meaningless 0xb1 0x60 header bytes on orig receiver */
1271     if (ir->flags.microsoft_gen1)
1272         i = 2;
1273 
1274     /* if there's no data, just return now */
1275     if (buf_len <= i)
1276         return;
1277 
1278     for (; i < buf_len; i++) {
1279         switch (ir->parser_state) {
1280         case SUBCMD:
1281             ir->rem = mceusb_cmd_datasize(ir->cmd, ir->buf_in[i]);
1282             mceusb_dev_printdata(ir, ir->buf_in, buf_len, i - 1,
1283                          ir->rem + 2, false);
1284             if (i + ir->rem < buf_len)
1285                 mceusb_handle_command(ir, &ir->buf_in[i - 1]);
1286             ir->parser_state = CMD_DATA;
1287             break;
1288         case PARSE_IRDATA:
1289             ir->rem--;
1290             rawir.pulse = ((ir->buf_in[i] & MCE_PULSE_BIT) != 0);
1291             rawir.duration = (ir->buf_in[i] & MCE_PULSE_MASK);
1292             if (unlikely(!rawir.duration)) {
1293                 dev_dbg(ir->dev, "nonsensical irdata %02x with duration 0",
1294                     ir->buf_in[i]);
1295                 break;
1296             }
1297             if (rawir.pulse) {
1298                 ir->pulse_tunit += rawir.duration;
1299                 ir->pulse_count++;
1300             }
1301             rawir.duration *= MCE_TIME_UNIT;
1302 
1303             dev_dbg(ir->dev, "Storing %s %u us (%02x)",
1304                 rawir.pulse ? "pulse" : "space",
1305                 rawir.duration, ir->buf_in[i]);
1306 
1307             if (ir_raw_event_store_with_filter(ir->rc, &rawir))
1308                 event = true;
1309             break;
1310         case CMD_DATA:
1311             ir->rem--;
1312             break;
1313         case CMD_HEADER:
1314             ir->cmd = ir->buf_in[i];
1315             if ((ir->cmd == MCE_CMD_PORT_IR) ||
1316                 ((ir->cmd & MCE_PORT_MASK) !=
1317                  MCE_COMMAND_IRDATA)) {
1318                 /*
1319                  * got PORT_SYS, PORT_IR, or unknown
1320                  * command response prefix
1321                  */
1322                 ir->parser_state = SUBCMD;
1323                 continue;
1324             }
1325             /*
1326              * got IR data prefix (0x80 + num_bytes)
1327              * decode MCE packets of the form {0x83, AA, BB, CC}
1328              * IR data packets can span USB messages
1329              */
1330             ir->rem = (ir->cmd & MCE_PACKET_LENGTH_MASK);
1331             mceusb_dev_printdata(ir, ir->buf_in, buf_len,
1332                          i, ir->rem + 1, false);
1333             if (ir->rem) {
1334                 ir->parser_state = PARSE_IRDATA;
1335             } else {
1336                 struct ir_raw_event ev = {
1337                     .timeout = 1,
1338                     .duration = ir->rc->timeout
1339                 };
1340 
1341                 if (ir_raw_event_store_with_filter(ir->rc,
1342                                    &ev))
1343                     event = true;
1344                 ir->pulse_tunit = 0;
1345                 ir->pulse_count = 0;
1346             }
1347             break;
1348         }
1349 
1350         if (ir->parser_state != CMD_HEADER && !ir->rem)
1351             ir->parser_state = CMD_HEADER;
1352     }
1353 
1354     /*
1355      * Accept IR data spanning multiple rx buffers.
1356      * Reject MCE command response spanning multiple rx buffers.
1357      */
1358     if (ir->parser_state != PARSE_IRDATA || !ir->rem)
1359         ir->parser_state = CMD_HEADER;
1360 
1361     if (event) {
1362         dev_dbg(ir->dev, "processed IR data");
1363         ir_raw_event_handle(ir->rc);
1364     }
1365 }
1366 
1367 static void mceusb_dev_recv(struct urb *urb)
1368 {
1369     struct mceusb_dev *ir;
1370 
1371     if (!urb)
1372         return;
1373 
1374     ir = urb->context;
1375     if (!ir) {
1376         usb_unlink_urb(urb);
1377         return;
1378     }
1379 
1380     switch (urb->status) {
1381     /* success */
1382     case 0:
1383         mceusb_process_ir_data(ir, urb->actual_length);
1384         break;
1385 
1386     case -ECONNRESET:
1387     case -ENOENT:
1388     case -EILSEQ:
1389     case -EPROTO:
1390     case -ESHUTDOWN:
1391         usb_unlink_urb(urb);
1392         return;
1393 
1394     case -EPIPE:
1395         dev_err(ir->dev, "Error: urb status = %d (RX HALT)",
1396             urb->status);
1397         mceusb_defer_kevent(ir, EVENT_RX_HALT);
1398         return;
1399 
1400     default:
1401         dev_err(ir->dev, "Error: urb status = %d", urb->status);
1402         break;
1403     }
1404 
1405     usb_submit_urb(urb, GFP_ATOMIC);
1406 }
1407 
1408 static void mceusb_get_emulator_version(struct mceusb_dev *ir)
1409 {
1410     /* If we get no reply or an illegal command reply, its ver 1, says MS */
1411     ir->emver = 1;
1412     mce_command_out(ir, GET_EMVER, sizeof(GET_EMVER));
1413 }
1414 
1415 static void mceusb_gen1_init(struct mceusb_dev *ir)
1416 {
1417     int ret;
1418     struct device *dev = ir->dev;
1419     char data[USB_CTRL_MSG_SZ];
1420 
1421     /*
1422      * This is a strange one. Windows issues a set address to the device
1423      * on the receive control pipe and expect a certain value pair back
1424      */
1425     ret = usb_control_msg_recv(ir->usbdev, 0, USB_REQ_SET_ADDRESS,
1426                    USB_DIR_IN | USB_TYPE_VENDOR,
1427                    0, 0, data, USB_CTRL_MSG_SZ, 3000,
1428                    GFP_KERNEL);
1429     dev_dbg(dev, "set address - ret = %d", ret);
1430     dev_dbg(dev, "set address - data[0] = %d, data[1] = %d",
1431                         data[0], data[1]);
1432 
1433     /* set feature: bit rate 38400 bps */
1434     ret = usb_control_msg_send(ir->usbdev, 0,
1435                    USB_REQ_SET_FEATURE, USB_TYPE_VENDOR,
1436                    0xc04e, 0x0000, NULL, 0, 3000, GFP_KERNEL);
1437 
1438     dev_dbg(dev, "set feature - ret = %d", ret);
1439 
1440     /* bRequest 4: set char length to 8 bits */
1441     ret = usb_control_msg_send(ir->usbdev, 0,
1442                    4, USB_TYPE_VENDOR,
1443                    0x0808, 0x0000, NULL, 0, 3000, GFP_KERNEL);
1444     dev_dbg(dev, "set char length - retB = %d", ret);
1445 
1446     /* bRequest 2: set handshaking to use DTR/DSR */
1447     ret = usb_control_msg_send(ir->usbdev, 0,
1448                    2, USB_TYPE_VENDOR,
1449                    0x0000, 0x0100, NULL, 0, 3000, GFP_KERNEL);
1450     dev_dbg(dev, "set handshake  - retC = %d", ret);
1451 
1452     /* device resume */
1453     mce_command_out(ir, DEVICE_RESUME, sizeof(DEVICE_RESUME));
1454 
1455     /* get hw/sw revision? */
1456     mce_command_out(ir, GET_REVISION, sizeof(GET_REVISION));
1457 }
1458 
1459 static void mceusb_gen2_init(struct mceusb_dev *ir)
1460 {
1461     /* device resume */
1462     mce_command_out(ir, DEVICE_RESUME, sizeof(DEVICE_RESUME));
1463 
1464     /* get wake version (protocol, key, address) */
1465     mce_command_out(ir, GET_WAKEVERSION, sizeof(GET_WAKEVERSION));
1466 
1467     /* unknown what this one actually returns... */
1468     mce_command_out(ir, GET_UNKNOWN2, sizeof(GET_UNKNOWN2));
1469 }
1470 
1471 static void mceusb_get_parameters(struct mceusb_dev *ir)
1472 {
1473     int i;
1474     unsigned char cmdbuf[3] = { MCE_CMD_PORT_SYS,
1475                     MCE_CMD_GETPORTSTATUS, 0x00 };
1476 
1477     /* defaults, if the hardware doesn't support querying */
1478     ir->num_txports = 2;
1479     ir->num_rxports = 2;
1480 
1481     /* get number of tx and rx ports */
1482     mce_command_out(ir, GET_NUM_PORTS, sizeof(GET_NUM_PORTS));
1483 
1484     /* get the carrier and frequency */
1485     mce_command_out(ir, GET_CARRIER_FREQ, sizeof(GET_CARRIER_FREQ));
1486 
1487     if (ir->num_txports && !ir->flags.no_tx)
1488         /* get the transmitter bitmask */
1489         mce_command_out(ir, GET_TX_BITMASK, sizeof(GET_TX_BITMASK));
1490 
1491     /* get receiver timeout value */
1492     mce_command_out(ir, GET_RX_TIMEOUT, sizeof(GET_RX_TIMEOUT));
1493 
1494     /* get receiver sensor setting */
1495     mce_command_out(ir, GET_RX_SENSOR, sizeof(GET_RX_SENSOR));
1496 
1497     for (i = 0; i < ir->num_txports; i++) {
1498         cmdbuf[2] = i;
1499         mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
1500     }
1501 }
1502 
1503 static void mceusb_flash_led(struct mceusb_dev *ir)
1504 {
1505     if (ir->emver < 2)
1506         return;
1507 
1508     mce_command_out(ir, FLASH_LED, sizeof(FLASH_LED));
1509 }
1510 
1511 /*
1512  * Workqueue function
1513  * for resetting or recovering device after occurrence of error events
1514  * specified in ir->kevent bit field.
1515  * Function runs (via schedule_work()) in non-interrupt context, for
1516  * calls here (such as usb_clear_halt()) requiring non-interrupt context.
1517  */
1518 static void mceusb_deferred_kevent(struct work_struct *work)
1519 {
1520     struct mceusb_dev *ir =
1521         container_of(work, struct mceusb_dev, kevent);
1522     int status;
1523 
1524     dev_err(ir->dev, "kevent handler called (flags 0x%lx)",
1525         ir->kevent_flags);
1526 
1527     if (test_bit(EVENT_RST_PEND, &ir->kevent_flags)) {
1528         dev_err(ir->dev, "kevent handler canceled pending USB Reset Device");
1529         return;
1530     }
1531 
1532     if (test_bit(EVENT_RX_HALT, &ir->kevent_flags)) {
1533         usb_unlink_urb(ir->urb_in);
1534         status = usb_clear_halt(ir->usbdev, ir->pipe_in);
1535         dev_err(ir->dev, "rx clear halt status = %d", status);
1536         if (status < 0) {
1537             /*
1538              * Unable to clear RX halt/stall.
1539              * Will need to call usb_reset_device().
1540              */
1541             dev_err(ir->dev,
1542                 "stuck RX HALT state requires USB Reset Device to clear");
1543             usb_queue_reset_device(ir->usbintf);
1544             set_bit(EVENT_RST_PEND, &ir->kevent_flags);
1545             clear_bit(EVENT_RX_HALT, &ir->kevent_flags);
1546 
1547             /* Cancel all other error events and handlers */
1548             clear_bit(EVENT_TX_HALT, &ir->kevent_flags);
1549             return;
1550         }
1551         clear_bit(EVENT_RX_HALT, &ir->kevent_flags);
1552         status = usb_submit_urb(ir->urb_in, GFP_KERNEL);
1553         if (status < 0) {
1554             dev_err(ir->dev, "rx unhalt submit urb error = %d",
1555                 status);
1556         }
1557     }
1558 
1559     if (test_bit(EVENT_TX_HALT, &ir->kevent_flags)) {
1560         status = usb_clear_halt(ir->usbdev, ir->pipe_out);
1561         dev_err(ir->dev, "tx clear halt status = %d", status);
1562         if (status < 0) {
1563             /*
1564              * Unable to clear TX halt/stall.
1565              * Will need to call usb_reset_device().
1566              */
1567             dev_err(ir->dev,
1568                 "stuck TX HALT state requires USB Reset Device to clear");
1569             usb_queue_reset_device(ir->usbintf);
1570             set_bit(EVENT_RST_PEND, &ir->kevent_flags);
1571             clear_bit(EVENT_TX_HALT, &ir->kevent_flags);
1572 
1573             /* Cancel all other error events and handlers */
1574             clear_bit(EVENT_RX_HALT, &ir->kevent_flags);
1575             return;
1576         }
1577         clear_bit(EVENT_TX_HALT, &ir->kevent_flags);
1578     }
1579 }
1580 
1581 static struct rc_dev *mceusb_init_rc_dev(struct mceusb_dev *ir)
1582 {
1583     struct usb_device *udev = ir->usbdev;
1584     struct device *dev = ir->dev;
1585     struct rc_dev *rc;
1586     int ret;
1587 
1588     rc = rc_allocate_device(RC_DRIVER_IR_RAW);
1589     if (!rc) {
1590         dev_err(dev, "remote dev allocation failed");
1591         goto out;
1592     }
1593 
1594     snprintf(ir->name, sizeof(ir->name), "%s (%04x:%04x)",
1595          mceusb_model[ir->model].name ?
1596             mceusb_model[ir->model].name :
1597             "Media Center Ed. eHome Infrared Remote Transceiver",
1598          le16_to_cpu(ir->usbdev->descriptor.idVendor),
1599          le16_to_cpu(ir->usbdev->descriptor.idProduct));
1600 
1601     usb_make_path(ir->usbdev, ir->phys, sizeof(ir->phys));
1602 
1603     rc->device_name = ir->name;
1604     rc->input_phys = ir->phys;
1605     usb_to_input_id(ir->usbdev, &rc->input_id);
1606     rc->dev.parent = dev;
1607     rc->priv = ir;
1608     rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
1609     rc->rx_resolution = MCE_TIME_UNIT;
1610     rc->min_timeout = MCE_TIME_UNIT;
1611     rc->timeout = MS_TO_US(100);
1612     if (!mceusb_model[ir->model].broken_irtimeout) {
1613         rc->s_timeout = mceusb_set_timeout;
1614         rc->max_timeout = 10 * IR_DEFAULT_TIMEOUT;
1615     } else {
1616         /*
1617          * If we can't set the timeout using CMD_SETIRTIMEOUT, we can
1618          * rely on software timeouts for timeouts < 100ms.
1619          */
1620         rc->max_timeout = rc->timeout;
1621     }
1622     if (!ir->flags.no_tx) {
1623         rc->s_tx_mask = mceusb_set_tx_mask;
1624         rc->s_tx_carrier = mceusb_set_tx_carrier;
1625         rc->tx_ir = mceusb_tx_ir;
1626     }
1627     if (ir->flags.rx2 > 0) {
1628         rc->s_wideband_receiver = mceusb_set_rx_wideband;
1629         rc->s_carrier_report = mceusb_set_rx_carrier_report;
1630     }
1631     rc->driver_name = DRIVER_NAME;
1632 
1633     switch (le16_to_cpu(udev->descriptor.idVendor)) {
1634     case VENDOR_HAUPPAUGE:
1635         rc->map_name = RC_MAP_HAUPPAUGE;
1636         break;
1637     case VENDOR_PCTV:
1638         rc->map_name = RC_MAP_PINNACLE_PCTV_HD;
1639         break;
1640     default:
1641         rc->map_name = RC_MAP_RC6_MCE;
1642     }
1643     if (mceusb_model[ir->model].rc_map)
1644         rc->map_name = mceusb_model[ir->model].rc_map;
1645 
1646     ret = rc_register_device(rc);
1647     if (ret < 0) {
1648         dev_err(dev, "remote dev registration failed");
1649         goto out;
1650     }
1651 
1652     return rc;
1653 
1654 out:
1655     rc_free_device(rc);
1656     return NULL;
1657 }
1658 
1659 static int mceusb_dev_probe(struct usb_interface *intf,
1660                 const struct usb_device_id *id)
1661 {
1662     struct usb_device *dev = interface_to_usbdev(intf);
1663     struct usb_host_interface *idesc;
1664     struct usb_endpoint_descriptor *ep = NULL;
1665     struct usb_endpoint_descriptor *ep_in = NULL;
1666     struct usb_endpoint_descriptor *ep_out = NULL;
1667     struct mceusb_dev *ir = NULL;
1668     int pipe, maxp, i, res;
1669     char buf[63], name[128] = "";
1670     enum mceusb_model_type model = id->driver_info;
1671     bool is_gen3;
1672     bool is_microsoft_gen1;
1673     bool tx_mask_normal;
1674     int ir_intfnum;
1675 
1676     dev_dbg(&intf->dev, "%s called", __func__);
1677 
1678     idesc  = intf->cur_altsetting;
1679 
1680     is_gen3 = mceusb_model[model].mce_gen3;
1681     is_microsoft_gen1 = mceusb_model[model].mce_gen1;
1682     tx_mask_normal = mceusb_model[model].tx_mask_normal;
1683     ir_intfnum = mceusb_model[model].ir_intfnum;
1684 
1685     /* There are multi-function devices with non-IR interfaces */
1686     if (idesc->desc.bInterfaceNumber != ir_intfnum)
1687         return -ENODEV;
1688 
1689     /* step through the endpoints to find first bulk in and out endpoint */
1690     for (i = 0; i < idesc->desc.bNumEndpoints; ++i) {
1691         ep = &idesc->endpoint[i].desc;
1692 
1693         if (ep_in == NULL) {
1694             if (usb_endpoint_is_bulk_in(ep)) {
1695                 ep_in = ep;
1696                 dev_dbg(&intf->dev, "acceptable bulk inbound endpoint found\n");
1697             } else if (usb_endpoint_is_int_in(ep)) {
1698                 ep_in = ep;
1699                 ep_in->bInterval = 1;
1700                 dev_dbg(&intf->dev, "acceptable interrupt inbound endpoint found\n");
1701             }
1702         }
1703 
1704         if (ep_out == NULL) {
1705             if (usb_endpoint_is_bulk_out(ep)) {
1706                 ep_out = ep;
1707                 dev_dbg(&intf->dev, "acceptable bulk outbound endpoint found\n");
1708             } else if (usb_endpoint_is_int_out(ep)) {
1709                 ep_out = ep;
1710                 ep_out->bInterval = 1;
1711                 dev_dbg(&intf->dev, "acceptable interrupt outbound endpoint found\n");
1712             }
1713         }
1714     }
1715     if (!ep_in || !ep_out) {
1716         dev_dbg(&intf->dev, "required endpoints not found\n");
1717         return -ENODEV;
1718     }
1719 
1720     if (usb_endpoint_xfer_int(ep_in))
1721         pipe = usb_rcvintpipe(dev, ep_in->bEndpointAddress);
1722     else
1723         pipe = usb_rcvbulkpipe(dev, ep_in->bEndpointAddress);
1724     maxp = usb_maxpacket(dev, pipe);
1725 
1726     ir = kzalloc(sizeof(struct mceusb_dev), GFP_KERNEL);
1727     if (!ir)
1728         goto mem_alloc_fail;
1729 
1730     ir->pipe_in = pipe;
1731     ir->buf_in = usb_alloc_coherent(dev, maxp, GFP_KERNEL, &ir->dma_in);
1732     if (!ir->buf_in)
1733         goto buf_in_alloc_fail;
1734 
1735     ir->urb_in = usb_alloc_urb(0, GFP_KERNEL);
1736     if (!ir->urb_in)
1737         goto urb_in_alloc_fail;
1738 
1739     ir->usbintf = intf;
1740     ir->usbdev = usb_get_dev(dev);
1741     ir->dev = &intf->dev;
1742     ir->len_in = maxp;
1743     ir->flags.microsoft_gen1 = is_microsoft_gen1;
1744     ir->flags.tx_mask_normal = tx_mask_normal;
1745     ir->flags.no_tx = mceusb_model[model].no_tx;
1746     ir->flags.rx2 = mceusb_model[model].rx2;
1747     ir->model = model;
1748 
1749     /* Saving usb interface data for use by the transmitter routine */
1750     ir->usb_ep_out = ep_out;
1751     if (usb_endpoint_xfer_int(ep_out))
1752         ir->pipe_out = usb_sndintpipe(ir->usbdev,
1753                           ep_out->bEndpointAddress);
1754     else
1755         ir->pipe_out = usb_sndbulkpipe(ir->usbdev,
1756                            ep_out->bEndpointAddress);
1757 
1758     if (dev->descriptor.iManufacturer
1759         && usb_string(dev, dev->descriptor.iManufacturer,
1760               buf, sizeof(buf)) > 0)
1761         strscpy(name, buf, sizeof(name));
1762     if (dev->descriptor.iProduct
1763         && usb_string(dev, dev->descriptor.iProduct,
1764               buf, sizeof(buf)) > 0)
1765         snprintf(name + strlen(name), sizeof(name) - strlen(name),
1766              " %s", buf);
1767 
1768     /*
1769      * Initialize async USB error handler before registering
1770      * or activating any mceusb RX and TX functions
1771      */
1772     INIT_WORK(&ir->kevent, mceusb_deferred_kevent);
1773 
1774     ir->rc = mceusb_init_rc_dev(ir);
1775     if (!ir->rc)
1776         goto rc_dev_fail;
1777 
1778     /* wire up inbound data handler */
1779     if (usb_endpoint_xfer_int(ep_in))
1780         usb_fill_int_urb(ir->urb_in, dev, pipe, ir->buf_in, maxp,
1781                  mceusb_dev_recv, ir, ep_in->bInterval);
1782     else
1783         usb_fill_bulk_urb(ir->urb_in, dev, pipe, ir->buf_in, maxp,
1784                   mceusb_dev_recv, ir);
1785 
1786     ir->urb_in->transfer_dma = ir->dma_in;
1787     ir->urb_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1788 
1789     /* flush buffers on the device */
1790     dev_dbg(&intf->dev, "Flushing receive buffers");
1791     res = usb_submit_urb(ir->urb_in, GFP_KERNEL);
1792     if (res)
1793         dev_err(&intf->dev, "failed to flush buffers: %d", res);
1794 
1795     /* figure out which firmware/emulator version this hardware has */
1796     mceusb_get_emulator_version(ir);
1797 
1798     /* initialize device */
1799     if (ir->flags.microsoft_gen1)
1800         mceusb_gen1_init(ir);
1801     else if (!is_gen3)
1802         mceusb_gen2_init(ir);
1803 
1804     mceusb_get_parameters(ir);
1805 
1806     mceusb_flash_led(ir);
1807 
1808     if (!ir->flags.no_tx)
1809         mceusb_set_tx_mask(ir->rc, MCE_DEFAULT_TX_MASK);
1810 
1811     usb_set_intfdata(intf, ir);
1812 
1813     /* enable wake via this device */
1814     device_set_wakeup_capable(ir->dev, true);
1815     device_set_wakeup_enable(ir->dev, true);
1816 
1817     dev_info(&intf->dev, "Registered %s with mce emulator interface version %x",
1818         name, ir->emver);
1819     dev_info(&intf->dev, "%x tx ports (0x%x cabled) and %x rx sensors (0x%x active)",
1820          ir->num_txports, ir->txports_cabled,
1821          ir->num_rxports, ir->rxports_active);
1822 
1823     return 0;
1824 
1825     /* Error-handling path */
1826 rc_dev_fail:
1827     cancel_work_sync(&ir->kevent);
1828     usb_put_dev(ir->usbdev);
1829     usb_kill_urb(ir->urb_in);
1830     usb_free_urb(ir->urb_in);
1831 urb_in_alloc_fail:
1832     usb_free_coherent(dev, maxp, ir->buf_in, ir->dma_in);
1833 buf_in_alloc_fail:
1834     kfree(ir);
1835 mem_alloc_fail:
1836     dev_err(&intf->dev, "%s: device setup failed!", __func__);
1837 
1838     return -ENOMEM;
1839 }
1840 
1841 
1842 static void mceusb_dev_disconnect(struct usb_interface *intf)
1843 {
1844     struct usb_device *dev = interface_to_usbdev(intf);
1845     struct mceusb_dev *ir = usb_get_intfdata(intf);
1846 
1847     dev_dbg(&intf->dev, "%s called", __func__);
1848 
1849     usb_set_intfdata(intf, NULL);
1850 
1851     if (!ir)
1852         return;
1853 
1854     ir->usbdev = NULL;
1855     cancel_work_sync(&ir->kevent);
1856     rc_unregister_device(ir->rc);
1857     usb_kill_urb(ir->urb_in);
1858     usb_free_urb(ir->urb_in);
1859     usb_free_coherent(dev, ir->len_in, ir->buf_in, ir->dma_in);
1860     usb_put_dev(dev);
1861 
1862     kfree(ir);
1863 }
1864 
1865 static int mceusb_dev_suspend(struct usb_interface *intf, pm_message_t message)
1866 {
1867     struct mceusb_dev *ir = usb_get_intfdata(intf);
1868     dev_info(ir->dev, "suspend");
1869     usb_kill_urb(ir->urb_in);
1870     return 0;
1871 }
1872 
1873 static int mceusb_dev_resume(struct usb_interface *intf)
1874 {
1875     struct mceusb_dev *ir = usb_get_intfdata(intf);
1876     dev_info(ir->dev, "resume");
1877     if (usb_submit_urb(ir->urb_in, GFP_ATOMIC))
1878         return -EIO;
1879     return 0;
1880 }
1881 
1882 static struct usb_driver mceusb_dev_driver = {
1883     .name =     DRIVER_NAME,
1884     .probe =    mceusb_dev_probe,
1885     .disconnect =   mceusb_dev_disconnect,
1886     .suspend =  mceusb_dev_suspend,
1887     .resume =   mceusb_dev_resume,
1888     .reset_resume = mceusb_dev_resume,
1889     .id_table = mceusb_dev_table
1890 };
1891 
1892 module_usb_driver(mceusb_dev_driver);
1893 
1894 MODULE_DESCRIPTION(DRIVER_DESC);
1895 MODULE_AUTHOR(DRIVER_AUTHOR);
1896 MODULE_LICENSE("GPL");
1897 MODULE_DEVICE_TABLE(usb, mceusb_dev_table);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!