1 /* 2 * USB Serial Converter Generic functions 3 * 4 * Copyright (C) 2010 - 2011 Johan Hovold (jhovold@gmail.com) 5 * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com) 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License version 9 * 2 as published by the Free Software Foundation. 10 * 11 */ 12 13 #include <linux/kernel.h> 14 #include <linux/errno.h> 15 #include <linux/slab.h> 16 #include <linux/sysrq.h> 17 #include <linux/tty.h> 18 #include <linux/tty_flip.h> 19 #include <linux/module.h> 20 #include <linux/moduleparam.h> 21 #include <linux/usb.h> 22 #include <linux/usb/serial.h> 23 #include <linux/uaccess.h> 24 #include <linux/kfifo.h> 25 #include <linux/serial.h> 26 27 static int debug; 28 29 #ifdef CONFIG_USB_SERIAL_GENERIC 30 31 static int generic_probe(struct usb_interface *interface, 32 const struct usb_device_id *id); 33 34 static __u16 vendor = 0x05f9; 35 static __u16 product = 0xffff; 36 37 module_param(vendor, ushort, 0); 38 MODULE_PARM_DESC(vendor, "User specified USB idVendor"); 39 40 module_param(product, ushort, 0); 41 MODULE_PARM_DESC(product, "User specified USB idProduct"); 42 43 static struct usb_device_id generic_device_ids[2]; /* Initially all zeroes. */ 44 45 /* we want to look at all devices, as the vendor/product id can change 46 * depending on the command line argument */ 47 static const struct usb_device_id generic_serial_ids[] = { 48 {.driver_info = 42}, 49 {} 50 }; 51 52 static struct usb_driver generic_driver = { 53 .name = "usbserial_generic", 54 .probe = generic_probe, 55 .disconnect = usb_serial_disconnect, 56 .id_table = generic_serial_ids, 57 .no_dynamic_id = 1, 58 }; 59 60 /* All of the device info needed for the Generic Serial Converter */ 61 struct usb_serial_driver usb_serial_generic_device = { 62 .driver = { 63 .owner = THIS_MODULE, 64 .name = "generic", 65 }, 66 .id_table = generic_device_ids, 67 .usb_driver = &generic_driver, 68 .num_ports = 1, 69 .disconnect = usb_serial_generic_disconnect, 70 .release = usb_serial_generic_release, 71 .throttle = usb_serial_generic_throttle, 72 .unthrottle = usb_serial_generic_unthrottle, 73 .resume = usb_serial_generic_resume, 74 }; 75 76 static int generic_probe(struct usb_interface *interface, 77 const struct usb_device_id *id) 78 { 79 const struct usb_device_id *id_pattern; 80 81 id_pattern = usb_match_id(interface, generic_device_ids); 82 if (id_pattern != NULL) 83 return usb_serial_probe(interface, id); 84 return -ENODEV; 85 } 86 #endif 87 88 int usb_serial_generic_register(int _debug) 89 { 90 int retval = 0; 91 92 debug = _debug; 93 #ifdef CONFIG_USB_SERIAL_GENERIC 94 generic_device_ids[0].idVendor = vendor; 95 generic_device_ids[0].idProduct = product; 96 generic_device_ids[0].match_flags = 97 USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT; 98 99 /* register our generic driver with ourselves */ 100 retval = usb_serial_register(&usb_serial_generic_device); 101 if (retval) 102 goto exit; 103 retval = usb_register(&generic_driver); 104 if (retval) 105 usb_serial_deregister(&usb_serial_generic_device); 106 exit: 107 #endif 108 return retval; 109 } 110 111 void usb_serial_generic_deregister(void) 112 { 113 #ifdef CONFIG_USB_SERIAL_GENERIC 114 /* remove our generic driver */ 115 usb_deregister(&generic_driver); 116 usb_serial_deregister(&usb_serial_generic_device); 117 #endif 118 } 119 120 int usb_serial_generic_open(struct tty_struct *tty, struct usb_serial_port *port) 121 { 122 int result = 0; 123 unsigned long flags; 124 125 dbg("%s - port %d", __func__, port->number); 126 127 /* clear the throttle flags */ 128 spin_lock_irqsave(&port->lock, flags); 129 port->throttled = 0; 130 port->throttle_req = 0; 131 spin_unlock_irqrestore(&port->lock, flags); 132 133 /* if we have a bulk endpoint, start reading from it */ 134 if (port->bulk_in_size) 135 result = usb_serial_generic_submit_read_urbs(port, GFP_KERNEL); 136 137 return result; 138 } 139 EXPORT_SYMBOL_GPL(usb_serial_generic_open); 140 141 static void generic_cleanup(struct usb_serial_port *port) 142 { 143 struct usb_serial *serial = port->serial; 144 unsigned long flags; 145 int i; 146 147 dbg("%s - port %d", __func__, port->number); 148 149 if (serial->dev) { 150 /* shutdown any bulk transfers that might be going on */ 151 if (port->bulk_out_size) { 152 usb_kill_urb(port->write_urb); 153 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) 154 usb_kill_urb(port->write_urbs[i]); 155 156 spin_lock_irqsave(&port->lock, flags); 157 kfifo_reset_out(&port->write_fifo); 158 spin_unlock_irqrestore(&port->lock, flags); 159 } 160 if (port->bulk_in_size) { 161 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) 162 usb_kill_urb(port->read_urbs[i]); 163 } 164 } 165 } 166 167 void usb_serial_generic_close(struct usb_serial_port *port) 168 { 169 dbg("%s - port %d", __func__, port->number); 170 generic_cleanup(port); 171 } 172 EXPORT_SYMBOL_GPL(usb_serial_generic_close); 173 174 int usb_serial_generic_prepare_write_buffer(struct usb_serial_port *port, 175 void *dest, size_t size) 176 { 177 return kfifo_out_locked(&port->write_fifo, dest, size, &port->lock); 178 } 179 180 /** 181 * usb_serial_generic_write_start - kick off an URB write 182 * @port: Pointer to the &struct usb_serial_port data 183 * 184 * Returns zero on success, or a negative errno value 185 */ 186 static int usb_serial_generic_write_start(struct usb_serial_port *port) 187 { 188 struct urb *urb; 189 int count, result; 190 unsigned long flags; 191 int i; 192 193 if (test_and_set_bit_lock(USB_SERIAL_WRITE_BUSY, &port->flags)) 194 return 0; 195 retry: 196 spin_lock_irqsave(&port->lock, flags); 197 if (!port->write_urbs_free || !kfifo_len(&port->write_fifo)) { 198 clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags); 199 spin_unlock_irqrestore(&port->lock, flags); 200 return 0; 201 } 202 i = (int)find_first_bit(&port->write_urbs_free, 203 ARRAY_SIZE(port->write_urbs)); 204 spin_unlock_irqrestore(&port->lock, flags); 205 206 urb = port->write_urbs[i]; 207 count = port->serial->type->prepare_write_buffer(port, 208 urb->transfer_buffer, 209 port->bulk_out_size); 210 urb->transfer_buffer_length = count; 211 usb_serial_debug_data(debug, &port->dev, __func__, count, 212 urb->transfer_buffer); 213 spin_lock_irqsave(&port->lock, flags); 214 port->tx_bytes += count; 215 spin_unlock_irqrestore(&port->lock, flags); 216 217 clear_bit(i, &port->write_urbs_free); 218 result = usb_submit_urb(urb, GFP_ATOMIC); 219 if (result) { 220 dev_err(&port->dev, "%s - error submitting urb: %d\n", 221 __func__, result); 222 set_bit(i, &port->write_urbs_free); 223 spin_lock_irqsave(&port->lock, flags); 224 port->tx_bytes -= count; 225 spin_unlock_irqrestore(&port->lock, flags); 226 227 clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags); 228 return result; 229 } 230 231 /* Try sending off another urb, unless in irq context (in which case 232 * there will be no free urb). */ 233 if (!in_irq()) 234 goto retry; 235 236 clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags); 237 238 return 0; 239 } 240 241 /** 242 * usb_serial_generic_write - generic write function for serial USB devices 243 * @tty: Pointer to &struct tty_struct for the device 244 * @port: Pointer to the &usb_serial_port structure for the device 245 * @buf: Pointer to the data to write 246 * @count: Number of bytes to write 247 * 248 * Returns the number of characters actually written, which may be anything 249 * from zero to @count. If an error occurs, it returns the negative errno 250 * value. 251 */ 252 int usb_serial_generic_write(struct tty_struct *tty, 253 struct usb_serial_port *port, const unsigned char *buf, int count) 254 { 255 int result; 256 257 dbg("%s - port %d", __func__, port->number); 258 259 /* only do something if we have a bulk out endpoint */ 260 if (!port->bulk_out_size) 261 return -ENODEV; 262 263 if (!count) 264 return 0; 265 266 count = kfifo_in_locked(&port->write_fifo, buf, count, &port->lock); 267 result = usb_serial_generic_write_start(port); 268 if (result) 269 return result; 270 271 return count; 272 } 273 EXPORT_SYMBOL_GPL(usb_serial_generic_write); 274 275 int usb_serial_generic_write_room(struct tty_struct *tty) 276 { 277 struct usb_serial_port *port = tty->driver_data; 278 unsigned long flags; 279 int room; 280 281 dbg("%s - port %d", __func__, port->number); 282 283 if (!port->bulk_out_size) 284 return 0; 285 286 spin_lock_irqsave(&port->lock, flags); 287 room = kfifo_avail(&port->write_fifo); 288 spin_unlock_irqrestore(&port->lock, flags); 289 290 dbg("%s - returns %d", __func__, room); 291 return room; 292 } 293 294 int usb_serial_generic_chars_in_buffer(struct tty_struct *tty) 295 { 296 struct usb_serial_port *port = tty->driver_data; 297 unsigned long flags; 298 int chars; 299 300 dbg("%s - port %d", __func__, port->number); 301 302 if (!port->bulk_out_size) 303 return 0; 304 305 spin_lock_irqsave(&port->lock, flags); 306 chars = kfifo_len(&port->write_fifo) + port->tx_bytes; 307 spin_unlock_irqrestore(&port->lock, flags); 308 309 dbg("%s - returns %d", __func__, chars); 310 return chars; 311 } 312 313 static int usb_serial_generic_submit_read_urb(struct usb_serial_port *port, 314 int index, gfp_t mem_flags) 315 { 316 int res; 317 318 if (!test_and_clear_bit(index, &port->read_urbs_free)) 319 return 0; 320 321 dbg("%s - port %d, urb %d\n", __func__, port->number, index); 322 323 res = usb_submit_urb(port->read_urbs[index], mem_flags); 324 if (res) { 325 if (res != -EPERM) { 326 dev_err(&port->dev, 327 "%s - usb_submit_urb failed: %d\n", 328 __func__, res); 329 } 330 set_bit(index, &port->read_urbs_free); 331 return res; 332 } 333 334 return 0; 335 } 336 337 int usb_serial_generic_submit_read_urbs(struct usb_serial_port *port, 338 gfp_t mem_flags) 339 { 340 int res; 341 int i; 342 343 dbg("%s - port %d", __func__, port->number); 344 345 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) { 346 res = usb_serial_generic_submit_read_urb(port, i, mem_flags); 347 if (res) 348 goto err; 349 } 350 351 return 0; 352 err: 353 for (; i >= 0; --i) 354 usb_kill_urb(port->read_urbs[i]); 355 356 return res; 357 } 358 EXPORT_SYMBOL_GPL(usb_serial_generic_submit_read_urbs); 359 360 void usb_serial_generic_process_read_urb(struct urb *urb) 361 { 362 struct usb_serial_port *port = urb->context; 363 struct tty_struct *tty; 364 char *ch = (char *)urb->transfer_buffer; 365 int i; 366 367 if (!urb->actual_length) 368 return; 369 370 tty = tty_port_tty_get(&port->port); 371 if (!tty) 372 return; 373 374 /* The per character mucking around with sysrq path it too slow for 375 stuff like 3G modems, so shortcircuit it in the 99.9999999% of cases 376 where the USB serial is not a console anyway */ 377 if (!port->port.console || !port->sysrq) 378 tty_insert_flip_string(tty, ch, urb->actual_length); 379 else { 380 for (i = 0; i < urb->actual_length; i++, ch++) { 381 if (!usb_serial_handle_sysrq_char(port, *ch)) 382 tty_insert_flip_char(tty, *ch, TTY_NORMAL); 383 } 384 } 385 tty_flip_buffer_push(tty); 386 tty_kref_put(tty); 387 } 388 EXPORT_SYMBOL_GPL(usb_serial_generic_process_read_urb); 389 390 void usb_serial_generic_read_bulk_callback(struct urb *urb) 391 { 392 struct usb_serial_port *port = urb->context; 393 unsigned char *data = urb->transfer_buffer; 394 unsigned long flags; 395 int i; 396 397 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) { 398 if (urb == port->read_urbs[i]) 399 break; 400 } 401 set_bit(i, &port->read_urbs_free); 402 403 dbg("%s - port %d, urb %d, len %d\n", __func__, port->number, i, 404 urb->actual_length); 405 if (urb->status) { 406 dbg("%s - non-zero urb status: %d\n", __func__, urb->status); 407 return; 408 } 409 410 usb_serial_debug_data(debug, &port->dev, __func__, 411 urb->actual_length, data); 412 port->serial->type->process_read_urb(urb); 413 414 /* Throttle the device if requested by tty */ 415 spin_lock_irqsave(&port->lock, flags); 416 port->throttled = port->throttle_req; 417 if (!port->throttled) { 418 spin_unlock_irqrestore(&port->lock, flags); 419 usb_serial_generic_submit_read_urb(port, i, GFP_ATOMIC); 420 } else 421 spin_unlock_irqrestore(&port->lock, flags); 422 } 423 EXPORT_SYMBOL_GPL(usb_serial_generic_read_bulk_callback); 424 425 void usb_serial_generic_write_bulk_callback(struct urb *urb) 426 { 427 unsigned long flags; 428 struct usb_serial_port *port = urb->context; 429 int status = urb->status; 430 int i; 431 432 dbg("%s - port %d", __func__, port->number); 433 434 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) 435 if (port->write_urbs[i] == urb) 436 break; 437 438 spin_lock_irqsave(&port->lock, flags); 439 port->tx_bytes -= urb->transfer_buffer_length; 440 set_bit(i, &port->write_urbs_free); 441 spin_unlock_irqrestore(&port->lock, flags); 442 443 if (status) { 444 dbg("%s - non-zero urb status: %d", __func__, status); 445 446 spin_lock_irqsave(&port->lock, flags); 447 kfifo_reset_out(&port->write_fifo); 448 spin_unlock_irqrestore(&port->lock, flags); 449 } else { 450 usb_serial_generic_write_start(port); 451 } 452 453 usb_serial_port_softint(port); 454 } 455 EXPORT_SYMBOL_GPL(usb_serial_generic_write_bulk_callback); 456 457 void usb_serial_generic_throttle(struct tty_struct *tty) 458 { 459 struct usb_serial_port *port = tty->driver_data; 460 unsigned long flags; 461 462 dbg("%s - port %d", __func__, port->number); 463 464 /* Set the throttle request flag. It will be picked up 465 * by usb_serial_generic_read_bulk_callback(). */ 466 spin_lock_irqsave(&port->lock, flags); 467 port->throttle_req = 1; 468 spin_unlock_irqrestore(&port->lock, flags); 469 } 470 EXPORT_SYMBOL_GPL(usb_serial_generic_throttle); 471 472 void usb_serial_generic_unthrottle(struct tty_struct *tty) 473 { 474 struct usb_serial_port *port = tty->driver_data; 475 int was_throttled; 476 477 dbg("%s - port %d", __func__, port->number); 478 479 /* Clear the throttle flags */ 480 spin_lock_irq(&port->lock); 481 was_throttled = port->throttled; 482 port->throttled = port->throttle_req = 0; 483 spin_unlock_irq(&port->lock); 484 485 if (was_throttled) 486 usb_serial_generic_submit_read_urbs(port, GFP_KERNEL); 487 } 488 EXPORT_SYMBOL_GPL(usb_serial_generic_unthrottle); 489 490 #ifdef CONFIG_MAGIC_SYSRQ 491 int usb_serial_handle_sysrq_char(struct usb_serial_port *port, unsigned int ch) 492 { 493 if (port->sysrq && port->port.console) { 494 if (ch && time_before(jiffies, port->sysrq)) { 495 handle_sysrq(ch); 496 port->sysrq = 0; 497 return 1; 498 } 499 port->sysrq = 0; 500 } 501 return 0; 502 } 503 #else 504 int usb_serial_handle_sysrq_char(struct usb_serial_port *port, unsigned int ch) 505 { 506 return 0; 507 } 508 #endif 509 EXPORT_SYMBOL_GPL(usb_serial_handle_sysrq_char); 510 511 int usb_serial_handle_break(struct usb_serial_port *port) 512 { 513 if (!port->sysrq) { 514 port->sysrq = jiffies + HZ*5; 515 return 1; 516 } 517 port->sysrq = 0; 518 return 0; 519 } 520 EXPORT_SYMBOL_GPL(usb_serial_handle_break); 521 522 /** 523 * usb_serial_handle_dcd_change - handle a change of carrier detect state 524 * @port: usb_serial_port structure for the open port 525 * @tty: tty_struct structure for the port 526 * @status: new carrier detect status, nonzero if active 527 */ 528 void usb_serial_handle_dcd_change(struct usb_serial_port *usb_port, 529 struct tty_struct *tty, unsigned int status) 530 { 531 struct tty_port *port = &usb_port->port; 532 533 dbg("%s - port %d, status %d", __func__, usb_port->number, status); 534 535 if (status) 536 wake_up_interruptible(&port->open_wait); 537 else if (tty && !C_CLOCAL(tty)) 538 tty_hangup(tty); 539 } 540 EXPORT_SYMBOL_GPL(usb_serial_handle_dcd_change); 541 542 int usb_serial_generic_resume(struct usb_serial *serial) 543 { 544 struct usb_serial_port *port; 545 int i, c = 0, r; 546 547 for (i = 0; i < serial->num_ports; i++) { 548 port = serial->port[i]; 549 if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags)) 550 continue; 551 552 if (port->bulk_in_size) { 553 r = usb_serial_generic_submit_read_urbs(port, 554 GFP_NOIO); 555 if (r < 0) 556 c++; 557 } 558 559 if (port->bulk_out_size) { 560 r = usb_serial_generic_write_start(port); 561 if (r < 0) 562 c++; 563 } 564 } 565 566 return c ? -EIO : 0; 567 } 568 EXPORT_SYMBOL_GPL(usb_serial_generic_resume); 569 570 void usb_serial_generic_disconnect(struct usb_serial *serial) 571 { 572 int i; 573 574 dbg("%s", __func__); 575 576 /* stop reads and writes on all ports */ 577 for (i = 0; i < serial->num_ports; ++i) 578 generic_cleanup(serial->port[i]); 579 } 580 EXPORT_SYMBOL_GPL(usb_serial_generic_disconnect); 581 582 void usb_serial_generic_release(struct usb_serial *serial) 583 { 584 dbg("%s", __func__); 585 } 586