151df0accSAmit Shah /* 251df0accSAmit Shah * Copyright (C) 2006, 2007, 2009 Rusty Russell, IBM Corporation 3ce86d35dSLinus Torvalds * Copyright (C) 2009, 2010, 2011 Red Hat, Inc. 4ce86d35dSLinus Torvalds * Copyright (C) 2009, 2010, 2011 Amit Shah <amit.shah@redhat.com> 551df0accSAmit Shah * 651df0accSAmit Shah * This program is free software; you can redistribute it and/or modify 751df0accSAmit Shah * it under the terms of the GNU General Public License as published by 851df0accSAmit Shah * the Free Software Foundation; either version 2 of the License, or 951df0accSAmit Shah * (at your option) any later version. 1051df0accSAmit Shah * 1151df0accSAmit Shah * This program is distributed in the hope that it will be useful, 1251df0accSAmit Shah * but WITHOUT ANY WARRANTY; without even the implied warranty of 1351df0accSAmit Shah * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1451df0accSAmit Shah * GNU General Public License for more details. 1551df0accSAmit Shah * 1651df0accSAmit Shah * You should have received a copy of the GNU General Public License 1751df0accSAmit Shah * along with this program; if not, write to the Free Software 1851df0accSAmit Shah * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 1951df0accSAmit Shah */ 2051df0accSAmit Shah #include <linux/cdev.h> 2151df0accSAmit Shah #include <linux/debugfs.h> 225e38483bSChristian Borntraeger #include <linux/completion.h> 2351df0accSAmit Shah #include <linux/device.h> 2451df0accSAmit Shah #include <linux/err.h> 25a08fa92dSAmit Shah #include <linux/freezer.h> 2651df0accSAmit Shah #include <linux/fs.h> 2751df0accSAmit Shah #include <linux/init.h> 2851df0accSAmit Shah #include <linux/list.h> 2951df0accSAmit Shah #include <linux/poll.h> 3051df0accSAmit Shah #include <linux/sched.h> 3151df0accSAmit Shah #include <linux/slab.h> 3251df0accSAmit Shah #include <linux/spinlock.h> 3351df0accSAmit Shah #include <linux/virtio.h> 3451df0accSAmit Shah #include <linux/virtio_console.h> 3551df0accSAmit Shah #include <linux/wait.h> 3651df0accSAmit Shah #include <linux/workqueue.h> 37c22405c9SPaul Gortmaker #include <linux/module.h> 3851df0accSAmit Shah #include "../tty/hvc/hvc_console.h" 3951df0accSAmit Shah 4051df0accSAmit Shah /* 4151df0accSAmit Shah * This is a global struct for storing common data for all the devices 4251df0accSAmit Shah * this driver handles. 4351df0accSAmit Shah * 4451df0accSAmit Shah * Mainly, it has a linked list for all the consoles in one place so 4551df0accSAmit Shah * that callbacks from hvc for get_chars(), put_chars() work properly 4651df0accSAmit Shah * across multiple devices and multiple ports per device. 4751df0accSAmit Shah */ 4851df0accSAmit Shah struct ports_driver_data { 4951df0accSAmit Shah /* Used for registering chardevs */ 5051df0accSAmit Shah struct class *class; 5151df0accSAmit Shah 5251df0accSAmit Shah /* Used for exporting per-port information to debugfs */ 5351df0accSAmit Shah struct dentry *debugfs_dir; 5451df0accSAmit Shah 5551df0accSAmit Shah /* List of all the devices we're handling */ 5651df0accSAmit Shah struct list_head portdevs; 5751df0accSAmit Shah 5851df0accSAmit Shah /* Number of devices this driver is handling */ 5951df0accSAmit Shah unsigned int index; 6051df0accSAmit Shah 6151df0accSAmit Shah /* 6251df0accSAmit Shah * This is used to keep track of the number of hvc consoles 6351df0accSAmit Shah * spawned by this driver. This number is given as the first 6451df0accSAmit Shah * argument to hvc_alloc(). To correctly map an initial 6551df0accSAmit Shah * console spawned via hvc_instantiate to the console being 6651df0accSAmit Shah * hooked up via hvc_alloc, we need to pass the same vtermno. 6751df0accSAmit Shah * 6851df0accSAmit Shah * We also just assume the first console being initialised was 6951df0accSAmit Shah * the first one that got used as the initial console. 7051df0accSAmit Shah */ 7151df0accSAmit Shah unsigned int next_vtermno; 7251df0accSAmit Shah 7351df0accSAmit Shah /* All the console devices handled by this driver */ 7451df0accSAmit Shah struct list_head consoles; 7551df0accSAmit Shah }; 7651df0accSAmit Shah static struct ports_driver_data pdrvdata; 7751df0accSAmit Shah 7851df0accSAmit Shah DEFINE_SPINLOCK(pdrvdata_lock); 795e38483bSChristian Borntraeger DECLARE_COMPLETION(early_console_added); 8051df0accSAmit Shah 8151df0accSAmit Shah /* This struct holds information that's relevant only for console ports */ 8251df0accSAmit Shah struct console { 8351df0accSAmit Shah /* We'll place all consoles in a list in the pdrvdata struct */ 8451df0accSAmit Shah struct list_head list; 8551df0accSAmit Shah 8651df0accSAmit Shah /* The hvc device associated with this console port */ 8751df0accSAmit Shah struct hvc_struct *hvc; 8851df0accSAmit Shah 8951df0accSAmit Shah /* The size of the console */ 9051df0accSAmit Shah struct winsize ws; 9151df0accSAmit Shah 9251df0accSAmit Shah /* 9351df0accSAmit Shah * This number identifies the number that we used to register 9451df0accSAmit Shah * with hvc in hvc_instantiate() and hvc_alloc(); this is the 9551df0accSAmit Shah * number passed on by the hvc callbacks to us to 9651df0accSAmit Shah * differentiate between the other console ports handled by 9751df0accSAmit Shah * this driver 9851df0accSAmit Shah */ 9951df0accSAmit Shah u32 vtermno; 10051df0accSAmit Shah }; 10151df0accSAmit Shah 10251df0accSAmit Shah struct port_buffer { 10351df0accSAmit Shah char *buf; 10451df0accSAmit Shah 10551df0accSAmit Shah /* size of the buffer in *buf above */ 10651df0accSAmit Shah size_t size; 10751df0accSAmit Shah 10851df0accSAmit Shah /* used length of the buffer */ 10951df0accSAmit Shah size_t len; 11051df0accSAmit Shah /* offset in the buf from which to consume data */ 11151df0accSAmit Shah size_t offset; 11251df0accSAmit Shah }; 11351df0accSAmit Shah 11451df0accSAmit Shah /* 11551df0accSAmit Shah * This is a per-device struct that stores data common to all the 11651df0accSAmit Shah * ports for that device (vdev->priv). 11751df0accSAmit Shah */ 11851df0accSAmit Shah struct ports_device { 11951df0accSAmit Shah /* Next portdev in the list, head is in the pdrvdata struct */ 12051df0accSAmit Shah struct list_head list; 12151df0accSAmit Shah 12251df0accSAmit Shah /* 12351df0accSAmit Shah * Workqueue handlers where we process deferred work after 12451df0accSAmit Shah * notification 12551df0accSAmit Shah */ 12651df0accSAmit Shah struct work_struct control_work; 12751df0accSAmit Shah 12851df0accSAmit Shah struct list_head ports; 12951df0accSAmit Shah 13051df0accSAmit Shah /* To protect the list of ports */ 13151df0accSAmit Shah spinlock_t ports_lock; 13251df0accSAmit Shah 13351df0accSAmit Shah /* To protect the vq operations for the control channel */ 13451df0accSAmit Shah spinlock_t cvq_lock; 13551df0accSAmit Shah 13651df0accSAmit Shah /* The current config space is stored here */ 13751df0accSAmit Shah struct virtio_console_config config; 13851df0accSAmit Shah 13951df0accSAmit Shah /* The virtio device we're associated with */ 14051df0accSAmit Shah struct virtio_device *vdev; 14151df0accSAmit Shah 14251df0accSAmit Shah /* 14351df0accSAmit Shah * A couple of virtqueues for the control channel: one for 14451df0accSAmit Shah * guest->host transfers, one for host->guest transfers 14551df0accSAmit Shah */ 14651df0accSAmit Shah struct virtqueue *c_ivq, *c_ovq; 14751df0accSAmit Shah 14851df0accSAmit Shah /* Array of per-port IO virtqueues */ 14951df0accSAmit Shah struct virtqueue **in_vqs, **out_vqs; 15051df0accSAmit Shah 15151df0accSAmit Shah /* Used for numbering devices for sysfs and debugfs */ 15251df0accSAmit Shah unsigned int drv_index; 15351df0accSAmit Shah 15451df0accSAmit Shah /* Major number for this device. Ports will be created as minors. */ 15551df0accSAmit Shah int chr_major; 15651df0accSAmit Shah }; 15751df0accSAmit Shah 15817e5b4f2SAmit Shah struct port_stats { 15917e5b4f2SAmit Shah unsigned long bytes_sent, bytes_received, bytes_discarded; 16017e5b4f2SAmit Shah }; 16117e5b4f2SAmit Shah 16251df0accSAmit Shah /* This struct holds the per-port data */ 16351df0accSAmit Shah struct port { 16451df0accSAmit Shah /* Next port in the list, head is in the ports_device */ 16551df0accSAmit Shah struct list_head list; 16651df0accSAmit Shah 16751df0accSAmit Shah /* Pointer to the parent virtio_console device */ 16851df0accSAmit Shah struct ports_device *portdev; 16951df0accSAmit Shah 17051df0accSAmit Shah /* The current buffer from which data has to be fed to readers */ 17151df0accSAmit Shah struct port_buffer *inbuf; 17251df0accSAmit Shah 17351df0accSAmit Shah /* 17451df0accSAmit Shah * To protect the operations on the in_vq associated with this 17551df0accSAmit Shah * port. Has to be a spinlock because it can be called from 17651df0accSAmit Shah * interrupt context (get_char()). 17751df0accSAmit Shah */ 17851df0accSAmit Shah spinlock_t inbuf_lock; 17951df0accSAmit Shah 18051df0accSAmit Shah /* Protect the operations on the out_vq. */ 18151df0accSAmit Shah spinlock_t outvq_lock; 18251df0accSAmit Shah 18351df0accSAmit Shah /* The IO vqs for this port */ 18451df0accSAmit Shah struct virtqueue *in_vq, *out_vq; 18551df0accSAmit Shah 18651df0accSAmit Shah /* File in the debugfs directory that exposes this port's information */ 18751df0accSAmit Shah struct dentry *debugfs_file; 18851df0accSAmit Shah 18951df0accSAmit Shah /* 19017e5b4f2SAmit Shah * Keep count of the bytes sent, received and discarded for 19117e5b4f2SAmit Shah * this port for accounting and debugging purposes. These 19217e5b4f2SAmit Shah * counts are not reset across port open / close events. 19317e5b4f2SAmit Shah */ 19417e5b4f2SAmit Shah struct port_stats stats; 19517e5b4f2SAmit Shah 19617e5b4f2SAmit Shah /* 19751df0accSAmit Shah * The entries in this struct will be valid if this port is 19851df0accSAmit Shah * hooked up to an hvc console 19951df0accSAmit Shah */ 20051df0accSAmit Shah struct console cons; 20151df0accSAmit Shah 20251df0accSAmit Shah /* Each port associates with a separate char device */ 20351df0accSAmit Shah struct cdev *cdev; 20451df0accSAmit Shah struct device *dev; 20551df0accSAmit Shah 20651df0accSAmit Shah /* Reference-counting to handle port hot-unplugs and file operations */ 20751df0accSAmit Shah struct kref kref; 20851df0accSAmit Shah 20951df0accSAmit Shah /* A waitqueue for poll() or blocking read operations */ 21051df0accSAmit Shah wait_queue_head_t waitqueue; 21151df0accSAmit Shah 21251df0accSAmit Shah /* The 'name' of the port that we expose via sysfs properties */ 21351df0accSAmit Shah char *name; 21451df0accSAmit Shah 21551df0accSAmit Shah /* We can notify apps of host connect / disconnect events via SIGIO */ 21651df0accSAmit Shah struct fasync_struct *async_queue; 21751df0accSAmit Shah 21851df0accSAmit Shah /* The 'id' to identify the port with the Host */ 21951df0accSAmit Shah u32 id; 22051df0accSAmit Shah 22151df0accSAmit Shah bool outvq_full; 22251df0accSAmit Shah 22351df0accSAmit Shah /* Is the host device open */ 22451df0accSAmit Shah bool host_connected; 22551df0accSAmit Shah 22651df0accSAmit Shah /* We should allow only one process to open a port */ 22751df0accSAmit Shah bool guest_connected; 22851df0accSAmit Shah }; 22951df0accSAmit Shah 23051df0accSAmit Shah /* This is the very early arch-specified put chars function. */ 23151df0accSAmit Shah static int (*early_put_chars)(u32, const char *, int); 23251df0accSAmit Shah 23351df0accSAmit Shah static struct port *find_port_by_vtermno(u32 vtermno) 23451df0accSAmit Shah { 23551df0accSAmit Shah struct port *port; 23651df0accSAmit Shah struct console *cons; 23751df0accSAmit Shah unsigned long flags; 23851df0accSAmit Shah 23951df0accSAmit Shah spin_lock_irqsave(&pdrvdata_lock, flags); 24051df0accSAmit Shah list_for_each_entry(cons, &pdrvdata.consoles, list) { 24151df0accSAmit Shah if (cons->vtermno == vtermno) { 24251df0accSAmit Shah port = container_of(cons, struct port, cons); 24351df0accSAmit Shah goto out; 24451df0accSAmit Shah } 24551df0accSAmit Shah } 24651df0accSAmit Shah port = NULL; 24751df0accSAmit Shah out: 24851df0accSAmit Shah spin_unlock_irqrestore(&pdrvdata_lock, flags); 24951df0accSAmit Shah return port; 25051df0accSAmit Shah } 25151df0accSAmit Shah 25251df0accSAmit Shah static struct port *find_port_by_devt_in_portdev(struct ports_device *portdev, 25351df0accSAmit Shah dev_t dev) 25451df0accSAmit Shah { 25551df0accSAmit Shah struct port *port; 25651df0accSAmit Shah unsigned long flags; 25751df0accSAmit Shah 25851df0accSAmit Shah spin_lock_irqsave(&portdev->ports_lock, flags); 25951df0accSAmit Shah list_for_each_entry(port, &portdev->ports, list) 26051df0accSAmit Shah if (port->cdev->dev == dev) 26151df0accSAmit Shah goto out; 26251df0accSAmit Shah port = NULL; 26351df0accSAmit Shah out: 26451df0accSAmit Shah spin_unlock_irqrestore(&portdev->ports_lock, flags); 26551df0accSAmit Shah 26651df0accSAmit Shah return port; 26751df0accSAmit Shah } 26851df0accSAmit Shah 26951df0accSAmit Shah static struct port *find_port_by_devt(dev_t dev) 27051df0accSAmit Shah { 27151df0accSAmit Shah struct ports_device *portdev; 27251df0accSAmit Shah struct port *port; 27351df0accSAmit Shah unsigned long flags; 27451df0accSAmit Shah 27551df0accSAmit Shah spin_lock_irqsave(&pdrvdata_lock, flags); 27651df0accSAmit Shah list_for_each_entry(portdev, &pdrvdata.portdevs, list) { 27751df0accSAmit Shah port = find_port_by_devt_in_portdev(portdev, dev); 27851df0accSAmit Shah if (port) 27951df0accSAmit Shah goto out; 28051df0accSAmit Shah } 28151df0accSAmit Shah port = NULL; 28251df0accSAmit Shah out: 28351df0accSAmit Shah spin_unlock_irqrestore(&pdrvdata_lock, flags); 28451df0accSAmit Shah return port; 28551df0accSAmit Shah } 28651df0accSAmit Shah 28751df0accSAmit Shah static struct port *find_port_by_id(struct ports_device *portdev, u32 id) 28851df0accSAmit Shah { 28951df0accSAmit Shah struct port *port; 29051df0accSAmit Shah unsigned long flags; 29151df0accSAmit Shah 29251df0accSAmit Shah spin_lock_irqsave(&portdev->ports_lock, flags); 29351df0accSAmit Shah list_for_each_entry(port, &portdev->ports, list) 29451df0accSAmit Shah if (port->id == id) 29551df0accSAmit Shah goto out; 29651df0accSAmit Shah port = NULL; 29751df0accSAmit Shah out: 29851df0accSAmit Shah spin_unlock_irqrestore(&portdev->ports_lock, flags); 29951df0accSAmit Shah 30051df0accSAmit Shah return port; 30151df0accSAmit Shah } 30251df0accSAmit Shah 30351df0accSAmit Shah static struct port *find_port_by_vq(struct ports_device *portdev, 30451df0accSAmit Shah struct virtqueue *vq) 30551df0accSAmit Shah { 30651df0accSAmit Shah struct port *port; 30751df0accSAmit Shah unsigned long flags; 30851df0accSAmit Shah 30951df0accSAmit Shah spin_lock_irqsave(&portdev->ports_lock, flags); 31051df0accSAmit Shah list_for_each_entry(port, &portdev->ports, list) 31151df0accSAmit Shah if (port->in_vq == vq || port->out_vq == vq) 31251df0accSAmit Shah goto out; 31351df0accSAmit Shah port = NULL; 31451df0accSAmit Shah out: 31551df0accSAmit Shah spin_unlock_irqrestore(&portdev->ports_lock, flags); 31651df0accSAmit Shah return port; 31751df0accSAmit Shah } 31851df0accSAmit Shah 31951df0accSAmit Shah static bool is_console_port(struct port *port) 32051df0accSAmit Shah { 32151df0accSAmit Shah if (port->cons.hvc) 32251df0accSAmit Shah return true; 32351df0accSAmit Shah return false; 32451df0accSAmit Shah } 32551df0accSAmit Shah 32651df0accSAmit Shah static inline bool use_multiport(struct ports_device *portdev) 32751df0accSAmit Shah { 32851df0accSAmit Shah /* 32951df0accSAmit Shah * This condition can be true when put_chars is called from 33051df0accSAmit Shah * early_init 33151df0accSAmit Shah */ 33251df0accSAmit Shah if (!portdev->vdev) 33351df0accSAmit Shah return 0; 33451df0accSAmit Shah return portdev->vdev->features[0] & (1 << VIRTIO_CONSOLE_F_MULTIPORT); 33551df0accSAmit Shah } 33651df0accSAmit Shah 33751df0accSAmit Shah static void free_buf(struct port_buffer *buf) 33851df0accSAmit Shah { 33951df0accSAmit Shah kfree(buf->buf); 34051df0accSAmit Shah kfree(buf); 34151df0accSAmit Shah } 34251df0accSAmit Shah 34351df0accSAmit Shah static struct port_buffer *alloc_buf(size_t buf_size) 34451df0accSAmit Shah { 34551df0accSAmit Shah struct port_buffer *buf; 34651df0accSAmit Shah 34751df0accSAmit Shah buf = kmalloc(sizeof(*buf), GFP_KERNEL); 34851df0accSAmit Shah if (!buf) 34951df0accSAmit Shah goto fail; 35051df0accSAmit Shah buf->buf = kzalloc(buf_size, GFP_KERNEL); 35151df0accSAmit Shah if (!buf->buf) 35251df0accSAmit Shah goto free_buf; 35351df0accSAmit Shah buf->len = 0; 35451df0accSAmit Shah buf->offset = 0; 35551df0accSAmit Shah buf->size = buf_size; 35651df0accSAmit Shah return buf; 35751df0accSAmit Shah 35851df0accSAmit Shah free_buf: 35951df0accSAmit Shah kfree(buf); 36051df0accSAmit Shah fail: 36151df0accSAmit Shah return NULL; 36251df0accSAmit Shah } 36351df0accSAmit Shah 36451df0accSAmit Shah /* Callers should take appropriate locks */ 365defde669SAmit Shah static struct port_buffer *get_inbuf(struct port *port) 36651df0accSAmit Shah { 36751df0accSAmit Shah struct port_buffer *buf; 36851df0accSAmit Shah unsigned int len; 36951df0accSAmit Shah 370d25a9ddaSAmit Shah if (port->inbuf) 371d25a9ddaSAmit Shah return port->inbuf; 372d25a9ddaSAmit Shah 373d25a9ddaSAmit Shah buf = virtqueue_get_buf(port->in_vq, &len); 37451df0accSAmit Shah if (buf) { 37551df0accSAmit Shah buf->len = len; 37651df0accSAmit Shah buf->offset = 0; 37717e5b4f2SAmit Shah port->stats.bytes_received += len; 37851df0accSAmit Shah } 37951df0accSAmit Shah return buf; 38051df0accSAmit Shah } 38151df0accSAmit Shah 38251df0accSAmit Shah /* 38351df0accSAmit Shah * Create a scatter-gather list representing our input buffer and put 38451df0accSAmit Shah * it in the queue. 38551df0accSAmit Shah * 38651df0accSAmit Shah * Callers should take appropriate locks. 38751df0accSAmit Shah */ 38851df0accSAmit Shah static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf) 38951df0accSAmit Shah { 39051df0accSAmit Shah struct scatterlist sg[1]; 39151df0accSAmit Shah int ret; 39251df0accSAmit Shah 39351df0accSAmit Shah sg_init_one(sg, buf->buf, buf->size); 39451df0accSAmit Shah 395f96fde41SRusty Russell ret = virtqueue_add_buf(vq, sg, 0, 1, buf, GFP_ATOMIC); 39651df0accSAmit Shah virtqueue_kick(vq); 39751df0accSAmit Shah return ret; 39851df0accSAmit Shah } 39951df0accSAmit Shah 40051df0accSAmit Shah /* Discard any unread data this port has. Callers lockers. */ 40151df0accSAmit Shah static void discard_port_data(struct port *port) 40251df0accSAmit Shah { 40351df0accSAmit Shah struct port_buffer *buf; 4042d24cdaaSAmit Shah unsigned int err; 40551df0accSAmit Shah 406d7a62cd0SAmit Shah if (!port->portdev) { 407d7a62cd0SAmit Shah /* Device has been unplugged. vqs are already gone. */ 408d7a62cd0SAmit Shah return; 409d7a62cd0SAmit Shah } 4102d24cdaaSAmit Shah buf = get_inbuf(port); 41151df0accSAmit Shah 412ce072a0cSAmit Shah err = 0; 41351df0accSAmit Shah while (buf) { 41417e5b4f2SAmit Shah port->stats.bytes_discarded += buf->len - buf->offset; 4152d24cdaaSAmit Shah if (add_inbuf(port->in_vq, buf) < 0) { 416ce072a0cSAmit Shah err++; 41751df0accSAmit Shah free_buf(buf); 41851df0accSAmit Shah } 41951df0accSAmit Shah port->inbuf = NULL; 4202d24cdaaSAmit Shah buf = get_inbuf(port); 4212d24cdaaSAmit Shah } 422ce072a0cSAmit Shah if (err) 42351df0accSAmit Shah dev_warn(port->dev, "Errors adding %d buffers back to vq\n", 424ce072a0cSAmit Shah err); 42551df0accSAmit Shah } 42651df0accSAmit Shah 42751df0accSAmit Shah static bool port_has_data(struct port *port) 42851df0accSAmit Shah { 42951df0accSAmit Shah unsigned long flags; 43051df0accSAmit Shah bool ret; 43151df0accSAmit Shah 43251df0accSAmit Shah ret = false; 433d25a9ddaSAmit Shah spin_lock_irqsave(&port->inbuf_lock, flags); 434d25a9ddaSAmit Shah port->inbuf = get_inbuf(port); 435d25a9ddaSAmit Shah if (port->inbuf) 436d25a9ddaSAmit Shah ret = true; 437d25a9ddaSAmit Shah 43851df0accSAmit Shah spin_unlock_irqrestore(&port->inbuf_lock, flags); 43951df0accSAmit Shah return ret; 44051df0accSAmit Shah } 44151df0accSAmit Shah 44251df0accSAmit Shah static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id, 44351df0accSAmit Shah unsigned int event, unsigned int value) 44451df0accSAmit Shah { 44551df0accSAmit Shah struct scatterlist sg[1]; 44651df0accSAmit Shah struct virtio_console_control cpkt; 44751df0accSAmit Shah struct virtqueue *vq; 44851df0accSAmit Shah unsigned int len; 44951df0accSAmit Shah 45051df0accSAmit Shah if (!use_multiport(portdev)) 45151df0accSAmit Shah return 0; 45251df0accSAmit Shah 45351df0accSAmit Shah cpkt.id = port_id; 45451df0accSAmit Shah cpkt.event = event; 45551df0accSAmit Shah cpkt.value = value; 45651df0accSAmit Shah 45751df0accSAmit Shah vq = portdev->c_ovq; 45851df0accSAmit Shah 45951df0accSAmit Shah sg_init_one(sg, &cpkt, sizeof(cpkt)); 460f96fde41SRusty Russell if (virtqueue_add_buf(vq, sg, 1, 0, &cpkt, GFP_ATOMIC) >= 0) { 46151df0accSAmit Shah virtqueue_kick(vq); 46251df0accSAmit Shah while (!virtqueue_get_buf(vq, &len)) 46351df0accSAmit Shah cpu_relax(); 46451df0accSAmit Shah } 46551df0accSAmit Shah return 0; 46651df0accSAmit Shah } 46751df0accSAmit Shah 46851df0accSAmit Shah static ssize_t send_control_msg(struct port *port, unsigned int event, 46951df0accSAmit Shah unsigned int value) 47051df0accSAmit Shah { 47151df0accSAmit Shah /* Did the port get unplugged before userspace closed it? */ 47251df0accSAmit Shah if (port->portdev) 47351df0accSAmit Shah return __send_control_msg(port->portdev, port->id, event, value); 47451df0accSAmit Shah return 0; 47551df0accSAmit Shah } 47651df0accSAmit Shah 47751df0accSAmit Shah /* Callers must take the port->outvq_lock */ 47851df0accSAmit Shah static void reclaim_consumed_buffers(struct port *port) 47951df0accSAmit Shah { 48051df0accSAmit Shah void *buf; 48151df0accSAmit Shah unsigned int len; 48251df0accSAmit Shah 483d7a62cd0SAmit Shah if (!port->portdev) { 484d7a62cd0SAmit Shah /* Device has been unplugged. vqs are already gone. */ 485d7a62cd0SAmit Shah return; 486d7a62cd0SAmit Shah } 48751df0accSAmit Shah while ((buf = virtqueue_get_buf(port->out_vq, &len))) { 48851df0accSAmit Shah kfree(buf); 48951df0accSAmit Shah port->outvq_full = false; 49051df0accSAmit Shah } 49151df0accSAmit Shah } 49251df0accSAmit Shah 49351df0accSAmit Shah static ssize_t send_buf(struct port *port, void *in_buf, size_t in_count, 49451df0accSAmit Shah bool nonblock) 49551df0accSAmit Shah { 49651df0accSAmit Shah struct scatterlist sg[1]; 49751df0accSAmit Shah struct virtqueue *out_vq; 49851df0accSAmit Shah ssize_t ret; 49951df0accSAmit Shah unsigned long flags; 50051df0accSAmit Shah unsigned int len; 50151df0accSAmit Shah 50251df0accSAmit Shah out_vq = port->out_vq; 50351df0accSAmit Shah 50451df0accSAmit Shah spin_lock_irqsave(&port->outvq_lock, flags); 50551df0accSAmit Shah 50651df0accSAmit Shah reclaim_consumed_buffers(port); 50751df0accSAmit Shah 50851df0accSAmit Shah sg_init_one(sg, in_buf, in_count); 509f96fde41SRusty Russell ret = virtqueue_add_buf(out_vq, sg, 1, 0, in_buf, GFP_ATOMIC); 51051df0accSAmit Shah 51151df0accSAmit Shah /* Tell Host to go! */ 51251df0accSAmit Shah virtqueue_kick(out_vq); 51351df0accSAmit Shah 51451df0accSAmit Shah if (ret < 0) { 51551df0accSAmit Shah in_count = 0; 51651df0accSAmit Shah goto done; 51751df0accSAmit Shah } 51851df0accSAmit Shah 51951df0accSAmit Shah if (ret == 0) 52051df0accSAmit Shah port->outvq_full = true; 52151df0accSAmit Shah 52251df0accSAmit Shah if (nonblock) 52351df0accSAmit Shah goto done; 52451df0accSAmit Shah 52551df0accSAmit Shah /* 52651df0accSAmit Shah * Wait till the host acknowledges it pushed out the data we 52751df0accSAmit Shah * sent. This is done for data from the hvc_console; the tty 52851df0accSAmit Shah * operations are performed with spinlocks held so we can't 52951df0accSAmit Shah * sleep here. An alternative would be to copy the data to a 53051df0accSAmit Shah * buffer and relax the spinning requirement. The downside is 53151df0accSAmit Shah * we need to kmalloc a GFP_ATOMIC buffer each time the 53251df0accSAmit Shah * console driver writes something out. 53351df0accSAmit Shah */ 53451df0accSAmit Shah while (!virtqueue_get_buf(out_vq, &len)) 53551df0accSAmit Shah cpu_relax(); 53651df0accSAmit Shah done: 53751df0accSAmit Shah spin_unlock_irqrestore(&port->outvq_lock, flags); 53817e5b4f2SAmit Shah 53917e5b4f2SAmit Shah port->stats.bytes_sent += in_count; 54051df0accSAmit Shah /* 54151df0accSAmit Shah * We're expected to return the amount of data we wrote -- all 54251df0accSAmit Shah * of it 54351df0accSAmit Shah */ 54451df0accSAmit Shah return in_count; 54551df0accSAmit Shah } 54651df0accSAmit Shah 54751df0accSAmit Shah /* 54851df0accSAmit Shah * Give out the data that's requested from the buffer that we have 54951df0accSAmit Shah * queued up. 55051df0accSAmit Shah */ 55151df0accSAmit Shah static ssize_t fill_readbuf(struct port *port, char *out_buf, size_t out_count, 55251df0accSAmit Shah bool to_user) 55351df0accSAmit Shah { 55451df0accSAmit Shah struct port_buffer *buf; 55551df0accSAmit Shah unsigned long flags; 55651df0accSAmit Shah 55751df0accSAmit Shah if (!out_count || !port_has_data(port)) 55851df0accSAmit Shah return 0; 55951df0accSAmit Shah 56051df0accSAmit Shah buf = port->inbuf; 56151df0accSAmit Shah out_count = min(out_count, buf->len - buf->offset); 56251df0accSAmit Shah 56351df0accSAmit Shah if (to_user) { 56451df0accSAmit Shah ssize_t ret; 56551df0accSAmit Shah 56651df0accSAmit Shah ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count); 56751df0accSAmit Shah if (ret) 56851df0accSAmit Shah return -EFAULT; 56951df0accSAmit Shah } else { 57051df0accSAmit Shah memcpy(out_buf, buf->buf + buf->offset, out_count); 57151df0accSAmit Shah } 57251df0accSAmit Shah 57351df0accSAmit Shah buf->offset += out_count; 57451df0accSAmit Shah 57551df0accSAmit Shah if (buf->offset == buf->len) { 57651df0accSAmit Shah /* 57751df0accSAmit Shah * We're done using all the data in this buffer. 57851df0accSAmit Shah * Re-queue so that the Host can send us more data. 57951df0accSAmit Shah */ 58051df0accSAmit Shah spin_lock_irqsave(&port->inbuf_lock, flags); 58151df0accSAmit Shah port->inbuf = NULL; 58251df0accSAmit Shah 58351df0accSAmit Shah if (add_inbuf(port->in_vq, buf) < 0) 58451df0accSAmit Shah dev_warn(port->dev, "failed add_buf\n"); 58551df0accSAmit Shah 58651df0accSAmit Shah spin_unlock_irqrestore(&port->inbuf_lock, flags); 58751df0accSAmit Shah } 58851df0accSAmit Shah /* Return the number of bytes actually copied */ 58951df0accSAmit Shah return out_count; 59051df0accSAmit Shah } 59151df0accSAmit Shah 59251df0accSAmit Shah /* The condition that must be true for polling to end */ 59351df0accSAmit Shah static bool will_read_block(struct port *port) 59451df0accSAmit Shah { 59551df0accSAmit Shah if (!port->guest_connected) { 59651df0accSAmit Shah /* Port got hot-unplugged. Let's exit. */ 59751df0accSAmit Shah return false; 59851df0accSAmit Shah } 59951df0accSAmit Shah return !port_has_data(port) && port->host_connected; 60051df0accSAmit Shah } 60151df0accSAmit Shah 60251df0accSAmit Shah static bool will_write_block(struct port *port) 60351df0accSAmit Shah { 60451df0accSAmit Shah bool ret; 60551df0accSAmit Shah 60651df0accSAmit Shah if (!port->guest_connected) { 60751df0accSAmit Shah /* Port got hot-unplugged. Let's exit. */ 60851df0accSAmit Shah return false; 60951df0accSAmit Shah } 61051df0accSAmit Shah if (!port->host_connected) 61151df0accSAmit Shah return true; 61251df0accSAmit Shah 61351df0accSAmit Shah spin_lock_irq(&port->outvq_lock); 61451df0accSAmit Shah /* 61551df0accSAmit Shah * Check if the Host has consumed any buffers since we last 61651df0accSAmit Shah * sent data (this is only applicable for nonblocking ports). 61751df0accSAmit Shah */ 61851df0accSAmit Shah reclaim_consumed_buffers(port); 61951df0accSAmit Shah ret = port->outvq_full; 62051df0accSAmit Shah spin_unlock_irq(&port->outvq_lock); 62151df0accSAmit Shah 62251df0accSAmit Shah return ret; 62351df0accSAmit Shah } 62451df0accSAmit Shah 62551df0accSAmit Shah static ssize_t port_fops_read(struct file *filp, char __user *ubuf, 62651df0accSAmit Shah size_t count, loff_t *offp) 62751df0accSAmit Shah { 62851df0accSAmit Shah struct port *port; 62951df0accSAmit Shah ssize_t ret; 63051df0accSAmit Shah 63151df0accSAmit Shah port = filp->private_data; 63251df0accSAmit Shah 63351df0accSAmit Shah if (!port_has_data(port)) { 63451df0accSAmit Shah /* 63551df0accSAmit Shah * If nothing's connected on the host just return 0 in 63651df0accSAmit Shah * case of list_empty; this tells the userspace app 63751df0accSAmit Shah * that there's no connection 63851df0accSAmit Shah */ 63951df0accSAmit Shah if (!port->host_connected) 64051df0accSAmit Shah return 0; 64151df0accSAmit Shah if (filp->f_flags & O_NONBLOCK) 64251df0accSAmit Shah return -EAGAIN; 64351df0accSAmit Shah 644a08fa92dSAmit Shah ret = wait_event_freezable(port->waitqueue, 64551df0accSAmit Shah !will_read_block(port)); 64651df0accSAmit Shah if (ret < 0) 64751df0accSAmit Shah return ret; 64851df0accSAmit Shah } 64951df0accSAmit Shah /* Port got hot-unplugged. */ 65051df0accSAmit Shah if (!port->guest_connected) 65151df0accSAmit Shah return -ENODEV; 65251df0accSAmit Shah /* 65351df0accSAmit Shah * We could've received a disconnection message while we were 65451df0accSAmit Shah * waiting for more data. 65551df0accSAmit Shah * 65651df0accSAmit Shah * This check is not clubbed in the if() statement above as we 65751df0accSAmit Shah * might receive some data as well as the host could get 65851df0accSAmit Shah * disconnected after we got woken up from our wait. So we 65951df0accSAmit Shah * really want to give off whatever data we have and only then 66051df0accSAmit Shah * check for host_connected. 66151df0accSAmit Shah */ 66251df0accSAmit Shah if (!port_has_data(port) && !port->host_connected) 66351df0accSAmit Shah return 0; 66451df0accSAmit Shah 66551df0accSAmit Shah return fill_readbuf(port, ubuf, count, true); 66651df0accSAmit Shah } 66751df0accSAmit Shah 66851df0accSAmit Shah static ssize_t port_fops_write(struct file *filp, const char __user *ubuf, 66951df0accSAmit Shah size_t count, loff_t *offp) 67051df0accSAmit Shah { 67151df0accSAmit Shah struct port *port; 67251df0accSAmit Shah char *buf; 67351df0accSAmit Shah ssize_t ret; 67451df0accSAmit Shah bool nonblock; 67551df0accSAmit Shah 67651df0accSAmit Shah /* Userspace could be out to fool us */ 67751df0accSAmit Shah if (!count) 67851df0accSAmit Shah return 0; 67951df0accSAmit Shah 68051df0accSAmit Shah port = filp->private_data; 68151df0accSAmit Shah 68251df0accSAmit Shah nonblock = filp->f_flags & O_NONBLOCK; 68351df0accSAmit Shah 68451df0accSAmit Shah if (will_write_block(port)) { 68551df0accSAmit Shah if (nonblock) 68651df0accSAmit Shah return -EAGAIN; 68751df0accSAmit Shah 688a08fa92dSAmit Shah ret = wait_event_freezable(port->waitqueue, 68951df0accSAmit Shah !will_write_block(port)); 69051df0accSAmit Shah if (ret < 0) 69151df0accSAmit Shah return ret; 69251df0accSAmit Shah } 69351df0accSAmit Shah /* Port got hot-unplugged. */ 69451df0accSAmit Shah if (!port->guest_connected) 69551df0accSAmit Shah return -ENODEV; 69651df0accSAmit Shah 69751df0accSAmit Shah count = min((size_t)(32 * 1024), count); 69851df0accSAmit Shah 69951df0accSAmit Shah buf = kmalloc(count, GFP_KERNEL); 70051df0accSAmit Shah if (!buf) 70151df0accSAmit Shah return -ENOMEM; 70251df0accSAmit Shah 70351df0accSAmit Shah ret = copy_from_user(buf, ubuf, count); 70451df0accSAmit Shah if (ret) { 70551df0accSAmit Shah ret = -EFAULT; 70651df0accSAmit Shah goto free_buf; 70751df0accSAmit Shah } 70851df0accSAmit Shah 70951df0accSAmit Shah /* 71051df0accSAmit Shah * We now ask send_buf() to not spin for generic ports -- we 71151df0accSAmit Shah * can re-use the same code path that non-blocking file 71251df0accSAmit Shah * descriptors take for blocking file descriptors since the 71351df0accSAmit Shah * wait is already done and we're certain the write will go 71451df0accSAmit Shah * through to the host. 71551df0accSAmit Shah */ 71651df0accSAmit Shah nonblock = true; 71751df0accSAmit Shah ret = send_buf(port, buf, count, nonblock); 71851df0accSAmit Shah 71951df0accSAmit Shah if (nonblock && ret > 0) 72051df0accSAmit Shah goto out; 72151df0accSAmit Shah 72251df0accSAmit Shah free_buf: 72351df0accSAmit Shah kfree(buf); 72451df0accSAmit Shah out: 72551df0accSAmit Shah return ret; 72651df0accSAmit Shah } 72751df0accSAmit Shah 72851df0accSAmit Shah static unsigned int port_fops_poll(struct file *filp, poll_table *wait) 72951df0accSAmit Shah { 73051df0accSAmit Shah struct port *port; 73151df0accSAmit Shah unsigned int ret; 73251df0accSAmit Shah 73351df0accSAmit Shah port = filp->private_data; 73451df0accSAmit Shah poll_wait(filp, &port->waitqueue, wait); 73551df0accSAmit Shah 73651df0accSAmit Shah if (!port->guest_connected) { 73751df0accSAmit Shah /* Port got unplugged */ 73851df0accSAmit Shah return POLLHUP; 73951df0accSAmit Shah } 74051df0accSAmit Shah ret = 0; 74151df0accSAmit Shah if (!will_read_block(port)) 74251df0accSAmit Shah ret |= POLLIN | POLLRDNORM; 74351df0accSAmit Shah if (!will_write_block(port)) 74451df0accSAmit Shah ret |= POLLOUT; 74551df0accSAmit Shah if (!port->host_connected) 74651df0accSAmit Shah ret |= POLLHUP; 74751df0accSAmit Shah 74851df0accSAmit Shah return ret; 74951df0accSAmit Shah } 75051df0accSAmit Shah 75151df0accSAmit Shah static void remove_port(struct kref *kref); 75251df0accSAmit Shah 75351df0accSAmit Shah static int port_fops_release(struct inode *inode, struct file *filp) 75451df0accSAmit Shah { 75551df0accSAmit Shah struct port *port; 75651df0accSAmit Shah 75751df0accSAmit Shah port = filp->private_data; 75851df0accSAmit Shah 75951df0accSAmit Shah /* Notify host of port being closed */ 76051df0accSAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0); 76151df0accSAmit Shah 76251df0accSAmit Shah spin_lock_irq(&port->inbuf_lock); 76351df0accSAmit Shah port->guest_connected = false; 76451df0accSAmit Shah 76551df0accSAmit Shah discard_port_data(port); 76651df0accSAmit Shah 76751df0accSAmit Shah spin_unlock_irq(&port->inbuf_lock); 76851df0accSAmit Shah 76951df0accSAmit Shah spin_lock_irq(&port->outvq_lock); 77051df0accSAmit Shah reclaim_consumed_buffers(port); 77151df0accSAmit Shah spin_unlock_irq(&port->outvq_lock); 77251df0accSAmit Shah 77351df0accSAmit Shah /* 77451df0accSAmit Shah * Locks aren't necessary here as a port can't be opened after 77551df0accSAmit Shah * unplug, and if a port isn't unplugged, a kref would already 77651df0accSAmit Shah * exist for the port. Plus, taking ports_lock here would 77751df0accSAmit Shah * create a dependency on other locks taken by functions 77851df0accSAmit Shah * inside remove_port if we're the last holder of the port, 77951df0accSAmit Shah * creating many problems. 78051df0accSAmit Shah */ 78151df0accSAmit Shah kref_put(&port->kref, remove_port); 78251df0accSAmit Shah 78351df0accSAmit Shah return 0; 78451df0accSAmit Shah } 78551df0accSAmit Shah 78651df0accSAmit Shah static int port_fops_open(struct inode *inode, struct file *filp) 78751df0accSAmit Shah { 78851df0accSAmit Shah struct cdev *cdev = inode->i_cdev; 78951df0accSAmit Shah struct port *port; 79051df0accSAmit Shah int ret; 79151df0accSAmit Shah 79251df0accSAmit Shah port = find_port_by_devt(cdev->dev); 79351df0accSAmit Shah filp->private_data = port; 79451df0accSAmit Shah 79551df0accSAmit Shah /* Prevent against a port getting hot-unplugged at the same time */ 79651df0accSAmit Shah spin_lock_irq(&port->portdev->ports_lock); 79751df0accSAmit Shah kref_get(&port->kref); 79851df0accSAmit Shah spin_unlock_irq(&port->portdev->ports_lock); 79951df0accSAmit Shah 80051df0accSAmit Shah /* 80151df0accSAmit Shah * Don't allow opening of console port devices -- that's done 80251df0accSAmit Shah * via /dev/hvc 80351df0accSAmit Shah */ 80451df0accSAmit Shah if (is_console_port(port)) { 80551df0accSAmit Shah ret = -ENXIO; 80651df0accSAmit Shah goto out; 80751df0accSAmit Shah } 80851df0accSAmit Shah 80951df0accSAmit Shah /* Allow only one process to open a particular port at a time */ 81051df0accSAmit Shah spin_lock_irq(&port->inbuf_lock); 81151df0accSAmit Shah if (port->guest_connected) { 81251df0accSAmit Shah spin_unlock_irq(&port->inbuf_lock); 81351df0accSAmit Shah ret = -EMFILE; 81451df0accSAmit Shah goto out; 81551df0accSAmit Shah } 81651df0accSAmit Shah 81751df0accSAmit Shah port->guest_connected = true; 81851df0accSAmit Shah spin_unlock_irq(&port->inbuf_lock); 81951df0accSAmit Shah 82051df0accSAmit Shah spin_lock_irq(&port->outvq_lock); 82151df0accSAmit Shah /* 82251df0accSAmit Shah * There might be a chance that we missed reclaiming a few 82351df0accSAmit Shah * buffers in the window of the port getting previously closed 82451df0accSAmit Shah * and opening now. 82551df0accSAmit Shah */ 82651df0accSAmit Shah reclaim_consumed_buffers(port); 82751df0accSAmit Shah spin_unlock_irq(&port->outvq_lock); 82851df0accSAmit Shah 82951df0accSAmit Shah nonseekable_open(inode, filp); 83051df0accSAmit Shah 83151df0accSAmit Shah /* Notify host of port being opened */ 83251df0accSAmit Shah send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1); 83351df0accSAmit Shah 83451df0accSAmit Shah return 0; 83551df0accSAmit Shah out: 83651df0accSAmit Shah kref_put(&port->kref, remove_port); 83751df0accSAmit Shah return ret; 83851df0accSAmit Shah } 83951df0accSAmit Shah 84051df0accSAmit Shah static int port_fops_fasync(int fd, struct file *filp, int mode) 84151df0accSAmit Shah { 84251df0accSAmit Shah struct port *port; 84351df0accSAmit Shah 84451df0accSAmit Shah port = filp->private_data; 84551df0accSAmit Shah return fasync_helper(fd, filp, mode, &port->async_queue); 84651df0accSAmit Shah } 84751df0accSAmit Shah 84851df0accSAmit Shah /* 84951df0accSAmit Shah * The file operations that we support: programs in the guest can open 85051df0accSAmit Shah * a console device, read from it, write to it, poll for data and 85151df0accSAmit Shah * close it. The devices are at 85251df0accSAmit Shah * /dev/vport<device number>p<port number> 85351df0accSAmit Shah */ 85451df0accSAmit Shah static const struct file_operations port_fops = { 85551df0accSAmit Shah .owner = THIS_MODULE, 85651df0accSAmit Shah .open = port_fops_open, 85751df0accSAmit Shah .read = port_fops_read, 85851df0accSAmit Shah .write = port_fops_write, 85951df0accSAmit Shah .poll = port_fops_poll, 86051df0accSAmit Shah .release = port_fops_release, 86151df0accSAmit Shah .fasync = port_fops_fasync, 86251df0accSAmit Shah .llseek = no_llseek, 86351df0accSAmit Shah }; 86451df0accSAmit Shah 86551df0accSAmit Shah /* 86651df0accSAmit Shah * The put_chars() callback is pretty straightforward. 86751df0accSAmit Shah * 86851df0accSAmit Shah * We turn the characters into a scatter-gather list, add it to the 86951df0accSAmit Shah * output queue and then kick the Host. Then we sit here waiting for 87051df0accSAmit Shah * it to finish: inefficient in theory, but in practice 87151df0accSAmit Shah * implementations will do it immediately (lguest's Launcher does). 87251df0accSAmit Shah */ 87351df0accSAmit Shah static int put_chars(u32 vtermno, const char *buf, int count) 87451df0accSAmit Shah { 87551df0accSAmit Shah struct port *port; 87651df0accSAmit Shah 87751df0accSAmit Shah if (unlikely(early_put_chars)) 87851df0accSAmit Shah return early_put_chars(vtermno, buf, count); 87951df0accSAmit Shah 88051df0accSAmit Shah port = find_port_by_vtermno(vtermno); 88151df0accSAmit Shah if (!port) 88251df0accSAmit Shah return -EPIPE; 88351df0accSAmit Shah 88451df0accSAmit Shah return send_buf(port, (void *)buf, count, false); 88551df0accSAmit Shah } 88651df0accSAmit Shah 88751df0accSAmit Shah /* 88851df0accSAmit Shah * get_chars() is the callback from the hvc_console infrastructure 88951df0accSAmit Shah * when an interrupt is received. 89051df0accSAmit Shah * 89151df0accSAmit Shah * We call out to fill_readbuf that gets us the required data from the 89251df0accSAmit Shah * buffers that are queued up. 89351df0accSAmit Shah */ 89451df0accSAmit Shah static int get_chars(u32 vtermno, char *buf, int count) 89551df0accSAmit Shah { 89651df0accSAmit Shah struct port *port; 89751df0accSAmit Shah 89851df0accSAmit Shah /* If we've not set up the port yet, we have no input to give. */ 89951df0accSAmit Shah if (unlikely(early_put_chars)) 90051df0accSAmit Shah return 0; 90151df0accSAmit Shah 90251df0accSAmit Shah port = find_port_by_vtermno(vtermno); 90351df0accSAmit Shah if (!port) 90451df0accSAmit Shah return -EPIPE; 90551df0accSAmit Shah 90651df0accSAmit Shah /* If we don't have an input queue yet, we can't get input. */ 90751df0accSAmit Shah BUG_ON(!port->in_vq); 90851df0accSAmit Shah 90951df0accSAmit Shah return fill_readbuf(port, buf, count, false); 91051df0accSAmit Shah } 91151df0accSAmit Shah 91251df0accSAmit Shah static void resize_console(struct port *port) 91351df0accSAmit Shah { 91451df0accSAmit Shah struct virtio_device *vdev; 91551df0accSAmit Shah 91651df0accSAmit Shah /* The port could have been hot-unplugged */ 91751df0accSAmit Shah if (!port || !is_console_port(port)) 91851df0accSAmit Shah return; 91951df0accSAmit Shah 92051df0accSAmit Shah vdev = port->portdev->vdev; 92151df0accSAmit Shah if (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE)) 92251df0accSAmit Shah hvc_resize(port->cons.hvc, port->cons.ws); 92351df0accSAmit Shah } 92451df0accSAmit Shah 92551df0accSAmit Shah /* We set the configuration at this point, since we now have a tty */ 92651df0accSAmit Shah static int notifier_add_vio(struct hvc_struct *hp, int data) 92751df0accSAmit Shah { 92851df0accSAmit Shah struct port *port; 92951df0accSAmit Shah 93051df0accSAmit Shah port = find_port_by_vtermno(hp->vtermno); 93151df0accSAmit Shah if (!port) 93251df0accSAmit Shah return -EINVAL; 93351df0accSAmit Shah 93451df0accSAmit Shah hp->irq_requested = 1; 93551df0accSAmit Shah resize_console(port); 93651df0accSAmit Shah 93751df0accSAmit Shah return 0; 93851df0accSAmit Shah } 93951df0accSAmit Shah 94051df0accSAmit Shah static void notifier_del_vio(struct hvc_struct *hp, int data) 94151df0accSAmit Shah { 94251df0accSAmit Shah hp->irq_requested = 0; 94351df0accSAmit Shah } 94451df0accSAmit Shah 94551df0accSAmit Shah /* The operations for console ports. */ 94651df0accSAmit Shah static const struct hv_ops hv_ops = { 94751df0accSAmit Shah .get_chars = get_chars, 94851df0accSAmit Shah .put_chars = put_chars, 94951df0accSAmit Shah .notifier_add = notifier_add_vio, 95051df0accSAmit Shah .notifier_del = notifier_del_vio, 95151df0accSAmit Shah .notifier_hangup = notifier_del_vio, 95251df0accSAmit Shah }; 95351df0accSAmit Shah 95451df0accSAmit Shah /* 95551df0accSAmit Shah * Console drivers are initialized very early so boot messages can go 95651df0accSAmit Shah * out, so we do things slightly differently from the generic virtio 95751df0accSAmit Shah * initialization of the net and block drivers. 95851df0accSAmit Shah * 95951df0accSAmit Shah * At this stage, the console is output-only. It's too early to set 96051df0accSAmit Shah * up a virtqueue, so we let the drivers do some boutique early-output 96151df0accSAmit Shah * thing. 96251df0accSAmit Shah */ 96351df0accSAmit Shah int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int)) 96451df0accSAmit Shah { 96551df0accSAmit Shah early_put_chars = put_chars; 96651df0accSAmit Shah return hvc_instantiate(0, 0, &hv_ops); 96751df0accSAmit Shah } 96851df0accSAmit Shah 96951df0accSAmit Shah int init_port_console(struct port *port) 97051df0accSAmit Shah { 97151df0accSAmit Shah int ret; 97251df0accSAmit Shah 97351df0accSAmit Shah /* 97451df0accSAmit Shah * The Host's telling us this port is a console port. Hook it 97551df0accSAmit Shah * up with an hvc console. 97651df0accSAmit Shah * 97751df0accSAmit Shah * To set up and manage our virtual console, we call 97851df0accSAmit Shah * hvc_alloc(). 97951df0accSAmit Shah * 98051df0accSAmit Shah * The first argument of hvc_alloc() is the virtual console 98151df0accSAmit Shah * number. The second argument is the parameter for the 98251df0accSAmit Shah * notification mechanism (like irq number). We currently 98351df0accSAmit Shah * leave this as zero, virtqueues have implicit notifications. 98451df0accSAmit Shah * 98551df0accSAmit Shah * The third argument is a "struct hv_ops" containing the 98651df0accSAmit Shah * put_chars() get_chars(), notifier_add() and notifier_del() 98751df0accSAmit Shah * pointers. The final argument is the output buffer size: we 98851df0accSAmit Shah * can do any size, so we put PAGE_SIZE here. 98951df0accSAmit Shah */ 99051df0accSAmit Shah port->cons.vtermno = pdrvdata.next_vtermno; 99151df0accSAmit Shah 99251df0accSAmit Shah port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE); 99351df0accSAmit Shah if (IS_ERR(port->cons.hvc)) { 99451df0accSAmit Shah ret = PTR_ERR(port->cons.hvc); 99551df0accSAmit Shah dev_err(port->dev, 99651df0accSAmit Shah "error %d allocating hvc for port\n", ret); 99751df0accSAmit Shah port->cons.hvc = NULL; 99851df0accSAmit Shah return ret; 99951df0accSAmit Shah } 100051df0accSAmit Shah spin_lock_irq(&pdrvdata_lock); 100151df0accSAmit Shah pdrvdata.next_vtermno++; 100251df0accSAmit Shah list_add_tail(&port->cons.list, &pdrvdata.consoles); 100351df0accSAmit Shah spin_unlock_irq(&pdrvdata_lock); 100451df0accSAmit Shah port->guest_connected = true; 100551df0accSAmit Shah 100651df0accSAmit Shah /* 100751df0accSAmit Shah * Start using the new console output if this is the first 100851df0accSAmit Shah * console to come up. 100951df0accSAmit Shah */ 101051df0accSAmit Shah if (early_put_chars) 101151df0accSAmit Shah early_put_chars = NULL; 101251df0accSAmit Shah 101351df0accSAmit Shah /* Notify host of port being opened */ 101451df0accSAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1); 101551df0accSAmit Shah 101651df0accSAmit Shah return 0; 101751df0accSAmit Shah } 101851df0accSAmit Shah 101951df0accSAmit Shah static ssize_t show_port_name(struct device *dev, 102051df0accSAmit Shah struct device_attribute *attr, char *buffer) 102151df0accSAmit Shah { 102251df0accSAmit Shah struct port *port; 102351df0accSAmit Shah 102451df0accSAmit Shah port = dev_get_drvdata(dev); 102551df0accSAmit Shah 102651df0accSAmit Shah return sprintf(buffer, "%s\n", port->name); 102751df0accSAmit Shah } 102851df0accSAmit Shah 102951df0accSAmit Shah static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL); 103051df0accSAmit Shah 103151df0accSAmit Shah static struct attribute *port_sysfs_entries[] = { 103251df0accSAmit Shah &dev_attr_name.attr, 103351df0accSAmit Shah NULL 103451df0accSAmit Shah }; 103551df0accSAmit Shah 103651df0accSAmit Shah static struct attribute_group port_attribute_group = { 103751df0accSAmit Shah .name = NULL, /* put in device directory */ 103851df0accSAmit Shah .attrs = port_sysfs_entries, 103951df0accSAmit Shah }; 104051df0accSAmit Shah 104151df0accSAmit Shah static ssize_t debugfs_read(struct file *filp, char __user *ubuf, 104251df0accSAmit Shah size_t count, loff_t *offp) 104351df0accSAmit Shah { 104451df0accSAmit Shah struct port *port; 104551df0accSAmit Shah char *buf; 104651df0accSAmit Shah ssize_t ret, out_offset, out_count; 104751df0accSAmit Shah 104851df0accSAmit Shah out_count = 1024; 104951df0accSAmit Shah buf = kmalloc(out_count, GFP_KERNEL); 105051df0accSAmit Shah if (!buf) 105151df0accSAmit Shah return -ENOMEM; 105251df0accSAmit Shah 105351df0accSAmit Shah port = filp->private_data; 105451df0accSAmit Shah out_offset = 0; 105551df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count, 105651df0accSAmit Shah "name: %s\n", port->name ? port->name : ""); 105751df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 105851df0accSAmit Shah "guest_connected: %d\n", port->guest_connected); 105951df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 106051df0accSAmit Shah "host_connected: %d\n", port->host_connected); 106151df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 106251df0accSAmit Shah "outvq_full: %d\n", port->outvq_full); 106351df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 106417e5b4f2SAmit Shah "bytes_sent: %lu\n", port->stats.bytes_sent); 106517e5b4f2SAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 106617e5b4f2SAmit Shah "bytes_received: %lu\n", 106717e5b4f2SAmit Shah port->stats.bytes_received); 106817e5b4f2SAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 106917e5b4f2SAmit Shah "bytes_discarded: %lu\n", 107017e5b4f2SAmit Shah port->stats.bytes_discarded); 107117e5b4f2SAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 107251df0accSAmit Shah "is_console: %s\n", 107351df0accSAmit Shah is_console_port(port) ? "yes" : "no"); 107451df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 107551df0accSAmit Shah "console_vtermno: %u\n", port->cons.vtermno); 107651df0accSAmit Shah 107751df0accSAmit Shah ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset); 107851df0accSAmit Shah kfree(buf); 107951df0accSAmit Shah return ret; 108051df0accSAmit Shah } 108151df0accSAmit Shah 108251df0accSAmit Shah static const struct file_operations port_debugfs_ops = { 108351df0accSAmit Shah .owner = THIS_MODULE, 1084234e3405SStephen Boyd .open = simple_open, 108551df0accSAmit Shah .read = debugfs_read, 108651df0accSAmit Shah }; 108751df0accSAmit Shah 108851df0accSAmit Shah static void set_console_size(struct port *port, u16 rows, u16 cols) 108951df0accSAmit Shah { 109051df0accSAmit Shah if (!port || !is_console_port(port)) 109151df0accSAmit Shah return; 109251df0accSAmit Shah 109351df0accSAmit Shah port->cons.ws.ws_row = rows; 109451df0accSAmit Shah port->cons.ws.ws_col = cols; 109551df0accSAmit Shah } 109651df0accSAmit Shah 109751df0accSAmit Shah static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock) 109851df0accSAmit Shah { 109951df0accSAmit Shah struct port_buffer *buf; 110051df0accSAmit Shah unsigned int nr_added_bufs; 110151df0accSAmit Shah int ret; 110251df0accSAmit Shah 110351df0accSAmit Shah nr_added_bufs = 0; 110451df0accSAmit Shah do { 110551df0accSAmit Shah buf = alloc_buf(PAGE_SIZE); 110651df0accSAmit Shah if (!buf) 110751df0accSAmit Shah break; 110851df0accSAmit Shah 110951df0accSAmit Shah spin_lock_irq(lock); 111051df0accSAmit Shah ret = add_inbuf(vq, buf); 111151df0accSAmit Shah if (ret < 0) { 111251df0accSAmit Shah spin_unlock_irq(lock); 111351df0accSAmit Shah free_buf(buf); 111451df0accSAmit Shah break; 111551df0accSAmit Shah } 111651df0accSAmit Shah nr_added_bufs++; 111751df0accSAmit Shah spin_unlock_irq(lock); 111851df0accSAmit Shah } while (ret > 0); 111951df0accSAmit Shah 112051df0accSAmit Shah return nr_added_bufs; 112151df0accSAmit Shah } 112251df0accSAmit Shah 112351df0accSAmit Shah static void send_sigio_to_port(struct port *port) 112451df0accSAmit Shah { 112551df0accSAmit Shah if (port->async_queue && port->guest_connected) 112651df0accSAmit Shah kill_fasync(&port->async_queue, SIGIO, POLL_OUT); 112751df0accSAmit Shah } 112851df0accSAmit Shah 112951df0accSAmit Shah static int add_port(struct ports_device *portdev, u32 id) 113051df0accSAmit Shah { 113151df0accSAmit Shah char debugfs_name[16]; 113251df0accSAmit Shah struct port *port; 113351df0accSAmit Shah struct port_buffer *buf; 113451df0accSAmit Shah dev_t devt; 113551df0accSAmit Shah unsigned int nr_added_bufs; 113651df0accSAmit Shah int err; 113751df0accSAmit Shah 113851df0accSAmit Shah port = kmalloc(sizeof(*port), GFP_KERNEL); 113951df0accSAmit Shah if (!port) { 114051df0accSAmit Shah err = -ENOMEM; 114151df0accSAmit Shah goto fail; 114251df0accSAmit Shah } 114351df0accSAmit Shah kref_init(&port->kref); 114451df0accSAmit Shah 114551df0accSAmit Shah port->portdev = portdev; 114651df0accSAmit Shah port->id = id; 114751df0accSAmit Shah 114851df0accSAmit Shah port->name = NULL; 114951df0accSAmit Shah port->inbuf = NULL; 115051df0accSAmit Shah port->cons.hvc = NULL; 115151df0accSAmit Shah port->async_queue = NULL; 115251df0accSAmit Shah 115351df0accSAmit Shah port->cons.ws.ws_row = port->cons.ws.ws_col = 0; 115451df0accSAmit Shah 115551df0accSAmit Shah port->host_connected = port->guest_connected = false; 115617e5b4f2SAmit Shah port->stats = (struct port_stats) { 0 }; 115751df0accSAmit Shah 115851df0accSAmit Shah port->outvq_full = false; 115951df0accSAmit Shah 116051df0accSAmit Shah port->in_vq = portdev->in_vqs[port->id]; 116151df0accSAmit Shah port->out_vq = portdev->out_vqs[port->id]; 116251df0accSAmit Shah 116351df0accSAmit Shah port->cdev = cdev_alloc(); 116451df0accSAmit Shah if (!port->cdev) { 116551df0accSAmit Shah dev_err(&port->portdev->vdev->dev, "Error allocating cdev\n"); 116651df0accSAmit Shah err = -ENOMEM; 116751df0accSAmit Shah goto free_port; 116851df0accSAmit Shah } 116951df0accSAmit Shah port->cdev->ops = &port_fops; 117051df0accSAmit Shah 117151df0accSAmit Shah devt = MKDEV(portdev->chr_major, id); 117251df0accSAmit Shah err = cdev_add(port->cdev, devt, 1); 117351df0accSAmit Shah if (err < 0) { 117451df0accSAmit Shah dev_err(&port->portdev->vdev->dev, 117551df0accSAmit Shah "Error %d adding cdev for port %u\n", err, id); 117651df0accSAmit Shah goto free_cdev; 117751df0accSAmit Shah } 117851df0accSAmit Shah port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev, 117951df0accSAmit Shah devt, port, "vport%up%u", 118051df0accSAmit Shah port->portdev->drv_index, id); 118151df0accSAmit Shah if (IS_ERR(port->dev)) { 118251df0accSAmit Shah err = PTR_ERR(port->dev); 118351df0accSAmit Shah dev_err(&port->portdev->vdev->dev, 118451df0accSAmit Shah "Error %d creating device for port %u\n", 118551df0accSAmit Shah err, id); 118651df0accSAmit Shah goto free_cdev; 118751df0accSAmit Shah } 118851df0accSAmit Shah 118951df0accSAmit Shah spin_lock_init(&port->inbuf_lock); 119051df0accSAmit Shah spin_lock_init(&port->outvq_lock); 119151df0accSAmit Shah init_waitqueue_head(&port->waitqueue); 119251df0accSAmit Shah 119351df0accSAmit Shah /* Fill the in_vq with buffers so the host can send us data. */ 119451df0accSAmit Shah nr_added_bufs = fill_queue(port->in_vq, &port->inbuf_lock); 119551df0accSAmit Shah if (!nr_added_bufs) { 119651df0accSAmit Shah dev_err(port->dev, "Error allocating inbufs\n"); 119751df0accSAmit Shah err = -ENOMEM; 119851df0accSAmit Shah goto free_device; 119951df0accSAmit Shah } 120051df0accSAmit Shah 120151df0accSAmit Shah /* 120251df0accSAmit Shah * If we're not using multiport support, this has to be a console port 120351df0accSAmit Shah */ 120451df0accSAmit Shah if (!use_multiport(port->portdev)) { 120551df0accSAmit Shah err = init_port_console(port); 120651df0accSAmit Shah if (err) 120751df0accSAmit Shah goto free_inbufs; 120851df0accSAmit Shah } 120951df0accSAmit Shah 121051df0accSAmit Shah spin_lock_irq(&portdev->ports_lock); 121151df0accSAmit Shah list_add_tail(&port->list, &port->portdev->ports); 121251df0accSAmit Shah spin_unlock_irq(&portdev->ports_lock); 121351df0accSAmit Shah 121451df0accSAmit Shah /* 121551df0accSAmit Shah * Tell the Host we're set so that it can send us various 121651df0accSAmit Shah * configuration parameters for this port (eg, port name, 121751df0accSAmit Shah * caching, whether this is a console port, etc.) 121851df0accSAmit Shah */ 121951df0accSAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1); 122051df0accSAmit Shah 122151df0accSAmit Shah if (pdrvdata.debugfs_dir) { 122251df0accSAmit Shah /* 122351df0accSAmit Shah * Finally, create the debugfs file that we can use to 122451df0accSAmit Shah * inspect a port's state at any time 122551df0accSAmit Shah */ 122651df0accSAmit Shah sprintf(debugfs_name, "vport%up%u", 122751df0accSAmit Shah port->portdev->drv_index, id); 122851df0accSAmit Shah port->debugfs_file = debugfs_create_file(debugfs_name, 0444, 122951df0accSAmit Shah pdrvdata.debugfs_dir, 123051df0accSAmit Shah port, 123151df0accSAmit Shah &port_debugfs_ops); 123251df0accSAmit Shah } 123351df0accSAmit Shah return 0; 123451df0accSAmit Shah 123551df0accSAmit Shah free_inbufs: 123651df0accSAmit Shah while ((buf = virtqueue_detach_unused_buf(port->in_vq))) 123751df0accSAmit Shah free_buf(buf); 123851df0accSAmit Shah free_device: 123951df0accSAmit Shah device_destroy(pdrvdata.class, port->dev->devt); 124051df0accSAmit Shah free_cdev: 124151df0accSAmit Shah cdev_del(port->cdev); 124251df0accSAmit Shah free_port: 124351df0accSAmit Shah kfree(port); 124451df0accSAmit Shah fail: 124551df0accSAmit Shah /* The host might want to notify management sw about port add failure */ 124651df0accSAmit Shah __send_control_msg(portdev, id, VIRTIO_CONSOLE_PORT_READY, 0); 124751df0accSAmit Shah return err; 124851df0accSAmit Shah } 124951df0accSAmit Shah 125051df0accSAmit Shah /* No users remain, remove all port-specific data. */ 125151df0accSAmit Shah static void remove_port(struct kref *kref) 125251df0accSAmit Shah { 125351df0accSAmit Shah struct port *port; 125451df0accSAmit Shah 125551df0accSAmit Shah port = container_of(kref, struct port, kref); 125651df0accSAmit Shah 125751df0accSAmit Shah sysfs_remove_group(&port->dev->kobj, &port_attribute_group); 125851df0accSAmit Shah device_destroy(pdrvdata.class, port->dev->devt); 125951df0accSAmit Shah cdev_del(port->cdev); 126051df0accSAmit Shah 126151df0accSAmit Shah kfree(port->name); 126251df0accSAmit Shah 126351df0accSAmit Shah debugfs_remove(port->debugfs_file); 126451df0accSAmit Shah 126551df0accSAmit Shah kfree(port); 126651df0accSAmit Shah } 126751df0accSAmit Shah 1268a0e2dbfcSAmit Shah static void remove_port_data(struct port *port) 1269a0e2dbfcSAmit Shah { 1270a0e2dbfcSAmit Shah struct port_buffer *buf; 1271a0e2dbfcSAmit Shah 1272a0e2dbfcSAmit Shah /* Remove unused data this port might have received. */ 1273a0e2dbfcSAmit Shah discard_port_data(port); 1274a0e2dbfcSAmit Shah 1275a0e2dbfcSAmit Shah reclaim_consumed_buffers(port); 1276a0e2dbfcSAmit Shah 1277a0e2dbfcSAmit Shah /* Remove buffers we queued up for the Host to send us data in. */ 1278a0e2dbfcSAmit Shah while ((buf = virtqueue_detach_unused_buf(port->in_vq))) 1279a0e2dbfcSAmit Shah free_buf(buf); 1280a0e2dbfcSAmit Shah } 1281a0e2dbfcSAmit Shah 128251df0accSAmit Shah /* 128351df0accSAmit Shah * Port got unplugged. Remove port from portdev's list and drop the 128451df0accSAmit Shah * kref reference. If no userspace has this port opened, it will 128551df0accSAmit Shah * result in immediate removal the port. 128651df0accSAmit Shah */ 128751df0accSAmit Shah static void unplug_port(struct port *port) 128851df0accSAmit Shah { 128951df0accSAmit Shah spin_lock_irq(&port->portdev->ports_lock); 129051df0accSAmit Shah list_del(&port->list); 129151df0accSAmit Shah spin_unlock_irq(&port->portdev->ports_lock); 129251df0accSAmit Shah 129351df0accSAmit Shah if (port->guest_connected) { 129451df0accSAmit Shah port->guest_connected = false; 129551df0accSAmit Shah port->host_connected = false; 129651df0accSAmit Shah wake_up_interruptible(&port->waitqueue); 129751df0accSAmit Shah 129851df0accSAmit Shah /* Let the app know the port is going down. */ 129951df0accSAmit Shah send_sigio_to_port(port); 130051df0accSAmit Shah } 130151df0accSAmit Shah 130251df0accSAmit Shah if (is_console_port(port)) { 130351df0accSAmit Shah spin_lock_irq(&pdrvdata_lock); 130451df0accSAmit Shah list_del(&port->cons.list); 130551df0accSAmit Shah spin_unlock_irq(&pdrvdata_lock); 130651df0accSAmit Shah hvc_remove(port->cons.hvc); 130751df0accSAmit Shah } 130851df0accSAmit Shah 1309a0e2dbfcSAmit Shah remove_port_data(port); 131051df0accSAmit Shah 131151df0accSAmit Shah /* 131251df0accSAmit Shah * We should just assume the device itself has gone off -- 131351df0accSAmit Shah * else a close on an open port later will try to send out a 131451df0accSAmit Shah * control message. 131551df0accSAmit Shah */ 131651df0accSAmit Shah port->portdev = NULL; 131751df0accSAmit Shah 131851df0accSAmit Shah /* 131951df0accSAmit Shah * Locks around here are not necessary - a port can't be 132051df0accSAmit Shah * opened after we removed the port struct from ports_list 132151df0accSAmit Shah * above. 132251df0accSAmit Shah */ 132351df0accSAmit Shah kref_put(&port->kref, remove_port); 132451df0accSAmit Shah } 132551df0accSAmit Shah 132651df0accSAmit Shah /* Any private messages that the Host and Guest want to share */ 132751df0accSAmit Shah static void handle_control_message(struct ports_device *portdev, 132851df0accSAmit Shah struct port_buffer *buf) 132951df0accSAmit Shah { 133051df0accSAmit Shah struct virtio_console_control *cpkt; 133151df0accSAmit Shah struct port *port; 133251df0accSAmit Shah size_t name_size; 133351df0accSAmit Shah int err; 133451df0accSAmit Shah 133551df0accSAmit Shah cpkt = (struct virtio_console_control *)(buf->buf + buf->offset); 133651df0accSAmit Shah 133751df0accSAmit Shah port = find_port_by_id(portdev, cpkt->id); 133851df0accSAmit Shah if (!port && cpkt->event != VIRTIO_CONSOLE_PORT_ADD) { 133951df0accSAmit Shah /* No valid header at start of buffer. Drop it. */ 134051df0accSAmit Shah dev_dbg(&portdev->vdev->dev, 134151df0accSAmit Shah "Invalid index %u in control packet\n", cpkt->id); 134251df0accSAmit Shah return; 134351df0accSAmit Shah } 134451df0accSAmit Shah 134551df0accSAmit Shah switch (cpkt->event) { 134651df0accSAmit Shah case VIRTIO_CONSOLE_PORT_ADD: 134751df0accSAmit Shah if (port) { 134851df0accSAmit Shah dev_dbg(&portdev->vdev->dev, 134951df0accSAmit Shah "Port %u already added\n", port->id); 135051df0accSAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1); 135151df0accSAmit Shah break; 135251df0accSAmit Shah } 135351df0accSAmit Shah if (cpkt->id >= portdev->config.max_nr_ports) { 135451df0accSAmit Shah dev_warn(&portdev->vdev->dev, 135551df0accSAmit Shah "Request for adding port with out-of-bound id %u, max. supported id: %u\n", 135651df0accSAmit Shah cpkt->id, portdev->config.max_nr_ports - 1); 135751df0accSAmit Shah break; 135851df0accSAmit Shah } 135951df0accSAmit Shah add_port(portdev, cpkt->id); 136051df0accSAmit Shah break; 136151df0accSAmit Shah case VIRTIO_CONSOLE_PORT_REMOVE: 136251df0accSAmit Shah unplug_port(port); 136351df0accSAmit Shah break; 136451df0accSAmit Shah case VIRTIO_CONSOLE_CONSOLE_PORT: 136551df0accSAmit Shah if (!cpkt->value) 136651df0accSAmit Shah break; 136751df0accSAmit Shah if (is_console_port(port)) 136851df0accSAmit Shah break; 136951df0accSAmit Shah 137051df0accSAmit Shah init_port_console(port); 13715e38483bSChristian Borntraeger complete(&early_console_added); 137251df0accSAmit Shah /* 137351df0accSAmit Shah * Could remove the port here in case init fails - but 137451df0accSAmit Shah * have to notify the host first. 137551df0accSAmit Shah */ 137651df0accSAmit Shah break; 137751df0accSAmit Shah case VIRTIO_CONSOLE_RESIZE: { 137851df0accSAmit Shah struct { 137951df0accSAmit Shah __u16 rows; 138051df0accSAmit Shah __u16 cols; 138151df0accSAmit Shah } size; 138251df0accSAmit Shah 138351df0accSAmit Shah if (!is_console_port(port)) 138451df0accSAmit Shah break; 138551df0accSAmit Shah 138651df0accSAmit Shah memcpy(&size, buf->buf + buf->offset + sizeof(*cpkt), 138751df0accSAmit Shah sizeof(size)); 138851df0accSAmit Shah set_console_size(port, size.rows, size.cols); 138951df0accSAmit Shah 139051df0accSAmit Shah port->cons.hvc->irq_requested = 1; 139151df0accSAmit Shah resize_console(port); 139251df0accSAmit Shah break; 139351df0accSAmit Shah } 139451df0accSAmit Shah case VIRTIO_CONSOLE_PORT_OPEN: 139551df0accSAmit Shah port->host_connected = cpkt->value; 139651df0accSAmit Shah wake_up_interruptible(&port->waitqueue); 139751df0accSAmit Shah /* 139851df0accSAmit Shah * If the host port got closed and the host had any 139951df0accSAmit Shah * unconsumed buffers, we'll be able to reclaim them 140051df0accSAmit Shah * now. 140151df0accSAmit Shah */ 140251df0accSAmit Shah spin_lock_irq(&port->outvq_lock); 140351df0accSAmit Shah reclaim_consumed_buffers(port); 140451df0accSAmit Shah spin_unlock_irq(&port->outvq_lock); 140551df0accSAmit Shah 140651df0accSAmit Shah /* 140751df0accSAmit Shah * If the guest is connected, it'll be interested in 140851df0accSAmit Shah * knowing the host connection state changed. 140951df0accSAmit Shah */ 141051df0accSAmit Shah send_sigio_to_port(port); 141151df0accSAmit Shah break; 141251df0accSAmit Shah case VIRTIO_CONSOLE_PORT_NAME: 141351df0accSAmit Shah /* 1414291024efSAmit Shah * If we woke up after hibernation, we can get this 1415291024efSAmit Shah * again. Skip it in that case. 1416291024efSAmit Shah */ 1417291024efSAmit Shah if (port->name) 1418291024efSAmit Shah break; 1419291024efSAmit Shah 1420291024efSAmit Shah /* 142151df0accSAmit Shah * Skip the size of the header and the cpkt to get the size 142251df0accSAmit Shah * of the name that was sent 142351df0accSAmit Shah */ 142451df0accSAmit Shah name_size = buf->len - buf->offset - sizeof(*cpkt) + 1; 142551df0accSAmit Shah 142651df0accSAmit Shah port->name = kmalloc(name_size, GFP_KERNEL); 142751df0accSAmit Shah if (!port->name) { 142851df0accSAmit Shah dev_err(port->dev, 142951df0accSAmit Shah "Not enough space to store port name\n"); 143051df0accSAmit Shah break; 143151df0accSAmit Shah } 143251df0accSAmit Shah strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt), 143351df0accSAmit Shah name_size - 1); 143451df0accSAmit Shah port->name[name_size - 1] = 0; 143551df0accSAmit Shah 143651df0accSAmit Shah /* 143751df0accSAmit Shah * Since we only have one sysfs attribute, 'name', 143851df0accSAmit Shah * create it only if we have a name for the port. 143951df0accSAmit Shah */ 144051df0accSAmit Shah err = sysfs_create_group(&port->dev->kobj, 144151df0accSAmit Shah &port_attribute_group); 144251df0accSAmit Shah if (err) { 144351df0accSAmit Shah dev_err(port->dev, 144451df0accSAmit Shah "Error %d creating sysfs device attributes\n", 144551df0accSAmit Shah err); 144651df0accSAmit Shah } else { 144751df0accSAmit Shah /* 144851df0accSAmit Shah * Generate a udev event so that appropriate 144951df0accSAmit Shah * symlinks can be created based on udev 145051df0accSAmit Shah * rules. 145151df0accSAmit Shah */ 145251df0accSAmit Shah kobject_uevent(&port->dev->kobj, KOBJ_CHANGE); 145351df0accSAmit Shah } 145451df0accSAmit Shah break; 145551df0accSAmit Shah } 145651df0accSAmit Shah } 145751df0accSAmit Shah 145851df0accSAmit Shah static void control_work_handler(struct work_struct *work) 145951df0accSAmit Shah { 146051df0accSAmit Shah struct ports_device *portdev; 146151df0accSAmit Shah struct virtqueue *vq; 146251df0accSAmit Shah struct port_buffer *buf; 146351df0accSAmit Shah unsigned int len; 146451df0accSAmit Shah 146551df0accSAmit Shah portdev = container_of(work, struct ports_device, control_work); 146651df0accSAmit Shah vq = portdev->c_ivq; 146751df0accSAmit Shah 146851df0accSAmit Shah spin_lock(&portdev->cvq_lock); 146951df0accSAmit Shah while ((buf = virtqueue_get_buf(vq, &len))) { 147051df0accSAmit Shah spin_unlock(&portdev->cvq_lock); 147151df0accSAmit Shah 147251df0accSAmit Shah buf->len = len; 147351df0accSAmit Shah buf->offset = 0; 147451df0accSAmit Shah 147551df0accSAmit Shah handle_control_message(portdev, buf); 147651df0accSAmit Shah 147751df0accSAmit Shah spin_lock(&portdev->cvq_lock); 147851df0accSAmit Shah if (add_inbuf(portdev->c_ivq, buf) < 0) { 147951df0accSAmit Shah dev_warn(&portdev->vdev->dev, 148051df0accSAmit Shah "Error adding buffer to queue\n"); 148151df0accSAmit Shah free_buf(buf); 148251df0accSAmit Shah } 148351df0accSAmit Shah } 148451df0accSAmit Shah spin_unlock(&portdev->cvq_lock); 148551df0accSAmit Shah } 148651df0accSAmit Shah 1487ce86d35dSLinus Torvalds static void out_intr(struct virtqueue *vq) 1488ce86d35dSLinus Torvalds { 1489ce86d35dSLinus Torvalds struct port *port; 1490ce86d35dSLinus Torvalds 1491ce86d35dSLinus Torvalds port = find_port_by_vq(vq->vdev->priv, vq); 1492ce86d35dSLinus Torvalds if (!port) 1493ce86d35dSLinus Torvalds return; 1494ce86d35dSLinus Torvalds 1495ce86d35dSLinus Torvalds wake_up_interruptible(&port->waitqueue); 1496ce86d35dSLinus Torvalds } 1497ce86d35dSLinus Torvalds 149851df0accSAmit Shah static void in_intr(struct virtqueue *vq) 149951df0accSAmit Shah { 150051df0accSAmit Shah struct port *port; 150151df0accSAmit Shah unsigned long flags; 150251df0accSAmit Shah 150351df0accSAmit Shah port = find_port_by_vq(vq->vdev->priv, vq); 150451df0accSAmit Shah if (!port) 150551df0accSAmit Shah return; 150651df0accSAmit Shah 150751df0accSAmit Shah spin_lock_irqsave(&port->inbuf_lock, flags); 150851df0accSAmit Shah port->inbuf = get_inbuf(port); 150951df0accSAmit Shah 151051df0accSAmit Shah /* 151151df0accSAmit Shah * Don't queue up data when port is closed. This condition 151251df0accSAmit Shah * can be reached when a console port is not yet connected (no 151351df0accSAmit Shah * tty is spawned) and the host sends out data to console 151451df0accSAmit Shah * ports. For generic serial ports, the host won't 151551df0accSAmit Shah * (shouldn't) send data till the guest is connected. 151651df0accSAmit Shah */ 151751df0accSAmit Shah if (!port->guest_connected) 151851df0accSAmit Shah discard_port_data(port); 151951df0accSAmit Shah 152051df0accSAmit Shah spin_unlock_irqrestore(&port->inbuf_lock, flags); 152151df0accSAmit Shah 152251df0accSAmit Shah wake_up_interruptible(&port->waitqueue); 152351df0accSAmit Shah 152451df0accSAmit Shah /* Send a SIGIO indicating new data in case the process asked for it */ 152551df0accSAmit Shah send_sigio_to_port(port); 152651df0accSAmit Shah 152751df0accSAmit Shah if (is_console_port(port) && hvc_poll(port->cons.hvc)) 152851df0accSAmit Shah hvc_kick(); 152951df0accSAmit Shah } 153051df0accSAmit Shah 153151df0accSAmit Shah static void control_intr(struct virtqueue *vq) 153251df0accSAmit Shah { 153351df0accSAmit Shah struct ports_device *portdev; 153451df0accSAmit Shah 153551df0accSAmit Shah portdev = vq->vdev->priv; 153651df0accSAmit Shah schedule_work(&portdev->control_work); 153751df0accSAmit Shah } 153851df0accSAmit Shah 153951df0accSAmit Shah static void config_intr(struct virtio_device *vdev) 154051df0accSAmit Shah { 154151df0accSAmit Shah struct ports_device *portdev; 154251df0accSAmit Shah 154351df0accSAmit Shah portdev = vdev->priv; 154451df0accSAmit Shah 154551df0accSAmit Shah if (!use_multiport(portdev)) { 154651df0accSAmit Shah struct port *port; 154751df0accSAmit Shah u16 rows, cols; 154851df0accSAmit Shah 154951df0accSAmit Shah vdev->config->get(vdev, 155051df0accSAmit Shah offsetof(struct virtio_console_config, cols), 155151df0accSAmit Shah &cols, sizeof(u16)); 155251df0accSAmit Shah vdev->config->get(vdev, 155351df0accSAmit Shah offsetof(struct virtio_console_config, rows), 155451df0accSAmit Shah &rows, sizeof(u16)); 155551df0accSAmit Shah 155651df0accSAmit Shah port = find_port_by_id(portdev, 0); 155751df0accSAmit Shah set_console_size(port, rows, cols); 155851df0accSAmit Shah 155951df0accSAmit Shah /* 156051df0accSAmit Shah * We'll use this way of resizing only for legacy 156151df0accSAmit Shah * support. For newer userspace 156251df0accSAmit Shah * (VIRTIO_CONSOLE_F_MULTPORT+), use control messages 156351df0accSAmit Shah * to indicate console size changes so that it can be 156451df0accSAmit Shah * done per-port. 156551df0accSAmit Shah */ 156651df0accSAmit Shah resize_console(port); 156751df0accSAmit Shah } 156851df0accSAmit Shah } 156951df0accSAmit Shah 157051df0accSAmit Shah static int init_vqs(struct ports_device *portdev) 157151df0accSAmit Shah { 157251df0accSAmit Shah vq_callback_t **io_callbacks; 157351df0accSAmit Shah char **io_names; 157451df0accSAmit Shah struct virtqueue **vqs; 157551df0accSAmit Shah u32 i, j, nr_ports, nr_queues; 157651df0accSAmit Shah int err; 157751df0accSAmit Shah 157851df0accSAmit Shah nr_ports = portdev->config.max_nr_ports; 157951df0accSAmit Shah nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2; 158051df0accSAmit Shah 158151df0accSAmit Shah vqs = kmalloc(nr_queues * sizeof(struct virtqueue *), GFP_KERNEL); 158251df0accSAmit Shah io_callbacks = kmalloc(nr_queues * sizeof(vq_callback_t *), GFP_KERNEL); 158351df0accSAmit Shah io_names = kmalloc(nr_queues * sizeof(char *), GFP_KERNEL); 158451df0accSAmit Shah portdev->in_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *), 158551df0accSAmit Shah GFP_KERNEL); 158651df0accSAmit Shah portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *), 158751df0accSAmit Shah GFP_KERNEL); 158851df0accSAmit Shah if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs || 158951df0accSAmit Shah !portdev->out_vqs) { 159051df0accSAmit Shah err = -ENOMEM; 159151df0accSAmit Shah goto free; 159251df0accSAmit Shah } 159351df0accSAmit Shah 159451df0accSAmit Shah /* 159551df0accSAmit Shah * For backward compat (newer host but older guest), the host 159651df0accSAmit Shah * spawns a console port first and also inits the vqs for port 159751df0accSAmit Shah * 0 before others. 159851df0accSAmit Shah */ 159951df0accSAmit Shah j = 0; 160051df0accSAmit Shah io_callbacks[j] = in_intr; 1601ce86d35dSLinus Torvalds io_callbacks[j + 1] = out_intr; 160251df0accSAmit Shah io_names[j] = "input"; 160351df0accSAmit Shah io_names[j + 1] = "output"; 160451df0accSAmit Shah j += 2; 160551df0accSAmit Shah 160651df0accSAmit Shah if (use_multiport(portdev)) { 160751df0accSAmit Shah io_callbacks[j] = control_intr; 160851df0accSAmit Shah io_callbacks[j + 1] = NULL; 160951df0accSAmit Shah io_names[j] = "control-i"; 161051df0accSAmit Shah io_names[j + 1] = "control-o"; 161151df0accSAmit Shah 161251df0accSAmit Shah for (i = 1; i < nr_ports; i++) { 161351df0accSAmit Shah j += 2; 161451df0accSAmit Shah io_callbacks[j] = in_intr; 1615ce86d35dSLinus Torvalds io_callbacks[j + 1] = out_intr; 161651df0accSAmit Shah io_names[j] = "input"; 161751df0accSAmit Shah io_names[j + 1] = "output"; 161851df0accSAmit Shah } 161951df0accSAmit Shah } 162051df0accSAmit Shah /* Find the queues. */ 162151df0accSAmit Shah err = portdev->vdev->config->find_vqs(portdev->vdev, nr_queues, vqs, 162251df0accSAmit Shah io_callbacks, 162351df0accSAmit Shah (const char **)io_names); 162451df0accSAmit Shah if (err) 162551df0accSAmit Shah goto free; 162651df0accSAmit Shah 162751df0accSAmit Shah j = 0; 162851df0accSAmit Shah portdev->in_vqs[0] = vqs[0]; 162951df0accSAmit Shah portdev->out_vqs[0] = vqs[1]; 163051df0accSAmit Shah j += 2; 163151df0accSAmit Shah if (use_multiport(portdev)) { 163251df0accSAmit Shah portdev->c_ivq = vqs[j]; 163351df0accSAmit Shah portdev->c_ovq = vqs[j + 1]; 163451df0accSAmit Shah 163551df0accSAmit Shah for (i = 1; i < nr_ports; i++) { 163651df0accSAmit Shah j += 2; 163751df0accSAmit Shah portdev->in_vqs[i] = vqs[j]; 163851df0accSAmit Shah portdev->out_vqs[i] = vqs[j + 1]; 163951df0accSAmit Shah } 164051df0accSAmit Shah } 164151df0accSAmit Shah kfree(io_names); 164251df0accSAmit Shah kfree(io_callbacks); 164351df0accSAmit Shah kfree(vqs); 164451df0accSAmit Shah 164551df0accSAmit Shah return 0; 164651df0accSAmit Shah 164751df0accSAmit Shah free: 164851df0accSAmit Shah kfree(portdev->out_vqs); 164951df0accSAmit Shah kfree(portdev->in_vqs); 165051df0accSAmit Shah kfree(io_names); 165151df0accSAmit Shah kfree(io_callbacks); 165251df0accSAmit Shah kfree(vqs); 165351df0accSAmit Shah 165451df0accSAmit Shah return err; 165551df0accSAmit Shah } 165651df0accSAmit Shah 165751df0accSAmit Shah static const struct file_operations portdev_fops = { 165851df0accSAmit Shah .owner = THIS_MODULE, 165951df0accSAmit Shah }; 166051df0accSAmit Shah 1661a0e2dbfcSAmit Shah static void remove_vqs(struct ports_device *portdev) 1662a0e2dbfcSAmit Shah { 1663a0e2dbfcSAmit Shah portdev->vdev->config->del_vqs(portdev->vdev); 1664a0e2dbfcSAmit Shah kfree(portdev->in_vqs); 1665a0e2dbfcSAmit Shah kfree(portdev->out_vqs); 1666a0e2dbfcSAmit Shah } 1667a0e2dbfcSAmit Shah 1668a0e2dbfcSAmit Shah static void remove_controlq_data(struct ports_device *portdev) 1669a0e2dbfcSAmit Shah { 1670a0e2dbfcSAmit Shah struct port_buffer *buf; 1671a0e2dbfcSAmit Shah unsigned int len; 1672a0e2dbfcSAmit Shah 1673a0e2dbfcSAmit Shah if (!use_multiport(portdev)) 1674a0e2dbfcSAmit Shah return; 1675a0e2dbfcSAmit Shah 1676a0e2dbfcSAmit Shah while ((buf = virtqueue_get_buf(portdev->c_ivq, &len))) 1677a0e2dbfcSAmit Shah free_buf(buf); 1678a0e2dbfcSAmit Shah 1679a0e2dbfcSAmit Shah while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq))) 1680a0e2dbfcSAmit Shah free_buf(buf); 1681a0e2dbfcSAmit Shah } 1682a0e2dbfcSAmit Shah 168351df0accSAmit Shah /* 168451df0accSAmit Shah * Once we're further in boot, we get probed like any other virtio 168551df0accSAmit Shah * device. 168651df0accSAmit Shah * 168751df0accSAmit Shah * If the host also supports multiple console ports, we check the 168851df0accSAmit Shah * config space to see how many ports the host has spawned. We 168951df0accSAmit Shah * initialize each port found. 169051df0accSAmit Shah */ 169151df0accSAmit Shah static int __devinit virtcons_probe(struct virtio_device *vdev) 169251df0accSAmit Shah { 169351df0accSAmit Shah struct ports_device *portdev; 169451df0accSAmit Shah int err; 169551df0accSAmit Shah bool multiport; 16965e38483bSChristian Borntraeger bool early = early_put_chars != NULL; 16975e38483bSChristian Borntraeger 16985e38483bSChristian Borntraeger /* Ensure to read early_put_chars now */ 16995e38483bSChristian Borntraeger barrier(); 170051df0accSAmit Shah 170151df0accSAmit Shah portdev = kmalloc(sizeof(*portdev), GFP_KERNEL); 170251df0accSAmit Shah if (!portdev) { 170351df0accSAmit Shah err = -ENOMEM; 170451df0accSAmit Shah goto fail; 170551df0accSAmit Shah } 170651df0accSAmit Shah 170751df0accSAmit Shah /* Attach this portdev to this virtio_device, and vice-versa. */ 170851df0accSAmit Shah portdev->vdev = vdev; 170951df0accSAmit Shah vdev->priv = portdev; 171051df0accSAmit Shah 171151df0accSAmit Shah spin_lock_irq(&pdrvdata_lock); 171251df0accSAmit Shah portdev->drv_index = pdrvdata.index++; 171351df0accSAmit Shah spin_unlock_irq(&pdrvdata_lock); 171451df0accSAmit Shah 171551df0accSAmit Shah portdev->chr_major = register_chrdev(0, "virtio-portsdev", 171651df0accSAmit Shah &portdev_fops); 171751df0accSAmit Shah if (portdev->chr_major < 0) { 171851df0accSAmit Shah dev_err(&vdev->dev, 171951df0accSAmit Shah "Error %d registering chrdev for device %u\n", 172051df0accSAmit Shah portdev->chr_major, portdev->drv_index); 172151df0accSAmit Shah err = portdev->chr_major; 172251df0accSAmit Shah goto free; 172351df0accSAmit Shah } 172451df0accSAmit Shah 172551df0accSAmit Shah multiport = false; 172651df0accSAmit Shah portdev->config.max_nr_ports = 1; 172751c6d61aSSasha Levin if (virtio_config_val(vdev, VIRTIO_CONSOLE_F_MULTIPORT, 172851c6d61aSSasha Levin offsetof(struct virtio_console_config, 172951df0accSAmit Shah max_nr_ports), 173051c6d61aSSasha Levin &portdev->config.max_nr_ports) == 0) 173151c6d61aSSasha Levin multiport = true; 173251df0accSAmit Shah 173351df0accSAmit Shah err = init_vqs(portdev); 173451df0accSAmit Shah if (err < 0) { 173551df0accSAmit Shah dev_err(&vdev->dev, "Error %d initializing vqs\n", err); 173651df0accSAmit Shah goto free_chrdev; 173751df0accSAmit Shah } 173851df0accSAmit Shah 173951df0accSAmit Shah spin_lock_init(&portdev->ports_lock); 174051df0accSAmit Shah INIT_LIST_HEAD(&portdev->ports); 174151df0accSAmit Shah 174251df0accSAmit Shah if (multiport) { 174351df0accSAmit Shah unsigned int nr_added_bufs; 174451df0accSAmit Shah 174551df0accSAmit Shah spin_lock_init(&portdev->cvq_lock); 174651df0accSAmit Shah INIT_WORK(&portdev->control_work, &control_work_handler); 174751df0accSAmit Shah 174851df0accSAmit Shah nr_added_bufs = fill_queue(portdev->c_ivq, &portdev->cvq_lock); 174951df0accSAmit Shah if (!nr_added_bufs) { 175051df0accSAmit Shah dev_err(&vdev->dev, 175151df0accSAmit Shah "Error allocating buffers for control queue\n"); 175251df0accSAmit Shah err = -ENOMEM; 175351df0accSAmit Shah goto free_vqs; 175451df0accSAmit Shah } 175551df0accSAmit Shah } else { 175651df0accSAmit Shah /* 175751df0accSAmit Shah * For backward compatibility: Create a console port 175851df0accSAmit Shah * if we're running on older host. 175951df0accSAmit Shah */ 176051df0accSAmit Shah add_port(portdev, 0); 176151df0accSAmit Shah } 176251df0accSAmit Shah 176351df0accSAmit Shah spin_lock_irq(&pdrvdata_lock); 176451df0accSAmit Shah list_add_tail(&portdev->list, &pdrvdata.portdevs); 176551df0accSAmit Shah spin_unlock_irq(&pdrvdata_lock); 176651df0accSAmit Shah 176751df0accSAmit Shah __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID, 176851df0accSAmit Shah VIRTIO_CONSOLE_DEVICE_READY, 1); 17695e38483bSChristian Borntraeger 17705e38483bSChristian Borntraeger /* 17715e38483bSChristian Borntraeger * If there was an early virtio console, assume that there are no 17725e38483bSChristian Borntraeger * other consoles. We need to wait until the hvc_alloc matches the 17735e38483bSChristian Borntraeger * hvc_instantiate, otherwise tty_open will complain, resulting in 17745e38483bSChristian Borntraeger * a "Warning: unable to open an initial console" boot failure. 17755e38483bSChristian Borntraeger * Without multiport this is done in add_port above. With multiport 17765e38483bSChristian Borntraeger * this might take some host<->guest communication - thus we have to 17775e38483bSChristian Borntraeger * wait. 17785e38483bSChristian Borntraeger */ 17795e38483bSChristian Borntraeger if (multiport && early) 17805e38483bSChristian Borntraeger wait_for_completion(&early_console_added); 17815e38483bSChristian Borntraeger 178251df0accSAmit Shah return 0; 178351df0accSAmit Shah 178451df0accSAmit Shah free_vqs: 178551df0accSAmit Shah /* The host might want to notify mgmt sw about device add failure */ 178651df0accSAmit Shah __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID, 178751df0accSAmit Shah VIRTIO_CONSOLE_DEVICE_READY, 0); 1788a0e2dbfcSAmit Shah remove_vqs(portdev); 178951df0accSAmit Shah free_chrdev: 179051df0accSAmit Shah unregister_chrdev(portdev->chr_major, "virtio-portsdev"); 179151df0accSAmit Shah free: 179251df0accSAmit Shah kfree(portdev); 179351df0accSAmit Shah fail: 179451df0accSAmit Shah return err; 179551df0accSAmit Shah } 179651df0accSAmit Shah 179751df0accSAmit Shah static void virtcons_remove(struct virtio_device *vdev) 179851df0accSAmit Shah { 179951df0accSAmit Shah struct ports_device *portdev; 180051df0accSAmit Shah struct port *port, *port2; 180151df0accSAmit Shah 180251df0accSAmit Shah portdev = vdev->priv; 180351df0accSAmit Shah 180451df0accSAmit Shah spin_lock_irq(&pdrvdata_lock); 180551df0accSAmit Shah list_del(&portdev->list); 180651df0accSAmit Shah spin_unlock_irq(&pdrvdata_lock); 180751df0accSAmit Shah 180851df0accSAmit Shah /* Disable interrupts for vqs */ 180951df0accSAmit Shah vdev->config->reset(vdev); 181051df0accSAmit Shah /* Finish up work that's lined up */ 181151df0accSAmit Shah cancel_work_sync(&portdev->control_work); 181251df0accSAmit Shah 181351df0accSAmit Shah list_for_each_entry_safe(port, port2, &portdev->ports, list) 181451df0accSAmit Shah unplug_port(port); 181551df0accSAmit Shah 181651df0accSAmit Shah unregister_chrdev(portdev->chr_major, "virtio-portsdev"); 181751df0accSAmit Shah 181851df0accSAmit Shah /* 181951df0accSAmit Shah * When yanking out a device, we immediately lose the 182051df0accSAmit Shah * (device-side) queues. So there's no point in keeping the 182151df0accSAmit Shah * guest side around till we drop our final reference. This 182251df0accSAmit Shah * also means that any ports which are in an open state will 182351df0accSAmit Shah * have to just stop using the port, as the vqs are going 182451df0accSAmit Shah * away. 182551df0accSAmit Shah */ 1826a0e2dbfcSAmit Shah remove_controlq_data(portdev); 1827a0e2dbfcSAmit Shah remove_vqs(portdev); 182851df0accSAmit Shah kfree(portdev); 182951df0accSAmit Shah } 183051df0accSAmit Shah 183151df0accSAmit Shah static struct virtio_device_id id_table[] = { 183251df0accSAmit Shah { VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID }, 183351df0accSAmit Shah { 0 }, 183451df0accSAmit Shah }; 183551df0accSAmit Shah 183651df0accSAmit Shah static unsigned int features[] = { 183751df0accSAmit Shah VIRTIO_CONSOLE_F_SIZE, 183851df0accSAmit Shah VIRTIO_CONSOLE_F_MULTIPORT, 183951df0accSAmit Shah }; 184051df0accSAmit Shah 18412b8f41d8SAmit Shah #ifdef CONFIG_PM 18422b8f41d8SAmit Shah static int virtcons_freeze(struct virtio_device *vdev) 18432b8f41d8SAmit Shah { 18442b8f41d8SAmit Shah struct ports_device *portdev; 18452b8f41d8SAmit Shah struct port *port; 18462b8f41d8SAmit Shah 18472b8f41d8SAmit Shah portdev = vdev->priv; 18482b8f41d8SAmit Shah 18492b8f41d8SAmit Shah vdev->config->reset(vdev); 18502b8f41d8SAmit Shah 1851c743d09dSAmit Shah virtqueue_disable_cb(portdev->c_ivq); 18522b8f41d8SAmit Shah cancel_work_sync(&portdev->control_work); 1853c743d09dSAmit Shah /* 1854c743d09dSAmit Shah * Once more: if control_work_handler() was running, it would 1855c743d09dSAmit Shah * enable the cb as the last step. 1856c743d09dSAmit Shah */ 1857c743d09dSAmit Shah virtqueue_disable_cb(portdev->c_ivq); 18582b8f41d8SAmit Shah remove_controlq_data(portdev); 18592b8f41d8SAmit Shah 18602b8f41d8SAmit Shah list_for_each_entry(port, &portdev->ports, list) { 1861c743d09dSAmit Shah virtqueue_disable_cb(port->in_vq); 1862c743d09dSAmit Shah virtqueue_disable_cb(port->out_vq); 18632b8f41d8SAmit Shah /* 18642b8f41d8SAmit Shah * We'll ask the host later if the new invocation has 18652b8f41d8SAmit Shah * the port opened or closed. 18662b8f41d8SAmit Shah */ 18672b8f41d8SAmit Shah port->host_connected = false; 18682b8f41d8SAmit Shah remove_port_data(port); 18692b8f41d8SAmit Shah } 18702b8f41d8SAmit Shah remove_vqs(portdev); 18712b8f41d8SAmit Shah 18722b8f41d8SAmit Shah return 0; 18732b8f41d8SAmit Shah } 18742b8f41d8SAmit Shah 18752b8f41d8SAmit Shah static int virtcons_restore(struct virtio_device *vdev) 18762b8f41d8SAmit Shah { 18772b8f41d8SAmit Shah struct ports_device *portdev; 18782b8f41d8SAmit Shah struct port *port; 18792b8f41d8SAmit Shah int ret; 18802b8f41d8SAmit Shah 18812b8f41d8SAmit Shah portdev = vdev->priv; 18822b8f41d8SAmit Shah 18832b8f41d8SAmit Shah ret = init_vqs(portdev); 18842b8f41d8SAmit Shah if (ret) 18852b8f41d8SAmit Shah return ret; 18862b8f41d8SAmit Shah 18872b8f41d8SAmit Shah if (use_multiport(portdev)) 18882b8f41d8SAmit Shah fill_queue(portdev->c_ivq, &portdev->cvq_lock); 18892b8f41d8SAmit Shah 18902b8f41d8SAmit Shah list_for_each_entry(port, &portdev->ports, list) { 18912b8f41d8SAmit Shah port->in_vq = portdev->in_vqs[port->id]; 18922b8f41d8SAmit Shah port->out_vq = portdev->out_vqs[port->id]; 18932b8f41d8SAmit Shah 18942b8f41d8SAmit Shah fill_queue(port->in_vq, &port->inbuf_lock); 18952b8f41d8SAmit Shah 18962b8f41d8SAmit Shah /* Get port open/close status on the host */ 18972b8f41d8SAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1); 18982b8f41d8SAmit Shah } 18992b8f41d8SAmit Shah return 0; 19002b8f41d8SAmit Shah } 19012b8f41d8SAmit Shah #endif 19022b8f41d8SAmit Shah 190351df0accSAmit Shah static struct virtio_driver virtio_console = { 190451df0accSAmit Shah .feature_table = features, 190551df0accSAmit Shah .feature_table_size = ARRAY_SIZE(features), 190651df0accSAmit Shah .driver.name = KBUILD_MODNAME, 190751df0accSAmit Shah .driver.owner = THIS_MODULE, 190851df0accSAmit Shah .id_table = id_table, 190951df0accSAmit Shah .probe = virtcons_probe, 191051df0accSAmit Shah .remove = virtcons_remove, 191151df0accSAmit Shah .config_changed = config_intr, 19122b8f41d8SAmit Shah #ifdef CONFIG_PM 19132b8f41d8SAmit Shah .freeze = virtcons_freeze, 19142b8f41d8SAmit Shah .restore = virtcons_restore, 19152b8f41d8SAmit Shah #endif 191651df0accSAmit Shah }; 191751df0accSAmit Shah 191851df0accSAmit Shah static int __init init(void) 191951df0accSAmit Shah { 192051df0accSAmit Shah int err; 192151df0accSAmit Shah 192251df0accSAmit Shah pdrvdata.class = class_create(THIS_MODULE, "virtio-ports"); 192351df0accSAmit Shah if (IS_ERR(pdrvdata.class)) { 192451df0accSAmit Shah err = PTR_ERR(pdrvdata.class); 192551df0accSAmit Shah pr_err("Error %d creating virtio-ports class\n", err); 192651df0accSAmit Shah return err; 192751df0accSAmit Shah } 192851df0accSAmit Shah 192951df0accSAmit Shah pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL); 193051df0accSAmit Shah if (!pdrvdata.debugfs_dir) { 193151df0accSAmit Shah pr_warning("Error %ld creating debugfs dir for virtio-ports\n", 193251df0accSAmit Shah PTR_ERR(pdrvdata.debugfs_dir)); 193351df0accSAmit Shah } 193451df0accSAmit Shah INIT_LIST_HEAD(&pdrvdata.consoles); 193551df0accSAmit Shah INIT_LIST_HEAD(&pdrvdata.portdevs); 193651df0accSAmit Shah 193751df0accSAmit Shah return register_virtio_driver(&virtio_console); 193851df0accSAmit Shah } 193951df0accSAmit Shah 194051df0accSAmit Shah static void __exit fini(void) 194151df0accSAmit Shah { 194251df0accSAmit Shah unregister_virtio_driver(&virtio_console); 194351df0accSAmit Shah 194451df0accSAmit Shah class_destroy(pdrvdata.class); 194551df0accSAmit Shah if (pdrvdata.debugfs_dir) 194651df0accSAmit Shah debugfs_remove_recursive(pdrvdata.debugfs_dir); 194751df0accSAmit Shah } 194851df0accSAmit Shah module_init(init); 194951df0accSAmit Shah module_exit(fini); 195051df0accSAmit Shah 195151df0accSAmit Shah MODULE_DEVICE_TABLE(virtio, id_table); 195251df0accSAmit Shah MODULE_DESCRIPTION("Virtio console driver"); 195351df0accSAmit Shah MODULE_LICENSE("GPL"); 1954