1 /* 2 * USB Serial Converter Generic functions 3 * 4 * Copyright (C) 2010 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_urb(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 usb_kill_urb(port->read_urb); 162 } 163 } 164 165 void usb_serial_generic_close(struct usb_serial_port *port) 166 { 167 dbg("%s - port %d", __func__, port->number); 168 generic_cleanup(port); 169 } 170 EXPORT_SYMBOL_GPL(usb_serial_generic_close); 171 172 int usb_serial_generic_prepare_write_buffer(struct usb_serial_port *port, 173 void *dest, size_t size) 174 { 175 return kfifo_out_locked(&port->write_fifo, dest, size, &port->lock); 176 } 177 178 /** 179 * usb_serial_generic_write_start - kick off an URB write 180 * @port: Pointer to the &struct usb_serial_port data 181 * 182 * Returns zero on success, or a negative errno value 183 */ 184 static int usb_serial_generic_write_start(struct usb_serial_port *port) 185 { 186 struct urb *urb; 187 int count, result; 188 unsigned long flags; 189 int i; 190 191 if (test_and_set_bit_lock(USB_SERIAL_WRITE_BUSY, &port->flags)) 192 return 0; 193 retry: 194 spin_lock_irqsave(&port->lock, flags); 195 if (!port->write_urbs_free || !kfifo_len(&port->write_fifo)) { 196 clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags); 197 spin_unlock_irqrestore(&port->lock, flags); 198 return 0; 199 } 200 i = (int)find_first_bit(&port->write_urbs_free, 201 ARRAY_SIZE(port->write_urbs)); 202 spin_unlock_irqrestore(&port->lock, flags); 203 204 urb = port->write_urbs[i]; 205 count = port->serial->type->prepare_write_buffer(port, 206 urb->transfer_buffer, 207 port->bulk_out_size); 208 urb->transfer_buffer_length = count; 209 usb_serial_debug_data(debug, &port->dev, __func__, count, 210 urb->transfer_buffer); 211 spin_lock_irqsave(&port->lock, flags); 212 port->tx_bytes += count; 213 spin_unlock_irqrestore(&port->lock, flags); 214 215 clear_bit(i, &port->write_urbs_free); 216 result = usb_submit_urb(urb, GFP_ATOMIC); 217 if (result) { 218 dev_err(&port->dev, "%s - error submitting urb: %d\n", 219 __func__, result); 220 set_bit(i, &port->write_urbs_free); 221 spin_lock_irqsave(&port->lock, flags); 222 port->tx_bytes -= count; 223 spin_unlock_irqrestore(&port->lock, flags); 224 225 clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags); 226 return result; 227 } 228 229 /* Try sending off another urb, unless in irq context (in which case 230 * there will be no free urb). */ 231 if (!in_irq()) 232 goto retry; 233 234 clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags); 235 236 return 0; 237 } 238 239 /** 240 * usb_serial_generic_write - generic write function for serial USB devices 241 * @tty: Pointer to &struct tty_struct for the device 242 * @port: Pointer to the &usb_serial_port structure for the device 243 * @buf: Pointer to the data to write 244 * @count: Number of bytes to write 245 * 246 * Returns the number of characters actually written, which may be anything 247 * from zero to @count. If an error occurs, it returns the negative errno 248 * value. 249 */ 250 int usb_serial_generic_write(struct tty_struct *tty, 251 struct usb_serial_port *port, const unsigned char *buf, int count) 252 { 253 int result; 254 255 dbg("%s - port %d", __func__, port->number); 256 257 /* only do something if we have a bulk out endpoint */ 258 if (!port->bulk_out_size) 259 return -ENODEV; 260 261 if (!count) 262 return 0; 263 264 count = kfifo_in_locked(&port->write_fifo, buf, count, &port->lock); 265 result = usb_serial_generic_write_start(port); 266 if (result) 267 return result; 268 269 return count; 270 } 271 EXPORT_SYMBOL_GPL(usb_serial_generic_write); 272 273 int usb_serial_generic_write_room(struct tty_struct *tty) 274 { 275 struct usb_serial_port *port = tty->driver_data; 276 unsigned long flags; 277 int room; 278 279 dbg("%s - port %d", __func__, port->number); 280 281 if (!port->bulk_out_size) 282 return 0; 283 284 spin_lock_irqsave(&port->lock, flags); 285 room = kfifo_avail(&port->write_fifo); 286 spin_unlock_irqrestore(&port->lock, flags); 287 288 dbg("%s - returns %d", __func__, room); 289 return room; 290 } 291 292 int usb_serial_generic_chars_in_buffer(struct tty_struct *tty) 293 { 294 struct usb_serial_port *port = tty->driver_data; 295 unsigned long flags; 296 int chars; 297 298 dbg("%s - port %d", __func__, port->number); 299 300 if (!port->bulk_out_size) 301 return 0; 302 303 spin_lock_irqsave(&port->lock, flags); 304 chars = kfifo_len(&port->write_fifo) + port->tx_bytes; 305 spin_unlock_irqrestore(&port->lock, flags); 306 307 dbg("%s - returns %d", __func__, chars); 308 return chars; 309 } 310 311 int usb_serial_generic_submit_read_urb(struct usb_serial_port *port, 312 gfp_t mem_flags) 313 { 314 int result; 315 316 result = usb_submit_urb(port->read_urb, mem_flags); 317 if (result && result != -EPERM) { 318 dev_err(&port->dev, "%s - error submitting urb: %d\n", 319 __func__, result); 320 } 321 return result; 322 } 323 EXPORT_SYMBOL_GPL(usb_serial_generic_submit_read_urb); 324 325 void usb_serial_generic_process_read_urb(struct urb *urb) 326 { 327 struct usb_serial_port *port = urb->context; 328 struct tty_struct *tty; 329 char *ch = (char *)urb->transfer_buffer; 330 int i; 331 332 if (!urb->actual_length) 333 return; 334 335 tty = tty_port_tty_get(&port->port); 336 if (!tty) 337 return; 338 339 /* The per character mucking around with sysrq path it too slow for 340 stuff like 3G modems, so shortcircuit it in the 99.9999999% of cases 341 where the USB serial is not a console anyway */ 342 if (!port->port.console || !port->sysrq) 343 tty_insert_flip_string(tty, ch, urb->actual_length); 344 else { 345 for (i = 0; i < urb->actual_length; i++, ch++) { 346 if (!usb_serial_handle_sysrq_char(port, *ch)) 347 tty_insert_flip_char(tty, *ch, TTY_NORMAL); 348 } 349 } 350 tty_flip_buffer_push(tty); 351 tty_kref_put(tty); 352 } 353 EXPORT_SYMBOL_GPL(usb_serial_generic_process_read_urb); 354 355 void usb_serial_generic_read_bulk_callback(struct urb *urb) 356 { 357 struct usb_serial_port *port = urb->context; 358 unsigned char *data = urb->transfer_buffer; 359 int status = urb->status; 360 unsigned long flags; 361 362 dbg("%s - port %d", __func__, port->number); 363 364 if (unlikely(status != 0)) { 365 dbg("%s - nonzero read bulk status received: %d", 366 __func__, status); 367 return; 368 } 369 370 usb_serial_debug_data(debug, &port->dev, __func__, 371 urb->actual_length, data); 372 port->serial->type->process_read_urb(urb); 373 374 /* Throttle the device if requested by tty */ 375 spin_lock_irqsave(&port->lock, flags); 376 port->throttled = port->throttle_req; 377 if (!port->throttled) { 378 spin_unlock_irqrestore(&port->lock, flags); 379 usb_serial_generic_submit_read_urb(port, GFP_ATOMIC); 380 } else 381 spin_unlock_irqrestore(&port->lock, flags); 382 } 383 EXPORT_SYMBOL_GPL(usb_serial_generic_read_bulk_callback); 384 385 void usb_serial_generic_write_bulk_callback(struct urb *urb) 386 { 387 unsigned long flags; 388 struct usb_serial_port *port = urb->context; 389 int status = urb->status; 390 int i; 391 392 dbg("%s - port %d", __func__, port->number); 393 394 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) 395 if (port->write_urbs[i] == urb) 396 break; 397 398 spin_lock_irqsave(&port->lock, flags); 399 port->tx_bytes -= urb->transfer_buffer_length; 400 set_bit(i, &port->write_urbs_free); 401 spin_unlock_irqrestore(&port->lock, flags); 402 403 if (status) { 404 dbg("%s - non-zero urb status: %d", __func__, status); 405 406 spin_lock_irqsave(&port->lock, flags); 407 kfifo_reset_out(&port->write_fifo); 408 spin_unlock_irqrestore(&port->lock, flags); 409 } else { 410 usb_serial_generic_write_start(port); 411 } 412 413 usb_serial_port_softint(port); 414 } 415 EXPORT_SYMBOL_GPL(usb_serial_generic_write_bulk_callback); 416 417 void usb_serial_generic_throttle(struct tty_struct *tty) 418 { 419 struct usb_serial_port *port = tty->driver_data; 420 unsigned long flags; 421 422 dbg("%s - port %d", __func__, port->number); 423 424 /* Set the throttle request flag. It will be picked up 425 * by usb_serial_generic_read_bulk_callback(). */ 426 spin_lock_irqsave(&port->lock, flags); 427 port->throttle_req = 1; 428 spin_unlock_irqrestore(&port->lock, flags); 429 } 430 EXPORT_SYMBOL_GPL(usb_serial_generic_throttle); 431 432 void usb_serial_generic_unthrottle(struct tty_struct *tty) 433 { 434 struct usb_serial_port *port = tty->driver_data; 435 int was_throttled; 436 437 dbg("%s - port %d", __func__, port->number); 438 439 /* Clear the throttle flags */ 440 spin_lock_irq(&port->lock); 441 was_throttled = port->throttled; 442 port->throttled = port->throttle_req = 0; 443 spin_unlock_irq(&port->lock); 444 445 if (was_throttled) 446 usb_serial_generic_submit_read_urb(port, GFP_KERNEL); 447 } 448 EXPORT_SYMBOL_GPL(usb_serial_generic_unthrottle); 449 450 #ifdef CONFIG_MAGIC_SYSRQ 451 int usb_serial_handle_sysrq_char(struct usb_serial_port *port, unsigned int ch) 452 { 453 if (port->sysrq && port->port.console) { 454 if (ch && time_before(jiffies, port->sysrq)) { 455 handle_sysrq(ch); 456 port->sysrq = 0; 457 return 1; 458 } 459 port->sysrq = 0; 460 } 461 return 0; 462 } 463 #else 464 int usb_serial_handle_sysrq_char(struct usb_serial_port *port, unsigned int ch) 465 { 466 return 0; 467 } 468 #endif 469 EXPORT_SYMBOL_GPL(usb_serial_handle_sysrq_char); 470 471 int usb_serial_handle_break(struct usb_serial_port *port) 472 { 473 if (!port->sysrq) { 474 port->sysrq = jiffies + HZ*5; 475 return 1; 476 } 477 port->sysrq = 0; 478 return 0; 479 } 480 EXPORT_SYMBOL_GPL(usb_serial_handle_break); 481 482 /** 483 * usb_serial_handle_dcd_change - handle a change of carrier detect state 484 * @port: usb_serial_port structure for the open port 485 * @tty: tty_struct structure for the port 486 * @status: new carrier detect status, nonzero if active 487 */ 488 void usb_serial_handle_dcd_change(struct usb_serial_port *usb_port, 489 struct tty_struct *tty, unsigned int status) 490 { 491 struct tty_port *port = &usb_port->port; 492 493 dbg("%s - port %d, status %d", __func__, usb_port->number, status); 494 495 if (status) 496 wake_up_interruptible(&port->open_wait); 497 else if (tty && !C_CLOCAL(tty)) 498 tty_hangup(tty); 499 } 500 EXPORT_SYMBOL_GPL(usb_serial_handle_dcd_change); 501 502 int usb_serial_generic_resume(struct usb_serial *serial) 503 { 504 struct usb_serial_port *port; 505 int i, c = 0, r; 506 507 for (i = 0; i < serial->num_ports; i++) { 508 port = serial->port[i]; 509 if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags)) 510 continue; 511 512 if (port->read_urb) { 513 r = usb_submit_urb(port->read_urb, GFP_NOIO); 514 if (r < 0) 515 c++; 516 } 517 518 if (port->bulk_out_size) { 519 r = usb_serial_generic_write_start(port); 520 if (r < 0) 521 c++; 522 } 523 } 524 525 return c ? -EIO : 0; 526 } 527 EXPORT_SYMBOL_GPL(usb_serial_generic_resume); 528 529 void usb_serial_generic_disconnect(struct usb_serial *serial) 530 { 531 int i; 532 533 dbg("%s", __func__); 534 535 /* stop reads and writes on all ports */ 536 for (i = 0; i < serial->num_ports; ++i) 537 generic_cleanup(serial->port[i]); 538 } 539 EXPORT_SYMBOL_GPL(usb_serial_generic_disconnect); 540 541 void usb_serial_generic_release(struct usb_serial *serial) 542 { 543 dbg("%s", __func__); 544 } 545