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