1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * USB IR Dongle driver |
4 | * |
5 | * Copyright (C) 2001-2002 Greg Kroah-Hartman (greg@kroah.com) |
6 | * Copyright (C) 2002 Gary Brubaker (xavyer@ix.netcom.com) |
7 | * Copyright (C) 2010 Johan Hovold (jhovold@gmail.com) |
8 | * |
9 | * This driver allows a USB IrDA device to be used as a "dumb" serial device. |
10 | * This can be useful if you do not have access to a full IrDA stack on the |
11 | * other side of the connection. If you do have an IrDA stack on both devices, |
12 | * please use the usb-irda driver, as it contains the proper error checking and |
13 | * other goodness of a full IrDA stack. |
14 | * |
15 | * Portions of this driver were taken from drivers/net/irda/irda-usb.c, which |
16 | * was written by Roman Weissgaerber <weissg@vienna.at>, Dag Brattli |
17 | * <dag@brattli.net>, and Jean Tourrilhes <jt@hpl.hp.com> |
18 | * |
19 | * See Documentation/usb/usb-serial.rst for more information on using this |
20 | * driver |
21 | */ |
22 | |
23 | #include <linux/kernel.h> |
24 | #include <linux/errno.h> |
25 | #include <linux/init.h> |
26 | #include <linux/slab.h> |
27 | #include <linux/tty.h> |
28 | #include <linux/tty_driver.h> |
29 | #include <linux/tty_flip.h> |
30 | #include <linux/module.h> |
31 | #include <linux/spinlock.h> |
32 | #include <linux/uaccess.h> |
33 | #include <linux/usb.h> |
34 | #include <linux/usb/serial.h> |
35 | #include <linux/usb/irda.h> |
36 | |
37 | #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Johan Hovold <jhovold@gmail.com>" |
38 | #define DRIVER_DESC "USB IR Dongle driver" |
39 | |
40 | /* if overridden by the user, then use their value for the size of the read and |
41 | * write urbs */ |
42 | static int buffer_size; |
43 | |
44 | /* if overridden by the user, then use the specified number of XBOFs */ |
45 | static int xbof = -1; |
46 | |
47 | static int ir_startup (struct usb_serial *serial); |
48 | static int ir_write(struct tty_struct *tty, struct usb_serial_port *port, |
49 | const unsigned char *buf, int count); |
50 | static unsigned int ir_write_room(struct tty_struct *tty); |
51 | static void ir_write_bulk_callback(struct urb *urb); |
52 | static void ir_process_read_urb(struct urb *urb); |
53 | static void ir_set_termios(struct tty_struct *tty, |
54 | struct usb_serial_port *port, |
55 | const struct ktermios *old_termios); |
56 | |
57 | /* Not that this lot means you can only have one per system */ |
58 | static u8 ir_baud; |
59 | static u8 ir_xbof; |
60 | static u8 ir_add_bof; |
61 | |
62 | static const struct usb_device_id ir_id_table[] = { |
63 | { USB_DEVICE(0x050f, 0x0180) }, /* KC Technology, KC-180 */ |
64 | { USB_DEVICE(0x08e9, 0x0100) }, /* XTNDAccess */ |
65 | { USB_DEVICE(0x09c4, 0x0011) }, /* ACTiSys ACT-IR2000U */ |
66 | { USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, USB_SUBCLASS_IRDA, 0) }, |
67 | { } /* Terminating entry */ |
68 | }; |
69 | |
70 | MODULE_DEVICE_TABLE(usb, ir_id_table); |
71 | |
72 | static struct usb_serial_driver ir_device = { |
73 | .driver = { |
74 | .owner = THIS_MODULE, |
75 | .name = "ir-usb" , |
76 | }, |
77 | .description = "IR Dongle" , |
78 | .id_table = ir_id_table, |
79 | .num_ports = 1, |
80 | .num_bulk_in = 1, |
81 | .num_bulk_out = 1, |
82 | .set_termios = ir_set_termios, |
83 | .attach = ir_startup, |
84 | .write = ir_write, |
85 | .write_room = ir_write_room, |
86 | .write_bulk_callback = ir_write_bulk_callback, |
87 | .process_read_urb = ir_process_read_urb, |
88 | }; |
89 | |
90 | static struct usb_serial_driver * const serial_drivers[] = { |
91 | &ir_device, NULL |
92 | }; |
93 | |
94 | static inline void irda_usb_dump_class_desc(struct usb_serial *serial, |
95 | struct usb_irda_cs_descriptor *desc) |
96 | { |
97 | struct device *dev = &serial->dev->dev; |
98 | |
99 | dev_dbg(dev, "bLength=%x\n" , desc->bLength); |
100 | dev_dbg(dev, "bDescriptorType=%x\n" , desc->bDescriptorType); |
101 | dev_dbg(dev, "bcdSpecRevision=%x\n" , __le16_to_cpu(desc->bcdSpecRevision)); |
102 | dev_dbg(dev, "bmDataSize=%x\n" , desc->bmDataSize); |
103 | dev_dbg(dev, "bmWindowSize=%x\n" , desc->bmWindowSize); |
104 | dev_dbg(dev, "bmMinTurnaroundTime=%d\n" , desc->bmMinTurnaroundTime); |
105 | dev_dbg(dev, "wBaudRate=%x\n" , __le16_to_cpu(desc->wBaudRate)); |
106 | dev_dbg(dev, "bmAdditionalBOFs=%x\n" , desc->bmAdditionalBOFs); |
107 | dev_dbg(dev, "bIrdaRateSniff=%x\n" , desc->bIrdaRateSniff); |
108 | dev_dbg(dev, "bMaxUnicastList=%x\n" , desc->bMaxUnicastList); |
109 | } |
110 | |
111 | /*------------------------------------------------------------------*/ |
112 | /* |
113 | * Function irda_usb_find_class_desc(dev, ifnum) |
114 | * |
115 | * Returns instance of IrDA class descriptor, or NULL if not found |
116 | * |
117 | * The class descriptor is some extra info that IrDA USB devices will |
118 | * offer to us, describing their IrDA characteristics. We will use that in |
119 | * irda_usb_init_qos() |
120 | * |
121 | * Based on the same function in drivers/net/irda/irda-usb.c |
122 | */ |
123 | static struct usb_irda_cs_descriptor * |
124 | irda_usb_find_class_desc(struct usb_serial *serial, unsigned int ifnum) |
125 | { |
126 | struct usb_device *dev = serial->dev; |
127 | struct usb_irda_cs_descriptor *desc; |
128 | int ret; |
129 | |
130 | desc = kzalloc(size: sizeof(*desc), GFP_KERNEL); |
131 | if (!desc) |
132 | return NULL; |
133 | |
134 | ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), |
135 | USB_REQ_CS_IRDA_GET_CLASS_DESC, |
136 | USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, |
137 | value: 0, index: ifnum, data: desc, size: sizeof(*desc), timeout: 1000); |
138 | |
139 | dev_dbg(&serial->dev->dev, "%s - ret=%d\n" , __func__, ret); |
140 | if (ret < (int)sizeof(*desc)) { |
141 | dev_dbg(&serial->dev->dev, |
142 | "%s - class descriptor read %s (%d)\n" , __func__, |
143 | (ret < 0) ? "failed" : "too short" , ret); |
144 | goto error; |
145 | } |
146 | if (desc->bDescriptorType != USB_DT_CS_IRDA) { |
147 | dev_dbg(&serial->dev->dev, "%s - bad class descriptor type\n" , |
148 | __func__); |
149 | goto error; |
150 | } |
151 | |
152 | irda_usb_dump_class_desc(serial, desc); |
153 | return desc; |
154 | |
155 | error: |
156 | kfree(objp: desc); |
157 | return NULL; |
158 | } |
159 | |
160 | static u8 ir_xbof_change(u8 xbof) |
161 | { |
162 | u8 result; |
163 | |
164 | /* reference irda-usb.c */ |
165 | switch (xbof) { |
166 | case 48: |
167 | result = 0x10; |
168 | break; |
169 | case 28: |
170 | case 24: |
171 | result = 0x20; |
172 | break; |
173 | default: |
174 | case 12: |
175 | result = 0x30; |
176 | break; |
177 | case 5: |
178 | case 6: |
179 | result = 0x40; |
180 | break; |
181 | case 3: |
182 | result = 0x50; |
183 | break; |
184 | case 2: |
185 | result = 0x60; |
186 | break; |
187 | case 1: |
188 | result = 0x70; |
189 | break; |
190 | case 0: |
191 | result = 0x80; |
192 | break; |
193 | } |
194 | |
195 | return(result); |
196 | } |
197 | |
198 | static int ir_startup(struct usb_serial *serial) |
199 | { |
200 | struct usb_irda_cs_descriptor *irda_desc; |
201 | int rates; |
202 | |
203 | irda_desc = irda_usb_find_class_desc(serial, ifnum: 0); |
204 | if (!irda_desc) { |
205 | dev_err(&serial->dev->dev, |
206 | "IRDA class descriptor not found, device not bound\n" ); |
207 | return -ENODEV; |
208 | } |
209 | |
210 | rates = le16_to_cpu(irda_desc->wBaudRate); |
211 | |
212 | dev_dbg(&serial->dev->dev, |
213 | "%s - Baud rates supported:%s%s%s%s%s%s%s%s%s\n" , |
214 | __func__, |
215 | (rates & USB_IRDA_BR_2400) ? " 2400" : "" , |
216 | (rates & USB_IRDA_BR_9600) ? " 9600" : "" , |
217 | (rates & USB_IRDA_BR_19200) ? " 19200" : "" , |
218 | (rates & USB_IRDA_BR_38400) ? " 38400" : "" , |
219 | (rates & USB_IRDA_BR_57600) ? " 57600" : "" , |
220 | (rates & USB_IRDA_BR_115200) ? " 115200" : "" , |
221 | (rates & USB_IRDA_BR_576000) ? " 576000" : "" , |
222 | (rates & USB_IRDA_BR_1152000) ? " 1152000" : "" , |
223 | (rates & USB_IRDA_BR_4000000) ? " 4000000" : "" ); |
224 | |
225 | switch (irda_desc->bmAdditionalBOFs) { |
226 | case USB_IRDA_AB_48: |
227 | ir_add_bof = 48; |
228 | break; |
229 | case USB_IRDA_AB_24: |
230 | ir_add_bof = 24; |
231 | break; |
232 | case USB_IRDA_AB_12: |
233 | ir_add_bof = 12; |
234 | break; |
235 | case USB_IRDA_AB_6: |
236 | ir_add_bof = 6; |
237 | break; |
238 | case USB_IRDA_AB_3: |
239 | ir_add_bof = 3; |
240 | break; |
241 | case USB_IRDA_AB_2: |
242 | ir_add_bof = 2; |
243 | break; |
244 | case USB_IRDA_AB_1: |
245 | ir_add_bof = 1; |
246 | break; |
247 | case USB_IRDA_AB_0: |
248 | ir_add_bof = 0; |
249 | break; |
250 | default: |
251 | break; |
252 | } |
253 | |
254 | kfree(objp: irda_desc); |
255 | |
256 | return 0; |
257 | } |
258 | |
259 | static int ir_write(struct tty_struct *tty, struct usb_serial_port *port, |
260 | const unsigned char *buf, int count) |
261 | { |
262 | struct urb *urb = NULL; |
263 | unsigned long flags; |
264 | int ret; |
265 | |
266 | if (port->bulk_out_size == 0) |
267 | return -EINVAL; |
268 | |
269 | if (count == 0) |
270 | return 0; |
271 | |
272 | count = min(count, port->bulk_out_size - 1); |
273 | |
274 | spin_lock_irqsave(&port->lock, flags); |
275 | if (__test_and_clear_bit(0, &port->write_urbs_free)) { |
276 | urb = port->write_urbs[0]; |
277 | port->tx_bytes += count; |
278 | } |
279 | spin_unlock_irqrestore(lock: &port->lock, flags); |
280 | |
281 | if (!urb) |
282 | return 0; |
283 | |
284 | /* |
285 | * The first byte of the packet we send to the device contains an |
286 | * outbound header which indicates an additional number of BOFs and |
287 | * a baud rate change. |
288 | * |
289 | * See section 5.4.2.2 of the USB IrDA spec. |
290 | */ |
291 | *(u8 *)urb->transfer_buffer = ir_xbof | ir_baud; |
292 | |
293 | memcpy(urb->transfer_buffer + 1, buf, count); |
294 | |
295 | urb->transfer_buffer_length = count + 1; |
296 | urb->transfer_flags = URB_ZERO_PACKET; |
297 | |
298 | ret = usb_submit_urb(urb, GFP_ATOMIC); |
299 | if (ret) { |
300 | dev_err(&port->dev, "failed to submit write urb: %d\n" , ret); |
301 | |
302 | spin_lock_irqsave(&port->lock, flags); |
303 | __set_bit(0, &port->write_urbs_free); |
304 | port->tx_bytes -= count; |
305 | spin_unlock_irqrestore(lock: &port->lock, flags); |
306 | |
307 | return ret; |
308 | } |
309 | |
310 | return count; |
311 | } |
312 | |
313 | static void ir_write_bulk_callback(struct urb *urb) |
314 | { |
315 | struct usb_serial_port *port = urb->context; |
316 | int status = urb->status; |
317 | unsigned long flags; |
318 | |
319 | spin_lock_irqsave(&port->lock, flags); |
320 | __set_bit(0, &port->write_urbs_free); |
321 | port->tx_bytes -= urb->transfer_buffer_length - 1; |
322 | spin_unlock_irqrestore(lock: &port->lock, flags); |
323 | |
324 | switch (status) { |
325 | case 0: |
326 | break; |
327 | case -ENOENT: |
328 | case -ECONNRESET: |
329 | case -ESHUTDOWN: |
330 | dev_dbg(&port->dev, "write urb stopped: %d\n" , status); |
331 | return; |
332 | case -EPIPE: |
333 | dev_err(&port->dev, "write urb stopped: %d\n" , status); |
334 | return; |
335 | default: |
336 | dev_err(&port->dev, "nonzero write-urb status: %d\n" , status); |
337 | break; |
338 | } |
339 | |
340 | usb_serial_port_softint(port); |
341 | } |
342 | |
343 | static unsigned int ir_write_room(struct tty_struct *tty) |
344 | { |
345 | struct usb_serial_port *port = tty->driver_data; |
346 | unsigned int count = 0; |
347 | |
348 | if (port->bulk_out_size == 0) |
349 | return 0; |
350 | |
351 | if (test_bit(0, &port->write_urbs_free)) |
352 | count = port->bulk_out_size - 1; |
353 | |
354 | return count; |
355 | } |
356 | |
357 | static void ir_process_read_urb(struct urb *urb) |
358 | { |
359 | struct usb_serial_port *port = urb->context; |
360 | unsigned char *data = urb->transfer_buffer; |
361 | |
362 | if (!urb->actual_length) |
363 | return; |
364 | /* |
365 | * The first byte of the packet we get from the device |
366 | * contains a busy indicator and baud rate change. |
367 | * See section 5.4.1.2 of the USB IrDA spec. |
368 | */ |
369 | if (*data & 0x0f) |
370 | ir_baud = *data & 0x0f; |
371 | |
372 | if (urb->actual_length == 1) |
373 | return; |
374 | |
375 | tty_insert_flip_string(port: &port->port, chars: data + 1, size: urb->actual_length - 1); |
376 | tty_flip_buffer_push(port: &port->port); |
377 | } |
378 | |
379 | static void ir_set_termios(struct tty_struct *tty, |
380 | struct usb_serial_port *port, |
381 | const struct ktermios *old_termios) |
382 | { |
383 | struct usb_device *udev = port->serial->dev; |
384 | unsigned char *transfer_buffer; |
385 | int actual_length; |
386 | speed_t baud; |
387 | int ir_baud; |
388 | int ret; |
389 | |
390 | baud = tty_get_baud_rate(tty); |
391 | |
392 | /* |
393 | * FIXME, we should compare the baud request against the |
394 | * capability stated in the IR header that we got in the |
395 | * startup function. |
396 | */ |
397 | |
398 | switch (baud) { |
399 | case 2400: |
400 | ir_baud = USB_IRDA_LS_2400; |
401 | break; |
402 | case 9600: |
403 | ir_baud = USB_IRDA_LS_9600; |
404 | break; |
405 | case 19200: |
406 | ir_baud = USB_IRDA_LS_19200; |
407 | break; |
408 | case 38400: |
409 | ir_baud = USB_IRDA_LS_38400; |
410 | break; |
411 | case 57600: |
412 | ir_baud = USB_IRDA_LS_57600; |
413 | break; |
414 | case 115200: |
415 | ir_baud = USB_IRDA_LS_115200; |
416 | break; |
417 | case 576000: |
418 | ir_baud = USB_IRDA_LS_576000; |
419 | break; |
420 | case 1152000: |
421 | ir_baud = USB_IRDA_LS_1152000; |
422 | break; |
423 | case 4000000: |
424 | ir_baud = USB_IRDA_LS_4000000; |
425 | break; |
426 | default: |
427 | ir_baud = USB_IRDA_LS_9600; |
428 | baud = 9600; |
429 | } |
430 | |
431 | if (xbof == -1) |
432 | ir_xbof = ir_xbof_change(xbof: ir_add_bof); |
433 | else |
434 | ir_xbof = ir_xbof_change(xbof) ; |
435 | |
436 | /* Only speed changes are supported */ |
437 | tty_termios_copy_hw(new: &tty->termios, old: old_termios); |
438 | tty_encode_baud_rate(tty, ibaud: baud, obaud: baud); |
439 | |
440 | /* |
441 | * send the baud change out on an "empty" data packet |
442 | */ |
443 | transfer_buffer = kmalloc(size: 1, GFP_KERNEL); |
444 | if (!transfer_buffer) |
445 | return; |
446 | |
447 | *transfer_buffer = ir_xbof | ir_baud; |
448 | |
449 | ret = usb_bulk_msg(usb_dev: udev, |
450 | usb_sndbulkpipe(udev, port->bulk_out_endpointAddress), |
451 | data: transfer_buffer, len: 1, actual_length: &actual_length, timeout: 5000); |
452 | if (ret || actual_length != 1) { |
453 | if (!ret) |
454 | ret = -EIO; |
455 | dev_err(&port->dev, "failed to change line speed: %d\n" , ret); |
456 | } |
457 | |
458 | kfree(objp: transfer_buffer); |
459 | } |
460 | |
461 | static int __init ir_init(void) |
462 | { |
463 | if (buffer_size) { |
464 | ir_device.bulk_in_size = buffer_size; |
465 | ir_device.bulk_out_size = buffer_size; |
466 | } |
467 | |
468 | return usb_serial_register_drivers(serial_drivers, KBUILD_MODNAME, id_table: ir_id_table); |
469 | } |
470 | |
471 | static void __exit ir_exit(void) |
472 | { |
473 | usb_serial_deregister_drivers(serial_drivers); |
474 | } |
475 | |
476 | |
477 | module_init(ir_init); |
478 | module_exit(ir_exit); |
479 | |
480 | MODULE_AUTHOR(DRIVER_AUTHOR); |
481 | MODULE_DESCRIPTION(DRIVER_DESC); |
482 | MODULE_LICENSE("GPL" ); |
483 | |
484 | module_param(xbof, int, 0); |
485 | MODULE_PARM_DESC(xbof, "Force specific number of XBOFs" ); |
486 | module_param(buffer_size, int, 0); |
487 | MODULE_PARM_DESC(buffer_size, "Size of the transfer buffers" ); |
488 | |
489 | |