1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * IguanaWorks USB IR Transceiver support
5 * Copyright (C) 2012 Sean Young <sean@mess.org>
8 #include <linux/device.h>
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/usb.h>
12 #include <linux/usb/input.h>
13 #include <linux/slab.h>
14 #include <linux/completion.h>
15 #include <media/rc-core.h>
23 struct usb_device
*udev
;
27 uint8_t cycle_overhead
;
29 /* receiver support */
31 dma_addr_t dma_in
, dma_out
;
33 struct urb
*urb_in
, *urb_out
;
34 struct completion completion
;
36 /* transmit support */
39 struct send_packet
*packet
;
46 #define CMD_GET_VERSION 0x01
47 #define CMD_GET_BUFSIZE 0x11
48 #define CMD_GET_FEATURES 0x10
50 #define CMD_EXECUTE 0x1f
51 #define CMD_RX_OVERFLOW 0x31
52 #define CMD_TX_OVERFLOW 0x32
53 #define CMD_RECEIVER_ON 0x12
54 #define CMD_RECEIVER_OFF 0x14
59 #define MAX_IN_PACKET 8u
60 #define MAX_OUT_PACKET (sizeof(struct send_packet) + BUF_SIZE)
62 #define RX_RESOLUTION 21
79 static void process_ir_data(struct iguanair
*ir
, unsigned len
)
81 if (len
>= 4 && ir
->buf_in
[0] == 0 && ir
->buf_in
[1] == 0) {
82 switch (ir
->buf_in
[3]) {
85 ir
->version
= (ir
->buf_in
[5] << 8) |
87 complete(&ir
->completion
);
92 ir
->bufsize
= ir
->buf_in
[4];
93 complete(&ir
->completion
);
96 case CMD_GET_FEATURES
:
98 ir
->cycle_overhead
= ir
->buf_in
[5];
99 complete(&ir
->completion
);
102 case CMD_TX_OVERFLOW
:
103 ir
->tx_overflow
= true;
105 case CMD_RECEIVER_OFF
:
106 case CMD_RECEIVER_ON
:
108 complete(&ir
->completion
);
110 case CMD_RX_OVERFLOW
:
111 dev_warn(ir
->dev
, "receive overflow\n");
112 ir_raw_event_reset(ir
->rc
);
115 dev_warn(ir
->dev
, "control code %02x received\n",
119 } else if (len
>= 7) {
120 struct ir_raw_event rawir
= {};
124 for (i
= 0; i
< 7; i
++) {
125 if (ir
->buf_in
[i
] == 0x80) {
127 rawir
.duration
= 21845;
129 rawir
.pulse
= (ir
->buf_in
[i
] & 0x80) == 0;
130 rawir
.duration
= ((ir
->buf_in
[i
] & 0x7f) + 1) *
134 if (ir_raw_event_store_with_filter(ir
->rc
, &rawir
))
139 ir_raw_event_handle(ir
->rc
);
143 static void iguanair_rx(struct urb
*urb
)
157 switch (urb
->status
) {
159 process_ir_data(ir
, urb
->actual_length
);
168 dev_dbg(ir
->dev
, "Error: urb status = %d\n", urb
->status
);
172 rc
= usb_submit_urb(urb
, GFP_ATOMIC
);
173 if (rc
&& rc
!= -ENODEV
)
174 dev_warn(ir
->dev
, "failed to resubmit urb: %d\n", rc
);
177 static void iguanair_irq_out(struct urb
*urb
)
179 struct iguanair
*ir
= urb
->context
;
182 dev_dbg(ir
->dev
, "Error: out urb status = %d\n", urb
->status
);
184 /* if we sent an nop packet, do not expect a response */
185 if (urb
->status
== 0 && ir
->packet
->header
.cmd
== CMD_NOP
)
186 complete(&ir
->completion
);
189 static int iguanair_send(struct iguanair
*ir
, unsigned size
)
193 reinit_completion(&ir
->completion
);
195 ir
->urb_out
->transfer_buffer_length
= size
;
196 rc
= usb_submit_urb(ir
->urb_out
, GFP_KERNEL
);
200 if (wait_for_completion_timeout(&ir
->completion
, TIMEOUT
) == 0)
206 static int iguanair_get_features(struct iguanair
*ir
)
211 * On cold boot, the iguanair initializes on the first packet
212 * received but does not process that packet. Send an empty
215 ir
->packet
->header
.start
= 0;
216 ir
->packet
->header
.direction
= DIR_OUT
;
217 ir
->packet
->header
.cmd
= CMD_NOP
;
218 iguanair_send(ir
, sizeof(ir
->packet
->header
));
220 ir
->packet
->header
.cmd
= CMD_GET_VERSION
;
221 rc
= iguanair_send(ir
, sizeof(ir
->packet
->header
));
223 dev_info(ir
->dev
, "failed to get version\n");
227 if (ir
->version
< 0x205) {
228 dev_err(ir
->dev
, "firmware 0x%04x is too old\n", ir
->version
);
234 ir
->cycle_overhead
= 65;
236 ir
->packet
->header
.cmd
= CMD_GET_BUFSIZE
;
238 rc
= iguanair_send(ir
, sizeof(ir
->packet
->header
));
240 dev_info(ir
->dev
, "failed to get buffer size\n");
244 if (ir
->bufsize
> BUF_SIZE
) {
245 dev_info(ir
->dev
, "buffer size %u larger than expected\n",
247 ir
->bufsize
= BUF_SIZE
;
250 ir
->packet
->header
.cmd
= CMD_GET_FEATURES
;
252 rc
= iguanair_send(ir
, sizeof(ir
->packet
->header
));
254 dev_info(ir
->dev
, "failed to get features\n");
259 static int iguanair_receiver(struct iguanair
*ir
, bool enable
)
261 ir
->packet
->header
.start
= 0;
262 ir
->packet
->header
.direction
= DIR_OUT
;
263 ir
->packet
->header
.cmd
= enable
? CMD_RECEIVER_ON
: CMD_RECEIVER_OFF
;
266 ir_raw_event_reset(ir
->rc
);
268 return iguanair_send(ir
, sizeof(ir
->packet
->header
));
272 * The iguanair creates the carrier by busy spinning after each half period.
273 * This is counted in CPU cycles, with the CPU running at 24MHz. It is
274 * broken down into 7-cycles and 4-cyles delays, with a preference for
275 * 4-cycle delays, minus the overhead of the loop itself (cycle_overhead).
277 static int iguanair_set_tx_carrier(struct rc_dev
*dev
, uint32_t carrier
)
279 struct iguanair
*ir
= dev
->priv
;
281 if (carrier
< 25000 || carrier
> 150000)
284 if (carrier
!= ir
->carrier
) {
285 uint32_t cycles
, fours
, sevens
;
287 ir
->carrier
= carrier
;
289 cycles
= DIV_ROUND_CLOSEST(24000000, carrier
* 2) -
293 * Calculate minimum number of 7 cycles needed so
294 * we are left with a multiple of 4; so we want to have
295 * (sevens * 7) & 3 == cycles & 3
297 sevens
= (4 - cycles
) & 3;
298 fours
= (cycles
- sevens
* 7) / 4;
301 * The firmware interprets these values as a relative offset
302 * for a branch. Immediately following the branches, there
303 * 4 instructions of 7 cycles (2 bytes each) and 110
304 * instructions of 4 cycles (1 byte each). A relative branch
305 * of 0 will execute all of them, branch further for less
308 ir
->packet
->busy7
= (4 - sevens
) * 2;
309 ir
->packet
->busy4
= 110 - fours
;
315 static int iguanair_set_tx_mask(struct rc_dev
*dev
, uint32_t mask
)
317 struct iguanair
*ir
= dev
->priv
;
322 ir
->packet
->channels
= mask
<< 4;
327 static int iguanair_tx(struct rc_dev
*dev
, unsigned *txbuf
, unsigned count
)
329 struct iguanair
*ir
= dev
->priv
;
330 unsigned int i
, size
, p
, periods
;
333 /* convert from us to carrier periods */
334 for (i
= size
= 0; i
< count
; i
++) {
335 periods
= DIV_ROUND_CLOSEST(txbuf
[i
] * ir
->carrier
, 1000000);
337 p
= min(periods
, 127u);
338 if (size
>= ir
->bufsize
) {
342 ir
->packet
->payload
[size
++] = p
| ((i
& 1) ? 0x80 : 0);
347 ir
->packet
->header
.start
= 0;
348 ir
->packet
->header
.direction
= DIR_OUT
;
349 ir
->packet
->header
.cmd
= CMD_SEND
;
350 ir
->packet
->length
= size
;
352 ir
->tx_overflow
= false;
354 rc
= iguanair_send(ir
, sizeof(*ir
->packet
) + size
);
356 if (rc
== 0 && ir
->tx_overflow
)
360 return rc
? rc
: count
;
363 static int iguanair_open(struct rc_dev
*rdev
)
365 struct iguanair
*ir
= rdev
->priv
;
368 rc
= iguanair_receiver(ir
, true);
370 ir
->receiver_on
= true;
375 static void iguanair_close(struct rc_dev
*rdev
)
377 struct iguanair
*ir
= rdev
->priv
;
380 rc
= iguanair_receiver(ir
, false);
381 ir
->receiver_on
= false;
382 if (rc
&& rc
!= -ENODEV
)
383 dev_warn(ir
->dev
, "failed to disable receiver: %d\n", rc
);
386 static int iguanair_probe(struct usb_interface
*intf
,
387 const struct usb_device_id
*id
)
389 struct usb_device
*udev
= interface_to_usbdev(intf
);
392 int ret
, pipein
, pipeout
;
393 struct usb_host_interface
*idesc
;
395 idesc
= intf
->cur_altsetting
;
396 if (idesc
->desc
.bNumEndpoints
< 2)
399 ir
= kzalloc(sizeof(*ir
), GFP_KERNEL
);
400 rc
= rc_allocate_device(RC_DRIVER_IR_RAW
);
406 ir
->buf_in
= usb_alloc_coherent(udev
, MAX_IN_PACKET
, GFP_KERNEL
,
408 ir
->packet
= usb_alloc_coherent(udev
, MAX_OUT_PACKET
, GFP_KERNEL
,
410 ir
->urb_in
= usb_alloc_urb(0, GFP_KERNEL
);
411 ir
->urb_out
= usb_alloc_urb(0, GFP_KERNEL
);
413 if (!ir
->buf_in
|| !ir
->packet
|| !ir
->urb_in
|| !ir
->urb_out
||
414 !usb_endpoint_is_int_in(&idesc
->endpoint
[0].desc
) ||
415 !usb_endpoint_is_int_out(&idesc
->endpoint
[1].desc
)) {
421 ir
->dev
= &intf
->dev
;
424 init_completion(&ir
->completion
);
425 pipeout
= usb_sndintpipe(udev
,
426 idesc
->endpoint
[1].desc
.bEndpointAddress
);
427 usb_fill_int_urb(ir
->urb_out
, udev
, pipeout
, ir
->packet
, MAX_OUT_PACKET
,
428 iguanair_irq_out
, ir
, 1);
429 ir
->urb_out
->transfer_dma
= ir
->dma_out
;
430 ir
->urb_out
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
432 pipein
= usb_rcvintpipe(udev
, idesc
->endpoint
[0].desc
.bEndpointAddress
);
433 usb_fill_int_urb(ir
->urb_in
, udev
, pipein
, ir
->buf_in
, MAX_IN_PACKET
,
435 ir
->urb_in
->transfer_dma
= ir
->dma_in
;
436 ir
->urb_in
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
438 ret
= usb_submit_urb(ir
->urb_in
, GFP_KERNEL
);
440 dev_warn(&intf
->dev
, "failed to submit urb: %d\n", ret
);
444 ret
= iguanair_get_features(ir
);
448 snprintf(ir
->name
, sizeof(ir
->name
),
449 "IguanaWorks USB IR Transceiver version 0x%04x", ir
->version
);
451 usb_make_path(ir
->udev
, ir
->phys
, sizeof(ir
->phys
));
453 rc
->device_name
= ir
->name
;
454 rc
->input_phys
= ir
->phys
;
455 usb_to_input_id(ir
->udev
, &rc
->input_id
);
456 rc
->dev
.parent
= &intf
->dev
;
457 rc
->allowed_protocols
= RC_PROTO_BIT_ALL_IR_DECODER
;
459 rc
->open
= iguanair_open
;
460 rc
->close
= iguanair_close
;
461 rc
->s_tx_mask
= iguanair_set_tx_mask
;
462 rc
->s_tx_carrier
= iguanair_set_tx_carrier
;
463 rc
->tx_ir
= iguanair_tx
;
464 rc
->driver_name
= KBUILD_MODNAME
;
465 rc
->map_name
= RC_MAP_RC6_MCE
;
467 rc
->timeout
= IR_DEFAULT_TIMEOUT
;
468 rc
->max_timeout
= 10 * IR_DEFAULT_TIMEOUT
;
469 rc
->rx_resolution
= RX_RESOLUTION
;
471 iguanair_set_tx_carrier(rc
, 38000);
472 iguanair_set_tx_mask(rc
, 0);
474 ret
= rc_register_device(rc
);
476 dev_err(&intf
->dev
, "failed to register rc device %d", ret
);
480 usb_set_intfdata(intf
, ir
);
484 usb_kill_urb(ir
->urb_in
);
485 usb_kill_urb(ir
->urb_out
);
488 usb_free_urb(ir
->urb_in
);
489 usb_free_urb(ir
->urb_out
);
490 usb_free_coherent(udev
, MAX_IN_PACKET
, ir
->buf_in
, ir
->dma_in
);
491 usb_free_coherent(udev
, MAX_OUT_PACKET
, ir
->packet
,
499 static void iguanair_disconnect(struct usb_interface
*intf
)
501 struct iguanair
*ir
= usb_get_intfdata(intf
);
503 rc_unregister_device(ir
->rc
);
504 usb_set_intfdata(intf
, NULL
);
505 usb_kill_urb(ir
->urb_in
);
506 usb_kill_urb(ir
->urb_out
);
507 usb_free_urb(ir
->urb_in
);
508 usb_free_urb(ir
->urb_out
);
509 usb_free_coherent(ir
->udev
, MAX_IN_PACKET
, ir
->buf_in
, ir
->dma_in
);
510 usb_free_coherent(ir
->udev
, MAX_OUT_PACKET
, ir
->packet
, ir
->dma_out
);
514 static int iguanair_suspend(struct usb_interface
*intf
, pm_message_t message
)
516 struct iguanair
*ir
= usb_get_intfdata(intf
);
519 if (ir
->receiver_on
) {
520 rc
= iguanair_receiver(ir
, false);
522 dev_warn(ir
->dev
, "failed to disable receiver for suspend\n");
525 usb_kill_urb(ir
->urb_in
);
526 usb_kill_urb(ir
->urb_out
);
531 static int iguanair_resume(struct usb_interface
*intf
)
533 struct iguanair
*ir
= usb_get_intfdata(intf
);
536 rc
= usb_submit_urb(ir
->urb_in
, GFP_KERNEL
);
538 dev_warn(&intf
->dev
, "failed to submit urb: %d\n", rc
);
540 if (ir
->receiver_on
) {
541 rc
= iguanair_receiver(ir
, true);
543 dev_warn(ir
->dev
, "failed to enable receiver after resume\n");
549 static const struct usb_device_id iguanair_table
[] = {
550 { USB_DEVICE(0x1781, 0x0938) },
554 static struct usb_driver iguanair_driver
= {
555 .name
= KBUILD_MODNAME
,
556 .probe
= iguanair_probe
,
557 .disconnect
= iguanair_disconnect
,
558 .suspend
= iguanair_suspend
,
559 .resume
= iguanair_resume
,
560 .reset_resume
= iguanair_resume
,
561 .id_table
= iguanair_table
,
562 .soft_unbind
= 1 /* we want to disable receiver on unbind */
565 module_usb_driver(iguanair_driver
);
567 MODULE_DESCRIPTION("IguanaWorks USB IR Transceiver");
568 MODULE_AUTHOR("Sean Young <sean@mess.org>");
569 MODULE_LICENSE("GPL");
570 MODULE_DEVICE_TABLE(usb
, iguanair_table
);