drivers/char/virtio_console.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2006, 2007, 2009 Rusty Russell, IBM Corporation
   4  * Copyright (C) 2009, 2010, 2011 Red Hat, Inc.
   5  * Copyright (C) 2009, 2010, 2011 Amit Shah <amit.shah@redhat.com>
   6  */
   7 #include <linux/cdev.h>
   8 #include <linux/debugfs.h>
   9 #include <linux/completion.h>
  10 #include <linux/device.h>
  11 #include <linux/err.h>
  12 #include <linux/freezer.h>
  13 #include <linux/fs.h>
  14 #include <linux/splice.h>
  15 #include <linux/pagemap.h>
  16 #include <linux/idr.h>
  17 #include <linux/init.h>
  18 #include <linux/list.h>
  19 #include <linux/poll.h>
  20 #include <linux/sched.h>
  21 #include <linux/slab.h>
  22 #include <linux/spinlock.h>
  23 #include <linux/virtio.h>
  24 #include <linux/virtio_console.h>
  25 #include <linux/wait.h>
  26 #include <linux/workqueue.h>
  27 #include <linux/module.h>
  28 #include <linux/dma-mapping.h>
  29 #include "../tty/hvc/hvc_console.h"
  30
  31 #define is_rproc_enabled IS_ENABLED(CONFIG_REMOTEPROC)
  32 #define VIRTCONS_MAX_PORTS 0x8000
  33
  34 /*
  35  * This is a global struct for storing common data for all the devices
  36  * this driver handles.
  37  *
  38  * Mainly, it has a linked list for all the consoles in one place so
  39  * that callbacks from hvc for get_chars(), put_chars() work properly
  40  * across multiple devices and multiple ports per device.
  41  */
  42 struct ports_driver_data {
  43         /* Used for registering chardevs */
  44         struct class *class;
  45
  46         /* Used for exporting per-port information to debugfs */
  47         struct dentry *debugfs_dir;
  48
  49         /* List of all the devices we're handling */
  50         struct list_head portdevs;
  51
  52         /* All the console devices handled by this driver */
  53         struct list_head consoles;
  54 };
  55
  56 static struct ports_driver_data pdrvdata;
  57
  58 static DEFINE_SPINLOCK(pdrvdata_lock);
  59 static DECLARE_COMPLETION(early_console_added);
  60
  61 /* This struct holds information that's relevant only for console ports */
  62 struct console {
  63         /* We'll place all consoles in a list in the pdrvdata struct */
  64         struct list_head list;
  65
  66         /* The hvc device associated with this console port */
  67         struct hvc_struct *hvc;
  68
  69         /* The size of the console */
  70         struct winsize ws;
  71
  72         /*
  73          * This number identifies the number that we used to register
  74          * with hvc in hvc_instantiate() and hvc_alloc(); this is the
  75          * number passed on by the hvc callbacks to us to
  76          * differentiate between the other console ports handled by
  77          * this driver
  78          */
  79         u32 vtermno;
  80 };
  81
  82 static DEFINE_IDA(vtermno_ida);
  83
  84 struct port_buffer {
  85         char *buf;
  86
  87         /* size of the buffer in *buf above */
  88         size_t size;
  89
  90         /* used length of the buffer */
  91         size_t len;
  92         /* offset in the buf from which to consume data */
  93         size_t offset;
  94
  95         /* DMA address of buffer */
  96         dma_addr_t dma;
  97
  98         /* Device we got DMA memory from */
  99         struct device *dev;
 100
 101         /* List of pending dma buffers to free */
 102         struct list_head list;
 103
 104         /* If sgpages == 0 then buf is used */
 105         unsigned int sgpages;
 106
 107         /* sg is used if spages > 0. sg must be the last in is struct */
 108         struct scatterlist sg[];
 109 };
 110
 111 /*
 112  * This is a per-device struct that stores data common to all the
 113  * ports for that device (vdev->priv).
 114  */
 115 struct ports_device {
 116         /* Next portdev in the list, head is in the pdrvdata struct */
 117         struct list_head list;
 118
 119         /*
 120          * Workqueue handlers where we process deferred work after
 121          * notification
 122          */
 123         struct work_struct control_work;
 124         struct work_struct config_work;
 125
 126         struct list_head ports;
 127
 128         /* To protect the list of ports */
 129         spinlock_t ports_lock;
 130
 131         /* To protect the vq operations for the control channel */
 132         spinlock_t c_ivq_lock;
 133         spinlock_t c_ovq_lock;
 134
 135         /* max. number of ports this device can hold */
 136         u32 max_nr_ports;
 137
 138         /* The virtio device we're associated with */
 139         struct virtio_device *vdev;
 140
 141         /*
 142          * A couple of virtqueues for the control channel: one for
 143          * guest->host transfers, one for host->guest transfers
 144          */
 145         struct virtqueue *c_ivq, *c_ovq;
 146
 147         /*
 148          * A control packet buffer for guest->host requests, protected
 149          * by c_ovq_lock.
 150          */
 151         struct virtio_console_control cpkt;
 152
 153         /* Array of per-port IO virtqueues */
 154         struct virtqueue **in_vqs, **out_vqs;
 155
 156         /* Major number for this device.  Ports will be created as minors. */
 157         int chr_major;
 158 };
 159
 160 struct port_stats {
 161         unsigned long bytes_sent, bytes_received, bytes_discarded;
 162 };
 163
 164 /* This struct holds the per-port data */
 165 struct port {
 166         /* Next port in the list, head is in the ports_device */
 167         struct list_head list;
 168
 169         /* Pointer to the parent virtio_console device */
 170         struct ports_device *portdev;
 171
 172         /* The current buffer from which data has to be fed to readers */
 173         struct port_buffer *inbuf;
 174
 175         /*
 176          * To protect the operations on the in_vq associated with this
 177          * port.  Has to be a spinlock because it can be called from
 178          * interrupt context (get_char()).
 179          */
 180         spinlock_t inbuf_lock;
 181
 182         /* Protect the operations on the out_vq. */
 183         spinlock_t outvq_lock;
 184
 185         /* The IO vqs for this port */
 186         struct virtqueue *in_vq, *out_vq;
 187
 188         /* File in the debugfs directory that exposes this port's information */
 189         struct dentry *debugfs_file;
 190
 191         /*
 192          * Keep count of the bytes sent, received and discarded for
 193          * this port for accounting and debugging purposes.  These
 194          * counts are not reset across port open / close events.
 195          */
 196         struct port_stats stats;
 197
 198         /*
 199          * The entries in this struct will be valid if this port is
 200          * hooked up to an hvc console
 201          */
 202         struct console cons;
 203
 204         /* Each port associates with a separate char device */
 205         struct cdev *cdev;
 206         struct device *dev;
 207
 208         /* Reference-counting to handle port hot-unplugs and file operations */
 209         struct kref kref;
 210
 211         /* A waitqueue for poll() or blocking read operations */
 212         wait_queue_head_t waitqueue;
 213
 214         /* The 'name' of the port that we expose via sysfs properties */
 215         char *name;
 216
 217         /* We can notify apps of host connect / disconnect events via SIGIO */
 218         struct fasync_struct *async_queue;
 219
 220         /* The 'id' to identify the port with the Host */
 221         u32 id;
 222
 223         bool outvq_full;
 224
 225         /* Is the host device open */
 226         bool host_connected;
 227
 228         /* We should allow only one process to open a port */
 229         bool guest_connected;
 230 };
 231
 232 /* This is the very early arch-specified put chars function. */
 233 static int (*early_put_chars)(u32, const char *, int);
 234
 235 static struct port *find_port_by_vtermno(u32 vtermno)
 236 {
 237         struct port *port;
 238         struct console *cons;
 239         unsigned long flags;
 240
 241         spin_lock_irqsave(&pdrvdata_lock, flags);
 242         list_for_each_entry(cons, &pdrvdata.consoles, list) {
 243                 if (cons->vtermno == vtermno) {
 244                         port = container_of(cons, struct port, cons);
 245                         goto out;
 246                 }
 247         }
 248         port = NULL;
 249 out:
 250         spin_unlock_irqrestore(&pdrvdata_lock, flags);
 251         return port;
 252 }
 253
 254 static struct port *find_port_by_devt_in_portdev(struct ports_device *portdev,
 255                                                  dev_t dev)
 256 {
 257         struct port *port;
 258         unsigned long flags;
 259
 260         spin_lock_irqsave(&portdev->ports_lock, flags);
 261         list_for_each_entry(port, &portdev->ports, list) {
 262                 if (port->cdev->dev == dev) {
 263                         kref_get(&port->kref);
 264                         goto out;
 265                 }
 266         }
 267         port = NULL;
 268 out:
 269         spin_unlock_irqrestore(&portdev->ports_lock, flags);
 270
 271         return port;
 272 }
 273
 274 static struct port *find_port_by_devt(dev_t dev)
 275 {
 276         struct ports_device *portdev;
 277         struct port *port;
 278         unsigned long flags;
 279
 280         spin_lock_irqsave(&pdrvdata_lock, flags);
 281         list_for_each_entry(portdev, &pdrvdata.portdevs, list) {
 282                 port = find_port_by_devt_in_portdev(portdev, dev);
 283                 if (port)
 284                         goto out;
 285         }
 286         port = NULL;
 287 out:
 288         spin_unlock_irqrestore(&pdrvdata_lock, flags);
 289         return port;
 290 }
 291
 292 static struct port *find_port_by_id(struct ports_device *portdev, u32 id)
 293 {
 294         struct port *port;
 295         unsigned long flags;
 296
 297         spin_lock_irqsave(&portdev->ports_lock, flags);
 298         list_for_each_entry(port, &portdev->ports, list)
 299                 if (port->id == id)
 300                         goto out;
 301         port = NULL;
 302 out:
 303         spin_unlock_irqrestore(&portdev->ports_lock, flags);
 304
 305         return port;
 306 }
 307
 308 static struct port *find_port_by_vq(struct ports_device *portdev,
 309                                     struct virtqueue *vq)
 310 {
 311         struct port *port;
 312         unsigned long flags;
 313
 314         spin_lock_irqsave(&portdev->ports_lock, flags);
 315         list_for_each_entry(port, &portdev->ports, list)
 316                 if (port->in_vq == vq || port->out_vq == vq)
 317                         goto out;
 318         port = NULL;
 319 out:
 320         spin_unlock_irqrestore(&portdev->ports_lock, flags);
 321         return port;
 322 }
 323
 324 static bool is_console_port(struct port *port)
 325 {
 326         if (port->cons.hvc)
 327                 return true;
 328         return false;
 329 }
 330
 331 static bool is_rproc_serial(const struct virtio_device *vdev)
 332 {
 333         return is_rproc_enabled && vdev->id.device == VIRTIO_ID_RPROC_SERIAL;
 334 }
 335
 336 static inline bool use_multiport(struct ports_device *portdev)
 337 {
 338         /*
 339          * This condition can be true when put_chars is called from
 340          * early_init
 341          */
 342         if (!portdev->vdev)
 343                 return false;
 344         return __virtio_test_bit(portdev->vdev, VIRTIO_CONSOLE_F_MULTIPORT);
 345 }
 346
 347 static DEFINE_SPINLOCK(dma_bufs_lock);
 348 static LIST_HEAD(pending_free_dma_bufs);
 349
 350 static void free_buf(struct port_buffer *buf, bool can_sleep)
 351 {
 352         unsigned int i;
 353
 354         for (i = 0; i < buf->sgpages; i++) {
 355                 struct page *page = sg_page(&buf->sg[i]);
 356                 if (!page)
 357                         break;
 358                 put_page(page);
 359         }
 360
 361         if (!buf->dev) {
 362                 kfree(buf->buf);
 363         } else if (is_rproc_enabled) {
 364                 unsigned long flags;
 365
 366                 /* dma_free_coherent requires interrupts to be enabled. */
 367                 if (!can_sleep) {
 368                         /* queue up dma-buffers to be freed later */
 369                         spin_lock_irqsave(&dma_bufs_lock, flags);
 370                         list_add_tail(&buf->list, &pending_free_dma_bufs);
 371                         spin_unlock_irqrestore(&dma_bufs_lock, flags);
 372                         return;
 373                 }
 374                 dma_free_coherent(buf->dev, buf->size, buf->buf, buf->dma);
 375
 376                 /* Release device refcnt and allow it to be freed */
 377                 put_device(buf->dev);
 378         }
 379
 380         kfree(buf);
 381 }
 382
 383 static void reclaim_dma_bufs(void)
 384 {
 385         unsigned long flags;
 386         struct port_buffer *buf, *tmp;
 387         LIST_HEAD(tmp_list);
 388
 389         if (list_empty(&pending_free_dma_bufs))
 390                 return;
 391
 392         /* Create a copy of the pending_free_dma_bufs while holding the lock */
 393         spin_lock_irqsave(&dma_bufs_lock, flags);
 394         list_cut_position(&tmp_list, &pending_free_dma_bufs,
 395                           pending_free_dma_bufs.prev);
 396         spin_unlock_irqrestore(&dma_bufs_lock, flags);
 397
 398         /* Release the dma buffers, without irqs enabled */
 399         list_for_each_entry_safe(buf, tmp, &tmp_list, list) {
 400                 list_del(&buf->list);
 401                 free_buf(buf, true);
 402         }
 403 }
 404
 405 static struct port_buffer *alloc_buf(struct virtio_device *vdev, size_t buf_size,
 406                                      int pages)
 407 {
 408         struct port_buffer *buf;
 409
 410         reclaim_dma_bufs();
 411
 412         /*
 413          * Allocate buffer and the sg list. The sg list array is allocated
 414          * directly after the port_buffer struct.
 415          */
 416         buf = kmalloc(struct_size(buf, sg, pages), GFP_KERNEL);
 417         if (!buf)
 418                 goto fail;
 419
 420         buf->sgpages = pages;
 421         if (pages > 0) {
 422                 buf->dev = NULL;
 423                 buf->buf = NULL;
 424                 return buf;
 425         }
 426
 427         if (is_rproc_serial(vdev)) {
 428                 /*
 429                  * Allocate DMA memory from ancestor. When a virtio
 430                  * device is created by remoteproc, the DMA memory is
 431                  * associated with the parent device:
 432                  * virtioY => remoteprocX#vdevYbuffer.
 433                  */
 434                 buf->dev = vdev->dev.parent;
 435                 if (!buf->dev)
 436                         goto free_buf;
 437
 438                 /* Increase device refcnt to avoid freeing it */
 439                 get_device(buf->dev);
 440                 buf->buf = dma_alloc_coherent(buf->dev, buf_size, &buf->dma,
 441                                               GFP_KERNEL);
 442         } else {
 443                 buf->dev = NULL;
 444                 buf->buf = kmalloc(buf_size, GFP_KERNEL);
 445         }
 446
 447         if (!buf->buf)
 448                 goto free_buf;
 449         buf->len = 0;
 450         buf->offset = 0;
 451         buf->size = buf_size;
 452         return buf;
 453
 454 free_buf:
 455         kfree(buf);
 456 fail:
 457         return NULL;
 458 }
 459
 460 /* Callers should take appropriate locks */
 461 static struct port_buffer *get_inbuf(struct port *port)
 462 {
 463         struct port_buffer *buf;
 464         unsigned int len;
 465
 466         if (port->inbuf)
 467                 return port->inbuf;
 468
 469         buf = virtqueue_get_buf(port->in_vq, &len);
 470         if (buf) {
 471                 buf->len = min_t(size_t, len, buf->size);
 472                 buf->offset = 0;
 473                 port->stats.bytes_received += len;
 474         }
 475         return buf;
 476 }
 477
 478 /*
 479  * Create a scatter-gather list representing our input buffer and put
 480  * it in the queue.
 481  *
 482  * Callers should take appropriate locks.
 483  */
 484 static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)
 485 {
 486         struct scatterlist sg[1];
 487         int ret;
 488
 489         sg_init_one(sg, buf->buf, buf->size);
 490
 491         ret = virtqueue_add_inbuf(vq, sg, 1, buf, GFP_ATOMIC);
 492         virtqueue_kick(vq);
 493         if (!ret)
 494                 ret = vq->num_free;
 495         return ret;
 496 }
 497
 498 /* Discard any unread data this port has. Callers lockers. */
 499 static void discard_port_data(struct port *port)
 500 {
 501         struct port_buffer *buf;
 502         unsigned int err;
 503
 504         if (!port->portdev) {
 505                 /* Device has been unplugged.  vqs are already gone. */
 506                 return;
 507         }
 508         buf = get_inbuf(port);
 509
 510         err = 0;
 511         while (buf) {
 512                 port->stats.bytes_discarded += buf->len - buf->offset;
 513                 if (add_inbuf(port->in_vq, buf) < 0) {
 514                         err++;
 515                         free_buf(buf, false);
 516                 }
 517                 port->inbuf = NULL;
 518                 buf = get_inbuf(port);
 519         }
 520         if (err)
 521                 dev_warn(port->dev, "Errors adding %d buffers back to vq\n",
 522                          err);
 523 }
 524
 525 static bool port_has_data(struct port *port)
 526 {
 527         unsigned long flags;
 528         bool ret;
 529
 530         ret = false;
 531         spin_lock_irqsave(&port->inbuf_lock, flags);
 532         port->inbuf = get_inbuf(port);
 533         if (port->inbuf)
 534                 ret = true;
 535
 536         spin_unlock_irqrestore(&port->inbuf_lock, flags);
 537         return ret;
 538 }
 539
 540 static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id,
 541                                   unsigned int event, unsigned int value)
 542 {
 543         struct scatterlist sg[1];
 544         struct virtqueue *vq;
 545         unsigned int len;
 546
 547         if (!use_multiport(portdev))
 548                 return 0;
 549
 550         vq = portdev->c_ovq;
 551
 552         spin_lock(&portdev->c_ovq_lock);
 553
 554         portdev->cpkt.id = cpu_to_virtio32(portdev->vdev, port_id);
 555         portdev->cpkt.event = cpu_to_virtio16(portdev->vdev, event);
 556         portdev->cpkt.value = cpu_to_virtio16(portdev->vdev, value);
 557
 558         sg_init_one(sg, &portdev->cpkt, sizeof(struct virtio_console_control));
 559
 560         if (virtqueue_add_outbuf(vq, sg, 1, &portdev->cpkt, GFP_ATOMIC) == 0) {
 561                 virtqueue_kick(vq);
 562                 while (!virtqueue_get_buf(vq, &len)
 563                         && !virtqueue_is_broken(vq))
 564                         cpu_relax();
 565         }
 566
 567         spin_unlock(&portdev->c_ovq_lock);
 568         return 0;
 569 }
 570
 571 static ssize_t send_control_msg(struct port *port, unsigned int event,
 572                                 unsigned int value)
 573 {
 574         /* Did the port get unplugged before userspace closed it? */
 575         if (port->portdev)
 576                 return __send_control_msg(port->portdev, port->id, event, value);
 577         return 0;
 578 }
 579
 580
 581 /* Callers must take the port->outvq_lock */
 582 static void reclaim_consumed_buffers(struct port *port)
 583 {
 584         struct port_buffer *buf;
 585         unsigned int len;
 586
 587         if (!port->portdev) {
 588                 /* Device has been unplugged.  vqs are already gone. */
 589                 return;
 590         }
 591         while ((buf = virtqueue_get_buf(port->out_vq, &len))) {
 592                 free_buf(buf, false);
 593                 port->outvq_full = false;
 594         }
 595 }
 596
 597 static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,
 598                               int nents, size_t in_count,
 599                               void *data, bool nonblock)
 600 {
 601         struct virtqueue *out_vq;
 602         int err;
 603         unsigned long flags;
 604         unsigned int len;
 605
 606         out_vq = port->out_vq;
 607
 608         spin_lock_irqsave(&port->outvq_lock, flags);
 609
 610         reclaim_consumed_buffers(port);
 611
 612         err = virtqueue_add_outbuf(out_vq, sg, nents, data, GFP_ATOMIC);
 613
 614         /* Tell Host to go! */
 615         virtqueue_kick(out_vq);
 616
 617         if (err) {
 618                 in_count = 0;
 619                 goto done;
 620         }
 621
 622         if (out_vq->num_free == 0)
 623                 port->outvq_full = true;
 624
 625         if (nonblock)
 626                 goto done;
 627
 628         /*
 629          * Wait till the host acknowledges it pushed out the data we
 630          * sent.  This is done for data from the hvc_console; the tty
 631          * operations are performed with spinlocks held so we can't
 632          * sleep here.  An alternative would be to copy the data to a
 633          * buffer and relax the spinning requirement.  The downside is
 634          * we need to kmalloc a GFP_ATOMIC buffer each time the
 635          * console driver writes something out.
 636          */
 637         while (!virtqueue_get_buf(out_vq, &len)
 638                 && !virtqueue_is_broken(out_vq))
 639                 cpu_relax();
 640 done:
 641         spin_unlock_irqrestore(&port->outvq_lock, flags);
 642
 643         port->stats.bytes_sent += in_count;
 644         /*
 645          * We're expected to return the amount of data we wrote -- all
 646          * of it
 647          */
 648         return in_count;
 649 }
 650
 651 /*
 652  * Give out the data that's requested from the buffer that we have
 653  * queued up.
 654  */
 655 static ssize_t fill_readbuf(struct port *port, char __user *out_buf,
 656                             size_t out_count, bool to_user)
 657 {
 658         struct port_buffer *buf;
 659         unsigned long flags;
 660
 661         if (!out_count || !port_has_data(port))
 662                 return 0;
 663
 664         buf = port->inbuf;
 665         out_count = min(out_count, buf->len - buf->offset);
 666
 667         if (to_user) {
 668                 ssize_t ret;
 669
 670                 ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count);
 671                 if (ret)
 672                         return -EFAULT;
 673         } else {
 674                 memcpy((__force char *)out_buf, buf->buf + buf->offset,
 675                        out_count);
 676         }
 677
 678         buf->offset += out_count;
 679
 680         if (buf->offset == buf->len) {
 681                 /*
 682                  * We're done using all the data in this buffer.
 683                  * Re-queue so that the Host can send us more data.
 684                  */
 685                 spin_lock_irqsave(&port->inbuf_lock, flags);
 686                 port->inbuf = NULL;
 687
 688                 if (add_inbuf(port->in_vq, buf) < 0)
 689                         dev_warn(port->dev, "failed add_buf\n");
 690
 691                 spin_unlock_irqrestore(&port->inbuf_lock, flags);
 692         }
 693         /* Return the number of bytes actually copied */
 694         return out_count;
 695 }
 696
 697 /* The condition that must be true for polling to end */
 698 static bool will_read_block(struct port *port)
 699 {
 700         if (!port->guest_connected) {
 701                 /* Port got hot-unplugged. Let's exit. */
 702                 return false;
 703         }
 704         return !port_has_data(port) && port->host_connected;
 705 }
 706
 707 static bool will_write_block(struct port *port)
 708 {
 709         bool ret;
 710
 711         if (!port->guest_connected) {
 712                 /* Port got hot-unplugged. Let's exit. */
 713                 return false;
 714         }
 715         if (!port->host_connected)
 716                 return true;
 717
 718         spin_lock_irq(&port->outvq_lock);
 719         /*
 720          * Check if the Host has consumed any buffers since we last
 721          * sent data (this is only applicable for nonblocking ports).
 722          */
 723         reclaim_consumed_buffers(port);
 724         ret = port->outvq_full;
 725         spin_unlock_irq(&port->outvq_lock);
 726
 727         return ret;
 728 }
 729
 730 static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
 731                               size_t count, loff_t *offp)
 732 {
 733         struct port *port;
 734         ssize_t ret;
 735
 736         port = filp->private_data;
 737
 738         /* Port is hot-unplugged. */
 739         if (!port->guest_connected)
 740                 return -ENODEV;
 741
 742         if (!port_has_data(port)) {
 743                 /*
 744                  * If nothing's connected on the host just return 0 in
 745                  * case of list_empty; this tells the userspace app
 746                  * that there's no connection
 747                  */
 748                 if (!port->host_connected)
 749                         return 0;
 750                 if (filp->f_flags & O_NONBLOCK)
 751                         return -EAGAIN;
 752
 753                 ret = wait_event_freezable(port->waitqueue,
 754                                            !will_read_block(port));
 755                 if (ret < 0)
 756                         return ret;
 757         }
 758         /* Port got hot-unplugged while we were waiting above. */
 759         if (!port->guest_connected)
 760                 return -ENODEV;
 761         /*
 762          * We could've received a disconnection message while we were
 763          * waiting for more data.
 764          *
 765          * This check is not clubbed in the if() statement above as we
 766          * might receive some data as well as the host could get
 767          * disconnected after we got woken up from our wait.  So we
 768          * really want to give off whatever data we have and only then
 769          * check for host_connected.
 770          */
 771         if (!port_has_data(port) && !port->host_connected)
 772                 return 0;
 773
 774         return fill_readbuf(port, ubuf, count, true);
 775 }
 776
 777 static int wait_port_writable(struct port *port, bool nonblock)
 778 {
 779         int ret;
 780
 781         if (will_write_block(port)) {
 782                 if (nonblock)
 783                         return -EAGAIN;
 784
 785                 ret = wait_event_freezable(port->waitqueue,
 786                                            !will_write_block(port));
 787                 if (ret < 0)
 788                         return ret;
 789         }
 790         /* Port got hot-unplugged. */
 791         if (!port->guest_connected)
 792                 return -ENODEV;
 793
 794         return 0;
 795 }
 796
 797 static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
 798                                size_t count, loff_t *offp)
 799 {
 800         struct port *port;
 801         struct port_buffer *buf;
 802         ssize_t ret;
 803         bool nonblock;
 804         struct scatterlist sg[1];
 805
 806         /* Userspace could be out to fool us */
 807         if (!count)
 808                 return 0;
 809
 810         port = filp->private_data;
 811
 812         nonblock = filp->f_flags & O_NONBLOCK;
 813
 814         ret = wait_port_writable(port, nonblock);
 815         if (ret < 0)
 816                 return ret;
 817
 818         count = min((size_t)(32 * 1024), count);
 819
 820         buf = alloc_buf(port->portdev->vdev, count, 0);
 821         if (!buf)
 822                 return -ENOMEM;
 823
 824         ret = copy_from_user(buf->buf, ubuf, count);
 825         if (ret) {
 826                 ret = -EFAULT;
 827                 goto free_buf;
 828         }
 829
 830         /*
 831          * We now ask send_buf() to not spin for generic ports -- we
 832          * can re-use the same code path that non-blocking file
 833          * descriptors take for blocking file descriptors since the
 834          * wait is already done and we're certain the write will go
 835          * through to the host.
 836          */
 837         nonblock = true;
 838         sg_init_one(sg, buf->buf, count);
 839         ret = __send_to_port(port, sg, 1, count, buf, nonblock);
 840
 841         if (nonblock && ret > 0)
 842                 goto out;
 843
 844 free_buf:
 845         free_buf(buf, true);
 846 out:
 847         return ret;
 848 }
 849
 850 struct sg_list {
 851         unsigned int n;
 852         unsigned int size;
 853         size_t len;
 854         struct scatterlist *sg;
 855 };
 856
 857 static int pipe_to_sg(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
 858                         struct splice_desc *sd)
 859 {
 860         struct sg_list *sgl = sd->u.data;
 861         unsigned int offset, len;
 862
 863         if (sgl->n == sgl->size)
 864                 return 0;
 865
 866         /* Try lock this page */
 867         if (pipe_buf_try_steal(pipe, buf)) {
 868                 /* Get reference and unlock page for moving */
 869                 get_page(buf->page);
 870                 unlock_page(buf->page);
 871
 872                 len = min(buf->len, sd->len);
 873                 sg_set_page(&(sgl->sg[sgl->n]), buf->page, len, buf->offset);
 874         } else {
 875                 /* Failback to copying a page */
 876                 struct page *page = alloc_page(GFP_KERNEL);
 877                 char *src;
 878
 879                 if (!page)
 880                         return -ENOMEM;
 881
 882                 offset = sd->pos & ~PAGE_MASK;
 883
 884                 len = sd->len;
 885                 if (len + offset > PAGE_SIZE)
 886                         len = PAGE_SIZE - offset;
 887
 888                 src = kmap_atomic(buf->page);
 889                 memcpy(page_address(page) + offset, src + buf->offset, len);
 890                 kunmap_atomic(src);
 891
 892                 sg_set_page(&(sgl->sg[sgl->n]), page, len, offset);
 893         }
 894         sgl->n++;
 895         sgl->len += len;
 896
 897         return len;
 898 }
 899
 900 /* Faster zero-copy write by splicing */
 901 static ssize_t port_fops_splice_write(struct pipe_inode_info *pipe,
 902                                       struct file *filp, loff_t *ppos,
 903                                       size_t len, unsigned int flags)
 904 {
 905         struct port *port = filp->private_data;
 906         struct sg_list sgl;
 907         ssize_t ret;
 908         struct port_buffer *buf;
 909         struct splice_desc sd = {
 910                 .total_len = len,
 911                 .flags = flags,
 912                 .pos = *ppos,
 913                 .u.data = &sgl,
 914         };
 915         unsigned int occupancy;
 916
 917         /*
 918          * Rproc_serial does not yet support splice. To support splice
 919          * pipe_to_sg() must allocate dma-buffers and copy content from
 920          * regular pages to dma pages. And alloc_buf and free_buf must
 921          * support allocating and freeing such a list of dma-buffers.
 922          */
 923         if (is_rproc_serial(port->out_vq->vdev))
 924                 return -EINVAL;
 925
 926         pipe_lock(pipe);
 927         ret = 0;
 928         if (pipe_empty(pipe->head, pipe->tail))
 929                 goto error_out;
 930
 931         ret = wait_port_writable(port, filp->f_flags & O_NONBLOCK);
 932         if (ret < 0)
 933                 goto error_out;
 934
 935         occupancy = pipe_occupancy(pipe->head, pipe->tail);
 936         buf = alloc_buf(port->portdev->vdev, 0, occupancy);
 937
 938         if (!buf) {
 939                 ret = -ENOMEM;
 940                 goto error_out;
 941         }
 942
 943         sgl.n = 0;
 944         sgl.len = 0;
 945         sgl.size = occupancy;
 946         sgl.sg = buf->sg;
 947         sg_init_table(sgl.sg, sgl.size);
 948         ret = __splice_from_pipe(pipe, &sd, pipe_to_sg);
 949         pipe_unlock(pipe);
 950         if (likely(ret > 0))
 951                 ret = __send_to_port(port, buf->sg, sgl.n, sgl.len, buf, true);
 952
 953         if (unlikely(ret <= 0))
 954                 free_buf(buf, true);
 955         return ret;
 956
 957 error_out:
 958         pipe_unlock(pipe);
 959         return ret;
 960 }
 961
 962 static __poll_t port_fops_poll(struct file *filp, poll_table *wait)
 963 {
 964         struct port *port;
 965         __poll_t ret;
 966
 967         port = filp->private_data;
 968         poll_wait(filp, &port->waitqueue, wait);
 969
 970         if (!port->guest_connected) {
 971                 /* Port got unplugged */
 972                 return EPOLLHUP;
 973         }
 974         ret = 0;
 975         if (!will_read_block(port))
 976                 ret |= EPOLLIN | EPOLLRDNORM;
 977         if (!will_write_block(port))
 978                 ret |= EPOLLOUT;
 979         if (!port->host_connected)
 980                 ret |= EPOLLHUP;
 981
 982         return ret;
 983 }
 984
 985 static void remove_port(struct kref *kref);
 986
 987 static int port_fops_release(struct inode *inode, struct file *filp)
 988 {
 989         struct port *port;
 990
 991         port = filp->private_data;
 992
 993         /* Notify host of port being closed */
 994         send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
 995
 996         spin_lock_irq(&port->inbuf_lock);
 997         port->guest_connected = false;
 998
 999         discard_port_data(port);
1000
1001         spin_unlock_irq(&port->inbuf_lock);
1002
1003         spin_lock_irq(&port->outvq_lock);
1004         reclaim_consumed_buffers(port);
1005         spin_unlock_irq(&port->outvq_lock);
1006
1007         reclaim_dma_bufs();
1008         /*
1009          * Locks aren't necessary here as a port can't be opened after
1010          * unplug, and if a port isn't unplugged, a kref would already
1011          * exist for the port.  Plus, taking ports_lock here would
1012          * create a dependency on other locks taken by functions
1013          * inside remove_port if we're the last holder of the port,
1014          * creating many problems.
1015          */
1016         kref_put(&port->kref, remove_port);
1017
1018         return 0;
1019 }
1020
1021 static int port_fops_open(struct inode *inode, struct file *filp)
1022 {
1023         struct cdev *cdev = inode->i_cdev;
1024         struct port *port;
1025         int ret;
1026
1027         /* We get the port with a kref here */
1028         port = find_port_by_devt(cdev->dev);
1029         if (!port) {
1030                 /* Port was unplugged before we could proceed */
1031                 return -ENXIO;
1032         }
1033         filp->private_data = port;
1034
1035         /*
1036          * Don't allow opening of console port devices -- that's done
1037          * via /dev/hvc
1038          */
1039         if (is_console_port(port)) {
1040                 ret = -ENXIO;
1041                 goto out;
1042         }
1043
1044         /* Allow only one process to open a particular port at a time */
1045         spin_lock_irq(&port->inbuf_lock);
1046         if (port->guest_connected) {
1047                 spin_unlock_irq(&port->inbuf_lock);
1048                 ret = -EBUSY;
1049                 goto out;
1050         }
1051
1052         port->guest_connected = true;
1053         spin_unlock_irq(&port->inbuf_lock);
1054
1055         spin_lock_irq(&port->outvq_lock);
1056         /*
1057          * There might be a chance that we missed reclaiming a few
1058          * buffers in the window of the port getting previously closed
1059          * and opening now.
1060          */
1061         reclaim_consumed_buffers(port);
1062         spin_unlock_irq(&port->outvq_lock);
1063
1064         nonseekable_open(inode, filp);
1065
1066         /* Notify host of port being opened */
1067         send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1);
1068
1069         return 0;
1070 out:
1071         kref_put(&port->kref, remove_port);
1072         return ret;
1073 }
1074
1075 static int port_fops_fasync(int fd, struct file *filp, int mode)
1076 {
1077         struct port *port;
1078
1079         port = filp->private_data;
1080         return fasync_helper(fd, filp, mode, &port->async_queue);
1081 }
1082
1083 /*
1084  * The file operations that we support: programs in the guest can open
1085  * a console device, read from it, write to it, poll for data and
1086  * close it.  The devices are at
1087  *   /dev/vport<device number>p<port number>
1088  */
1089 static const struct file_operations port_fops = {
1090         .owner = THIS_MODULE,
1091         .open  = port_fops_open,
1092         .read  = port_fops_read,
1093         .write = port_fops_write,
1094         .splice_write = port_fops_splice_write,
1095         .poll  = port_fops_poll,
1096         .release = port_fops_release,
1097         .fasync = port_fops_fasync,
1098         .llseek = no_llseek,
1099 };
1100
1101 /*
1102  * The put_chars() callback is pretty straightforward.
1103  *
1104  * We turn the characters into a scatter-gather list, add it to the
1105  * output queue and then kick the Host.  Then we sit here waiting for
1106  * it to finish: inefficient in theory, but in practice
1107  * implementations will do it immediately.
1108  */
1109 static int put_chars(u32 vtermno, const char *buf, int count)
1110 {
1111         struct port *port;
1112         struct scatterlist sg[1];
1113         void *data;
1114         int ret;
1115
1116         if (unlikely(early_put_chars))
1117                 return early_put_chars(vtermno, buf, count);
1118
1119         port = find_port_by_vtermno(vtermno);
1120         if (!port)
1121                 return -EPIPE;
1122
1123         data = kmemdup(buf, count, GFP_ATOMIC);
1124         if (!data)
1125                 return -ENOMEM;
1126
1127         sg_init_one(sg, data, count);
1128         ret = __send_to_port(port, sg, 1, count, data, false);
1129         kfree(data);
1130         return ret;
1131 }
1132
1133 /*
1134  * get_chars() is the callback from the hvc_console infrastructure
1135  * when an interrupt is received.
1136  *
1137  * We call out to fill_readbuf that gets us the required data from the
1138  * buffers that are queued up.
1139  */
1140 static int get_chars(u32 vtermno, char *buf, int count)
1141 {
1142         struct port *port;
1143
1144         /* If we've not set up the port yet, we have no input to give. */
1145         if (unlikely(early_put_chars))
1146                 return 0;
1147
1148         port = find_port_by_vtermno(vtermno);
1149         if (!port)
1150                 return -EPIPE;
1151
1152         /* If we don't have an input queue yet, we can't get input. */
1153         BUG_ON(!port->in_vq);
1154
1155         return fill_readbuf(port, (__force char __user *)buf, count, false);
1156 }
1157
1158 static void resize_console(struct port *port)
1159 {
1160         struct virtio_device *vdev;
1161
1162         /* The port could have been hot-unplugged */
1163         if (!port || !is_console_port(port))
1164                 return;
1165
1166         vdev = port->portdev->vdev;
1167
1168         /* Don't test F_SIZE at all if we're rproc: not a valid feature! */
1169         if (!is_rproc_serial(vdev) &&
1170             virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE))
1171                 hvc_resize(port->cons.hvc, port->cons.ws);
1172 }
1173
1174 /* We set the configuration at this point, since we now have a tty */
1175 static int notifier_add_vio(struct hvc_struct *hp, int data)
1176 {
1177         struct port *port;
1178
1179         port = find_port_by_vtermno(hp->vtermno);
1180         if (!port)
1181                 return -EINVAL;
1182
1183         hp->irq_requested = 1;
1184         resize_console(port);
1185
1186         return 0;
1187 }
1188
1189 static void notifier_del_vio(struct hvc_struct *hp, int data)
1190 {
1191         hp->irq_requested = 0;
1192 }
1193
1194 /* The operations for console ports. */
1195 static const struct hv_ops hv_ops = {
1196         .get_chars = get_chars,
1197         .put_chars = put_chars,
1198         .notifier_add = notifier_add_vio,
1199         .notifier_del = notifier_del_vio,
1200         .notifier_hangup = notifier_del_vio,
1201 };
1202
1203 /*
1204  * Console drivers are initialized very early so boot messages can go
1205  * out, so we do things slightly differently from the generic virtio
1206  * initialization of the net and block drivers.
1207  *
1208  * At this stage, the console is output-only.  It's too early to set
1209  * up a virtqueue, so we let the drivers do some boutique early-output
1210  * thing.
1211  */
1212 int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int))
1213 {
1214         early_put_chars = put_chars;
1215         return hvc_instantiate(0, 0, &hv_ops);
1216 }
1217
1218 static int init_port_console(struct port *port)
1219 {
1220         int ret;
1221
1222         /*
1223          * The Host's telling us this port is a console port.  Hook it
1224          * up with an hvc console.
1225          *
1226          * To set up and manage our virtual console, we call
1227          * hvc_alloc().
1228          *
1229          * The first argument of hvc_alloc() is the virtual console
1230          * number.  The second argument is the parameter for the
1231          * notification mechanism (like irq number).  We currently
1232          * leave this as zero, virtqueues have implicit notifications.
1233          *
1234          * The third argument is a "struct hv_ops" containing the
1235          * put_chars() get_chars(), notifier_add() and notifier_del()
1236          * pointers.  The final argument is the output buffer size: we
1237          * can do any size, so we put PAGE_SIZE here.
1238          */
1239         ret = ida_alloc_min(&vtermno_ida, 1, GFP_KERNEL);
1240         if (ret < 0)
1241                 return ret;
1242
1243         port->cons.vtermno = ret;
1244         port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE);
1245         if (IS_ERR(port->cons.hvc)) {
1246                 ret = PTR_ERR(port->cons.hvc);
1247                 dev_err(port->dev,
1248                         "error %d allocating hvc for port\n", ret);
1249                 port->cons.hvc = NULL;
1250                 ida_free(&vtermno_ida, port->cons.vtermno);
1251                 return ret;
1252         }
1253         spin_lock_irq(&pdrvdata_lock);
1254         list_add_tail(&port->cons.list, &pdrvdata.consoles);
1255         spin_unlock_irq(&pdrvdata_lock);
1256         port->guest_connected = true;
1257
1258         /*
1259          * Start using the new console output if this is the first
1260          * console to come up.
1261          */
1262         if (early_put_chars)
1263                 early_put_chars = NULL;
1264
1265         /* Notify host of port being opened */
1266         send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
1267
1268         return 0;
1269 }
1270
1271 static ssize_t show_port_name(struct device *dev,
1272                               struct device_attribute *attr, char *buffer)
1273 {
1274         struct port *port;
1275
1276         port = dev_get_drvdata(dev);
1277
1278         return sprintf(buffer, "%s\n", port->name);
1279 }
1280
1281 static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL);
1282
1283 static struct attribute *port_sysfs_entries[] = {
1284         &dev_attr_name.attr,
1285         NULL
1286 };
1287
1288 static const struct attribute_group port_attribute_group = {
1289         .name = NULL,           /* put in device directory */
1290         .attrs = port_sysfs_entries,
1291 };
1292
1293 static int port_debugfs_show(struct seq_file *s, void *data)
1294 {
1295         struct port *port = s->private;
1296
1297         seq_printf(s, "name: %s\n", port->name ? port->name : "");
1298         seq_printf(s, "guest_connected: %d\n", port->guest_connected);
1299         seq_printf(s, "host_connected: %d\n", port->host_connected);
1300         seq_printf(s, "outvq_full: %d\n", port->outvq_full);
1301         seq_printf(s, "bytes_sent: %lu\n", port->stats.bytes_sent);
1302         seq_printf(s, "bytes_received: %lu\n", port->stats.bytes_received);
1303         seq_printf(s, "bytes_discarded: %lu\n", port->stats.bytes_discarded);
1304         seq_printf(s, "is_console: %s\n",
1305                    is_console_port(port) ? "yes" : "no");
1306         seq_printf(s, "console_vtermno: %u\n", port->cons.vtermno);
1307
1308         return 0;
1309 }
1310
1311 DEFINE_SHOW_ATTRIBUTE(port_debugfs);
1312
1313 static void set_console_size(struct port *port, u16 rows, u16 cols)
1314 {
1315         if (!port || !is_console_port(port))
1316                 return;
1317
1318         port->cons.ws.ws_row = rows;
1319         port->cons.ws.ws_col = cols;
1320 }
1321
1322 static int fill_queue(struct virtqueue *vq, spinlock_t *lock)
1323 {
1324         struct port_buffer *buf;
1325         int nr_added_bufs;
1326         int ret;
1327
1328         nr_added_bufs = 0;
1329         do {
1330                 buf = alloc_buf(vq->vdev, PAGE_SIZE, 0);
1331                 if (!buf)
1332                         return -ENOMEM;
1333
1334                 spin_lock_irq(lock);
1335                 ret = add_inbuf(vq, buf);
1336                 if (ret < 0) {
1337                         spin_unlock_irq(lock);
1338                         free_buf(buf, true);
1339                         return ret;
1340                 }
1341                 nr_added_bufs++;
1342                 spin_unlock_irq(lock);
1343         } while (ret > 0);
1344
1345         return nr_added_bufs;
1346 }
1347
1348 static void send_sigio_to_port(struct port *port)
1349 {
1350         if (port->async_queue && port->guest_connected)
1351                 kill_fasync(&port->async_queue, SIGIO, POLL_OUT);
1352 }
1353
1354 static int add_port(struct ports_device *portdev, u32 id)
1355 {
1356         char debugfs_name[16];
1357         struct port *port;
1358         dev_t devt;
1359         int err;
1360
1361         port = kmalloc(sizeof(*port), GFP_KERNEL);
1362         if (!port) {
1363                 err = -ENOMEM;
1364                 goto fail;
1365         }
1366         kref_init(&port->kref);
1367
1368         port->portdev = portdev;
1369         port->id = id;
1370
1371         port->name = NULL;
1372         port->inbuf = NULL;
1373         port->cons.hvc = NULL;
1374         port->async_queue = NULL;
1375
1376         port->cons.ws.ws_row = port->cons.ws.ws_col = 0;
1377         port->cons.vtermno = 0;
1378
1379         port->host_connected = port->guest_connected = false;
1380         port->stats = (struct port_stats) { 0 };
1381
1382         port->outvq_full = false;
1383
1384         port->in_vq = portdev->in_vqs[port->id];
1385         port->out_vq = portdev->out_vqs[port->id];
1386
1387         port->cdev = cdev_alloc();
1388         if (!port->cdev) {
1389                 dev_err(&port->portdev->vdev->dev, "Error allocating cdev\n");
1390                 err = -ENOMEM;
1391                 goto free_port;
1392         }
1393         port->cdev->ops = &port_fops;
1394
1395         devt = MKDEV(portdev->chr_major, id);
1396         err = cdev_add(port->cdev, devt, 1);
1397         if (err < 0) {
1398                 dev_err(&port->portdev->vdev->dev,
1399                         "Error %d adding cdev for port %u\n", err, id);
1400                 goto free_cdev;
1401         }
1402         port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev,
1403                                   devt, port, "vport%up%u",
1404                                   port->portdev->vdev->index, id);
1405         if (IS_ERR(port->dev)) {
1406                 err = PTR_ERR(port->dev);
1407                 dev_err(&port->portdev->vdev->dev,
1408                         "Error %d creating device for port %u\n",
1409                         err, id);
1410                 goto free_cdev;
1411         }
1412
1413         spin_lock_init(&port->inbuf_lock);
1414         spin_lock_init(&port->outvq_lock);
1415         init_waitqueue_head(&port->waitqueue);
1416
1417         /* We can safely ignore ENOSPC because it means
1418          * the queue already has buffers. Buffers are removed
1419          * only by virtcons_remove(), not by unplug_port()
1420          */
1421         err = fill_queue(port->in_vq, &port->inbuf_lock);
1422         if (err < 0 && err != -ENOSPC) {
1423                 dev_err(port->dev, "Error allocating inbufs\n");
1424                 goto free_device;
1425         }
1426
1427         if (is_rproc_serial(port->portdev->vdev))
1428                 /*
1429                  * For rproc_serial assume remote processor is connected.
1430                  * rproc_serial does not want the console port, only
1431                  * the generic port implementation.
1432                  */
1433                 port->host_connected = true;
1434         else if (!use_multiport(port->portdev)) {
1435                 /*
1436                  * If we're not using multiport support,
1437                  * this has to be a console port.
1438                  */
1439                 err = init_port_console(port);
1440                 if (err)
1441                         goto free_inbufs;
1442         }
1443
1444         spin_lock_irq(&portdev->ports_lock);
1445         list_add_tail(&port->list, &port->portdev->ports);
1446         spin_unlock_irq(&portdev->ports_lock);
1447
1448         /*
1449          * Tell the Host we're set so that it can send us various
1450          * configuration parameters for this port (eg, port name,
1451          * caching, whether this is a console port, etc.)
1452          */
1453         send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1454
1455         /*
1456          * Finally, create the debugfs file that we can use to
1457          * inspect a port's state at any time
1458          */
1459         snprintf(debugfs_name, sizeof(debugfs_name), "vport%up%u",
1460                  port->portdev->vdev->index, id);
1461         port->debugfs_file = debugfs_create_file(debugfs_name, 0444,
1462                                                  pdrvdata.debugfs_dir,
1463                                                  port, &port_debugfs_fops);
1464         return 0;
1465
1466 free_inbufs:
1467 free_device:
1468         device_destroy(pdrvdata.class, port->dev->devt);
1469 free_cdev:
1470         cdev_del(port->cdev);
1471 free_port:
1472         kfree(port);
1473 fail:
1474         /* The host might want to notify management sw about port add failure */
1475         __send_control_msg(portdev, id, VIRTIO_CONSOLE_PORT_READY, 0);
1476         return err;
1477 }
1478
1479 /* No users remain, remove all port-specific data. */
1480 static void remove_port(struct kref *kref)
1481 {
1482         struct port *port;
1483
1484         port = container_of(kref, struct port, kref);
1485
1486         kfree(port);
1487 }
1488
1489 static void remove_port_data(struct port *port)
1490 {
1491         spin_lock_irq(&port->inbuf_lock);
1492         /* Remove unused data this port might have received. */
1493         discard_port_data(port);
1494         spin_unlock_irq(&port->inbuf_lock);
1495
1496         spin_lock_irq(&port->outvq_lock);
1497         reclaim_consumed_buffers(port);
1498         spin_unlock_irq(&port->outvq_lock);
1499 }
1500
1501 /*
1502  * Port got unplugged.  Remove port from portdev's list and drop the
1503  * kref reference.  If no userspace has this port opened, it will
1504  * result in immediate removal the port.
1505  */
1506 static void unplug_port(struct port *port)
1507 {
1508         spin_lock_irq(&port->portdev->ports_lock);
1509         list_del(&port->list);
1510         spin_unlock_irq(&port->portdev->ports_lock);
1511
1512         spin_lock_irq(&port->inbuf_lock);
1513         if (port->guest_connected) {
1514                 /* Let the app know the port is going down. */
1515                 send_sigio_to_port(port);
1516
1517                 /* Do this after sigio is actually sent */
1518                 port->guest_connected = false;
1519                 port->host_connected = false;
1520
1521                 wake_up_interruptible(&port->waitqueue);
1522         }
1523         spin_unlock_irq(&port->inbuf_lock);
1524
1525         if (is_console_port(port)) {
1526                 spin_lock_irq(&pdrvdata_lock);
1527                 list_del(&port->cons.list);
1528                 spin_unlock_irq(&pdrvdata_lock);
1529                 hvc_remove(port->cons.hvc);
1530                 ida_free(&vtermno_ida, port->cons.vtermno);
1531         }
1532
1533         remove_port_data(port);
1534
1535         /*
1536          * We should just assume the device itself has gone off --
1537          * else a close on an open port later will try to send out a
1538          * control message.
1539          */
1540         port->portdev = NULL;
1541
1542         sysfs_remove_group(&port->dev->kobj, &port_attribute_group);
1543         device_destroy(pdrvdata.class, port->dev->devt);
1544         cdev_del(port->cdev);
1545
1546         debugfs_remove(port->debugfs_file);
1547         kfree(port->name);
1548
1549         /*
1550          * Locks around here are not necessary - a port can't be
1551          * opened after we removed the port struct from ports_list
1552          * above.
1553          */
1554         kref_put(&port->kref, remove_port);
1555 }
1556
1557 /* Any private messages that the Host and Guest want to share */
1558 static void handle_control_message(struct virtio_device *vdev,
1559                                    struct ports_device *portdev,
1560                                    struct port_buffer *buf)
1561 {
1562         struct virtio_console_control *cpkt;
1563         struct port *port;
1564         size_t name_size;
1565         int err;
1566
1567         cpkt = (struct virtio_console_control *)(buf->buf + buf->offset);
1568
1569         port = find_port_by_id(portdev, virtio32_to_cpu(vdev, cpkt->id));
1570         if (!port &&
1571             cpkt->event != cpu_to_virtio16(vdev, VIRTIO_CONSOLE_PORT_ADD)) {
1572                 /* No valid header at start of buffer.  Drop it. */
1573                 dev_dbg(&portdev->vdev->dev,
1574                         "Invalid index %u in control packet\n", cpkt->id);
1575                 return;
1576         }
1577
1578         switch (virtio16_to_cpu(vdev, cpkt->event)) {
1579         case VIRTIO_CONSOLE_PORT_ADD:
1580                 if (port) {
1581                         dev_dbg(&portdev->vdev->dev,
1582                                 "Port %u already added\n", port->id);
1583                         send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1584                         break;
1585                 }
1586                 if (virtio32_to_cpu(vdev, cpkt->id) >=
1587                     portdev->max_nr_ports) {
1588                         dev_warn(&portdev->vdev->dev,
1589                                 "Request for adding port with "
1590                                 "out-of-bound id %u, max. supported id: %u\n",
1591                                 cpkt->id, portdev->max_nr_ports - 1);
1592                         break;
1593                 }
1594                 add_port(portdev, virtio32_to_cpu(vdev, cpkt->id));
1595                 break;
1596         case VIRTIO_CONSOLE_PORT_REMOVE:
1597                 unplug_port(port);
1598                 break;
1599         case VIRTIO_CONSOLE_CONSOLE_PORT:
1600                 if (!cpkt->value)
1601                         break;
1602                 if (is_console_port(port))
1603                         break;
1604
1605                 init_port_console(port);
1606                 complete(&early_console_added);
1607                 /*
1608                  * Could remove the port here in case init fails - but
1609                  * have to notify the host first.
1610                  */
1611                 break;
1612         case VIRTIO_CONSOLE_RESIZE: {
1613                 struct {
1614                         __u16 rows;
1615                         __u16 cols;
1616                 } size;
1617
1618                 if (!is_console_port(port))
1619                         break;
1620
1621                 memcpy(&size, buf->buf + buf->offset + sizeof(*cpkt),
1622                        sizeof(size));
1623                 set_console_size(port, size.rows, size.cols);
1624
1625                 port->cons.hvc->irq_requested = 1;
1626                 resize_console(port);
1627                 break;
1628         }
1629         case VIRTIO_CONSOLE_PORT_OPEN:
1630                 port->host_connected = virtio16_to_cpu(vdev, cpkt->value);
1631                 wake_up_interruptible(&port->waitqueue);
1632                 /*
1633                  * If the host port got closed and the host had any
1634                  * unconsumed buffers, we'll be able to reclaim them
1635                  * now.
1636                  */
1637                 spin_lock_irq(&port->outvq_lock);
1638                 reclaim_consumed_buffers(port);
1639                 spin_unlock_irq(&port->outvq_lock);
1640
1641                 /*
1642                  * If the guest is connected, it'll be interested in
1643                  * knowing the host connection state changed.
1644                  */
1645                 spin_lock_irq(&port->inbuf_lock);
1646                 send_sigio_to_port(port);
1647                 spin_unlock_irq(&port->inbuf_lock);
1648                 break;
1649         case VIRTIO_CONSOLE_PORT_NAME:
1650                 /*
1651                  * If we woke up after hibernation, we can get this
1652                  * again.  Skip it in that case.
1653                  */
1654                 if (port->name)
1655                         break;
1656
1657                 /*
1658                  * Skip the size of the header and the cpkt to get the size
1659                  * of the name that was sent
1660                  */
1661                 name_size = buf->len - buf->offset - sizeof(*cpkt) + 1;
1662
1663                 port->name = kmalloc(name_size, GFP_KERNEL);
1664                 if (!port->name) {
1665                         dev_err(port->dev,
1666                                 "Not enough space to store port name\n");
1667                         break;
1668                 }
1669                 strscpy(port->name, buf->buf + buf->offset + sizeof(*cpkt),
1670                         name_size);
1671
1672                 /*
1673                  * Since we only have one sysfs attribute, 'name',
1674                  * create it only if we have a name for the port.
1675                  */
1676                 err = sysfs_create_group(&port->dev->kobj,
1677                                          &port_attribute_group);
1678                 if (err) {
1679                         dev_err(port->dev,
1680                                 "Error %d creating sysfs device attributes\n",
1681                                 err);
1682                 } else {
1683                         /*
1684                          * Generate a udev event so that appropriate
1685                          * symlinks can be created based on udev
1686                          * rules.
1687                          */
1688                         kobject_uevent(&port->dev->kobj, KOBJ_CHANGE);
1689                 }
1690                 break;
1691         }
1692 }
1693
1694 static void control_work_handler(struct work_struct *work)
1695 {
1696         struct ports_device *portdev;
1697         struct virtqueue *vq;
1698         struct port_buffer *buf;
1699         unsigned int len;
1700
1701         portdev = container_of(work, struct ports_device, control_work);
1702         vq = portdev->c_ivq;
1703
1704         spin_lock(&portdev->c_ivq_lock);
1705         while ((buf = virtqueue_get_buf(vq, &len))) {
1706                 spin_unlock(&portdev->c_ivq_lock);
1707
1708                 buf->len = min_t(size_t, len, buf->size);
1709                 buf->offset = 0;
1710
1711                 handle_control_message(vq->vdev, portdev, buf);
1712
1713                 spin_lock(&portdev->c_ivq_lock);
1714                 if (add_inbuf(portdev->c_ivq, buf) < 0) {
1715                         dev_warn(&portdev->vdev->dev,
1716                                  "Error adding buffer to queue\n");
1717                         free_buf(buf, false);
1718                 }
1719         }
1720         spin_unlock(&portdev->c_ivq_lock);
1721 }
1722
1723 static void flush_bufs(struct virtqueue *vq, bool can_sleep)
1724 {
1725         struct port_buffer *buf;
1726         unsigned int len;
1727
1728         while ((buf = virtqueue_get_buf(vq, &len)))
1729                 free_buf(buf, can_sleep);
1730 }
1731
1732 static void out_intr(struct virtqueue *vq)
1733 {
1734         struct port *port;
1735
1736         port = find_port_by_vq(vq->vdev->priv, vq);
1737         if (!port) {
1738                 flush_bufs(vq, false);
1739                 return;
1740         }
1741
1742         wake_up_interruptible(&port->waitqueue);
1743 }
1744
1745 static void in_intr(struct virtqueue *vq)
1746 {
1747         struct port *port;
1748         unsigned long flags;
1749
1750         port = find_port_by_vq(vq->vdev->priv, vq);
1751         if (!port) {
1752                 flush_bufs(vq, false);
1753                 return;
1754         }
1755
1756         spin_lock_irqsave(&port->inbuf_lock, flags);
1757         port->inbuf = get_inbuf(port);
1758
1759         /*
1760          * Normally the port should not accept data when the port is
1761          * closed. For generic serial ports, the host won't (shouldn't)
1762          * send data till the guest is connected. But this condition
1763          * can be reached when a console port is not yet connected (no
1764          * tty is spawned) and the other side sends out data over the
1765          * vring, or when a remote devices start sending data before
1766          * the ports are opened.
1767          *
1768          * A generic serial port will discard data if not connected,
1769          * while console ports and rproc-serial ports accepts data at
1770          * any time. rproc-serial is initiated with guest_connected to
1771          * false because port_fops_open expects this. Console ports are
1772          * hooked up with an HVC console and is initialized with
1773          * guest_connected to true.
1774          */
1775
1776         if (!port->guest_connected && !is_rproc_serial(port->portdev->vdev))
1777                 discard_port_data(port);
1778
1779         /* Send a SIGIO indicating new data in case the process asked for it */
1780         send_sigio_to_port(port);
1781
1782         spin_unlock_irqrestore(&port->inbuf_lock, flags);
1783
1784         wake_up_interruptible(&port->waitqueue);
1785
1786         if (is_console_port(port) && hvc_poll(port->cons.hvc))
1787                 hvc_kick();
1788 }
1789
1790 static void control_intr(struct virtqueue *vq)
1791 {
1792         struct ports_device *portdev;
1793
1794         portdev = vq->vdev->priv;
1795         schedule_work(&portdev->control_work);
1796 }
1797
1798 static void config_intr(struct virtio_device *vdev)
1799 {
1800         struct ports_device *portdev;
1801
1802         portdev = vdev->priv;
1803
1804         if (!use_multiport(portdev))
1805                 schedule_work(&portdev->config_work);
1806 }
1807
1808 static void config_work_handler(struct work_struct *work)
1809 {
1810         struct ports_device *portdev;
1811
1812         portdev = container_of(work, struct ports_device, config_work);
1813         if (!use_multiport(portdev)) {
1814                 struct virtio_device *vdev;
1815                 struct port *port;
1816                 u16 rows, cols;
1817
1818                 vdev = portdev->vdev;
1819                 virtio_cread(vdev, struct virtio_console_config, cols, &cols);
1820                 virtio_cread(vdev, struct virtio_console_config, rows, &rows);
1821
1822                 port = find_port_by_id(portdev, 0);
1823                 set_console_size(port, rows, cols);
1824
1825                 /*
1826                  * We'll use this way of resizing only for legacy
1827                  * support.  For newer userspace
1828                  * (VIRTIO_CONSOLE_F_MULTPORT+), use control messages
1829                  * to indicate console size changes so that it can be
1830                  * done per-port.
1831                  */
1832                 resize_console(port);
1833         }
1834 }
1835
1836 static int init_vqs(struct ports_device *portdev)
1837 {
1838         vq_callback_t **io_callbacks;
1839         char **io_names;
1840         struct virtqueue **vqs;
1841         u32 i, j, nr_ports, nr_queues;
1842         int err;
1843
1844         nr_ports = portdev->max_nr_ports;
1845         nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2;
1846
1847         vqs = kmalloc_array(nr_queues, sizeof(struct virtqueue *), GFP_KERNEL);
1848         io_callbacks = kmalloc_array(nr_queues, sizeof(vq_callback_t *),
1849                                      GFP_KERNEL);
1850         io_names = kmalloc_array(nr_queues, sizeof(char *), GFP_KERNEL);
1851         portdev->in_vqs = kmalloc_array(nr_ports, sizeof(struct virtqueue *),
1852                                         GFP_KERNEL);
1853         portdev->out_vqs = kmalloc_array(nr_ports, sizeof(struct virtqueue *),
1854                                          GFP_KERNEL);
1855         if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs ||
1856             !portdev->out_vqs) {
1857                 err = -ENOMEM;
1858                 goto free;
1859         }
1860
1861         /*
1862          * For backward compat (newer host but older guest), the host
1863          * spawns a console port first and also inits the vqs for port
1864          * 0 before others.
1865          */
1866         j = 0;
1867         io_callbacks[j] = in_intr;
1868         io_callbacks[j + 1] = out_intr;
1869         io_names[j] = "input";
1870         io_names[j + 1] = "output";
1871         j += 2;
1872
1873         if (use_multiport(portdev)) {
1874                 io_callbacks[j] = control_intr;
1875                 io_callbacks[j + 1] = NULL;
1876                 io_names[j] = "control-i";
1877                 io_names[j + 1] = "control-o";
1878
1879                 for (i = 1; i < nr_ports; i++) {
1880                         j += 2;
1881                         io_callbacks[j] = in_intr;
1882                         io_callbacks[j + 1] = out_intr;
1883                         io_names[j] = "input";
1884                         io_names[j + 1] = "output";
1885                 }
1886         }
1887         /* Find the queues. */
1888         err = virtio_find_vqs(portdev->vdev, nr_queues, vqs,
1889                               io_callbacks,
1890                               (const char **)io_names, NULL);
1891         if (err)
1892                 goto free;
1893
1894         j = 0;
1895         portdev->in_vqs[0] = vqs[0];
1896         portdev->out_vqs[0] = vqs[1];
1897         j += 2;
1898         if (use_multiport(portdev)) {
1899                 portdev->c_ivq = vqs[j];
1900                 portdev->c_ovq = vqs[j + 1];
1901
1902                 for (i = 1; i < nr_ports; i++) {
1903                         j += 2;
1904                         portdev->in_vqs[i] = vqs[j];
1905                         portdev->out_vqs[i] = vqs[j + 1];
1906                 }
1907         }
1908         kfree(io_names);
1909         kfree(io_callbacks);
1910         kfree(vqs);
1911
1912         return 0;
1913
1914 free:
1915         kfree(portdev->out_vqs);
1916         kfree(portdev->in_vqs);
1917         kfree(io_names);
1918         kfree(io_callbacks);
1919         kfree(vqs);
1920
1921         return err;
1922 }
1923
1924 static const struct file_operations portdev_fops = {
1925         .owner = THIS_MODULE,
1926 };
1927
1928 static void remove_vqs(struct ports_device *portdev)
1929 {
1930         struct virtqueue *vq;
1931
1932         virtio_device_for_each_vq(portdev->vdev, vq) {
1933                 struct port_buffer *buf;
1934
1935                 flush_bufs(vq, true);
1936                 while ((buf = virtqueue_detach_unused_buf(vq)))
1937                         free_buf(buf, true);
1938         }
1939         portdev->vdev->config->del_vqs(portdev->vdev);
1940         kfree(portdev->in_vqs);
1941         kfree(portdev->out_vqs);
1942 }
1943
1944 static void virtcons_remove(struct virtio_device *vdev)
1945 {
1946         struct ports_device *portdev;
1947         struct port *port, *port2;
1948
1949         portdev = vdev->priv;
1950
1951         spin_lock_irq(&pdrvdata_lock);
1952         list_del(&portdev->list);
1953         spin_unlock_irq(&pdrvdata_lock);
1954
1955         /* Device is going away, exit any polling for buffers */
1956         virtio_break_device(vdev);
1957         if (use_multiport(portdev))
1958                 flush_work(&portdev->control_work);
1959         else
1960                 flush_work(&portdev->config_work);
1961
1962         /* Disable interrupts for vqs */
1963         virtio_reset_device(vdev);
1964         /* Finish up work that's lined up */
1965         if (use_multiport(portdev))
1966                 cancel_work_sync(&portdev->control_work);
1967         else
1968                 cancel_work_sync(&portdev->config_work);
1969
1970         list_for_each_entry_safe(port, port2, &portdev->ports, list)
1971                 unplug_port(port);
1972
1973         unregister_chrdev(portdev->chr_major, "virtio-portsdev");
1974
1975         /*
1976          * When yanking out a device, we immediately lose the
1977          * (device-side) queues.  So there's no point in keeping the
1978          * guest side around till we drop our final reference.  This
1979          * also means that any ports which are in an open state will
1980          * have to just stop using the port, as the vqs are going
1981          * away.
1982          */
1983         remove_vqs(portdev);
1984         kfree(portdev);
1985 }
1986
1987 /*
1988  * Once we're further in boot, we get probed like any other virtio
1989  * device.
1990  *
1991  * If the host also supports multiple console ports, we check the
1992  * config space to see how many ports the host has spawned.  We
1993  * initialize each port found.
1994  */
1995 static int virtcons_probe(struct virtio_device *vdev)
1996 {
1997         struct ports_device *portdev;
1998         int err;
1999         bool multiport;
2000         bool early = early_put_chars != NULL;
2001
2002         /* We only need a config space if features are offered */
2003         if (!vdev->config->get &&
2004             (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE)
2005              || virtio_has_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT))) {
2006                 dev_err(&vdev->dev, "%s failure: config access disabled\n",
2007                         __func__);
2008                 return -EINVAL;
2009         }
2010
2011         /* Ensure to read early_put_chars now */
2012         barrier();
2013
2014         portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
2015         if (!portdev) {
2016                 err = -ENOMEM;
2017                 goto fail;
2018         }
2019
2020         /* Attach this portdev to this virtio_device, and vice-versa. */
2021         portdev->vdev = vdev;
2022         vdev->priv = portdev;
2023
2024         portdev->chr_major = register_chrdev(0, "virtio-portsdev",
2025                                              &portdev_fops);
2026         if (portdev->chr_major < 0) {
2027                 dev_err(&vdev->dev,
2028                         "Error %d registering chrdev for device %u\n",
2029                         portdev->chr_major, vdev->index);
2030                 err = portdev->chr_major;
2031                 goto free;
2032         }
2033
2034         multiport = false;
2035         portdev->max_nr_ports = 1;
2036
2037         /* Don't test MULTIPORT at all if we're rproc: not a valid feature! */
2038         if (!is_rproc_serial(vdev) &&
2039             virtio_cread_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT,
2040                                  struct virtio_console_config, max_nr_ports,
2041                                  &portdev->max_nr_ports) == 0) {
2042                 if (portdev->max_nr_ports == 0 ||
2043                     portdev->max_nr_ports > VIRTCONS_MAX_PORTS) {
2044                         dev_err(&vdev->dev,
2045                                 "Invalidate max_nr_ports %d",
2046                                 portdev->max_nr_ports);
2047                         err = -EINVAL;
2048                         goto free;
2049                 }
2050                 multiport = true;
2051         }
2052
2053         err = init_vqs(portdev);
2054         if (err < 0) {
2055                 dev_err(&vdev->dev, "Error %d initializing vqs\n", err);
2056                 goto free_chrdev;
2057         }
2058
2059         spin_lock_init(&portdev->ports_lock);
2060         INIT_LIST_HEAD(&portdev->ports);
2061         INIT_LIST_HEAD(&portdev->list);
2062
2063         virtio_device_ready(portdev->vdev);
2064
2065         INIT_WORK(&portdev->config_work, &config_work_handler);
2066         INIT_WORK(&portdev->control_work, &control_work_handler);
2067
2068         if (multiport) {
2069                 spin_lock_init(&portdev->c_ivq_lock);
2070                 spin_lock_init(&portdev->c_ovq_lock);
2071
2072                 err = fill_queue(portdev->c_ivq, &portdev->c_ivq_lock);
2073                 if (err < 0) {
2074                         dev_err(&vdev->dev,
2075                                 "Error allocating buffers for control queue\n");
2076                         /*
2077                          * The host might want to notify mgmt sw about device
2078                          * add failure.
2079                          */
2080                         __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2081                                            VIRTIO_CONSOLE_DEVICE_READY, 0);
2082                         /* Device was functional: we need full cleanup. */
2083                         virtcons_remove(vdev);
2084                         return err;
2085                 }
2086         } else {
2087                 /*
2088                  * For backward compatibility: Create a console port
2089                  * if we're running on older host.
2090                  */
2091                 add_port(portdev, 0);
2092         }
2093
2094         spin_lock_irq(&pdrvdata_lock);
2095         list_add_tail(&portdev->list, &pdrvdata.portdevs);
2096         spin_unlock_irq(&pdrvdata_lock);
2097
2098         __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2099                            VIRTIO_CONSOLE_DEVICE_READY, 1);
2100
2101         /*
2102          * If there was an early virtio console, assume that there are no
2103          * other consoles. We need to wait until the hvc_alloc matches the
2104          * hvc_instantiate, otherwise tty_open will complain, resulting in
2105          * a "Warning: unable to open an initial console" boot failure.
2106          * Without multiport this is done in add_port above. With multiport
2107          * this might take some host<->guest communication - thus we have to
2108          * wait.
2109          */
2110         if (multiport && early)
2111                 wait_for_completion(&early_console_added);
2112
2113         return 0;
2114
2115 free_chrdev:
2116         unregister_chrdev(portdev->chr_major, "virtio-portsdev");
2117 free:
2118         kfree(portdev);
2119 fail:
2120         return err;
2121 }
2122
2123 static const struct virtio_device_id id_table[] = {
2124         { VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID },
2125         { 0 },
2126 };
2127 MODULE_DEVICE_TABLE(virtio, id_table);
2128
2129 static const unsigned int features[] = {
2130         VIRTIO_CONSOLE_F_SIZE,
2131         VIRTIO_CONSOLE_F_MULTIPORT,
2132 };
2133
2134 static const struct virtio_device_id rproc_serial_id_table[] = {
2135 #if IS_ENABLED(CONFIG_REMOTEPROC)
2136         { VIRTIO_ID_RPROC_SERIAL, VIRTIO_DEV_ANY_ID },
2137 #endif
2138         { 0 },
2139 };
2140 MODULE_DEVICE_TABLE(virtio, rproc_serial_id_table);
2141
2142 static const unsigned int rproc_serial_features[] = {
2143 };
2144
2145 #ifdef CONFIG_PM_SLEEP
2146 static int virtcons_freeze(struct virtio_device *vdev)
2147 {
2148         struct ports_device *portdev;
2149         struct port *port;
2150
2151         portdev = vdev->priv;
2152
2153         virtio_reset_device(vdev);
2154
2155         if (use_multiport(portdev))
2156                 virtqueue_disable_cb(portdev->c_ivq);
2157         cancel_work_sync(&portdev->control_work);
2158         cancel_work_sync(&portdev->config_work);
2159         /*
2160          * Once more: if control_work_handler() was running, it would
2161          * enable the cb as the last step.
2162          */
2163         if (use_multiport(portdev))
2164                 virtqueue_disable_cb(portdev->c_ivq);
2165
2166         list_for_each_entry(port, &portdev->ports, list) {
2167                 virtqueue_disable_cb(port->in_vq);
2168                 virtqueue_disable_cb(port->out_vq);
2169                 /*
2170                  * We'll ask the host later if the new invocation has
2171                  * the port opened or closed.
2172                  */
2173                 port->host_connected = false;
2174                 remove_port_data(port);
2175         }
2176         remove_vqs(portdev);
2177
2178         return 0;
2179 }
2180
2181 static int virtcons_restore(struct virtio_device *vdev)
2182 {
2183         struct ports_device *portdev;
2184         struct port *port;
2185         int ret;
2186
2187         portdev = vdev->priv;
2188
2189         ret = init_vqs(portdev);
2190         if (ret)
2191                 return ret;
2192
2193         virtio_device_ready(portdev->vdev);
2194
2195         if (use_multiport(portdev))
2196                 fill_queue(portdev->c_ivq, &portdev->c_ivq_lock);
2197
2198         list_for_each_entry(port, &portdev->ports, list) {
2199                 port->in_vq = portdev->in_vqs[port->id];
2200                 port->out_vq = portdev->out_vqs[port->id];
2201
2202                 fill_queue(port->in_vq, &port->inbuf_lock);
2203
2204                 /* Get port open/close status on the host */
2205                 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
2206
2207                 /*
2208                  * If a port was open at the time of suspending, we
2209                  * have to let the host know that it's still open.
2210                  */
2211                 if (port->guest_connected)
2212                         send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
2213         }
2214         return 0;
2215 }
2216 #endif
2217
2218 static struct virtio_driver virtio_console = {
2219         .feature_table = features,
2220         .feature_table_size = ARRAY_SIZE(features),
2221         .driver.name =  KBUILD_MODNAME,
2222         .driver.owner = THIS_MODULE,
2223         .id_table =     id_table,
2224         .probe =        virtcons_probe,
2225         .remove =       virtcons_remove,
2226         .config_changed = config_intr,
2227 #ifdef CONFIG_PM_SLEEP
2228         .freeze =       virtcons_freeze,
2229         .restore =      virtcons_restore,
2230 #endif
2231 };
2232
2233 static struct virtio_driver virtio_rproc_serial = {
2234         .feature_table = rproc_serial_features,
2235         .feature_table_size = ARRAY_SIZE(rproc_serial_features),
2236         .driver.name =  "virtio_rproc_serial",
2237         .driver.owner = THIS_MODULE,
2238         .id_table =     rproc_serial_id_table,
2239         .probe =        virtcons_probe,
2240         .remove =       virtcons_remove,
2241 };
2242
2243 static int __init virtio_console_init(void)
2244 {
2245         int err;
2246
2247         pdrvdata.class = class_create("virtio-ports");
2248         if (IS_ERR(pdrvdata.class)) {
2249                 err = PTR_ERR(pdrvdata.class);
2250                 pr_err("Error %d creating virtio-ports class\n", err);
2251                 return err;
2252         }
2253
2254         pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL);
2255         INIT_LIST_HEAD(&pdrvdata.consoles);
2256         INIT_LIST_HEAD(&pdrvdata.portdevs);
2257
2258         err = register_virtio_driver(&virtio_console);
2259         if (err < 0) {
2260                 pr_err("Error %d registering virtio driver\n", err);
2261                 goto free;
2262         }
2263         err = register_virtio_driver(&virtio_rproc_serial);
2264         if (err < 0) {
2265                 pr_err("Error %d registering virtio rproc serial driver\n",
2266                        err);
2267                 goto unregister;
2268         }
2269         return 0;
2270 unregister:
2271         unregister_virtio_driver(&virtio_console);
2272 free:
2273         debugfs_remove_recursive(pdrvdata.debugfs_dir);
2274         class_destroy(pdrvdata.class);
2275         return err;
2276 }
2277
2278 static void __exit virtio_console_fini(void)
2279 {
2280         reclaim_dma_bufs();
2281
2282         unregister_virtio_driver(&virtio_console);
2283         unregister_virtio_driver(&virtio_rproc_serial);
2284
2285         class_destroy(pdrvdata.class);
2286         debugfs_remove_recursive(pdrvdata.debugfs_dir);
2287 }
2288 module_init(virtio_console_init);
2289 module_exit(virtio_console_fini);
2290
2291 MODULE_DESCRIPTION("Virtio console driver");
2292 MODULE_LICENSE("GPL");