ttusbir.c 9.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * TechnoTrend USB IR Receiver
  4. *
  5. * Copyright (C) 2012 Sean Young <[email protected]>
  6. */
  7. #include <linux/module.h>
  8. #include <linux/usb.h>
  9. #include <linux/usb/input.h>
  10. #include <linux/slab.h>
  11. #include <linux/leds.h>
  12. #include <media/rc-core.h>
  13. #define DRIVER_NAME "ttusbir"
  14. #define DRIVER_DESC "TechnoTrend USB IR Receiver"
  15. /*
  16. * The Windows driver uses 8 URBS, the original lirc drivers has a
  17. * configurable amount (2 default, 4 max). This device generates about 125
  18. * messages per second (!), whether IR is idle or not.
  19. */
  20. #define NUM_URBS 4
  21. #define US_PER_BYTE 62
  22. #define US_PER_BIT (US_PER_BYTE / 8)
  23. struct ttusbir {
  24. struct rc_dev *rc;
  25. struct device *dev;
  26. struct usb_device *udev;
  27. struct urb *urb[NUM_URBS];
  28. struct led_classdev led;
  29. struct urb *bulk_urb;
  30. uint8_t bulk_buffer[5];
  31. int bulk_out_endp, iso_in_endp;
  32. bool led_on, is_led_on;
  33. atomic_t led_complete;
  34. char phys[64];
  35. };
  36. static enum led_brightness ttusbir_brightness_get(struct led_classdev *led_dev)
  37. {
  38. struct ttusbir *tt = container_of(led_dev, struct ttusbir, led);
  39. return tt->led_on ? LED_FULL : LED_OFF;
  40. }
  41. static void ttusbir_set_led(struct ttusbir *tt)
  42. {
  43. int ret;
  44. smp_mb();
  45. if (tt->led_on != tt->is_led_on && tt->udev &&
  46. atomic_add_unless(&tt->led_complete, 1, 1)) {
  47. tt->bulk_buffer[4] = tt->is_led_on = tt->led_on;
  48. ret = usb_submit_urb(tt->bulk_urb, GFP_ATOMIC);
  49. if (ret) {
  50. dev_warn(tt->dev, "failed to submit bulk urb: %d\n",
  51. ret);
  52. atomic_dec(&tt->led_complete);
  53. }
  54. }
  55. }
  56. static void ttusbir_brightness_set(struct led_classdev *led_dev, enum
  57. led_brightness brightness)
  58. {
  59. struct ttusbir *tt = container_of(led_dev, struct ttusbir, led);
  60. tt->led_on = brightness != LED_OFF;
  61. ttusbir_set_led(tt);
  62. }
  63. /*
  64. * The urb cannot be reused until the urb completes
  65. */
  66. static void ttusbir_bulk_complete(struct urb *urb)
  67. {
  68. struct ttusbir *tt = urb->context;
  69. atomic_dec(&tt->led_complete);
  70. switch (urb->status) {
  71. case 0:
  72. break;
  73. case -ECONNRESET:
  74. case -ENOENT:
  75. case -ESHUTDOWN:
  76. return;
  77. case -EPIPE:
  78. default:
  79. dev_dbg(tt->dev, "Error: urb status = %d\n", urb->status);
  80. break;
  81. }
  82. ttusbir_set_led(tt);
  83. }
  84. /*
  85. * The data is one bit per sample, a set bit signifying silence and samples
  86. * being MSB first. Bit 0 can contain garbage so take it to be whatever
  87. * bit 1 is, so we don't have unexpected edges.
  88. */
  89. static void ttusbir_process_ir_data(struct ttusbir *tt, uint8_t *buf)
  90. {
  91. struct ir_raw_event rawir = {};
  92. unsigned i, v, b;
  93. bool event = false;
  94. for (i = 0; i < 128; i++) {
  95. v = buf[i] & 0xfe;
  96. switch (v) {
  97. case 0xfe:
  98. rawir.pulse = false;
  99. rawir.duration = US_PER_BYTE;
  100. if (ir_raw_event_store_with_filter(tt->rc, &rawir))
  101. event = true;
  102. break;
  103. case 0:
  104. rawir.pulse = true;
  105. rawir.duration = US_PER_BYTE;
  106. if (ir_raw_event_store_with_filter(tt->rc, &rawir))
  107. event = true;
  108. break;
  109. default:
  110. /* one edge per byte */
  111. if (v & 2) {
  112. b = ffz(v | 1);
  113. rawir.pulse = true;
  114. } else {
  115. b = ffs(v) - 1;
  116. rawir.pulse = false;
  117. }
  118. rawir.duration = US_PER_BIT * (8 - b);
  119. if (ir_raw_event_store_with_filter(tt->rc, &rawir))
  120. event = true;
  121. rawir.pulse = !rawir.pulse;
  122. rawir.duration = US_PER_BIT * b;
  123. if (ir_raw_event_store_with_filter(tt->rc, &rawir))
  124. event = true;
  125. break;
  126. }
  127. }
  128. /* don't wakeup when there's nothing to do */
  129. if (event)
  130. ir_raw_event_handle(tt->rc);
  131. }
  132. static void ttusbir_urb_complete(struct urb *urb)
  133. {
  134. struct ttusbir *tt = urb->context;
  135. int rc;
  136. switch (urb->status) {
  137. case 0:
  138. ttusbir_process_ir_data(tt, urb->transfer_buffer);
  139. break;
  140. case -ECONNRESET:
  141. case -ENOENT:
  142. case -ESHUTDOWN:
  143. return;
  144. case -EPIPE:
  145. default:
  146. dev_dbg(tt->dev, "Error: urb status = %d\n", urb->status);
  147. break;
  148. }
  149. rc = usb_submit_urb(urb, GFP_ATOMIC);
  150. if (rc && rc != -ENODEV)
  151. dev_warn(tt->dev, "failed to resubmit urb: %d\n", rc);
  152. }
  153. static int ttusbir_probe(struct usb_interface *intf,
  154. const struct usb_device_id *id)
  155. {
  156. struct ttusbir *tt;
  157. struct usb_interface_descriptor *idesc;
  158. struct usb_endpoint_descriptor *desc;
  159. struct rc_dev *rc;
  160. int i, j, ret;
  161. int altsetting = -1;
  162. tt = kzalloc(sizeof(*tt), GFP_KERNEL);
  163. rc = rc_allocate_device(RC_DRIVER_IR_RAW);
  164. if (!tt || !rc) {
  165. ret = -ENOMEM;
  166. goto out;
  167. }
  168. /* find the correct alt setting */
  169. for (i = 0; i < intf->num_altsetting && altsetting == -1; i++) {
  170. int max_packet, bulk_out_endp = -1, iso_in_endp = -1;
  171. idesc = &intf->altsetting[i].desc;
  172. for (j = 0; j < idesc->bNumEndpoints; j++) {
  173. desc = &intf->altsetting[i].endpoint[j].desc;
  174. max_packet = le16_to_cpu(desc->wMaxPacketSize);
  175. if (usb_endpoint_dir_in(desc) &&
  176. usb_endpoint_xfer_isoc(desc) &&
  177. max_packet == 0x10)
  178. iso_in_endp = j;
  179. else if (usb_endpoint_dir_out(desc) &&
  180. usb_endpoint_xfer_bulk(desc) &&
  181. max_packet == 0x20)
  182. bulk_out_endp = j;
  183. if (bulk_out_endp != -1 && iso_in_endp != -1) {
  184. tt->bulk_out_endp = bulk_out_endp;
  185. tt->iso_in_endp = iso_in_endp;
  186. altsetting = i;
  187. break;
  188. }
  189. }
  190. }
  191. if (altsetting == -1) {
  192. dev_err(&intf->dev, "cannot find expected altsetting\n");
  193. ret = -ENODEV;
  194. goto out;
  195. }
  196. tt->dev = &intf->dev;
  197. tt->udev = interface_to_usbdev(intf);
  198. tt->rc = rc;
  199. ret = usb_set_interface(tt->udev, 0, altsetting);
  200. if (ret)
  201. goto out;
  202. for (i = 0; i < NUM_URBS; i++) {
  203. struct urb *urb = usb_alloc_urb(8, GFP_KERNEL);
  204. void *buffer;
  205. if (!urb) {
  206. ret = -ENOMEM;
  207. goto out;
  208. }
  209. urb->dev = tt->udev;
  210. urb->context = tt;
  211. urb->pipe = usb_rcvisocpipe(tt->udev, tt->iso_in_endp);
  212. urb->interval = 1;
  213. buffer = usb_alloc_coherent(tt->udev, 128, GFP_KERNEL,
  214. &urb->transfer_dma);
  215. if (!buffer) {
  216. usb_free_urb(urb);
  217. ret = -ENOMEM;
  218. goto out;
  219. }
  220. urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP | URB_ISO_ASAP;
  221. urb->transfer_buffer = buffer;
  222. urb->complete = ttusbir_urb_complete;
  223. urb->number_of_packets = 8;
  224. urb->transfer_buffer_length = 128;
  225. for (j = 0; j < 8; j++) {
  226. urb->iso_frame_desc[j].offset = j * 16;
  227. urb->iso_frame_desc[j].length = 16;
  228. }
  229. tt->urb[i] = urb;
  230. }
  231. tt->bulk_urb = usb_alloc_urb(0, GFP_KERNEL);
  232. if (!tt->bulk_urb) {
  233. ret = -ENOMEM;
  234. goto out;
  235. }
  236. tt->bulk_buffer[0] = 0xaa;
  237. tt->bulk_buffer[1] = 0x01;
  238. tt->bulk_buffer[2] = 0x05;
  239. tt->bulk_buffer[3] = 0x01;
  240. usb_fill_bulk_urb(tt->bulk_urb, tt->udev, usb_sndbulkpipe(tt->udev,
  241. tt->bulk_out_endp), tt->bulk_buffer, sizeof(tt->bulk_buffer),
  242. ttusbir_bulk_complete, tt);
  243. tt->led.name = "ttusbir:green:power";
  244. tt->led.default_trigger = "rc-feedback";
  245. tt->led.brightness_set = ttusbir_brightness_set;
  246. tt->led.brightness_get = ttusbir_brightness_get;
  247. tt->is_led_on = tt->led_on = true;
  248. atomic_set(&tt->led_complete, 0);
  249. ret = led_classdev_register(&intf->dev, &tt->led);
  250. if (ret)
  251. goto out;
  252. usb_make_path(tt->udev, tt->phys, sizeof(tt->phys));
  253. rc->device_name = DRIVER_DESC;
  254. rc->input_phys = tt->phys;
  255. usb_to_input_id(tt->udev, &rc->input_id);
  256. rc->dev.parent = &intf->dev;
  257. rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
  258. rc->priv = tt;
  259. rc->driver_name = DRIVER_NAME;
  260. rc->map_name = RC_MAP_TT_1500;
  261. rc->min_timeout = 1;
  262. rc->timeout = IR_DEFAULT_TIMEOUT;
  263. rc->max_timeout = 10 * IR_DEFAULT_TIMEOUT;
  264. /*
  265. * The precision is US_PER_BIT, but since every 8th bit can be
  266. * overwritten with garbage the accuracy is at best 2 * US_PER_BIT.
  267. */
  268. rc->rx_resolution = 2 * US_PER_BIT;
  269. ret = rc_register_device(rc);
  270. if (ret) {
  271. dev_err(&intf->dev, "failed to register rc device %d\n", ret);
  272. goto out2;
  273. }
  274. usb_set_intfdata(intf, tt);
  275. for (i = 0; i < NUM_URBS; i++) {
  276. ret = usb_submit_urb(tt->urb[i], GFP_KERNEL);
  277. if (ret) {
  278. dev_err(tt->dev, "failed to submit urb %d\n", ret);
  279. goto out3;
  280. }
  281. }
  282. return 0;
  283. out3:
  284. rc_unregister_device(rc);
  285. rc = NULL;
  286. out2:
  287. led_classdev_unregister(&tt->led);
  288. out:
  289. if (tt) {
  290. for (i = 0; i < NUM_URBS && tt->urb[i]; i++) {
  291. struct urb *urb = tt->urb[i];
  292. usb_kill_urb(urb);
  293. usb_free_coherent(tt->udev, 128, urb->transfer_buffer,
  294. urb->transfer_dma);
  295. usb_free_urb(urb);
  296. }
  297. usb_kill_urb(tt->bulk_urb);
  298. usb_free_urb(tt->bulk_urb);
  299. kfree(tt);
  300. }
  301. rc_free_device(rc);
  302. return ret;
  303. }
  304. static void ttusbir_disconnect(struct usb_interface *intf)
  305. {
  306. struct ttusbir *tt = usb_get_intfdata(intf);
  307. struct usb_device *udev = tt->udev;
  308. int i;
  309. tt->udev = NULL;
  310. rc_unregister_device(tt->rc);
  311. led_classdev_unregister(&tt->led);
  312. for (i = 0; i < NUM_URBS; i++) {
  313. usb_kill_urb(tt->urb[i]);
  314. usb_free_coherent(udev, 128, tt->urb[i]->transfer_buffer,
  315. tt->urb[i]->transfer_dma);
  316. usb_free_urb(tt->urb[i]);
  317. }
  318. usb_kill_urb(tt->bulk_urb);
  319. usb_free_urb(tt->bulk_urb);
  320. usb_set_intfdata(intf, NULL);
  321. kfree(tt);
  322. }
  323. static int ttusbir_suspend(struct usb_interface *intf, pm_message_t message)
  324. {
  325. struct ttusbir *tt = usb_get_intfdata(intf);
  326. int i;
  327. for (i = 0; i < NUM_URBS; i++)
  328. usb_kill_urb(tt->urb[i]);
  329. led_classdev_suspend(&tt->led);
  330. usb_kill_urb(tt->bulk_urb);
  331. return 0;
  332. }
  333. static int ttusbir_resume(struct usb_interface *intf)
  334. {
  335. struct ttusbir *tt = usb_get_intfdata(intf);
  336. int i, rc;
  337. tt->is_led_on = true;
  338. led_classdev_resume(&tt->led);
  339. for (i = 0; i < NUM_URBS; i++) {
  340. rc = usb_submit_urb(tt->urb[i], GFP_NOIO);
  341. if (rc) {
  342. dev_warn(tt->dev, "failed to submit urb: %d\n", rc);
  343. break;
  344. }
  345. }
  346. return rc;
  347. }
  348. static const struct usb_device_id ttusbir_table[] = {
  349. { USB_DEVICE(0x0b48, 0x2003) },
  350. { }
  351. };
  352. static struct usb_driver ttusbir_driver = {
  353. .name = DRIVER_NAME,
  354. .id_table = ttusbir_table,
  355. .probe = ttusbir_probe,
  356. .suspend = ttusbir_suspend,
  357. .resume = ttusbir_resume,
  358. .reset_resume = ttusbir_resume,
  359. .disconnect = ttusbir_disconnect,
  360. };
  361. module_usb_driver(ttusbir_driver);
  362. MODULE_DESCRIPTION(DRIVER_DESC);
  363. MODULE_AUTHOR("Sean Young <[email protected]>");
  364. MODULE_LICENSE("GPL");
  365. MODULE_DEVICE_TABLE(usb, ttusbir_table);