1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Driver for USB Windows Media Center Ed. eHome Infrared Transceivers |
4 | * |
5 | * Copyright (c) 2010-2011, Jarod Wilson <jarod@redhat.com> |
6 | * |
7 | * Based on the original lirc_mceusb and lirc_mceusb2 drivers, by Dan |
8 | * Conti, Martin Blatter and Daniel Melander, the latter of which was |
9 | * in turn also based on the lirc_atiusb driver by Paul Miller. The |
10 | * two mce drivers were merged into one by Jarod Wilson, with transmit |
11 | * support for the 1st-gen device added primarily by Patrick Calhoun, |
12 | * with a bit of tweaks by Jarod. Debugging improvements and proper |
13 | * support for what appears to be 3rd-gen hardware added by Jarod. |
14 | * Initial port from lirc driver to ir-core drivery by Jarod, based |
15 | * partially on a port to an earlier proposed IR infrastructure by |
16 | * Jon Smirl, which included enhancements and simplifications to the |
17 | * incoming IR buffer parsing routines. |
18 | * |
19 | * Updated in July of 2011 with the aid of Microsoft's official |
20 | * remote/transceiver requirements and specification document, found at |
21 | * download.microsoft.com, title |
22 | * Windows-Media-Center-RC-IR-Collection-Green-Button-Specification-03-08-2011-V2.pdf |
23 | */ |
24 | |
25 | #include <linux/device.h> |
26 | #include <linux/module.h> |
27 | #include <linux/slab.h> |
28 | #include <linux/workqueue.h> |
29 | #include <linux/usb.h> |
30 | #include <linux/usb/input.h> |
31 | #include <linux/pm_wakeup.h> |
32 | #include <media/rc-core.h> |
33 | |
34 | #define DRIVER_VERSION "1.95" |
35 | #define DRIVER_AUTHOR "Jarod Wilson <jarod@redhat.com>" |
36 | #define DRIVER_DESC "Windows Media Center Ed. eHome Infrared Transceiver " \ |
37 | "device driver" |
38 | #define DRIVER_NAME "mceusb" |
39 | |
40 | #define USB_TX_TIMEOUT 1000 /* in milliseconds */ |
41 | #define USB_CTRL_MSG_SZ 2 /* Size of usb ctrl msg on gen1 hw */ |
42 | #define MCE_G1_INIT_MSGS 40 /* Init messages on gen1 hw to throw out */ |
43 | |
44 | /* MCE constants */ |
45 | #define MCE_IRBUF_SIZE 128 /* TX IR buffer length */ |
46 | #define MCE_TIME_UNIT 50 /* Approx 50us resolution */ |
47 | #define MCE_PACKET_SIZE 31 /* Max length of packet (with header) */ |
48 | #define (0x80 + MCE_PACKET_SIZE - 1) |
49 | /* Actual format is 0x80 + num_bytes */ |
50 | #define MCE_IRDATA_TRAILER 0x80 /* End of IR data */ |
51 | #define MCE_MAX_CHANNELS 2 /* Two transmitters, hardware dependent? */ |
52 | #define MCE_DEFAULT_TX_MASK 0x03 /* Vals: TX1=0x01, TX2=0x02, ALL=0x03 */ |
53 | #define MCE_PULSE_BIT 0x80 /* Pulse bit, MSB set == PULSE else SPACE */ |
54 | #define MCE_PULSE_MASK 0x7f /* Pulse mask */ |
55 | #define MCE_MAX_PULSE_LENGTH 0x7f /* Longest transmittable pulse symbol */ |
56 | |
57 | /* |
58 | * The interface between the host and the IR hardware is command-response |
59 | * based. All commands and responses have a consistent format, where a lead |
60 | * byte always identifies the type of data following it. The lead byte has |
61 | * a port value in the 3 highest bits and a length value in the 5 lowest |
62 | * bits. |
63 | * |
64 | * The length field is overloaded, with a value of 11111 indicating that the |
65 | * following byte is a command or response code, and the length of the entire |
66 | * message is determined by the code. If the length field is not 11111, then |
67 | * it specifies the number of bytes of port data that follow. |
68 | */ |
69 | #define MCE_CMD 0x1f |
70 | #define MCE_PORT_IR 0x4 /* (0x4 << 5) | MCE_CMD = 0x9f */ |
71 | #define MCE_PORT_SYS 0x7 /* (0x7 << 5) | MCE_CMD = 0xff */ |
72 | #define MCE_PORT_SER 0x6 /* 0xc0 through 0xdf flush & 0x1f bytes */ |
73 | #define MCE_PORT_MASK 0xe0 /* Mask out command bits */ |
74 | |
75 | /* Command port headers */ |
76 | #define MCE_CMD_PORT_IR 0x9f /* IR-related cmd/rsp */ |
77 | #define MCE_CMD_PORT_SYS 0xff /* System (non-IR) device cmd/rsp */ |
78 | |
79 | /* Commands that set device state (2-4 bytes in length) */ |
80 | #define MCE_CMD_RESET 0xfe /* Reset device, 2 bytes */ |
81 | #define MCE_CMD_RESUME 0xaa /* Resume device after error, 2 bytes */ |
82 | #define MCE_CMD_SETIRCFS 0x06 /* Set tx carrier, 4 bytes */ |
83 | #define MCE_CMD_SETIRTIMEOUT 0x0c /* Set timeout, 4 bytes */ |
84 | #define MCE_CMD_SETIRTXPORTS 0x08 /* Set tx ports, 3 bytes */ |
85 | #define MCE_CMD_SETIRRXPORTEN 0x14 /* Set rx ports, 3 bytes */ |
86 | #define MCE_CMD_FLASHLED 0x23 /* Flash receiver LED, 2 bytes */ |
87 | |
88 | /* Commands that query device state (all 2 bytes, unless noted) */ |
89 | #define MCE_CMD_GETIRCFS 0x07 /* Get carrier */ |
90 | #define MCE_CMD_GETIRTIMEOUT 0x0d /* Get timeout */ |
91 | #define MCE_CMD_GETIRTXPORTS 0x13 /* Get tx ports */ |
92 | #define MCE_CMD_GETIRRXPORTEN 0x15 /* Get rx ports */ |
93 | #define MCE_CMD_GETPORTSTATUS 0x11 /* Get tx port status, 3 bytes */ |
94 | #define MCE_CMD_GETIRNUMPORTS 0x16 /* Get number of ports */ |
95 | #define MCE_CMD_GETWAKESOURCE 0x17 /* Get wake source */ |
96 | #define MCE_CMD_GETEMVER 0x22 /* Get emulator interface version */ |
97 | #define MCE_CMD_GETDEVDETAILS 0x21 /* Get device details (em ver2 only) */ |
98 | #define MCE_CMD_GETWAKESUPPORT 0x20 /* Get wake details (em ver2 only) */ |
99 | #define MCE_CMD_GETWAKEVERSION 0x18 /* Get wake pattern (em ver2 only) */ |
100 | |
101 | /* Misc commands */ |
102 | #define MCE_CMD_NOP 0xff /* No operation */ |
103 | |
104 | /* Responses to commands (non-error cases) */ |
105 | #define MCE_RSP_EQIRCFS 0x06 /* tx carrier, 4 bytes */ |
106 | #define MCE_RSP_EQIRTIMEOUT 0x0c /* rx timeout, 4 bytes */ |
107 | #define MCE_RSP_GETWAKESOURCE 0x17 /* wake source, 3 bytes */ |
108 | #define MCE_RSP_EQIRTXPORTS 0x08 /* tx port mask, 3 bytes */ |
109 | #define MCE_RSP_EQIRRXPORTEN 0x14 /* rx port mask, 3 bytes */ |
110 | #define MCE_RSP_GETPORTSTATUS 0x11 /* tx port status, 7 bytes */ |
111 | #define MCE_RSP_EQIRRXCFCNT 0x15 /* rx carrier count, 4 bytes */ |
112 | #define MCE_RSP_EQIRNUMPORTS 0x16 /* number of ports, 4 bytes */ |
113 | #define MCE_RSP_EQWAKESUPPORT 0x20 /* wake capabilities, 3 bytes */ |
114 | #define MCE_RSP_EQWAKEVERSION 0x18 /* wake pattern details, 6 bytes */ |
115 | #define MCE_RSP_EQDEVDETAILS 0x21 /* device capabilities, 3 bytes */ |
116 | #define MCE_RSP_EQEMVER 0x22 /* emulator interface ver, 3 bytes */ |
117 | #define MCE_RSP_FLASHLED 0x23 /* success flashing LED, 2 bytes */ |
118 | |
119 | /* Responses to error cases, must send MCE_CMD_RESUME to clear them */ |
120 | #define MCE_RSP_CMD_ILLEGAL 0xfe /* illegal command for port, 2 bytes */ |
121 | #define MCE_RSP_TX_TIMEOUT 0x81 /* tx timed out, 2 bytes */ |
122 | |
123 | /* Misc commands/responses not defined in the MCE remote/transceiver spec */ |
124 | #define MCE_CMD_SIG_END 0x01 /* End of signal */ |
125 | #define MCE_CMD_PING 0x03 /* Ping device */ |
126 | #define MCE_CMD_UNKNOWN 0x04 /* Unknown */ |
127 | #define MCE_CMD_UNKNOWN2 0x05 /* Unknown */ |
128 | #define MCE_CMD_UNKNOWN3 0x09 /* Unknown */ |
129 | #define MCE_CMD_UNKNOWN4 0x0a /* Unknown */ |
130 | #define MCE_CMD_G_REVISION 0x0b /* Get hw/sw revision */ |
131 | #define MCE_CMD_UNKNOWN5 0x0e /* Unknown */ |
132 | #define MCE_CMD_UNKNOWN6 0x0f /* Unknown */ |
133 | #define MCE_CMD_UNKNOWN8 0x19 /* Unknown */ |
134 | #define MCE_CMD_UNKNOWN9 0x1b /* Unknown */ |
135 | #define MCE_CMD_NULL 0x00 /* These show up various places... */ |
136 | |
137 | /* if buf[i] & MCE_PORT_MASK == 0x80 and buf[i] != MCE_CMD_PORT_IR, |
138 | * then we're looking at a raw IR data sample */ |
139 | #define MCE_COMMAND_IRDATA 0x80 |
140 | #define MCE_PACKET_LENGTH_MASK 0x1f /* Packet length mask */ |
141 | |
142 | #define VENDOR_PHILIPS 0x0471 |
143 | #define VENDOR_SMK 0x0609 |
144 | #define VENDOR_TATUNG 0x1460 |
145 | #define VENDOR_GATEWAY 0x107b |
146 | #define VENDOR_SHUTTLE 0x1308 |
147 | #define VENDOR_SHUTTLE2 0x051c |
148 | #define VENDOR_MITSUMI 0x03ee |
149 | #define VENDOR_TOPSEED 0x1784 |
150 | #define VENDOR_RICAVISION 0x179d |
151 | #define VENDOR_ITRON 0x195d |
152 | #define VENDOR_FIC 0x1509 |
153 | #define VENDOR_LG 0x043e |
154 | #define VENDOR_MICROSOFT 0x045e |
155 | #define VENDOR_FORMOSA 0x147a |
156 | #define VENDOR_FINTEK 0x1934 |
157 | #define VENDOR_PINNACLE 0x2304 |
158 | #define VENDOR_ECS 0x1019 |
159 | #define VENDOR_WISTRON 0x0fb8 |
160 | #define VENDOR_COMPRO 0x185b |
161 | #define VENDOR_NORTHSTAR 0x04eb |
162 | #define VENDOR_REALTEK 0x0bda |
163 | #define VENDOR_TIVO 0x105a |
164 | #define VENDOR_CONEXANT 0x0572 |
165 | #define VENDOR_TWISTEDMELON 0x2596 |
166 | #define VENDOR_HAUPPAUGE 0x2040 |
167 | #define VENDOR_PCTV 0x2013 |
168 | #define VENDOR_ADAPTEC 0x03f3 |
169 | |
170 | enum mceusb_model_type { |
171 | MCE_GEN2 = 0, /* Most boards */ |
172 | MCE_GEN1, |
173 | MCE_GEN3, |
174 | MCE_GEN3_BROKEN_IRTIMEOUT, |
175 | MCE_GEN2_TX_INV, |
176 | MCE_GEN2_TX_INV_RX_GOOD, |
177 | POLARIS_EVK, |
178 | CX_HYBRID_TV, |
179 | MULTIFUNCTION, |
180 | TIVO_KIT, |
181 | MCE_GEN2_NO_TX, |
182 | HAUPPAUGE_CX_HYBRID_TV, |
183 | EVROMEDIA_FULL_HYBRID_FULLHD, |
184 | ASTROMETA_T2HYBRID, |
185 | }; |
186 | |
187 | struct mceusb_model { |
188 | u32 mce_gen1:1; |
189 | u32 mce_gen2:1; |
190 | u32 mce_gen3:1; |
191 | u32 tx_mask_normal:1; |
192 | u32 no_tx:1; |
193 | u32 broken_irtimeout:1; |
194 | /* |
195 | * 2nd IR receiver (short-range, wideband) for learning mode: |
196 | * 0, absent 2nd receiver (rx2) |
197 | * 1, rx2 present |
198 | * 2, rx2 which under counts IR carrier cycles |
199 | */ |
200 | u32 rx2; |
201 | |
202 | int ir_intfnum; |
203 | |
204 | const char *rc_map; /* Allow specify a per-board map */ |
205 | const char *name; /* per-board name */ |
206 | }; |
207 | |
208 | static const struct mceusb_model mceusb_model[] = { |
209 | [MCE_GEN1] = { |
210 | .mce_gen1 = 1, |
211 | .tx_mask_normal = 1, |
212 | .rx2 = 2, |
213 | }, |
214 | [MCE_GEN2] = { |
215 | .mce_gen2 = 1, |
216 | .rx2 = 2, |
217 | }, |
218 | [MCE_GEN2_NO_TX] = { |
219 | .mce_gen2 = 1, |
220 | .no_tx = 1, |
221 | }, |
222 | [MCE_GEN2_TX_INV] = { |
223 | .mce_gen2 = 1, |
224 | .tx_mask_normal = 1, |
225 | .rx2 = 1, |
226 | }, |
227 | [MCE_GEN2_TX_INV_RX_GOOD] = { |
228 | .mce_gen2 = 1, |
229 | .tx_mask_normal = 1, |
230 | .rx2 = 2, |
231 | }, |
232 | [MCE_GEN3] = { |
233 | .mce_gen3 = 1, |
234 | .tx_mask_normal = 1, |
235 | .rx2 = 2, |
236 | }, |
237 | [MCE_GEN3_BROKEN_IRTIMEOUT] = { |
238 | .mce_gen3 = 1, |
239 | .tx_mask_normal = 1, |
240 | .rx2 = 2, |
241 | .broken_irtimeout = 1 |
242 | }, |
243 | [POLARIS_EVK] = { |
244 | /* |
245 | * In fact, the EVK is shipped without |
246 | * remotes, but we should have something handy, |
247 | * to allow testing it |
248 | */ |
249 | .name = "Conexant Hybrid TV (cx231xx) MCE IR" , |
250 | .rx2 = 2, |
251 | }, |
252 | [CX_HYBRID_TV] = { |
253 | .no_tx = 1, /* tx isn't wired up at all */ |
254 | .name = "Conexant Hybrid TV (cx231xx) MCE IR" , |
255 | }, |
256 | [HAUPPAUGE_CX_HYBRID_TV] = { |
257 | .no_tx = 1, /* eeprom says it has no tx */ |
258 | .name = "Conexant Hybrid TV (cx231xx) MCE IR no TX" , |
259 | }, |
260 | [MULTIFUNCTION] = { |
261 | .mce_gen2 = 1, |
262 | .ir_intfnum = 2, |
263 | .rx2 = 2, |
264 | }, |
265 | [TIVO_KIT] = { |
266 | .mce_gen2 = 1, |
267 | .rc_map = RC_MAP_TIVO, |
268 | .rx2 = 2, |
269 | }, |
270 | [EVROMEDIA_FULL_HYBRID_FULLHD] = { |
271 | .name = "Evromedia USB Full Hybrid Full HD" , |
272 | .no_tx = 1, |
273 | .rc_map = RC_MAP_MSI_DIGIVOX_III, |
274 | }, |
275 | [ASTROMETA_T2HYBRID] = { |
276 | .name = "Astrometa T2Hybrid" , |
277 | .no_tx = 1, |
278 | .rc_map = RC_MAP_ASTROMETA_T2HYBRID, |
279 | } |
280 | }; |
281 | |
282 | static const struct usb_device_id mceusb_dev_table[] = { |
283 | /* Original Microsoft MCE IR Transceiver (often HP-branded) */ |
284 | { USB_DEVICE(VENDOR_MICROSOFT, 0x006d), |
285 | .driver_info = MCE_GEN1 }, |
286 | /* Philips Infrared Transceiver - Sahara branded */ |
287 | { USB_DEVICE(VENDOR_PHILIPS, 0x0608) }, |
288 | /* Philips Infrared Transceiver - HP branded */ |
289 | { USB_DEVICE(VENDOR_PHILIPS, 0x060c), |
290 | .driver_info = MCE_GEN2_TX_INV }, |
291 | /* Philips SRM5100 */ |
292 | { USB_DEVICE(VENDOR_PHILIPS, 0x060d) }, |
293 | /* Philips Infrared Transceiver - Omaura */ |
294 | { USB_DEVICE(VENDOR_PHILIPS, 0x060f) }, |
295 | /* Philips Infrared Transceiver - Spinel plus */ |
296 | { USB_DEVICE(VENDOR_PHILIPS, 0x0613) }, |
297 | /* Philips eHome Infrared Transceiver */ |
298 | { USB_DEVICE(VENDOR_PHILIPS, 0x0815) }, |
299 | /* Philips/Spinel plus IR transceiver for ASUS */ |
300 | { USB_DEVICE(VENDOR_PHILIPS, 0x206c) }, |
301 | /* Philips/Spinel plus IR transceiver for ASUS */ |
302 | { USB_DEVICE(VENDOR_PHILIPS, 0x2088) }, |
303 | /* Philips IR transceiver (Dell branded) */ |
304 | { USB_DEVICE(VENDOR_PHILIPS, 0x2093), |
305 | .driver_info = MCE_GEN2_TX_INV }, |
306 | /* Realtek MCE IR Receiver and card reader */ |
307 | { USB_DEVICE(VENDOR_REALTEK, 0x0161), |
308 | .driver_info = MULTIFUNCTION }, |
309 | /* SMK/Toshiba G83C0004D410 */ |
310 | { USB_DEVICE(VENDOR_SMK, 0x031d), |
311 | .driver_info = MCE_GEN2_TX_INV_RX_GOOD }, |
312 | /* SMK eHome Infrared Transceiver (Sony VAIO) */ |
313 | { USB_DEVICE(VENDOR_SMK, 0x0322), |
314 | .driver_info = MCE_GEN2_TX_INV }, |
315 | /* bundled with Hauppauge PVR-150 */ |
316 | { USB_DEVICE(VENDOR_SMK, 0x0334), |
317 | .driver_info = MCE_GEN2_TX_INV }, |
318 | /* SMK eHome Infrared Transceiver */ |
319 | { USB_DEVICE(VENDOR_SMK, 0x0338) }, |
320 | /* SMK/I-O Data GV-MC7/RCKIT Receiver */ |
321 | { USB_DEVICE(VENDOR_SMK, 0x0353), |
322 | .driver_info = MCE_GEN2_NO_TX }, |
323 | /* SMK RXX6000 Infrared Receiver */ |
324 | { USB_DEVICE(VENDOR_SMK, 0x0357), |
325 | .driver_info = MCE_GEN2_NO_TX }, |
326 | /* Tatung eHome Infrared Transceiver */ |
327 | { USB_DEVICE(VENDOR_TATUNG, 0x9150) }, |
328 | /* Shuttle eHome Infrared Transceiver */ |
329 | { USB_DEVICE(VENDOR_SHUTTLE, 0xc001) }, |
330 | /* Shuttle eHome Infrared Transceiver */ |
331 | { USB_DEVICE(VENDOR_SHUTTLE2, 0xc001) }, |
332 | /* Gateway eHome Infrared Transceiver */ |
333 | { USB_DEVICE(VENDOR_GATEWAY, 0x3009) }, |
334 | /* Mitsumi */ |
335 | { USB_DEVICE(VENDOR_MITSUMI, 0x2501) }, |
336 | /* Topseed eHome Infrared Transceiver */ |
337 | { USB_DEVICE(VENDOR_TOPSEED, 0x0001), |
338 | .driver_info = MCE_GEN2_TX_INV }, |
339 | /* Topseed HP eHome Infrared Transceiver */ |
340 | { USB_DEVICE(VENDOR_TOPSEED, 0x0006), |
341 | .driver_info = MCE_GEN2_TX_INV }, |
342 | /* Topseed eHome Infrared Transceiver */ |
343 | { USB_DEVICE(VENDOR_TOPSEED, 0x0007), |
344 | .driver_info = MCE_GEN2_TX_INV }, |
345 | /* Topseed eHome Infrared Transceiver */ |
346 | { USB_DEVICE(VENDOR_TOPSEED, 0x0008), |
347 | .driver_info = MCE_GEN3 }, |
348 | /* Topseed eHome Infrared Transceiver */ |
349 | { USB_DEVICE(VENDOR_TOPSEED, 0x000a), |
350 | .driver_info = MCE_GEN2_TX_INV }, |
351 | /* Topseed eHome Infrared Transceiver */ |
352 | { USB_DEVICE(VENDOR_TOPSEED, 0x0011), |
353 | .driver_info = MCE_GEN3_BROKEN_IRTIMEOUT }, |
354 | /* Ricavision internal Infrared Transceiver */ |
355 | { USB_DEVICE(VENDOR_RICAVISION, 0x0010) }, |
356 | /* Itron ione Libra Q-11 */ |
357 | { USB_DEVICE(VENDOR_ITRON, 0x7002) }, |
358 | /* FIC eHome Infrared Transceiver */ |
359 | { USB_DEVICE(VENDOR_FIC, 0x9242) }, |
360 | /* LG eHome Infrared Transceiver */ |
361 | { USB_DEVICE(VENDOR_LG, 0x9803) }, |
362 | /* Microsoft MCE Infrared Transceiver */ |
363 | { USB_DEVICE(VENDOR_MICROSOFT, 0x00a0) }, |
364 | /* Formosa eHome Infrared Transceiver */ |
365 | { USB_DEVICE(VENDOR_FORMOSA, 0xe015) }, |
366 | /* Formosa21 / eHome Infrared Receiver */ |
367 | { USB_DEVICE(VENDOR_FORMOSA, 0xe016) }, |
368 | /* Formosa aim / Trust MCE Infrared Receiver */ |
369 | { USB_DEVICE(VENDOR_FORMOSA, 0xe017), |
370 | .driver_info = MCE_GEN2_NO_TX }, |
371 | /* Formosa Industrial Computing / Beanbag Emulation Device */ |
372 | { USB_DEVICE(VENDOR_FORMOSA, 0xe018) }, |
373 | /* Formosa21 / eHome Infrared Receiver */ |
374 | { USB_DEVICE(VENDOR_FORMOSA, 0xe03a) }, |
375 | /* Formosa Industrial Computing AIM IR605/A */ |
376 | { USB_DEVICE(VENDOR_FORMOSA, 0xe03c) }, |
377 | /* Formosa Industrial Computing */ |
378 | { USB_DEVICE(VENDOR_FORMOSA, 0xe03e) }, |
379 | /* Formosa Industrial Computing */ |
380 | { USB_DEVICE(VENDOR_FORMOSA, 0xe042) }, |
381 | /* Fintek eHome Infrared Transceiver (HP branded) */ |
382 | { USB_DEVICE(VENDOR_FINTEK, 0x5168), |
383 | .driver_info = MCE_GEN2_TX_INV }, |
384 | /* Fintek eHome Infrared Transceiver */ |
385 | { USB_DEVICE(VENDOR_FINTEK, 0x0602) }, |
386 | /* Fintek eHome Infrared Transceiver (in the AOpen MP45) */ |
387 | { USB_DEVICE(VENDOR_FINTEK, 0x0702) }, |
388 | /* Pinnacle Remote Kit */ |
389 | { USB_DEVICE(VENDOR_PINNACLE, 0x0225), |
390 | .driver_info = MCE_GEN3 }, |
391 | /* Elitegroup Computer Systems IR */ |
392 | { USB_DEVICE(VENDOR_ECS, 0x0f38) }, |
393 | /* Wistron Corp. eHome Infrared Receiver */ |
394 | { USB_DEVICE(VENDOR_WISTRON, 0x0002) }, |
395 | /* Compro K100 */ |
396 | { USB_DEVICE(VENDOR_COMPRO, 0x3020) }, |
397 | /* Compro K100 v2 */ |
398 | { USB_DEVICE(VENDOR_COMPRO, 0x3082) }, |
399 | /* Northstar Systems, Inc. eHome Infrared Transceiver */ |
400 | { USB_DEVICE(VENDOR_NORTHSTAR, 0xe004) }, |
401 | /* TiVo PC IR Receiver */ |
402 | { USB_DEVICE(VENDOR_TIVO, 0x2000), |
403 | .driver_info = TIVO_KIT }, |
404 | /* Conexant Hybrid TV "Shelby" Polaris SDK */ |
405 | { USB_DEVICE(VENDOR_CONEXANT, 0x58a1), |
406 | .driver_info = POLARIS_EVK }, |
407 | /* Conexant Hybrid TV RDU253S Polaris */ |
408 | { USB_DEVICE(VENDOR_CONEXANT, 0x58a5), |
409 | .driver_info = CX_HYBRID_TV }, |
410 | /* Twisted Melon Inc. - Manta Mini Receiver */ |
411 | { USB_DEVICE(VENDOR_TWISTEDMELON, 0x8008) }, |
412 | /* Twisted Melon Inc. - Manta Pico Receiver */ |
413 | { USB_DEVICE(VENDOR_TWISTEDMELON, 0x8016) }, |
414 | /* Twisted Melon Inc. - Manta Transceiver */ |
415 | { USB_DEVICE(VENDOR_TWISTEDMELON, 0x8042) }, |
416 | /* Hauppauge WINTV-HVR-HVR 930C-HD - based on cx231xx */ |
417 | { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb130), |
418 | .driver_info = HAUPPAUGE_CX_HYBRID_TV }, |
419 | { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb131), |
420 | .driver_info = HAUPPAUGE_CX_HYBRID_TV }, |
421 | { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb138), |
422 | .driver_info = HAUPPAUGE_CX_HYBRID_TV }, |
423 | { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb139), |
424 | .driver_info = HAUPPAUGE_CX_HYBRID_TV }, |
425 | /* Hauppauge WinTV-HVR-935C - based on cx231xx */ |
426 | { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb151), |
427 | .driver_info = HAUPPAUGE_CX_HYBRID_TV }, |
428 | /* Hauppauge WinTV-HVR-955Q - based on cx231xx */ |
429 | { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb123), |
430 | .driver_info = HAUPPAUGE_CX_HYBRID_TV }, |
431 | /* Hauppauge WinTV-HVR-975 - based on cx231xx */ |
432 | { USB_DEVICE(VENDOR_HAUPPAUGE, 0xb150), |
433 | .driver_info = HAUPPAUGE_CX_HYBRID_TV }, |
434 | { USB_DEVICE(VENDOR_PCTV, 0x0259), |
435 | .driver_info = HAUPPAUGE_CX_HYBRID_TV }, |
436 | { USB_DEVICE(VENDOR_PCTV, 0x025e), |
437 | .driver_info = HAUPPAUGE_CX_HYBRID_TV }, |
438 | /* Adaptec / HP eHome Receiver */ |
439 | { USB_DEVICE(VENDOR_ADAPTEC, 0x0094) }, |
440 | /* Evromedia USB Full Hybrid Full HD */ |
441 | { USB_DEVICE(0x1b80, 0xd3b2), |
442 | .driver_info = EVROMEDIA_FULL_HYBRID_FULLHD }, |
443 | /* Astrometa T2hybrid */ |
444 | { USB_DEVICE(0x15f4, 0x0135), |
445 | .driver_info = ASTROMETA_T2HYBRID }, |
446 | |
447 | /* Terminating entry */ |
448 | { } |
449 | }; |
450 | |
451 | /* data structure for each usb transceiver */ |
452 | struct mceusb_dev { |
453 | /* ir-core bits */ |
454 | struct rc_dev *rc; |
455 | |
456 | /* optional features we can enable */ |
457 | bool carrier_report_enabled; |
458 | bool wideband_rx_enabled; /* aka learning mode, short-range rx */ |
459 | |
460 | /* core device bits */ |
461 | struct device *dev; |
462 | |
463 | /* usb */ |
464 | struct usb_device *usbdev; |
465 | struct usb_interface *usbintf; |
466 | struct urb *urb_in; |
467 | unsigned int pipe_in; |
468 | struct usb_endpoint_descriptor *usb_ep_out; |
469 | unsigned int pipe_out; |
470 | |
471 | /* buffers and dma */ |
472 | unsigned char *buf_in; |
473 | unsigned int len_in; |
474 | dma_addr_t dma_in; |
475 | |
476 | enum { |
477 | = 0, |
478 | SUBCMD, |
479 | CMD_DATA, |
480 | PARSE_IRDATA, |
481 | } parser_state; |
482 | |
483 | u8 cmd, rem; /* Remaining IR data bytes in packet */ |
484 | |
485 | struct { |
486 | u32 connected:1; |
487 | u32 tx_mask_normal:1; |
488 | u32 microsoft_gen1:1; |
489 | u32 no_tx:1; |
490 | u32 rx2; |
491 | } flags; |
492 | |
493 | /* transmit support */ |
494 | u32 carrier; |
495 | unsigned char tx_mask; |
496 | |
497 | char name[128]; |
498 | char phys[64]; |
499 | enum mceusb_model_type model; |
500 | |
501 | bool need_reset; /* flag to issue a device resume cmd */ |
502 | u8 emver; /* emulator interface version */ |
503 | u8 num_txports; /* number of transmit ports */ |
504 | u8 num_rxports; /* number of receive sensors */ |
505 | u8 txports_cabled; /* bitmask of transmitters with cable */ |
506 | u8 rxports_active; /* bitmask of active receive sensors */ |
507 | bool learning_active; /* wideband rx is active */ |
508 | |
509 | /* receiver carrier frequency detection support */ |
510 | u32 pulse_tunit; /* IR pulse "on" cumulative time units */ |
511 | u32 pulse_count; /* pulse "on" count in measurement interval */ |
512 | |
513 | /* |
514 | * support for async error handler mceusb_deferred_kevent() |
515 | * where usb_clear_halt(), usb_reset_configuration(), |
516 | * usb_reset_device(), etc. must be done in process context |
517 | */ |
518 | struct work_struct kevent; |
519 | unsigned long kevent_flags; |
520 | # define EVENT_TX_HALT 0 |
521 | # define EVENT_RX_HALT 1 |
522 | # define EVENT_RST_PEND 31 |
523 | }; |
524 | |
525 | /* MCE Device Command Strings, generally a port and command pair */ |
526 | static char DEVICE_RESUME[] = {MCE_CMD_NULL, MCE_CMD_PORT_SYS, |
527 | MCE_CMD_RESUME}; |
528 | static char GET_REVISION[] = {MCE_CMD_PORT_SYS, MCE_CMD_G_REVISION}; |
529 | static char GET_EMVER[] = {MCE_CMD_PORT_SYS, MCE_CMD_GETEMVER}; |
530 | static char GET_WAKEVERSION[] = {MCE_CMD_PORT_SYS, MCE_CMD_GETWAKEVERSION}; |
531 | static char FLASH_LED[] = {MCE_CMD_PORT_SYS, MCE_CMD_FLASHLED}; |
532 | static char GET_UNKNOWN2[] = {MCE_CMD_PORT_IR, MCE_CMD_UNKNOWN2}; |
533 | static char GET_CARRIER_FREQ[] = {MCE_CMD_PORT_IR, MCE_CMD_GETIRCFS}; |
534 | static char GET_RX_TIMEOUT[] = {MCE_CMD_PORT_IR, MCE_CMD_GETIRTIMEOUT}; |
535 | static char GET_NUM_PORTS[] = {MCE_CMD_PORT_IR, MCE_CMD_GETIRNUMPORTS}; |
536 | static char GET_TX_BITMASK[] = {MCE_CMD_PORT_IR, MCE_CMD_GETIRTXPORTS}; |
537 | static char GET_RX_SENSOR[] = {MCE_CMD_PORT_IR, MCE_CMD_GETIRRXPORTEN}; |
538 | /* sub in desired values in lower byte or bytes for full command */ |
539 | /* FIXME: make use of these for transmit. |
540 | static char SET_CARRIER_FREQ[] = {MCE_CMD_PORT_IR, |
541 | MCE_CMD_SETIRCFS, 0x00, 0x00}; |
542 | static char SET_TX_BITMASK[] = {MCE_CMD_PORT_IR, MCE_CMD_SETIRTXPORTS, 0x00}; |
543 | static char SET_RX_TIMEOUT[] = {MCE_CMD_PORT_IR, |
544 | MCE_CMD_SETIRTIMEOUT, 0x00, 0x00}; |
545 | static char SET_RX_SENSOR[] = {MCE_CMD_PORT_IR, |
546 | MCE_RSP_EQIRRXPORTEN, 0x00}; |
547 | */ |
548 | |
549 | static int mceusb_cmd_datasize(u8 cmd, u8 subcmd) |
550 | { |
551 | int datasize = 0; |
552 | |
553 | switch (cmd) { |
554 | case MCE_CMD_NULL: |
555 | if (subcmd == MCE_CMD_PORT_SYS) |
556 | datasize = 1; |
557 | break; |
558 | case MCE_CMD_PORT_SYS: |
559 | switch (subcmd) { |
560 | case MCE_RSP_GETPORTSTATUS: |
561 | datasize = 5; |
562 | break; |
563 | case MCE_RSP_EQWAKEVERSION: |
564 | datasize = 4; |
565 | break; |
566 | case MCE_CMD_G_REVISION: |
567 | datasize = 4; |
568 | break; |
569 | case MCE_RSP_EQWAKESUPPORT: |
570 | case MCE_RSP_GETWAKESOURCE: |
571 | case MCE_RSP_EQDEVDETAILS: |
572 | case MCE_RSP_EQEMVER: |
573 | datasize = 1; |
574 | break; |
575 | } |
576 | break; |
577 | case MCE_CMD_PORT_IR: |
578 | switch (subcmd) { |
579 | case MCE_CMD_UNKNOWN: |
580 | case MCE_RSP_EQIRCFS: |
581 | case MCE_RSP_EQIRTIMEOUT: |
582 | case MCE_RSP_EQIRRXCFCNT: |
583 | case MCE_RSP_EQIRNUMPORTS: |
584 | datasize = 2; |
585 | break; |
586 | case MCE_CMD_SIG_END: |
587 | case MCE_RSP_EQIRTXPORTS: |
588 | case MCE_RSP_EQIRRXPORTEN: |
589 | datasize = 1; |
590 | break; |
591 | } |
592 | } |
593 | return datasize; |
594 | } |
595 | |
596 | static void mceusb_dev_printdata(struct mceusb_dev *ir, u8 *buf, int buf_len, |
597 | int offset, int len, bool out) |
598 | { |
599 | #if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG) |
600 | char *inout; |
601 | u8 cmd, subcmd, *data; |
602 | struct device *dev = ir->dev; |
603 | u32 carrier, period; |
604 | |
605 | if (offset < 0 || offset >= buf_len) |
606 | return; |
607 | |
608 | dev_dbg(dev, "%cx data[%d]: %*ph (len=%d sz=%d)" , |
609 | (out ? 't' : 'r'), offset, |
610 | min(len, buf_len - offset), buf + offset, len, buf_len); |
611 | |
612 | inout = out ? "Request" : "Got" ; |
613 | |
614 | cmd = buf[offset]; |
615 | subcmd = (offset + 1 < buf_len) ? buf[offset + 1] : 0; |
616 | data = &buf[offset] + 2; |
617 | |
618 | /* Trace meaningless 0xb1 0x60 header bytes on original receiver */ |
619 | if (ir->flags.microsoft_gen1 && !out && !offset) { |
620 | dev_dbg(dev, "MCE gen 1 header" ); |
621 | return; |
622 | } |
623 | |
624 | /* Trace IR data header or trailer */ |
625 | if (cmd != MCE_CMD_PORT_IR && |
626 | (cmd & MCE_PORT_MASK) == MCE_COMMAND_IRDATA) { |
627 | if (cmd == MCE_IRDATA_TRAILER) |
628 | dev_dbg(dev, "End of raw IR data" ); |
629 | else |
630 | dev_dbg(dev, "Raw IR data, %d pulse/space samples" , |
631 | cmd & MCE_PACKET_LENGTH_MASK); |
632 | return; |
633 | } |
634 | |
635 | /* Unexpected end of buffer? */ |
636 | if (offset + len > buf_len) |
637 | return; |
638 | |
639 | /* Decode MCE command/response */ |
640 | switch (cmd) { |
641 | case MCE_CMD_NULL: |
642 | if (subcmd == MCE_CMD_NULL) |
643 | break; |
644 | if ((subcmd == MCE_CMD_PORT_SYS) && |
645 | (data[0] == MCE_CMD_RESUME)) |
646 | dev_dbg(dev, "Device resume requested" ); |
647 | else |
648 | dev_dbg(dev, "Unknown command 0x%02x 0x%02x" , |
649 | cmd, subcmd); |
650 | break; |
651 | case MCE_CMD_PORT_SYS: |
652 | switch (subcmd) { |
653 | case MCE_RSP_EQEMVER: |
654 | if (!out) |
655 | dev_dbg(dev, "Emulator interface version %x" , |
656 | data[0]); |
657 | break; |
658 | case MCE_CMD_G_REVISION: |
659 | if (len == 2) |
660 | dev_dbg(dev, "Get hw/sw rev?" ); |
661 | else |
662 | dev_dbg(dev, "hw/sw rev %*ph" , |
663 | 4, &buf[offset + 2]); |
664 | break; |
665 | case MCE_CMD_RESUME: |
666 | dev_dbg(dev, "Device resume requested" ); |
667 | break; |
668 | case MCE_RSP_CMD_ILLEGAL: |
669 | dev_dbg(dev, "Illegal PORT_SYS command" ); |
670 | break; |
671 | case MCE_RSP_EQWAKEVERSION: |
672 | if (!out) |
673 | dev_dbg(dev, "Wake version, proto: 0x%02x, payload: 0x%02x, address: 0x%02x, version: 0x%02x" , |
674 | data[0], data[1], data[2], data[3]); |
675 | break; |
676 | case MCE_RSP_GETPORTSTATUS: |
677 | if (!out) |
678 | /* We use data1 + 1 here, to match hw labels */ |
679 | dev_dbg(dev, "TX port %d: blaster is%s connected" , |
680 | data[0] + 1, data[3] ? " not" : "" ); |
681 | break; |
682 | case MCE_CMD_FLASHLED: |
683 | dev_dbg(dev, "Attempting to flash LED" ); |
684 | break; |
685 | default: |
686 | dev_dbg(dev, "Unknown command 0x%02x 0x%02x" , |
687 | cmd, subcmd); |
688 | break; |
689 | } |
690 | break; |
691 | case MCE_CMD_PORT_IR: |
692 | switch (subcmd) { |
693 | case MCE_CMD_SIG_END: |
694 | dev_dbg(dev, "End of signal" ); |
695 | break; |
696 | case MCE_CMD_PING: |
697 | dev_dbg(dev, "Ping" ); |
698 | break; |
699 | case MCE_CMD_UNKNOWN: |
700 | dev_dbg(dev, "Resp to 9f 05 of 0x%02x 0x%02x" , |
701 | data[0], data[1]); |
702 | break; |
703 | case MCE_RSP_EQIRCFS: |
704 | if (!data[0] && !data[1]) { |
705 | dev_dbg(dev, "%s: no carrier" , inout); |
706 | break; |
707 | } |
708 | // prescaler should make sense |
709 | if (data[0] > 8) |
710 | break; |
711 | period = DIV_ROUND_CLOSEST((1U << data[0] * 2) * |
712 | (data[1] + 1), 10); |
713 | if (!period) |
714 | break; |
715 | carrier = USEC_PER_SEC / period; |
716 | dev_dbg(dev, "%s carrier of %u Hz (period %uus)" , |
717 | inout, carrier, period); |
718 | break; |
719 | case MCE_CMD_GETIRCFS: |
720 | dev_dbg(dev, "Get carrier mode and freq" ); |
721 | break; |
722 | case MCE_RSP_EQIRTXPORTS: |
723 | dev_dbg(dev, "%s transmit blaster mask of 0x%02x" , |
724 | inout, data[0]); |
725 | break; |
726 | case MCE_RSP_EQIRTIMEOUT: |
727 | /* value is in units of 50us, so x*50/1000 ms */ |
728 | period = ((data[0] << 8) | data[1]) * |
729 | MCE_TIME_UNIT / 1000; |
730 | dev_dbg(dev, "%s receive timeout of %d ms" , |
731 | inout, period); |
732 | break; |
733 | case MCE_CMD_GETIRTIMEOUT: |
734 | dev_dbg(dev, "Get receive timeout" ); |
735 | break; |
736 | case MCE_CMD_GETIRTXPORTS: |
737 | dev_dbg(dev, "Get transmit blaster mask" ); |
738 | break; |
739 | case MCE_RSP_EQIRRXPORTEN: |
740 | dev_dbg(dev, "%s %s-range receive sensor in use" , |
741 | inout, data[0] == 0x02 ? "short" : "long" ); |
742 | break; |
743 | case MCE_CMD_GETIRRXPORTEN: |
744 | /* aka MCE_RSP_EQIRRXCFCNT */ |
745 | if (out) |
746 | dev_dbg(dev, "Get receive sensor" ); |
747 | else |
748 | dev_dbg(dev, "RX carrier cycle count: %d" , |
749 | ((data[0] << 8) | data[1])); |
750 | break; |
751 | case MCE_RSP_EQIRNUMPORTS: |
752 | if (out) |
753 | break; |
754 | dev_dbg(dev, "Num TX ports: %x, num RX ports: %x" , |
755 | data[0], data[1]); |
756 | break; |
757 | case MCE_RSP_CMD_ILLEGAL: |
758 | dev_dbg(dev, "Illegal PORT_IR command" ); |
759 | break; |
760 | case MCE_RSP_TX_TIMEOUT: |
761 | dev_dbg(dev, "IR TX timeout (TX buffer underrun)" ); |
762 | break; |
763 | default: |
764 | dev_dbg(dev, "Unknown command 0x%02x 0x%02x" , |
765 | cmd, subcmd); |
766 | break; |
767 | } |
768 | break; |
769 | default: |
770 | break; |
771 | } |
772 | #endif |
773 | } |
774 | |
775 | /* |
776 | * Schedule work that can't be done in interrupt handlers |
777 | * (mceusb_dev_recv() and mce_write_callback()) nor tasklets. |
778 | * Invokes mceusb_deferred_kevent() for recovering from |
779 | * error events specified by the kevent bit field. |
780 | */ |
781 | static void mceusb_defer_kevent(struct mceusb_dev *ir, int kevent) |
782 | { |
783 | set_bit(nr: kevent, addr: &ir->kevent_flags); |
784 | |
785 | if (test_bit(EVENT_RST_PEND, &ir->kevent_flags)) { |
786 | dev_dbg(ir->dev, "kevent %d dropped pending USB Reset Device" , |
787 | kevent); |
788 | return; |
789 | } |
790 | |
791 | if (!schedule_work(work: &ir->kevent)) |
792 | dev_dbg(ir->dev, "kevent %d already scheduled" , kevent); |
793 | else |
794 | dev_dbg(ir->dev, "kevent %d scheduled" , kevent); |
795 | } |
796 | |
797 | static void mce_write_callback(struct urb *urb) |
798 | { |
799 | if (!urb) |
800 | return; |
801 | |
802 | complete(urb->context); |
803 | } |
804 | |
805 | /* |
806 | * Write (TX/send) data to MCE device USB endpoint out. |
807 | * Used for IR blaster TX and MCE device commands. |
808 | * |
809 | * Return: The number of bytes written (> 0) or errno (< 0). |
810 | */ |
811 | static int mce_write(struct mceusb_dev *ir, u8 *data, int size) |
812 | { |
813 | int ret; |
814 | struct urb *urb; |
815 | struct device *dev = ir->dev; |
816 | unsigned char *buf_out; |
817 | struct completion tx_done; |
818 | unsigned long expire; |
819 | unsigned long ret_wait; |
820 | |
821 | mceusb_dev_printdata(ir, buf: data, buf_len: size, offset: 0, len: size, out: true); |
822 | |
823 | urb = usb_alloc_urb(iso_packets: 0, GFP_KERNEL); |
824 | if (unlikely(!urb)) { |
825 | dev_err(dev, "Error: mce write couldn't allocate urb" ); |
826 | return -ENOMEM; |
827 | } |
828 | |
829 | buf_out = kmalloc(size, GFP_KERNEL); |
830 | if (!buf_out) { |
831 | usb_free_urb(urb); |
832 | return -ENOMEM; |
833 | } |
834 | |
835 | init_completion(x: &tx_done); |
836 | |
837 | /* outbound data */ |
838 | if (usb_endpoint_xfer_int(epd: ir->usb_ep_out)) |
839 | usb_fill_int_urb(urb, dev: ir->usbdev, pipe: ir->pipe_out, |
840 | transfer_buffer: buf_out, buffer_length: size, complete_fn: mce_write_callback, context: &tx_done, |
841 | interval: ir->usb_ep_out->bInterval); |
842 | else |
843 | usb_fill_bulk_urb(urb, dev: ir->usbdev, pipe: ir->pipe_out, |
844 | transfer_buffer: buf_out, buffer_length: size, complete_fn: mce_write_callback, context: &tx_done); |
845 | memcpy(buf_out, data, size); |
846 | |
847 | ret = usb_submit_urb(urb, GFP_KERNEL); |
848 | if (ret) { |
849 | dev_err(dev, "Error: mce write submit urb error = %d" , ret); |
850 | kfree(objp: buf_out); |
851 | usb_free_urb(urb); |
852 | return ret; |
853 | } |
854 | |
855 | expire = msecs_to_jiffies(USB_TX_TIMEOUT); |
856 | ret_wait = wait_for_completion_timeout(x: &tx_done, timeout: expire); |
857 | if (!ret_wait) { |
858 | dev_err(dev, "Error: mce write timed out (expire = %lu (%dms))" , |
859 | expire, USB_TX_TIMEOUT); |
860 | usb_kill_urb(urb); |
861 | ret = (urb->status == -ENOENT ? -ETIMEDOUT : urb->status); |
862 | } else { |
863 | ret = urb->status; |
864 | } |
865 | if (ret >= 0) |
866 | ret = urb->actual_length; /* bytes written */ |
867 | |
868 | switch (urb->status) { |
869 | /* success */ |
870 | case 0: |
871 | break; |
872 | |
873 | case -ECONNRESET: |
874 | case -ENOENT: |
875 | case -EILSEQ: |
876 | case -ESHUTDOWN: |
877 | break; |
878 | |
879 | case -EPIPE: |
880 | dev_err(ir->dev, "Error: mce write urb status = %d (TX HALT)" , |
881 | urb->status); |
882 | mceusb_defer_kevent(ir, EVENT_TX_HALT); |
883 | break; |
884 | |
885 | default: |
886 | dev_err(ir->dev, "Error: mce write urb status = %d" , |
887 | urb->status); |
888 | break; |
889 | } |
890 | |
891 | dev_dbg(dev, "tx done status = %d (wait = %lu, expire = %lu (%dms), urb->actual_length = %d, urb->status = %d)" , |
892 | ret, ret_wait, expire, USB_TX_TIMEOUT, |
893 | urb->actual_length, urb->status); |
894 | |
895 | kfree(objp: buf_out); |
896 | usb_free_urb(urb); |
897 | |
898 | return ret; |
899 | } |
900 | |
901 | static void mce_command_out(struct mceusb_dev *ir, u8 *data, int size) |
902 | { |
903 | int rsize = sizeof(DEVICE_RESUME); |
904 | |
905 | if (ir->need_reset) { |
906 | ir->need_reset = false; |
907 | mce_write(ir, data: DEVICE_RESUME, size: rsize); |
908 | msleep(msecs: 10); |
909 | } |
910 | |
911 | mce_write(ir, data, size); |
912 | msleep(msecs: 10); |
913 | } |
914 | |
915 | /* |
916 | * Transmit IR out the MCE device IR blaster port(s). |
917 | * |
918 | * Convert IR pulse/space sequence from LIRC to MCE format. |
919 | * Break up a long IR sequence into multiple parts (MCE IR data packets). |
920 | * |
921 | * u32 txbuf[] consists of IR pulse, space, ..., and pulse times in usec. |
922 | * Pulses and spaces are implicit by their position. |
923 | * The first IR sample, txbuf[0], is always a pulse. |
924 | * |
925 | * u8 irbuf[] consists of multiple IR data packets for the MCE device. |
926 | * A packet is 1 u8 MCE_IRDATA_HEADER and up to 30 u8 IR samples. |
927 | * An IR sample is 1-bit pulse/space flag with 7-bit time |
928 | * in MCE time units (50usec). |
929 | * |
930 | * Return: The number of IR samples sent (> 0) or errno (< 0). |
931 | */ |
932 | static int mceusb_tx_ir(struct rc_dev *dev, unsigned *txbuf, unsigned count) |
933 | { |
934 | struct mceusb_dev *ir = dev->priv; |
935 | u8 cmdbuf[3] = { MCE_CMD_PORT_IR, MCE_CMD_SETIRTXPORTS, 0x00 }; |
936 | u8 irbuf[MCE_IRBUF_SIZE]; |
937 | int ircount = 0; |
938 | unsigned int irsample; |
939 | int i, length, ret; |
940 | |
941 | /* Send the set TX ports command */ |
942 | cmdbuf[2] = ir->tx_mask; |
943 | mce_command_out(ir, data: cmdbuf, size: sizeof(cmdbuf)); |
944 | |
945 | /* Generate mce IR data packet */ |
946 | for (i = 0; i < count; i++) { |
947 | irsample = txbuf[i] / MCE_TIME_UNIT; |
948 | |
949 | /* loop to support long pulses/spaces > 6350us (127*50us) */ |
950 | while (irsample > 0) { |
951 | /* Insert IR header every 30th entry */ |
952 | if (ircount % MCE_PACKET_SIZE == 0) { |
953 | /* Room for IR header and one IR sample? */ |
954 | if (ircount >= MCE_IRBUF_SIZE - 1) { |
955 | /* Send near full buffer */ |
956 | ret = mce_write(ir, data: irbuf, size: ircount); |
957 | if (ret < 0) |
958 | return ret; |
959 | ircount = 0; |
960 | } |
961 | irbuf[ircount++] = MCE_IRDATA_HEADER; |
962 | } |
963 | |
964 | /* Insert IR sample */ |
965 | if (irsample <= MCE_MAX_PULSE_LENGTH) { |
966 | irbuf[ircount] = irsample; |
967 | irsample = 0; |
968 | } else { |
969 | irbuf[ircount] = MCE_MAX_PULSE_LENGTH; |
970 | irsample -= MCE_MAX_PULSE_LENGTH; |
971 | } |
972 | /* |
973 | * Even i = IR pulse |
974 | * Odd i = IR space |
975 | */ |
976 | irbuf[ircount] |= (i & 1 ? 0 : MCE_PULSE_BIT); |
977 | ircount++; |
978 | |
979 | /* IR buffer full? */ |
980 | if (ircount >= MCE_IRBUF_SIZE) { |
981 | /* Fix packet length in last header */ |
982 | length = ircount % MCE_PACKET_SIZE; |
983 | if (length > 0) |
984 | irbuf[ircount - length] -= |
985 | MCE_PACKET_SIZE - length; |
986 | /* Send full buffer */ |
987 | ret = mce_write(ir, data: irbuf, size: ircount); |
988 | if (ret < 0) |
989 | return ret; |
990 | ircount = 0; |
991 | } |
992 | } |
993 | } /* after for loop, 0 <= ircount < MCE_IRBUF_SIZE */ |
994 | |
995 | /* Fix packet length in last header */ |
996 | length = ircount % MCE_PACKET_SIZE; |
997 | if (length > 0) |
998 | irbuf[ircount - length] -= MCE_PACKET_SIZE - length; |
999 | |
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, data: irbuf, size: 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, data: cmdbuf, size: 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, data: cmdbuf, size: 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_UP(timeout, MCE_TIME_UNIT); |
1081 | |
1082 | cmdbuf[2] = units >> 8; |
1083 | cmdbuf[3] = units; |
1084 | |
1085 | mce_command_out(ir, data: cmdbuf, size: sizeof(cmdbuf)); |
1086 | |
1087 | /* get receiver timeout value */ |
1088 | mce_command_out(ir, data: GET_RX_TIMEOUT, size: 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, data: cmdbuf, size: 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, data: cmdbuf, size: 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, data: cmdbuf, size: 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(dev: ir->rc, ev: &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(cmd: ir->cmd, subcmd: ir->buf_in[i]); |
1282 | mceusb_dev_printdata(ir, buf: ir->buf_in, buf_len, offset: i - 1, |
1283 | len: ir->rem + 2, out: false); |
1284 | if (i + ir->rem < buf_len) |
1285 | mceusb_handle_command(ir, buf_in: &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(dev: ir->rc, ev: &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, buf: ir->buf_in, buf_len, |
1332 | offset: i, len: ir->rem + 1, out: 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(dev: ir->rc, |
1342 | ev: &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(dev: 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, buf_len: 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, data: GET_EMVER, size: 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(dev: ir->usbdev, endpoint: 0, USB_REQ_SET_ADDRESS, |
1426 | USB_DIR_IN | USB_TYPE_VENDOR, |
1427 | value: 0, index: 0, data, USB_CTRL_MSG_SZ, timeout: 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(dev: ir->usbdev, endpoint: 0, |
1435 | USB_REQ_SET_FEATURE, USB_TYPE_VENDOR, |
1436 | value: 0xc04e, index: 0x0000, NULL, size: 0, timeout: 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(dev: ir->usbdev, endpoint: 0, |
1442 | request: 4, USB_TYPE_VENDOR, |
1443 | value: 0x0808, index: 0x0000, NULL, size: 0, timeout: 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(dev: ir->usbdev, endpoint: 0, |
1448 | request: 2, USB_TYPE_VENDOR, |
1449 | value: 0x0000, index: 0x0100, NULL, size: 0, timeout: 3000, GFP_KERNEL); |
1450 | dev_dbg(dev, "set handshake - retC = %d" , ret); |
1451 | |
1452 | /* device resume */ |
1453 | mce_command_out(ir, data: DEVICE_RESUME, size: sizeof(DEVICE_RESUME)); |
1454 | |
1455 | /* get hw/sw revision? */ |
1456 | mce_command_out(ir, data: GET_REVISION, size: sizeof(GET_REVISION)); |
1457 | } |
1458 | |
1459 | static void mceusb_gen2_init(struct mceusb_dev *ir) |
1460 | { |
1461 | /* device resume */ |
1462 | mce_command_out(ir, data: DEVICE_RESUME, size: sizeof(DEVICE_RESUME)); |
1463 | |
1464 | /* get wake version (protocol, key, address) */ |
1465 | mce_command_out(ir, data: GET_WAKEVERSION, size: sizeof(GET_WAKEVERSION)); |
1466 | |
1467 | /* unknown what this one actually returns... */ |
1468 | mce_command_out(ir, data: GET_UNKNOWN2, size: 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, data: GET_NUM_PORTS, size: sizeof(GET_NUM_PORTS)); |
1483 | |
1484 | /* get the carrier and frequency */ |
1485 | mce_command_out(ir, data: GET_CARRIER_FREQ, size: sizeof(GET_CARRIER_FREQ)); |
1486 | |
1487 | if (ir->num_txports && !ir->flags.no_tx) |
1488 | /* get the transmitter bitmask */ |
1489 | mce_command_out(ir, data: GET_TX_BITMASK, size: sizeof(GET_TX_BITMASK)); |
1490 | |
1491 | /* get receiver timeout value */ |
1492 | mce_command_out(ir, data: GET_RX_TIMEOUT, size: sizeof(GET_RX_TIMEOUT)); |
1493 | |
1494 | /* get receiver sensor setting */ |
1495 | mce_command_out(ir, data: GET_RX_SENSOR, size: sizeof(GET_RX_SENSOR)); |
1496 | |
1497 | for (i = 0; i < ir->num_txports; i++) { |
1498 | cmdbuf[2] = i; |
1499 | mce_command_out(ir, data: cmdbuf, size: 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, data: FLASH_LED, size: 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(urb: ir->urb_in); |
1534 | status = usb_clear_halt(dev: ir->usbdev, pipe: 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(dev: ir->usbintf); |
1544 | set_bit(EVENT_RST_PEND, addr: &ir->kevent_flags); |
1545 | clear_bit(EVENT_RX_HALT, addr: &ir->kevent_flags); |
1546 | |
1547 | /* Cancel all other error events and handlers */ |
1548 | clear_bit(EVENT_TX_HALT, addr: &ir->kevent_flags); |
1549 | return; |
1550 | } |
1551 | clear_bit(EVENT_RX_HALT, addr: &ir->kevent_flags); |
1552 | status = usb_submit_urb(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(dev: ir->usbdev, pipe: 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(dev: ir->usbintf); |
1570 | set_bit(EVENT_RST_PEND, addr: &ir->kevent_flags); |
1571 | clear_bit(EVENT_TX_HALT, addr: &ir->kevent_flags); |
1572 | |
1573 | /* Cancel all other error events and handlers */ |
1574 | clear_bit(EVENT_RX_HALT, addr: &ir->kevent_flags); |
1575 | return; |
1576 | } |
1577 | clear_bit(EVENT_TX_HALT, addr: &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(buf: ir->name, size: sizeof(ir->name), fmt: "%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(dev: ir->usbdev, buf: ir->phys, size: sizeof(ir->phys)); |
1602 | |
1603 | rc->device_name = ir->name; |
1604 | rc->input_phys = ir->phys; |
1605 | usb_to_input_id(dev: ir->usbdev, id: &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(dev: 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(dev: 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(epd: ep)) { |
1695 | ep_in = ep; |
1696 | dev_dbg(&intf->dev, "acceptable bulk inbound endpoint found\n" ); |
1697 | } else if (usb_endpoint_is_int_in(epd: 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(epd: ep)) { |
1706 | ep_out = ep; |
1707 | dev_dbg(&intf->dev, "acceptable bulk outbound endpoint found\n" ); |
1708 | } else if (usb_endpoint_is_int_out(epd: 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(epd: ep_in)) |
1721 | pipe = usb_rcvintpipe(dev, ep_in->bEndpointAddress); |
1722 | else |
1723 | pipe = usb_rcvbulkpipe(dev, ep_in->bEndpointAddress); |
1724 | maxp = usb_maxpacket(udev: dev, pipe); |
1725 | |
1726 | ir = kzalloc(size: 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, size: maxp, GFP_KERNEL, dma: &ir->dma_in); |
1732 | if (!ir->buf_in) |
1733 | goto buf_in_alloc_fail; |
1734 | |
1735 | ir->urb_in = usb_alloc_urb(iso_packets: 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(epd: 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, index: dev->descriptor.iManufacturer, |
1760 | buf, size: sizeof(buf)) > 0) |
1761 | strscpy(p: name, q: buf, size: sizeof(name)); |
1762 | if (dev->descriptor.iProduct |
1763 | && usb_string(dev, index: dev->descriptor.iProduct, |
1764 | buf, size: sizeof(buf)) > 0) |
1765 | snprintf(buf: name + strlen(name), size: sizeof(name) - strlen(name), |
1766 | fmt: " %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(epd: ep_in)) |
1780 | usb_fill_int_urb(urb: ir->urb_in, dev, pipe, transfer_buffer: ir->buf_in, buffer_length: maxp, |
1781 | complete_fn: mceusb_dev_recv, context: ir, interval: ep_in->bInterval); |
1782 | else |
1783 | usb_fill_bulk_urb(urb: ir->urb_in, dev, pipe, transfer_buffer: ir->buf_in, buffer_length: maxp, |
1784 | complete_fn: mceusb_dev_recv, context: 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(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(dev: ir->rc, MCE_DEFAULT_TX_MASK); |
1810 | |
1811 | usb_set_intfdata(intf, data: ir); |
1812 | |
1813 | /* enable wake via this device */ |
1814 | device_set_wakeup_capable(dev: ir->dev, capable: true); |
1815 | device_set_wakeup_enable(dev: ir->dev, enable: 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(work: &ir->kevent); |
1828 | usb_put_dev(dev: ir->usbdev); |
1829 | usb_kill_urb(urb: ir->urb_in); |
1830 | usb_free_urb(urb: ir->urb_in); |
1831 | urb_in_alloc_fail: |
1832 | usb_free_coherent(dev, size: maxp, addr: ir->buf_in, dma: ir->dma_in); |
1833 | buf_in_alloc_fail: |
1834 | kfree(objp: 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(work: &ir->kevent); |
1856 | rc_unregister_device(dev: ir->rc); |
1857 | usb_kill_urb(urb: ir->urb_in); |
1858 | usb_free_urb(urb: ir->urb_in); |
1859 | usb_free_coherent(dev, size: ir->len_in, addr: ir->buf_in, dma: ir->dma_in); |
1860 | usb_put_dev(dev); |
1861 | |
1862 | kfree(objp: 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(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(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); |
1898 | |