1 // SPDX-License-Identifier: GPL-2.0 2 /* vcc.c: sun4v virtual channel concentrator 3 * 4 * Copyright (C) 2017 Oracle. All rights reserved. 5 */ 6 7 #include <linux/delay.h> 8 #include <linux/interrupt.h> 9 #include <linux/module.h> 10 #include <linux/slab.h> 11 #include <linux/sysfs.h> 12 #include <linux/tty.h> 13 #include <linux/tty_flip.h> 14 #include <asm/vio.h> 15 #include <asm/ldc.h> 16 17 #define DRV_MODULE_NAME "vcc" 18 #define DRV_MODULE_VERSION "1.1" 19 #define DRV_MODULE_RELDATE "July 1, 2017" 20 21 static char version[] = 22 DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")"; 23 24 MODULE_DESCRIPTION("Sun LDOM virtual console concentrator driver"); 25 MODULE_LICENSE("GPL"); 26 MODULE_VERSION(DRV_MODULE_VERSION); 27 28 struct vcc_port { 29 struct vio_driver_state vio; 30 31 spinlock_t lock; 32 char *domain; 33 struct tty_struct *tty; /* only populated while dev is open */ 34 unsigned long index; /* index into the vcc_table */ 35 36 u64 refcnt; 37 bool excl_locked; 38 39 bool removed; 40 41 /* This buffer is required to support the tty write_room interface 42 * and guarantee that any characters that the driver accepts will 43 * be eventually sent, either immediately or later. 44 */ 45 int chars_in_buffer; 46 struct vio_vcc buffer; 47 48 struct timer_list rx_timer; 49 struct timer_list tx_timer; 50 }; 51 52 /* Microseconds that thread will delay waiting for a vcc port ref */ 53 #define VCC_REF_DELAY 100 54 55 #define VCC_MAX_PORTS 1024 56 #define VCC_MINOR_START 0 /* must be zero */ 57 #define VCC_BUFF_LEN VIO_VCC_MTU_SIZE 58 59 #define VCC_CTL_BREAK -1 60 #define VCC_CTL_HUP -2 61 62 static const char vcc_driver_name[] = "vcc"; 63 static const char vcc_device_node[] = "vcc"; 64 static struct tty_driver *vcc_tty_driver; 65 66 static struct vcc_port *vcc_table[VCC_MAX_PORTS]; 67 static DEFINE_SPINLOCK(vcc_table_lock); 68 69 int vcc_dbg; 70 int vcc_dbg_ldc; 71 int vcc_dbg_vio; 72 73 module_param(vcc_dbg, uint, 0664); 74 module_param(vcc_dbg_ldc, uint, 0664); 75 module_param(vcc_dbg_vio, uint, 0664); 76 77 #define VCC_DBG_DRV 0x1 78 #define VCC_DBG_LDC 0x2 79 #define VCC_DBG_PKT 0x4 80 81 #define vccdbg(f, a...) \ 82 do { \ 83 if (vcc_dbg & VCC_DBG_DRV) \ 84 pr_info(f, ## a); \ 85 } while (0) \ 86 87 #define vccdbgl(l) \ 88 do { \ 89 if (vcc_dbg & VCC_DBG_LDC) \ 90 ldc_print(l); \ 91 } while (0) \ 92 93 #define vccdbgp(pkt) \ 94 do { \ 95 if (vcc_dbg & VCC_DBG_PKT) { \ 96 int i; \ 97 for (i = 0; i < pkt.tag.stype; i++) \ 98 pr_info("[%c]", pkt.data[i]); \ 99 } \ 100 } while (0) \ 101 102 /* Note: Be careful when adding flags to this line discipline. Don't 103 * add anything that will cause echoing or we'll go into recursive 104 * loop echoing chars back and forth with the console drivers. 105 */ 106 static const struct ktermios vcc_tty_termios = { 107 .c_iflag = IGNBRK | IGNPAR, 108 .c_oflag = OPOST, 109 .c_cflag = B38400 | CS8 | CREAD | HUPCL, 110 .c_cc = INIT_C_CC, 111 .c_ispeed = 38400, 112 .c_ospeed = 38400 113 }; 114 115 /** 116 * vcc_table_add() - Add VCC port to the VCC table 117 * @port: pointer to the VCC port 118 * 119 * Return: index of the port in the VCC table on success, 120 * -1 on failure 121 */ 122 static int vcc_table_add(struct vcc_port *port) 123 { 124 unsigned long flags; 125 int i; 126 127 spin_lock_irqsave(&vcc_table_lock, flags); 128 for (i = VCC_MINOR_START; i < VCC_MAX_PORTS; i++) { 129 if (!vcc_table[i]) { 130 vcc_table[i] = port; 131 break; 132 } 133 } 134 spin_unlock_irqrestore(&vcc_table_lock, flags); 135 136 if (i < VCC_MAX_PORTS) 137 return i; 138 else 139 return -1; 140 } 141 142 /** 143 * vcc_table_remove() - Removes a VCC port from the VCC table 144 * @index: Index into the VCC table 145 */ 146 static void vcc_table_remove(unsigned long index) 147 { 148 unsigned long flags; 149 150 if (WARN_ON(index >= VCC_MAX_PORTS)) 151 return; 152 153 spin_lock_irqsave(&vcc_table_lock, flags); 154 vcc_table[index] = NULL; 155 spin_unlock_irqrestore(&vcc_table_lock, flags); 156 } 157 158 /** 159 * vcc_get() - Gets a reference to VCC port 160 * @index: Index into the VCC table 161 * @excl: Indicates if an exclusive access is requested 162 * 163 * Return: reference to the VCC port, if found 164 * NULL, if port not found 165 */ 166 static struct vcc_port *vcc_get(unsigned long index, bool excl) 167 { 168 struct vcc_port *port; 169 unsigned long flags; 170 171 try_again: 172 spin_lock_irqsave(&vcc_table_lock, flags); 173 174 port = vcc_table[index]; 175 if (!port) { 176 spin_unlock_irqrestore(&vcc_table_lock, flags); 177 return NULL; 178 } 179 180 if (!excl) { 181 if (port->excl_locked) { 182 spin_unlock_irqrestore(&vcc_table_lock, flags); 183 udelay(VCC_REF_DELAY); 184 goto try_again; 185 } 186 port->refcnt++; 187 spin_unlock_irqrestore(&vcc_table_lock, flags); 188 return port; 189 } 190 191 if (port->refcnt) { 192 spin_unlock_irqrestore(&vcc_table_lock, flags); 193 /* Threads wanting exclusive access will wait half the time, 194 * probably giving them higher priority in the case of 195 * multiple waiters. 196 */ 197 udelay(VCC_REF_DELAY/2); 198 goto try_again; 199 } 200 201 port->refcnt++; 202 port->excl_locked = true; 203 spin_unlock_irqrestore(&vcc_table_lock, flags); 204 205 return port; 206 } 207 208 /** 209 * vcc_put() - Returns a reference to VCC port 210 * @port: pointer to VCC port 211 * @excl: Indicates if the returned reference is an exclusive reference 212 * 213 * Note: It's the caller's responsibility to ensure the correct value 214 * for the excl flag 215 */ 216 static void vcc_put(struct vcc_port *port, bool excl) 217 { 218 unsigned long flags; 219 220 if (!port) 221 return; 222 223 spin_lock_irqsave(&vcc_table_lock, flags); 224 225 /* check if caller attempted to put with the wrong flags */ 226 if (WARN_ON((excl && !port->excl_locked) || 227 (!excl && port->excl_locked))) 228 goto done; 229 230 port->refcnt--; 231 232 if (excl) 233 port->excl_locked = false; 234 235 done: 236 spin_unlock_irqrestore(&vcc_table_lock, flags); 237 } 238 239 /** 240 * vcc_get_ne() - Get a non-exclusive reference to VCC port 241 * @index: Index into the VCC table 242 * 243 * Gets a non-exclusive reference to VCC port, if it's not removed 244 * 245 * Return: pointer to the VCC port, if found 246 * NULL, if port not found 247 */ 248 static struct vcc_port *vcc_get_ne(unsigned long index) 249 { 250 struct vcc_port *port; 251 252 port = vcc_get(index, false); 253 254 if (port && port->removed) { 255 vcc_put(port, false); 256 return NULL; 257 } 258 259 return port; 260 } 261 262 static void vcc_kick_rx(struct vcc_port *port) 263 { 264 struct vio_driver_state *vio = &port->vio; 265 266 assert_spin_locked(&port->lock); 267 268 if (!timer_pending(&port->rx_timer) && !port->removed) { 269 disable_irq_nosync(vio->vdev->rx_irq); 270 port->rx_timer.expires = (jiffies + 1); 271 add_timer(&port->rx_timer); 272 } 273 } 274 275 static void vcc_kick_tx(struct vcc_port *port) 276 { 277 assert_spin_locked(&port->lock); 278 279 if (!timer_pending(&port->tx_timer) && !port->removed) { 280 port->tx_timer.expires = (jiffies + 1); 281 add_timer(&port->tx_timer); 282 } 283 } 284 285 static int vcc_rx_check(struct tty_struct *tty, int size) 286 { 287 if (WARN_ON(!tty || !tty->port)) 288 return 1; 289 290 /* tty_buffer_request_room won't sleep because it uses 291 * GFP_ATOMIC flag to allocate buffer 292 */ 293 if (test_bit(TTY_THROTTLED, &tty->flags) || 294 (tty_buffer_request_room(tty->port, VCC_BUFF_LEN) < VCC_BUFF_LEN)) 295 return 0; 296 297 return 1; 298 } 299 300 static int vcc_rx(struct tty_struct *tty, char *buf, int size) 301 { 302 int len = 0; 303 304 if (WARN_ON(!tty || !tty->port)) 305 return len; 306 307 len = tty_insert_flip_string(tty->port, buf, size); 308 if (len) 309 tty_flip_buffer_push(tty->port); 310 311 return len; 312 } 313 314 static int vcc_ldc_read(struct vcc_port *port) 315 { 316 struct vio_driver_state *vio = &port->vio; 317 struct tty_struct *tty; 318 struct vio_vcc pkt; 319 int rv = 0; 320 321 tty = port->tty; 322 if (!tty) { 323 rv = ldc_rx_reset(vio->lp); 324 vccdbg("VCC: reset rx q: rv=%d\n", rv); 325 goto done; 326 } 327 328 /* Read as long as LDC has incoming data. */ 329 while (1) { 330 if (!vcc_rx_check(tty, VIO_VCC_MTU_SIZE)) { 331 vcc_kick_rx(port); 332 break; 333 } 334 335 vccdbgl(vio->lp); 336 337 rv = ldc_read(vio->lp, &pkt, sizeof(pkt)); 338 if (rv <= 0) 339 break; 340 341 vccdbg("VCC: ldc_read()=%d\n", rv); 342 vccdbg("TAG [%02x:%02x:%04x:%08x]\n", 343 pkt.tag.type, pkt.tag.stype, 344 pkt.tag.stype_env, pkt.tag.sid); 345 346 if (pkt.tag.type == VIO_TYPE_DATA) { 347 vccdbgp(pkt); 348 /* vcc_rx_check ensures memory availability */ 349 vcc_rx(tty, pkt.data, pkt.tag.stype); 350 } else { 351 pr_err("VCC: unknown msg [%02x:%02x:%04x:%08x]\n", 352 pkt.tag.type, pkt.tag.stype, 353 pkt.tag.stype_env, pkt.tag.sid); 354 rv = -ECONNRESET; 355 break; 356 } 357 358 WARN_ON(rv != LDC_PACKET_SIZE); 359 } 360 361 done: 362 return rv; 363 } 364 365 static void vcc_rx_timer(struct timer_list *t) 366 { 367 struct vcc_port *port = from_timer(port, t, rx_timer); 368 struct vio_driver_state *vio; 369 unsigned long flags; 370 int rv; 371 372 spin_lock_irqsave(&port->lock, flags); 373 port->rx_timer.expires = 0; 374 375 vio = &port->vio; 376 377 enable_irq(vio->vdev->rx_irq); 378 379 if (!port->tty || port->removed) 380 goto done; 381 382 rv = vcc_ldc_read(port); 383 if (rv == -ECONNRESET) 384 vio_conn_reset(vio); 385 386 done: 387 spin_unlock_irqrestore(&port->lock, flags); 388 vcc_put(port, false); 389 } 390 391 static void vcc_tx_timer(struct timer_list *t) 392 { 393 struct vcc_port *port = from_timer(port, t, tx_timer); 394 struct vio_vcc *pkt; 395 unsigned long flags; 396 int tosend = 0; 397 int rv; 398 399 spin_lock_irqsave(&port->lock, flags); 400 port->tx_timer.expires = 0; 401 402 if (!port->tty || port->removed) 403 goto done; 404 405 tosend = min(VCC_BUFF_LEN, port->chars_in_buffer); 406 if (!tosend) 407 goto done; 408 409 pkt = &port->buffer; 410 pkt->tag.type = VIO_TYPE_DATA; 411 pkt->tag.stype = tosend; 412 vccdbgl(port->vio.lp); 413 414 rv = ldc_write(port->vio.lp, pkt, (VIO_TAG_SIZE + tosend)); 415 WARN_ON(!rv); 416 417 if (rv < 0) { 418 vccdbg("VCC: ldc_write()=%d\n", rv); 419 vcc_kick_tx(port); 420 } else { 421 struct tty_struct *tty = port->tty; 422 423 port->chars_in_buffer = 0; 424 if (tty) 425 tty_wakeup(tty); 426 } 427 428 done: 429 spin_unlock_irqrestore(&port->lock, flags); 430 vcc_put(port, false); 431 } 432 433 /** 434 * vcc_event() - LDC event processing engine 435 * @arg: VCC private data 436 * @event: LDC event 437 * 438 * Handles LDC events for VCC 439 */ 440 static void vcc_event(void *arg, int event) 441 { 442 struct vio_driver_state *vio; 443 struct vcc_port *port; 444 unsigned long flags; 445 int rv; 446 447 port = arg; 448 vio = &port->vio; 449 450 spin_lock_irqsave(&port->lock, flags); 451 452 switch (event) { 453 case LDC_EVENT_RESET: 454 case LDC_EVENT_UP: 455 vio_link_state_change(vio, event); 456 break; 457 458 case LDC_EVENT_DATA_READY: 459 rv = vcc_ldc_read(port); 460 if (rv == -ECONNRESET) 461 vio_conn_reset(vio); 462 break; 463 464 default: 465 pr_err("VCC: unexpected LDC event(%d)\n", event); 466 } 467 468 spin_unlock_irqrestore(&port->lock, flags); 469 } 470 471 static struct ldc_channel_config vcc_ldc_cfg = { 472 .event = vcc_event, 473 .mtu = VIO_VCC_MTU_SIZE, 474 .mode = LDC_MODE_RAW, 475 .debug = 0, 476 }; 477 478 /* Ordered from largest major to lowest */ 479 static struct vio_version vcc_versions[] = { 480 { .major = 1, .minor = 0 }, 481 }; 482 483 static struct tty_port_operations vcc_port_ops = { 0 }; 484 485 static ssize_t vcc_sysfs_domain_show(struct device *dev, 486 struct device_attribute *attr, 487 char *buf) 488 { 489 struct vcc_port *port; 490 int rv; 491 492 port = dev_get_drvdata(dev); 493 if (!port) 494 return -ENODEV; 495 496 rv = scnprintf(buf, PAGE_SIZE, "%s\n", port->domain); 497 498 return rv; 499 } 500 501 static int vcc_send_ctl(struct vcc_port *port, int ctl) 502 { 503 struct vio_vcc pkt; 504 int rv; 505 506 pkt.tag.type = VIO_TYPE_CTRL; 507 pkt.tag.sid = ctl; 508 pkt.tag.stype = 0; 509 510 rv = ldc_write(port->vio.lp, &pkt, sizeof(pkt.tag)); 511 WARN_ON(!rv); 512 vccdbg("VCC: ldc_write(%ld)=%d\n", sizeof(pkt.tag), rv); 513 514 return rv; 515 } 516 517 static ssize_t vcc_sysfs_break_store(struct device *dev, 518 struct device_attribute *attr, 519 const char *buf, size_t count) 520 { 521 struct vcc_port *port; 522 unsigned long flags; 523 int rv = count; 524 int brk; 525 526 port = dev_get_drvdata(dev); 527 if (!port) 528 return -ENODEV; 529 530 spin_lock_irqsave(&port->lock, flags); 531 532 if (sscanf(buf, "%ud", &brk) != 1 || brk != 1) 533 rv = -EINVAL; 534 else if (vcc_send_ctl(port, VCC_CTL_BREAK) < 0) 535 vcc_kick_tx(port); 536 537 spin_unlock_irqrestore(&port->lock, flags); 538 539 return rv; 540 } 541 542 static DEVICE_ATTR(domain, 0400, vcc_sysfs_domain_show, NULL); 543 static DEVICE_ATTR(break, 0200, NULL, vcc_sysfs_break_store); 544 545 static struct attribute *vcc_sysfs_entries[] = { 546 &dev_attr_domain.attr, 547 &dev_attr_break.attr, 548 NULL 549 }; 550 551 static struct attribute_group vcc_attribute_group = { 552 .name = NULL, 553 .attrs = vcc_sysfs_entries, 554 }; 555 556 /** 557 * vcc_probe() - Initialize VCC port 558 * @vdev: Pointer to VIO device of the new VCC port 559 * @id: VIO device ID 560 * 561 * Initializes a VCC port to receive serial console data from 562 * the guest domain. Sets up a TTY end point on the control 563 * domain. Sets up VIO/LDC link between the guest & control 564 * domain endpoints. 565 * 566 * Return: status of the probe 567 */ 568 static int vcc_probe(struct vio_dev *vdev, const struct vio_device_id *id) 569 { 570 struct mdesc_handle *hp; 571 struct vcc_port *port; 572 struct device *dev; 573 const char *domain; 574 char *name; 575 u64 node; 576 int rv; 577 578 vccdbg("VCC: name=%s\n", dev_name(&vdev->dev)); 579 580 if (!vcc_tty_driver) { 581 pr_err("VCC: TTY driver not registered\n"); 582 return -ENODEV; 583 } 584 585 port = kzalloc(sizeof(struct vcc_port), GFP_KERNEL); 586 if (!port) 587 return -ENOMEM; 588 589 name = kstrdup(dev_name(&vdev->dev), GFP_KERNEL); 590 591 rv = vio_driver_init(&port->vio, vdev, VDEV_CONSOLE_CON, vcc_versions, 592 ARRAY_SIZE(vcc_versions), NULL, name); 593 if (rv) 594 goto free_port; 595 596 port->vio.debug = vcc_dbg_vio; 597 vcc_ldc_cfg.debug = vcc_dbg_ldc; 598 599 rv = vio_ldc_alloc(&port->vio, &vcc_ldc_cfg, port); 600 if (rv) 601 goto free_port; 602 603 spin_lock_init(&port->lock); 604 605 port->index = vcc_table_add(port); 606 if (port->index == -1) { 607 pr_err("VCC: no more TTY indices left for allocation\n"); 608 goto free_ldc; 609 } 610 611 /* Register the device using VCC table index as TTY index */ 612 dev = tty_register_device(vcc_tty_driver, port->index, &vdev->dev); 613 if (IS_ERR(dev)) { 614 rv = PTR_ERR(dev); 615 goto free_table; 616 } 617 618 hp = mdesc_grab(); 619 620 node = vio_vdev_node(hp, vdev); 621 if (node == MDESC_NODE_NULL) { 622 rv = -ENXIO; 623 mdesc_release(hp); 624 goto unreg_tty; 625 } 626 627 domain = mdesc_get_property(hp, node, "vcc-domain-name", NULL); 628 if (!domain) { 629 rv = -ENXIO; 630 mdesc_release(hp); 631 goto unreg_tty; 632 } 633 port->domain = kstrdup(domain, GFP_KERNEL); 634 635 mdesc_release(hp); 636 637 rv = sysfs_create_group(&vdev->dev.kobj, &vcc_attribute_group); 638 if (rv) 639 goto free_domain; 640 641 timer_setup(&port->rx_timer, vcc_rx_timer, 0); 642 timer_setup(&port->tx_timer, vcc_tx_timer, 0); 643 644 dev_set_drvdata(&vdev->dev, port); 645 646 /* It's possible to receive IRQs in the middle of vio_port_up. Disable 647 * IRQs until the port is up. 648 */ 649 disable_irq_nosync(vdev->rx_irq); 650 vio_port_up(&port->vio); 651 enable_irq(vdev->rx_irq); 652 653 return 0; 654 655 free_domain: 656 kfree(port->domain); 657 unreg_tty: 658 tty_unregister_device(vcc_tty_driver, port->index); 659 free_table: 660 vcc_table_remove(port->index); 661 free_ldc: 662 vio_ldc_free(&port->vio); 663 free_port: 664 kfree(name); 665 kfree(port); 666 667 return rv; 668 } 669 670 /** 671 * vcc_remove() - Terminate a VCC port 672 * @vdev: Pointer to VIO device of the VCC port 673 * 674 * Terminates a VCC port. Sets up the teardown of TTY and 675 * VIO/LDC link between guest and primary domains. 676 * 677 * Return: status of removal 678 */ 679 static int vcc_remove(struct vio_dev *vdev) 680 { 681 struct vcc_port *port = dev_get_drvdata(&vdev->dev); 682 683 if (!port) 684 return -ENODEV; 685 686 del_timer_sync(&port->rx_timer); 687 del_timer_sync(&port->tx_timer); 688 689 /* If there's a process with the device open, do a synchronous 690 * hangup of the TTY. This *may* cause the process to call close 691 * asynchronously, but it's not guaranteed. 692 */ 693 if (port->tty) 694 tty_vhangup(port->tty); 695 696 /* Get exclusive reference to VCC, ensures that there are no other 697 * clients to this port 698 */ 699 port = vcc_get(port->index, true); 700 701 if (WARN_ON(!port)) 702 return -ENODEV; 703 704 tty_unregister_device(vcc_tty_driver, port->index); 705 706 del_timer_sync(&port->vio.timer); 707 vio_ldc_free(&port->vio); 708 sysfs_remove_group(&vdev->dev.kobj, &vcc_attribute_group); 709 dev_set_drvdata(&vdev->dev, NULL); 710 if (port->tty) { 711 port->removed = true; 712 vcc_put(port, true); 713 } else { 714 vcc_table_remove(port->index); 715 716 kfree(port->vio.name); 717 kfree(port->domain); 718 kfree(port); 719 } 720 721 return 0; 722 } 723 724 static const struct vio_device_id vcc_match[] = { 725 { 726 .type = "vcc-port", 727 }, 728 {}, 729 }; 730 MODULE_DEVICE_TABLE(vio, vcc_match); 731 732 static struct vio_driver vcc_driver = { 733 .id_table = vcc_match, 734 .probe = vcc_probe, 735 .remove = vcc_remove, 736 .name = "vcc", 737 }; 738 739 static int vcc_open(struct tty_struct *tty, struct file *vcc_file) 740 { 741 struct vcc_port *port; 742 743 if (unlikely(!tty)) { 744 pr_err("VCC: open: Invalid TTY handle\n"); 745 return -ENXIO; 746 } 747 748 if (tty->count > 1) 749 return -EBUSY; 750 751 port = vcc_get_ne(tty->index); 752 if (unlikely(!port)) { 753 pr_err("VCC: open: Failed to find VCC port\n"); 754 return -ENODEV; 755 } 756 757 if (unlikely(!port->vio.lp)) { 758 pr_err("VCC: open: LDC channel not configured\n"); 759 vcc_put(port, false); 760 return -EPIPE; 761 } 762 vccdbgl(port->vio.lp); 763 764 vcc_put(port, false); 765 766 if (unlikely(!tty->port)) { 767 pr_err("VCC: open: TTY port not found\n"); 768 return -ENXIO; 769 } 770 771 if (unlikely(!tty->port->ops)) { 772 pr_err("VCC: open: TTY ops not defined\n"); 773 return -ENXIO; 774 } 775 776 return tty_port_open(tty->port, tty, vcc_file); 777 } 778 779 static void vcc_close(struct tty_struct *tty, struct file *vcc_file) 780 { 781 if (unlikely(!tty)) { 782 pr_err("VCC: close: Invalid TTY handle\n"); 783 return; 784 } 785 786 if (unlikely(tty->count > 1)) 787 return; 788 789 if (unlikely(!tty->port)) { 790 pr_err("VCC: close: TTY port not found\n"); 791 return; 792 } 793 794 tty_port_close(tty->port, tty, vcc_file); 795 } 796 797 static void vcc_ldc_hup(struct vcc_port *port) 798 { 799 unsigned long flags; 800 801 spin_lock_irqsave(&port->lock, flags); 802 803 if (vcc_send_ctl(port, VCC_CTL_HUP) < 0) 804 vcc_kick_tx(port); 805 806 spin_unlock_irqrestore(&port->lock, flags); 807 } 808 809 static void vcc_hangup(struct tty_struct *tty) 810 { 811 struct vcc_port *port; 812 813 if (unlikely(!tty)) { 814 pr_err("VCC: hangup: Invalid TTY handle\n"); 815 return; 816 } 817 818 port = vcc_get_ne(tty->index); 819 if (unlikely(!port)) { 820 pr_err("VCC: hangup: Failed to find VCC port\n"); 821 return; 822 } 823 824 if (unlikely(!tty->port)) { 825 pr_err("VCC: hangup: TTY port not found\n"); 826 vcc_put(port, false); 827 return; 828 } 829 830 vcc_ldc_hup(port); 831 832 vcc_put(port, false); 833 834 tty_port_hangup(tty->port); 835 } 836 837 static int vcc_write(struct tty_struct *tty, const unsigned char *buf, 838 int count) 839 { 840 struct vcc_port *port; 841 struct vio_vcc *pkt; 842 unsigned long flags; 843 int total_sent = 0; 844 int tosend = 0; 845 int rv = -EINVAL; 846 847 if (unlikely(!tty)) { 848 pr_err("VCC: write: Invalid TTY handle\n"); 849 return -ENXIO; 850 } 851 852 port = vcc_get_ne(tty->index); 853 if (unlikely(!port)) { 854 pr_err("VCC: write: Failed to find VCC port"); 855 return -ENODEV; 856 } 857 858 spin_lock_irqsave(&port->lock, flags); 859 860 pkt = &port->buffer; 861 pkt->tag.type = VIO_TYPE_DATA; 862 863 while (count > 0) { 864 /* Minimum of data to write and space available */ 865 tosend = min(count, (VCC_BUFF_LEN - port->chars_in_buffer)); 866 867 if (!tosend) 868 break; 869 870 memcpy(&pkt->data[port->chars_in_buffer], &buf[total_sent], 871 tosend); 872 port->chars_in_buffer += tosend; 873 pkt->tag.stype = tosend; 874 875 vccdbg("TAG [%02x:%02x:%04x:%08x]\n", pkt->tag.type, 876 pkt->tag.stype, pkt->tag.stype_env, pkt->tag.sid); 877 vccdbg("DATA [%s]\n", pkt->data); 878 vccdbgl(port->vio.lp); 879 880 /* Since we know we have enough room in VCC buffer for tosend 881 * we record that it was sent regardless of whether the 882 * hypervisor actually took it because we have it buffered. 883 */ 884 rv = ldc_write(port->vio.lp, pkt, (VIO_TAG_SIZE + tosend)); 885 vccdbg("VCC: write: ldc_write(%d)=%d\n", 886 (VIO_TAG_SIZE + tosend), rv); 887 888 total_sent += tosend; 889 count -= tosend; 890 if (rv < 0) { 891 vcc_kick_tx(port); 892 break; 893 } 894 895 port->chars_in_buffer = 0; 896 } 897 898 spin_unlock_irqrestore(&port->lock, flags); 899 900 vcc_put(port, false); 901 902 vccdbg("VCC: write: total=%d rv=%d", total_sent, rv); 903 904 return total_sent ? total_sent : rv; 905 } 906 907 static int vcc_write_room(struct tty_struct *tty) 908 { 909 struct vcc_port *port; 910 u64 num; 911 912 if (unlikely(!tty)) { 913 pr_err("VCC: write_room: Invalid TTY handle\n"); 914 return -ENXIO; 915 } 916 917 port = vcc_get_ne(tty->index); 918 if (unlikely(!port)) { 919 pr_err("VCC: write_room: Failed to find VCC port\n"); 920 return -ENODEV; 921 } 922 923 num = VCC_BUFF_LEN - port->chars_in_buffer; 924 925 vcc_put(port, false); 926 927 return num; 928 } 929 930 static int vcc_chars_in_buffer(struct tty_struct *tty) 931 { 932 struct vcc_port *port; 933 u64 num; 934 935 if (unlikely(!tty)) { 936 pr_err("VCC: chars_in_buffer: Invalid TTY handle\n"); 937 return -ENXIO; 938 } 939 940 port = vcc_get_ne(tty->index); 941 if (unlikely(!port)) { 942 pr_err("VCC: chars_in_buffer: Failed to find VCC port\n"); 943 return -ENODEV; 944 } 945 946 num = port->chars_in_buffer; 947 948 vcc_put(port, false); 949 950 return num; 951 } 952 953 static int vcc_break_ctl(struct tty_struct *tty, int state) 954 { 955 struct vcc_port *port; 956 unsigned long flags; 957 958 if (unlikely(!tty)) { 959 pr_err("VCC: break_ctl: Invalid TTY handle\n"); 960 return -ENXIO; 961 } 962 963 port = vcc_get_ne(tty->index); 964 if (unlikely(!port)) { 965 pr_err("VCC: break_ctl: Failed to find VCC port\n"); 966 return -ENODEV; 967 } 968 969 /* Turn off break */ 970 if (state == 0) { 971 vcc_put(port, false); 972 return 0; 973 } 974 975 spin_lock_irqsave(&port->lock, flags); 976 977 if (vcc_send_ctl(port, VCC_CTL_BREAK) < 0) 978 vcc_kick_tx(port); 979 980 spin_unlock_irqrestore(&port->lock, flags); 981 982 vcc_put(port, false); 983 984 return 0; 985 } 986 987 static int vcc_install(struct tty_driver *driver, struct tty_struct *tty) 988 { 989 struct vcc_port *port_vcc; 990 struct tty_port *port_tty; 991 int ret; 992 993 if (unlikely(!tty)) { 994 pr_err("VCC: install: Invalid TTY handle\n"); 995 return -ENXIO; 996 } 997 998 if (tty->index >= VCC_MAX_PORTS) 999 return -EINVAL; 1000 1001 ret = tty_standard_install(driver, tty); 1002 if (ret) 1003 return ret; 1004 1005 port_tty = kzalloc(sizeof(struct tty_port), GFP_KERNEL); 1006 if (!port_tty) 1007 return -ENOMEM; 1008 1009 port_vcc = vcc_get(tty->index, true); 1010 if (!port_vcc) { 1011 pr_err("VCC: install: Failed to find VCC port\n"); 1012 tty->port = NULL; 1013 kfree(port_tty); 1014 return -ENODEV; 1015 } 1016 1017 tty_port_init(port_tty); 1018 port_tty->ops = &vcc_port_ops; 1019 tty->port = port_tty; 1020 1021 port_vcc->tty = tty; 1022 1023 vcc_put(port_vcc, true); 1024 1025 return 0; 1026 } 1027 1028 static void vcc_cleanup(struct tty_struct *tty) 1029 { 1030 struct vcc_port *port; 1031 1032 if (unlikely(!tty)) { 1033 pr_err("VCC: cleanup: Invalid TTY handle\n"); 1034 return; 1035 } 1036 1037 port = vcc_get(tty->index, true); 1038 if (port) { 1039 port->tty = NULL; 1040 1041 if (port->removed) { 1042 vcc_table_remove(tty->index); 1043 kfree(port->vio.name); 1044 kfree(port->domain); 1045 kfree(port); 1046 } else { 1047 vcc_put(port, true); 1048 } 1049 } 1050 1051 tty_port_destroy(tty->port); 1052 kfree(tty->port); 1053 tty->port = NULL; 1054 } 1055 1056 static const struct tty_operations vcc_ops = { 1057 .open = vcc_open, 1058 .close = vcc_close, 1059 .hangup = vcc_hangup, 1060 .write = vcc_write, 1061 .write_room = vcc_write_room, 1062 .chars_in_buffer = vcc_chars_in_buffer, 1063 .break_ctl = vcc_break_ctl, 1064 .install = vcc_install, 1065 .cleanup = vcc_cleanup, 1066 }; 1067 1068 #define VCC_TTY_FLAGS (TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_REAL_RAW) 1069 1070 static int vcc_tty_init(void) 1071 { 1072 int rv; 1073 1074 pr_info("VCC: %s\n", version); 1075 1076 vcc_tty_driver = tty_alloc_driver(VCC_MAX_PORTS, VCC_TTY_FLAGS); 1077 if (IS_ERR(vcc_tty_driver)) { 1078 pr_err("VCC: TTY driver alloc failed\n"); 1079 return PTR_ERR(vcc_tty_driver); 1080 } 1081 1082 vcc_tty_driver->driver_name = vcc_driver_name; 1083 vcc_tty_driver->name = vcc_device_node; 1084 1085 vcc_tty_driver->minor_start = VCC_MINOR_START; 1086 vcc_tty_driver->type = TTY_DRIVER_TYPE_SYSTEM; 1087 vcc_tty_driver->init_termios = vcc_tty_termios; 1088 1089 tty_set_operations(vcc_tty_driver, &vcc_ops); 1090 1091 rv = tty_register_driver(vcc_tty_driver); 1092 if (rv) { 1093 pr_err("VCC: TTY driver registration failed\n"); 1094 put_tty_driver(vcc_tty_driver); 1095 vcc_tty_driver = NULL; 1096 return rv; 1097 } 1098 1099 vccdbg("VCC: TTY driver registered\n"); 1100 1101 return 0; 1102 } 1103 1104 static void vcc_tty_exit(void) 1105 { 1106 tty_unregister_driver(vcc_tty_driver); 1107 put_tty_driver(vcc_tty_driver); 1108 vccdbg("VCC: TTY driver unregistered\n"); 1109 1110 vcc_tty_driver = NULL; 1111 } 1112 1113 static int __init vcc_init(void) 1114 { 1115 int rv; 1116 1117 rv = vcc_tty_init(); 1118 if (rv) { 1119 pr_err("VCC: TTY init failed\n"); 1120 return rv; 1121 } 1122 1123 rv = vio_register_driver(&vcc_driver); 1124 if (rv) { 1125 pr_err("VCC: VIO driver registration failed\n"); 1126 vcc_tty_exit(); 1127 } else { 1128 vccdbg("VCC: VIO driver registered successfully\n"); 1129 } 1130 1131 return rv; 1132 } 1133 1134 static void __exit vcc_exit(void) 1135 { 1136 vio_unregister_driver(&vcc_driver); 1137 vccdbg("VCC: VIO driver unregistered\n"); 1138 vcc_tty_exit(); 1139 vccdbg("VCC: TTY driver unregistered\n"); 1140 } 1141 1142 module_init(vcc_init); 1143 module_exit(vcc_exit); 1144