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.txt 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_open(struct tty_struct *tty, struct usb_serial_port *port); 49 static int ir_prepare_write_buffer(struct usb_serial_port *port, 50 void *dest, size_t size); 51 static void ir_process_read_urb(struct urb *urb); 52 static void ir_set_termios(struct tty_struct *tty, 53 struct usb_serial_port *port, struct ktermios *old_termios); 54 55 /* Not that this lot means you can only have one per system */ 56 static u8 ir_baud; 57 static u8 ir_xbof; 58 static u8 ir_add_bof; 59 60 static const struct usb_device_id ir_id_table[] = { 61 { USB_DEVICE(0x050f, 0x0180) }, /* KC Technology, KC-180 */ 62 { USB_DEVICE(0x08e9, 0x0100) }, /* XTNDAccess */ 63 { USB_DEVICE(0x09c4, 0x0011) }, /* ACTiSys ACT-IR2000U */ 64 { USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, USB_SUBCLASS_IRDA, 0) }, 65 { } /* Terminating entry */ 66 }; 67 68 MODULE_DEVICE_TABLE(usb, ir_id_table); 69 70 static struct usb_serial_driver ir_device = { 71 .driver = { 72 .owner = THIS_MODULE, 73 .name = "ir-usb", 74 }, 75 .description = "IR Dongle", 76 .id_table = ir_id_table, 77 .num_ports = 1, 78 .set_termios = ir_set_termios, 79 .attach = ir_startup, 80 .open = ir_open, 81 .prepare_write_buffer = ir_prepare_write_buffer, 82 .process_read_urb = ir_process_read_urb, 83 }; 84 85 static struct usb_serial_driver * const serial_drivers[] = { 86 &ir_device, NULL 87 }; 88 89 static inline void irda_usb_dump_class_desc(struct usb_serial *serial, 90 struct usb_irda_cs_descriptor *desc) 91 { 92 struct device *dev = &serial->dev->dev; 93 94 dev_dbg(dev, "bLength=%x\n", desc->bLength); 95 dev_dbg(dev, "bDescriptorType=%x\n", desc->bDescriptorType); 96 dev_dbg(dev, "bcdSpecRevision=%x\n", __le16_to_cpu(desc->bcdSpecRevision)); 97 dev_dbg(dev, "bmDataSize=%x\n", desc->bmDataSize); 98 dev_dbg(dev, "bmWindowSize=%x\n", desc->bmWindowSize); 99 dev_dbg(dev, "bmMinTurnaroundTime=%d\n", desc->bmMinTurnaroundTime); 100 dev_dbg(dev, "wBaudRate=%x\n", __le16_to_cpu(desc->wBaudRate)); 101 dev_dbg(dev, "bmAdditionalBOFs=%x\n", desc->bmAdditionalBOFs); 102 dev_dbg(dev, "bIrdaRateSniff=%x\n", desc->bIrdaRateSniff); 103 dev_dbg(dev, "bMaxUnicastList=%x\n", desc->bMaxUnicastList); 104 } 105 106 /*------------------------------------------------------------------*/ 107 /* 108 * Function irda_usb_find_class_desc(dev, ifnum) 109 * 110 * Returns instance of IrDA class descriptor, or NULL if not found 111 * 112 * The class descriptor is some extra info that IrDA USB devices will 113 * offer to us, describing their IrDA characteristics. We will use that in 114 * irda_usb_init_qos() 115 * 116 * Based on the same function in drivers/net/irda/irda-usb.c 117 */ 118 static struct usb_irda_cs_descriptor * 119 irda_usb_find_class_desc(struct usb_serial *serial, unsigned int ifnum) 120 { 121 struct usb_device *dev = serial->dev; 122 struct usb_irda_cs_descriptor *desc; 123 int ret; 124 125 desc = kzalloc(sizeof(*desc), GFP_KERNEL); 126 if (!desc) 127 return NULL; 128 129 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 130 USB_REQ_CS_IRDA_GET_CLASS_DESC, 131 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 132 0, ifnum, desc, sizeof(*desc), 1000); 133 134 dev_dbg(&serial->dev->dev, "%s - ret=%d\n", __func__, ret); 135 if (ret < sizeof(*desc)) { 136 dev_dbg(&serial->dev->dev, 137 "%s - class descriptor read %s (%d)\n", __func__, 138 (ret < 0) ? "failed" : "too short", ret); 139 goto error; 140 } 141 if (desc->bDescriptorType != USB_DT_CS_IRDA) { 142 dev_dbg(&serial->dev->dev, "%s - bad class descriptor type\n", 143 __func__); 144 goto error; 145 } 146 147 irda_usb_dump_class_desc(serial, desc); 148 return desc; 149 150 error: 151 kfree(desc); 152 return NULL; 153 } 154 155 static u8 ir_xbof_change(u8 xbof) 156 { 157 u8 result; 158 159 /* reference irda-usb.c */ 160 switch (xbof) { 161 case 48: 162 result = 0x10; 163 break; 164 case 28: 165 case 24: 166 result = 0x20; 167 break; 168 default: 169 case 12: 170 result = 0x30; 171 break; 172 case 5: 173 case 6: 174 result = 0x40; 175 break; 176 case 3: 177 result = 0x50; 178 break; 179 case 2: 180 result = 0x60; 181 break; 182 case 1: 183 result = 0x70; 184 break; 185 case 0: 186 result = 0x80; 187 break; 188 } 189 190 return(result); 191 } 192 193 static int ir_startup(struct usb_serial *serial) 194 { 195 struct usb_irda_cs_descriptor *irda_desc; 196 int rates; 197 198 irda_desc = irda_usb_find_class_desc(serial, 0); 199 if (!irda_desc) { 200 dev_err(&serial->dev->dev, 201 "IRDA class descriptor not found, device not bound\n"); 202 return -ENODEV; 203 } 204 205 rates = le16_to_cpu(irda_desc->wBaudRate); 206 207 dev_dbg(&serial->dev->dev, 208 "%s - Baud rates supported:%s%s%s%s%s%s%s%s%s\n", 209 __func__, 210 (rates & USB_IRDA_BR_2400) ? " 2400" : "", 211 (rates & USB_IRDA_BR_9600) ? " 9600" : "", 212 (rates & USB_IRDA_BR_19200) ? " 19200" : "", 213 (rates & USB_IRDA_BR_38400) ? " 38400" : "", 214 (rates & USB_IRDA_BR_57600) ? " 57600" : "", 215 (rates & USB_IRDA_BR_115200) ? " 115200" : "", 216 (rates & USB_IRDA_BR_576000) ? " 576000" : "", 217 (rates & USB_IRDA_BR_1152000) ? " 1152000" : "", 218 (rates & USB_IRDA_BR_4000000) ? " 4000000" : ""); 219 220 switch (irda_desc->bmAdditionalBOFs) { 221 case USB_IRDA_AB_48: 222 ir_add_bof = 48; 223 break; 224 case USB_IRDA_AB_24: 225 ir_add_bof = 24; 226 break; 227 case USB_IRDA_AB_12: 228 ir_add_bof = 12; 229 break; 230 case USB_IRDA_AB_6: 231 ir_add_bof = 6; 232 break; 233 case USB_IRDA_AB_3: 234 ir_add_bof = 3; 235 break; 236 case USB_IRDA_AB_2: 237 ir_add_bof = 2; 238 break; 239 case USB_IRDA_AB_1: 240 ir_add_bof = 1; 241 break; 242 case USB_IRDA_AB_0: 243 ir_add_bof = 0; 244 break; 245 default: 246 break; 247 } 248 249 kfree(irda_desc); 250 251 return 0; 252 } 253 254 static int ir_open(struct tty_struct *tty, struct usb_serial_port *port) 255 { 256 int i; 257 258 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) 259 port->write_urbs[i]->transfer_flags = URB_ZERO_PACKET; 260 261 /* Start reading from the device */ 262 return usb_serial_generic_open(tty, port); 263 } 264 265 static int ir_prepare_write_buffer(struct usb_serial_port *port, 266 void *dest, size_t size) 267 { 268 unsigned char *buf = dest; 269 int count; 270 271 /* 272 * The first byte of the packet we send to the device contains an 273 * inbound header which indicates an additional number of BOFs and 274 * a baud rate change. 275 * 276 * See section 5.4.2.2 of the USB IrDA spec. 277 */ 278 *buf = ir_xbof | ir_baud; 279 280 count = kfifo_out_locked(&port->write_fifo, buf + 1, size - 1, 281 &port->lock); 282 return count + 1; 283 } 284 285 static void ir_process_read_urb(struct urb *urb) 286 { 287 struct usb_serial_port *port = urb->context; 288 unsigned char *data = urb->transfer_buffer; 289 290 if (!urb->actual_length) 291 return; 292 /* 293 * The first byte of the packet we get from the device 294 * contains a busy indicator and baud rate change. 295 * See section 5.4.1.2 of the USB IrDA spec. 296 */ 297 if (*data & 0x0f) 298 ir_baud = *data & 0x0f; 299 300 if (urb->actual_length == 1) 301 return; 302 303 tty_insert_flip_string(&port->port, data + 1, urb->actual_length - 1); 304 tty_flip_buffer_push(&port->port); 305 } 306 307 static void ir_set_termios_callback(struct urb *urb) 308 { 309 kfree(urb->transfer_buffer); 310 311 if (urb->status) 312 dev_dbg(&urb->dev->dev, "%s - non-zero urb status: %d\n", 313 __func__, urb->status); 314 } 315 316 static void ir_set_termios(struct tty_struct *tty, 317 struct usb_serial_port *port, struct ktermios *old_termios) 318 { 319 struct urb *urb; 320 unsigned char *transfer_buffer; 321 int result; 322 speed_t baud; 323 int ir_baud; 324 325 baud = tty_get_baud_rate(tty); 326 327 /* 328 * FIXME, we should compare the baud request against the 329 * capability stated in the IR header that we got in the 330 * startup function. 331 */ 332 333 switch (baud) { 334 case 2400: 335 ir_baud = USB_IRDA_BR_2400; 336 break; 337 case 9600: 338 ir_baud = USB_IRDA_BR_9600; 339 break; 340 case 19200: 341 ir_baud = USB_IRDA_BR_19200; 342 break; 343 case 38400: 344 ir_baud = USB_IRDA_BR_38400; 345 break; 346 case 57600: 347 ir_baud = USB_IRDA_BR_57600; 348 break; 349 case 115200: 350 ir_baud = USB_IRDA_BR_115200; 351 break; 352 case 576000: 353 ir_baud = USB_IRDA_BR_576000; 354 break; 355 case 1152000: 356 ir_baud = USB_IRDA_BR_1152000; 357 break; 358 case 4000000: 359 ir_baud = USB_IRDA_BR_4000000; 360 break; 361 default: 362 ir_baud = USB_IRDA_BR_9600; 363 baud = 9600; 364 } 365 366 if (xbof == -1) 367 ir_xbof = ir_xbof_change(ir_add_bof); 368 else 369 ir_xbof = ir_xbof_change(xbof) ; 370 371 /* Only speed changes are supported */ 372 tty_termios_copy_hw(&tty->termios, old_termios); 373 tty_encode_baud_rate(tty, baud, baud); 374 375 /* 376 * send the baud change out on an "empty" data packet 377 */ 378 urb = usb_alloc_urb(0, GFP_KERNEL); 379 if (!urb) 380 return; 381 382 transfer_buffer = kmalloc(1, GFP_KERNEL); 383 if (!transfer_buffer) 384 goto err_buf; 385 386 *transfer_buffer = ir_xbof | ir_baud; 387 388 usb_fill_bulk_urb( 389 urb, 390 port->serial->dev, 391 usb_sndbulkpipe(port->serial->dev, 392 port->bulk_out_endpointAddress), 393 transfer_buffer, 394 1, 395 ir_set_termios_callback, 396 port); 397 398 urb->transfer_flags = URB_ZERO_PACKET; 399 400 result = usb_submit_urb(urb, GFP_KERNEL); 401 if (result) { 402 dev_err(&port->dev, "%s - failed to submit urb: %d\n", 403 __func__, result); 404 goto err_subm; 405 } 406 407 usb_free_urb(urb); 408 409 return; 410 err_subm: 411 kfree(transfer_buffer); 412 err_buf: 413 usb_free_urb(urb); 414 } 415 416 static int __init ir_init(void) 417 { 418 if (buffer_size) { 419 ir_device.bulk_in_size = buffer_size; 420 ir_device.bulk_out_size = buffer_size; 421 } 422 423 return usb_serial_register_drivers(serial_drivers, KBUILD_MODNAME, ir_id_table); 424 } 425 426 static void __exit ir_exit(void) 427 { 428 usb_serial_deregister_drivers(serial_drivers); 429 } 430 431 432 module_init(ir_init); 433 module_exit(ir_exit); 434 435 MODULE_AUTHOR(DRIVER_AUTHOR); 436 MODULE_DESCRIPTION(DRIVER_DESC); 437 MODULE_LICENSE("GPL"); 438 439 module_param(xbof, int, 0); 440 MODULE_PARM_DESC(xbof, "Force specific number of XBOFs"); 441 module_param(buffer_size, int, 0); 442 MODULE_PARM_DESC(buffer_size, "Size of the transfer buffers"); 443 444