1 // SPDX-License-Identifier: GPL-2.0+
2 //
3 // Copyright (C) 2018 Sean Young <sean@mess.org>
4 
5 #include <linux/module.h>
6 #include <linux/usb.h>
7 #include <linux/usb/input.h>
8 #include <media/rc-core.h>
9 
10 /* Each bit is 250us */
11 #define BIT_DURATION 250
12 
13 struct imon {
14 	struct device *dev;
15 	struct urb *ir_urb;
16 	struct rc_dev *rcdev;
17 	__be64 *ir_buf;
18 	char phys[64];
19 };
20 
21 /*
22  * The first 5 bytes of data represent IR pulse or space. Each bit, starting
23  * from highest bit in the first byte, represents 250µs of data. It is 1
24  * for space and 0 for pulse.
25  *
26  * The station sends 10 packets, and the 7th byte will be number 1 to 10, so
27  * when we receive 10 we assume all the data has arrived.
28  */
imon_ir_data(struct imon * imon)29 static void imon_ir_data(struct imon *imon)
30 {
31 	struct ir_raw_event rawir = {};
32 	u64 data = be64_to_cpup(imon->ir_buf);
33 	u8 packet_no = data & 0xff;
34 	int offset = 40;
35 	int bit;
36 
37 	if (packet_no == 0xff)
38 		return;
39 
40 	dev_dbg(imon->dev, "data: %*ph", 8, imon->ir_buf);
41 
42 	/*
43 	 * Only the first 5 bytes contain IR data. Right shift so we move
44 	 * the IR bits to the lower 40 bits.
45 	 */
46 	data >>= 24;
47 
48 	do {
49 		/*
50 		 * Find highest set bit which is less or equal to offset
51 		 *
52 		 * offset is the bit above (base 0) where we start looking.
53 		 *
54 		 * data & (BIT_ULL(offset) - 1) masks off any unwanted bits,
55 		 * so we have just bits less than offset.
56 		 *
57 		 * fls will tell us the highest bit set plus 1 (or 0 if no
58 		 * bits are set).
59 		 */
60 		rawir.pulse = !rawir.pulse;
61 		bit = fls64(data & (BIT_ULL(offset) - 1));
62 		if (bit < offset) {
63 			dev_dbg(imon->dev, "%s: %d bits",
64 				rawir.pulse ? "pulse" : "space", offset - bit);
65 			rawir.duration = (offset - bit) * BIT_DURATION;
66 			ir_raw_event_store_with_filter(imon->rcdev, &rawir);
67 
68 			offset = bit;
69 		}
70 
71 		data = ~data;
72 	} while (offset > 0);
73 
74 	if (packet_no == 0x0a && !imon->rcdev->idle) {
75 		ir_raw_event_set_idle(imon->rcdev, true);
76 		ir_raw_event_handle(imon->rcdev);
77 	}
78 }
79 
imon_ir_rx(struct urb * urb)80 static void imon_ir_rx(struct urb *urb)
81 {
82 	struct imon *imon = urb->context;
83 	int ret;
84 
85 	switch (urb->status) {
86 	case 0:
87 		imon_ir_data(imon);
88 		break;
89 	case -ECONNRESET:
90 	case -ENOENT:
91 	case -ESHUTDOWN:
92 		usb_unlink_urb(urb);
93 		return;
94 	case -EPIPE:
95 	default:
96 		dev_dbg(imon->dev, "error: urb status = %d", urb->status);
97 		break;
98 	}
99 
100 	ret = usb_submit_urb(urb, GFP_ATOMIC);
101 	if (ret && ret != -ENODEV)
102 		dev_warn(imon->dev, "failed to resubmit urb: %d", ret);
103 }
104 
imon_probe(struct usb_interface * intf,const struct usb_device_id * id)105 static int imon_probe(struct usb_interface *intf,
106 		      const struct usb_device_id *id)
107 {
108 	struct usb_endpoint_descriptor *ir_ep = NULL;
109 	struct usb_host_interface *idesc;
110 	struct usb_device *udev;
111 	struct rc_dev *rcdev;
112 	struct imon *imon;
113 	int i, ret;
114 
115 	udev = interface_to_usbdev(intf);
116 	idesc = intf->cur_altsetting;
117 
118 	for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
119 		struct usb_endpoint_descriptor *ep = &idesc->endpoint[i].desc;
120 
121 		if (usb_endpoint_is_int_in(ep)) {
122 			ir_ep = ep;
123 			break;
124 		}
125 	}
126 
127 	if (!ir_ep) {
128 		dev_err(&intf->dev, "IR endpoint missing");
129 		return -ENODEV;
130 	}
131 
132 	imon = devm_kmalloc(&intf->dev, sizeof(*imon), GFP_KERNEL);
133 	if (!imon)
134 		return -ENOMEM;
135 
136 	imon->ir_urb = usb_alloc_urb(0, GFP_KERNEL);
137 	if (!imon->ir_urb)
138 		return -ENOMEM;
139 
140 	imon->ir_buf = kmalloc(sizeof(__be64), GFP_KERNEL);
141 	if (!imon->ir_buf) {
142 		ret = -ENOMEM;
143 		goto free_urb;
144 	}
145 
146 	imon->dev = &intf->dev;
147 	usb_fill_int_urb(imon->ir_urb, udev,
148 			 usb_rcvintpipe(udev, ir_ep->bEndpointAddress),
149 			 imon->ir_buf, sizeof(__be64),
150 			 imon_ir_rx, imon, ir_ep->bInterval);
151 
152 	rcdev = devm_rc_allocate_device(&intf->dev, RC_DRIVER_IR_RAW);
153 	if (!rcdev) {
154 		ret = -ENOMEM;
155 		goto free_urb;
156 	}
157 
158 	usb_make_path(udev, imon->phys, sizeof(imon->phys));
159 
160 	rcdev->device_name = "iMON Station";
161 	rcdev->driver_name = KBUILD_MODNAME;
162 	rcdev->input_phys = imon->phys;
163 	usb_to_input_id(udev, &rcdev->input_id);
164 	rcdev->dev.parent = &intf->dev;
165 	rcdev->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
166 	rcdev->map_name = RC_MAP_IMON_RSC;
167 	rcdev->rx_resolution = BIT_DURATION;
168 	rcdev->priv = imon;
169 
170 	ret = devm_rc_register_device(&intf->dev, rcdev);
171 	if (ret)
172 		goto free_urb;
173 
174 	imon->rcdev = rcdev;
175 
176 	ret = usb_submit_urb(imon->ir_urb, GFP_KERNEL);
177 	if (ret)
178 		goto free_urb;
179 
180 	usb_set_intfdata(intf, imon);
181 
182 	return 0;
183 
184 free_urb:
185 	usb_free_urb(imon->ir_urb);
186 	kfree(imon->ir_buf);
187 	return ret;
188 }
189 
imon_disconnect(struct usb_interface * intf)190 static void imon_disconnect(struct usb_interface *intf)
191 {
192 	struct imon *imon = usb_get_intfdata(intf);
193 
194 	usb_kill_urb(imon->ir_urb);
195 	usb_free_urb(imon->ir_urb);
196 	kfree(imon->ir_buf);
197 }
198 
199 static const struct usb_device_id imon_table[] = {
200 	/* SoundGraph iMON (IR only) -- sg_imon.inf */
201 	{ USB_DEVICE(0x04e8, 0xff30) },
202 	{}
203 };
204 
205 static struct usb_driver imon_driver = {
206 	.name = KBUILD_MODNAME,
207 	.probe = imon_probe,
208 	.disconnect = imon_disconnect,
209 	.id_table = imon_table
210 };
211 
212 module_usb_driver(imon_driver);
213 
214 MODULE_DESCRIPTION("Early raw iMON IR devices");
215 MODULE_AUTHOR("Sean Young <sean@mess.org>");
216 MODULE_LICENSE("GPL");
217 MODULE_DEVICE_TABLE(usb, imon_table);
218