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