drivers/tty/vcc.c

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