mceusb.c 54 KB

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