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