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