1/* 2 * u_serial.c - utilities for USB gadget "serial port"/TTY support 3 * 4 * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com) 5 * Copyright (C) 2008 David Brownell 6 * Copyright (C) 2008 by Nokia Corporation 7 * 8 * This code also borrows from usbserial.c, which is 9 * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com) 10 * Copyright (C) 2000 Peter Berger (pberger@brimson.com) 11 * Copyright (C) 2000 Al Borchers (alborchers@steinerpoint.com) 12 * 13 * This software is distributed under the terms of the GNU General 14 * Public License ("GPL") as published by the Free Software Foundation, 15 * either version 2 of that License or (at your option) any later version. 16 */ 17 18/* #define VERBOSE_DEBUG */ 19 20#include <linux/kernel.h> 21#include <linux/sched.h> 22#include <linux/interrupt.h> 23#include <linux/device.h> 24#include <linux/delay.h> 25#include <linux/tty.h> 26#include <linux/tty_flip.h> 27#include <linux/slab.h> 28 29#include "u_serial.h" 30 31 32/* 33 * This component encapsulates the TTY layer glue needed to provide basic 34 * "serial port" functionality through the USB gadget stack. Each such 35 * port is exposed through a /dev/ttyGS* node. 36 * 37 * After initialization (gserial_setup), these TTY port devices stay 38 * available until they are removed (gserial_cleanup). Each one may be 39 * connected to a USB function (gserial_connect), or disconnected (with 40 * gserial_disconnect) when the USB host issues a config change event. 41 * Data can only flow when the port is connected to the host. 42 * 43 * A given TTY port can be made available in multiple configurations. 44 * For example, each one might expose a ttyGS0 node which provides a 45 * login application. In one case that might use CDC ACM interface 0, 46 * while another configuration might use interface 3 for that. The 47 * work to handle that (including descriptor management) is not part 48 * of this component. 49 * 50 * Configurations may expose more than one TTY port. For example, if 51 * ttyGS0 provides login service, then ttyGS1 might provide dialer access 52 * for a telephone or fax link. And ttyGS2 might be something that just 53 * needs a simple byte stream interface for some messaging protocol that 54 * is managed in userspace ... OBEX, PTP, and MTP have been mentioned. 55 */ 56 57#define PREFIX "ttyGS" 58 59/* 60 * gserial is the lifecycle interface, used by USB functions 61 * gs_port is the I/O nexus, used by the tty driver 62 * tty_struct links to the tty/filesystem framework 63 * 64 * gserial <---> gs_port ... links will be null when the USB link is 65 * inactive; managed by gserial_{connect,disconnect}(). each gserial 66 * instance can wrap its own USB control protocol. 67 * gserial->ioport == usb_ep->driver_data ... gs_port 68 * gs_port->port_usb ... gserial 69 * 70 * gs_port <---> tty_struct ... links will be null when the TTY file 71 * isn't opened; managed by gs_open()/gs_close() 72 * gserial->port_tty ... tty_struct 73 * tty_struct->driver_data ... gserial 74 */ 75 76/* RX and TX queues can buffer QUEUE_SIZE packets before they hit the 77 * next layer of buffering. For TX that's a circular buffer; for RX 78 * consider it a NOP. A third layer is provided by the TTY code. 79 */ 80#define QUEUE_SIZE 16 81#define WRITE_BUF_SIZE 8192 /* TX only */ 82 83/* circular buffer */ 84struct gs_buf { 85 unsigned buf_size; 86 char *buf_buf; 87 char *buf_get; 88 char *buf_put; 89}; 90 91/* 92 * The port structure holds info for each port, one for each minor number 93 * (and thus for each /dev/ node). 94 */ 95struct gs_port { 96 spinlock_t port_lock; /* guard port_* access */ 97 98 struct gserial *port_usb; 99 struct tty_struct *port_tty; 100 101 unsigned open_count; 102 bool openclose; /* open/close in progress */ 103 u8 port_num; 104 105 wait_queue_head_t close_wait; /* wait for last close */ 106 107 struct list_head read_pool; 108 struct list_head read_queue; 109 unsigned n_read; 110 struct tasklet_struct push; 111 112 struct list_head write_pool; 113 struct gs_buf port_write_buf; 114 wait_queue_head_t drain_wait; /* wait while writes drain */ 115 116 /* REVISIT this state ... */ 117 struct usb_cdc_line_coding port_line_coding; /* 8-N-1 etc */ 118}; 119 120/* increase N_PORTS if you need more */ 121#define N_PORTS 4 122static struct portmaster { 123 struct mutex lock; /* protect open/close */ 124 struct gs_port *port; 125} ports[N_PORTS]; 126static unsigned n_ports; 127 128#define GS_CLOSE_TIMEOUT 15 /* seconds */ 129 130 131 132#ifdef VERBOSE_DEBUG 133#define pr_vdebug(fmt, arg...) \ 134 pr_debug(fmt, ##arg) 135#else 136#define pr_vdebug(fmt, arg...) \ 137 ({ if (0) pr_debug(fmt, ##arg); }) 138#endif 139 140/*-------------------------------------------------------------------------*/ 141 142/* Circular Buffer */ 143 144/* 145 * gs_buf_alloc 146 * 147 * Allocate a circular buffer and all associated memory. 148 */ 149static int gs_buf_alloc(struct gs_buf *gb, unsigned size) 150{ 151 gb->buf_buf = kmalloc(size, GFP_KERNEL); 152 if (gb->buf_buf == NULL) 153 return -ENOMEM; 154 155 gb->buf_size = size; 156 gb->buf_put = gb->buf_buf; 157 gb->buf_get = gb->buf_buf; 158 159 return 0; 160} 161 162/* 163 * gs_buf_free 164 * 165 * Free the buffer and all associated memory. 166 */ 167static void gs_buf_free(struct gs_buf *gb) 168{ 169 kfree(gb->buf_buf); 170 gb->buf_buf = NULL; 171} 172 173/* 174 * gs_buf_clear 175 * 176 * Clear out all data in the circular buffer. 177 */ 178static void gs_buf_clear(struct gs_buf *gb) 179{ 180 gb->buf_get = gb->buf_put; 181 /* equivalent to a get of all data available */ 182} 183 184/* 185 * gs_buf_data_avail 186 * 187 * Return the number of bytes of data written into the circular 188 * buffer. 189 */ 190static unsigned gs_buf_data_avail(struct gs_buf *gb) 191{ 192 return (gb->buf_size + gb->buf_put - gb->buf_get) % gb->buf_size; 193} 194 195/* 196 * gs_buf_space_avail 197 * 198 * Return the number of bytes of space available in the circular 199 * buffer. 200 */ 201static unsigned gs_buf_space_avail(struct gs_buf *gb) 202{ 203 return (gb->buf_size + gb->buf_get - gb->buf_put - 1) % gb->buf_size; 204} 205 206/* 207 * gs_buf_put 208 * 209 * Copy data data from a user buffer and put it into the circular buffer. 210 * Restrict to the amount of space available. 211 * 212 * Return the number of bytes copied. 213 */ 214static unsigned 215gs_buf_put(struct gs_buf *gb, const char *buf, unsigned count) 216{ 217 unsigned len; 218 219 len = gs_buf_space_avail(gb); 220 if (count > len) 221 count = len; 222 223 if (count == 0) 224 return 0; 225 226 len = gb->buf_buf + gb->buf_size - gb->buf_put; 227 if (count > len) { 228 memcpy(gb->buf_put, buf, len); 229 memcpy(gb->buf_buf, buf+len, count - len); 230 gb->buf_put = gb->buf_buf + count - len; 231 } else { 232 memcpy(gb->buf_put, buf, count); 233 if (count < len) 234 gb->buf_put += count; 235 else /* count == len */ 236 gb->buf_put = gb->buf_buf; 237 } 238 239 return count; 240} 241 242/* 243 * gs_buf_get 244 * 245 * Get data from the circular buffer and copy to the given buffer. 246 * Restrict to the amount of data available. 247 * 248 * Return the number of bytes copied. 249 */ 250static unsigned 251gs_buf_get(struct gs_buf *gb, char *buf, unsigned count) 252{ 253 unsigned len; 254 255 len = gs_buf_data_avail(gb); 256 if (count > len) 257 count = len; 258 259 if (count == 0) 260 return 0; 261 262 len = gb->buf_buf + gb->buf_size - gb->buf_get; 263 if (count > len) { 264 memcpy(buf, gb->buf_get, len); 265 memcpy(buf+len, gb->buf_buf, count - len); 266 gb->buf_get = gb->buf_buf + count - len; 267 } else { 268 memcpy(buf, gb->buf_get, count); 269 if (count < len) 270 gb->buf_get += count; 271 else /* count == len */ 272 gb->buf_get = gb->buf_buf; 273 } 274 275 return count; 276} 277 278/*-------------------------------------------------------------------------*/ 279 280/* I/O glue between TTY (upper) and USB function (lower) driver layers */ 281 282/* 283 * gs_alloc_req 284 * 285 * Allocate a usb_request and its buffer. Returns a pointer to the 286 * usb_request or NULL if there is an error. 287 */ 288struct usb_request * 289gs_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags) 290{ 291 struct usb_request *req; 292 293 req = usb_ep_alloc_request(ep, kmalloc_flags); 294 295 if (req != NULL) { 296 req->length = len; 297 req->buf = kmalloc(len, kmalloc_flags); 298 if (req->buf == NULL) { 299 usb_ep_free_request(ep, req); 300 return NULL; 301 } 302 } 303 304 return req; 305} 306 307/* 308 * gs_free_req 309 * 310 * Free a usb_request and its buffer. 311 */ 312void gs_free_req(struct usb_ep *ep, struct usb_request *req) 313{ 314 kfree(req->buf); 315 usb_ep_free_request(ep, req); 316} 317 318/* 319 * gs_send_packet 320 * 321 * If there is data to send, a packet is built in the given 322 * buffer and the size is returned. If there is no data to 323 * send, 0 is returned. 324 * 325 * Called with port_lock held. 326 */ 327static unsigned 328gs_send_packet(struct gs_port *port, char *packet, unsigned size) 329{ 330 unsigned len; 331 332 len = gs_buf_data_avail(&port->port_write_buf); 333 if (len < size) 334 size = len; 335 if (size != 0) 336 size = gs_buf_get(&port->port_write_buf, packet, size); 337 return size; 338} 339 340/* 341 * gs_start_tx 342 * 343 * This function finds available write requests, calls 344 * gs_send_packet to fill these packets with data, and 345 * continues until either there are no more write requests 346 * available or no more data to send. This function is 347 * run whenever data arrives or write requests are available. 348 * 349 * Context: caller owns port_lock; port_usb is non-null. 350 */ 351static int gs_start_tx(struct gs_port *port) 352/* 353__releases(&port->port_lock) 354__acquires(&port->port_lock) 355*/ 356{ 357 struct list_head *pool = &port->write_pool; 358 struct usb_ep *in = port->port_usb->in; 359 int status = 0; 360 bool do_tty_wake = false; 361 362 while (!list_empty(pool)) { 363 struct usb_request *req; 364 int len; 365 366 req = list_entry(pool->next, struct usb_request, list); 367 len = gs_send_packet(port, req->buf, in->maxpacket); 368 if (len == 0) { 369 wake_up_interruptible(&port->drain_wait); 370 break; 371 } 372 do_tty_wake = true; 373 374 req->length = len; 375 list_del(&req->list); 376 req->zero = (gs_buf_data_avail(&port->port_write_buf) == 0); 377 378 pr_vdebug(PREFIX "%d: tx len=%d, 0x%02x 0x%02x 0x%02x ...\n", 379 port->port_num, len, *((u8 *)req->buf), 380 *((u8 *)req->buf+1), *((u8 *)req->buf+2)); 381 382 /* Drop lock while we call out of driver; completions 383 * could be issued while we do so. Disconnection may 384 * happen too; maybe immediately before we queue this! 385 * 386 * NOTE that we may keep sending data for a while after 387 * the TTY closed (dev->ioport->port_tty is NULL). 388 */ 389 spin_unlock(&port->port_lock); 390 status = usb_ep_queue(in, req, GFP_ATOMIC); 391 spin_lock(&port->port_lock); 392 393 if (status) { 394 pr_debug("%s: %s %s err %d\n", 395 __func__, "queue", in->name, status); 396 list_add(&req->list, pool); 397 break; 398 } 399 400 /* abort immediately after disconnect */ 401 if (!port->port_usb) 402 break; 403 } 404 405 if (do_tty_wake && port->port_tty) 406 tty_wakeup(port->port_tty); 407 return status; 408} 409 410/* 411 * Context: caller owns port_lock, and port_usb is set 412 */ 413static unsigned gs_start_rx(struct gs_port *port) 414/* 415__releases(&port->port_lock) 416__acquires(&port->port_lock) 417*/ 418{ 419 struct list_head *pool = &port->read_pool; 420 struct usb_ep *out = port->port_usb->out; 421 unsigned started = 0; 422 423 while (!list_empty(pool)) { 424 struct usb_request *req; 425 int status; 426 struct tty_struct *tty; 427 428 /* no more rx if closed */ 429 tty = port->port_tty; 430 if (!tty) 431 break; 432 433 req = list_entry(pool->next, struct usb_request, list); 434 list_del(&req->list); 435 req->length = out->maxpacket; 436 437 /* drop lock while we call out; the controller driver 438 * may need to call us back (e.g. for disconnect) 439 */ 440 spin_unlock(&port->port_lock); 441 status = usb_ep_queue(out, req, GFP_ATOMIC); 442 spin_lock(&port->port_lock); 443 444 if (status) { 445 pr_debug("%s: %s %s err %d\n", 446 __func__, "queue", out->name, status); 447 list_add(&req->list, pool); 448 break; 449 } 450 started++; 451 452 /* abort immediately after disconnect */ 453 if (!port->port_usb) 454 break; 455 } 456 return started; 457} 458 459/* 460 * RX tasklet takes data out of the RX queue and hands it up to the TTY 461 * layer until it refuses to take any more data (or is throttled back). 462 * Then it issues reads for any further data. 463 * 464 * If the RX queue becomes full enough that no usb_request is queued, 465 * the OUT endpoint may begin NAKing as soon as its FIFO fills up. 466 * So QUEUE_SIZE packets plus however many the FIFO holds (usually two) 467 * can be buffered before the TTY layer's buffers (currently 64 KB). 468 */ 469static void gs_rx_push(unsigned long _port) 470{ 471 struct gs_port *port = (void *)_port; 472 struct tty_struct *tty; 473 struct list_head *queue = &port->read_queue; 474 bool disconnect = false; 475 bool do_push = false; 476 477 /* hand any queued data to the tty */ 478 spin_lock_irq(&port->port_lock); 479 tty = port->port_tty; 480 while (!list_empty(queue)) { 481 struct usb_request *req; 482 483 req = list_first_entry(queue, struct usb_request, list); 484 485 /* discard data if tty was closed */ 486 if (!tty) 487 goto recycle; 488 489 /* leave data queued if tty was rx throttled */ 490 if (test_bit(TTY_THROTTLED, &tty->flags)) 491 break; 492 493 switch (req->status) { 494 case -ESHUTDOWN: 495 disconnect = true; 496 pr_vdebug(PREFIX "%d: shutdown\n", port->port_num); 497 break; 498 499 default: 500 /* presumably a transient fault */ 501 pr_warning(PREFIX "%d: unexpected RX status %d\n", 502 port->port_num, req->status); 503 /* FALLTHROUGH */ 504 case 0: 505 /* normal completion */ 506 break; 507 } 508 509 /* push data to (open) tty */ 510 if (req->actual) { 511 char *packet = req->buf; 512 unsigned size = req->actual; 513 unsigned n; 514 int count; 515 516 /* we may have pushed part of this packet already... */ 517 n = port->n_read; 518 if (n) { 519 packet += n; 520 size -= n; 521 } 522 523 count = tty_insert_flip_string(tty, packet, size); 524 if (count) 525 do_push = true; 526 if (count != size) { 527 /* stop pushing; TTY layer can't handle more */ 528 port->n_read += count; 529 pr_vdebug(PREFIX "%d: rx block %d/%d\n", 530 port->port_num, 531 count, req->actual); 532 break; 533 } 534 port->n_read = 0; 535 } 536recycle: 537 list_move(&req->list, &port->read_pool); 538 } 539 540 /* Push from tty to ldisc; without low_latency set this is handled by 541 * a workqueue, so we won't get callbacks and can hold port_lock 542 */ 543 if (tty && do_push) { 544 tty_flip_buffer_push(tty); 545 } 546 547 548 /* We want our data queue to become empty ASAP, keeping data 549 * in the tty and ldisc (not here). If we couldn't push any 550 * this time around, there may be trouble unless there's an 551 * implicit tty_unthrottle() call on its way... 552 * 553 * REVISIT we should probably add a timer to keep the tasklet 554 * from starving ... but it's not clear that case ever happens. 555 */ 556 if (!list_empty(queue) && tty) { 557 if (!test_bit(TTY_THROTTLED, &tty->flags)) { 558 if (do_push) 559 tasklet_schedule(&port->push); 560 else 561 pr_warning(PREFIX "%d: RX not scheduled?\n", 562 port->port_num); 563 } 564 } 565 566 /* If we're still connected, refill the USB RX queue. */ 567 if (!disconnect && port->port_usb) 568 gs_start_rx(port); 569 570 spin_unlock_irq(&port->port_lock); 571} 572 573static void gs_read_complete(struct usb_ep *ep, struct usb_request *req) 574{ 575 struct gs_port *port = ep->driver_data; 576 577 /* Queue all received data until the tty layer is ready for it. */ 578 spin_lock(&port->port_lock); 579 list_add_tail(&req->list, &port->read_queue); 580 tasklet_schedule(&port->push); 581 spin_unlock(&port->port_lock); 582} 583 584static void gs_write_complete(struct usb_ep *ep, struct usb_request *req) 585{ 586 struct gs_port *port = ep->driver_data; 587 588 spin_lock(&port->port_lock); 589 list_add(&req->list, &port->write_pool); 590 591 switch (req->status) { 592 default: 593 /* presumably a transient fault */ 594 pr_warning("%s: unexpected %s status %d\n", 595 __func__, ep->name, req->status); 596 /* FALL THROUGH */ 597 case 0: 598 /* normal completion */ 599 gs_start_tx(port); 600 break; 601 602 case -ESHUTDOWN: 603 /* disconnect */ 604 pr_vdebug("%s: %s shutdown\n", __func__, ep->name); 605 break; 606 } 607 608 spin_unlock(&port->port_lock); 609} 610 611static void gs_free_requests(struct usb_ep *ep, struct list_head *head) 612{ 613 struct usb_request *req; 614 615 while (!list_empty(head)) { 616 req = list_entry(head->next, struct usb_request, list); 617 list_del(&req->list); 618 gs_free_req(ep, req); 619 } 620} 621 622static int gs_alloc_requests(struct usb_ep *ep, struct list_head *head, 623 void (*fn)(struct usb_ep *, struct usb_request *)) 624{ 625 int i; 626 struct usb_request *req; 627 628 /* Pre-allocate up to QUEUE_SIZE transfers, but if we can't 629 * do quite that many this time, don't fail ... we just won't 630 * be as speedy as we might otherwise be. 631 */ 632 for (i = 0; i < QUEUE_SIZE; i++) { 633 req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC); 634 if (!req) 635 return list_empty(head) ? -ENOMEM : 0; 636 req->complete = fn; 637 list_add_tail(&req->list, head); 638 } 639 return 0; 640} 641 642/** 643 * gs_start_io - start USB I/O streams 644 * @dev: encapsulates endpoints to use 645 * Context: holding port_lock; port_tty and port_usb are non-null 646 * 647 * We only start I/O when something is connected to both sides of 648 * this port. If nothing is listening on the host side, we may 649 * be pointlessly filling up our TX buffers and FIFO. 650 */ 651static int gs_start_io(struct gs_port *port) 652{ 653 struct list_head *head = &port->read_pool; 654 struct usb_ep *ep = port->port_usb->out; 655 int status; 656 unsigned started; 657 658 /* Allocate RX and TX I/O buffers. We can't easily do this much 659 * earlier (with GFP_KERNEL) because the requests are coupled to 660 * endpoints, as are the packet sizes we'll be using. Different 661 * configurations may use different endpoints with a given port; 662 * and high speed vs full speed changes packet sizes too. 663 */ 664 status = gs_alloc_requests(ep, head, gs_read_complete); 665 if (status) 666 return status; 667 668 status = gs_alloc_requests(port->port_usb->in, &port->write_pool, 669 gs_write_complete); 670 if (status) { 671 gs_free_requests(ep, head); 672 return status; 673 } 674 675 /* queue read requests */ 676 port->n_read = 0; 677 started = gs_start_rx(port); 678 679 /* unblock any pending writes into our circular buffer */ 680 if (started) { 681 tty_wakeup(port->port_tty); 682 } else { 683 gs_free_requests(ep, head); 684 gs_free_requests(port->port_usb->in, &port->write_pool); 685 status = -EIO; 686 } 687 688 return status; 689} 690 691/*-------------------------------------------------------------------------*/ 692 693/* TTY Driver */ 694 695/* 696 * gs_open sets up the link between a gs_port and its associated TTY. 697 * That link is broken *only* by TTY close(), and all driver methods 698 * know that. 699 */ 700static int gs_open(struct tty_struct *tty, struct file *file) 701{ 702 int port_num = tty->index; 703 struct gs_port *port; 704 int status; 705 706 if (port_num < 0 || port_num >= n_ports) 707 return -ENXIO; 708 709 do { 710 mutex_lock(&ports[port_num].lock); 711 port = ports[port_num].port; 712 if (!port) 713 status = -ENODEV; 714 else { 715 spin_lock_irq(&port->port_lock); 716 717 /* already open? Great. */ 718 if (port->open_count) { 719 status = 0; 720 port->open_count++; 721 722 /* currently opening/closing? wait ... */ 723 } else if (port->openclose) { 724 status = -EBUSY; 725 726 /* ... else we do the work */ 727 } else { 728 status = -EAGAIN; 729 port->openclose = true; 730 } 731 spin_unlock_irq(&port->port_lock); 732 } 733 mutex_unlock(&ports[port_num].lock); 734 735 switch (status) { 736 default: 737 /* fully handled */ 738 return status; 739 case -EAGAIN: 740 /* must do the work */ 741 break; 742 case -EBUSY: 743 /* wait for EAGAIN task to finish */ 744 msleep(1); 745 /* REVISIT could have a waitchannel here, if 746 * concurrent open performance is important 747 */ 748 break; 749 } 750 } while (status != -EAGAIN); 751 752 /* Do the "real open" */ 753 spin_lock_irq(&port->port_lock); 754 755 /* allocate circular buffer on first open */ 756 if (port->port_write_buf.buf_buf == NULL) { 757 758 spin_unlock_irq(&port->port_lock); 759 status = gs_buf_alloc(&port->port_write_buf, WRITE_BUF_SIZE); 760 spin_lock_irq(&port->port_lock); 761 762 if (status) { 763 pr_debug("gs_open: ttyGS%d (%p,%p) no buffer\n", 764 port->port_num, tty, file); 765 port->openclose = false; 766 goto exit_unlock_port; 767 } 768 } 769 770 /* REVISIT if REMOVED (ports[].port NULL), abort the open 771 * to let rmmod work faster (but this way isn't wrong). 772 */ 773 774 /* REVISIT maybe wait for "carrier detect" */ 775 776 tty->driver_data = port; 777 port->port_tty = tty; 778 779 port->open_count = 1; 780 port->openclose = false; 781 782 /* if connected, start the I/O stream */ 783 if (port->port_usb) { 784 struct gserial *gser = port->port_usb; 785 786 pr_debug("gs_open: start ttyGS%d\n", port->port_num); 787 gs_start_io(port); 788 789 if (gser->connect) 790 gser->connect(gser); 791 } 792 793 pr_debug("gs_open: ttyGS%d (%p,%p)\n", port->port_num, tty, file); 794 795 status = 0; 796 797exit_unlock_port: 798 spin_unlock_irq(&port->port_lock); 799 return status; 800} 801 802static int gs_writes_finished(struct gs_port *p) 803{ 804 int cond; 805 806 /* return true on disconnect or empty buffer */ 807 spin_lock_irq(&p->port_lock); 808 cond = (p->port_usb == NULL) || !gs_buf_data_avail(&p->port_write_buf); 809 spin_unlock_irq(&p->port_lock); 810 811 return cond; 812} 813 814static void gs_close(struct tty_struct *tty, struct file *file) 815{ 816 struct gs_port *port = tty->driver_data; 817 struct gserial *gser; 818 819 spin_lock_irq(&port->port_lock); 820 821 if (port->open_count != 1) { 822 if (port->open_count == 0) 823 WARN_ON(1); 824 else 825 --port->open_count; 826 goto exit; 827 } 828 829 pr_debug("gs_close: ttyGS%d (%p,%p) ...\n", port->port_num, tty, file); 830 831 /* mark port as closing but in use; we can drop port lock 832 * and sleep if necessary 833 */ 834 port->openclose = true; 835 port->open_count = 0; 836 837 gser = port->port_usb; 838 if (gser && gser->disconnect) 839 gser->disconnect(gser); 840 841 /* wait for circular write buffer to drain, disconnect, or at 842 * most GS_CLOSE_TIMEOUT seconds; then discard the rest 843 */ 844 if (gs_buf_data_avail(&port->port_write_buf) > 0 && gser) { 845 spin_unlock_irq(&port->port_lock); 846 wait_event_interruptible_timeout(port->drain_wait, 847 gs_writes_finished(port), 848 GS_CLOSE_TIMEOUT * HZ); 849 spin_lock_irq(&port->port_lock); 850 gser = port->port_usb; 851 } 852 853 /* Iff we're disconnected, there can be no I/O in flight so it's 854 * ok to free the circular buffer; else just scrub it. And don't 855 * let the push tasklet fire again until we're re-opened. 856 */ 857 if (gser == NULL) 858 gs_buf_free(&port->port_write_buf); 859 else 860 gs_buf_clear(&port->port_write_buf); 861 862 tty->driver_data = NULL; 863 port->port_tty = NULL; 864 865 port->openclose = false; 866 867 pr_debug("gs_close: ttyGS%d (%p,%p) done!\n", 868 port->port_num, tty, file); 869 870 wake_up_interruptible(&port->close_wait); 871exit: 872 spin_unlock_irq(&port->port_lock); 873} 874 875static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count) 876{ 877 struct gs_port *port = tty->driver_data; 878 unsigned long flags; 879 int status; 880 881 pr_vdebug("gs_write: ttyGS%d (%p) writing %d bytes\n", 882 port->port_num, tty, count); 883 884 spin_lock_irqsave(&port->port_lock, flags); 885 if (count) 886 count = gs_buf_put(&port->port_write_buf, buf, count); 887 /* treat count == 0 as flush_chars() */ 888 if (port->port_usb) 889 status = gs_start_tx(port); 890 spin_unlock_irqrestore(&port->port_lock, flags); 891 892 return count; 893} 894 895static int gs_put_char(struct tty_struct *tty, unsigned char ch) 896{ 897 struct gs_port *port = tty->driver_data; 898 unsigned long flags; 899 int status; 900 901 pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %p\n", 902 port->port_num, tty, ch, __builtin_return_address(0)); 903 904 spin_lock_irqsave(&port->port_lock, flags); 905 status = gs_buf_put(&port->port_write_buf, &ch, 1); 906 spin_unlock_irqrestore(&port->port_lock, flags); 907 908 return status; 909} 910 911static void gs_flush_chars(struct tty_struct *tty) 912{ 913 struct gs_port *port = tty->driver_data; 914 unsigned long flags; 915 916 pr_vdebug("gs_flush_chars: (%d,%p)\n", port->port_num, tty); 917 918 spin_lock_irqsave(&port->port_lock, flags); 919 if (port->port_usb) 920 gs_start_tx(port); 921 spin_unlock_irqrestore(&port->port_lock, flags); 922} 923 924static int gs_write_room(struct tty_struct *tty) 925{ 926 struct gs_port *port = tty->driver_data; 927 unsigned long flags; 928 int room = 0; 929 930 spin_lock_irqsave(&port->port_lock, flags); 931 if (port->port_usb) 932 room = gs_buf_space_avail(&port->port_write_buf); 933 spin_unlock_irqrestore(&port->port_lock, flags); 934 935 pr_vdebug("gs_write_room: (%d,%p) room=%d\n", 936 port->port_num, tty, room); 937 938 return room; 939} 940 941static int gs_chars_in_buffer(struct tty_struct *tty) 942{ 943 struct gs_port *port = tty->driver_data; 944 unsigned long flags; 945 int chars = 0; 946 947 spin_lock_irqsave(&port->port_lock, flags); 948 chars = gs_buf_data_avail(&port->port_write_buf); 949 spin_unlock_irqrestore(&port->port_lock, flags); 950 951 pr_vdebug("gs_chars_in_buffer: (%d,%p) chars=%d\n", 952 port->port_num, tty, chars); 953 954 return chars; 955} 956 957/* undo side effects of setting TTY_THROTTLED */ 958static void gs_unthrottle(struct tty_struct *tty) 959{ 960 struct gs_port *port = tty->driver_data; 961 unsigned long flags; 962 963 spin_lock_irqsave(&port->port_lock, flags); 964 if (port->port_usb) { 965 /* Kickstart read queue processing. We don't do xon/xoff, 966 * rts/cts, or other handshaking with the host, but if the 967 * read queue backs up enough we'll be NAKing OUT packets. 968 */ 969 tasklet_schedule(&port->push); 970 pr_vdebug(PREFIX "%d: unthrottle\n", port->port_num); 971 } 972 spin_unlock_irqrestore(&port->port_lock, flags); 973} 974 975static int gs_break_ctl(struct tty_struct *tty, int duration) 976{ 977 struct gs_port *port = tty->driver_data; 978 int status = 0; 979 struct gserial *gser; 980 981 pr_vdebug("gs_break_ctl: ttyGS%d, send break (%d) \n", 982 port->port_num, duration); 983 984 spin_lock_irq(&port->port_lock); 985 gser = port->port_usb; 986 if (gser && gser->send_break) 987 status = gser->send_break(gser, duration); 988 spin_unlock_irq(&port->port_lock); 989 990 return status; 991} 992 993static const struct tty_operations gs_tty_ops = { 994 .open = gs_open, 995 .close = gs_close, 996 .write = gs_write, 997 .put_char = gs_put_char, 998 .flush_chars = gs_flush_chars, 999 .write_room = gs_write_room, 1000 .chars_in_buffer = gs_chars_in_buffer, 1001 .unthrottle = gs_unthrottle, 1002 .break_ctl = gs_break_ctl, 1003}; 1004 1005/*-------------------------------------------------------------------------*/ 1006 1007static struct tty_driver *gs_tty_driver; 1008 1009static int __init 1010gs_port_alloc(unsigned port_num, struct usb_cdc_line_coding *coding) 1011{ 1012 struct gs_port *port; 1013 1014 port = kzalloc(sizeof(struct gs_port), GFP_KERNEL); 1015 if (port == NULL) 1016 return -ENOMEM; 1017 1018 spin_lock_init(&port->port_lock); 1019 init_waitqueue_head(&port->close_wait); 1020 init_waitqueue_head(&port->drain_wait); 1021 1022 tasklet_init(&port->push, gs_rx_push, (unsigned long) port); 1023 1024 INIT_LIST_HEAD(&port->read_pool); 1025 INIT_LIST_HEAD(&port->read_queue); 1026 INIT_LIST_HEAD(&port->write_pool); 1027 1028 port->port_num = port_num; 1029 port->port_line_coding = *coding; 1030 1031 ports[port_num].port = port; 1032 1033 return 0; 1034} 1035 1036/** 1037 * gserial_setup - initialize TTY driver for one or more ports 1038 * @g: gadget to associate with these ports 1039 * @count: how many ports to support 1040 * Context: may sleep 1041 * 1042 * The TTY stack needs to know in advance how many devices it should 1043 * plan to manage. Use this call to set up the ports you will be 1044 * exporting through USB. Later, connect them to functions based 1045 * on what configuration is activated by the USB host; and disconnect 1046 * them as appropriate. 1047 * 1048 * An example would be a two-configuration device in which both 1049 * configurations expose port 0, but through different functions. 1050 * One configuration could even expose port 1 while the other 1051 * one doesn't. 1052 * 1053 * Returns negative errno or zero. 1054 */ 1055int __init gserial_setup(struct usb_gadget *g, unsigned count) 1056{ 1057 unsigned i; 1058 struct usb_cdc_line_coding coding; 1059 int status; 1060 1061 if (count == 0 || count > N_PORTS) 1062 return -EINVAL; 1063 1064 gs_tty_driver = alloc_tty_driver(count); 1065 if (!gs_tty_driver) 1066 return -ENOMEM; 1067 1068 gs_tty_driver->owner = THIS_MODULE; 1069 gs_tty_driver->driver_name = "g_serial"; 1070 gs_tty_driver->name = PREFIX; 1071 /* uses dynamically assigned dev_t values */ 1072 1073 gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; 1074 gs_tty_driver->subtype = SERIAL_TYPE_NORMAL; 1075 gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 1076 gs_tty_driver->init_termios = tty_std_termios; 1077 1078 /* 9600-8-N-1 ... matches defaults expected by "usbser.sys" on 1079 * MS-Windows. Otherwise, most of these flags shouldn't affect 1080 * anything unless we were to actually hook up to a serial line. 1081 */ 1082 gs_tty_driver->init_termios.c_cflag = 1083 B9600 | CS8 | CREAD | HUPCL | CLOCAL; 1084 gs_tty_driver->init_termios.c_ispeed = 9600; 1085 gs_tty_driver->init_termios.c_ospeed = 9600; 1086 1087 coding.dwDTERate = cpu_to_le32(9600); 1088 coding.bCharFormat = 8; 1089 coding.bParityType = USB_CDC_NO_PARITY; 1090 coding.bDataBits = USB_CDC_1_STOP_BITS; 1091 1092 tty_set_operations(gs_tty_driver, &gs_tty_ops); 1093 1094 /* make devices be openable */ 1095 for (i = 0; i < count; i++) { 1096 mutex_init(&ports[i].lock); 1097 status = gs_port_alloc(i, &coding); 1098 if (status) { 1099 count = i; 1100 goto fail; 1101 } 1102 } 1103 n_ports = count; 1104 1105 /* export the driver ... */ 1106 status = tty_register_driver(gs_tty_driver); 1107 if (status) { 1108 pr_err("%s: cannot register, err %d\n", 1109 __func__, status); 1110 goto fail; 1111 } 1112 1113 /* ... and sysfs class devices, so mdev/udev make /dev/ttyGS* */ 1114 for (i = 0; i < count; i++) { 1115 struct device *tty_dev; 1116 1117 tty_dev = tty_register_device(gs_tty_driver, i, &g->dev); 1118 if (IS_ERR(tty_dev)) 1119 pr_warning("%s: no classdev for port %d, err %ld\n", 1120 __func__, i, PTR_ERR(tty_dev)); 1121 } 1122 1123 pr_debug("%s: registered %d ttyGS* device%s\n", __func__, 1124 count, (count == 1) ? "" : "s"); 1125 1126 return status; 1127fail: 1128 while (count--) 1129 kfree(ports[count].port); 1130 put_tty_driver(gs_tty_driver); 1131 gs_tty_driver = NULL; 1132 return status; 1133} 1134 1135static int gs_closed(struct gs_port *port) 1136{ 1137 int cond; 1138 1139 spin_lock_irq(&port->port_lock); 1140 cond = (port->open_count == 0) && !port->openclose; 1141 spin_unlock_irq(&port->port_lock); 1142 return cond; 1143} 1144 1145/** 1146 * gserial_cleanup - remove TTY-over-USB driver and devices 1147 * Context: may sleep 1148 * 1149 * This is called to free all resources allocated by @gserial_setup(). 1150 * Accordingly, it may need to wait until some open /dev/ files have 1151 * closed. 1152 * 1153 * The caller must have issued @gserial_disconnect() for any ports 1154 * that had previously been connected, so that there is never any 1155 * I/O pending when it's called. 1156 */ 1157void gserial_cleanup(void) 1158{ 1159 unsigned i; 1160 struct gs_port *port; 1161 1162 if (!gs_tty_driver) 1163 return; 1164 1165 /* start sysfs and /dev/ttyGS* node removal */ 1166 for (i = 0; i < n_ports; i++) 1167 tty_unregister_device(gs_tty_driver, i); 1168 1169 for (i = 0; i < n_ports; i++) { 1170 /* prevent new opens */ 1171 mutex_lock(&ports[i].lock); 1172 port = ports[i].port; 1173 ports[i].port = NULL; 1174 mutex_unlock(&ports[i].lock); 1175 1176 tasklet_kill(&port->push); 1177 1178 /* wait for old opens to finish */ 1179 wait_event(port->close_wait, gs_closed(port)); 1180 1181 WARN_ON(port->port_usb != NULL); 1182 1183 kfree(port); 1184 } 1185 n_ports = 0; 1186 1187 tty_unregister_driver(gs_tty_driver); 1188 put_tty_driver(gs_tty_driver); 1189 gs_tty_driver = NULL; 1190 1191 pr_debug("%s: cleaned up ttyGS* support\n", __func__); 1192} 1193 1194/** 1195 * gserial_connect - notify TTY I/O glue that USB link is active 1196 * @gser: the function, set up with endpoints and descriptors 1197 * @port_num: which port is active 1198 * Context: any (usually from irq) 1199 * 1200 * This is called activate endpoints and let the TTY layer know that 1201 * the connection is active ... not unlike "carrier detect". It won't 1202 * necessarily start I/O queues; unless the TTY is held open by any 1203 * task, there would be no point. However, the endpoints will be 1204 * activated so the USB host can perform I/O, subject to basic USB 1205 * hardware flow control. 1206 * 1207 * Caller needs to have set up the endpoints and USB function in @dev 1208 * before calling this, as well as the appropriate (speed-specific) 1209 * endpoint descriptors, and also have set up the TTY driver by calling 1210 * @gserial_setup(). 1211 * 1212 * Returns negative errno or zero. 1213 * On success, ep->driver_data will be overwritten. 1214 */ 1215int gserial_connect(struct gserial *gser, u8 port_num) 1216{ 1217 struct gs_port *port; 1218 unsigned long flags; 1219 int status; 1220 1221 if (!gs_tty_driver || port_num >= n_ports) 1222 return -ENXIO; 1223 1224 /* we "know" gserial_cleanup() hasn't been called */ 1225 port = ports[port_num].port; 1226 1227 /* activate the endpoints */ 1228 status = usb_ep_enable(gser->in, gser->in_desc); 1229 if (status < 0) 1230 return status; 1231 gser->in->driver_data = port; 1232 1233 status = usb_ep_enable(gser->out, gser->out_desc); 1234 if (status < 0) 1235 goto fail_out; 1236 gser->out->driver_data = port; 1237 1238 /* then tell the tty glue that I/O can work */ 1239 spin_lock_irqsave(&port->port_lock, flags); 1240 gser->ioport = port; 1241 port->port_usb = gser; 1242 1243 /* REVISIT unclear how best to handle this state... 1244 * we don't really couple it with the Linux TTY. 1245 */ 1246 gser->port_line_coding = port->port_line_coding; 1247 1248 /* REVISIT if waiting on "carrier detect", signal. */ 1249 1250 /* if it's already open, start I/O ... and notify the serial 1251 * protocol about open/close status (connect/disconnect). 1252 */ 1253 if (port->open_count) { 1254 pr_debug("gserial_connect: start ttyGS%d\n", port->port_num); 1255 gs_start_io(port); 1256 if (gser->connect) 1257 gser->connect(gser); 1258 } else { 1259 if (gser->disconnect) 1260 gser->disconnect(gser); 1261 } 1262 1263 spin_unlock_irqrestore(&port->port_lock, flags); 1264 1265 return status; 1266 1267fail_out: 1268 usb_ep_disable(gser->in); 1269 gser->in->driver_data = NULL; 1270 return status; 1271} 1272 1273/** 1274 * gserial_disconnect - notify TTY I/O glue that USB link is inactive 1275 * @gser: the function, on which gserial_connect() was called 1276 * Context: any (usually from irq) 1277 * 1278 * This is called to deactivate endpoints and let the TTY layer know 1279 * that the connection went inactive ... not unlike "hangup". 1280 * 1281 * On return, the state is as if gserial_connect() had never been called; 1282 * there is no active USB I/O on these endpoints. 1283 */ 1284void gserial_disconnect(struct gserial *gser) 1285{ 1286 struct gs_port *port = gser->ioport; 1287 unsigned long flags; 1288 1289 if (!port) 1290 return; 1291 1292 /* tell the TTY glue not to do I/O here any more */ 1293 spin_lock_irqsave(&port->port_lock, flags); 1294 1295 /* REVISIT as above: how best to track this? */ 1296 port->port_line_coding = gser->port_line_coding; 1297 1298 port->port_usb = NULL; 1299 gser->ioport = NULL; 1300 if (port->open_count > 0 || port->openclose) { 1301 wake_up_interruptible(&port->drain_wait); 1302 if (port->port_tty) 1303 tty_hangup(port->port_tty); 1304 } 1305 spin_unlock_irqrestore(&port->port_lock, flags); 1306 1307 /* disable endpoints, aborting down any active I/O */ 1308 usb_ep_disable(gser->out); 1309 gser->out->driver_data = NULL; 1310 1311 usb_ep_disable(gser->in); 1312 gser->in->driver_data = NULL; 1313 1314 /* finally, free any unused/unusable I/O buffers */ 1315 spin_lock_irqsave(&port->port_lock, flags); 1316 if (port->open_count == 0 && !port->openclose) 1317 gs_buf_free(&port->port_write_buf); 1318 gs_free_requests(gser->out, &port->read_pool); 1319 gs_free_requests(gser->out, &port->read_queue); 1320 gs_free_requests(gser->in, &port->write_pool); 1321 spin_unlock_irqrestore(&port->port_lock, flags); 1322} 1323