1// SPDX-License-Identifier: GPL-2.0-or-later
2
3/*
4 * Infrared Toy and IR Droid RC core driver
5 *
6 * Copyright (C) 2020 Sean Young <sean@mess.org>
7
8 * This driver is based on the lirc driver which can be found here:
9 * https://sourceforge.net/p/lirc/git/ci/master/tree/plugins/irtoy.c
10 * Copyright (C) 2011 Peter Kooiman <pkooiman@gmail.com>
11 */
12
13#include <asm/unaligned.h>
14#include <linux/completion.h>
15#include <linux/kernel.h>
16#include <linux/module.h>
17#include <linux/usb.h>
18#include <linux/slab.h>
19#include <linux/usb/input.h>
20
21#include <media/rc-core.h>
22
23static const u8 COMMAND_VERSION[] = { 'v' };
24// End transmit and repeat reset command so we exit sump mode
25static const u8 COMMAND_RESET[] = { 0xff, 0xff, 0, 0, 0, 0, 0 };
26static const u8 COMMAND_SMODE_ENTER[] = { 's' };
27static const u8 COMMAND_SMODE_EXIT[] = { 0 };
28static const u8 COMMAND_TXSTART[] = { 0x26, 0x24, 0x25, 0x03 };
29
30#define REPLY_XMITCOUNT 't'
31#define REPLY_XMITSUCCESS 'C'
32#define REPLY_VERSION 'V'
33#define REPLY_SAMPLEMODEPROTO 'S'
34
35#define TIMEOUT 500
36
37#define LEN_XMITRES 3
38#define LEN_VERSION 4
39#define LEN_SAMPLEMODEPROTO 3
40
41#define MIN_FW_VERSION 20
42#define UNIT_US 21
43#define MAX_TIMEOUT_US (UNIT_US * U16_MAX)
44
45#define MAX_PACKET 64
46
47enum state {
48	STATE_IRDATA,
49	STATE_RESET,
50	STATE_COMMAND,
51	STATE_TX,
52};
53
54struct irtoy {
55	struct device *dev;
56	struct usb_device *usbdev;
57
58	struct rc_dev *rc;
59	struct urb *urb_in, *urb_out;
60
61	u8 *in;
62	u8 *out;
63	struct completion command_done;
64
65	bool pulse;
66	enum state state;
67
68	void *tx_buf;
69	uint tx_len;
70
71	uint emitted;
72	uint hw_version;
73	uint sw_version;
74	uint proto_version;
75
76	char phys[64];
77};
78
79static void irtoy_response(struct irtoy *irtoy, u32 len)
80{
81	switch (irtoy->state) {
82	case STATE_COMMAND:
83		if (len == LEN_VERSION && irtoy->in[0] == REPLY_VERSION) {
84			uint version;
85
86			irtoy->in[LEN_VERSION] = 0;
87
88			if (kstrtouint(irtoy->in + 1, 10, &version)) {
89				dev_err(irtoy->dev, "invalid version %*phN. Please make sure you are using firmware v20 or higher",
90					LEN_VERSION, irtoy->in);
91				break;
92			}
93
94			dev_dbg(irtoy->dev, "version %s\n", irtoy->in);
95
96			irtoy->hw_version = version / 100;
97			irtoy->sw_version = version % 100;
98
99			irtoy->state = STATE_IRDATA;
100			complete(&irtoy->command_done);
101		} else if (len == LEN_SAMPLEMODEPROTO &&
102			   irtoy->in[0] == REPLY_SAMPLEMODEPROTO) {
103			uint version;
104
105			irtoy->in[LEN_SAMPLEMODEPROTO] = 0;
106
107			if (kstrtouint(irtoy->in + 1, 10, &version)) {
108				dev_err(irtoy->dev, "invalid sample mode response %*phN",
109					LEN_SAMPLEMODEPROTO, irtoy->in);
110				return;
111			}
112
113			dev_dbg(irtoy->dev, "protocol %s\n", irtoy->in);
114
115			irtoy->proto_version = version;
116
117			irtoy->state = STATE_IRDATA;
118			complete(&irtoy->command_done);
119		} else {
120			dev_err(irtoy->dev, "unexpected response to command: %*phN\n",
121				len, irtoy->in);
122		}
123		break;
124	case STATE_IRDATA: {
125		struct ir_raw_event rawir = { .pulse = irtoy->pulse };
126		__be16 *in = (__be16 *)irtoy->in;
127		int i;
128
129		for (i = 0; i < len / sizeof(__be16); i++) {
130			u16 v = be16_to_cpu(in[i]);
131
132			if (v == 0xffff) {
133				rawir.pulse = false;
134			} else {
135				rawir.duration = v * UNIT_US;
136				ir_raw_event_store_with_timeout(irtoy->rc,
137								&rawir);
138			}
139
140			rawir.pulse = !rawir.pulse;
141		}
142
143		irtoy->pulse = rawir.pulse;
144
145		ir_raw_event_handle(irtoy->rc);
146		break;
147	}
148	case STATE_TX:
149		if (irtoy->tx_len == 0) {
150			if (len == LEN_XMITRES &&
151			    irtoy->in[0] == REPLY_XMITCOUNT) {
152				u16 emitted = get_unaligned_be16(irtoy->in + 1);
153
154				dev_dbg(irtoy->dev, "emitted:%u\n", emitted);
155
156				irtoy->emitted = emitted;
157			} else if (len == 1 &&
158				   irtoy->in[0] == REPLY_XMITSUCCESS) {
159				irtoy->state = STATE_IRDATA;
160				complete(&irtoy->command_done);
161			}
162		} else {
163			// send next part of tx buffer
164			uint space = irtoy->in[0];
165			uint buf_len;
166			int err;
167
168			if (len != 1 || space > MAX_PACKET || space == 0) {
169				dev_err(irtoy->dev, "packet length expected: %*phN\n",
170					len, irtoy->in);
171				irtoy->state = STATE_IRDATA;
172				complete(&irtoy->command_done);
173				break;
174			}
175
176			buf_len = min(space, irtoy->tx_len);
177
178			dev_dbg(irtoy->dev, "remaining:%u sending:%u\n",
179				irtoy->tx_len, buf_len);
180
181			memcpy(irtoy->out, irtoy->tx_buf, buf_len);
182			irtoy->urb_out->transfer_buffer_length = buf_len;
183			err = usb_submit_urb(irtoy->urb_out, GFP_ATOMIC);
184			if (err != 0) {
185				dev_err(irtoy->dev, "fail to submit tx buf urb: %d\n",
186					err);
187				irtoy->state = STATE_IRDATA;
188				complete(&irtoy->command_done);
189				break;
190			}
191
192			irtoy->tx_buf += buf_len;
193			irtoy->tx_len -= buf_len;
194		}
195		break;
196	case STATE_RESET:
197		dev_err(irtoy->dev, "unexpected response to reset: %*phN\n",
198			len, irtoy->in);
199	}
200}
201
202static void irtoy_out_callback(struct urb *urb)
203{
204	struct irtoy *irtoy = urb->context;
205
206	if (urb->status == 0) {
207		if (irtoy->state == STATE_RESET)
208			complete(&irtoy->command_done);
209	} else {
210		dev_warn(irtoy->dev, "out urb status: %d\n", urb->status);
211	}
212}
213
214static void irtoy_in_callback(struct urb *urb)
215{
216	struct irtoy *irtoy = urb->context;
217	int ret;
218
219	if (urb->status == 0)
220		irtoy_response(irtoy, urb->actual_length);
221	else
222		dev_dbg(irtoy->dev, "in urb status: %d\n", urb->status);
223
224	ret = usb_submit_urb(urb, GFP_ATOMIC);
225	if (ret && ret != -ENODEV)
226		dev_warn(irtoy->dev, "failed to resubmit urb: %d\n", ret);
227}
228
229static int irtoy_command(struct irtoy *irtoy, const u8 *cmd, int cmd_len,
230			 enum state state)
231{
232	int err;
233
234	init_completion(&irtoy->command_done);
235
236	irtoy->state = state;
237
238	memcpy(irtoy->out, cmd, cmd_len);
239	irtoy->urb_out->transfer_buffer_length = cmd_len;
240
241	err = usb_submit_urb(irtoy->urb_out, GFP_KERNEL);
242	if (err != 0)
243		return err;
244
245	if (!wait_for_completion_timeout(&irtoy->command_done,
246					 msecs_to_jiffies(TIMEOUT))) {
247		usb_kill_urb(irtoy->urb_out);
248		return -ETIMEDOUT;
249	}
250
251	return 0;
252}
253
254static int irtoy_setup(struct irtoy *irtoy)
255{
256	int err;
257
258	err = irtoy_command(irtoy, COMMAND_RESET, sizeof(COMMAND_RESET),
259			    STATE_RESET);
260	if (err != 0) {
261		dev_err(irtoy->dev, "could not write reset command: %d\n",
262			err);
263		return err;
264	}
265
266	usleep_range(50, 50);
267
268	// get version
269	err = irtoy_command(irtoy, COMMAND_VERSION, sizeof(COMMAND_VERSION),
270			    STATE_COMMAND);
271	if (err) {
272		dev_err(irtoy->dev, "could not write version command: %d\n",
273			err);
274		return err;
275	}
276
277	// enter sample mode
278	err = irtoy_command(irtoy, COMMAND_SMODE_ENTER,
279			    sizeof(COMMAND_SMODE_ENTER), STATE_COMMAND);
280	if (err)
281		dev_err(irtoy->dev, "could not write sample command: %d\n",
282			err);
283
284	return err;
285}
286
287/*
288 * When sending IR, it is imperative that we send the IR data as quickly
289 * as possible to the device, so it does not run out of IR data and
290 * introduce gaps. Allocate the buffer here, and then feed the data from
291 * the urb callback handler.
292 */
293static int irtoy_tx(struct rc_dev *rc, uint *txbuf, uint count)
294{
295	struct irtoy *irtoy = rc->priv;
296	unsigned int i, size;
297	__be16 *buf;
298	int err;
299
300	size = sizeof(u16) * (count + 1);
301	buf = kmalloc(size, GFP_KERNEL);
302	if (!buf)
303		return -ENOMEM;
304
305	for (i = 0; i < count; i++) {
306		u16 v = DIV_ROUND_CLOSEST(txbuf[i], UNIT_US);
307
308		if (!v)
309			v = 1;
310		buf[i] = cpu_to_be16(v);
311	}
312
313	buf[count] = cpu_to_be16(0xffff);
314
315	irtoy->tx_buf = buf;
316	irtoy->tx_len = size;
317	irtoy->emitted = 0;
318
319	// There is an issue where if the unit is receiving IR while the
320	// first TXSTART command is sent, the device might end up hanging
321	// with its led on. It does not respond to any command when this
322	// happens. To work around this, re-enter sample mode.
323	err = irtoy_command(irtoy, COMMAND_SMODE_EXIT,
324			    sizeof(COMMAND_SMODE_EXIT), STATE_RESET);
325	if (err) {
326		dev_err(irtoy->dev, "exit sample mode: %d\n", err);
327		kfree(buf);
328		return err;
329	}
330
331	err = irtoy_command(irtoy, COMMAND_SMODE_ENTER,
332			    sizeof(COMMAND_SMODE_ENTER), STATE_COMMAND);
333	if (err) {
334		dev_err(irtoy->dev, "enter sample mode: %d\n", err);
335		kfree(buf);
336		return err;
337	}
338
339	err = irtoy_command(irtoy, COMMAND_TXSTART, sizeof(COMMAND_TXSTART),
340			    STATE_TX);
341	kfree(buf);
342
343	if (err) {
344		dev_err(irtoy->dev, "failed to send tx start command: %d\n",
345			err);
346		// not sure what state the device is in, reset it
347		irtoy_setup(irtoy);
348		return err;
349	}
350
351	if (size != irtoy->emitted) {
352		dev_err(irtoy->dev, "expected %u emitted, got %u\n", size,
353			irtoy->emitted);
354		// not sure what state the device is in, reset it
355		irtoy_setup(irtoy);
356		return -EINVAL;
357	}
358
359	return count;
360}
361
362static int irtoy_probe(struct usb_interface *intf,
363		       const struct usb_device_id *id)
364{
365	struct usb_host_interface *idesc = intf->cur_altsetting;
366	struct usb_device *usbdev = interface_to_usbdev(intf);
367	struct usb_endpoint_descriptor *ep_in = NULL;
368	struct usb_endpoint_descriptor *ep_out = NULL;
369	struct usb_endpoint_descriptor *ep = NULL;
370	struct irtoy *irtoy;
371	struct rc_dev *rc;
372	struct urb *urb;
373	int i, pipe, err = -ENOMEM;
374
375	for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
376		ep = &idesc->endpoint[i].desc;
377
378		if (!ep_in && usb_endpoint_is_bulk_in(ep) &&
379		    usb_endpoint_maxp(ep) == MAX_PACKET)
380			ep_in = ep;
381
382		if (!ep_out && usb_endpoint_is_bulk_out(ep) &&
383		    usb_endpoint_maxp(ep) == MAX_PACKET)
384			ep_out = ep;
385	}
386
387	if (!ep_in || !ep_out) {
388		dev_err(&intf->dev, "required endpoints not found\n");
389		return -ENODEV;
390	}
391
392	irtoy = kzalloc(sizeof(*irtoy), GFP_KERNEL);
393	if (!irtoy)
394		return -ENOMEM;
395
396	irtoy->in = kmalloc(MAX_PACKET,  GFP_KERNEL);
397	if (!irtoy->in)
398		goto free_irtoy;
399
400	irtoy->out = kmalloc(MAX_PACKET,  GFP_KERNEL);
401	if (!irtoy->out)
402		goto free_irtoy;
403
404	rc = rc_allocate_device(RC_DRIVER_IR_RAW);
405	if (!rc)
406		goto free_irtoy;
407
408	urb = usb_alloc_urb(0, GFP_KERNEL);
409	if (!urb)
410		goto free_rcdev;
411
412	pipe = usb_rcvbulkpipe(usbdev, ep_in->bEndpointAddress);
413	usb_fill_bulk_urb(urb, usbdev, pipe, irtoy->in, MAX_PACKET,
414			  irtoy_in_callback, irtoy);
415	irtoy->urb_in = urb;
416
417	urb = usb_alloc_urb(0, GFP_KERNEL);
418	if (!urb)
419		goto free_rcdev;
420
421	pipe = usb_sndbulkpipe(usbdev, ep_out->bEndpointAddress);
422	usb_fill_bulk_urb(urb, usbdev, pipe, irtoy->out, MAX_PACKET,
423			  irtoy_out_callback, irtoy);
424
425	irtoy->dev = &intf->dev;
426	irtoy->usbdev = usbdev;
427	irtoy->rc = rc;
428	irtoy->urb_out = urb;
429	irtoy->pulse = true;
430
431	err = usb_submit_urb(irtoy->urb_in, GFP_KERNEL);
432	if (err != 0) {
433		dev_err(irtoy->dev, "fail to submit in urb: %d\n", err);
434		goto free_rcdev;
435	}
436
437	err = irtoy_setup(irtoy);
438	if (err)
439		goto free_rcdev;
440
441	dev_info(irtoy->dev, "version: hardware %u, firmware %u, protocol %u",
442		 irtoy->hw_version, irtoy->sw_version, irtoy->proto_version);
443
444	if (irtoy->sw_version < MIN_FW_VERSION) {
445		dev_err(irtoy->dev, "need firmware V%02u or higher",
446			MIN_FW_VERSION);
447		err = -ENODEV;
448		goto free_rcdev;
449	}
450
451	usb_make_path(usbdev, irtoy->phys, sizeof(irtoy->phys));
452
453	rc->device_name = "Infrared Toy";
454	rc->driver_name = KBUILD_MODNAME;
455	rc->input_phys = irtoy->phys;
456	usb_to_input_id(usbdev, &rc->input_id);
457	rc->dev.parent = &intf->dev;
458	rc->priv = irtoy;
459	rc->tx_ir = irtoy_tx;
460	rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
461	rc->map_name = RC_MAP_RC6_MCE;
462	rc->rx_resolution = UNIT_US;
463	rc->timeout = IR_DEFAULT_TIMEOUT;
464
465	/*
466	 * end of transmission is detected by absence of a usb packet
467	 * with more pulse/spaces. However, each usb packet sent can
468	 * contain 32 pulse/spaces, which can be quite lengthy, so there
469	 * can be a delay between usb packets. For example with nec there is a
470	 * 17ms gap between packets.
471	 *
472	 * So, make timeout a largish minimum which works with most protocols.
473	 */
474	rc->min_timeout = MS_TO_US(40);
475	rc->max_timeout = MAX_TIMEOUT_US;
476
477	err = rc_register_device(rc);
478	if (err)
479		goto free_rcdev;
480
481	usb_set_intfdata(intf, irtoy);
482
483	return 0;
484
485free_rcdev:
486	usb_kill_urb(irtoy->urb_out);
487	usb_free_urb(irtoy->urb_out);
488	usb_kill_urb(irtoy->urb_in);
489	usb_free_urb(irtoy->urb_in);
490	rc_free_device(rc);
491free_irtoy:
492	kfree(irtoy->in);
493	kfree(irtoy->out);
494	kfree(irtoy);
495	return err;
496}
497
498static void irtoy_disconnect(struct usb_interface *intf)
499{
500	struct irtoy *ir = usb_get_intfdata(intf);
501
502	rc_unregister_device(ir->rc);
503	usb_set_intfdata(intf, NULL);
504	usb_kill_urb(ir->urb_out);
505	usb_free_urb(ir->urb_out);
506	usb_kill_urb(ir->urb_in);
507	usb_free_urb(ir->urb_in);
508	kfree(ir->in);
509	kfree(ir->out);
510	kfree(ir);
511}
512
513static const struct usb_device_id irtoy_table[] = {
514	{ USB_DEVICE_INTERFACE_CLASS(0x04d8, 0xfd08, USB_CLASS_CDC_DATA) },
515	{ USB_DEVICE_INTERFACE_CLASS(0x04d8, 0xf58b, USB_CLASS_CDC_DATA) },
516	{ }
517};
518
519static struct usb_driver irtoy_driver = {
520	.name = KBUILD_MODNAME,
521	.probe = irtoy_probe,
522	.disconnect = irtoy_disconnect,
523	.id_table = irtoy_table,
524};
525
526module_usb_driver(irtoy_driver);
527
528MODULE_AUTHOR("Sean Young <sean@mess.org>");
529MODULE_DESCRIPTION("Infrared Toy and IR Droid driver");
530MODULE_LICENSE("GPL");
531MODULE_DEVICE_TABLE(usb, irtoy_table);
532