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> 27eb5e89fcSMasami Hiramatsu #include <linux/splice.h> 28eb5e89fcSMasami Hiramatsu #include <linux/pagemap.h> 2951df0accSAmit Shah #include <linux/init.h> 3051df0accSAmit Shah #include <linux/list.h> 3151df0accSAmit Shah #include <linux/poll.h> 3251df0accSAmit Shah #include <linux/sched.h> 3351df0accSAmit Shah #include <linux/slab.h> 3451df0accSAmit Shah #include <linux/spinlock.h> 3551df0accSAmit Shah #include <linux/virtio.h> 3651df0accSAmit Shah #include <linux/virtio_console.h> 3751df0accSAmit Shah #include <linux/wait.h> 3851df0accSAmit Shah #include <linux/workqueue.h> 39c22405c9SPaul Gortmaker #include <linux/module.h> 401b637046SSjur Brændeland #include <linux/dma-mapping.h> 411b637046SSjur Brændeland #include <linux/kconfig.h> 4251df0accSAmit Shah #include "../tty/hvc/hvc_console.h" 4351df0accSAmit Shah 441b637046SSjur Brændeland #define is_rproc_enabled IS_ENABLED(CONFIG_REMOTEPROC) 451b637046SSjur Brændeland 4651df0accSAmit Shah /* 4751df0accSAmit Shah * This is a global struct for storing common data for all the devices 4851df0accSAmit Shah * this driver handles. 4951df0accSAmit Shah * 5051df0accSAmit Shah * Mainly, it has a linked list for all the consoles in one place so 5151df0accSAmit Shah * that callbacks from hvc for get_chars(), put_chars() work properly 5251df0accSAmit Shah * across multiple devices and multiple ports per device. 5351df0accSAmit Shah */ 5451df0accSAmit Shah struct ports_driver_data { 5551df0accSAmit Shah /* Used for registering chardevs */ 5651df0accSAmit Shah struct class *class; 5751df0accSAmit Shah 5851df0accSAmit Shah /* Used for exporting per-port information to debugfs */ 5951df0accSAmit Shah struct dentry *debugfs_dir; 6051df0accSAmit Shah 6151df0accSAmit Shah /* List of all the devices we're handling */ 6251df0accSAmit Shah struct list_head portdevs; 6351df0accSAmit Shah 6451df0accSAmit Shah /* 6551df0accSAmit Shah * This is used to keep track of the number of hvc consoles 6651df0accSAmit Shah * spawned by this driver. This number is given as the first 6751df0accSAmit Shah * argument to hvc_alloc(). To correctly map an initial 6851df0accSAmit Shah * console spawned via hvc_instantiate to the console being 6951df0accSAmit Shah * hooked up via hvc_alloc, we need to pass the same vtermno. 7051df0accSAmit Shah * 7151df0accSAmit Shah * We also just assume the first console being initialised was 7251df0accSAmit Shah * the first one that got used as the initial console. 7351df0accSAmit Shah */ 7451df0accSAmit Shah unsigned int next_vtermno; 7551df0accSAmit Shah 7651df0accSAmit Shah /* All the console devices handled by this driver */ 7751df0accSAmit Shah struct list_head consoles; 7851df0accSAmit Shah }; 7951df0accSAmit Shah static struct ports_driver_data pdrvdata; 8051df0accSAmit Shah 813826835aSWei Yongjun static DEFINE_SPINLOCK(pdrvdata_lock); 823826835aSWei Yongjun static DECLARE_COMPLETION(early_console_added); 8351df0accSAmit Shah 8451df0accSAmit Shah /* This struct holds information that's relevant only for console ports */ 8551df0accSAmit Shah struct console { 8651df0accSAmit Shah /* We'll place all consoles in a list in the pdrvdata struct */ 8751df0accSAmit Shah struct list_head list; 8851df0accSAmit Shah 8951df0accSAmit Shah /* The hvc device associated with this console port */ 9051df0accSAmit Shah struct hvc_struct *hvc; 9151df0accSAmit Shah 9251df0accSAmit Shah /* The size of the console */ 9351df0accSAmit Shah struct winsize ws; 9451df0accSAmit Shah 9551df0accSAmit Shah /* 9651df0accSAmit Shah * This number identifies the number that we used to register 9751df0accSAmit Shah * with hvc in hvc_instantiate() and hvc_alloc(); this is the 9851df0accSAmit Shah * number passed on by the hvc callbacks to us to 9951df0accSAmit Shah * differentiate between the other console ports handled by 10051df0accSAmit Shah * this driver 10151df0accSAmit Shah */ 10251df0accSAmit Shah u32 vtermno; 10351df0accSAmit Shah }; 10451df0accSAmit Shah 10551df0accSAmit Shah struct port_buffer { 10651df0accSAmit Shah char *buf; 10751df0accSAmit Shah 10851df0accSAmit Shah /* size of the buffer in *buf above */ 10951df0accSAmit Shah size_t size; 11051df0accSAmit Shah 11151df0accSAmit Shah /* used length of the buffer */ 11251df0accSAmit Shah size_t len; 11351df0accSAmit Shah /* offset in the buf from which to consume data */ 11451df0accSAmit Shah size_t offset; 115276a3e95SSjur Brændeland 1161b637046SSjur Brændeland /* DMA address of buffer */ 1171b637046SSjur Brændeland dma_addr_t dma; 1181b637046SSjur Brændeland 1191b637046SSjur Brændeland /* Device we got DMA memory from */ 1201b637046SSjur Brændeland struct device *dev; 1211b637046SSjur Brændeland 1221b637046SSjur Brændeland /* List of pending dma buffers to free */ 1231b637046SSjur Brændeland struct list_head list; 1241b637046SSjur Brændeland 125276a3e95SSjur Brændeland /* If sgpages == 0 then buf is used */ 126276a3e95SSjur Brændeland unsigned int sgpages; 127276a3e95SSjur Brændeland 128276a3e95SSjur Brændeland /* sg is used if spages > 0. sg must be the last in is struct */ 129276a3e95SSjur Brændeland struct scatterlist sg[0]; 13051df0accSAmit Shah }; 13151df0accSAmit Shah 13251df0accSAmit Shah /* 13351df0accSAmit Shah * This is a per-device struct that stores data common to all the 13451df0accSAmit Shah * ports for that device (vdev->priv). 13551df0accSAmit Shah */ 13651df0accSAmit Shah struct ports_device { 13751df0accSAmit Shah /* Next portdev in the list, head is in the pdrvdata struct */ 13851df0accSAmit Shah struct list_head list; 13951df0accSAmit Shah 14051df0accSAmit Shah /* 14151df0accSAmit Shah * Workqueue handlers where we process deferred work after 14251df0accSAmit Shah * notification 14351df0accSAmit Shah */ 14451df0accSAmit Shah struct work_struct control_work; 14551df0accSAmit Shah 14651df0accSAmit Shah struct list_head ports; 14751df0accSAmit Shah 14851df0accSAmit Shah /* To protect the list of ports */ 14951df0accSAmit Shah spinlock_t ports_lock; 15051df0accSAmit Shah 15151df0accSAmit Shah /* To protect the vq operations for the control channel */ 152165b1b8bSAmit Shah spinlock_t c_ivq_lock; 1539ba5c80bSAmit Shah spinlock_t c_ovq_lock; 15451df0accSAmit Shah 15551df0accSAmit Shah /* The current config space is stored here */ 15651df0accSAmit Shah struct virtio_console_config config; 15751df0accSAmit Shah 15851df0accSAmit Shah /* The virtio device we're associated with */ 15951df0accSAmit Shah struct virtio_device *vdev; 16051df0accSAmit Shah 16151df0accSAmit Shah /* 16251df0accSAmit Shah * A couple of virtqueues for the control channel: one for 16351df0accSAmit Shah * guest->host transfers, one for host->guest transfers 16451df0accSAmit Shah */ 16551df0accSAmit Shah struct virtqueue *c_ivq, *c_ovq; 16651df0accSAmit Shah 16751df0accSAmit Shah /* Array of per-port IO virtqueues */ 16851df0accSAmit Shah struct virtqueue **in_vqs, **out_vqs; 16951df0accSAmit Shah 17051df0accSAmit Shah /* Major number for this device. Ports will be created as minors. */ 17151df0accSAmit Shah int chr_major; 17251df0accSAmit Shah }; 17351df0accSAmit Shah 17417e5b4f2SAmit Shah struct port_stats { 17517e5b4f2SAmit Shah unsigned long bytes_sent, bytes_received, bytes_discarded; 17617e5b4f2SAmit Shah }; 17717e5b4f2SAmit Shah 17851df0accSAmit Shah /* This struct holds the per-port data */ 17951df0accSAmit Shah struct port { 18051df0accSAmit Shah /* Next port in the list, head is in the ports_device */ 18151df0accSAmit Shah struct list_head list; 18251df0accSAmit Shah 18351df0accSAmit Shah /* Pointer to the parent virtio_console device */ 18451df0accSAmit Shah struct ports_device *portdev; 18551df0accSAmit Shah 18651df0accSAmit Shah /* The current buffer from which data has to be fed to readers */ 18751df0accSAmit Shah struct port_buffer *inbuf; 18851df0accSAmit Shah 18951df0accSAmit Shah /* 19051df0accSAmit Shah * To protect the operations on the in_vq associated with this 19151df0accSAmit Shah * port. Has to be a spinlock because it can be called from 19251df0accSAmit Shah * interrupt context (get_char()). 19351df0accSAmit Shah */ 19451df0accSAmit Shah spinlock_t inbuf_lock; 19551df0accSAmit Shah 19651df0accSAmit Shah /* Protect the operations on the out_vq. */ 19751df0accSAmit Shah spinlock_t outvq_lock; 19851df0accSAmit Shah 19951df0accSAmit Shah /* The IO vqs for this port */ 20051df0accSAmit Shah struct virtqueue *in_vq, *out_vq; 20151df0accSAmit Shah 20251df0accSAmit Shah /* File in the debugfs directory that exposes this port's information */ 20351df0accSAmit Shah struct dentry *debugfs_file; 20451df0accSAmit Shah 20551df0accSAmit Shah /* 20617e5b4f2SAmit Shah * Keep count of the bytes sent, received and discarded for 20717e5b4f2SAmit Shah * this port for accounting and debugging purposes. These 20817e5b4f2SAmit Shah * counts are not reset across port open / close events. 20917e5b4f2SAmit Shah */ 21017e5b4f2SAmit Shah struct port_stats stats; 21117e5b4f2SAmit Shah 21217e5b4f2SAmit Shah /* 21351df0accSAmit Shah * The entries in this struct will be valid if this port is 21451df0accSAmit Shah * hooked up to an hvc console 21551df0accSAmit Shah */ 21651df0accSAmit Shah struct console cons; 21751df0accSAmit Shah 21851df0accSAmit Shah /* Each port associates with a separate char device */ 21951df0accSAmit Shah struct cdev *cdev; 22051df0accSAmit Shah struct device *dev; 22151df0accSAmit Shah 22251df0accSAmit Shah /* Reference-counting to handle port hot-unplugs and file operations */ 22351df0accSAmit Shah struct kref kref; 22451df0accSAmit Shah 22551df0accSAmit Shah /* A waitqueue for poll() or blocking read operations */ 22651df0accSAmit Shah wait_queue_head_t waitqueue; 22751df0accSAmit Shah 22851df0accSAmit Shah /* The 'name' of the port that we expose via sysfs properties */ 22951df0accSAmit Shah char *name; 23051df0accSAmit Shah 23151df0accSAmit Shah /* We can notify apps of host connect / disconnect events via SIGIO */ 23251df0accSAmit Shah struct fasync_struct *async_queue; 23351df0accSAmit Shah 23451df0accSAmit Shah /* The 'id' to identify the port with the Host */ 23551df0accSAmit Shah u32 id; 23651df0accSAmit Shah 23751df0accSAmit Shah bool outvq_full; 23851df0accSAmit Shah 23951df0accSAmit Shah /* Is the host device open */ 24051df0accSAmit Shah bool host_connected; 24151df0accSAmit Shah 24251df0accSAmit Shah /* We should allow only one process to open a port */ 24351df0accSAmit Shah bool guest_connected; 24451df0accSAmit Shah }; 24551df0accSAmit Shah 24651df0accSAmit Shah /* This is the very early arch-specified put chars function. */ 24751df0accSAmit Shah static int (*early_put_chars)(u32, const char *, int); 24851df0accSAmit Shah 24951df0accSAmit Shah static struct port *find_port_by_vtermno(u32 vtermno) 25051df0accSAmit Shah { 25151df0accSAmit Shah struct port *port; 25251df0accSAmit Shah struct console *cons; 25351df0accSAmit Shah unsigned long flags; 25451df0accSAmit Shah 25551df0accSAmit Shah spin_lock_irqsave(&pdrvdata_lock, flags); 25651df0accSAmit Shah list_for_each_entry(cons, &pdrvdata.consoles, list) { 25751df0accSAmit Shah if (cons->vtermno == vtermno) { 25851df0accSAmit Shah port = container_of(cons, struct port, cons); 25951df0accSAmit Shah goto out; 26051df0accSAmit Shah } 26151df0accSAmit Shah } 26251df0accSAmit Shah port = NULL; 26351df0accSAmit Shah out: 26451df0accSAmit Shah spin_unlock_irqrestore(&pdrvdata_lock, flags); 26551df0accSAmit Shah return port; 26651df0accSAmit Shah } 26751df0accSAmit Shah 26851df0accSAmit Shah static struct port *find_port_by_devt_in_portdev(struct ports_device *portdev, 26951df0accSAmit Shah dev_t dev) 27051df0accSAmit Shah { 27151df0accSAmit Shah struct port *port; 27251df0accSAmit Shah unsigned long flags; 27351df0accSAmit Shah 27451df0accSAmit Shah spin_lock_irqsave(&portdev->ports_lock, flags); 275057b82beSAmit Shah list_for_each_entry(port, &portdev->ports, list) { 276057b82beSAmit Shah if (port->cdev->dev == dev) { 277057b82beSAmit Shah kref_get(&port->kref); 27851df0accSAmit Shah goto out; 279057b82beSAmit Shah } 280057b82beSAmit Shah } 28151df0accSAmit Shah port = NULL; 28251df0accSAmit Shah out: 28351df0accSAmit Shah spin_unlock_irqrestore(&portdev->ports_lock, flags); 28451df0accSAmit Shah 28551df0accSAmit Shah return port; 28651df0accSAmit Shah } 28751df0accSAmit Shah 28851df0accSAmit Shah static struct port *find_port_by_devt(dev_t dev) 28951df0accSAmit Shah { 29051df0accSAmit Shah struct ports_device *portdev; 29151df0accSAmit Shah struct port *port; 29251df0accSAmit Shah unsigned long flags; 29351df0accSAmit Shah 29451df0accSAmit Shah spin_lock_irqsave(&pdrvdata_lock, flags); 29551df0accSAmit Shah list_for_each_entry(portdev, &pdrvdata.portdevs, list) { 29651df0accSAmit Shah port = find_port_by_devt_in_portdev(portdev, dev); 29751df0accSAmit Shah if (port) 29851df0accSAmit Shah goto out; 29951df0accSAmit Shah } 30051df0accSAmit Shah port = NULL; 30151df0accSAmit Shah out: 30251df0accSAmit Shah spin_unlock_irqrestore(&pdrvdata_lock, flags); 30351df0accSAmit Shah return port; 30451df0accSAmit Shah } 30551df0accSAmit Shah 30651df0accSAmit Shah static struct port *find_port_by_id(struct ports_device *portdev, u32 id) 30751df0accSAmit Shah { 30851df0accSAmit Shah struct port *port; 30951df0accSAmit Shah unsigned long flags; 31051df0accSAmit Shah 31151df0accSAmit Shah spin_lock_irqsave(&portdev->ports_lock, flags); 31251df0accSAmit Shah list_for_each_entry(port, &portdev->ports, list) 31351df0accSAmit Shah if (port->id == id) 31451df0accSAmit Shah goto out; 31551df0accSAmit Shah port = NULL; 31651df0accSAmit Shah out: 31751df0accSAmit Shah spin_unlock_irqrestore(&portdev->ports_lock, flags); 31851df0accSAmit Shah 31951df0accSAmit Shah return port; 32051df0accSAmit Shah } 32151df0accSAmit Shah 32251df0accSAmit Shah static struct port *find_port_by_vq(struct ports_device *portdev, 32351df0accSAmit Shah struct virtqueue *vq) 32451df0accSAmit Shah { 32551df0accSAmit Shah struct port *port; 32651df0accSAmit Shah unsigned long flags; 32751df0accSAmit Shah 32851df0accSAmit Shah spin_lock_irqsave(&portdev->ports_lock, flags); 32951df0accSAmit Shah list_for_each_entry(port, &portdev->ports, list) 33051df0accSAmit Shah if (port->in_vq == vq || port->out_vq == vq) 33151df0accSAmit Shah goto out; 33251df0accSAmit Shah port = NULL; 33351df0accSAmit Shah out: 33451df0accSAmit Shah spin_unlock_irqrestore(&portdev->ports_lock, flags); 33551df0accSAmit Shah return port; 33651df0accSAmit Shah } 33751df0accSAmit Shah 33851df0accSAmit Shah static bool is_console_port(struct port *port) 33951df0accSAmit Shah { 34051df0accSAmit Shah if (port->cons.hvc) 34151df0accSAmit Shah return true; 34251df0accSAmit Shah return false; 34351df0accSAmit Shah } 34451df0accSAmit Shah 3451b637046SSjur Brændeland static bool is_rproc_serial(const struct virtio_device *vdev) 3461b637046SSjur Brændeland { 3471b637046SSjur Brændeland return is_rproc_enabled && vdev->id.device == VIRTIO_ID_RPROC_SERIAL; 3481b637046SSjur Brændeland } 3491b637046SSjur Brændeland 35051df0accSAmit Shah static inline bool use_multiport(struct ports_device *portdev) 35151df0accSAmit Shah { 35251df0accSAmit Shah /* 35351df0accSAmit Shah * This condition can be true when put_chars is called from 35451df0accSAmit Shah * early_init 35551df0accSAmit Shah */ 35651df0accSAmit Shah if (!portdev->vdev) 35751df0accSAmit Shah return 0; 358e16e12beSMichael S. Tsirkin return __virtio_test_bit(portdev->vdev, VIRTIO_CONSOLE_F_MULTIPORT); 35951df0accSAmit Shah } 36051df0accSAmit Shah 3611b637046SSjur Brændeland static DEFINE_SPINLOCK(dma_bufs_lock); 3621b637046SSjur Brændeland static LIST_HEAD(pending_free_dma_bufs); 3631b637046SSjur Brændeland 3641b637046SSjur Brændeland static void free_buf(struct port_buffer *buf, bool can_sleep) 36551df0accSAmit Shah { 366276a3e95SSjur Brændeland unsigned int i; 367276a3e95SSjur Brændeland 368276a3e95SSjur Brændeland for (i = 0; i < buf->sgpages; i++) { 369276a3e95SSjur Brændeland struct page *page = sg_page(&buf->sg[i]); 370276a3e95SSjur Brændeland if (!page) 371276a3e95SSjur Brændeland break; 372276a3e95SSjur Brændeland put_page(page); 373276a3e95SSjur Brændeland } 374276a3e95SSjur Brændeland 3751b637046SSjur Brændeland if (!buf->dev) { 37651df0accSAmit Shah kfree(buf->buf); 3771b637046SSjur Brændeland } else if (is_rproc_enabled) { 3781b637046SSjur Brændeland unsigned long flags; 3791b637046SSjur Brændeland 3801b637046SSjur Brændeland /* dma_free_coherent requires interrupts to be enabled. */ 3811b637046SSjur Brændeland if (!can_sleep) { 3821b637046SSjur Brændeland /* queue up dma-buffers to be freed later */ 3831b637046SSjur Brændeland spin_lock_irqsave(&dma_bufs_lock, flags); 3841b637046SSjur Brændeland list_add_tail(&buf->list, &pending_free_dma_bufs); 3851b637046SSjur Brændeland spin_unlock_irqrestore(&dma_bufs_lock, flags); 3861b637046SSjur Brændeland return; 3871b637046SSjur Brændeland } 3881b637046SSjur Brændeland dma_free_coherent(buf->dev, buf->size, buf->buf, buf->dma); 3891b637046SSjur Brændeland 3901b637046SSjur Brændeland /* Release device refcnt and allow it to be freed */ 3911b637046SSjur Brændeland put_device(buf->dev); 3921b637046SSjur Brændeland } 3931b637046SSjur Brændeland 39451df0accSAmit Shah kfree(buf); 39551df0accSAmit Shah } 39651df0accSAmit Shah 3971b637046SSjur Brændeland static void reclaim_dma_bufs(void) 3981b637046SSjur Brændeland { 3991b637046SSjur Brændeland unsigned long flags; 4001b637046SSjur Brændeland struct port_buffer *buf, *tmp; 4011b637046SSjur Brændeland LIST_HEAD(tmp_list); 4021b637046SSjur Brændeland 4031b637046SSjur Brændeland if (list_empty(&pending_free_dma_bufs)) 4041b637046SSjur Brændeland return; 4051b637046SSjur Brændeland 4061b637046SSjur Brændeland /* Create a copy of the pending_free_dma_bufs while holding the lock */ 4071b637046SSjur Brændeland spin_lock_irqsave(&dma_bufs_lock, flags); 4081b637046SSjur Brændeland list_cut_position(&tmp_list, &pending_free_dma_bufs, 4091b637046SSjur Brændeland pending_free_dma_bufs.prev); 4101b637046SSjur Brændeland spin_unlock_irqrestore(&dma_bufs_lock, flags); 4111b637046SSjur Brændeland 4121b637046SSjur Brændeland /* Release the dma buffers, without irqs enabled */ 4131b637046SSjur Brændeland list_for_each_entry_safe(buf, tmp, &tmp_list, list) { 4141b637046SSjur Brændeland list_del(&buf->list); 4151b637046SSjur Brændeland free_buf(buf, true); 4161b637046SSjur Brændeland } 4171b637046SSjur Brændeland } 4181b637046SSjur Brændeland 419276a3e95SSjur Brændeland static struct port_buffer *alloc_buf(struct virtqueue *vq, size_t buf_size, 420276a3e95SSjur Brændeland int pages) 42151df0accSAmit Shah { 42251df0accSAmit Shah struct port_buffer *buf; 42351df0accSAmit Shah 4241b637046SSjur Brændeland reclaim_dma_bufs(); 4251b637046SSjur Brændeland 426276a3e95SSjur Brændeland /* 427276a3e95SSjur Brændeland * Allocate buffer and the sg list. The sg list array is allocated 428276a3e95SSjur Brændeland * directly after the port_buffer struct. 429276a3e95SSjur Brændeland */ 430276a3e95SSjur Brændeland buf = kmalloc(sizeof(*buf) + sizeof(struct scatterlist) * pages, 431276a3e95SSjur Brændeland GFP_KERNEL); 43251df0accSAmit Shah if (!buf) 43351df0accSAmit Shah goto fail; 434276a3e95SSjur Brændeland 435276a3e95SSjur Brændeland buf->sgpages = pages; 436276a3e95SSjur Brændeland if (pages > 0) { 4371b637046SSjur Brændeland buf->dev = NULL; 438276a3e95SSjur Brændeland buf->buf = NULL; 439276a3e95SSjur Brændeland return buf; 440276a3e95SSjur Brændeland } 441276a3e95SSjur Brændeland 4421b637046SSjur Brændeland if (is_rproc_serial(vq->vdev)) { 4431b637046SSjur Brændeland /* 4441b637046SSjur Brændeland * Allocate DMA memory from ancestor. When a virtio 4451b637046SSjur Brændeland * device is created by remoteproc, the DMA memory is 4461b637046SSjur Brændeland * associated with the grandparent device: 4471b637046SSjur Brændeland * vdev => rproc => platform-dev. 4481b637046SSjur Brændeland * The code here would have been less quirky if 4491b637046SSjur Brændeland * DMA_MEMORY_INCLUDES_CHILDREN had been supported 4501b637046SSjur Brændeland * in dma-coherent.c 4511b637046SSjur Brændeland */ 4521b637046SSjur Brændeland if (!vq->vdev->dev.parent || !vq->vdev->dev.parent->parent) 4531b637046SSjur Brændeland goto free_buf; 4541b637046SSjur Brændeland buf->dev = vq->vdev->dev.parent->parent; 4551b637046SSjur Brændeland 4561b637046SSjur Brændeland /* Increase device refcnt to avoid freeing it */ 4571b637046SSjur Brændeland get_device(buf->dev); 4581b637046SSjur Brændeland buf->buf = dma_alloc_coherent(buf->dev, buf_size, &buf->dma, 4591b637046SSjur Brændeland GFP_KERNEL); 4601b637046SSjur Brændeland } else { 4611b637046SSjur Brændeland buf->dev = NULL; 4620127f685SSjur Brændeland buf->buf = kmalloc(buf_size, GFP_KERNEL); 4631b637046SSjur Brændeland } 4641b637046SSjur Brændeland 46551df0accSAmit Shah if (!buf->buf) 46651df0accSAmit Shah goto free_buf; 46751df0accSAmit Shah buf->len = 0; 46851df0accSAmit Shah buf->offset = 0; 46951df0accSAmit Shah buf->size = buf_size; 47051df0accSAmit Shah return buf; 47151df0accSAmit Shah 47251df0accSAmit Shah free_buf: 47351df0accSAmit Shah kfree(buf); 47451df0accSAmit Shah fail: 47551df0accSAmit Shah return NULL; 47651df0accSAmit Shah } 47751df0accSAmit Shah 47851df0accSAmit Shah /* Callers should take appropriate locks */ 479defde669SAmit Shah static struct port_buffer *get_inbuf(struct port *port) 48051df0accSAmit Shah { 48151df0accSAmit Shah struct port_buffer *buf; 48251df0accSAmit Shah unsigned int len; 48351df0accSAmit Shah 484d25a9ddaSAmit Shah if (port->inbuf) 485d25a9ddaSAmit Shah return port->inbuf; 486d25a9ddaSAmit Shah 487d25a9ddaSAmit Shah buf = virtqueue_get_buf(port->in_vq, &len); 48851df0accSAmit Shah if (buf) { 48951df0accSAmit Shah buf->len = len; 49051df0accSAmit Shah buf->offset = 0; 49117e5b4f2SAmit Shah port->stats.bytes_received += len; 49251df0accSAmit Shah } 49351df0accSAmit Shah return buf; 49451df0accSAmit Shah } 49551df0accSAmit Shah 49651df0accSAmit Shah /* 49751df0accSAmit Shah * Create a scatter-gather list representing our input buffer and put 49851df0accSAmit Shah * it in the queue. 49951df0accSAmit Shah * 50051df0accSAmit Shah * Callers should take appropriate locks. 50151df0accSAmit Shah */ 50251df0accSAmit Shah static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf) 50351df0accSAmit Shah { 50451df0accSAmit Shah struct scatterlist sg[1]; 50551df0accSAmit Shah int ret; 50651df0accSAmit Shah 50751df0accSAmit Shah sg_init_one(sg, buf->buf, buf->size); 50851df0accSAmit Shah 5096797999dSRusty Russell ret = virtqueue_add_inbuf(vq, sg, 1, buf, GFP_ATOMIC); 51051df0accSAmit Shah virtqueue_kick(vq); 51149e86f16SAmit Shah if (!ret) 51249e86f16SAmit Shah ret = vq->num_free; 51351df0accSAmit Shah return ret; 51451df0accSAmit Shah } 51551df0accSAmit Shah 51651df0accSAmit Shah /* Discard any unread data this port has. Callers lockers. */ 51751df0accSAmit Shah static void discard_port_data(struct port *port) 51851df0accSAmit Shah { 51951df0accSAmit Shah struct port_buffer *buf; 5202d24cdaaSAmit Shah unsigned int err; 52151df0accSAmit Shah 522d7a62cd0SAmit Shah if (!port->portdev) { 523d7a62cd0SAmit Shah /* Device has been unplugged. vqs are already gone. */ 524d7a62cd0SAmit Shah return; 525d7a62cd0SAmit Shah } 5262d24cdaaSAmit Shah buf = get_inbuf(port); 52751df0accSAmit Shah 528ce072a0cSAmit Shah err = 0; 52951df0accSAmit Shah while (buf) { 53017e5b4f2SAmit Shah port->stats.bytes_discarded += buf->len - buf->offset; 5312d24cdaaSAmit Shah if (add_inbuf(port->in_vq, buf) < 0) { 532ce072a0cSAmit Shah err++; 5331b637046SSjur Brændeland free_buf(buf, false); 53451df0accSAmit Shah } 53551df0accSAmit Shah port->inbuf = NULL; 5362d24cdaaSAmit Shah buf = get_inbuf(port); 5372d24cdaaSAmit Shah } 538ce072a0cSAmit Shah if (err) 53951df0accSAmit Shah dev_warn(port->dev, "Errors adding %d buffers back to vq\n", 540ce072a0cSAmit Shah err); 54151df0accSAmit Shah } 54251df0accSAmit Shah 54351df0accSAmit Shah static bool port_has_data(struct port *port) 54451df0accSAmit Shah { 54551df0accSAmit Shah unsigned long flags; 54651df0accSAmit Shah bool ret; 54751df0accSAmit Shah 54851df0accSAmit Shah ret = false; 549d25a9ddaSAmit Shah spin_lock_irqsave(&port->inbuf_lock, flags); 550d25a9ddaSAmit Shah port->inbuf = get_inbuf(port); 551d25a9ddaSAmit Shah if (port->inbuf) 552d25a9ddaSAmit Shah ret = true; 553d25a9ddaSAmit Shah 55451df0accSAmit Shah spin_unlock_irqrestore(&port->inbuf_lock, flags); 55551df0accSAmit Shah return ret; 55651df0accSAmit Shah } 55751df0accSAmit Shah 55851df0accSAmit Shah static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id, 55951df0accSAmit Shah unsigned int event, unsigned int value) 56051df0accSAmit Shah { 56151df0accSAmit Shah struct scatterlist sg[1]; 56251df0accSAmit Shah struct virtio_console_control cpkt; 56351df0accSAmit Shah struct virtqueue *vq; 56451df0accSAmit Shah unsigned int len; 56551df0accSAmit Shah 56651df0accSAmit Shah if (!use_multiport(portdev)) 56751df0accSAmit Shah return 0; 56851df0accSAmit Shah 5691f0f9106SMichael S. Tsirkin cpkt.id = cpu_to_virtio32(portdev->vdev, port_id); 5701f0f9106SMichael S. Tsirkin cpkt.event = cpu_to_virtio16(portdev->vdev, event); 5711f0f9106SMichael S. Tsirkin cpkt.value = cpu_to_virtio16(portdev->vdev, value); 57251df0accSAmit Shah 57351df0accSAmit Shah vq = portdev->c_ovq; 57451df0accSAmit Shah 57551df0accSAmit Shah sg_init_one(sg, &cpkt, sizeof(cpkt)); 5769ba5c80bSAmit Shah 5779ba5c80bSAmit Shah spin_lock(&portdev->c_ovq_lock); 5786797999dSRusty Russell if (virtqueue_add_outbuf(vq, sg, 1, &cpkt, GFP_ATOMIC) == 0) { 57951df0accSAmit Shah virtqueue_kick(vq); 58040e4dc53SHeinz Graalfs while (!virtqueue_get_buf(vq, &len) 58140e4dc53SHeinz Graalfs && !virtqueue_is_broken(vq)) 58251df0accSAmit Shah cpu_relax(); 58351df0accSAmit Shah } 5849ba5c80bSAmit Shah spin_unlock(&portdev->c_ovq_lock); 58551df0accSAmit Shah return 0; 58651df0accSAmit Shah } 58751df0accSAmit Shah 58851df0accSAmit Shah static ssize_t send_control_msg(struct port *port, unsigned int event, 58951df0accSAmit Shah unsigned int value) 59051df0accSAmit Shah { 59151df0accSAmit Shah /* Did the port get unplugged before userspace closed it? */ 59251df0accSAmit Shah if (port->portdev) 59351df0accSAmit Shah return __send_control_msg(port->portdev, port->id, event, value); 59451df0accSAmit Shah return 0; 59551df0accSAmit Shah } 59651df0accSAmit Shah 597eb5e89fcSMasami Hiramatsu 59851df0accSAmit Shah /* Callers must take the port->outvq_lock */ 59951df0accSAmit Shah static void reclaim_consumed_buffers(struct port *port) 60051df0accSAmit Shah { 601276a3e95SSjur Brændeland struct port_buffer *buf; 60251df0accSAmit Shah unsigned int len; 60351df0accSAmit Shah 604d7a62cd0SAmit Shah if (!port->portdev) { 605d7a62cd0SAmit Shah /* Device has been unplugged. vqs are already gone. */ 606d7a62cd0SAmit Shah return; 607d7a62cd0SAmit Shah } 608276a3e95SSjur Brændeland while ((buf = virtqueue_get_buf(port->out_vq, &len))) { 6091b637046SSjur Brændeland free_buf(buf, false); 61051df0accSAmit Shah port->outvq_full = false; 61151df0accSAmit Shah } 61251df0accSAmit Shah } 61351df0accSAmit Shah 614eb5e89fcSMasami Hiramatsu static ssize_t __send_to_port(struct port *port, struct scatterlist *sg, 615eb5e89fcSMasami Hiramatsu int nents, size_t in_count, 616276a3e95SSjur Brændeland void *data, bool nonblock) 61751df0accSAmit Shah { 61851df0accSAmit Shah struct virtqueue *out_vq; 619589575a2SRusty Russell int err; 62051df0accSAmit Shah unsigned long flags; 62151df0accSAmit Shah unsigned int len; 62251df0accSAmit Shah 62351df0accSAmit Shah out_vq = port->out_vq; 62451df0accSAmit Shah 62551df0accSAmit Shah spin_lock_irqsave(&port->outvq_lock, flags); 62651df0accSAmit Shah 62751df0accSAmit Shah reclaim_consumed_buffers(port); 62851df0accSAmit Shah 6296797999dSRusty Russell err = virtqueue_add_outbuf(out_vq, sg, nents, data, GFP_ATOMIC); 63051df0accSAmit Shah 63151df0accSAmit Shah /* Tell Host to go! */ 63251df0accSAmit Shah virtqueue_kick(out_vq); 63351df0accSAmit Shah 634589575a2SRusty Russell if (err) { 63551df0accSAmit Shah in_count = 0; 63651df0accSAmit Shah goto done; 63751df0accSAmit Shah } 63851df0accSAmit Shah 639589575a2SRusty Russell if (out_vq->num_free == 0) 64051df0accSAmit Shah port->outvq_full = true; 64151df0accSAmit Shah 64251df0accSAmit Shah if (nonblock) 64351df0accSAmit Shah goto done; 64451df0accSAmit Shah 64551df0accSAmit Shah /* 64651df0accSAmit Shah * Wait till the host acknowledges it pushed out the data we 64751df0accSAmit Shah * sent. This is done for data from the hvc_console; the tty 64851df0accSAmit Shah * operations are performed with spinlocks held so we can't 64951df0accSAmit Shah * sleep here. An alternative would be to copy the data to a 65051df0accSAmit Shah * buffer and relax the spinning requirement. The downside is 65151df0accSAmit Shah * we need to kmalloc a GFP_ATOMIC buffer each time the 65251df0accSAmit Shah * console driver writes something out. 65351df0accSAmit Shah */ 65440e4dc53SHeinz Graalfs while (!virtqueue_get_buf(out_vq, &len) 65540e4dc53SHeinz Graalfs && !virtqueue_is_broken(out_vq)) 65651df0accSAmit Shah cpu_relax(); 65751df0accSAmit Shah done: 65851df0accSAmit Shah spin_unlock_irqrestore(&port->outvq_lock, flags); 65917e5b4f2SAmit Shah 66017e5b4f2SAmit Shah port->stats.bytes_sent += in_count; 66151df0accSAmit Shah /* 66251df0accSAmit Shah * We're expected to return the amount of data we wrote -- all 66351df0accSAmit Shah * of it 66451df0accSAmit Shah */ 66551df0accSAmit Shah return in_count; 66651df0accSAmit Shah } 66751df0accSAmit Shah 66851df0accSAmit Shah /* 66951df0accSAmit Shah * Give out the data that's requested from the buffer that we have 67051df0accSAmit Shah * queued up. 67151df0accSAmit Shah */ 67248b36066SMichael S. Tsirkin static ssize_t fill_readbuf(struct port *port, char __user *out_buf, 67348b36066SMichael S. Tsirkin size_t out_count, bool to_user) 67451df0accSAmit Shah { 67551df0accSAmit Shah struct port_buffer *buf; 67651df0accSAmit Shah unsigned long flags; 67751df0accSAmit Shah 67851df0accSAmit Shah if (!out_count || !port_has_data(port)) 67951df0accSAmit Shah return 0; 68051df0accSAmit Shah 68151df0accSAmit Shah buf = port->inbuf; 68251df0accSAmit Shah out_count = min(out_count, buf->len - buf->offset); 68351df0accSAmit Shah 68451df0accSAmit Shah if (to_user) { 68551df0accSAmit Shah ssize_t ret; 68651df0accSAmit Shah 68751df0accSAmit Shah ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count); 68851df0accSAmit Shah if (ret) 68951df0accSAmit Shah return -EFAULT; 69051df0accSAmit Shah } else { 69148b36066SMichael S. Tsirkin memcpy((__force char *)out_buf, buf->buf + buf->offset, 69248b36066SMichael S. Tsirkin out_count); 69351df0accSAmit Shah } 69451df0accSAmit Shah 69551df0accSAmit Shah buf->offset += out_count; 69651df0accSAmit Shah 69751df0accSAmit Shah if (buf->offset == buf->len) { 69851df0accSAmit Shah /* 69951df0accSAmit Shah * We're done using all the data in this buffer. 70051df0accSAmit Shah * Re-queue so that the Host can send us more data. 70151df0accSAmit Shah */ 70251df0accSAmit Shah spin_lock_irqsave(&port->inbuf_lock, flags); 70351df0accSAmit Shah port->inbuf = NULL; 70451df0accSAmit Shah 70551df0accSAmit Shah if (add_inbuf(port->in_vq, buf) < 0) 70651df0accSAmit Shah dev_warn(port->dev, "failed add_buf\n"); 70751df0accSAmit Shah 70851df0accSAmit Shah spin_unlock_irqrestore(&port->inbuf_lock, flags); 70951df0accSAmit Shah } 71051df0accSAmit Shah /* Return the number of bytes actually copied */ 71151df0accSAmit Shah return out_count; 71251df0accSAmit Shah } 71351df0accSAmit Shah 71451df0accSAmit Shah /* The condition that must be true for polling to end */ 71551df0accSAmit Shah static bool will_read_block(struct port *port) 71651df0accSAmit Shah { 71751df0accSAmit Shah if (!port->guest_connected) { 71851df0accSAmit Shah /* Port got hot-unplugged. Let's exit. */ 71951df0accSAmit Shah return false; 72051df0accSAmit Shah } 72151df0accSAmit Shah return !port_has_data(port) && port->host_connected; 72251df0accSAmit Shah } 72351df0accSAmit Shah 72451df0accSAmit Shah static bool will_write_block(struct port *port) 72551df0accSAmit Shah { 72651df0accSAmit Shah bool ret; 72751df0accSAmit Shah 72851df0accSAmit Shah if (!port->guest_connected) { 72951df0accSAmit Shah /* Port got hot-unplugged. Let's exit. */ 73051df0accSAmit Shah return false; 73151df0accSAmit Shah } 73251df0accSAmit Shah if (!port->host_connected) 73351df0accSAmit Shah return true; 73451df0accSAmit Shah 73551df0accSAmit Shah spin_lock_irq(&port->outvq_lock); 73651df0accSAmit Shah /* 73751df0accSAmit Shah * Check if the Host has consumed any buffers since we last 73851df0accSAmit Shah * sent data (this is only applicable for nonblocking ports). 73951df0accSAmit Shah */ 74051df0accSAmit Shah reclaim_consumed_buffers(port); 74151df0accSAmit Shah ret = port->outvq_full; 74251df0accSAmit Shah spin_unlock_irq(&port->outvq_lock); 74351df0accSAmit Shah 74451df0accSAmit Shah return ret; 74551df0accSAmit Shah } 74651df0accSAmit Shah 74751df0accSAmit Shah static ssize_t port_fops_read(struct file *filp, char __user *ubuf, 74851df0accSAmit Shah size_t count, loff_t *offp) 74951df0accSAmit Shah { 75051df0accSAmit Shah struct port *port; 75151df0accSAmit Shah ssize_t ret; 75251df0accSAmit Shah 75351df0accSAmit Shah port = filp->private_data; 75451df0accSAmit Shah 75596f97a83SAmit Shah /* Port is hot-unplugged. */ 75696f97a83SAmit Shah if (!port->guest_connected) 75796f97a83SAmit Shah return -ENODEV; 75896f97a83SAmit Shah 75951df0accSAmit Shah if (!port_has_data(port)) { 76051df0accSAmit Shah /* 76151df0accSAmit Shah * If nothing's connected on the host just return 0 in 76251df0accSAmit Shah * case of list_empty; this tells the userspace app 76351df0accSAmit Shah * that there's no connection 76451df0accSAmit Shah */ 76551df0accSAmit Shah if (!port->host_connected) 76651df0accSAmit Shah return 0; 76751df0accSAmit Shah if (filp->f_flags & O_NONBLOCK) 76851df0accSAmit Shah return -EAGAIN; 76951df0accSAmit Shah 770a08fa92dSAmit Shah ret = wait_event_freezable(port->waitqueue, 77151df0accSAmit Shah !will_read_block(port)); 77251df0accSAmit Shah if (ret < 0) 77351df0accSAmit Shah return ret; 77451df0accSAmit Shah } 77596f97a83SAmit Shah /* Port got hot-unplugged while we were waiting above. */ 77651df0accSAmit Shah if (!port->guest_connected) 77751df0accSAmit Shah return -ENODEV; 77851df0accSAmit Shah /* 77951df0accSAmit Shah * We could've received a disconnection message while we were 78051df0accSAmit Shah * waiting for more data. 78151df0accSAmit Shah * 78251df0accSAmit Shah * This check is not clubbed in the if() statement above as we 78351df0accSAmit Shah * might receive some data as well as the host could get 78451df0accSAmit Shah * disconnected after we got woken up from our wait. So we 78551df0accSAmit Shah * really want to give off whatever data we have and only then 78651df0accSAmit Shah * check for host_connected. 78751df0accSAmit Shah */ 78851df0accSAmit Shah if (!port_has_data(port) && !port->host_connected) 78951df0accSAmit Shah return 0; 79051df0accSAmit Shah 79151df0accSAmit Shah return fill_readbuf(port, ubuf, count, true); 79251df0accSAmit Shah } 79351df0accSAmit Shah 794efe75d24SMasami Hiramatsu static int wait_port_writable(struct port *port, bool nonblock) 795efe75d24SMasami Hiramatsu { 796efe75d24SMasami Hiramatsu int ret; 797efe75d24SMasami Hiramatsu 798efe75d24SMasami Hiramatsu if (will_write_block(port)) { 799efe75d24SMasami Hiramatsu if (nonblock) 800efe75d24SMasami Hiramatsu return -EAGAIN; 801efe75d24SMasami Hiramatsu 802efe75d24SMasami Hiramatsu ret = wait_event_freezable(port->waitqueue, 803efe75d24SMasami Hiramatsu !will_write_block(port)); 804efe75d24SMasami Hiramatsu if (ret < 0) 805efe75d24SMasami Hiramatsu return ret; 806efe75d24SMasami Hiramatsu } 807efe75d24SMasami Hiramatsu /* Port got hot-unplugged. */ 808efe75d24SMasami Hiramatsu if (!port->guest_connected) 809efe75d24SMasami Hiramatsu return -ENODEV; 810efe75d24SMasami Hiramatsu 811efe75d24SMasami Hiramatsu return 0; 812efe75d24SMasami Hiramatsu } 813efe75d24SMasami Hiramatsu 81451df0accSAmit Shah static ssize_t port_fops_write(struct file *filp, const char __user *ubuf, 81551df0accSAmit Shah size_t count, loff_t *offp) 81651df0accSAmit Shah { 81751df0accSAmit Shah struct port *port; 818276a3e95SSjur Brændeland struct port_buffer *buf; 81951df0accSAmit Shah ssize_t ret; 82051df0accSAmit Shah bool nonblock; 821276a3e95SSjur Brændeland struct scatterlist sg[1]; 82251df0accSAmit Shah 82351df0accSAmit Shah /* Userspace could be out to fool us */ 82451df0accSAmit Shah if (!count) 82551df0accSAmit Shah return 0; 82651df0accSAmit Shah 82751df0accSAmit Shah port = filp->private_data; 82851df0accSAmit Shah 82951df0accSAmit Shah nonblock = filp->f_flags & O_NONBLOCK; 83051df0accSAmit Shah 831efe75d24SMasami Hiramatsu ret = wait_port_writable(port, nonblock); 83251df0accSAmit Shah if (ret < 0) 83351df0accSAmit Shah return ret; 83451df0accSAmit Shah 83551df0accSAmit Shah count = min((size_t)(32 * 1024), count); 83651df0accSAmit Shah 837276a3e95SSjur Brændeland buf = alloc_buf(port->out_vq, count, 0); 83851df0accSAmit Shah if (!buf) 83951df0accSAmit Shah return -ENOMEM; 84051df0accSAmit Shah 841276a3e95SSjur Brændeland ret = copy_from_user(buf->buf, ubuf, count); 84251df0accSAmit Shah if (ret) { 84351df0accSAmit Shah ret = -EFAULT; 84451df0accSAmit Shah goto free_buf; 84551df0accSAmit Shah } 84651df0accSAmit Shah 84751df0accSAmit Shah /* 84851df0accSAmit Shah * We now ask send_buf() to not spin for generic ports -- we 84951df0accSAmit Shah * can re-use the same code path that non-blocking file 85051df0accSAmit Shah * descriptors take for blocking file descriptors since the 85151df0accSAmit Shah * wait is already done and we're certain the write will go 85251df0accSAmit Shah * through to the host. 85351df0accSAmit Shah */ 85451df0accSAmit Shah nonblock = true; 855276a3e95SSjur Brændeland sg_init_one(sg, buf->buf, count); 856276a3e95SSjur Brændeland ret = __send_to_port(port, sg, 1, count, buf, nonblock); 85751df0accSAmit Shah 85851df0accSAmit Shah if (nonblock && ret > 0) 85951df0accSAmit Shah goto out; 86051df0accSAmit Shah 86151df0accSAmit Shah free_buf: 8621b637046SSjur Brændeland free_buf(buf, true); 86351df0accSAmit Shah out: 86451df0accSAmit Shah return ret; 86551df0accSAmit Shah } 86651df0accSAmit Shah 867eb5e89fcSMasami Hiramatsu struct sg_list { 868eb5e89fcSMasami Hiramatsu unsigned int n; 8698ca84a50SMasami Hiramatsu unsigned int size; 870eb5e89fcSMasami Hiramatsu size_t len; 871eb5e89fcSMasami Hiramatsu struct scatterlist *sg; 872eb5e89fcSMasami Hiramatsu }; 873eb5e89fcSMasami Hiramatsu 874eb5e89fcSMasami Hiramatsu static int pipe_to_sg(struct pipe_inode_info *pipe, struct pipe_buffer *buf, 875eb5e89fcSMasami Hiramatsu struct splice_desc *sd) 876eb5e89fcSMasami Hiramatsu { 877eb5e89fcSMasami Hiramatsu struct sg_list *sgl = sd->u.data; 878ec8fc870SMasami Hiramatsu unsigned int offset, len; 879eb5e89fcSMasami Hiramatsu 8808ca84a50SMasami Hiramatsu if (sgl->n == sgl->size) 881eb5e89fcSMasami Hiramatsu return 0; 882eb5e89fcSMasami Hiramatsu 883eb5e89fcSMasami Hiramatsu /* Try lock this page */ 884eb5e89fcSMasami Hiramatsu if (buf->ops->steal(pipe, buf) == 0) { 885eb5e89fcSMasami Hiramatsu /* Get reference and unlock page for moving */ 886eb5e89fcSMasami Hiramatsu get_page(buf->page); 887eb5e89fcSMasami Hiramatsu unlock_page(buf->page); 888eb5e89fcSMasami Hiramatsu 889eb5e89fcSMasami Hiramatsu len = min(buf->len, sd->len); 890eb5e89fcSMasami Hiramatsu sg_set_page(&(sgl->sg[sgl->n]), buf->page, len, buf->offset); 891ec8fc870SMasami Hiramatsu } else { 892ec8fc870SMasami Hiramatsu /* Failback to copying a page */ 893ec8fc870SMasami Hiramatsu struct page *page = alloc_page(GFP_KERNEL); 894c9efe511SAl Viro char *src; 895ec8fc870SMasami Hiramatsu 896ec8fc870SMasami Hiramatsu if (!page) 897ec8fc870SMasami Hiramatsu return -ENOMEM; 898ec8fc870SMasami Hiramatsu 899ec8fc870SMasami Hiramatsu offset = sd->pos & ~PAGE_MASK; 900ec8fc870SMasami Hiramatsu 901ec8fc870SMasami Hiramatsu len = sd->len; 902ec8fc870SMasami Hiramatsu if (len + offset > PAGE_SIZE) 903ec8fc870SMasami Hiramatsu len = PAGE_SIZE - offset; 904ec8fc870SMasami Hiramatsu 905fbb32750SAl Viro src = kmap_atomic(buf->page); 906c9efe511SAl Viro memcpy(page_address(page) + offset, src + buf->offset, len); 907fbb32750SAl Viro kunmap_atomic(src); 908ec8fc870SMasami Hiramatsu 909ec8fc870SMasami Hiramatsu sg_set_page(&(sgl->sg[sgl->n]), page, len, offset); 910ec8fc870SMasami Hiramatsu } 911eb5e89fcSMasami Hiramatsu sgl->n++; 912eb5e89fcSMasami Hiramatsu sgl->len += len; 913eb5e89fcSMasami Hiramatsu 914eb5e89fcSMasami Hiramatsu return len; 915eb5e89fcSMasami Hiramatsu } 916eb5e89fcSMasami Hiramatsu 917eb5e89fcSMasami Hiramatsu /* Faster zero-copy write by splicing */ 918eb5e89fcSMasami Hiramatsu static ssize_t port_fops_splice_write(struct pipe_inode_info *pipe, 919eb5e89fcSMasami Hiramatsu struct file *filp, loff_t *ppos, 920eb5e89fcSMasami Hiramatsu size_t len, unsigned int flags) 921eb5e89fcSMasami Hiramatsu { 922eb5e89fcSMasami Hiramatsu struct port *port = filp->private_data; 923eb5e89fcSMasami Hiramatsu struct sg_list sgl; 924eb5e89fcSMasami Hiramatsu ssize_t ret; 925276a3e95SSjur Brændeland struct port_buffer *buf; 926eb5e89fcSMasami Hiramatsu struct splice_desc sd = { 927eb5e89fcSMasami Hiramatsu .total_len = len, 928eb5e89fcSMasami Hiramatsu .flags = flags, 929eb5e89fcSMasami Hiramatsu .pos = *ppos, 930eb5e89fcSMasami Hiramatsu .u.data = &sgl, 931eb5e89fcSMasami Hiramatsu }; 932eb5e89fcSMasami Hiramatsu 9331b637046SSjur Brændeland /* 9341b637046SSjur Brændeland * Rproc_serial does not yet support splice. To support splice 9351b637046SSjur Brændeland * pipe_to_sg() must allocate dma-buffers and copy content from 9361b637046SSjur Brændeland * regular pages to dma pages. And alloc_buf and free_buf must 9371b637046SSjur Brændeland * support allocating and freeing such a list of dma-buffers. 9381b637046SSjur Brændeland */ 9391b637046SSjur Brændeland if (is_rproc_serial(port->out_vq->vdev)) 9401b637046SSjur Brændeland return -EINVAL; 9411b637046SSjur Brændeland 94268c034feSYoshihiro YUNOMAE /* 94368c034feSYoshihiro YUNOMAE * pipe->nrbufs == 0 means there are no data to transfer, 94468c034feSYoshihiro YUNOMAE * so this returns just 0 for no data. 94568c034feSYoshihiro YUNOMAE */ 9462b4fbf02SYoshihiro YUNOMAE pipe_lock(pipe); 9472b4fbf02SYoshihiro YUNOMAE if (!pipe->nrbufs) { 9482b4fbf02SYoshihiro YUNOMAE ret = 0; 9492b4fbf02SYoshihiro YUNOMAE goto error_out; 9502b4fbf02SYoshihiro YUNOMAE } 95168c034feSYoshihiro YUNOMAE 952efe75d24SMasami Hiramatsu ret = wait_port_writable(port, filp->f_flags & O_NONBLOCK); 953efe75d24SMasami Hiramatsu if (ret < 0) 9542b4fbf02SYoshihiro YUNOMAE goto error_out; 955efe75d24SMasami Hiramatsu 956276a3e95SSjur Brændeland buf = alloc_buf(port->out_vq, 0, pipe->nrbufs); 9572b4fbf02SYoshihiro YUNOMAE if (!buf) { 9582b4fbf02SYoshihiro YUNOMAE ret = -ENOMEM; 9592b4fbf02SYoshihiro YUNOMAE goto error_out; 9602b4fbf02SYoshihiro YUNOMAE } 961276a3e95SSjur Brændeland 962eb5e89fcSMasami Hiramatsu sgl.n = 0; 963eb5e89fcSMasami Hiramatsu sgl.len = 0; 9648ca84a50SMasami Hiramatsu sgl.size = pipe->nrbufs; 965276a3e95SSjur Brændeland sgl.sg = buf->sg; 9668ca84a50SMasami Hiramatsu sg_init_table(sgl.sg, sgl.size); 967eb5e89fcSMasami Hiramatsu ret = __splice_from_pipe(pipe, &sd, pipe_to_sg); 9682b4fbf02SYoshihiro YUNOMAE pipe_unlock(pipe); 969eb5e89fcSMasami Hiramatsu if (likely(ret > 0)) 970276a3e95SSjur Brændeland ret = __send_to_port(port, buf->sg, sgl.n, sgl.len, buf, true); 971eb5e89fcSMasami Hiramatsu 972fe529537SSjur Brændeland if (unlikely(ret <= 0)) 9731b637046SSjur Brændeland free_buf(buf, true); 974eb5e89fcSMasami Hiramatsu return ret; 9752b4fbf02SYoshihiro YUNOMAE 9762b4fbf02SYoshihiro YUNOMAE error_out: 9772b4fbf02SYoshihiro YUNOMAE pipe_unlock(pipe); 9782b4fbf02SYoshihiro YUNOMAE return ret; 979eb5e89fcSMasami Hiramatsu } 980eb5e89fcSMasami Hiramatsu 98151df0accSAmit Shah static unsigned int port_fops_poll(struct file *filp, poll_table *wait) 98251df0accSAmit Shah { 98351df0accSAmit Shah struct port *port; 98451df0accSAmit Shah unsigned int ret; 98551df0accSAmit Shah 98651df0accSAmit Shah port = filp->private_data; 98751df0accSAmit Shah poll_wait(filp, &port->waitqueue, wait); 98851df0accSAmit Shah 98951df0accSAmit Shah if (!port->guest_connected) { 99051df0accSAmit Shah /* Port got unplugged */ 99151df0accSAmit Shah return POLLHUP; 99251df0accSAmit Shah } 99351df0accSAmit Shah ret = 0; 99451df0accSAmit Shah if (!will_read_block(port)) 99551df0accSAmit Shah ret |= POLLIN | POLLRDNORM; 99651df0accSAmit Shah if (!will_write_block(port)) 99751df0accSAmit Shah ret |= POLLOUT; 99851df0accSAmit Shah if (!port->host_connected) 99951df0accSAmit Shah ret |= POLLHUP; 100051df0accSAmit Shah 100151df0accSAmit Shah return ret; 100251df0accSAmit Shah } 100351df0accSAmit Shah 100451df0accSAmit Shah static void remove_port(struct kref *kref); 100551df0accSAmit Shah 100651df0accSAmit Shah static int port_fops_release(struct inode *inode, struct file *filp) 100751df0accSAmit Shah { 100851df0accSAmit Shah struct port *port; 100951df0accSAmit Shah 101051df0accSAmit Shah port = filp->private_data; 101151df0accSAmit Shah 101251df0accSAmit Shah /* Notify host of port being closed */ 101351df0accSAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0); 101451df0accSAmit Shah 101551df0accSAmit Shah spin_lock_irq(&port->inbuf_lock); 101651df0accSAmit Shah port->guest_connected = false; 101751df0accSAmit Shah 101851df0accSAmit Shah discard_port_data(port); 101951df0accSAmit Shah 102051df0accSAmit Shah spin_unlock_irq(&port->inbuf_lock); 102151df0accSAmit Shah 102251df0accSAmit Shah spin_lock_irq(&port->outvq_lock); 102351df0accSAmit Shah reclaim_consumed_buffers(port); 102451df0accSAmit Shah spin_unlock_irq(&port->outvq_lock); 102551df0accSAmit Shah 10261b637046SSjur Brændeland reclaim_dma_bufs(); 102751df0accSAmit Shah /* 102851df0accSAmit Shah * Locks aren't necessary here as a port can't be opened after 102951df0accSAmit Shah * unplug, and if a port isn't unplugged, a kref would already 103051df0accSAmit Shah * exist for the port. Plus, taking ports_lock here would 103151df0accSAmit Shah * create a dependency on other locks taken by functions 103251df0accSAmit Shah * inside remove_port if we're the last holder of the port, 103351df0accSAmit Shah * creating many problems. 103451df0accSAmit Shah */ 103551df0accSAmit Shah kref_put(&port->kref, remove_port); 103651df0accSAmit Shah 103751df0accSAmit Shah return 0; 103851df0accSAmit Shah } 103951df0accSAmit Shah 104051df0accSAmit Shah static int port_fops_open(struct inode *inode, struct file *filp) 104151df0accSAmit Shah { 104251df0accSAmit Shah struct cdev *cdev = inode->i_cdev; 104351df0accSAmit Shah struct port *port; 104451df0accSAmit Shah int ret; 104551df0accSAmit Shah 1046057b82beSAmit Shah /* We get the port with a kref here */ 104751df0accSAmit Shah port = find_port_by_devt(cdev->dev); 1048671bdea2SAmit Shah if (!port) { 1049671bdea2SAmit Shah /* Port was unplugged before we could proceed */ 1050671bdea2SAmit Shah return -ENXIO; 1051671bdea2SAmit Shah } 105251df0accSAmit Shah filp->private_data = port; 105351df0accSAmit Shah 105451df0accSAmit Shah /* 105551df0accSAmit Shah * Don't allow opening of console port devices -- that's done 105651df0accSAmit Shah * via /dev/hvc 105751df0accSAmit Shah */ 105851df0accSAmit Shah if (is_console_port(port)) { 105951df0accSAmit Shah ret = -ENXIO; 106051df0accSAmit Shah goto out; 106151df0accSAmit Shah } 106251df0accSAmit Shah 106351df0accSAmit Shah /* Allow only one process to open a particular port at a time */ 106451df0accSAmit Shah spin_lock_irq(&port->inbuf_lock); 106551df0accSAmit Shah if (port->guest_connected) { 106651df0accSAmit Shah spin_unlock_irq(&port->inbuf_lock); 106774ff582cSAmit Shah ret = -EBUSY; 106851df0accSAmit Shah goto out; 106951df0accSAmit Shah } 107051df0accSAmit Shah 107151df0accSAmit Shah port->guest_connected = true; 107251df0accSAmit Shah spin_unlock_irq(&port->inbuf_lock); 107351df0accSAmit Shah 107451df0accSAmit Shah spin_lock_irq(&port->outvq_lock); 107551df0accSAmit Shah /* 107651df0accSAmit Shah * There might be a chance that we missed reclaiming a few 107751df0accSAmit Shah * buffers in the window of the port getting previously closed 107851df0accSAmit Shah * and opening now. 107951df0accSAmit Shah */ 108051df0accSAmit Shah reclaim_consumed_buffers(port); 108151df0accSAmit Shah spin_unlock_irq(&port->outvq_lock); 108251df0accSAmit Shah 108351df0accSAmit Shah nonseekable_open(inode, filp); 108451df0accSAmit Shah 108551df0accSAmit Shah /* Notify host of port being opened */ 108651df0accSAmit Shah send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1); 108751df0accSAmit Shah 108851df0accSAmit Shah return 0; 108951df0accSAmit Shah out: 109051df0accSAmit Shah kref_put(&port->kref, remove_port); 109151df0accSAmit Shah return ret; 109251df0accSAmit Shah } 109351df0accSAmit Shah 109451df0accSAmit Shah static int port_fops_fasync(int fd, struct file *filp, int mode) 109551df0accSAmit Shah { 109651df0accSAmit Shah struct port *port; 109751df0accSAmit Shah 109851df0accSAmit Shah port = filp->private_data; 109951df0accSAmit Shah return fasync_helper(fd, filp, mode, &port->async_queue); 110051df0accSAmit Shah } 110151df0accSAmit Shah 110251df0accSAmit Shah /* 110351df0accSAmit Shah * The file operations that we support: programs in the guest can open 110451df0accSAmit Shah * a console device, read from it, write to it, poll for data and 110551df0accSAmit Shah * close it. The devices are at 110651df0accSAmit Shah * /dev/vport<device number>p<port number> 110751df0accSAmit Shah */ 110851df0accSAmit Shah static const struct file_operations port_fops = { 110951df0accSAmit Shah .owner = THIS_MODULE, 111051df0accSAmit Shah .open = port_fops_open, 111151df0accSAmit Shah .read = port_fops_read, 111251df0accSAmit Shah .write = port_fops_write, 1113eb5e89fcSMasami Hiramatsu .splice_write = port_fops_splice_write, 111451df0accSAmit Shah .poll = port_fops_poll, 111551df0accSAmit Shah .release = port_fops_release, 111651df0accSAmit Shah .fasync = port_fops_fasync, 111751df0accSAmit Shah .llseek = no_llseek, 111851df0accSAmit Shah }; 111951df0accSAmit Shah 112051df0accSAmit Shah /* 112151df0accSAmit Shah * The put_chars() callback is pretty straightforward. 112251df0accSAmit Shah * 112351df0accSAmit Shah * We turn the characters into a scatter-gather list, add it to the 112451df0accSAmit Shah * output queue and then kick the Host. Then we sit here waiting for 112551df0accSAmit Shah * it to finish: inefficient in theory, but in practice 112651df0accSAmit Shah * implementations will do it immediately (lguest's Launcher does). 112751df0accSAmit Shah */ 112851df0accSAmit Shah static int put_chars(u32 vtermno, const char *buf, int count) 112951df0accSAmit Shah { 113051df0accSAmit Shah struct port *port; 1131276a3e95SSjur Brændeland struct scatterlist sg[1]; 113251df0accSAmit Shah 113351df0accSAmit Shah if (unlikely(early_put_chars)) 113451df0accSAmit Shah return early_put_chars(vtermno, buf, count); 113551df0accSAmit Shah 113651df0accSAmit Shah port = find_port_by_vtermno(vtermno); 113751df0accSAmit Shah if (!port) 113851df0accSAmit Shah return -EPIPE; 113951df0accSAmit Shah 1140276a3e95SSjur Brændeland sg_init_one(sg, buf, count); 1141276a3e95SSjur Brændeland return __send_to_port(port, sg, 1, count, (void *)buf, false); 114251df0accSAmit Shah } 114351df0accSAmit Shah 114451df0accSAmit Shah /* 114551df0accSAmit Shah * get_chars() is the callback from the hvc_console infrastructure 114651df0accSAmit Shah * when an interrupt is received. 114751df0accSAmit Shah * 114851df0accSAmit Shah * We call out to fill_readbuf that gets us the required data from the 114951df0accSAmit Shah * buffers that are queued up. 115051df0accSAmit Shah */ 115151df0accSAmit Shah static int get_chars(u32 vtermno, char *buf, int count) 115251df0accSAmit Shah { 115351df0accSAmit Shah struct port *port; 115451df0accSAmit Shah 115551df0accSAmit Shah /* If we've not set up the port yet, we have no input to give. */ 115651df0accSAmit Shah if (unlikely(early_put_chars)) 115751df0accSAmit Shah return 0; 115851df0accSAmit Shah 115951df0accSAmit Shah port = find_port_by_vtermno(vtermno); 116051df0accSAmit Shah if (!port) 116151df0accSAmit Shah return -EPIPE; 116251df0accSAmit Shah 116351df0accSAmit Shah /* If we don't have an input queue yet, we can't get input. */ 116451df0accSAmit Shah BUG_ON(!port->in_vq); 116551df0accSAmit Shah 116648b36066SMichael S. Tsirkin return fill_readbuf(port, (__force char __user *)buf, count, false); 116751df0accSAmit Shah } 116851df0accSAmit Shah 116951df0accSAmit Shah static void resize_console(struct port *port) 117051df0accSAmit Shah { 117151df0accSAmit Shah struct virtio_device *vdev; 117251df0accSAmit Shah 117351df0accSAmit Shah /* The port could have been hot-unplugged */ 117451df0accSAmit Shah if (!port || !is_console_port(port)) 117551df0accSAmit Shah return; 117651df0accSAmit Shah 117751df0accSAmit Shah vdev = port->portdev->vdev; 11781b637046SSjur Brændeland 11791b637046SSjur Brændeland /* Don't test F_SIZE at all if we're rproc: not a valid feature! */ 11801b637046SSjur Brændeland if (!is_rproc_serial(vdev) && 11811b637046SSjur Brændeland virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE)) 118251df0accSAmit Shah hvc_resize(port->cons.hvc, port->cons.ws); 118351df0accSAmit Shah } 118451df0accSAmit Shah 118551df0accSAmit Shah /* We set the configuration at this point, since we now have a tty */ 118651df0accSAmit Shah static int notifier_add_vio(struct hvc_struct *hp, int data) 118751df0accSAmit Shah { 118851df0accSAmit Shah struct port *port; 118951df0accSAmit Shah 119051df0accSAmit Shah port = find_port_by_vtermno(hp->vtermno); 119151df0accSAmit Shah if (!port) 119251df0accSAmit Shah return -EINVAL; 119351df0accSAmit Shah 119451df0accSAmit Shah hp->irq_requested = 1; 119551df0accSAmit Shah resize_console(port); 119651df0accSAmit Shah 119751df0accSAmit Shah return 0; 119851df0accSAmit Shah } 119951df0accSAmit Shah 120051df0accSAmit Shah static void notifier_del_vio(struct hvc_struct *hp, int data) 120151df0accSAmit Shah { 120251df0accSAmit Shah hp->irq_requested = 0; 120351df0accSAmit Shah } 120451df0accSAmit Shah 120551df0accSAmit Shah /* The operations for console ports. */ 120651df0accSAmit Shah static const struct hv_ops hv_ops = { 120751df0accSAmit Shah .get_chars = get_chars, 120851df0accSAmit Shah .put_chars = put_chars, 120951df0accSAmit Shah .notifier_add = notifier_add_vio, 121051df0accSAmit Shah .notifier_del = notifier_del_vio, 121151df0accSAmit Shah .notifier_hangup = notifier_del_vio, 121251df0accSAmit Shah }; 121351df0accSAmit Shah 121451df0accSAmit Shah /* 121551df0accSAmit Shah * Console drivers are initialized very early so boot messages can go 121651df0accSAmit Shah * out, so we do things slightly differently from the generic virtio 121751df0accSAmit Shah * initialization of the net and block drivers. 121851df0accSAmit Shah * 121951df0accSAmit Shah * At this stage, the console is output-only. It's too early to set 122051df0accSAmit Shah * up a virtqueue, so we let the drivers do some boutique early-output 122151df0accSAmit Shah * thing. 122251df0accSAmit Shah */ 122351df0accSAmit Shah int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int)) 122451df0accSAmit Shah { 122551df0accSAmit Shah early_put_chars = put_chars; 122651df0accSAmit Shah return hvc_instantiate(0, 0, &hv_ops); 122751df0accSAmit Shah } 122851df0accSAmit Shah 12293826835aSWei Yongjun static int init_port_console(struct port *port) 123051df0accSAmit Shah { 123151df0accSAmit Shah int ret; 123251df0accSAmit Shah 123351df0accSAmit Shah /* 123451df0accSAmit Shah * The Host's telling us this port is a console port. Hook it 123551df0accSAmit Shah * up with an hvc console. 123651df0accSAmit Shah * 123751df0accSAmit Shah * To set up and manage our virtual console, we call 123851df0accSAmit Shah * hvc_alloc(). 123951df0accSAmit Shah * 124051df0accSAmit Shah * The first argument of hvc_alloc() is the virtual console 124151df0accSAmit Shah * number. The second argument is the parameter for the 124251df0accSAmit Shah * notification mechanism (like irq number). We currently 124351df0accSAmit Shah * leave this as zero, virtqueues have implicit notifications. 124451df0accSAmit Shah * 124551df0accSAmit Shah * The third argument is a "struct hv_ops" containing the 124651df0accSAmit Shah * put_chars() get_chars(), notifier_add() and notifier_del() 124751df0accSAmit Shah * pointers. The final argument is the output buffer size: we 124851df0accSAmit Shah * can do any size, so we put PAGE_SIZE here. 124951df0accSAmit Shah */ 125051df0accSAmit Shah port->cons.vtermno = pdrvdata.next_vtermno; 125151df0accSAmit Shah 125251df0accSAmit Shah port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE); 125351df0accSAmit Shah if (IS_ERR(port->cons.hvc)) { 125451df0accSAmit Shah ret = PTR_ERR(port->cons.hvc); 125551df0accSAmit Shah dev_err(port->dev, 125651df0accSAmit Shah "error %d allocating hvc for port\n", ret); 125751df0accSAmit Shah port->cons.hvc = NULL; 125851df0accSAmit Shah return ret; 125951df0accSAmit Shah } 126051df0accSAmit Shah spin_lock_irq(&pdrvdata_lock); 126151df0accSAmit Shah pdrvdata.next_vtermno++; 126251df0accSAmit Shah list_add_tail(&port->cons.list, &pdrvdata.consoles); 126351df0accSAmit Shah spin_unlock_irq(&pdrvdata_lock); 126451df0accSAmit Shah port->guest_connected = true; 126551df0accSAmit Shah 126651df0accSAmit Shah /* 126751df0accSAmit Shah * Start using the new console output if this is the first 126851df0accSAmit Shah * console to come up. 126951df0accSAmit Shah */ 127051df0accSAmit Shah if (early_put_chars) 127151df0accSAmit Shah early_put_chars = NULL; 127251df0accSAmit Shah 127351df0accSAmit Shah /* Notify host of port being opened */ 127451df0accSAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1); 127551df0accSAmit Shah 127651df0accSAmit Shah return 0; 127751df0accSAmit Shah } 127851df0accSAmit Shah 127951df0accSAmit Shah static ssize_t show_port_name(struct device *dev, 128051df0accSAmit Shah struct device_attribute *attr, char *buffer) 128151df0accSAmit Shah { 128251df0accSAmit Shah struct port *port; 128351df0accSAmit Shah 128451df0accSAmit Shah port = dev_get_drvdata(dev); 128551df0accSAmit Shah 128651df0accSAmit Shah return sprintf(buffer, "%s\n", port->name); 128751df0accSAmit Shah } 128851df0accSAmit Shah 128951df0accSAmit Shah static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL); 129051df0accSAmit Shah 129151df0accSAmit Shah static struct attribute *port_sysfs_entries[] = { 129251df0accSAmit Shah &dev_attr_name.attr, 129351df0accSAmit Shah NULL 129451df0accSAmit Shah }; 129551df0accSAmit Shah 129651df0accSAmit Shah static struct attribute_group port_attribute_group = { 129751df0accSAmit Shah .name = NULL, /* put in device directory */ 129851df0accSAmit Shah .attrs = port_sysfs_entries, 129951df0accSAmit Shah }; 130051df0accSAmit Shah 130151df0accSAmit Shah static ssize_t debugfs_read(struct file *filp, char __user *ubuf, 130251df0accSAmit Shah size_t count, loff_t *offp) 130351df0accSAmit Shah { 130451df0accSAmit Shah struct port *port; 130551df0accSAmit Shah char *buf; 130651df0accSAmit Shah ssize_t ret, out_offset, out_count; 130751df0accSAmit Shah 130851df0accSAmit Shah out_count = 1024; 130951df0accSAmit Shah buf = kmalloc(out_count, GFP_KERNEL); 131051df0accSAmit Shah if (!buf) 131151df0accSAmit Shah return -ENOMEM; 131251df0accSAmit Shah 131351df0accSAmit Shah port = filp->private_data; 131451df0accSAmit Shah out_offset = 0; 131551df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count, 131651df0accSAmit Shah "name: %s\n", port->name ? port->name : ""); 131751df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 131851df0accSAmit Shah "guest_connected: %d\n", port->guest_connected); 131951df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 132051df0accSAmit Shah "host_connected: %d\n", port->host_connected); 132151df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 132251df0accSAmit Shah "outvq_full: %d\n", port->outvq_full); 132351df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 132417e5b4f2SAmit Shah "bytes_sent: %lu\n", port->stats.bytes_sent); 132517e5b4f2SAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 132617e5b4f2SAmit Shah "bytes_received: %lu\n", 132717e5b4f2SAmit Shah port->stats.bytes_received); 132817e5b4f2SAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 132917e5b4f2SAmit Shah "bytes_discarded: %lu\n", 133017e5b4f2SAmit Shah port->stats.bytes_discarded); 133117e5b4f2SAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 133251df0accSAmit Shah "is_console: %s\n", 133351df0accSAmit Shah is_console_port(port) ? "yes" : "no"); 133451df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 133551df0accSAmit Shah "console_vtermno: %u\n", port->cons.vtermno); 133651df0accSAmit Shah 133751df0accSAmit Shah ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset); 133851df0accSAmit Shah kfree(buf); 133951df0accSAmit Shah return ret; 134051df0accSAmit Shah } 134151df0accSAmit Shah 134251df0accSAmit Shah static const struct file_operations port_debugfs_ops = { 134351df0accSAmit Shah .owner = THIS_MODULE, 1344234e3405SStephen Boyd .open = simple_open, 134551df0accSAmit Shah .read = debugfs_read, 134651df0accSAmit Shah }; 134751df0accSAmit Shah 134851df0accSAmit Shah static void set_console_size(struct port *port, u16 rows, u16 cols) 134951df0accSAmit Shah { 135051df0accSAmit Shah if (!port || !is_console_port(port)) 135151df0accSAmit Shah return; 135251df0accSAmit Shah 135351df0accSAmit Shah port->cons.ws.ws_row = rows; 135451df0accSAmit Shah port->cons.ws.ws_col = cols; 135551df0accSAmit Shah } 135651df0accSAmit Shah 135751df0accSAmit Shah static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock) 135851df0accSAmit Shah { 135951df0accSAmit Shah struct port_buffer *buf; 136051df0accSAmit Shah unsigned int nr_added_bufs; 136151df0accSAmit Shah int ret; 136251df0accSAmit Shah 136351df0accSAmit Shah nr_added_bufs = 0; 136451df0accSAmit Shah do { 1365276a3e95SSjur Brændeland buf = alloc_buf(vq, PAGE_SIZE, 0); 136651df0accSAmit Shah if (!buf) 136751df0accSAmit Shah break; 136851df0accSAmit Shah 136951df0accSAmit Shah spin_lock_irq(lock); 137051df0accSAmit Shah ret = add_inbuf(vq, buf); 137151df0accSAmit Shah if (ret < 0) { 137251df0accSAmit Shah spin_unlock_irq(lock); 13731b637046SSjur Brændeland free_buf(buf, true); 137451df0accSAmit Shah break; 137551df0accSAmit Shah } 137651df0accSAmit Shah nr_added_bufs++; 137751df0accSAmit Shah spin_unlock_irq(lock); 137851df0accSAmit Shah } while (ret > 0); 137951df0accSAmit Shah 138051df0accSAmit Shah return nr_added_bufs; 138151df0accSAmit Shah } 138251df0accSAmit Shah 138351df0accSAmit Shah static void send_sigio_to_port(struct port *port) 138451df0accSAmit Shah { 138551df0accSAmit Shah if (port->async_queue && port->guest_connected) 138651df0accSAmit Shah kill_fasync(&port->async_queue, SIGIO, POLL_OUT); 138751df0accSAmit Shah } 138851df0accSAmit Shah 138951df0accSAmit Shah static int add_port(struct ports_device *portdev, u32 id) 139051df0accSAmit Shah { 139151df0accSAmit Shah char debugfs_name[16]; 139251df0accSAmit Shah struct port *port; 139351df0accSAmit Shah struct port_buffer *buf; 139451df0accSAmit Shah dev_t devt; 139551df0accSAmit Shah unsigned int nr_added_bufs; 139651df0accSAmit Shah int err; 139751df0accSAmit Shah 139851df0accSAmit Shah port = kmalloc(sizeof(*port), GFP_KERNEL); 139951df0accSAmit Shah if (!port) { 140051df0accSAmit Shah err = -ENOMEM; 140151df0accSAmit Shah goto fail; 140251df0accSAmit Shah } 140351df0accSAmit Shah kref_init(&port->kref); 140451df0accSAmit Shah 140551df0accSAmit Shah port->portdev = portdev; 140651df0accSAmit Shah port->id = id; 140751df0accSAmit Shah 140851df0accSAmit Shah port->name = NULL; 140951df0accSAmit Shah port->inbuf = NULL; 141051df0accSAmit Shah port->cons.hvc = NULL; 141151df0accSAmit Shah port->async_queue = NULL; 141251df0accSAmit Shah 141351df0accSAmit Shah port->cons.ws.ws_row = port->cons.ws.ws_col = 0; 141451df0accSAmit Shah 141551df0accSAmit Shah port->host_connected = port->guest_connected = false; 141617e5b4f2SAmit Shah port->stats = (struct port_stats) { 0 }; 141751df0accSAmit Shah 141851df0accSAmit Shah port->outvq_full = false; 141951df0accSAmit Shah 142051df0accSAmit Shah port->in_vq = portdev->in_vqs[port->id]; 142151df0accSAmit Shah port->out_vq = portdev->out_vqs[port->id]; 142251df0accSAmit Shah 142351df0accSAmit Shah port->cdev = cdev_alloc(); 142451df0accSAmit Shah if (!port->cdev) { 142551df0accSAmit Shah dev_err(&port->portdev->vdev->dev, "Error allocating cdev\n"); 142651df0accSAmit Shah err = -ENOMEM; 142751df0accSAmit Shah goto free_port; 142851df0accSAmit Shah } 142951df0accSAmit Shah port->cdev->ops = &port_fops; 143051df0accSAmit Shah 143151df0accSAmit Shah devt = MKDEV(portdev->chr_major, id); 143251df0accSAmit Shah err = cdev_add(port->cdev, devt, 1); 143351df0accSAmit Shah if (err < 0) { 143451df0accSAmit Shah dev_err(&port->portdev->vdev->dev, 143551df0accSAmit Shah "Error %d adding cdev for port %u\n", err, id); 143651df0accSAmit Shah goto free_cdev; 143751df0accSAmit Shah } 143851df0accSAmit Shah port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev, 143951df0accSAmit Shah devt, port, "vport%up%u", 1440dc18f080SSjur Brændeland port->portdev->vdev->index, id); 144151df0accSAmit Shah if (IS_ERR(port->dev)) { 144251df0accSAmit Shah err = PTR_ERR(port->dev); 144351df0accSAmit Shah dev_err(&port->portdev->vdev->dev, 144451df0accSAmit Shah "Error %d creating device for port %u\n", 144551df0accSAmit Shah err, id); 144651df0accSAmit Shah goto free_cdev; 144751df0accSAmit Shah } 144851df0accSAmit Shah 144951df0accSAmit Shah spin_lock_init(&port->inbuf_lock); 145051df0accSAmit Shah spin_lock_init(&port->outvq_lock); 145151df0accSAmit Shah init_waitqueue_head(&port->waitqueue); 145251df0accSAmit Shah 145351df0accSAmit Shah /* Fill the in_vq with buffers so the host can send us data. */ 145451df0accSAmit Shah nr_added_bufs = fill_queue(port->in_vq, &port->inbuf_lock); 145551df0accSAmit Shah if (!nr_added_bufs) { 145651df0accSAmit Shah dev_err(port->dev, "Error allocating inbufs\n"); 145751df0accSAmit Shah err = -ENOMEM; 145851df0accSAmit Shah goto free_device; 145951df0accSAmit Shah } 146051df0accSAmit Shah 14611b637046SSjur Brændeland if (is_rproc_serial(port->portdev->vdev)) 146251df0accSAmit Shah /* 14631b637046SSjur Brændeland * For rproc_serial assume remote processor is connected. 14641b637046SSjur Brændeland * rproc_serial does not want the console port, only 14651b637046SSjur Brændeland * the generic port implementation. 146651df0accSAmit Shah */ 1467aabd6a8fSSjur Brændeland port->host_connected = true; 14681b637046SSjur Brændeland else if (!use_multiport(port->portdev)) { 14691b637046SSjur Brændeland /* 14701b637046SSjur Brændeland * If we're not using multiport support, 14711b637046SSjur Brændeland * this has to be a console port. 14721b637046SSjur Brændeland */ 147351df0accSAmit Shah err = init_port_console(port); 147451df0accSAmit Shah if (err) 147551df0accSAmit Shah goto free_inbufs; 147651df0accSAmit Shah } 147751df0accSAmit Shah 147851df0accSAmit Shah spin_lock_irq(&portdev->ports_lock); 147951df0accSAmit Shah list_add_tail(&port->list, &port->portdev->ports); 148051df0accSAmit Shah spin_unlock_irq(&portdev->ports_lock); 148151df0accSAmit Shah 148251df0accSAmit Shah /* 148351df0accSAmit Shah * Tell the Host we're set so that it can send us various 148451df0accSAmit Shah * configuration parameters for this port (eg, port name, 148551df0accSAmit Shah * caching, whether this is a console port, etc.) 148651df0accSAmit Shah */ 148751df0accSAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1); 148851df0accSAmit Shah 148951df0accSAmit Shah if (pdrvdata.debugfs_dir) { 149051df0accSAmit Shah /* 149151df0accSAmit Shah * Finally, create the debugfs file that we can use to 149251df0accSAmit Shah * inspect a port's state at any time 149351df0accSAmit Shah */ 149451df0accSAmit Shah sprintf(debugfs_name, "vport%up%u", 1495dc18f080SSjur Brændeland port->portdev->vdev->index, id); 149651df0accSAmit Shah port->debugfs_file = debugfs_create_file(debugfs_name, 0444, 149751df0accSAmit Shah pdrvdata.debugfs_dir, 149851df0accSAmit Shah port, 149951df0accSAmit Shah &port_debugfs_ops); 150051df0accSAmit Shah } 150151df0accSAmit Shah return 0; 150251df0accSAmit Shah 150351df0accSAmit Shah free_inbufs: 150451df0accSAmit Shah while ((buf = virtqueue_detach_unused_buf(port->in_vq))) 15051b637046SSjur Brændeland free_buf(buf, true); 150651df0accSAmit Shah free_device: 150751df0accSAmit Shah device_destroy(pdrvdata.class, port->dev->devt); 150851df0accSAmit Shah free_cdev: 150951df0accSAmit Shah cdev_del(port->cdev); 151051df0accSAmit Shah free_port: 151151df0accSAmit Shah kfree(port); 151251df0accSAmit Shah fail: 151351df0accSAmit Shah /* The host might want to notify management sw about port add failure */ 151451df0accSAmit Shah __send_control_msg(portdev, id, VIRTIO_CONSOLE_PORT_READY, 0); 151551df0accSAmit Shah return err; 151651df0accSAmit Shah } 151751df0accSAmit Shah 151851df0accSAmit Shah /* No users remain, remove all port-specific data. */ 151951df0accSAmit Shah static void remove_port(struct kref *kref) 152051df0accSAmit Shah { 152151df0accSAmit Shah struct port *port; 152251df0accSAmit Shah 152351df0accSAmit Shah port = container_of(kref, struct port, kref); 152451df0accSAmit Shah 152551df0accSAmit Shah kfree(port); 152651df0accSAmit Shah } 152751df0accSAmit Shah 1528a0e2dbfcSAmit Shah static void remove_port_data(struct port *port) 1529a0e2dbfcSAmit Shah { 1530a0e2dbfcSAmit Shah struct port_buffer *buf; 1531a0e2dbfcSAmit Shah 1532c6017e79SAmit Shah spin_lock_irq(&port->inbuf_lock); 1533a0e2dbfcSAmit Shah /* Remove unused data this port might have received. */ 1534a0e2dbfcSAmit Shah discard_port_data(port); 1535a0e2dbfcSAmit Shah 1536a0e2dbfcSAmit Shah /* Remove buffers we queued up for the Host to send us data in. */ 1537a0e2dbfcSAmit Shah while ((buf = virtqueue_detach_unused_buf(port->in_vq))) 15381b637046SSjur Brændeland free_buf(buf, true); 1539c6017e79SAmit Shah spin_unlock_irq(&port->inbuf_lock); 1540c6017e79SAmit Shah 1541c6017e79SAmit Shah spin_lock_irq(&port->outvq_lock); 1542c6017e79SAmit Shah reclaim_consumed_buffers(port); 1543eb34f12bSsjur.brandeland@stericsson.com 1544eb34f12bSsjur.brandeland@stericsson.com /* Free pending buffers from the out-queue. */ 1545eb34f12bSsjur.brandeland@stericsson.com while ((buf = virtqueue_detach_unused_buf(port->out_vq))) 15461b637046SSjur Brændeland free_buf(buf, true); 1547c6017e79SAmit Shah spin_unlock_irq(&port->outvq_lock); 1548a0e2dbfcSAmit Shah } 1549a0e2dbfcSAmit Shah 155051df0accSAmit Shah /* 155151df0accSAmit Shah * Port got unplugged. Remove port from portdev's list and drop the 155251df0accSAmit Shah * kref reference. If no userspace has this port opened, it will 155351df0accSAmit Shah * result in immediate removal the port. 155451df0accSAmit Shah */ 155551df0accSAmit Shah static void unplug_port(struct port *port) 155651df0accSAmit Shah { 155751df0accSAmit Shah spin_lock_irq(&port->portdev->ports_lock); 155851df0accSAmit Shah list_del(&port->list); 155951df0accSAmit Shah spin_unlock_irq(&port->portdev->ports_lock); 156051df0accSAmit Shah 15615549fb25SAmit Shah spin_lock_irq(&port->inbuf_lock); 156251df0accSAmit Shah if (port->guest_connected) { 156351df0accSAmit Shah /* Let the app know the port is going down. */ 156451df0accSAmit Shah send_sigio_to_port(port); 156592d34538SAmit Shah 156692d34538SAmit Shah /* Do this after sigio is actually sent */ 156792d34538SAmit Shah port->guest_connected = false; 156892d34538SAmit Shah port->host_connected = false; 156992d34538SAmit Shah 157092d34538SAmit Shah wake_up_interruptible(&port->waitqueue); 157151df0accSAmit Shah } 15725549fb25SAmit Shah spin_unlock_irq(&port->inbuf_lock); 157351df0accSAmit Shah 157451df0accSAmit Shah if (is_console_port(port)) { 157551df0accSAmit Shah spin_lock_irq(&pdrvdata_lock); 157651df0accSAmit Shah list_del(&port->cons.list); 157751df0accSAmit Shah spin_unlock_irq(&pdrvdata_lock); 157851df0accSAmit Shah hvc_remove(port->cons.hvc); 157951df0accSAmit Shah } 158051df0accSAmit Shah 1581a0e2dbfcSAmit Shah remove_port_data(port); 158251df0accSAmit Shah 158351df0accSAmit Shah /* 158451df0accSAmit Shah * We should just assume the device itself has gone off -- 158551df0accSAmit Shah * else a close on an open port later will try to send out a 158651df0accSAmit Shah * control message. 158751df0accSAmit Shah */ 158851df0accSAmit Shah port->portdev = NULL; 158951df0accSAmit Shah 1590ea3768b4SAmit Shah sysfs_remove_group(&port->dev->kobj, &port_attribute_group); 1591ea3768b4SAmit Shah device_destroy(pdrvdata.class, port->dev->devt); 1592ea3768b4SAmit Shah cdev_del(port->cdev); 1593ea3768b4SAmit Shah 1594ea3768b4SAmit Shah debugfs_remove(port->debugfs_file); 15953b868a40SAmit Shah kfree(port->name); 1596ea3768b4SAmit Shah 159751df0accSAmit Shah /* 159851df0accSAmit Shah * Locks around here are not necessary - a port can't be 159951df0accSAmit Shah * opened after we removed the port struct from ports_list 160051df0accSAmit Shah * above. 160151df0accSAmit Shah */ 160251df0accSAmit Shah kref_put(&port->kref, remove_port); 160351df0accSAmit Shah } 160451df0accSAmit Shah 160551df0accSAmit Shah /* Any private messages that the Host and Guest want to share */ 16061f0f9106SMichael S. Tsirkin static void handle_control_message(struct virtio_device *vdev, 16071f0f9106SMichael S. Tsirkin struct ports_device *portdev, 160851df0accSAmit Shah struct port_buffer *buf) 160951df0accSAmit Shah { 161051df0accSAmit Shah struct virtio_console_control *cpkt; 161151df0accSAmit Shah struct port *port; 161251df0accSAmit Shah size_t name_size; 161351df0accSAmit Shah int err; 161451df0accSAmit Shah 161551df0accSAmit Shah cpkt = (struct virtio_console_control *)(buf->buf + buf->offset); 161651df0accSAmit Shah 16171f0f9106SMichael S. Tsirkin port = find_port_by_id(portdev, virtio32_to_cpu(vdev, cpkt->id)); 16181f0f9106SMichael S. Tsirkin if (!port && 16191f0f9106SMichael S. Tsirkin cpkt->event != cpu_to_virtio16(vdev, VIRTIO_CONSOLE_PORT_ADD)) { 162051df0accSAmit Shah /* No valid header at start of buffer. Drop it. */ 162151df0accSAmit Shah dev_dbg(&portdev->vdev->dev, 162251df0accSAmit Shah "Invalid index %u in control packet\n", cpkt->id); 162351df0accSAmit Shah return; 162451df0accSAmit Shah } 162551df0accSAmit Shah 16261f0f9106SMichael S. Tsirkin switch (virtio16_to_cpu(vdev, cpkt->event)) { 162751df0accSAmit Shah case VIRTIO_CONSOLE_PORT_ADD: 162851df0accSAmit Shah if (port) { 162951df0accSAmit Shah dev_dbg(&portdev->vdev->dev, 163051df0accSAmit Shah "Port %u already added\n", port->id); 163151df0accSAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1); 163251df0accSAmit Shah break; 163351df0accSAmit Shah } 16341f0f9106SMichael S. Tsirkin if (virtio32_to_cpu(vdev, cpkt->id) >= 16351f0f9106SMichael S. Tsirkin portdev->config.max_nr_ports) { 163651df0accSAmit Shah dev_warn(&portdev->vdev->dev, 16371f0f9106SMichael S. Tsirkin "Request for adding port with " 16381f0f9106SMichael S. Tsirkin "out-of-bound id %u, max. supported id: %u\n", 163951df0accSAmit Shah cpkt->id, portdev->config.max_nr_ports - 1); 164051df0accSAmit Shah break; 164151df0accSAmit Shah } 16421f0f9106SMichael S. Tsirkin add_port(portdev, virtio32_to_cpu(vdev, cpkt->id)); 164351df0accSAmit Shah break; 164451df0accSAmit Shah case VIRTIO_CONSOLE_PORT_REMOVE: 164551df0accSAmit Shah unplug_port(port); 164651df0accSAmit Shah break; 164751df0accSAmit Shah case VIRTIO_CONSOLE_CONSOLE_PORT: 164851df0accSAmit Shah if (!cpkt->value) 164951df0accSAmit Shah break; 165051df0accSAmit Shah if (is_console_port(port)) 165151df0accSAmit Shah break; 165251df0accSAmit Shah 165351df0accSAmit Shah init_port_console(port); 16545e38483bSChristian Borntraeger complete(&early_console_added); 165551df0accSAmit Shah /* 165651df0accSAmit Shah * Could remove the port here in case init fails - but 165751df0accSAmit Shah * have to notify the host first. 165851df0accSAmit Shah */ 165951df0accSAmit Shah break; 166051df0accSAmit Shah case VIRTIO_CONSOLE_RESIZE: { 166151df0accSAmit Shah struct { 166251df0accSAmit Shah __u16 rows; 166351df0accSAmit Shah __u16 cols; 166451df0accSAmit Shah } size; 166551df0accSAmit Shah 166651df0accSAmit Shah if (!is_console_port(port)) 166751df0accSAmit Shah break; 166851df0accSAmit Shah 166951df0accSAmit Shah memcpy(&size, buf->buf + buf->offset + sizeof(*cpkt), 167051df0accSAmit Shah sizeof(size)); 167151df0accSAmit Shah set_console_size(port, size.rows, size.cols); 167251df0accSAmit Shah 167351df0accSAmit Shah port->cons.hvc->irq_requested = 1; 167451df0accSAmit Shah resize_console(port); 167551df0accSAmit Shah break; 167651df0accSAmit Shah } 167751df0accSAmit Shah case VIRTIO_CONSOLE_PORT_OPEN: 16781f0f9106SMichael S. Tsirkin port->host_connected = virtio16_to_cpu(vdev, cpkt->value); 167951df0accSAmit Shah wake_up_interruptible(&port->waitqueue); 168051df0accSAmit Shah /* 168151df0accSAmit Shah * If the host port got closed and the host had any 168251df0accSAmit Shah * unconsumed buffers, we'll be able to reclaim them 168351df0accSAmit Shah * now. 168451df0accSAmit Shah */ 168551df0accSAmit Shah spin_lock_irq(&port->outvq_lock); 168651df0accSAmit Shah reclaim_consumed_buffers(port); 168751df0accSAmit Shah spin_unlock_irq(&port->outvq_lock); 168851df0accSAmit Shah 168951df0accSAmit Shah /* 169051df0accSAmit Shah * If the guest is connected, it'll be interested in 169151df0accSAmit Shah * knowing the host connection state changed. 169251df0accSAmit Shah */ 1693314081f1SAmit Shah spin_lock_irq(&port->inbuf_lock); 169451df0accSAmit Shah send_sigio_to_port(port); 1695314081f1SAmit Shah spin_unlock_irq(&port->inbuf_lock); 169651df0accSAmit Shah break; 169751df0accSAmit Shah case VIRTIO_CONSOLE_PORT_NAME: 169851df0accSAmit Shah /* 1699291024efSAmit Shah * If we woke up after hibernation, we can get this 1700291024efSAmit Shah * again. Skip it in that case. 1701291024efSAmit Shah */ 1702291024efSAmit Shah if (port->name) 1703291024efSAmit Shah break; 1704291024efSAmit Shah 1705291024efSAmit Shah /* 170651df0accSAmit Shah * Skip the size of the header and the cpkt to get the size 170751df0accSAmit Shah * of the name that was sent 170851df0accSAmit Shah */ 170951df0accSAmit Shah name_size = buf->len - buf->offset - sizeof(*cpkt) + 1; 171051df0accSAmit Shah 171151df0accSAmit Shah port->name = kmalloc(name_size, GFP_KERNEL); 171251df0accSAmit Shah if (!port->name) { 171351df0accSAmit Shah dev_err(port->dev, 171451df0accSAmit Shah "Not enough space to store port name\n"); 171551df0accSAmit Shah break; 171651df0accSAmit Shah } 171751df0accSAmit Shah strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt), 171851df0accSAmit Shah name_size - 1); 171951df0accSAmit Shah port->name[name_size - 1] = 0; 172051df0accSAmit Shah 172151df0accSAmit Shah /* 172251df0accSAmit Shah * Since we only have one sysfs attribute, 'name', 172351df0accSAmit Shah * create it only if we have a name for the port. 172451df0accSAmit Shah */ 172551df0accSAmit Shah err = sysfs_create_group(&port->dev->kobj, 172651df0accSAmit Shah &port_attribute_group); 172751df0accSAmit Shah if (err) { 172851df0accSAmit Shah dev_err(port->dev, 172951df0accSAmit Shah "Error %d creating sysfs device attributes\n", 173051df0accSAmit Shah err); 173151df0accSAmit Shah } else { 173251df0accSAmit Shah /* 173351df0accSAmit Shah * Generate a udev event so that appropriate 173451df0accSAmit Shah * symlinks can be created based on udev 173551df0accSAmit Shah * rules. 173651df0accSAmit Shah */ 173751df0accSAmit Shah kobject_uevent(&port->dev->kobj, KOBJ_CHANGE); 173851df0accSAmit Shah } 173951df0accSAmit Shah break; 174051df0accSAmit Shah } 174151df0accSAmit Shah } 174251df0accSAmit Shah 174351df0accSAmit Shah static void control_work_handler(struct work_struct *work) 174451df0accSAmit Shah { 174551df0accSAmit Shah struct ports_device *portdev; 174651df0accSAmit Shah struct virtqueue *vq; 174751df0accSAmit Shah struct port_buffer *buf; 174851df0accSAmit Shah unsigned int len; 174951df0accSAmit Shah 175051df0accSAmit Shah portdev = container_of(work, struct ports_device, control_work); 175151df0accSAmit Shah vq = portdev->c_ivq; 175251df0accSAmit Shah 1753165b1b8bSAmit Shah spin_lock(&portdev->c_ivq_lock); 175451df0accSAmit Shah while ((buf = virtqueue_get_buf(vq, &len))) { 1755165b1b8bSAmit Shah spin_unlock(&portdev->c_ivq_lock); 175651df0accSAmit Shah 175751df0accSAmit Shah buf->len = len; 175851df0accSAmit Shah buf->offset = 0; 175951df0accSAmit Shah 17601f0f9106SMichael S. Tsirkin handle_control_message(vq->vdev, portdev, buf); 176151df0accSAmit Shah 1762165b1b8bSAmit Shah spin_lock(&portdev->c_ivq_lock); 176351df0accSAmit Shah if (add_inbuf(portdev->c_ivq, buf) < 0) { 176451df0accSAmit Shah dev_warn(&portdev->vdev->dev, 176551df0accSAmit Shah "Error adding buffer to queue\n"); 17661b637046SSjur Brændeland free_buf(buf, false); 176751df0accSAmit Shah } 176851df0accSAmit Shah } 1769165b1b8bSAmit Shah spin_unlock(&portdev->c_ivq_lock); 177051df0accSAmit Shah } 177151df0accSAmit Shah 1772ce86d35dSLinus Torvalds static void out_intr(struct virtqueue *vq) 1773ce86d35dSLinus Torvalds { 1774ce86d35dSLinus Torvalds struct port *port; 1775ce86d35dSLinus Torvalds 1776ce86d35dSLinus Torvalds port = find_port_by_vq(vq->vdev->priv, vq); 1777ce86d35dSLinus Torvalds if (!port) 1778ce86d35dSLinus Torvalds return; 1779ce86d35dSLinus Torvalds 1780ce86d35dSLinus Torvalds wake_up_interruptible(&port->waitqueue); 1781ce86d35dSLinus Torvalds } 1782ce86d35dSLinus Torvalds 178351df0accSAmit Shah static void in_intr(struct virtqueue *vq) 178451df0accSAmit Shah { 178551df0accSAmit Shah struct port *port; 178651df0accSAmit Shah unsigned long flags; 178751df0accSAmit Shah 178851df0accSAmit Shah port = find_port_by_vq(vq->vdev->priv, vq); 178951df0accSAmit Shah if (!port) 179051df0accSAmit Shah return; 179151df0accSAmit Shah 179251df0accSAmit Shah spin_lock_irqsave(&port->inbuf_lock, flags); 179351df0accSAmit Shah port->inbuf = get_inbuf(port); 179451df0accSAmit Shah 179551df0accSAmit Shah /* 1796aabd6a8fSSjur Brændeland * Normally the port should not accept data when the port is 1797aabd6a8fSSjur Brændeland * closed. For generic serial ports, the host won't (shouldn't) 1798aabd6a8fSSjur Brændeland * send data till the guest is connected. But this condition 179951df0accSAmit Shah * can be reached when a console port is not yet connected (no 1800aabd6a8fSSjur Brændeland * tty is spawned) and the other side sends out data over the 1801aabd6a8fSSjur Brændeland * vring, or when a remote devices start sending data before 1802aabd6a8fSSjur Brændeland * the ports are opened. 1803aabd6a8fSSjur Brændeland * 1804aabd6a8fSSjur Brændeland * A generic serial port will discard data if not connected, 1805aabd6a8fSSjur Brændeland * while console ports and rproc-serial ports accepts data at 1806aabd6a8fSSjur Brændeland * any time. rproc-serial is initiated with guest_connected to 1807aabd6a8fSSjur Brændeland * false because port_fops_open expects this. Console ports are 1808aabd6a8fSSjur Brændeland * hooked up with an HVC console and is initialized with 1809aabd6a8fSSjur Brændeland * guest_connected to true. 181051df0accSAmit Shah */ 1811aabd6a8fSSjur Brændeland 1812aabd6a8fSSjur Brændeland if (!port->guest_connected && !is_rproc_serial(port->portdev->vdev)) 181351df0accSAmit Shah discard_port_data(port); 181451df0accSAmit Shah 1815314081f1SAmit Shah /* Send a SIGIO indicating new data in case the process asked for it */ 1816314081f1SAmit Shah send_sigio_to_port(port); 1817314081f1SAmit Shah 181851df0accSAmit Shah spin_unlock_irqrestore(&port->inbuf_lock, flags); 181951df0accSAmit Shah 182051df0accSAmit Shah wake_up_interruptible(&port->waitqueue); 182151df0accSAmit Shah 182251df0accSAmit Shah if (is_console_port(port) && hvc_poll(port->cons.hvc)) 182351df0accSAmit Shah hvc_kick(); 182451df0accSAmit Shah } 182551df0accSAmit Shah 182651df0accSAmit Shah static void control_intr(struct virtqueue *vq) 182751df0accSAmit Shah { 182851df0accSAmit Shah struct ports_device *portdev; 182951df0accSAmit Shah 183051df0accSAmit Shah portdev = vq->vdev->priv; 183151df0accSAmit Shah schedule_work(&portdev->control_work); 183251df0accSAmit Shah } 183351df0accSAmit Shah 183451df0accSAmit Shah static void config_intr(struct virtio_device *vdev) 183551df0accSAmit Shah { 183651df0accSAmit Shah struct ports_device *portdev; 183751df0accSAmit Shah 183851df0accSAmit Shah portdev = vdev->priv; 183951df0accSAmit Shah 184051df0accSAmit Shah if (!use_multiport(portdev)) { 184151df0accSAmit Shah struct port *port; 184251df0accSAmit Shah u16 rows, cols; 184351df0accSAmit Shah 1844855e0c52SRusty Russell virtio_cread(vdev, struct virtio_console_config, cols, &cols); 1845855e0c52SRusty Russell virtio_cread(vdev, struct virtio_console_config, rows, &rows); 184651df0accSAmit Shah 184751df0accSAmit Shah port = find_port_by_id(portdev, 0); 184851df0accSAmit Shah set_console_size(port, rows, cols); 184951df0accSAmit Shah 185051df0accSAmit Shah /* 185151df0accSAmit Shah * We'll use this way of resizing only for legacy 185251df0accSAmit Shah * support. For newer userspace 185351df0accSAmit Shah * (VIRTIO_CONSOLE_F_MULTPORT+), use control messages 185451df0accSAmit Shah * to indicate console size changes so that it can be 185551df0accSAmit Shah * done per-port. 185651df0accSAmit Shah */ 185751df0accSAmit Shah resize_console(port); 185851df0accSAmit Shah } 185951df0accSAmit Shah } 186051df0accSAmit Shah 186151df0accSAmit Shah static int init_vqs(struct ports_device *portdev) 186251df0accSAmit Shah { 186351df0accSAmit Shah vq_callback_t **io_callbacks; 186451df0accSAmit Shah char **io_names; 186551df0accSAmit Shah struct virtqueue **vqs; 186651df0accSAmit Shah u32 i, j, nr_ports, nr_queues; 186751df0accSAmit Shah int err; 186851df0accSAmit Shah 186951df0accSAmit Shah nr_ports = portdev->config.max_nr_ports; 187051df0accSAmit Shah nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2; 187151df0accSAmit Shah 187251df0accSAmit Shah vqs = kmalloc(nr_queues * sizeof(struct virtqueue *), GFP_KERNEL); 187351df0accSAmit Shah io_callbacks = kmalloc(nr_queues * sizeof(vq_callback_t *), GFP_KERNEL); 187451df0accSAmit Shah io_names = kmalloc(nr_queues * sizeof(char *), GFP_KERNEL); 187551df0accSAmit Shah portdev->in_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *), 187651df0accSAmit Shah GFP_KERNEL); 187751df0accSAmit Shah portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *), 187851df0accSAmit Shah GFP_KERNEL); 187951df0accSAmit Shah if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs || 188051df0accSAmit Shah !portdev->out_vqs) { 188151df0accSAmit Shah err = -ENOMEM; 188251df0accSAmit Shah goto free; 188351df0accSAmit Shah } 188451df0accSAmit Shah 188551df0accSAmit Shah /* 188651df0accSAmit Shah * For backward compat (newer host but older guest), the host 188751df0accSAmit Shah * spawns a console port first and also inits the vqs for port 188851df0accSAmit Shah * 0 before others. 188951df0accSAmit Shah */ 189051df0accSAmit Shah j = 0; 189151df0accSAmit Shah io_callbacks[j] = in_intr; 1892ce86d35dSLinus Torvalds io_callbacks[j + 1] = out_intr; 189351df0accSAmit Shah io_names[j] = "input"; 189451df0accSAmit Shah io_names[j + 1] = "output"; 189551df0accSAmit Shah j += 2; 189651df0accSAmit Shah 189751df0accSAmit Shah if (use_multiport(portdev)) { 189851df0accSAmit Shah io_callbacks[j] = control_intr; 189951df0accSAmit Shah io_callbacks[j + 1] = NULL; 190051df0accSAmit Shah io_names[j] = "control-i"; 190151df0accSAmit Shah io_names[j + 1] = "control-o"; 190251df0accSAmit Shah 190351df0accSAmit Shah for (i = 1; i < nr_ports; i++) { 190451df0accSAmit Shah j += 2; 190551df0accSAmit Shah io_callbacks[j] = in_intr; 1906ce86d35dSLinus Torvalds io_callbacks[j + 1] = out_intr; 190751df0accSAmit Shah io_names[j] = "input"; 190851df0accSAmit Shah io_names[j + 1] = "output"; 190951df0accSAmit Shah } 191051df0accSAmit Shah } 191151df0accSAmit Shah /* Find the queues. */ 191251df0accSAmit Shah err = portdev->vdev->config->find_vqs(portdev->vdev, nr_queues, vqs, 191351df0accSAmit Shah io_callbacks, 191451df0accSAmit Shah (const char **)io_names); 191551df0accSAmit Shah if (err) 191651df0accSAmit Shah goto free; 191751df0accSAmit Shah 191851df0accSAmit Shah j = 0; 191951df0accSAmit Shah portdev->in_vqs[0] = vqs[0]; 192051df0accSAmit Shah portdev->out_vqs[0] = vqs[1]; 192151df0accSAmit Shah j += 2; 192251df0accSAmit Shah if (use_multiport(portdev)) { 192351df0accSAmit Shah portdev->c_ivq = vqs[j]; 192451df0accSAmit Shah portdev->c_ovq = vqs[j + 1]; 192551df0accSAmit Shah 192651df0accSAmit Shah for (i = 1; i < nr_ports; i++) { 192751df0accSAmit Shah j += 2; 192851df0accSAmit Shah portdev->in_vqs[i] = vqs[j]; 192951df0accSAmit Shah portdev->out_vqs[i] = vqs[j + 1]; 193051df0accSAmit Shah } 193151df0accSAmit Shah } 193251df0accSAmit Shah kfree(io_names); 193351df0accSAmit Shah kfree(io_callbacks); 193451df0accSAmit Shah kfree(vqs); 193551df0accSAmit Shah 193651df0accSAmit Shah return 0; 193751df0accSAmit Shah 193851df0accSAmit Shah free: 193951df0accSAmit Shah kfree(portdev->out_vqs); 194051df0accSAmit Shah kfree(portdev->in_vqs); 194151df0accSAmit Shah kfree(io_names); 194251df0accSAmit Shah kfree(io_callbacks); 194351df0accSAmit Shah kfree(vqs); 194451df0accSAmit Shah 194551df0accSAmit Shah return err; 194651df0accSAmit Shah } 194751df0accSAmit Shah 194851df0accSAmit Shah static const struct file_operations portdev_fops = { 194951df0accSAmit Shah .owner = THIS_MODULE, 195051df0accSAmit Shah }; 195151df0accSAmit Shah 1952a0e2dbfcSAmit Shah static void remove_vqs(struct ports_device *portdev) 1953a0e2dbfcSAmit Shah { 1954a0e2dbfcSAmit Shah portdev->vdev->config->del_vqs(portdev->vdev); 1955a0e2dbfcSAmit Shah kfree(portdev->in_vqs); 1956a0e2dbfcSAmit Shah kfree(portdev->out_vqs); 1957a0e2dbfcSAmit Shah } 1958a0e2dbfcSAmit Shah 1959a0e2dbfcSAmit Shah static void remove_controlq_data(struct ports_device *portdev) 1960a0e2dbfcSAmit Shah { 1961a0e2dbfcSAmit Shah struct port_buffer *buf; 1962a0e2dbfcSAmit Shah unsigned int len; 1963a0e2dbfcSAmit Shah 1964a0e2dbfcSAmit Shah if (!use_multiport(portdev)) 1965a0e2dbfcSAmit Shah return; 1966a0e2dbfcSAmit Shah 1967a0e2dbfcSAmit Shah while ((buf = virtqueue_get_buf(portdev->c_ivq, &len))) 19681b637046SSjur Brændeland free_buf(buf, true); 1969a0e2dbfcSAmit Shah 1970a0e2dbfcSAmit Shah while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq))) 19711b637046SSjur Brændeland free_buf(buf, true); 1972a0e2dbfcSAmit Shah } 1973a0e2dbfcSAmit Shah 197451df0accSAmit Shah /* 197551df0accSAmit Shah * Once we're further in boot, we get probed like any other virtio 197651df0accSAmit Shah * device. 197751df0accSAmit Shah * 197851df0accSAmit Shah * If the host also supports multiple console ports, we check the 197951df0accSAmit Shah * config space to see how many ports the host has spawned. We 198051df0accSAmit Shah * initialize each port found. 198151df0accSAmit Shah */ 19822223cbecSBill Pemberton static int virtcons_probe(struct virtio_device *vdev) 198351df0accSAmit Shah { 198451df0accSAmit Shah struct ports_device *portdev; 198551df0accSAmit Shah int err; 198651df0accSAmit Shah bool multiport; 19875e38483bSChristian Borntraeger bool early = early_put_chars != NULL; 19885e38483bSChristian Borntraeger 19895e38483bSChristian Borntraeger /* Ensure to read early_put_chars now */ 19905e38483bSChristian Borntraeger barrier(); 199151df0accSAmit Shah 199251df0accSAmit Shah portdev = kmalloc(sizeof(*portdev), GFP_KERNEL); 199351df0accSAmit Shah if (!portdev) { 199451df0accSAmit Shah err = -ENOMEM; 199551df0accSAmit Shah goto fail; 199651df0accSAmit Shah } 199751df0accSAmit Shah 199851df0accSAmit Shah /* Attach this portdev to this virtio_device, and vice-versa. */ 199951df0accSAmit Shah portdev->vdev = vdev; 200051df0accSAmit Shah vdev->priv = portdev; 200151df0accSAmit Shah 200251df0accSAmit Shah portdev->chr_major = register_chrdev(0, "virtio-portsdev", 200351df0accSAmit Shah &portdev_fops); 200451df0accSAmit Shah if (portdev->chr_major < 0) { 200551df0accSAmit Shah dev_err(&vdev->dev, 200651df0accSAmit Shah "Error %d registering chrdev for device %u\n", 2007dc18f080SSjur Brændeland portdev->chr_major, vdev->index); 200851df0accSAmit Shah err = portdev->chr_major; 200951df0accSAmit Shah goto free; 201051df0accSAmit Shah } 201151df0accSAmit Shah 201251df0accSAmit Shah multiport = false; 201351df0accSAmit Shah portdev->config.max_nr_ports = 1; 20141b637046SSjur Brændeland 20151b637046SSjur Brændeland /* Don't test MULTIPORT at all if we're rproc: not a valid feature! */ 20161b637046SSjur Brændeland if (!is_rproc_serial(vdev) && 2017855e0c52SRusty Russell virtio_cread_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT, 2018855e0c52SRusty Russell struct virtio_console_config, max_nr_ports, 20191b637046SSjur Brændeland &portdev->config.max_nr_ports) == 0) { 202051c6d61aSSasha Levin multiport = true; 20211b637046SSjur Brændeland } 202251df0accSAmit Shah 202351df0accSAmit Shah err = init_vqs(portdev); 202451df0accSAmit Shah if (err < 0) { 202551df0accSAmit Shah dev_err(&vdev->dev, "Error %d initializing vqs\n", err); 202651df0accSAmit Shah goto free_chrdev; 202751df0accSAmit Shah } 202851df0accSAmit Shah 202951df0accSAmit Shah spin_lock_init(&portdev->ports_lock); 203051df0accSAmit Shah INIT_LIST_HEAD(&portdev->ports); 203151df0accSAmit Shah 203265eca3a2SCornelia Huck virtio_device_ready(portdev->vdev); 203365eca3a2SCornelia Huck 203451df0accSAmit Shah if (multiport) { 203551df0accSAmit Shah unsigned int nr_added_bufs; 203651df0accSAmit Shah 2037165b1b8bSAmit Shah spin_lock_init(&portdev->c_ivq_lock); 20389ba5c80bSAmit Shah spin_lock_init(&portdev->c_ovq_lock); 203951df0accSAmit Shah INIT_WORK(&portdev->control_work, &control_work_handler); 204051df0accSAmit Shah 2041165b1b8bSAmit Shah nr_added_bufs = fill_queue(portdev->c_ivq, 2042165b1b8bSAmit Shah &portdev->c_ivq_lock); 204351df0accSAmit Shah if (!nr_added_bufs) { 204451df0accSAmit Shah dev_err(&vdev->dev, 204551df0accSAmit Shah "Error allocating buffers for control queue\n"); 204651df0accSAmit Shah err = -ENOMEM; 204751df0accSAmit Shah goto free_vqs; 204851df0accSAmit Shah } 204951df0accSAmit Shah } else { 205051df0accSAmit Shah /* 205151df0accSAmit Shah * For backward compatibility: Create a console port 205251df0accSAmit Shah * if we're running on older host. 205351df0accSAmit Shah */ 205451df0accSAmit Shah add_port(portdev, 0); 205551df0accSAmit Shah } 205651df0accSAmit Shah 205751df0accSAmit Shah spin_lock_irq(&pdrvdata_lock); 205851df0accSAmit Shah list_add_tail(&portdev->list, &pdrvdata.portdevs); 205951df0accSAmit Shah spin_unlock_irq(&pdrvdata_lock); 206051df0accSAmit Shah 206151df0accSAmit Shah __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID, 206251df0accSAmit Shah VIRTIO_CONSOLE_DEVICE_READY, 1); 20635e38483bSChristian Borntraeger 20645e38483bSChristian Borntraeger /* 20655e38483bSChristian Borntraeger * If there was an early virtio console, assume that there are no 20665e38483bSChristian Borntraeger * other consoles. We need to wait until the hvc_alloc matches the 20675e38483bSChristian Borntraeger * hvc_instantiate, otherwise tty_open will complain, resulting in 20685e38483bSChristian Borntraeger * a "Warning: unable to open an initial console" boot failure. 20695e38483bSChristian Borntraeger * Without multiport this is done in add_port above. With multiport 20705e38483bSChristian Borntraeger * this might take some host<->guest communication - thus we have to 20715e38483bSChristian Borntraeger * wait. 20725e38483bSChristian Borntraeger */ 20735e38483bSChristian Borntraeger if (multiport && early) 20745e38483bSChristian Borntraeger wait_for_completion(&early_console_added); 20755e38483bSChristian Borntraeger 207651df0accSAmit Shah return 0; 207751df0accSAmit Shah 207851df0accSAmit Shah free_vqs: 207951df0accSAmit Shah /* The host might want to notify mgmt sw about device add failure */ 208051df0accSAmit Shah __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID, 208151df0accSAmit Shah VIRTIO_CONSOLE_DEVICE_READY, 0); 2082a0e2dbfcSAmit Shah remove_vqs(portdev); 208351df0accSAmit Shah free_chrdev: 208451df0accSAmit Shah unregister_chrdev(portdev->chr_major, "virtio-portsdev"); 208551df0accSAmit Shah free: 208651df0accSAmit Shah kfree(portdev); 208751df0accSAmit Shah fail: 208851df0accSAmit Shah return err; 208951df0accSAmit Shah } 209051df0accSAmit Shah 209151df0accSAmit Shah static void virtcons_remove(struct virtio_device *vdev) 209251df0accSAmit Shah { 209351df0accSAmit Shah struct ports_device *portdev; 209451df0accSAmit Shah struct port *port, *port2; 209551df0accSAmit Shah 209651df0accSAmit Shah portdev = vdev->priv; 209751df0accSAmit Shah 209851df0accSAmit Shah spin_lock_irq(&pdrvdata_lock); 209951df0accSAmit Shah list_del(&portdev->list); 210051df0accSAmit Shah spin_unlock_irq(&pdrvdata_lock); 210151df0accSAmit Shah 210251df0accSAmit Shah /* Disable interrupts for vqs */ 210351df0accSAmit Shah vdev->config->reset(vdev); 210451df0accSAmit Shah /* Finish up work that's lined up */ 2105aded024aSSjur Brændeland if (use_multiport(portdev)) 210651df0accSAmit Shah cancel_work_sync(&portdev->control_work); 210751df0accSAmit Shah 210851df0accSAmit Shah list_for_each_entry_safe(port, port2, &portdev->ports, list) 210951df0accSAmit Shah unplug_port(port); 211051df0accSAmit Shah 211151df0accSAmit Shah unregister_chrdev(portdev->chr_major, "virtio-portsdev"); 211251df0accSAmit Shah 211351df0accSAmit Shah /* 211451df0accSAmit Shah * When yanking out a device, we immediately lose the 211551df0accSAmit Shah * (device-side) queues. So there's no point in keeping the 211651df0accSAmit Shah * guest side around till we drop our final reference. This 211751df0accSAmit Shah * also means that any ports which are in an open state will 211851df0accSAmit Shah * have to just stop using the port, as the vqs are going 211951df0accSAmit Shah * away. 212051df0accSAmit Shah */ 2121a0e2dbfcSAmit Shah remove_controlq_data(portdev); 2122a0e2dbfcSAmit Shah remove_vqs(portdev); 212351df0accSAmit Shah kfree(portdev); 212451df0accSAmit Shah } 212551df0accSAmit Shah 212651df0accSAmit Shah static struct virtio_device_id id_table[] = { 212751df0accSAmit Shah { VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID }, 212851df0accSAmit Shah { 0 }, 212951df0accSAmit Shah }; 213051df0accSAmit Shah 213151df0accSAmit Shah static unsigned int features[] = { 213251df0accSAmit Shah VIRTIO_CONSOLE_F_SIZE, 213351df0accSAmit Shah VIRTIO_CONSOLE_F_MULTIPORT, 213451df0accSAmit Shah }; 213551df0accSAmit Shah 21361b637046SSjur Brændeland static struct virtio_device_id rproc_serial_id_table[] = { 21371b637046SSjur Brændeland #if IS_ENABLED(CONFIG_REMOTEPROC) 21381b637046SSjur Brændeland { VIRTIO_ID_RPROC_SERIAL, VIRTIO_DEV_ANY_ID }, 21391b637046SSjur Brændeland #endif 21401b637046SSjur Brændeland { 0 }, 21411b637046SSjur Brændeland }; 21421b637046SSjur Brændeland 21431b637046SSjur Brændeland static unsigned int rproc_serial_features[] = { 21441b637046SSjur Brændeland }; 21451b637046SSjur Brændeland 214689107000SAaron Lu #ifdef CONFIG_PM_SLEEP 21472b8f41d8SAmit Shah static int virtcons_freeze(struct virtio_device *vdev) 21482b8f41d8SAmit Shah { 21492b8f41d8SAmit Shah struct ports_device *portdev; 21502b8f41d8SAmit Shah struct port *port; 21512b8f41d8SAmit Shah 21522b8f41d8SAmit Shah portdev = vdev->priv; 21532b8f41d8SAmit Shah 21542b8f41d8SAmit Shah vdev->config->reset(vdev); 21552b8f41d8SAmit Shah 2156c743d09dSAmit Shah virtqueue_disable_cb(portdev->c_ivq); 21572b8f41d8SAmit Shah cancel_work_sync(&portdev->control_work); 2158c743d09dSAmit Shah /* 2159c743d09dSAmit Shah * Once more: if control_work_handler() was running, it would 2160c743d09dSAmit Shah * enable the cb as the last step. 2161c743d09dSAmit Shah */ 2162c743d09dSAmit Shah virtqueue_disable_cb(portdev->c_ivq); 21632b8f41d8SAmit Shah remove_controlq_data(portdev); 21642b8f41d8SAmit Shah 21652b8f41d8SAmit Shah list_for_each_entry(port, &portdev->ports, list) { 2166c743d09dSAmit Shah virtqueue_disable_cb(port->in_vq); 2167c743d09dSAmit Shah virtqueue_disable_cb(port->out_vq); 21682b8f41d8SAmit Shah /* 21692b8f41d8SAmit Shah * We'll ask the host later if the new invocation has 21702b8f41d8SAmit Shah * the port opened or closed. 21712b8f41d8SAmit Shah */ 21722b8f41d8SAmit Shah port->host_connected = false; 21732b8f41d8SAmit Shah remove_port_data(port); 21742b8f41d8SAmit Shah } 21752b8f41d8SAmit Shah remove_vqs(portdev); 21762b8f41d8SAmit Shah 21772b8f41d8SAmit Shah return 0; 21782b8f41d8SAmit Shah } 21792b8f41d8SAmit Shah 21802b8f41d8SAmit Shah static int virtcons_restore(struct virtio_device *vdev) 21812b8f41d8SAmit Shah { 21822b8f41d8SAmit Shah struct ports_device *portdev; 21832b8f41d8SAmit Shah struct port *port; 21842b8f41d8SAmit Shah int ret; 21852b8f41d8SAmit Shah 21862b8f41d8SAmit Shah portdev = vdev->priv; 21872b8f41d8SAmit Shah 21882b8f41d8SAmit Shah ret = init_vqs(portdev); 21892b8f41d8SAmit Shah if (ret) 21902b8f41d8SAmit Shah return ret; 21912b8f41d8SAmit Shah 2192401bbdc9SMichael S. Tsirkin virtio_device_ready(portdev->vdev); 2193401bbdc9SMichael S. Tsirkin 21942b8f41d8SAmit Shah if (use_multiport(portdev)) 2195165b1b8bSAmit Shah fill_queue(portdev->c_ivq, &portdev->c_ivq_lock); 21962b8f41d8SAmit Shah 21972b8f41d8SAmit Shah list_for_each_entry(port, &portdev->ports, list) { 21982b8f41d8SAmit Shah port->in_vq = portdev->in_vqs[port->id]; 21992b8f41d8SAmit Shah port->out_vq = portdev->out_vqs[port->id]; 22002b8f41d8SAmit Shah 22012b8f41d8SAmit Shah fill_queue(port->in_vq, &port->inbuf_lock); 22022b8f41d8SAmit Shah 22032b8f41d8SAmit Shah /* Get port open/close status on the host */ 22042b8f41d8SAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1); 2205fa8b66ccSAmit Shah 2206fa8b66ccSAmit Shah /* 2207fa8b66ccSAmit Shah * If a port was open at the time of suspending, we 2208fa8b66ccSAmit Shah * have to let the host know that it's still open. 2209fa8b66ccSAmit Shah */ 2210fa8b66ccSAmit Shah if (port->guest_connected) 2211fa8b66ccSAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1); 22122b8f41d8SAmit Shah } 22132b8f41d8SAmit Shah return 0; 22142b8f41d8SAmit Shah } 22152b8f41d8SAmit Shah #endif 22162b8f41d8SAmit Shah 221751df0accSAmit Shah static struct virtio_driver virtio_console = { 221851df0accSAmit Shah .feature_table = features, 221951df0accSAmit Shah .feature_table_size = ARRAY_SIZE(features), 222051df0accSAmit Shah .driver.name = KBUILD_MODNAME, 222151df0accSAmit Shah .driver.owner = THIS_MODULE, 222251df0accSAmit Shah .id_table = id_table, 222351df0accSAmit Shah .probe = virtcons_probe, 222451df0accSAmit Shah .remove = virtcons_remove, 222551df0accSAmit Shah .config_changed = config_intr, 222689107000SAaron Lu #ifdef CONFIG_PM_SLEEP 22272b8f41d8SAmit Shah .freeze = virtcons_freeze, 22282b8f41d8SAmit Shah .restore = virtcons_restore, 22292b8f41d8SAmit Shah #endif 223051df0accSAmit Shah }; 223151df0accSAmit Shah 2232bcd2982aSGreg Kroah-Hartman static struct virtio_driver virtio_rproc_serial = { 22331b637046SSjur Brændeland .feature_table = rproc_serial_features, 22341b637046SSjur Brændeland .feature_table_size = ARRAY_SIZE(rproc_serial_features), 22351b637046SSjur Brændeland .driver.name = "virtio_rproc_serial", 22361b637046SSjur Brændeland .driver.owner = THIS_MODULE, 22371b637046SSjur Brændeland .id_table = rproc_serial_id_table, 22381b637046SSjur Brændeland .probe = virtcons_probe, 22391b637046SSjur Brændeland .remove = virtcons_remove, 22401b637046SSjur Brændeland }; 22411b637046SSjur Brændeland 224251df0accSAmit Shah static int __init init(void) 224351df0accSAmit Shah { 224451df0accSAmit Shah int err; 224551df0accSAmit Shah 224651df0accSAmit Shah pdrvdata.class = class_create(THIS_MODULE, "virtio-ports"); 224751df0accSAmit Shah if (IS_ERR(pdrvdata.class)) { 224851df0accSAmit Shah err = PTR_ERR(pdrvdata.class); 224951df0accSAmit Shah pr_err("Error %d creating virtio-ports class\n", err); 225051df0accSAmit Shah return err; 225151df0accSAmit Shah } 225251df0accSAmit Shah 225351df0accSAmit Shah pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL); 22543f0d0c9bSDan Carpenter if (!pdrvdata.debugfs_dir) 22553f0d0c9bSDan Carpenter pr_warning("Error creating debugfs dir for virtio-ports\n"); 225651df0accSAmit Shah INIT_LIST_HEAD(&pdrvdata.consoles); 225751df0accSAmit Shah INIT_LIST_HEAD(&pdrvdata.portdevs); 225851df0accSAmit Shah 225933e1afc3SAlexey Khoroshilov err = register_virtio_driver(&virtio_console); 226033e1afc3SAlexey Khoroshilov if (err < 0) { 226133e1afc3SAlexey Khoroshilov pr_err("Error %d registering virtio driver\n", err); 226233e1afc3SAlexey Khoroshilov goto free; 226333e1afc3SAlexey Khoroshilov } 22641b637046SSjur Brændeland err = register_virtio_driver(&virtio_rproc_serial); 22651b637046SSjur Brændeland if (err < 0) { 22661b637046SSjur Brændeland pr_err("Error %d registering virtio rproc serial driver\n", 22671b637046SSjur Brændeland err); 22681b637046SSjur Brændeland goto unregister; 22691b637046SSjur Brændeland } 227033e1afc3SAlexey Khoroshilov return 0; 22711b637046SSjur Brændeland unregister: 22721b637046SSjur Brændeland unregister_virtio_driver(&virtio_console); 227333e1afc3SAlexey Khoroshilov free: 227433e1afc3SAlexey Khoroshilov debugfs_remove_recursive(pdrvdata.debugfs_dir); 227533e1afc3SAlexey Khoroshilov class_destroy(pdrvdata.class); 227633e1afc3SAlexey Khoroshilov return err; 227751df0accSAmit Shah } 227851df0accSAmit Shah 227951df0accSAmit Shah static void __exit fini(void) 228051df0accSAmit Shah { 22811b637046SSjur Brændeland reclaim_dma_bufs(); 22821b637046SSjur Brændeland 228351df0accSAmit Shah unregister_virtio_driver(&virtio_console); 22841b637046SSjur Brændeland unregister_virtio_driver(&virtio_rproc_serial); 228551df0accSAmit Shah 228651df0accSAmit Shah class_destroy(pdrvdata.class); 228751df0accSAmit Shah debugfs_remove_recursive(pdrvdata.debugfs_dir); 228851df0accSAmit Shah } 228951df0accSAmit Shah module_init(init); 229051df0accSAmit Shah module_exit(fini); 229151df0accSAmit Shah 229251df0accSAmit Shah MODULE_DEVICE_TABLE(virtio, id_table); 229351df0accSAmit Shah MODULE_DESCRIPTION("Virtio console driver"); 229451df0accSAmit Shah MODULE_LICENSE("GPL"); 2295