drivers/tty/vcc.c

   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(unsigned long index)
 365 {
 366         struct vio_driver_state *vio;
 367         struct vcc_port *port;
 368         unsigned long flags;
 369         int rv;
 370
 371         port = vcc_get_ne(index);
 372         if (!port)
 373                 return;
 374
 375         spin_lock_irqsave(&port->lock, flags);
 376         port->rx_timer.expires = 0;
 377
 378         vio = &port->vio;
 379
 380         enable_irq(vio->vdev->rx_irq);
 381
 382         if (!port->tty || port->removed)
 383                 goto done;
 384
 385         rv = vcc_ldc_read(port);
 386         if (rv == -ECONNRESET)
 387                 vio_conn_reset(vio);
 388
 389 done:
 390         spin_unlock_irqrestore(&port->lock, flags);
 391         vcc_put(port, false);
 392 }
 393
 394 static void vcc_tx_timer(unsigned long index)
 395 {
 396         struct vcc_port *port;
 397         struct vio_vcc *pkt;
 398         unsigned long flags;
 399         int tosend = 0;
 400         int rv;
 401
 402         port = vcc_get_ne(index);
 403         if (!port)
 404                 return;
 405
 406         spin_lock_irqsave(&port->lock, flags);
 407         port->tx_timer.expires = 0;
 408
 409         if (!port->tty || port->removed)
 410                 goto done;
 411
 412         tosend = min(VCC_BUFF_LEN, port->chars_in_buffer);
 413         if (!tosend)
 414                 goto done;
 415
 416         pkt = &port->buffer;
 417         pkt->tag.type = VIO_TYPE_DATA;
 418         pkt->tag.stype = tosend;
 419         vccdbgl(port->vio.lp);
 420
 421         rv = ldc_write(port->vio.lp, pkt, (VIO_TAG_SIZE + tosend));
 422         WARN_ON(!rv);
 423
 424         if (rv < 0) {
 425                 vccdbg("VCC: ldc_write()=%d\n", rv);
 426                 vcc_kick_tx(port);
 427         } else {
 428                 struct tty_struct *tty = port->tty;
 429
 430                 port->chars_in_buffer = 0;
 431                 if (tty)
 432                         tty_wakeup(tty);
 433         }
 434
 435 done:
 436         spin_unlock_irqrestore(&port->lock, flags);
 437         vcc_put(port, false);
 438 }
 439
 440 /**
 441  * vcc_event() - LDC event processing engine
 442  * @arg: VCC private data
 443  * @event: LDC event
 444  *
 445  * Handles LDC events for VCC
 446  */
 447 static void vcc_event(void *arg, int event)
 448 {
 449         struct vio_driver_state *vio;
 450         struct vcc_port *port;
 451         unsigned long flags;
 452         int rv;
 453
 454         port = arg;
 455         vio = &port->vio;
 456
 457         spin_lock_irqsave(&port->lock, flags);
 458
 459         switch (event) {
 460         case LDC_EVENT_RESET:
 461         case LDC_EVENT_UP:
 462                 vio_link_state_change(vio, event);
 463                 break;
 464
 465         case LDC_EVENT_DATA_READY:
 466                 rv = vcc_ldc_read(port);
 467                 if (rv == -ECONNRESET)
 468                         vio_conn_reset(vio);
 469                 break;
 470
 471         default:
 472                 pr_err("VCC: unexpected LDC event(%d)\n", event);
 473         }
 474
 475         spin_unlock_irqrestore(&port->lock, flags);
 476 }
 477
 478 static struct ldc_channel_config vcc_ldc_cfg = {
 479         .event          = vcc_event,
 480         .mtu            = VIO_VCC_MTU_SIZE,
 481         .mode           = LDC_MODE_RAW,
 482         .debug          = 0,
 483 };
 484
 485 /* Ordered from largest major to lowest */
 486 static struct vio_version vcc_versions[] = {
 487         { .major = 1, .minor = 0 },
 488 };
 489
 490 static struct tty_port_operations vcc_port_ops = { 0 };
 491
 492 static ssize_t vcc_sysfs_domain_show(struct device *dev,
 493                                      struct device_attribute *attr,
 494                                      char *buf)
 495 {
 496         struct vcc_port *port;
 497         int rv;
 498
 499         port = dev_get_drvdata(dev);
 500         if (!port)
 501                 return -ENODEV;
 502
 503         rv = scnprintf(buf, PAGE_SIZE, "%s\n", port->domain);
 504
 505         return rv;
 506 }
 507
 508 static int vcc_send_ctl(struct vcc_port *port, int ctl)
 509 {
 510         struct vio_vcc pkt;
 511         int rv;
 512
 513         pkt.tag.type = VIO_TYPE_CTRL;
 514         pkt.tag.sid = ctl;
 515         pkt.tag.stype = 0;
 516
 517         rv = ldc_write(port->vio.lp, &pkt, sizeof(pkt.tag));
 518         WARN_ON(!rv);
 519         vccdbg("VCC: ldc_write(%ld)=%d\n", sizeof(pkt.tag), rv);
 520
 521         return rv;
 522 }
 523
 524 static ssize_t vcc_sysfs_break_store(struct device *dev,
 525                                      struct device_attribute *attr,
 526                                      const char *buf, size_t count)
 527 {
 528         struct vcc_port *port;
 529         unsigned long flags;
 530         int rv = count;
 531         int brk;
 532
 533         port = dev_get_drvdata(dev);
 534         if (!port)
 535                 return -ENODEV;
 536
 537         spin_lock_irqsave(&port->lock, flags);
 538
 539         if (sscanf(buf, "%ud", &brk) != 1 || brk != 1)
 540                 rv = -EINVAL;
 541         else if (vcc_send_ctl(port, VCC_CTL_BREAK) < 0)
 542                 vcc_kick_tx(port);
 543
 544         spin_unlock_irqrestore(&port->lock, flags);
 545
 546         return rv;
 547 }
 548
 549 static DEVICE_ATTR(domain, 0400, vcc_sysfs_domain_show, NULL);
 550 static DEVICE_ATTR(break, 0200, NULL, vcc_sysfs_break_store);
 551
 552 static struct attribute *vcc_sysfs_entries[] = {
 553         &dev_attr_domain.attr,
 554         &dev_attr_break.attr,
 555         NULL
 556 };
 557
 558 static struct attribute_group vcc_attribute_group = {
 559         .name = NULL,
 560         .attrs = vcc_sysfs_entries,
 561 };
 562
 563 /**
 564  * vcc_probe() - Initialize VCC port
 565  * @vdev: Pointer to VIO device of the new VCC port
 566  * @id: VIO device ID
 567  *
 568  * Initializes a VCC port to receive serial console data from
 569  * the guest domain. Sets up a TTY end point on the control
 570  * domain. Sets up VIO/LDC link between the guest & control
 571  * domain endpoints.
 572  *
 573  * Return: status of the probe
 574  */
 575 static int vcc_probe(struct vio_dev *vdev, const struct vio_device_id *id)
 576 {
 577         struct mdesc_handle *hp;
 578         struct vcc_port *port;
 579         struct device *dev;
 580         const char *domain;
 581         char *name;
 582         u64 node;
 583         int rv;
 584
 585         vccdbg("VCC: name=%s\n", dev_name(&vdev->dev));
 586
 587         if (!vcc_tty_driver) {
 588                 pr_err("VCC: TTY driver not registered\n");
 589                 return -ENODEV;
 590         }
 591
 592         port = kzalloc(sizeof(struct vcc_port), GFP_KERNEL);
 593         if (!port)
 594                 return -ENOMEM;
 595
 596         name = kstrdup(dev_name(&vdev->dev), GFP_KERNEL);
 597         if (!name) {
 598                 rv = -ENOMEM;
 599                 goto free_port;
 600         }
 601
 602         rv = vio_driver_init(&port->vio, vdev, VDEV_CONSOLE_CON, vcc_versions,
 603                              ARRAY_SIZE(vcc_versions), NULL, name);
 604         if (rv)
 605                 goto free_name;
 606
 607         port->vio.debug = vcc_dbg_vio;
 608         vcc_ldc_cfg.debug = vcc_dbg_ldc;
 609
 610         rv = vio_ldc_alloc(&port->vio, &vcc_ldc_cfg, port);
 611         if (rv)
 612                 goto free_name;
 613
 614         spin_lock_init(&port->lock);
 615
 616         port->index = vcc_table_add(port);
 617         if (port->index == -1) {
 618                 pr_err("VCC: no more TTY indices left for allocation\n");
 619                 rv = -ENOMEM;
 620                 goto free_ldc;
 621         }
 622
 623         /* Register the device using VCC table index as TTY index */
 624         dev = tty_register_device(vcc_tty_driver, port->index, &vdev->dev);
 625         if (IS_ERR(dev)) {
 626                 rv = PTR_ERR(dev);
 627                 goto free_table;
 628         }
 629
 630         hp = mdesc_grab();
 631
 632         node = vio_vdev_node(hp, vdev);
 633         if (node == MDESC_NODE_NULL) {
 634                 rv = -ENXIO;
 635                 mdesc_release(hp);
 636                 goto unreg_tty;
 637         }
 638
 639         domain = mdesc_get_property(hp, node, "vcc-domain-name", NULL);
 640         if (!domain) {
 641                 rv = -ENXIO;
 642                 mdesc_release(hp);
 643                 goto unreg_tty;
 644         }
 645         port->domain = kstrdup(domain, GFP_KERNEL);
 646         if (!port->domain) {
 647                 rv = -ENOMEM;
 648                 goto unreg_tty;
 649         }
 650
 651
 652         mdesc_release(hp);
 653
 654         rv = sysfs_create_group(&vdev->dev.kobj, &vcc_attribute_group);
 655         if (rv)
 656                 goto free_domain;
 657
 658         init_timer(&port->rx_timer);
 659         port->rx_timer.function = vcc_rx_timer;
 660         port->rx_timer.data = port->index;
 661
 662         init_timer(&port->tx_timer);
 663         port->tx_timer.function = vcc_tx_timer;
 664         port->tx_timer.data = port->index;
 665
 666         dev_set_drvdata(&vdev->dev, port);
 667
 668         /* It's possible to receive IRQs in the middle of vio_port_up. Disable
 669          * IRQs until the port is up.
 670          */
 671         disable_irq_nosync(vdev->rx_irq);
 672         vio_port_up(&port->vio);
 673         enable_irq(vdev->rx_irq);
 674
 675         return 0;
 676
 677 free_domain:
 678         kfree(port->domain);
 679 unreg_tty:
 680         tty_unregister_device(vcc_tty_driver, port->index);
 681 free_table:
 682         vcc_table_remove(port->index);
 683 free_ldc:
 684         vio_ldc_free(&port->vio);
 685 free_name:
 686         kfree(name);
 687 free_port:
 688         kfree(port);
 689
 690         return rv;
 691 }
 692
 693 /**
 694  * vcc_remove() - Terminate a VCC port
 695  * @vdev: Pointer to VIO device of the VCC port
 696  *
 697  * Terminates a VCC port. Sets up the teardown of TTY and
 698  * VIO/LDC link between guest and primary domains.
 699  *
 700  * Return: status of removal
 701  */
 702 static int vcc_remove(struct vio_dev *vdev)
 703 {
 704         struct vcc_port *port = dev_get_drvdata(&vdev->dev);
 705
 706         if (!port)
 707                 return -ENODEV;
 708
 709         del_timer_sync(&port->rx_timer);
 710         del_timer_sync(&port->tx_timer);
 711
 712         /* If there's a process with the device open, do a synchronous
 713          * hangup of the TTY. This *may* cause the process to call close
 714          * asynchronously, but it's not guaranteed.
 715          */
 716         if (port->tty)
 717                 tty_vhangup(port->tty);
 718
 719         /* Get exclusive reference to VCC, ensures that there are no other
 720          * clients to this port
 721          */
 722         port = vcc_get(port->index, true);
 723
 724         if (WARN_ON(!port))
 725                 return -ENODEV;
 726
 727         tty_unregister_device(vcc_tty_driver, port->index);
 728
 729         del_timer_sync(&port->vio.timer);
 730         vio_ldc_free(&port->vio);
 731         sysfs_remove_group(&vdev->dev.kobj, &vcc_attribute_group);
 732         dev_set_drvdata(&vdev->dev, NULL);
 733         if (port->tty) {
 734                 port->removed = true;
 735                 vcc_put(port, true);
 736         } else {
 737                 vcc_table_remove(port->index);
 738
 739                 kfree(port->vio.name);
 740                 kfree(port->domain);
 741                 kfree(port);
 742         }
 743
 744         return 0;
 745 }
 746
 747 static const struct vio_device_id vcc_match[] = {
 748         {
 749                 .type = "vcc-port",
 750         },
 751         {},
 752 };
 753 MODULE_DEVICE_TABLE(vio, vcc_match);
 754
 755 static struct vio_driver vcc_driver = {
 756         .id_table       = vcc_match,
 757         .probe          = vcc_probe,
 758         .remove         = vcc_remove,
 759         .name           = "vcc",
 760 };
 761
 762 static int vcc_open(struct tty_struct *tty, struct file *vcc_file)
 763 {
 764         struct vcc_port *port;
 765
 766         if (unlikely(!tty)) {
 767                 pr_err("VCC: open: Invalid TTY handle\n");
 768                 return -ENXIO;
 769         }
 770
 771         if (tty->count > 1)
 772                 return -EBUSY;
 773
 774         port = vcc_get_ne(tty->index);
 775         if (unlikely(!port)) {
 776                 pr_err("VCC: open: Failed to find VCC port\n");
 777                 return -ENODEV;
 778         }
 779
 780         if (unlikely(!port->vio.lp)) {
 781                 pr_err("VCC: open: LDC channel not configured\n");
 782                 vcc_put(port, false);
 783                 return -EPIPE;
 784         }
 785         vccdbgl(port->vio.lp);
 786
 787         vcc_put(port, false);
 788
 789         if (unlikely(!tty->port)) {
 790                 pr_err("VCC: open: TTY port not found\n");
 791                 return -ENXIO;
 792         }
 793
 794         if (unlikely(!tty->port->ops)) {
 795                 pr_err("VCC: open: TTY ops not defined\n");
 796                 return -ENXIO;
 797         }
 798
 799         return tty_port_open(tty->port, tty, vcc_file);
 800 }
 801
 802 static void vcc_close(struct tty_struct *tty, struct file *vcc_file)
 803 {
 804         if (unlikely(!tty)) {
 805                 pr_err("VCC: close: Invalid TTY handle\n");
 806                 return;
 807         }
 808
 809         if (unlikely(tty->count > 1))
 810                 return;
 811
 812         if (unlikely(!tty->port)) {
 813                 pr_err("VCC: close: TTY port not found\n");
 814                 return;
 815         }
 816
 817         tty_port_close(tty->port, tty, vcc_file);
 818 }
 819
 820 static void vcc_ldc_hup(struct vcc_port *port)
 821 {
 822         unsigned long flags;
 823
 824         spin_lock_irqsave(&port->lock, flags);
 825
 826         if (vcc_send_ctl(port, VCC_CTL_HUP) < 0)
 827                 vcc_kick_tx(port);
 828
 829         spin_unlock_irqrestore(&port->lock, flags);
 830 }
 831
 832 static void vcc_hangup(struct tty_struct *tty)
 833 {
 834         struct vcc_port *port;
 835
 836         if (unlikely(!tty)) {
 837                 pr_err("VCC: hangup: Invalid TTY handle\n");
 838                 return;
 839         }
 840
 841         port = vcc_get_ne(tty->index);
 842         if (unlikely(!port)) {
 843                 pr_err("VCC: hangup: Failed to find VCC port\n");
 844                 return;
 845         }
 846
 847         if (unlikely(!tty->port)) {
 848                 pr_err("VCC: hangup: TTY port not found\n");
 849                 vcc_put(port, false);
 850                 return;
 851         }
 852
 853         vcc_ldc_hup(port);
 854
 855         vcc_put(port, false);
 856
 857         tty_port_hangup(tty->port);
 858 }
 859
 860 static int vcc_write(struct tty_struct *tty, const unsigned char *buf,
 861                      int count)
 862 {
 863         struct vcc_port *port;
 864         struct vio_vcc *pkt;
 865         unsigned long flags;
 866         int total_sent = 0;
 867         int tosend = 0;
 868         int rv = -EINVAL;
 869
 870         if (unlikely(!tty)) {
 871                 pr_err("VCC: write: Invalid TTY handle\n");
 872                 return -ENXIO;
 873         }
 874
 875         port = vcc_get_ne(tty->index);
 876         if (unlikely(!port)) {
 877                 pr_err("VCC: write: Failed to find VCC port");
 878                 return -ENODEV;
 879         }
 880
 881         spin_lock_irqsave(&port->lock, flags);
 882
 883         pkt = &port->buffer;
 884         pkt->tag.type = VIO_TYPE_DATA;
 885
 886         while (count > 0) {
 887                 /* Minimum of data to write and space available */
 888                 tosend = min(count, (VCC_BUFF_LEN - port->chars_in_buffer));
 889
 890                 if (!tosend)
 891                         break;
 892
 893                 memcpy(&pkt->data[port->chars_in_buffer], &buf[total_sent],
 894                        tosend);
 895                 port->chars_in_buffer += tosend;
 896                 pkt->tag.stype = tosend;
 897
 898                 vccdbg("TAG [%02x:%02x:%04x:%08x]\n", pkt->tag.type,
 899                        pkt->tag.stype, pkt->tag.stype_env, pkt->tag.sid);
 900                 vccdbg("DATA [%s]\n", pkt->data);
 901                 vccdbgl(port->vio.lp);
 902
 903                 /* Since we know we have enough room in VCC buffer for tosend
 904                  * we record that it was sent regardless of whether the
 905                  * hypervisor actually took it because we have it buffered.
 906                  */
 907                 rv = ldc_write(port->vio.lp, pkt, (VIO_TAG_SIZE + tosend));
 908                 vccdbg("VCC: write: ldc_write(%d)=%d\n",
 909                        (VIO_TAG_SIZE + tosend), rv);
 910
 911                 total_sent += tosend;
 912                 count -= tosend;
 913                 if (rv < 0) {
 914                         vcc_kick_tx(port);
 915                         break;
 916                 }
 917
 918                 port->chars_in_buffer = 0;
 919         }
 920
 921         spin_unlock_irqrestore(&port->lock, flags);
 922
 923         vcc_put(port, false);
 924
 925         vccdbg("VCC: write: total=%d rv=%d", total_sent, rv);
 926
 927         return total_sent ? total_sent : rv;
 928 }
 929
 930 static int vcc_write_room(struct tty_struct *tty)
 931 {
 932         struct vcc_port *port;
 933         u64 num;
 934
 935         if (unlikely(!tty)) {
 936                 pr_err("VCC: write_room: Invalid TTY handle\n");
 937                 return -ENXIO;
 938         }
 939
 940         port = vcc_get_ne(tty->index);
 941         if (unlikely(!port)) {
 942                 pr_err("VCC: write_room: Failed to find VCC port\n");
 943                 return -ENODEV;
 944         }
 945
 946         num = VCC_BUFF_LEN - port->chars_in_buffer;
 947
 948         vcc_put(port, false);
 949
 950         return num;
 951 }
 952
 953 static int vcc_chars_in_buffer(struct tty_struct *tty)
 954 {
 955         struct vcc_port *port;
 956         u64 num;
 957
 958         if (unlikely(!tty)) {
 959                 pr_err("VCC: chars_in_buffer: Invalid TTY handle\n");
 960                 return -ENXIO;
 961         }
 962
 963         port = vcc_get_ne(tty->index);
 964         if (unlikely(!port)) {
 965                 pr_err("VCC: chars_in_buffer: Failed to find VCC port\n");
 966                 return -ENODEV;
 967         }
 968
 969         num = port->chars_in_buffer;
 970
 971         vcc_put(port, false);
 972
 973         return num;
 974 }
 975
 976 static int vcc_break_ctl(struct tty_struct *tty, int state)
 977 {
 978         struct vcc_port *port;
 979         unsigned long flags;
 980
 981         if (unlikely(!tty)) {
 982                 pr_err("VCC: break_ctl: Invalid TTY handle\n");
 983                 return -ENXIO;
 984         }
 985
 986         port = vcc_get_ne(tty->index);
 987         if (unlikely(!port)) {
 988                 pr_err("VCC: break_ctl: Failed to find VCC port\n");
 989                 return -ENODEV;
 990         }
 991
 992         /* Turn off break */
 993         if (state == 0) {
 994                 vcc_put(port, false);
 995                 return 0;
 996         }
 997
 998         spin_lock_irqsave(&port->lock, flags);
 999
1000         if (vcc_send_ctl(port, VCC_CTL_BREAK) < 0)
1001                 vcc_kick_tx(port);
1002
1003         spin_unlock_irqrestore(&port->lock, flags);
1004
1005         vcc_put(port, false);
1006
1007         return 0;
1008 }
1009
1010 static int vcc_install(struct tty_driver *driver, struct tty_struct *tty)
1011 {
1012         struct vcc_port *port_vcc;
1013         struct tty_port *port_tty;
1014         int ret;
1015
1016         if (unlikely(!tty)) {
1017                 pr_err("VCC: install: Invalid TTY handle\n");
1018                 return -ENXIO;
1019         }
1020
1021         if (tty->index >= VCC_MAX_PORTS)
1022                 return -EINVAL;
1023
1024         ret = tty_standard_install(driver, tty);
1025         if (ret)
1026                 return ret;
1027
1028         port_tty = kzalloc(sizeof(struct tty_port), GFP_KERNEL);
1029         if (!port_tty)
1030                 return -ENOMEM;
1031
1032         port_vcc = vcc_get(tty->index, true);
1033         if (!port_vcc) {
1034                 pr_err("VCC: install: Failed to find VCC port\n");
1035                 tty->port = NULL;
1036                 kfree(port_tty);
1037                 return -ENODEV;
1038         }
1039
1040         tty_port_init(port_tty);
1041         port_tty->ops = &vcc_port_ops;
1042         tty->port = port_tty;
1043
1044         port_vcc->tty = tty;
1045
1046         vcc_put(port_vcc, true);
1047
1048         return 0;
1049 }
1050
1051 static void vcc_cleanup(struct tty_struct *tty)
1052 {
1053         struct vcc_port *port;
1054
1055         if (unlikely(!tty)) {
1056                 pr_err("VCC: cleanup: Invalid TTY handle\n");
1057                 return;
1058         }
1059
1060         port = vcc_get(tty->index, true);
1061         if (port) {
1062                 port->tty = NULL;
1063
1064                 if (port->removed) {
1065                         vcc_table_remove(tty->index);
1066                         kfree(port->vio.name);
1067                         kfree(port->domain);
1068                         kfree(port);
1069                 } else {
1070                         vcc_put(port, true);
1071                 }
1072         }
1073
1074         tty_port_destroy(tty->port);
1075         kfree(tty->port);
1076         tty->port = NULL;
1077 }
1078
1079 static const struct tty_operations vcc_ops = {
1080         .open                   = vcc_open,
1081         .close                  = vcc_close,
1082         .hangup                 = vcc_hangup,
1083         .write                  = vcc_write,
1084         .write_room             = vcc_write_room,
1085         .chars_in_buffer        = vcc_chars_in_buffer,
1086         .break_ctl              = vcc_break_ctl,
1087         .install                = vcc_install,
1088         .cleanup                = vcc_cleanup,
1089 };
1090
1091 #define VCC_TTY_FLAGS   (TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_REAL_RAW)
1092
1093 static int vcc_tty_init(void)
1094 {
1095         int rv;
1096
1097         pr_info("VCC: %s\n", version);
1098
1099         vcc_tty_driver = tty_alloc_driver(VCC_MAX_PORTS, VCC_TTY_FLAGS);
1100         if (IS_ERR(vcc_tty_driver)) {
1101                 pr_err("VCC: TTY driver alloc failed\n");
1102                 return PTR_ERR(vcc_tty_driver);
1103         }
1104
1105         vcc_tty_driver->driver_name = vcc_driver_name;
1106         vcc_tty_driver->name = vcc_device_node;
1107
1108         vcc_tty_driver->minor_start = VCC_MINOR_START;
1109         vcc_tty_driver->type = TTY_DRIVER_TYPE_SYSTEM;
1110         vcc_tty_driver->init_termios = vcc_tty_termios;
1111
1112         tty_set_operations(vcc_tty_driver, &vcc_ops);
1113
1114         rv = tty_register_driver(vcc_tty_driver);
1115         if (rv) {
1116                 pr_err("VCC: TTY driver registration failed\n");
1117                 put_tty_driver(vcc_tty_driver);
1118                 vcc_tty_driver = NULL;
1119                 return rv;
1120         }
1121
1122         vccdbg("VCC: TTY driver registered\n");
1123
1124         return 0;
1125 }
1126
1127 static void vcc_tty_exit(void)
1128 {
1129         tty_unregister_driver(vcc_tty_driver);
1130         put_tty_driver(vcc_tty_driver);
1131         vccdbg("VCC: TTY driver unregistered\n");
1132
1133         vcc_tty_driver = NULL;
1134 }
1135
1136 static int __init vcc_init(void)
1137 {
1138         int rv;
1139
1140         rv = vcc_tty_init();
1141         if (rv) {
1142                 pr_err("VCC: TTY init failed\n");
1143                 return rv;
1144         }
1145
1146         rv = vio_register_driver(&vcc_driver);
1147         if (rv) {
1148                 pr_err("VCC: VIO driver registration failed\n");
1149                 vcc_tty_exit();
1150         } else {
1151                 vccdbg("VCC: VIO driver registered successfully\n");
1152         }
1153
1154         return rv;
1155 }
1156
1157 static void __exit vcc_exit(void)
1158 {
1159         vio_unregister_driver(&vcc_driver);
1160         vccdbg("VCC: VIO driver unregistered\n");
1161         vcc_tty_exit();
1162         vccdbg("VCC: TTY driver unregistered\n");
1163 }
1164
1165 module_init(vcc_init);
1166 module_exit(vcc_exit);