drivers/char/virtio_console.c

   1 /*
   2  * Copyright (C) 2006, 2007, 2009 Rusty Russell, IBM Corporation
   3  * Copyright (C) 2009, 2010 Red Hat, Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19 #include <linux/cdev.h>
  20 #include <linux/debugfs.h>
  21 #include <linux/device.h>
  22 #include <linux/err.h>
  23 #include <linux/fs.h>
  24 #include <linux/init.h>
  25 #include <linux/list.h>
  26 #include <linux/poll.h>
  27 #include <linux/sched.h>
  28 #include <linux/spinlock.h>
  29 #include <linux/virtio.h>
  30 #include <linux/virtio_console.h>
  31 #include <linux/wait.h>
  32 #include <linux/workqueue.h>
  33 #include "hvc_console.h"
  34
  35 /*
  36  * This is a global struct for storing common data for all the devices
  37  * this driver handles.
  38  *
  39  * Mainly, it has a linked list for all the consoles in one place so
  40  * that callbacks from hvc for get_chars(), put_chars() work properly
  41  * across multiple devices and multiple ports per device.
  42  */
  43 struct ports_driver_data {
  44         /* Used for registering chardevs */
  45         struct class *class;
  46
  47         /* Used for exporting per-port information to debugfs */
  48         struct dentry *debugfs_dir;
  49
  50         /* Number of devices this driver is handling */
  51         unsigned int index;
  52
  53         /*
  54          * This is used to keep track of the number of hvc consoles
  55          * spawned by this driver.  This number is given as the first
  56          * argument to hvc_alloc().  To correctly map an initial
  57          * console spawned via hvc_instantiate to the console being
  58          * hooked up via hvc_alloc, we need to pass the same vtermno.
  59          *
  60          * We also just assume the first console being initialised was
  61          * the first one that got used as the initial console.
  62          */
  63         unsigned int next_vtermno;
  64
  65         /* All the console devices handled by this driver */
  66         struct list_head consoles;
  67 };
  68 static struct ports_driver_data pdrvdata;
  69
  70 DEFINE_SPINLOCK(pdrvdata_lock);
  71
  72 /* This struct holds information that's relevant only for console ports */
  73 struct console {
  74         /* We'll place all consoles in a list in the pdrvdata struct */
  75         struct list_head list;
  76
  77         /* The hvc device associated with this console port */
  78         struct hvc_struct *hvc;
  79
  80         /*
  81          * This number identifies the number that we used to register
  82          * with hvc in hvc_instantiate() and hvc_alloc(); this is the
  83          * number passed on by the hvc callbacks to us to
  84          * differentiate between the other console ports handled by
  85          * this driver
  86          */
  87         u32 vtermno;
  88 };
  89
  90 struct port_buffer {
  91         char *buf;
  92
  93         /* size of the buffer in *buf above */
  94         size_t size;
  95
  96         /* used length of the buffer */
  97         size_t len;
  98         /* offset in the buf from which to consume data */
  99         size_t offset;
 100 };
 101
 102 /*
 103  * This is a per-device struct that stores data common to all the
 104  * ports for that device (vdev->priv).
 105  */
 106 struct ports_device {
 107         /*
 108          * Workqueue handlers where we process deferred work after
 109          * notification
 110          */
 111         struct work_struct control_work;
 112         struct work_struct config_work;
 113
 114         struct list_head ports;
 115
 116         /* To protect the list of ports */
 117         spinlock_t ports_lock;
 118
 119         /* To protect the vq operations for the control channel */
 120         spinlock_t cvq_lock;
 121
 122         /* The current config space is stored here */
 123         struct virtio_console_config config;
 124
 125         /* The virtio device we're associated with */
 126         struct virtio_device *vdev;
 127
 128         /*
 129          * A couple of virtqueues for the control channel: one for
 130          * guest->host transfers, one for host->guest transfers
 131          */
 132         struct virtqueue *c_ivq, *c_ovq;
 133
 134         /* Array of per-port IO virtqueues */
 135         struct virtqueue **in_vqs, **out_vqs;
 136
 137         /* Used for numbering devices for sysfs and debugfs */
 138         unsigned int drv_index;
 139
 140         /* Major number for this device.  Ports will be created as minors. */
 141         int chr_major;
 142 };
 143
 144 /* This struct holds the per-port data */
 145 struct port {
 146         /* Next port in the list, head is in the ports_device */
 147         struct list_head list;
 148
 149         /* Pointer to the parent virtio_console device */
 150         struct ports_device *portdev;
 151
 152         /* The current buffer from which data has to be fed to readers */
 153         struct port_buffer *inbuf;
 154
 155         /*
 156          * To protect the operations on the in_vq associated with this
 157          * port.  Has to be a spinlock because it can be called from
 158          * interrupt context (get_char()).
 159          */
 160         spinlock_t inbuf_lock;
 161
 162         /* The IO vqs for this port */
 163         struct virtqueue *in_vq, *out_vq;
 164
 165         /* File in the debugfs directory that exposes this port's information */
 166         struct dentry *debugfs_file;
 167
 168         /*
 169          * The entries in this struct will be valid if this port is
 170          * hooked up to an hvc console
 171          */
 172         struct console cons;
 173
 174         /* Each port associates with a separate char device */
 175         struct cdev cdev;
 176         struct device *dev;
 177
 178         /* A waitqueue for poll() or blocking read operations */
 179         wait_queue_head_t waitqueue;
 180
 181         /* The 'name' of the port that we expose via sysfs properties */
 182         char *name;
 183
 184         /* The 'id' to identify the port with the Host */
 185         u32 id;
 186
 187         /* Is the host device open */
 188         bool host_connected;
 189
 190         /* We should allow only one process to open a port */
 191         bool guest_connected;
 192 };
 193
 194 /* This is the very early arch-specified put chars function. */
 195 static int (*early_put_chars)(u32, const char *, int);
 196
 197 static struct port *find_port_by_vtermno(u32 vtermno)
 198 {
 199         struct port *port;
 200         struct console *cons;
 201         unsigned long flags;
 202
 203         spin_lock_irqsave(&pdrvdata_lock, flags);
 204         list_for_each_entry(cons, &pdrvdata.consoles, list) {
 205                 if (cons->vtermno == vtermno) {
 206                         port = container_of(cons, struct port, cons);
 207                         goto out;
 208                 }
 209         }
 210         port = NULL;
 211 out:
 212         spin_unlock_irqrestore(&pdrvdata_lock, flags);
 213         return port;
 214 }
 215
 216 static struct port *find_port_by_id(struct ports_device *portdev, u32 id)
 217 {
 218         struct port *port;
 219         unsigned long flags;
 220
 221         spin_lock_irqsave(&portdev->ports_lock, flags);
 222         list_for_each_entry(port, &portdev->ports, list)
 223                 if (port->id == id)
 224                         goto out;
 225         port = NULL;
 226 out:
 227         spin_unlock_irqrestore(&portdev->ports_lock, flags);
 228
 229         return port;
 230 }
 231
 232 static struct port *find_port_by_vq(struct ports_device *portdev,
 233                                     struct virtqueue *vq)
 234 {
 235         struct port *port;
 236         unsigned long flags;
 237
 238         spin_lock_irqsave(&portdev->ports_lock, flags);
 239         list_for_each_entry(port, &portdev->ports, list)
 240                 if (port->in_vq == vq || port->out_vq == vq)
 241                         goto out;
 242         port = NULL;
 243 out:
 244         spin_unlock_irqrestore(&portdev->ports_lock, flags);
 245         return port;
 246 }
 247
 248 static bool is_console_port(struct port *port)
 249 {
 250         if (port->cons.hvc)
 251                 return true;
 252         return false;
 253 }
 254
 255 static inline bool use_multiport(struct ports_device *portdev)
 256 {
 257         /*
 258          * This condition can be true when put_chars is called from
 259          * early_init
 260          */
 261         if (!portdev->vdev)
 262                 return 0;
 263         return portdev->vdev->features[0] & (1 << VIRTIO_CONSOLE_F_MULTIPORT);
 264 }
 265
 266 static void free_buf(struct port_buffer *buf)
 267 {
 268         kfree(buf->buf);
 269         kfree(buf);
 270 }
 271
 272 static struct port_buffer *alloc_buf(size_t buf_size)
 273 {
 274         struct port_buffer *buf;
 275
 276         buf = kmalloc(sizeof(*buf), GFP_KERNEL);
 277         if (!buf)
 278                 goto fail;
 279         buf->buf = kzalloc(buf_size, GFP_KERNEL);
 280         if (!buf->buf)
 281                 goto free_buf;
 282         buf->len = 0;
 283         buf->offset = 0;
 284         buf->size = buf_size;
 285         return buf;
 286
 287 free_buf:
 288         kfree(buf);
 289 fail:
 290         return NULL;
 291 }
 292
 293 /* Callers should take appropriate locks */
 294 static void *get_inbuf(struct port *port)
 295 {
 296         struct port_buffer *buf;
 297         struct virtqueue *vq;
 298         unsigned int len;
 299
 300         vq = port->in_vq;
 301         buf = vq->vq_ops->get_buf(vq, &len);
 302         if (buf) {
 303                 buf->len = len;
 304                 buf->offset = 0;
 305         }
 306         return buf;
 307 }
 308
 309 /*
 310  * Create a scatter-gather list representing our input buffer and put
 311  * it in the queue.
 312  *
 313  * Callers should take appropriate locks.
 314  */
 315 static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)
 316 {
 317         struct scatterlist sg[1];
 318         int ret;
 319
 320         sg_init_one(sg, buf->buf, buf->size);
 321
 322         ret = vq->vq_ops->add_buf(vq, sg, 0, 1, buf);
 323         vq->vq_ops->kick(vq);
 324         return ret;
 325 }
 326
 327 /* Discard any unread data this port has. Callers lockers. */
 328 static void discard_port_data(struct port *port)
 329 {
 330         struct port_buffer *buf;
 331         struct virtqueue *vq;
 332         unsigned int len;
 333
 334         vq = port->in_vq;
 335         if (port->inbuf)
 336                 buf = port->inbuf;
 337         else
 338                 buf = vq->vq_ops->get_buf(vq, &len);
 339
 340         if (!buf)
 341                 return;
 342
 343         if (add_inbuf(vq, buf) < 0) {
 344                 buf->len = buf->offset = 0;
 345                 dev_warn(port->dev, "Error adding buffer back to vq\n");
 346                 return;
 347         }
 348
 349         port->inbuf = NULL;
 350 }
 351
 352 static bool port_has_data(struct port *port)
 353 {
 354         unsigned long flags;
 355         bool ret;
 356
 357         ret = false;
 358         spin_lock_irqsave(&port->inbuf_lock, flags);
 359         if (port->inbuf)
 360                 ret = true;
 361         spin_unlock_irqrestore(&port->inbuf_lock, flags);
 362
 363         return ret;
 364 }
 365
 366 static ssize_t send_control_msg(struct port *port, unsigned int event,
 367                                 unsigned int value)
 368 {
 369         struct scatterlist sg[1];
 370         struct virtio_console_control cpkt;
 371         struct virtqueue *vq;
 372         int len;
 373
 374         if (!use_multiport(port->portdev))
 375                 return 0;
 376
 377         cpkt.id = port->id;
 378         cpkt.event = event;
 379         cpkt.value = value;
 380
 381         vq = port->portdev->c_ovq;
 382
 383         sg_init_one(sg, &cpkt, sizeof(cpkt));
 384         if (vq->vq_ops->add_buf(vq, sg, 1, 0, &cpkt) >= 0) {
 385                 vq->vq_ops->kick(vq);
 386                 while (!vq->vq_ops->get_buf(vq, &len))
 387                         cpu_relax();
 388         }
 389         return 0;
 390 }
 391
 392 static ssize_t send_buf(struct port *port, void *in_buf, size_t in_count)
 393 {
 394         struct scatterlist sg[1];
 395         struct virtqueue *out_vq;
 396         ssize_t ret;
 397         unsigned int len;
 398
 399         out_vq = port->out_vq;
 400
 401         sg_init_one(sg, in_buf, in_count);
 402         ret = out_vq->vq_ops->add_buf(out_vq, sg, 1, 0, in_buf);
 403
 404         /* Tell Host to go! */
 405         out_vq->vq_ops->kick(out_vq);
 406
 407         if (ret < 0) {
 408                 len = 0;
 409                 goto fail;
 410         }
 411
 412         /*
 413          * Wait till the host acknowledges it pushed out the data we
 414          * sent. Also ensure we return to userspace the number of
 415          * bytes that were successfully consumed by the host.
 416          */
 417         while (!out_vq->vq_ops->get_buf(out_vq, &len))
 418                 cpu_relax();
 419 fail:
 420         /* We're expected to return the amount of data we wrote */
 421         return len;
 422 }
 423
 424 /*
 425  * Give out the data that's requested from the buffer that we have
 426  * queued up.
 427  */
 428 static ssize_t fill_readbuf(struct port *port, char *out_buf, size_t out_count,
 429                             bool to_user)
 430 {
 431         struct port_buffer *buf;
 432         unsigned long flags;
 433
 434         if (!out_count || !port_has_data(port))
 435                 return 0;
 436
 437         buf = port->inbuf;
 438         out_count = min(out_count, buf->len - buf->offset);
 439
 440         if (to_user) {
 441                 ssize_t ret;
 442
 443                 ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count);
 444                 if (ret)
 445                         return -EFAULT;
 446         } else {
 447                 memcpy(out_buf, buf->buf + buf->offset, out_count);
 448         }
 449
 450         buf->offset += out_count;
 451
 452         if (buf->offset == buf->len) {
 453                 /*
 454                  * We're done using all the data in this buffer.
 455                  * Re-queue so that the Host can send us more data.
 456                  */
 457                 spin_lock_irqsave(&port->inbuf_lock, flags);
 458                 port->inbuf = NULL;
 459
 460                 if (add_inbuf(port->in_vq, buf) < 0)
 461                         dev_warn(port->dev, "failed add_buf\n");
 462
 463                 spin_unlock_irqrestore(&port->inbuf_lock, flags);
 464         }
 465         /* Return the number of bytes actually copied */
 466         return out_count;
 467 }
 468
 469 /* The condition that must be true for polling to end */
 470 static bool wait_is_over(struct port *port)
 471 {
 472         return port_has_data(port) || !port->host_connected;
 473 }
 474
 475 static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
 476                               size_t count, loff_t *offp)
 477 {
 478         struct port *port;
 479         ssize_t ret;
 480
 481         port = filp->private_data;
 482
 483         if (!port_has_data(port)) {
 484                 /*
 485                  * If nothing's connected on the host just return 0 in
 486                  * case of list_empty; this tells the userspace app
 487                  * that there's no connection
 488                  */
 489                 if (!port->host_connected)
 490                         return 0;
 491                 if (filp->f_flags & O_NONBLOCK)
 492                         return -EAGAIN;
 493
 494                 ret = wait_event_interruptible(port->waitqueue,
 495                                                wait_is_over(port));
 496                 if (ret < 0)
 497                         return ret;
 498         }
 499         /*
 500          * We could've received a disconnection message while we were
 501          * waiting for more data.
 502          *
 503          * This check is not clubbed in the if() statement above as we
 504          * might receive some data as well as the host could get
 505          * disconnected after we got woken up from our wait.  So we
 506          * really want to give off whatever data we have and only then
 507          * check for host_connected.
 508          */
 509         if (!port_has_data(port) && !port->host_connected)
 510                 return 0;
 511
 512         return fill_readbuf(port, ubuf, count, true);
 513 }
 514
 515 static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
 516                                size_t count, loff_t *offp)
 517 {
 518         struct port *port;
 519         char *buf;
 520         ssize_t ret;
 521
 522         port = filp->private_data;
 523
 524         count = min((size_t)(32 * 1024), count);
 525
 526         buf = kmalloc(count, GFP_KERNEL);
 527         if (!buf)
 528                 return -ENOMEM;
 529
 530         ret = copy_from_user(buf, ubuf, count);
 531         if (ret) {
 532                 ret = -EFAULT;
 533                 goto free_buf;
 534         }
 535
 536         ret = send_buf(port, buf, count);
 537 free_buf:
 538         kfree(buf);
 539         return ret;
 540 }
 541
 542 static unsigned int port_fops_poll(struct file *filp, poll_table *wait)
 543 {
 544         struct port *port;
 545         unsigned int ret;
 546
 547         port = filp->private_data;
 548         poll_wait(filp, &port->waitqueue, wait);
 549
 550         ret = 0;
 551         if (port->inbuf)
 552                 ret |= POLLIN | POLLRDNORM;
 553         if (port->host_connected)
 554                 ret |= POLLOUT;
 555         if (!port->host_connected)
 556                 ret |= POLLHUP;
 557
 558         return ret;
 559 }
 560
 561 static int port_fops_release(struct inode *inode, struct file *filp)
 562 {
 563         struct port *port;
 564
 565         port = filp->private_data;
 566
 567         /* Notify host of port being closed */
 568         send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
 569
 570         spin_lock_irq(&port->inbuf_lock);
 571         port->guest_connected = false;
 572
 573         discard_port_data(port);
 574
 575         spin_unlock_irq(&port->inbuf_lock);
 576
 577         return 0;
 578 }
 579
 580 static int port_fops_open(struct inode *inode, struct file *filp)
 581 {
 582         struct cdev *cdev = inode->i_cdev;
 583         struct port *port;
 584
 585         port = container_of(cdev, struct port, cdev);
 586         filp->private_data = port;
 587
 588         /*
 589          * Don't allow opening of console port devices -- that's done
 590          * via /dev/hvc
 591          */
 592         if (is_console_port(port))
 593                 return -ENXIO;
 594
 595         /* Allow only one process to open a particular port at a time */
 596         spin_lock_irq(&port->inbuf_lock);
 597         if (port->guest_connected) {
 598                 spin_unlock_irq(&port->inbuf_lock);
 599                 return -EMFILE;
 600         }
 601
 602         port->guest_connected = true;
 603         spin_unlock_irq(&port->inbuf_lock);
 604
 605         /* Notify host of port being opened */
 606         send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1);
 607
 608         return 0;
 609 }
 610
 611 /*
 612  * The file operations that we support: programs in the guest can open
 613  * a console device, read from it, write to it, poll for data and
 614  * close it.  The devices are at
 615  *   /dev/vport<device number>p<port number>
 616  */
 617 static const struct file_operations port_fops = {
 618         .owner = THIS_MODULE,
 619         .open  = port_fops_open,
 620         .read  = port_fops_read,
 621         .write = port_fops_write,
 622         .poll  = port_fops_poll,
 623         .release = port_fops_release,
 624 };
 625
 626 /*
 627  * The put_chars() callback is pretty straightforward.
 628  *
 629  * We turn the characters into a scatter-gather list, add it to the
 630  * output queue and then kick the Host.  Then we sit here waiting for
 631  * it to finish: inefficient in theory, but in practice
 632  * implementations will do it immediately (lguest's Launcher does).
 633  */
 634 static int put_chars(u32 vtermno, const char *buf, int count)
 635 {
 636         struct port *port;
 637
 638         port = find_port_by_vtermno(vtermno);
 639         if (!port)
 640                 return 0;
 641
 642         if (unlikely(early_put_chars))
 643                 return early_put_chars(vtermno, buf, count);
 644
 645         return send_buf(port, (void *)buf, count);
 646 }
 647
 648 /*
 649  * get_chars() is the callback from the hvc_console infrastructure
 650  * when an interrupt is received.
 651  *
 652  * We call out to fill_readbuf that gets us the required data from the
 653  * buffers that are queued up.
 654  */
 655 static int get_chars(u32 vtermno, char *buf, int count)
 656 {
 657         struct port *port;
 658
 659         port = find_port_by_vtermno(vtermno);
 660         if (!port)
 661                 return 0;
 662
 663         /* If we don't have an input queue yet, we can't get input. */
 664         BUG_ON(!port->in_vq);
 665
 666         return fill_readbuf(port, buf, count, false);
 667 }
 668
 669 static void resize_console(struct port *port)
 670 {
 671         struct virtio_device *vdev;
 672         struct winsize ws;
 673
 674         vdev = port->portdev->vdev;
 675         if (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE)) {
 676                 vdev->config->get(vdev,
 677                                   offsetof(struct virtio_console_config, cols),
 678                                   &ws.ws_col, sizeof(u16));
 679                 vdev->config->get(vdev,
 680                                   offsetof(struct virtio_console_config, rows),
 681                                   &ws.ws_row, sizeof(u16));
 682                 hvc_resize(port->cons.hvc, ws);
 683         }
 684 }
 685
 686 /* We set the configuration at this point, since we now have a tty */
 687 static int notifier_add_vio(struct hvc_struct *hp, int data)
 688 {
 689         struct port *port;
 690
 691         port = find_port_by_vtermno(hp->vtermno);
 692         if (!port)
 693                 return -EINVAL;
 694
 695         hp->irq_requested = 1;
 696         resize_console(port);
 697
 698         return 0;
 699 }
 700
 701 static void notifier_del_vio(struct hvc_struct *hp, int data)
 702 {
 703         hp->irq_requested = 0;
 704 }
 705
 706 /* The operations for console ports. */
 707 static const struct hv_ops hv_ops = {
 708         .get_chars = get_chars,
 709         .put_chars = put_chars,
 710         .notifier_add = notifier_add_vio,
 711         .notifier_del = notifier_del_vio,
 712         .notifier_hangup = notifier_del_vio,
 713 };
 714
 715 /*
 716  * Console drivers are initialized very early so boot messages can go
 717  * out, so we do things slightly differently from the generic virtio
 718  * initialization of the net and block drivers.
 719  *
 720  * At this stage, the console is output-only.  It's too early to set
 721  * up a virtqueue, so we let the drivers do some boutique early-output
 722  * thing.
 723  */
 724 int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int))
 725 {
 726         early_put_chars = put_chars;
 727         return hvc_instantiate(0, 0, &hv_ops);
 728 }
 729
 730 int init_port_console(struct port *port)
 731 {
 732         int ret;
 733
 734         /*
 735          * The Host's telling us this port is a console port.  Hook it
 736          * up with an hvc console.
 737          *
 738          * To set up and manage our virtual console, we call
 739          * hvc_alloc().
 740          *
 741          * The first argument of hvc_alloc() is the virtual console
 742          * number.  The second argument is the parameter for the
 743          * notification mechanism (like irq number).  We currently
 744          * leave this as zero, virtqueues have implicit notifications.
 745          *
 746          * The third argument is a "struct hv_ops" containing the
 747          * put_chars() get_chars(), notifier_add() and notifier_del()
 748          * pointers.  The final argument is the output buffer size: we
 749          * can do any size, so we put PAGE_SIZE here.
 750          */
 751         port->cons.vtermno = pdrvdata.next_vtermno;
 752
 753         port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE);
 754         if (IS_ERR(port->cons.hvc)) {
 755                 ret = PTR_ERR(port->cons.hvc);
 756                 dev_err(port->dev,
 757                         "error %d allocating hvc for port\n", ret);
 758                 port->cons.hvc = NULL;
 759                 return ret;
 760         }
 761         spin_lock_irq(&pdrvdata_lock);
 762         pdrvdata.next_vtermno++;
 763         list_add_tail(&port->cons.list, &pdrvdata.consoles);
 764         spin_unlock_irq(&pdrvdata_lock);
 765         port->guest_connected = true;
 766
 767         /* Notify host of port being opened */
 768         send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
 769
 770         return 0;
 771 }
 772
 773 static ssize_t show_port_name(struct device *dev,
 774                               struct device_attribute *attr, char *buffer)
 775 {
 776         struct port *port;
 777
 778         port = dev_get_drvdata(dev);
 779
 780         return sprintf(buffer, "%s\n", port->name);
 781 }
 782
 783 static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL);
 784
 785 static struct attribute *port_sysfs_entries[] = {
 786         &dev_attr_name.attr,
 787         NULL
 788 };
 789
 790 static struct attribute_group port_attribute_group = {
 791         .name = NULL,           /* put in device directory */
 792         .attrs = port_sysfs_entries,
 793 };
 794
 795 static int debugfs_open(struct inode *inode, struct file *filp)
 796 {
 797         filp->private_data = inode->i_private;
 798         return 0;
 799 }
 800
 801 static ssize_t debugfs_read(struct file *filp, char __user *ubuf,
 802                             size_t count, loff_t *offp)
 803 {
 804         struct port *port;
 805         char *buf;
 806         ssize_t ret, out_offset, out_count;
 807
 808         out_count = 1024;
 809         buf = kmalloc(out_count, GFP_KERNEL);
 810         if (!buf)
 811                 return -ENOMEM;
 812
 813         port = filp->private_data;
 814         out_offset = 0;
 815         out_offset += snprintf(buf + out_offset, out_count,
 816                                "name: %s\n", port->name ? port->name : "");
 817         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 818                                "guest_connected: %d\n", port->guest_connected);
 819         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 820                                "host_connected: %d\n", port->host_connected);
 821         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 822                                "is_console: %s\n",
 823                                is_console_port(port) ? "yes" : "no");
 824         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 825                                "console_vtermno: %u\n", port->cons.vtermno);
 826
 827         ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset);
 828         kfree(buf);
 829         return ret;
 830 }
 831
 832 static const struct file_operations port_debugfs_ops = {
 833         .owner = THIS_MODULE,
 834         .open  = debugfs_open,
 835         .read  = debugfs_read,
 836 };
 837
 838 /* Remove all port-specific data. */
 839 static int remove_port(struct port *port)
 840 {
 841         struct port_buffer *buf;
 842
 843         spin_lock_irq(&port->portdev->ports_lock);
 844         list_del(&port->list);
 845         spin_unlock_irq(&port->portdev->ports_lock);
 846
 847         if (is_console_port(port)) {
 848                 spin_lock_irq(&pdrvdata_lock);
 849                 list_del(&port->cons.list);
 850                 spin_unlock_irq(&pdrvdata_lock);
 851                 hvc_remove(port->cons.hvc);
 852         }
 853         if (port->guest_connected)
 854                 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
 855
 856         sysfs_remove_group(&port->dev->kobj, &port_attribute_group);
 857         device_destroy(pdrvdata.class, port->dev->devt);
 858         cdev_del(&port->cdev);
 859
 860         /* Remove unused data this port might have received. */
 861         discard_port_data(port);
 862
 863         /* Remove buffers we queued up for the Host to send us data in. */
 864         while ((buf = port->in_vq->vq_ops->detach_unused_buf(port->in_vq)))
 865                 free_buf(buf);
 866
 867         kfree(port->name);
 868
 869         debugfs_remove(port->debugfs_file);
 870
 871         kfree(port);
 872         return 0;
 873 }
 874
 875 /* Any private messages that the Host and Guest want to share */
 876 static void handle_control_message(struct ports_device *portdev,
 877                                    struct port_buffer *buf)
 878 {
 879         struct virtio_console_control *cpkt;
 880         struct port *port;
 881         size_t name_size;
 882         int err;
 883
 884         cpkt = (struct virtio_console_control *)(buf->buf + buf->offset);
 885
 886         port = find_port_by_id(portdev, cpkt->id);
 887         if (!port) {
 888                 /* No valid header at start of buffer.  Drop it. */
 889                 dev_dbg(&portdev->vdev->dev,
 890                         "Invalid index %u in control packet\n", cpkt->id);
 891                 return;
 892         }
 893
 894         switch (cpkt->event) {
 895         case VIRTIO_CONSOLE_CONSOLE_PORT:
 896                 if (!cpkt->value)
 897                         break;
 898                 if (is_console_port(port))
 899                         break;
 900
 901                 init_port_console(port);
 902                 /*
 903                  * Could remove the port here in case init fails - but
 904                  * have to notify the host first.
 905                  */
 906                 break;
 907         case VIRTIO_CONSOLE_RESIZE:
 908                 if (!is_console_port(port))
 909                         break;
 910                 port->cons.hvc->irq_requested = 1;
 911                 resize_console(port);
 912                 break;
 913         case VIRTIO_CONSOLE_PORT_OPEN:
 914                 port->host_connected = cpkt->value;
 915                 wake_up_interruptible(&port->waitqueue);
 916                 break;
 917         case VIRTIO_CONSOLE_PORT_NAME:
 918                 /*
 919                  * Skip the size of the header and the cpkt to get the size
 920                  * of the name that was sent
 921                  */
 922                 name_size = buf->len - buf->offset - sizeof(*cpkt) + 1;
 923
 924                 port->name = kmalloc(name_size, GFP_KERNEL);
 925                 if (!port->name) {
 926                         dev_err(port->dev,
 927                                 "Not enough space to store port name\n");
 928                         break;
 929                 }
 930                 strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt),
 931                         name_size - 1);
 932                 port->name[name_size - 1] = 0;
 933
 934                 /*
 935                  * Since we only have one sysfs attribute, 'name',
 936                  * create it only if we have a name for the port.
 937                  */
 938                 err = sysfs_create_group(&port->dev->kobj,
 939                                          &port_attribute_group);
 940                 if (err)
 941                         dev_err(port->dev,
 942                                 "Error %d creating sysfs device attributes\n",
 943                                 err);
 944
 945                 break;
 946         case VIRTIO_CONSOLE_PORT_REMOVE:
 947                 /*
 948                  * Hot unplug the port.  We don't decrement nr_ports
 949                  * since we don't want to deal with extra complexities
 950                  * of using the lowest-available port id: We can just
 951                  * pick up the nr_ports number as the id and not have
 952                  * userspace send it to us.  This helps us in two
 953                  * ways:
 954                  *
 955                  * - We don't need to have a 'port_id' field in the
 956                  *   config space when a port is hot-added.  This is a
 957                  *   good thing as we might queue up multiple hotplug
 958                  *   requests issued in our workqueue.
 959                  *
 960                  * - Another way to deal with this would have been to
 961                  *   use a bitmap of the active ports and select the
 962                  *   lowest non-active port from that map.  That
 963                  *   bloats the already tight config space and we
 964                  *   would end up artificially limiting the
 965                  *   max. number of ports to sizeof(bitmap).  Right
 966                  *   now we can support 2^32 ports (as the port id is
 967                  *   stored in a u32 type).
 968                  *
 969                  */
 970                 remove_port(port);
 971                 break;
 972         }
 973 }
 974
 975 static void control_work_handler(struct work_struct *work)
 976 {
 977         struct ports_device *portdev;
 978         struct virtqueue *vq;
 979         struct port_buffer *buf;
 980         unsigned int len;
 981
 982         portdev = container_of(work, struct ports_device, control_work);
 983         vq = portdev->c_ivq;
 984
 985         spin_lock(&portdev->cvq_lock);
 986         while ((buf = vq->vq_ops->get_buf(vq, &len))) {
 987                 spin_unlock(&portdev->cvq_lock);
 988
 989                 buf->len = len;
 990                 buf->offset = 0;
 991
 992                 handle_control_message(portdev, buf);
 993
 994                 spin_lock(&portdev->cvq_lock);
 995                 if (add_inbuf(portdev->c_ivq, buf) < 0) {
 996                         dev_warn(&portdev->vdev->dev,
 997                                  "Error adding buffer to queue\n");
 998                         free_buf(buf);
 999                 }
1000         }
1001         spin_unlock(&portdev->cvq_lock);
1002 }
1003
1004 static void in_intr(struct virtqueue *vq)
1005 {
1006         struct port *port;
1007         unsigned long flags;
1008
1009         port = find_port_by_vq(vq->vdev->priv, vq);
1010         if (!port)
1011                 return;
1012
1013         spin_lock_irqsave(&port->inbuf_lock, flags);
1014         port->inbuf = get_inbuf(port);
1015
1016         /*
1017          * Don't queue up data when port is closed.  This condition
1018          * can be reached when a console port is not yet connected (no
1019          * tty is spawned) and the host sends out data to console
1020          * ports.  For generic serial ports, the host won't
1021          * (shouldn't) send data till the guest is connected.
1022          */
1023         if (!port->guest_connected)
1024                 discard_port_data(port);
1025
1026         spin_unlock_irqrestore(&port->inbuf_lock, flags);
1027
1028         wake_up_interruptible(&port->waitqueue);
1029
1030         if (is_console_port(port) && hvc_poll(port->cons.hvc))
1031                 hvc_kick();
1032 }
1033
1034 static void control_intr(struct virtqueue *vq)
1035 {
1036         struct ports_device *portdev;
1037
1038         portdev = vq->vdev->priv;
1039         schedule_work(&portdev->control_work);
1040 }
1041
1042 static void config_intr(struct virtio_device *vdev)
1043 {
1044         struct ports_device *portdev;
1045
1046         portdev = vdev->priv;
1047         if (use_multiport(portdev)) {
1048                 /* Handle port hot-add */
1049                 schedule_work(&portdev->config_work);
1050         }
1051         /*
1052          * We'll use this way of resizing only for legacy support.
1053          * For newer userspace (VIRTIO_CONSOLE_F_MULTPORT+), use
1054          * control messages to indicate console size changes so that
1055          * it can be done per-port
1056          */
1057         resize_console(find_port_by_id(portdev, 0));
1058 }
1059
1060 static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock)
1061 {
1062         struct port_buffer *buf;
1063         unsigned int ret;
1064         int err;
1065
1066         ret = 0;
1067         do {
1068                 buf = alloc_buf(PAGE_SIZE);
1069                 if (!buf)
1070                         break;
1071
1072                 spin_lock_irq(lock);
1073                 err = add_inbuf(vq, buf);
1074                 if (err < 0) {
1075                         spin_unlock_irq(lock);
1076                         free_buf(buf);
1077                         break;
1078                 }
1079                 ret++;
1080                 spin_unlock_irq(lock);
1081         } while (err > 0);
1082
1083         return ret;
1084 }
1085
1086 static int add_port(struct ports_device *portdev, u32 id)
1087 {
1088         char debugfs_name[16];
1089         struct port *port;
1090         struct port_buffer *inbuf;
1091         dev_t devt;
1092         int err;
1093
1094         port = kmalloc(sizeof(*port), GFP_KERNEL);
1095         if (!port) {
1096                 err = -ENOMEM;
1097                 goto fail;
1098         }
1099
1100         port->portdev = portdev;
1101         port->id = id;
1102
1103         port->name = NULL;
1104         port->inbuf = NULL;
1105         port->cons.hvc = NULL;
1106
1107         port->host_connected = port->guest_connected = false;
1108
1109         port->in_vq = portdev->in_vqs[port->id];
1110         port->out_vq = portdev->out_vqs[port->id];
1111
1112         cdev_init(&port->cdev, &port_fops);
1113
1114         devt = MKDEV(portdev->chr_major, id);
1115         err = cdev_add(&port->cdev, devt, 1);
1116         if (err < 0) {
1117                 dev_err(&port->portdev->vdev->dev,
1118                         "Error %d adding cdev for port %u\n", err, id);
1119                 goto free_port;
1120         }
1121         port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev,
1122                                   devt, port, "vport%up%u",
1123                                   port->portdev->drv_index, id);
1124         if (IS_ERR(port->dev)) {
1125                 err = PTR_ERR(port->dev);
1126                 dev_err(&port->portdev->vdev->dev,
1127                         "Error %d creating device for port %u\n",
1128                         err, id);
1129                 goto free_cdev;
1130         }
1131
1132         spin_lock_init(&port->inbuf_lock);
1133         init_waitqueue_head(&port->waitqueue);
1134
1135         inbuf = alloc_buf(PAGE_SIZE);
1136         if (!inbuf) {
1137                 err = -ENOMEM;
1138                 goto free_device;
1139         }
1140
1141         /* Register the input buffer the first time. */
1142         add_inbuf(port->in_vq, inbuf);
1143
1144         /*
1145          * If we're not using multiport support, this has to be a console port
1146          */
1147         if (!use_multiport(port->portdev)) {
1148                 err = init_port_console(port);
1149                 if (err)
1150                         goto free_inbuf;
1151         }
1152
1153         spin_lock_irq(&portdev->ports_lock);
1154         list_add_tail(&port->list, &port->portdev->ports);
1155         spin_unlock_irq(&portdev->ports_lock);
1156
1157         /*
1158          * Tell the Host we're set so that it can send us various
1159          * configuration parameters for this port (eg, port name,
1160          * caching, whether this is a console port, etc.)
1161          */
1162         send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1163
1164         if (pdrvdata.debugfs_dir) {
1165                 /*
1166                  * Finally, create the debugfs file that we can use to
1167                  * inspect a port's state at any time
1168                  */
1169                 sprintf(debugfs_name, "vport%up%u",
1170                         port->portdev->drv_index, id);
1171                 port->debugfs_file = debugfs_create_file(debugfs_name, 0444,
1172                                                          pdrvdata.debugfs_dir,
1173                                                          port,
1174                                                          &port_debugfs_ops);
1175         }
1176         return 0;
1177
1178 free_inbuf:
1179         free_buf(inbuf);
1180 free_device:
1181         device_destroy(pdrvdata.class, port->dev->devt);
1182 free_cdev:
1183         cdev_del(&port->cdev);
1184 free_port:
1185         kfree(port);
1186 fail:
1187         return err;
1188 }
1189
1190 /*
1191  * The workhandler for config-space updates.
1192  *
1193  * This is called when ports are hot-added.
1194  */
1195 static void config_work_handler(struct work_struct *work)
1196 {
1197         struct virtio_console_config virtconconf;
1198         struct ports_device *portdev;
1199         struct virtio_device *vdev;
1200         int err;
1201
1202         portdev = container_of(work, struct ports_device, config_work);
1203
1204         vdev = portdev->vdev;
1205         vdev->config->get(vdev,
1206                           offsetof(struct virtio_console_config, nr_ports),
1207                           &virtconconf.nr_ports,
1208                           sizeof(virtconconf.nr_ports));
1209
1210         if (portdev->config.nr_ports == virtconconf.nr_ports) {
1211                 /*
1212                  * Port 0 got hot-added.  Since we already did all the
1213                  * other initialisation for it, just tell the Host
1214                  * that the port is ready if we find the port.  In
1215                  * case the port was hot-removed earlier, we call
1216                  * add_port to add the port.
1217                  */
1218                 struct port *port;
1219
1220                 port = find_port_by_id(portdev, 0);
1221                 if (!port)
1222                         add_port(portdev, 0);
1223                 else
1224                         send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1225                 return;
1226         }
1227         if (virtconconf.nr_ports > portdev->config.max_nr_ports) {
1228                 dev_warn(&vdev->dev,
1229                          "More ports specified (%u) than allowed (%u)",
1230                          portdev->config.nr_ports + 1,
1231                          portdev->config.max_nr_ports);
1232                 return;
1233         }
1234         if (virtconconf.nr_ports < portdev->config.nr_ports)
1235                 return;
1236
1237         /* Hot-add ports */
1238         while (virtconconf.nr_ports - portdev->config.nr_ports) {
1239                 err = add_port(portdev, portdev->config.nr_ports);
1240                 if (err)
1241                         break;
1242                 portdev->config.nr_ports++;
1243         }
1244 }
1245
1246 static int init_vqs(struct ports_device *portdev)
1247 {
1248         vq_callback_t **io_callbacks;
1249         char **io_names;
1250         struct virtqueue **vqs;
1251         u32 i, j, nr_ports, nr_queues;
1252         int err;
1253
1254         nr_ports = portdev->config.max_nr_ports;
1255         nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2;
1256
1257         vqs = kmalloc(nr_queues * sizeof(struct virtqueue *), GFP_KERNEL);
1258         if (!vqs) {
1259                 err = -ENOMEM;
1260                 goto fail;
1261         }
1262         io_callbacks = kmalloc(nr_queues * sizeof(vq_callback_t *), GFP_KERNEL);
1263         if (!io_callbacks) {
1264                 err = -ENOMEM;
1265                 goto free_vqs;
1266         }
1267         io_names = kmalloc(nr_queues * sizeof(char *), GFP_KERNEL);
1268         if (!io_names) {
1269                 err = -ENOMEM;
1270                 goto free_callbacks;
1271         }
1272         portdev->in_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
1273                                   GFP_KERNEL);
1274         if (!portdev->in_vqs) {
1275                 err = -ENOMEM;
1276                 goto free_names;
1277         }
1278         portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
1279                                    GFP_KERNEL);
1280         if (!portdev->out_vqs) {
1281                 err = -ENOMEM;
1282                 goto free_invqs;
1283         }
1284
1285         /*
1286          * For backward compat (newer host but older guest), the host
1287          * spawns a console port first and also inits the vqs for port
1288          * 0 before others.
1289          */
1290         j = 0;
1291         io_callbacks[j] = in_intr;
1292         io_callbacks[j + 1] = NULL;
1293         io_names[j] = "input";
1294         io_names[j + 1] = "output";
1295         j += 2;
1296
1297         if (use_multiport(portdev)) {
1298                 io_callbacks[j] = control_intr;
1299                 io_callbacks[j + 1] = NULL;
1300                 io_names[j] = "control-i";
1301                 io_names[j + 1] = "control-o";
1302
1303                 for (i = 1; i < nr_ports; i++) {
1304                         j += 2;
1305                         io_callbacks[j] = in_intr;
1306                         io_callbacks[j + 1] = NULL;
1307                         io_names[j] = "input";
1308                         io_names[j + 1] = "output";
1309                 }
1310         }
1311         /* Find the queues. */
1312         err = portdev->vdev->config->find_vqs(portdev->vdev, nr_queues, vqs,
1313                                               io_callbacks,
1314                                               (const char **)io_names);
1315         if (err)
1316                 goto free_outvqs;
1317
1318         j = 0;
1319         portdev->in_vqs[0] = vqs[0];
1320         portdev->out_vqs[0] = vqs[1];
1321         j += 2;
1322         if (use_multiport(portdev)) {
1323                 portdev->c_ivq = vqs[j];
1324                 portdev->c_ovq = vqs[j + 1];
1325
1326                 for (i = 1; i < nr_ports; i++) {
1327                         j += 2;
1328                         portdev->in_vqs[i] = vqs[j];
1329                         portdev->out_vqs[i] = vqs[j + 1];
1330                 }
1331         }
1332         kfree(io_callbacks);
1333         kfree(io_names);
1334         kfree(vqs);
1335
1336         return 0;
1337
1338 free_names:
1339         kfree(io_names);
1340 free_callbacks:
1341         kfree(io_callbacks);
1342 free_outvqs:
1343         kfree(portdev->out_vqs);
1344 free_invqs:
1345         kfree(portdev->in_vqs);
1346 free_vqs:
1347         kfree(vqs);
1348 fail:
1349         return err;
1350 }
1351
1352 static const struct file_operations portdev_fops = {
1353         .owner = THIS_MODULE,
1354 };
1355
1356 /*
1357  * Once we're further in boot, we get probed like any other virtio
1358  * device.
1359  *
1360  * If the host also supports multiple console ports, we check the
1361  * config space to see how many ports the host has spawned.  We
1362  * initialize each port found.
1363  */
1364 static int __devinit virtcons_probe(struct virtio_device *vdev)
1365 {
1366         struct ports_device *portdev;
1367         u32 i;
1368         int err;
1369         bool multiport;
1370
1371         portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
1372         if (!portdev) {
1373                 err = -ENOMEM;
1374                 goto fail;
1375         }
1376
1377         /* Attach this portdev to this virtio_device, and vice-versa. */
1378         portdev->vdev = vdev;
1379         vdev->priv = portdev;
1380
1381         spin_lock_irq(&pdrvdata_lock);
1382         portdev->drv_index = pdrvdata.index++;
1383         spin_unlock_irq(&pdrvdata_lock);
1384
1385         portdev->chr_major = register_chrdev(0, "virtio-portsdev",
1386                                              &portdev_fops);
1387         if (portdev->chr_major < 0) {
1388                 dev_err(&vdev->dev,
1389                         "Error %d registering chrdev for device %u\n",
1390                         portdev->chr_major, portdev->drv_index);
1391                 err = portdev->chr_major;
1392                 goto free;
1393         }
1394
1395         multiport = false;
1396         portdev->config.nr_ports = 1;
1397         portdev->config.max_nr_ports = 1;
1398         if (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT)) {
1399                 multiport = true;
1400                 vdev->features[0] |= 1 << VIRTIO_CONSOLE_F_MULTIPORT;
1401
1402                 vdev->config->get(vdev, offsetof(struct virtio_console_config,
1403                                                  nr_ports),
1404                                   &portdev->config.nr_ports,
1405                                   sizeof(portdev->config.nr_ports));
1406                 vdev->config->get(vdev, offsetof(struct virtio_console_config,
1407                                                  max_nr_ports),
1408                                   &portdev->config.max_nr_ports,
1409                                   sizeof(portdev->config.max_nr_ports));
1410                 if (portdev->config.nr_ports > portdev->config.max_nr_ports) {
1411                         dev_warn(&vdev->dev,
1412                                  "More ports (%u) specified than allowed (%u). Will init %u ports.",
1413                                  portdev->config.nr_ports,
1414                                  portdev->config.max_nr_ports,
1415                                  portdev->config.max_nr_ports);
1416
1417                         portdev->config.nr_ports = portdev->config.max_nr_ports;
1418                 }
1419         }
1420
1421         /* Let the Host know we support multiple ports.*/
1422         vdev->config->finalize_features(vdev);
1423
1424         err = init_vqs(portdev);
1425         if (err < 0) {
1426                 dev_err(&vdev->dev, "Error %d initializing vqs\n", err);
1427                 goto free_chrdev;
1428         }
1429
1430         spin_lock_init(&portdev->ports_lock);
1431         INIT_LIST_HEAD(&portdev->ports);
1432
1433         if (multiport) {
1434                 spin_lock_init(&portdev->cvq_lock);
1435                 INIT_WORK(&portdev->control_work, &control_work_handler);
1436                 INIT_WORK(&portdev->config_work, &config_work_handler);
1437
1438                 err = fill_queue(portdev->c_ivq, &portdev->cvq_lock);
1439                 if (!err) {
1440                         dev_err(&vdev->dev,
1441                                 "Error allocating buffers for control queue\n");
1442                         err = -ENOMEM;
1443                         goto free_vqs;
1444                 }
1445         }
1446
1447         for (i = 0; i < portdev->config.nr_ports; i++)
1448                 add_port(portdev, i);
1449
1450         /* Start using the new console output. */
1451         early_put_chars = NULL;
1452         return 0;
1453
1454 free_vqs:
1455         vdev->config->del_vqs(vdev);
1456         kfree(portdev->in_vqs);
1457         kfree(portdev->out_vqs);
1458 free_chrdev:
1459         unregister_chrdev(portdev->chr_major, "virtio-portsdev");
1460 free:
1461         kfree(portdev);
1462 fail:
1463         return err;
1464 }
1465
1466 static void virtcons_remove(struct virtio_device *vdev)
1467 {
1468         struct ports_device *portdev;
1469         struct port *port, *port2;
1470         struct port_buffer *buf;
1471         unsigned int len;
1472
1473         portdev = vdev->priv;
1474
1475         cancel_work_sync(&portdev->control_work);
1476         cancel_work_sync(&portdev->config_work);
1477
1478         list_for_each_entry_safe(port, port2, &portdev->ports, list)
1479                 remove_port(port);
1480
1481         unregister_chrdev(portdev->chr_major, "virtio-portsdev");
1482
1483         while ((buf = portdev->c_ivq->vq_ops->get_buf(portdev->c_ivq, &len)))
1484                 free_buf(buf);
1485
1486         while ((buf = portdev->c_ivq->vq_ops->detach_unused_buf(portdev->c_ivq)))
1487                 free_buf(buf);
1488
1489         vdev->config->del_vqs(vdev);
1490         kfree(portdev->in_vqs);
1491         kfree(portdev->out_vqs);
1492
1493         kfree(portdev);
1494 }
1495
1496 static struct virtio_device_id id_table[] = {
1497         { VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID },
1498         { 0 },
1499 };
1500
1501 static unsigned int features[] = {
1502         VIRTIO_CONSOLE_F_SIZE,
1503         VIRTIO_CONSOLE_F_MULTIPORT,
1504 };
1505
1506 static struct virtio_driver virtio_console = {
1507         .feature_table = features,
1508         .feature_table_size = ARRAY_SIZE(features),
1509         .driver.name =  KBUILD_MODNAME,
1510         .driver.owner = THIS_MODULE,
1511         .id_table =     id_table,
1512         .probe =        virtcons_probe,
1513         .remove =       virtcons_remove,
1514         .config_changed = config_intr,
1515 };
1516
1517 static int __init init(void)
1518 {
1519         int err;
1520
1521         pdrvdata.class = class_create(THIS_MODULE, "virtio-ports");
1522         if (IS_ERR(pdrvdata.class)) {
1523                 err = PTR_ERR(pdrvdata.class);
1524                 pr_err("Error %d creating virtio-ports class\n", err);
1525                 return err;
1526         }
1527
1528         pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL);
1529         if (!pdrvdata.debugfs_dir) {
1530                 pr_warning("Error %ld creating debugfs dir for virtio-ports\n",
1531                            PTR_ERR(pdrvdata.debugfs_dir));
1532         }
1533         INIT_LIST_HEAD(&pdrvdata.consoles);
1534
1535         return register_virtio_driver(&virtio_console);
1536 }
1537
1538 static void __exit fini(void)
1539 {
1540         unregister_virtio_driver(&virtio_console);
1541
1542         class_destroy(pdrvdata.class);
1543         if (pdrvdata.debugfs_dir)
1544                 debugfs_remove_recursive(pdrvdata.debugfs_dir);
1545 }
1546 module_init(init);
1547 module_exit(fini);
1548
1549 MODULE_DEVICE_TABLE(virtio, id_table);
1550 MODULE_DESCRIPTION("Virtio console driver");
1551 MODULE_LICENSE("GPL");