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