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; 145eeb8a7e8SMichael S. Tsirkin struct work_struct config_work; 14651df0accSAmit Shah 14751df0accSAmit Shah struct list_head ports; 14851df0accSAmit Shah 14951df0accSAmit Shah /* To protect the list of ports */ 15051df0accSAmit Shah spinlock_t ports_lock; 15151df0accSAmit Shah 15251df0accSAmit Shah /* To protect the vq operations for the control channel */ 153165b1b8bSAmit Shah spinlock_t c_ivq_lock; 1549ba5c80bSAmit Shah spinlock_t c_ovq_lock; 15551df0accSAmit Shah 15651df0accSAmit Shah /* The current config space is stored here */ 15751df0accSAmit Shah struct virtio_console_config config; 15851df0accSAmit Shah 15951df0accSAmit Shah /* The virtio device we're associated with */ 16051df0accSAmit Shah struct virtio_device *vdev; 16151df0accSAmit Shah 16251df0accSAmit Shah /* 16351df0accSAmit Shah * A couple of virtqueues for the control channel: one for 16451df0accSAmit Shah * guest->host transfers, one for host->guest transfers 16551df0accSAmit Shah */ 16651df0accSAmit Shah struct virtqueue *c_ivq, *c_ovq; 16751df0accSAmit Shah 16851df0accSAmit Shah /* Array of per-port IO virtqueues */ 16951df0accSAmit Shah struct virtqueue **in_vqs, **out_vqs; 17051df0accSAmit Shah 17151df0accSAmit Shah /* Major number for this device. Ports will be created as minors. */ 17251df0accSAmit Shah int chr_major; 17351df0accSAmit Shah }; 17451df0accSAmit Shah 17517e5b4f2SAmit Shah struct port_stats { 17617e5b4f2SAmit Shah unsigned long bytes_sent, bytes_received, bytes_discarded; 17717e5b4f2SAmit Shah }; 17817e5b4f2SAmit Shah 17951df0accSAmit Shah /* This struct holds the per-port data */ 18051df0accSAmit Shah struct port { 18151df0accSAmit Shah /* Next port in the list, head is in the ports_device */ 18251df0accSAmit Shah struct list_head list; 18351df0accSAmit Shah 18451df0accSAmit Shah /* Pointer to the parent virtio_console device */ 18551df0accSAmit Shah struct ports_device *portdev; 18651df0accSAmit Shah 18751df0accSAmit Shah /* The current buffer from which data has to be fed to readers */ 18851df0accSAmit Shah struct port_buffer *inbuf; 18951df0accSAmit Shah 19051df0accSAmit Shah /* 19151df0accSAmit Shah * To protect the operations on the in_vq associated with this 19251df0accSAmit Shah * port. Has to be a spinlock because it can be called from 19351df0accSAmit Shah * interrupt context (get_char()). 19451df0accSAmit Shah */ 19551df0accSAmit Shah spinlock_t inbuf_lock; 19651df0accSAmit Shah 19751df0accSAmit Shah /* Protect the operations on the out_vq. */ 19851df0accSAmit Shah spinlock_t outvq_lock; 19951df0accSAmit Shah 20051df0accSAmit Shah /* The IO vqs for this port */ 20151df0accSAmit Shah struct virtqueue *in_vq, *out_vq; 20251df0accSAmit Shah 20351df0accSAmit Shah /* File in the debugfs directory that exposes this port's information */ 20451df0accSAmit Shah struct dentry *debugfs_file; 20551df0accSAmit Shah 20651df0accSAmit Shah /* 20717e5b4f2SAmit Shah * Keep count of the bytes sent, received and discarded for 20817e5b4f2SAmit Shah * this port for accounting and debugging purposes. These 20917e5b4f2SAmit Shah * counts are not reset across port open / close events. 21017e5b4f2SAmit Shah */ 21117e5b4f2SAmit Shah struct port_stats stats; 21217e5b4f2SAmit Shah 21317e5b4f2SAmit Shah /* 21451df0accSAmit Shah * The entries in this struct will be valid if this port is 21551df0accSAmit Shah * hooked up to an hvc console 21651df0accSAmit Shah */ 21751df0accSAmit Shah struct console cons; 21851df0accSAmit Shah 21951df0accSAmit Shah /* Each port associates with a separate char device */ 22051df0accSAmit Shah struct cdev *cdev; 22151df0accSAmit Shah struct device *dev; 22251df0accSAmit Shah 22351df0accSAmit Shah /* Reference-counting to handle port hot-unplugs and file operations */ 22451df0accSAmit Shah struct kref kref; 22551df0accSAmit Shah 22651df0accSAmit Shah /* A waitqueue for poll() or blocking read operations */ 22751df0accSAmit Shah wait_queue_head_t waitqueue; 22851df0accSAmit Shah 22951df0accSAmit Shah /* The 'name' of the port that we expose via sysfs properties */ 23051df0accSAmit Shah char *name; 23151df0accSAmit Shah 23251df0accSAmit Shah /* We can notify apps of host connect / disconnect events via SIGIO */ 23351df0accSAmit Shah struct fasync_struct *async_queue; 23451df0accSAmit Shah 23551df0accSAmit Shah /* The 'id' to identify the port with the Host */ 23651df0accSAmit Shah u32 id; 23751df0accSAmit Shah 23851df0accSAmit Shah bool outvq_full; 23951df0accSAmit Shah 24051df0accSAmit Shah /* Is the host device open */ 24151df0accSAmit Shah bool host_connected; 24251df0accSAmit Shah 24351df0accSAmit Shah /* We should allow only one process to open a port */ 24451df0accSAmit Shah bool guest_connected; 24551df0accSAmit Shah }; 24651df0accSAmit Shah 24751df0accSAmit Shah /* This is the very early arch-specified put chars function. */ 24851df0accSAmit Shah static int (*early_put_chars)(u32, const char *, int); 24951df0accSAmit Shah 25051df0accSAmit Shah static struct port *find_port_by_vtermno(u32 vtermno) 25151df0accSAmit Shah { 25251df0accSAmit Shah struct port *port; 25351df0accSAmit Shah struct console *cons; 25451df0accSAmit Shah unsigned long flags; 25551df0accSAmit Shah 25651df0accSAmit Shah spin_lock_irqsave(&pdrvdata_lock, flags); 25751df0accSAmit Shah list_for_each_entry(cons, &pdrvdata.consoles, list) { 25851df0accSAmit Shah if (cons->vtermno == vtermno) { 25951df0accSAmit Shah port = container_of(cons, struct port, cons); 26051df0accSAmit Shah goto out; 26151df0accSAmit Shah } 26251df0accSAmit Shah } 26351df0accSAmit Shah port = NULL; 26451df0accSAmit Shah out: 26551df0accSAmit Shah spin_unlock_irqrestore(&pdrvdata_lock, flags); 26651df0accSAmit Shah return port; 26751df0accSAmit Shah } 26851df0accSAmit Shah 26951df0accSAmit Shah static struct port *find_port_by_devt_in_portdev(struct ports_device *portdev, 27051df0accSAmit Shah dev_t dev) 27151df0accSAmit Shah { 27251df0accSAmit Shah struct port *port; 27351df0accSAmit Shah unsigned long flags; 27451df0accSAmit Shah 27551df0accSAmit Shah spin_lock_irqsave(&portdev->ports_lock, flags); 276057b82beSAmit Shah list_for_each_entry(port, &portdev->ports, list) { 277057b82beSAmit Shah if (port->cdev->dev == dev) { 278057b82beSAmit Shah kref_get(&port->kref); 27951df0accSAmit Shah goto out; 280057b82beSAmit Shah } 281057b82beSAmit Shah } 28251df0accSAmit Shah port = NULL; 28351df0accSAmit Shah out: 28451df0accSAmit Shah spin_unlock_irqrestore(&portdev->ports_lock, flags); 28551df0accSAmit Shah 28651df0accSAmit Shah return port; 28751df0accSAmit Shah } 28851df0accSAmit Shah 28951df0accSAmit Shah static struct port *find_port_by_devt(dev_t dev) 29051df0accSAmit Shah { 29151df0accSAmit Shah struct ports_device *portdev; 29251df0accSAmit Shah struct port *port; 29351df0accSAmit Shah unsigned long flags; 29451df0accSAmit Shah 29551df0accSAmit Shah spin_lock_irqsave(&pdrvdata_lock, flags); 29651df0accSAmit Shah list_for_each_entry(portdev, &pdrvdata.portdevs, list) { 29751df0accSAmit Shah port = find_port_by_devt_in_portdev(portdev, dev); 29851df0accSAmit Shah if (port) 29951df0accSAmit Shah goto out; 30051df0accSAmit Shah } 30151df0accSAmit Shah port = NULL; 30251df0accSAmit Shah out: 30351df0accSAmit Shah spin_unlock_irqrestore(&pdrvdata_lock, flags); 30451df0accSAmit Shah return port; 30551df0accSAmit Shah } 30651df0accSAmit Shah 30751df0accSAmit Shah static struct port *find_port_by_id(struct ports_device *portdev, u32 id) 30851df0accSAmit Shah { 30951df0accSAmit Shah struct port *port; 31051df0accSAmit Shah unsigned long flags; 31151df0accSAmit Shah 31251df0accSAmit Shah spin_lock_irqsave(&portdev->ports_lock, flags); 31351df0accSAmit Shah list_for_each_entry(port, &portdev->ports, list) 31451df0accSAmit Shah if (port->id == id) 31551df0accSAmit Shah goto out; 31651df0accSAmit Shah port = NULL; 31751df0accSAmit Shah out: 31851df0accSAmit Shah spin_unlock_irqrestore(&portdev->ports_lock, flags); 31951df0accSAmit Shah 32051df0accSAmit Shah return port; 32151df0accSAmit Shah } 32251df0accSAmit Shah 32351df0accSAmit Shah static struct port *find_port_by_vq(struct ports_device *portdev, 32451df0accSAmit Shah struct virtqueue *vq) 32551df0accSAmit Shah { 32651df0accSAmit Shah struct port *port; 32751df0accSAmit Shah unsigned long flags; 32851df0accSAmit Shah 32951df0accSAmit Shah spin_lock_irqsave(&portdev->ports_lock, flags); 33051df0accSAmit Shah list_for_each_entry(port, &portdev->ports, list) 33151df0accSAmit Shah if (port->in_vq == vq || port->out_vq == vq) 33251df0accSAmit Shah goto out; 33351df0accSAmit Shah port = NULL; 33451df0accSAmit Shah out: 33551df0accSAmit Shah spin_unlock_irqrestore(&portdev->ports_lock, flags); 33651df0accSAmit Shah return port; 33751df0accSAmit Shah } 33851df0accSAmit Shah 33951df0accSAmit Shah static bool is_console_port(struct port *port) 34051df0accSAmit Shah { 34151df0accSAmit Shah if (port->cons.hvc) 34251df0accSAmit Shah return true; 34351df0accSAmit Shah return false; 34451df0accSAmit Shah } 34551df0accSAmit Shah 3461b637046SSjur Brændeland static bool is_rproc_serial(const struct virtio_device *vdev) 3471b637046SSjur Brændeland { 3481b637046SSjur Brændeland return is_rproc_enabled && vdev->id.device == VIRTIO_ID_RPROC_SERIAL; 3491b637046SSjur Brændeland } 3501b637046SSjur Brændeland 35151df0accSAmit Shah static inline bool use_multiport(struct ports_device *portdev) 35251df0accSAmit Shah { 35351df0accSAmit Shah /* 35451df0accSAmit Shah * This condition can be true when put_chars is called from 35551df0accSAmit Shah * early_init 35651df0accSAmit Shah */ 35751df0accSAmit Shah if (!portdev->vdev) 358f580d730SJoe Perches return false; 359e16e12beSMichael S. Tsirkin return __virtio_test_bit(portdev->vdev, VIRTIO_CONSOLE_F_MULTIPORT); 36051df0accSAmit Shah } 36151df0accSAmit Shah 3621b637046SSjur Brændeland static DEFINE_SPINLOCK(dma_bufs_lock); 3631b637046SSjur Brændeland static LIST_HEAD(pending_free_dma_bufs); 3641b637046SSjur Brændeland 3651b637046SSjur Brændeland static void free_buf(struct port_buffer *buf, bool can_sleep) 36651df0accSAmit Shah { 367276a3e95SSjur Brændeland unsigned int i; 368276a3e95SSjur Brændeland 369276a3e95SSjur Brændeland for (i = 0; i < buf->sgpages; i++) { 370276a3e95SSjur Brændeland struct page *page = sg_page(&buf->sg[i]); 371276a3e95SSjur Brændeland if (!page) 372276a3e95SSjur Brændeland break; 373276a3e95SSjur Brændeland put_page(page); 374276a3e95SSjur Brændeland } 375276a3e95SSjur Brændeland 3761b637046SSjur Brændeland if (!buf->dev) { 37751df0accSAmit Shah kfree(buf->buf); 3781b637046SSjur Brændeland } else if (is_rproc_enabled) { 3791b637046SSjur Brændeland unsigned long flags; 3801b637046SSjur Brændeland 3811b637046SSjur Brændeland /* dma_free_coherent requires interrupts to be enabled. */ 3821b637046SSjur Brændeland if (!can_sleep) { 3831b637046SSjur Brændeland /* queue up dma-buffers to be freed later */ 3841b637046SSjur Brændeland spin_lock_irqsave(&dma_bufs_lock, flags); 3851b637046SSjur Brændeland list_add_tail(&buf->list, &pending_free_dma_bufs); 3861b637046SSjur Brændeland spin_unlock_irqrestore(&dma_bufs_lock, flags); 3871b637046SSjur Brændeland return; 3881b637046SSjur Brændeland } 3891b637046SSjur Brændeland dma_free_coherent(buf->dev, buf->size, buf->buf, buf->dma); 3901b637046SSjur Brændeland 3911b637046SSjur Brændeland /* Release device refcnt and allow it to be freed */ 3921b637046SSjur Brændeland put_device(buf->dev); 3931b637046SSjur Brændeland } 3941b637046SSjur Brændeland 39551df0accSAmit Shah kfree(buf); 39651df0accSAmit Shah } 39751df0accSAmit Shah 3981b637046SSjur Brændeland static void reclaim_dma_bufs(void) 3991b637046SSjur Brændeland { 4001b637046SSjur Brændeland unsigned long flags; 4011b637046SSjur Brændeland struct port_buffer *buf, *tmp; 4021b637046SSjur Brændeland LIST_HEAD(tmp_list); 4031b637046SSjur Brændeland 4041b637046SSjur Brændeland if (list_empty(&pending_free_dma_bufs)) 4051b637046SSjur Brændeland return; 4061b637046SSjur Brændeland 4071b637046SSjur Brændeland /* Create a copy of the pending_free_dma_bufs while holding the lock */ 4081b637046SSjur Brændeland spin_lock_irqsave(&dma_bufs_lock, flags); 4091b637046SSjur Brændeland list_cut_position(&tmp_list, &pending_free_dma_bufs, 4101b637046SSjur Brændeland pending_free_dma_bufs.prev); 4111b637046SSjur Brændeland spin_unlock_irqrestore(&dma_bufs_lock, flags); 4121b637046SSjur Brændeland 4131b637046SSjur Brændeland /* Release the dma buffers, without irqs enabled */ 4141b637046SSjur Brændeland list_for_each_entry_safe(buf, tmp, &tmp_list, list) { 4151b637046SSjur Brændeland list_del(&buf->list); 4161b637046SSjur Brændeland free_buf(buf, true); 4171b637046SSjur Brændeland } 4181b637046SSjur Brændeland } 4191b637046SSjur Brændeland 420276a3e95SSjur Brændeland static struct port_buffer *alloc_buf(struct virtqueue *vq, size_t buf_size, 421276a3e95SSjur Brændeland int pages) 42251df0accSAmit Shah { 42351df0accSAmit Shah struct port_buffer *buf; 42451df0accSAmit Shah 4251b637046SSjur Brændeland reclaim_dma_bufs(); 4261b637046SSjur Brændeland 427276a3e95SSjur Brændeland /* 428276a3e95SSjur Brændeland * Allocate buffer and the sg list. The sg list array is allocated 429276a3e95SSjur Brændeland * directly after the port_buffer struct. 430276a3e95SSjur Brændeland */ 431276a3e95SSjur Brændeland buf = kmalloc(sizeof(*buf) + sizeof(struct scatterlist) * pages, 432276a3e95SSjur Brændeland GFP_KERNEL); 43351df0accSAmit Shah if (!buf) 43451df0accSAmit Shah goto fail; 435276a3e95SSjur Brændeland 436276a3e95SSjur Brændeland buf->sgpages = pages; 437276a3e95SSjur Brændeland if (pages > 0) { 4381b637046SSjur Brændeland buf->dev = NULL; 439276a3e95SSjur Brændeland buf->buf = NULL; 440276a3e95SSjur Brændeland return buf; 441276a3e95SSjur Brændeland } 442276a3e95SSjur Brændeland 4431b637046SSjur Brændeland if (is_rproc_serial(vq->vdev)) { 4441b637046SSjur Brændeland /* 4451b637046SSjur Brændeland * Allocate DMA memory from ancestor. When a virtio 4461b637046SSjur Brændeland * device is created by remoteproc, the DMA memory is 4471b637046SSjur Brændeland * associated with the grandparent device: 4481b637046SSjur Brændeland * vdev => rproc => platform-dev. 4491b637046SSjur Brændeland * The code here would have been less quirky if 4501b637046SSjur Brændeland * DMA_MEMORY_INCLUDES_CHILDREN had been supported 4511b637046SSjur Brændeland * in dma-coherent.c 4521b637046SSjur Brændeland */ 4531b637046SSjur Brændeland if (!vq->vdev->dev.parent || !vq->vdev->dev.parent->parent) 4541b637046SSjur Brændeland goto free_buf; 4551b637046SSjur Brændeland buf->dev = vq->vdev->dev.parent->parent; 4561b637046SSjur Brændeland 4571b637046SSjur Brændeland /* Increase device refcnt to avoid freeing it */ 4581b637046SSjur Brændeland get_device(buf->dev); 4591b637046SSjur Brændeland buf->buf = dma_alloc_coherent(buf->dev, buf_size, &buf->dma, 4601b637046SSjur Brændeland GFP_KERNEL); 4611b637046SSjur Brændeland } else { 4621b637046SSjur Brændeland buf->dev = NULL; 4630127f685SSjur Brændeland buf->buf = kmalloc(buf_size, GFP_KERNEL); 4641b637046SSjur Brændeland } 4651b637046SSjur Brændeland 46651df0accSAmit Shah if (!buf->buf) 46751df0accSAmit Shah goto free_buf; 46851df0accSAmit Shah buf->len = 0; 46951df0accSAmit Shah buf->offset = 0; 47051df0accSAmit Shah buf->size = buf_size; 47151df0accSAmit Shah return buf; 47251df0accSAmit Shah 47351df0accSAmit Shah free_buf: 47451df0accSAmit Shah kfree(buf); 47551df0accSAmit Shah fail: 47651df0accSAmit Shah return NULL; 47751df0accSAmit Shah } 47851df0accSAmit Shah 47951df0accSAmit Shah /* Callers should take appropriate locks */ 480defde669SAmit Shah static struct port_buffer *get_inbuf(struct port *port) 48151df0accSAmit Shah { 48251df0accSAmit Shah struct port_buffer *buf; 48351df0accSAmit Shah unsigned int len; 48451df0accSAmit Shah 485d25a9ddaSAmit Shah if (port->inbuf) 486d25a9ddaSAmit Shah return port->inbuf; 487d25a9ddaSAmit Shah 488d25a9ddaSAmit Shah buf = virtqueue_get_buf(port->in_vq, &len); 48951df0accSAmit Shah if (buf) { 49051df0accSAmit Shah buf->len = len; 49151df0accSAmit Shah buf->offset = 0; 49217e5b4f2SAmit Shah port->stats.bytes_received += len; 49351df0accSAmit Shah } 49451df0accSAmit Shah return buf; 49551df0accSAmit Shah } 49651df0accSAmit Shah 49751df0accSAmit Shah /* 49851df0accSAmit Shah * Create a scatter-gather list representing our input buffer and put 49951df0accSAmit Shah * it in the queue. 50051df0accSAmit Shah * 50151df0accSAmit Shah * Callers should take appropriate locks. 50251df0accSAmit Shah */ 50351df0accSAmit Shah static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf) 50451df0accSAmit Shah { 50551df0accSAmit Shah struct scatterlist sg[1]; 50651df0accSAmit Shah int ret; 50751df0accSAmit Shah 50851df0accSAmit Shah sg_init_one(sg, buf->buf, buf->size); 50951df0accSAmit Shah 5106797999dSRusty Russell ret = virtqueue_add_inbuf(vq, sg, 1, buf, GFP_ATOMIC); 51151df0accSAmit Shah virtqueue_kick(vq); 51249e86f16SAmit Shah if (!ret) 51349e86f16SAmit Shah ret = vq->num_free; 51451df0accSAmit Shah return ret; 51551df0accSAmit Shah } 51651df0accSAmit Shah 51751df0accSAmit Shah /* Discard any unread data this port has. Callers lockers. */ 51851df0accSAmit Shah static void discard_port_data(struct port *port) 51951df0accSAmit Shah { 52051df0accSAmit Shah struct port_buffer *buf; 5212d24cdaaSAmit Shah unsigned int err; 52251df0accSAmit Shah 523d7a62cd0SAmit Shah if (!port->portdev) { 524d7a62cd0SAmit Shah /* Device has been unplugged. vqs are already gone. */ 525d7a62cd0SAmit Shah return; 526d7a62cd0SAmit Shah } 5272d24cdaaSAmit Shah buf = get_inbuf(port); 52851df0accSAmit Shah 529ce072a0cSAmit Shah err = 0; 53051df0accSAmit Shah while (buf) { 53117e5b4f2SAmit Shah port->stats.bytes_discarded += buf->len - buf->offset; 5322d24cdaaSAmit Shah if (add_inbuf(port->in_vq, buf) < 0) { 533ce072a0cSAmit Shah err++; 5341b637046SSjur Brændeland free_buf(buf, false); 53551df0accSAmit Shah } 53651df0accSAmit Shah port->inbuf = NULL; 5372d24cdaaSAmit Shah buf = get_inbuf(port); 5382d24cdaaSAmit Shah } 539ce072a0cSAmit Shah if (err) 54051df0accSAmit Shah dev_warn(port->dev, "Errors adding %d buffers back to vq\n", 541ce072a0cSAmit Shah err); 54251df0accSAmit Shah } 54351df0accSAmit Shah 54451df0accSAmit Shah static bool port_has_data(struct port *port) 54551df0accSAmit Shah { 54651df0accSAmit Shah unsigned long flags; 54751df0accSAmit Shah bool ret; 54851df0accSAmit Shah 54951df0accSAmit Shah ret = false; 550d25a9ddaSAmit Shah spin_lock_irqsave(&port->inbuf_lock, flags); 551d25a9ddaSAmit Shah port->inbuf = get_inbuf(port); 552d25a9ddaSAmit Shah if (port->inbuf) 553d25a9ddaSAmit Shah ret = true; 554d25a9ddaSAmit Shah 55551df0accSAmit Shah spin_unlock_irqrestore(&port->inbuf_lock, flags); 55651df0accSAmit Shah return ret; 55751df0accSAmit Shah } 55851df0accSAmit Shah 55951df0accSAmit Shah static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id, 56051df0accSAmit Shah unsigned int event, unsigned int value) 56151df0accSAmit Shah { 56251df0accSAmit Shah struct scatterlist sg[1]; 56351df0accSAmit Shah struct virtio_console_control cpkt; 56451df0accSAmit Shah struct virtqueue *vq; 56551df0accSAmit Shah unsigned int len; 56651df0accSAmit Shah 56751df0accSAmit Shah if (!use_multiport(portdev)) 56851df0accSAmit Shah return 0; 56951df0accSAmit Shah 5701f0f9106SMichael S. Tsirkin cpkt.id = cpu_to_virtio32(portdev->vdev, port_id); 5711f0f9106SMichael S. Tsirkin cpkt.event = cpu_to_virtio16(portdev->vdev, event); 5721f0f9106SMichael S. Tsirkin cpkt.value = cpu_to_virtio16(portdev->vdev, value); 57351df0accSAmit Shah 57451df0accSAmit Shah vq = portdev->c_ovq; 57551df0accSAmit Shah 57651df0accSAmit Shah sg_init_one(sg, &cpkt, sizeof(cpkt)); 5779ba5c80bSAmit Shah 5789ba5c80bSAmit Shah spin_lock(&portdev->c_ovq_lock); 5796797999dSRusty Russell if (virtqueue_add_outbuf(vq, sg, 1, &cpkt, GFP_ATOMIC) == 0) { 58051df0accSAmit Shah virtqueue_kick(vq); 58140e4dc53SHeinz Graalfs while (!virtqueue_get_buf(vq, &len) 58240e4dc53SHeinz Graalfs && !virtqueue_is_broken(vq)) 58351df0accSAmit Shah cpu_relax(); 58451df0accSAmit Shah } 5859ba5c80bSAmit Shah spin_unlock(&portdev->c_ovq_lock); 58651df0accSAmit Shah return 0; 58751df0accSAmit Shah } 58851df0accSAmit Shah 58951df0accSAmit Shah static ssize_t send_control_msg(struct port *port, unsigned int event, 59051df0accSAmit Shah unsigned int value) 59151df0accSAmit Shah { 59251df0accSAmit Shah /* Did the port get unplugged before userspace closed it? */ 59351df0accSAmit Shah if (port->portdev) 59451df0accSAmit Shah return __send_control_msg(port->portdev, port->id, event, value); 59551df0accSAmit Shah return 0; 59651df0accSAmit Shah } 59751df0accSAmit Shah 598eb5e89fcSMasami Hiramatsu 59951df0accSAmit Shah /* Callers must take the port->outvq_lock */ 60051df0accSAmit Shah static void reclaim_consumed_buffers(struct port *port) 60151df0accSAmit Shah { 602276a3e95SSjur Brændeland struct port_buffer *buf; 60351df0accSAmit Shah unsigned int len; 60451df0accSAmit Shah 605d7a62cd0SAmit Shah if (!port->portdev) { 606d7a62cd0SAmit Shah /* Device has been unplugged. vqs are already gone. */ 607d7a62cd0SAmit Shah return; 608d7a62cd0SAmit Shah } 609276a3e95SSjur Brændeland while ((buf = virtqueue_get_buf(port->out_vq, &len))) { 6101b637046SSjur Brændeland free_buf(buf, false); 61151df0accSAmit Shah port->outvq_full = false; 61251df0accSAmit Shah } 61351df0accSAmit Shah } 61451df0accSAmit Shah 615eb5e89fcSMasami Hiramatsu static ssize_t __send_to_port(struct port *port, struct scatterlist *sg, 616eb5e89fcSMasami Hiramatsu int nents, size_t in_count, 617276a3e95SSjur Brændeland void *data, bool nonblock) 61851df0accSAmit Shah { 61951df0accSAmit Shah struct virtqueue *out_vq; 620589575a2SRusty Russell int err; 62151df0accSAmit Shah unsigned long flags; 62251df0accSAmit Shah unsigned int len; 62351df0accSAmit Shah 62451df0accSAmit Shah out_vq = port->out_vq; 62551df0accSAmit Shah 62651df0accSAmit Shah spin_lock_irqsave(&port->outvq_lock, flags); 62751df0accSAmit Shah 62851df0accSAmit Shah reclaim_consumed_buffers(port); 62951df0accSAmit Shah 6306797999dSRusty Russell err = virtqueue_add_outbuf(out_vq, sg, nents, data, GFP_ATOMIC); 63151df0accSAmit Shah 63251df0accSAmit Shah /* Tell Host to go! */ 63351df0accSAmit Shah virtqueue_kick(out_vq); 63451df0accSAmit Shah 635589575a2SRusty Russell if (err) { 63651df0accSAmit Shah in_count = 0; 63751df0accSAmit Shah goto done; 63851df0accSAmit Shah } 63951df0accSAmit Shah 640589575a2SRusty Russell if (out_vq->num_free == 0) 64151df0accSAmit Shah port->outvq_full = true; 64251df0accSAmit Shah 64351df0accSAmit Shah if (nonblock) 64451df0accSAmit Shah goto done; 64551df0accSAmit Shah 64651df0accSAmit Shah /* 64751df0accSAmit Shah * Wait till the host acknowledges it pushed out the data we 64851df0accSAmit Shah * sent. This is done for data from the hvc_console; the tty 64951df0accSAmit Shah * operations are performed with spinlocks held so we can't 65051df0accSAmit Shah * sleep here. An alternative would be to copy the data to a 65151df0accSAmit Shah * buffer and relax the spinning requirement. The downside is 65251df0accSAmit Shah * we need to kmalloc a GFP_ATOMIC buffer each time the 65351df0accSAmit Shah * console driver writes something out. 65451df0accSAmit Shah */ 65540e4dc53SHeinz Graalfs while (!virtqueue_get_buf(out_vq, &len) 65640e4dc53SHeinz Graalfs && !virtqueue_is_broken(out_vq)) 65751df0accSAmit Shah cpu_relax(); 65851df0accSAmit Shah done: 65951df0accSAmit Shah spin_unlock_irqrestore(&port->outvq_lock, flags); 66017e5b4f2SAmit Shah 66117e5b4f2SAmit Shah port->stats.bytes_sent += in_count; 66251df0accSAmit Shah /* 66351df0accSAmit Shah * We're expected to return the amount of data we wrote -- all 66451df0accSAmit Shah * of it 66551df0accSAmit Shah */ 66651df0accSAmit Shah return in_count; 66751df0accSAmit Shah } 66851df0accSAmit Shah 66951df0accSAmit Shah /* 67051df0accSAmit Shah * Give out the data that's requested from the buffer that we have 67151df0accSAmit Shah * queued up. 67251df0accSAmit Shah */ 67348b36066SMichael S. Tsirkin static ssize_t fill_readbuf(struct port *port, char __user *out_buf, 67448b36066SMichael S. Tsirkin size_t out_count, bool to_user) 67551df0accSAmit Shah { 67651df0accSAmit Shah struct port_buffer *buf; 67751df0accSAmit Shah unsigned long flags; 67851df0accSAmit Shah 67951df0accSAmit Shah if (!out_count || !port_has_data(port)) 68051df0accSAmit Shah return 0; 68151df0accSAmit Shah 68251df0accSAmit Shah buf = port->inbuf; 68351df0accSAmit Shah out_count = min(out_count, buf->len - buf->offset); 68451df0accSAmit Shah 68551df0accSAmit Shah if (to_user) { 68651df0accSAmit Shah ssize_t ret; 68751df0accSAmit Shah 68851df0accSAmit Shah ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count); 68951df0accSAmit Shah if (ret) 69051df0accSAmit Shah return -EFAULT; 69151df0accSAmit Shah } else { 69248b36066SMichael S. Tsirkin memcpy((__force char *)out_buf, buf->buf + buf->offset, 69348b36066SMichael S. Tsirkin out_count); 69451df0accSAmit Shah } 69551df0accSAmit Shah 69651df0accSAmit Shah buf->offset += out_count; 69751df0accSAmit Shah 69851df0accSAmit Shah if (buf->offset == buf->len) { 69951df0accSAmit Shah /* 70051df0accSAmit Shah * We're done using all the data in this buffer. 70151df0accSAmit Shah * Re-queue so that the Host can send us more data. 70251df0accSAmit Shah */ 70351df0accSAmit Shah spin_lock_irqsave(&port->inbuf_lock, flags); 70451df0accSAmit Shah port->inbuf = NULL; 70551df0accSAmit Shah 70651df0accSAmit Shah if (add_inbuf(port->in_vq, buf) < 0) 70751df0accSAmit Shah dev_warn(port->dev, "failed add_buf\n"); 70851df0accSAmit Shah 70951df0accSAmit Shah spin_unlock_irqrestore(&port->inbuf_lock, flags); 71051df0accSAmit Shah } 71151df0accSAmit Shah /* Return the number of bytes actually copied */ 71251df0accSAmit Shah return out_count; 71351df0accSAmit Shah } 71451df0accSAmit Shah 71551df0accSAmit Shah /* The condition that must be true for polling to end */ 71651df0accSAmit Shah static bool will_read_block(struct port *port) 71751df0accSAmit Shah { 71851df0accSAmit Shah if (!port->guest_connected) { 71951df0accSAmit Shah /* Port got hot-unplugged. Let's exit. */ 72051df0accSAmit Shah return false; 72151df0accSAmit Shah } 72251df0accSAmit Shah return !port_has_data(port) && port->host_connected; 72351df0accSAmit Shah } 72451df0accSAmit Shah 72551df0accSAmit Shah static bool will_write_block(struct port *port) 72651df0accSAmit Shah { 72751df0accSAmit Shah bool ret; 72851df0accSAmit Shah 72951df0accSAmit Shah if (!port->guest_connected) { 73051df0accSAmit Shah /* Port got hot-unplugged. Let's exit. */ 73151df0accSAmit Shah return false; 73251df0accSAmit Shah } 73351df0accSAmit Shah if (!port->host_connected) 73451df0accSAmit Shah return true; 73551df0accSAmit Shah 73651df0accSAmit Shah spin_lock_irq(&port->outvq_lock); 73751df0accSAmit Shah /* 73851df0accSAmit Shah * Check if the Host has consumed any buffers since we last 73951df0accSAmit Shah * sent data (this is only applicable for nonblocking ports). 74051df0accSAmit Shah */ 74151df0accSAmit Shah reclaim_consumed_buffers(port); 74251df0accSAmit Shah ret = port->outvq_full; 74351df0accSAmit Shah spin_unlock_irq(&port->outvq_lock); 74451df0accSAmit Shah 74551df0accSAmit Shah return ret; 74651df0accSAmit Shah } 74751df0accSAmit Shah 74851df0accSAmit Shah static ssize_t port_fops_read(struct file *filp, char __user *ubuf, 74951df0accSAmit Shah size_t count, loff_t *offp) 75051df0accSAmit Shah { 75151df0accSAmit Shah struct port *port; 75251df0accSAmit Shah ssize_t ret; 75351df0accSAmit Shah 75451df0accSAmit Shah port = filp->private_data; 75551df0accSAmit Shah 75696f97a83SAmit Shah /* Port is hot-unplugged. */ 75796f97a83SAmit Shah if (!port->guest_connected) 75896f97a83SAmit Shah return -ENODEV; 75996f97a83SAmit Shah 76051df0accSAmit Shah if (!port_has_data(port)) { 76151df0accSAmit Shah /* 76251df0accSAmit Shah * If nothing's connected on the host just return 0 in 76351df0accSAmit Shah * case of list_empty; this tells the userspace app 76451df0accSAmit Shah * that there's no connection 76551df0accSAmit Shah */ 76651df0accSAmit Shah if (!port->host_connected) 76751df0accSAmit Shah return 0; 76851df0accSAmit Shah if (filp->f_flags & O_NONBLOCK) 76951df0accSAmit Shah return -EAGAIN; 77051df0accSAmit Shah 771a08fa92dSAmit Shah ret = wait_event_freezable(port->waitqueue, 77251df0accSAmit Shah !will_read_block(port)); 77351df0accSAmit Shah if (ret < 0) 77451df0accSAmit Shah return ret; 77551df0accSAmit Shah } 77696f97a83SAmit Shah /* Port got hot-unplugged while we were waiting above. */ 77751df0accSAmit Shah if (!port->guest_connected) 77851df0accSAmit Shah return -ENODEV; 77951df0accSAmit Shah /* 78051df0accSAmit Shah * We could've received a disconnection message while we were 78151df0accSAmit Shah * waiting for more data. 78251df0accSAmit Shah * 78351df0accSAmit Shah * This check is not clubbed in the if() statement above as we 78451df0accSAmit Shah * might receive some data as well as the host could get 78551df0accSAmit Shah * disconnected after we got woken up from our wait. So we 78651df0accSAmit Shah * really want to give off whatever data we have and only then 78751df0accSAmit Shah * check for host_connected. 78851df0accSAmit Shah */ 78951df0accSAmit Shah if (!port_has_data(port) && !port->host_connected) 79051df0accSAmit Shah return 0; 79151df0accSAmit Shah 79251df0accSAmit Shah return fill_readbuf(port, ubuf, count, true); 79351df0accSAmit Shah } 79451df0accSAmit Shah 795efe75d24SMasami Hiramatsu static int wait_port_writable(struct port *port, bool nonblock) 796efe75d24SMasami Hiramatsu { 797efe75d24SMasami Hiramatsu int ret; 798efe75d24SMasami Hiramatsu 799efe75d24SMasami Hiramatsu if (will_write_block(port)) { 800efe75d24SMasami Hiramatsu if (nonblock) 801efe75d24SMasami Hiramatsu return -EAGAIN; 802efe75d24SMasami Hiramatsu 803efe75d24SMasami Hiramatsu ret = wait_event_freezable(port->waitqueue, 804efe75d24SMasami Hiramatsu !will_write_block(port)); 805efe75d24SMasami Hiramatsu if (ret < 0) 806efe75d24SMasami Hiramatsu return ret; 807efe75d24SMasami Hiramatsu } 808efe75d24SMasami Hiramatsu /* Port got hot-unplugged. */ 809efe75d24SMasami Hiramatsu if (!port->guest_connected) 810efe75d24SMasami Hiramatsu return -ENODEV; 811efe75d24SMasami Hiramatsu 812efe75d24SMasami Hiramatsu return 0; 813efe75d24SMasami Hiramatsu } 814efe75d24SMasami Hiramatsu 81551df0accSAmit Shah static ssize_t port_fops_write(struct file *filp, const char __user *ubuf, 81651df0accSAmit Shah size_t count, loff_t *offp) 81751df0accSAmit Shah { 81851df0accSAmit Shah struct port *port; 819276a3e95SSjur Brændeland struct port_buffer *buf; 82051df0accSAmit Shah ssize_t ret; 82151df0accSAmit Shah bool nonblock; 822276a3e95SSjur Brændeland struct scatterlist sg[1]; 82351df0accSAmit Shah 82451df0accSAmit Shah /* Userspace could be out to fool us */ 82551df0accSAmit Shah if (!count) 82651df0accSAmit Shah return 0; 82751df0accSAmit Shah 82851df0accSAmit Shah port = filp->private_data; 82951df0accSAmit Shah 83051df0accSAmit Shah nonblock = filp->f_flags & O_NONBLOCK; 83151df0accSAmit Shah 832efe75d24SMasami Hiramatsu ret = wait_port_writable(port, nonblock); 83351df0accSAmit Shah if (ret < 0) 83451df0accSAmit Shah return ret; 83551df0accSAmit Shah 83651df0accSAmit Shah count = min((size_t)(32 * 1024), count); 83751df0accSAmit Shah 838276a3e95SSjur Brændeland buf = alloc_buf(port->out_vq, count, 0); 83951df0accSAmit Shah if (!buf) 84051df0accSAmit Shah return -ENOMEM; 84151df0accSAmit Shah 842276a3e95SSjur Brændeland ret = copy_from_user(buf->buf, ubuf, count); 84351df0accSAmit Shah if (ret) { 84451df0accSAmit Shah ret = -EFAULT; 84551df0accSAmit Shah goto free_buf; 84651df0accSAmit Shah } 84751df0accSAmit Shah 84851df0accSAmit Shah /* 84951df0accSAmit Shah * We now ask send_buf() to not spin for generic ports -- we 85051df0accSAmit Shah * can re-use the same code path that non-blocking file 85151df0accSAmit Shah * descriptors take for blocking file descriptors since the 85251df0accSAmit Shah * wait is already done and we're certain the write will go 85351df0accSAmit Shah * through to the host. 85451df0accSAmit Shah */ 85551df0accSAmit Shah nonblock = true; 856276a3e95SSjur Brændeland sg_init_one(sg, buf->buf, count); 857276a3e95SSjur Brændeland ret = __send_to_port(port, sg, 1, count, buf, nonblock); 85851df0accSAmit Shah 85951df0accSAmit Shah if (nonblock && ret > 0) 86051df0accSAmit Shah goto out; 86151df0accSAmit Shah 86251df0accSAmit Shah free_buf: 8631b637046SSjur Brændeland free_buf(buf, true); 86451df0accSAmit Shah out: 86551df0accSAmit Shah return ret; 86651df0accSAmit Shah } 86751df0accSAmit Shah 868eb5e89fcSMasami Hiramatsu struct sg_list { 869eb5e89fcSMasami Hiramatsu unsigned int n; 8708ca84a50SMasami Hiramatsu unsigned int size; 871eb5e89fcSMasami Hiramatsu size_t len; 872eb5e89fcSMasami Hiramatsu struct scatterlist *sg; 873eb5e89fcSMasami Hiramatsu }; 874eb5e89fcSMasami Hiramatsu 875eb5e89fcSMasami Hiramatsu static int pipe_to_sg(struct pipe_inode_info *pipe, struct pipe_buffer *buf, 876eb5e89fcSMasami Hiramatsu struct splice_desc *sd) 877eb5e89fcSMasami Hiramatsu { 878eb5e89fcSMasami Hiramatsu struct sg_list *sgl = sd->u.data; 879ec8fc870SMasami Hiramatsu unsigned int offset, len; 880eb5e89fcSMasami Hiramatsu 8818ca84a50SMasami Hiramatsu if (sgl->n == sgl->size) 882eb5e89fcSMasami Hiramatsu return 0; 883eb5e89fcSMasami Hiramatsu 884eb5e89fcSMasami Hiramatsu /* Try lock this page */ 885eb5e89fcSMasami Hiramatsu if (buf->ops->steal(pipe, buf) == 0) { 886eb5e89fcSMasami Hiramatsu /* Get reference and unlock page for moving */ 887eb5e89fcSMasami Hiramatsu get_page(buf->page); 888eb5e89fcSMasami Hiramatsu unlock_page(buf->page); 889eb5e89fcSMasami Hiramatsu 890eb5e89fcSMasami Hiramatsu len = min(buf->len, sd->len); 891eb5e89fcSMasami Hiramatsu sg_set_page(&(sgl->sg[sgl->n]), buf->page, len, buf->offset); 892ec8fc870SMasami Hiramatsu } else { 893ec8fc870SMasami Hiramatsu /* Failback to copying a page */ 894ec8fc870SMasami Hiramatsu struct page *page = alloc_page(GFP_KERNEL); 895c9efe511SAl Viro char *src; 896ec8fc870SMasami Hiramatsu 897ec8fc870SMasami Hiramatsu if (!page) 898ec8fc870SMasami Hiramatsu return -ENOMEM; 899ec8fc870SMasami Hiramatsu 900ec8fc870SMasami Hiramatsu offset = sd->pos & ~PAGE_MASK; 901ec8fc870SMasami Hiramatsu 902ec8fc870SMasami Hiramatsu len = sd->len; 903ec8fc870SMasami Hiramatsu if (len + offset > PAGE_SIZE) 904ec8fc870SMasami Hiramatsu len = PAGE_SIZE - offset; 905ec8fc870SMasami Hiramatsu 906fbb32750SAl Viro src = kmap_atomic(buf->page); 907c9efe511SAl Viro memcpy(page_address(page) + offset, src + buf->offset, len); 908fbb32750SAl Viro kunmap_atomic(src); 909ec8fc870SMasami Hiramatsu 910ec8fc870SMasami Hiramatsu sg_set_page(&(sgl->sg[sgl->n]), page, len, offset); 911ec8fc870SMasami Hiramatsu } 912eb5e89fcSMasami Hiramatsu sgl->n++; 913eb5e89fcSMasami Hiramatsu sgl->len += len; 914eb5e89fcSMasami Hiramatsu 915eb5e89fcSMasami Hiramatsu return len; 916eb5e89fcSMasami Hiramatsu } 917eb5e89fcSMasami Hiramatsu 918eb5e89fcSMasami Hiramatsu /* Faster zero-copy write by splicing */ 919eb5e89fcSMasami Hiramatsu static ssize_t port_fops_splice_write(struct pipe_inode_info *pipe, 920eb5e89fcSMasami Hiramatsu struct file *filp, loff_t *ppos, 921eb5e89fcSMasami Hiramatsu size_t len, unsigned int flags) 922eb5e89fcSMasami Hiramatsu { 923eb5e89fcSMasami Hiramatsu struct port *port = filp->private_data; 924eb5e89fcSMasami Hiramatsu struct sg_list sgl; 925eb5e89fcSMasami Hiramatsu ssize_t ret; 926276a3e95SSjur Brændeland struct port_buffer *buf; 927eb5e89fcSMasami Hiramatsu struct splice_desc sd = { 928eb5e89fcSMasami Hiramatsu .total_len = len, 929eb5e89fcSMasami Hiramatsu .flags = flags, 930eb5e89fcSMasami Hiramatsu .pos = *ppos, 931eb5e89fcSMasami Hiramatsu .u.data = &sgl, 932eb5e89fcSMasami Hiramatsu }; 933eb5e89fcSMasami Hiramatsu 9341b637046SSjur Brændeland /* 9351b637046SSjur Brændeland * Rproc_serial does not yet support splice. To support splice 9361b637046SSjur Brændeland * pipe_to_sg() must allocate dma-buffers and copy content from 9371b637046SSjur Brændeland * regular pages to dma pages. And alloc_buf and free_buf must 9381b637046SSjur Brændeland * support allocating and freeing such a list of dma-buffers. 9391b637046SSjur Brændeland */ 9401b637046SSjur Brændeland if (is_rproc_serial(port->out_vq->vdev)) 9411b637046SSjur Brændeland return -EINVAL; 9421b637046SSjur Brændeland 94368c034feSYoshihiro YUNOMAE /* 94468c034feSYoshihiro YUNOMAE * pipe->nrbufs == 0 means there are no data to transfer, 94568c034feSYoshihiro YUNOMAE * so this returns just 0 for no data. 94668c034feSYoshihiro YUNOMAE */ 9472b4fbf02SYoshihiro YUNOMAE pipe_lock(pipe); 9482b4fbf02SYoshihiro YUNOMAE if (!pipe->nrbufs) { 9492b4fbf02SYoshihiro YUNOMAE ret = 0; 9502b4fbf02SYoshihiro YUNOMAE goto error_out; 9512b4fbf02SYoshihiro YUNOMAE } 95268c034feSYoshihiro YUNOMAE 953efe75d24SMasami Hiramatsu ret = wait_port_writable(port, filp->f_flags & O_NONBLOCK); 954efe75d24SMasami Hiramatsu if (ret < 0) 9552b4fbf02SYoshihiro YUNOMAE goto error_out; 956efe75d24SMasami Hiramatsu 957276a3e95SSjur Brændeland buf = alloc_buf(port->out_vq, 0, pipe->nrbufs); 9582b4fbf02SYoshihiro YUNOMAE if (!buf) { 9592b4fbf02SYoshihiro YUNOMAE ret = -ENOMEM; 9602b4fbf02SYoshihiro YUNOMAE goto error_out; 9612b4fbf02SYoshihiro YUNOMAE } 962276a3e95SSjur Brændeland 963eb5e89fcSMasami Hiramatsu sgl.n = 0; 964eb5e89fcSMasami Hiramatsu sgl.len = 0; 9658ca84a50SMasami Hiramatsu sgl.size = pipe->nrbufs; 966276a3e95SSjur Brændeland sgl.sg = buf->sg; 9678ca84a50SMasami Hiramatsu sg_init_table(sgl.sg, sgl.size); 968eb5e89fcSMasami Hiramatsu ret = __splice_from_pipe(pipe, &sd, pipe_to_sg); 9692b4fbf02SYoshihiro YUNOMAE pipe_unlock(pipe); 970eb5e89fcSMasami Hiramatsu if (likely(ret > 0)) 971276a3e95SSjur Brændeland ret = __send_to_port(port, buf->sg, sgl.n, sgl.len, buf, true); 972eb5e89fcSMasami Hiramatsu 973fe529537SSjur Brændeland if (unlikely(ret <= 0)) 9741b637046SSjur Brændeland free_buf(buf, true); 975eb5e89fcSMasami Hiramatsu return ret; 9762b4fbf02SYoshihiro YUNOMAE 9772b4fbf02SYoshihiro YUNOMAE error_out: 9782b4fbf02SYoshihiro YUNOMAE pipe_unlock(pipe); 9792b4fbf02SYoshihiro YUNOMAE return ret; 980eb5e89fcSMasami Hiramatsu } 981eb5e89fcSMasami Hiramatsu 98251df0accSAmit Shah static unsigned int port_fops_poll(struct file *filp, poll_table *wait) 98351df0accSAmit Shah { 98451df0accSAmit Shah struct port *port; 98551df0accSAmit Shah unsigned int ret; 98651df0accSAmit Shah 98751df0accSAmit Shah port = filp->private_data; 98851df0accSAmit Shah poll_wait(filp, &port->waitqueue, wait); 98951df0accSAmit Shah 99051df0accSAmit Shah if (!port->guest_connected) { 99151df0accSAmit Shah /* Port got unplugged */ 99251df0accSAmit Shah return POLLHUP; 99351df0accSAmit Shah } 99451df0accSAmit Shah ret = 0; 99551df0accSAmit Shah if (!will_read_block(port)) 99651df0accSAmit Shah ret |= POLLIN | POLLRDNORM; 99751df0accSAmit Shah if (!will_write_block(port)) 99851df0accSAmit Shah ret |= POLLOUT; 99951df0accSAmit Shah if (!port->host_connected) 100051df0accSAmit Shah ret |= POLLHUP; 100151df0accSAmit Shah 100251df0accSAmit Shah return ret; 100351df0accSAmit Shah } 100451df0accSAmit Shah 100551df0accSAmit Shah static void remove_port(struct kref *kref); 100651df0accSAmit Shah 100751df0accSAmit Shah static int port_fops_release(struct inode *inode, struct file *filp) 100851df0accSAmit Shah { 100951df0accSAmit Shah struct port *port; 101051df0accSAmit Shah 101151df0accSAmit Shah port = filp->private_data; 101251df0accSAmit Shah 101351df0accSAmit Shah /* Notify host of port being closed */ 101451df0accSAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0); 101551df0accSAmit Shah 101651df0accSAmit Shah spin_lock_irq(&port->inbuf_lock); 101751df0accSAmit Shah port->guest_connected = false; 101851df0accSAmit Shah 101951df0accSAmit Shah discard_port_data(port); 102051df0accSAmit Shah 102151df0accSAmit Shah spin_unlock_irq(&port->inbuf_lock); 102251df0accSAmit Shah 102351df0accSAmit Shah spin_lock_irq(&port->outvq_lock); 102451df0accSAmit Shah reclaim_consumed_buffers(port); 102551df0accSAmit Shah spin_unlock_irq(&port->outvq_lock); 102651df0accSAmit Shah 10271b637046SSjur Brændeland reclaim_dma_bufs(); 102851df0accSAmit Shah /* 102951df0accSAmit Shah * Locks aren't necessary here as a port can't be opened after 103051df0accSAmit Shah * unplug, and if a port isn't unplugged, a kref would already 103151df0accSAmit Shah * exist for the port. Plus, taking ports_lock here would 103251df0accSAmit Shah * create a dependency on other locks taken by functions 103351df0accSAmit Shah * inside remove_port if we're the last holder of the port, 103451df0accSAmit Shah * creating many problems. 103551df0accSAmit Shah */ 103651df0accSAmit Shah kref_put(&port->kref, remove_port); 103751df0accSAmit Shah 103851df0accSAmit Shah return 0; 103951df0accSAmit Shah } 104051df0accSAmit Shah 104151df0accSAmit Shah static int port_fops_open(struct inode *inode, struct file *filp) 104251df0accSAmit Shah { 104351df0accSAmit Shah struct cdev *cdev = inode->i_cdev; 104451df0accSAmit Shah struct port *port; 104551df0accSAmit Shah int ret; 104651df0accSAmit Shah 1047057b82beSAmit Shah /* We get the port with a kref here */ 104851df0accSAmit Shah port = find_port_by_devt(cdev->dev); 1049671bdea2SAmit Shah if (!port) { 1050671bdea2SAmit Shah /* Port was unplugged before we could proceed */ 1051671bdea2SAmit Shah return -ENXIO; 1052671bdea2SAmit Shah } 105351df0accSAmit Shah filp->private_data = port; 105451df0accSAmit Shah 105551df0accSAmit Shah /* 105651df0accSAmit Shah * Don't allow opening of console port devices -- that's done 105751df0accSAmit Shah * via /dev/hvc 105851df0accSAmit Shah */ 105951df0accSAmit Shah if (is_console_port(port)) { 106051df0accSAmit Shah ret = -ENXIO; 106151df0accSAmit Shah goto out; 106251df0accSAmit Shah } 106351df0accSAmit Shah 106451df0accSAmit Shah /* Allow only one process to open a particular port at a time */ 106551df0accSAmit Shah spin_lock_irq(&port->inbuf_lock); 106651df0accSAmit Shah if (port->guest_connected) { 106751df0accSAmit Shah spin_unlock_irq(&port->inbuf_lock); 106874ff582cSAmit Shah ret = -EBUSY; 106951df0accSAmit Shah goto out; 107051df0accSAmit Shah } 107151df0accSAmit Shah 107251df0accSAmit Shah port->guest_connected = true; 107351df0accSAmit Shah spin_unlock_irq(&port->inbuf_lock); 107451df0accSAmit Shah 107551df0accSAmit Shah spin_lock_irq(&port->outvq_lock); 107651df0accSAmit Shah /* 107751df0accSAmit Shah * There might be a chance that we missed reclaiming a few 107851df0accSAmit Shah * buffers in the window of the port getting previously closed 107951df0accSAmit Shah * and opening now. 108051df0accSAmit Shah */ 108151df0accSAmit Shah reclaim_consumed_buffers(port); 108251df0accSAmit Shah spin_unlock_irq(&port->outvq_lock); 108351df0accSAmit Shah 108451df0accSAmit Shah nonseekable_open(inode, filp); 108551df0accSAmit Shah 108651df0accSAmit Shah /* Notify host of port being opened */ 108751df0accSAmit Shah send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1); 108851df0accSAmit Shah 108951df0accSAmit Shah return 0; 109051df0accSAmit Shah out: 109151df0accSAmit Shah kref_put(&port->kref, remove_port); 109251df0accSAmit Shah return ret; 109351df0accSAmit Shah } 109451df0accSAmit Shah 109551df0accSAmit Shah static int port_fops_fasync(int fd, struct file *filp, int mode) 109651df0accSAmit Shah { 109751df0accSAmit Shah struct port *port; 109851df0accSAmit Shah 109951df0accSAmit Shah port = filp->private_data; 110051df0accSAmit Shah return fasync_helper(fd, filp, mode, &port->async_queue); 110151df0accSAmit Shah } 110251df0accSAmit Shah 110351df0accSAmit Shah /* 110451df0accSAmit Shah * The file operations that we support: programs in the guest can open 110551df0accSAmit Shah * a console device, read from it, write to it, poll for data and 110651df0accSAmit Shah * close it. The devices are at 110751df0accSAmit Shah * /dev/vport<device number>p<port number> 110851df0accSAmit Shah */ 110951df0accSAmit Shah static const struct file_operations port_fops = { 111051df0accSAmit Shah .owner = THIS_MODULE, 111151df0accSAmit Shah .open = port_fops_open, 111251df0accSAmit Shah .read = port_fops_read, 111351df0accSAmit Shah .write = port_fops_write, 1114eb5e89fcSMasami Hiramatsu .splice_write = port_fops_splice_write, 111551df0accSAmit Shah .poll = port_fops_poll, 111651df0accSAmit Shah .release = port_fops_release, 111751df0accSAmit Shah .fasync = port_fops_fasync, 111851df0accSAmit Shah .llseek = no_llseek, 111951df0accSAmit Shah }; 112051df0accSAmit Shah 112151df0accSAmit Shah /* 112251df0accSAmit Shah * The put_chars() callback is pretty straightforward. 112351df0accSAmit Shah * 112451df0accSAmit Shah * We turn the characters into a scatter-gather list, add it to the 112551df0accSAmit Shah * output queue and then kick the Host. Then we sit here waiting for 112651df0accSAmit Shah * it to finish: inefficient in theory, but in practice 112751df0accSAmit Shah * implementations will do it immediately (lguest's Launcher does). 112851df0accSAmit Shah */ 112951df0accSAmit Shah static int put_chars(u32 vtermno, const char *buf, int count) 113051df0accSAmit Shah { 113151df0accSAmit Shah struct port *port; 1132276a3e95SSjur Brændeland struct scatterlist sg[1]; 113351df0accSAmit Shah 113451df0accSAmit Shah if (unlikely(early_put_chars)) 113551df0accSAmit Shah return early_put_chars(vtermno, buf, count); 113651df0accSAmit Shah 113751df0accSAmit Shah port = find_port_by_vtermno(vtermno); 113851df0accSAmit Shah if (!port) 113951df0accSAmit Shah return -EPIPE; 114051df0accSAmit Shah 1141276a3e95SSjur Brændeland sg_init_one(sg, buf, count); 1142276a3e95SSjur Brændeland return __send_to_port(port, sg, 1, count, (void *)buf, false); 114351df0accSAmit Shah } 114451df0accSAmit Shah 114551df0accSAmit Shah /* 114651df0accSAmit Shah * get_chars() is the callback from the hvc_console infrastructure 114751df0accSAmit Shah * when an interrupt is received. 114851df0accSAmit Shah * 114951df0accSAmit Shah * We call out to fill_readbuf that gets us the required data from the 115051df0accSAmit Shah * buffers that are queued up. 115151df0accSAmit Shah */ 115251df0accSAmit Shah static int get_chars(u32 vtermno, char *buf, int count) 115351df0accSAmit Shah { 115451df0accSAmit Shah struct port *port; 115551df0accSAmit Shah 115651df0accSAmit Shah /* If we've not set up the port yet, we have no input to give. */ 115751df0accSAmit Shah if (unlikely(early_put_chars)) 115851df0accSAmit Shah return 0; 115951df0accSAmit Shah 116051df0accSAmit Shah port = find_port_by_vtermno(vtermno); 116151df0accSAmit Shah if (!port) 116251df0accSAmit Shah return -EPIPE; 116351df0accSAmit Shah 116451df0accSAmit Shah /* If we don't have an input queue yet, we can't get input. */ 116551df0accSAmit Shah BUG_ON(!port->in_vq); 116651df0accSAmit Shah 116748b36066SMichael S. Tsirkin return fill_readbuf(port, (__force char __user *)buf, count, false); 116851df0accSAmit Shah } 116951df0accSAmit Shah 117051df0accSAmit Shah static void resize_console(struct port *port) 117151df0accSAmit Shah { 117251df0accSAmit Shah struct virtio_device *vdev; 117351df0accSAmit Shah 117451df0accSAmit Shah /* The port could have been hot-unplugged */ 117551df0accSAmit Shah if (!port || !is_console_port(port)) 117651df0accSAmit Shah return; 117751df0accSAmit Shah 117851df0accSAmit Shah vdev = port->portdev->vdev; 11791b637046SSjur Brændeland 11801b637046SSjur Brændeland /* Don't test F_SIZE at all if we're rproc: not a valid feature! */ 11811b637046SSjur Brændeland if (!is_rproc_serial(vdev) && 11821b637046SSjur Brændeland virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE)) 118351df0accSAmit Shah hvc_resize(port->cons.hvc, port->cons.ws); 118451df0accSAmit Shah } 118551df0accSAmit Shah 118651df0accSAmit Shah /* We set the configuration at this point, since we now have a tty */ 118751df0accSAmit Shah static int notifier_add_vio(struct hvc_struct *hp, int data) 118851df0accSAmit Shah { 118951df0accSAmit Shah struct port *port; 119051df0accSAmit Shah 119151df0accSAmit Shah port = find_port_by_vtermno(hp->vtermno); 119251df0accSAmit Shah if (!port) 119351df0accSAmit Shah return -EINVAL; 119451df0accSAmit Shah 119551df0accSAmit Shah hp->irq_requested = 1; 119651df0accSAmit Shah resize_console(port); 119751df0accSAmit Shah 119851df0accSAmit Shah return 0; 119951df0accSAmit Shah } 120051df0accSAmit Shah 120151df0accSAmit Shah static void notifier_del_vio(struct hvc_struct *hp, int data) 120251df0accSAmit Shah { 120351df0accSAmit Shah hp->irq_requested = 0; 120451df0accSAmit Shah } 120551df0accSAmit Shah 120651df0accSAmit Shah /* The operations for console ports. */ 120751df0accSAmit Shah static const struct hv_ops hv_ops = { 120851df0accSAmit Shah .get_chars = get_chars, 120951df0accSAmit Shah .put_chars = put_chars, 121051df0accSAmit Shah .notifier_add = notifier_add_vio, 121151df0accSAmit Shah .notifier_del = notifier_del_vio, 121251df0accSAmit Shah .notifier_hangup = notifier_del_vio, 121351df0accSAmit Shah }; 121451df0accSAmit Shah 121551df0accSAmit Shah /* 121651df0accSAmit Shah * Console drivers are initialized very early so boot messages can go 121751df0accSAmit Shah * out, so we do things slightly differently from the generic virtio 121851df0accSAmit Shah * initialization of the net and block drivers. 121951df0accSAmit Shah * 122051df0accSAmit Shah * At this stage, the console is output-only. It's too early to set 122151df0accSAmit Shah * up a virtqueue, so we let the drivers do some boutique early-output 122251df0accSAmit Shah * thing. 122351df0accSAmit Shah */ 122451df0accSAmit Shah int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int)) 122551df0accSAmit Shah { 122651df0accSAmit Shah early_put_chars = put_chars; 122751df0accSAmit Shah return hvc_instantiate(0, 0, &hv_ops); 122851df0accSAmit Shah } 122951df0accSAmit Shah 12303826835aSWei Yongjun static int init_port_console(struct port *port) 123151df0accSAmit Shah { 123251df0accSAmit Shah int ret; 123351df0accSAmit Shah 123451df0accSAmit Shah /* 123551df0accSAmit Shah * The Host's telling us this port is a console port. Hook it 123651df0accSAmit Shah * up with an hvc console. 123751df0accSAmit Shah * 123851df0accSAmit Shah * To set up and manage our virtual console, we call 123951df0accSAmit Shah * hvc_alloc(). 124051df0accSAmit Shah * 124151df0accSAmit Shah * The first argument of hvc_alloc() is the virtual console 124251df0accSAmit Shah * number. The second argument is the parameter for the 124351df0accSAmit Shah * notification mechanism (like irq number). We currently 124451df0accSAmit Shah * leave this as zero, virtqueues have implicit notifications. 124551df0accSAmit Shah * 124651df0accSAmit Shah * The third argument is a "struct hv_ops" containing the 124751df0accSAmit Shah * put_chars() get_chars(), notifier_add() and notifier_del() 124851df0accSAmit Shah * pointers. The final argument is the output buffer size: we 124951df0accSAmit Shah * can do any size, so we put PAGE_SIZE here. 125051df0accSAmit Shah */ 125151df0accSAmit Shah port->cons.vtermno = pdrvdata.next_vtermno; 125251df0accSAmit Shah 125351df0accSAmit Shah port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE); 125451df0accSAmit Shah if (IS_ERR(port->cons.hvc)) { 125551df0accSAmit Shah ret = PTR_ERR(port->cons.hvc); 125651df0accSAmit Shah dev_err(port->dev, 125751df0accSAmit Shah "error %d allocating hvc for port\n", ret); 125851df0accSAmit Shah port->cons.hvc = NULL; 125951df0accSAmit Shah return ret; 126051df0accSAmit Shah } 126151df0accSAmit Shah spin_lock_irq(&pdrvdata_lock); 126251df0accSAmit Shah pdrvdata.next_vtermno++; 126351df0accSAmit Shah list_add_tail(&port->cons.list, &pdrvdata.consoles); 126451df0accSAmit Shah spin_unlock_irq(&pdrvdata_lock); 126551df0accSAmit Shah port->guest_connected = true; 126651df0accSAmit Shah 126751df0accSAmit Shah /* 126851df0accSAmit Shah * Start using the new console output if this is the first 126951df0accSAmit Shah * console to come up. 127051df0accSAmit Shah */ 127151df0accSAmit Shah if (early_put_chars) 127251df0accSAmit Shah early_put_chars = NULL; 127351df0accSAmit Shah 127451df0accSAmit Shah /* Notify host of port being opened */ 127551df0accSAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1); 127651df0accSAmit Shah 127751df0accSAmit Shah return 0; 127851df0accSAmit Shah } 127951df0accSAmit Shah 128051df0accSAmit Shah static ssize_t show_port_name(struct device *dev, 128151df0accSAmit Shah struct device_attribute *attr, char *buffer) 128251df0accSAmit Shah { 128351df0accSAmit Shah struct port *port; 128451df0accSAmit Shah 128551df0accSAmit Shah port = dev_get_drvdata(dev); 128651df0accSAmit Shah 128751df0accSAmit Shah return sprintf(buffer, "%s\n", port->name); 128851df0accSAmit Shah } 128951df0accSAmit Shah 129051df0accSAmit Shah static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL); 129151df0accSAmit Shah 129251df0accSAmit Shah static struct attribute *port_sysfs_entries[] = { 129351df0accSAmit Shah &dev_attr_name.attr, 129451df0accSAmit Shah NULL 129551df0accSAmit Shah }; 129651df0accSAmit Shah 129751df0accSAmit Shah static struct attribute_group port_attribute_group = { 129851df0accSAmit Shah .name = NULL, /* put in device directory */ 129951df0accSAmit Shah .attrs = port_sysfs_entries, 130051df0accSAmit Shah }; 130151df0accSAmit Shah 130251df0accSAmit Shah static ssize_t debugfs_read(struct file *filp, char __user *ubuf, 130351df0accSAmit Shah size_t count, loff_t *offp) 130451df0accSAmit Shah { 130551df0accSAmit Shah struct port *port; 130651df0accSAmit Shah char *buf; 130751df0accSAmit Shah ssize_t ret, out_offset, out_count; 130851df0accSAmit Shah 130951df0accSAmit Shah out_count = 1024; 131051df0accSAmit Shah buf = kmalloc(out_count, GFP_KERNEL); 131151df0accSAmit Shah if (!buf) 131251df0accSAmit Shah return -ENOMEM; 131351df0accSAmit Shah 131451df0accSAmit Shah port = filp->private_data; 131551df0accSAmit Shah out_offset = 0; 131651df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count, 131751df0accSAmit Shah "name: %s\n", port->name ? port->name : ""); 131851df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 131951df0accSAmit Shah "guest_connected: %d\n", port->guest_connected); 132051df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 132151df0accSAmit Shah "host_connected: %d\n", port->host_connected); 132251df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 132351df0accSAmit Shah "outvq_full: %d\n", port->outvq_full); 132451df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 132517e5b4f2SAmit Shah "bytes_sent: %lu\n", port->stats.bytes_sent); 132617e5b4f2SAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 132717e5b4f2SAmit Shah "bytes_received: %lu\n", 132817e5b4f2SAmit Shah port->stats.bytes_received); 132917e5b4f2SAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 133017e5b4f2SAmit Shah "bytes_discarded: %lu\n", 133117e5b4f2SAmit Shah port->stats.bytes_discarded); 133217e5b4f2SAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 133351df0accSAmit Shah "is_console: %s\n", 133451df0accSAmit Shah is_console_port(port) ? "yes" : "no"); 133551df0accSAmit Shah out_offset += snprintf(buf + out_offset, out_count - out_offset, 133651df0accSAmit Shah "console_vtermno: %u\n", port->cons.vtermno); 133751df0accSAmit Shah 133851df0accSAmit Shah ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset); 133951df0accSAmit Shah kfree(buf); 134051df0accSAmit Shah return ret; 134151df0accSAmit Shah } 134251df0accSAmit Shah 134351df0accSAmit Shah static const struct file_operations port_debugfs_ops = { 134451df0accSAmit Shah .owner = THIS_MODULE, 1345234e3405SStephen Boyd .open = simple_open, 134651df0accSAmit Shah .read = debugfs_read, 134751df0accSAmit Shah }; 134851df0accSAmit Shah 134951df0accSAmit Shah static void set_console_size(struct port *port, u16 rows, u16 cols) 135051df0accSAmit Shah { 135151df0accSAmit Shah if (!port || !is_console_port(port)) 135251df0accSAmit Shah return; 135351df0accSAmit Shah 135451df0accSAmit Shah port->cons.ws.ws_row = rows; 135551df0accSAmit Shah port->cons.ws.ws_col = cols; 135651df0accSAmit Shah } 135751df0accSAmit Shah 135851df0accSAmit Shah static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock) 135951df0accSAmit Shah { 136051df0accSAmit Shah struct port_buffer *buf; 136151df0accSAmit Shah unsigned int nr_added_bufs; 136251df0accSAmit Shah int ret; 136351df0accSAmit Shah 136451df0accSAmit Shah nr_added_bufs = 0; 136551df0accSAmit Shah do { 1366276a3e95SSjur Brændeland buf = alloc_buf(vq, PAGE_SIZE, 0); 136751df0accSAmit Shah if (!buf) 136851df0accSAmit Shah break; 136951df0accSAmit Shah 137051df0accSAmit Shah spin_lock_irq(lock); 137151df0accSAmit Shah ret = add_inbuf(vq, buf); 137251df0accSAmit Shah if (ret < 0) { 137351df0accSAmit Shah spin_unlock_irq(lock); 13741b637046SSjur Brændeland free_buf(buf, true); 137551df0accSAmit Shah break; 137651df0accSAmit Shah } 137751df0accSAmit Shah nr_added_bufs++; 137851df0accSAmit Shah spin_unlock_irq(lock); 137951df0accSAmit Shah } while (ret > 0); 138051df0accSAmit Shah 138151df0accSAmit Shah return nr_added_bufs; 138251df0accSAmit Shah } 138351df0accSAmit Shah 138451df0accSAmit Shah static void send_sigio_to_port(struct port *port) 138551df0accSAmit Shah { 138651df0accSAmit Shah if (port->async_queue && port->guest_connected) 138751df0accSAmit Shah kill_fasync(&port->async_queue, SIGIO, POLL_OUT); 138851df0accSAmit Shah } 138951df0accSAmit Shah 139051df0accSAmit Shah static int add_port(struct ports_device *portdev, u32 id) 139151df0accSAmit Shah { 139251df0accSAmit Shah char debugfs_name[16]; 139351df0accSAmit Shah struct port *port; 139451df0accSAmit Shah struct port_buffer *buf; 139551df0accSAmit Shah dev_t devt; 139651df0accSAmit Shah unsigned int nr_added_bufs; 139751df0accSAmit Shah int err; 139851df0accSAmit Shah 139951df0accSAmit Shah port = kmalloc(sizeof(*port), GFP_KERNEL); 140051df0accSAmit Shah if (!port) { 140151df0accSAmit Shah err = -ENOMEM; 140251df0accSAmit Shah goto fail; 140351df0accSAmit Shah } 140451df0accSAmit Shah kref_init(&port->kref); 140551df0accSAmit Shah 140651df0accSAmit Shah port->portdev = portdev; 140751df0accSAmit Shah port->id = id; 140851df0accSAmit Shah 140951df0accSAmit Shah port->name = NULL; 141051df0accSAmit Shah port->inbuf = NULL; 141151df0accSAmit Shah port->cons.hvc = NULL; 141251df0accSAmit Shah port->async_queue = NULL; 141351df0accSAmit Shah 141451df0accSAmit Shah port->cons.ws.ws_row = port->cons.ws.ws_col = 0; 141551df0accSAmit Shah 141651df0accSAmit Shah port->host_connected = port->guest_connected = false; 141717e5b4f2SAmit Shah port->stats = (struct port_stats) { 0 }; 141851df0accSAmit Shah 141951df0accSAmit Shah port->outvq_full = false; 142051df0accSAmit Shah 142151df0accSAmit Shah port->in_vq = portdev->in_vqs[port->id]; 142251df0accSAmit Shah port->out_vq = portdev->out_vqs[port->id]; 142351df0accSAmit Shah 142451df0accSAmit Shah port->cdev = cdev_alloc(); 142551df0accSAmit Shah if (!port->cdev) { 142651df0accSAmit Shah dev_err(&port->portdev->vdev->dev, "Error allocating cdev\n"); 142751df0accSAmit Shah err = -ENOMEM; 142851df0accSAmit Shah goto free_port; 142951df0accSAmit Shah } 143051df0accSAmit Shah port->cdev->ops = &port_fops; 143151df0accSAmit Shah 143251df0accSAmit Shah devt = MKDEV(portdev->chr_major, id); 143351df0accSAmit Shah err = cdev_add(port->cdev, devt, 1); 143451df0accSAmit Shah if (err < 0) { 143551df0accSAmit Shah dev_err(&port->portdev->vdev->dev, 143651df0accSAmit Shah "Error %d adding cdev for port %u\n", err, id); 143751df0accSAmit Shah goto free_cdev; 143851df0accSAmit Shah } 143951df0accSAmit Shah port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev, 144051df0accSAmit Shah devt, port, "vport%up%u", 1441dc18f080SSjur Brændeland port->portdev->vdev->index, id); 144251df0accSAmit Shah if (IS_ERR(port->dev)) { 144351df0accSAmit Shah err = PTR_ERR(port->dev); 144451df0accSAmit Shah dev_err(&port->portdev->vdev->dev, 144551df0accSAmit Shah "Error %d creating device for port %u\n", 144651df0accSAmit Shah err, id); 144751df0accSAmit Shah goto free_cdev; 144851df0accSAmit Shah } 144951df0accSAmit Shah 145051df0accSAmit Shah spin_lock_init(&port->inbuf_lock); 145151df0accSAmit Shah spin_lock_init(&port->outvq_lock); 145251df0accSAmit Shah init_waitqueue_head(&port->waitqueue); 145351df0accSAmit Shah 145451df0accSAmit Shah /* Fill the in_vq with buffers so the host can send us data. */ 145551df0accSAmit Shah nr_added_bufs = fill_queue(port->in_vq, &port->inbuf_lock); 145651df0accSAmit Shah if (!nr_added_bufs) { 145751df0accSAmit Shah dev_err(port->dev, "Error allocating inbufs\n"); 145851df0accSAmit Shah err = -ENOMEM; 145951df0accSAmit Shah goto free_device; 146051df0accSAmit Shah } 146151df0accSAmit Shah 14621b637046SSjur Brændeland if (is_rproc_serial(port->portdev->vdev)) 146351df0accSAmit Shah /* 14641b637046SSjur Brændeland * For rproc_serial assume remote processor is connected. 14651b637046SSjur Brændeland * rproc_serial does not want the console port, only 14661b637046SSjur Brændeland * the generic port implementation. 146751df0accSAmit Shah */ 1468aabd6a8fSSjur Brændeland port->host_connected = true; 14691b637046SSjur Brændeland else if (!use_multiport(port->portdev)) { 14701b637046SSjur Brændeland /* 14711b637046SSjur Brændeland * If we're not using multiport support, 14721b637046SSjur Brændeland * this has to be a console port. 14731b637046SSjur Brændeland */ 147451df0accSAmit Shah err = init_port_console(port); 147551df0accSAmit Shah if (err) 147651df0accSAmit Shah goto free_inbufs; 147751df0accSAmit Shah } 147851df0accSAmit Shah 147951df0accSAmit Shah spin_lock_irq(&portdev->ports_lock); 148051df0accSAmit Shah list_add_tail(&port->list, &port->portdev->ports); 148151df0accSAmit Shah spin_unlock_irq(&portdev->ports_lock); 148251df0accSAmit Shah 148351df0accSAmit Shah /* 148451df0accSAmit Shah * Tell the Host we're set so that it can send us various 148551df0accSAmit Shah * configuration parameters for this port (eg, port name, 148651df0accSAmit Shah * caching, whether this is a console port, etc.) 148751df0accSAmit Shah */ 148851df0accSAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1); 148951df0accSAmit Shah 149051df0accSAmit Shah if (pdrvdata.debugfs_dir) { 149151df0accSAmit Shah /* 149251df0accSAmit Shah * Finally, create the debugfs file that we can use to 149351df0accSAmit Shah * inspect a port's state at any time 149451df0accSAmit Shah */ 149551df0accSAmit Shah sprintf(debugfs_name, "vport%up%u", 1496dc18f080SSjur Brændeland port->portdev->vdev->index, id); 149751df0accSAmit Shah port->debugfs_file = debugfs_create_file(debugfs_name, 0444, 149851df0accSAmit Shah pdrvdata.debugfs_dir, 149951df0accSAmit Shah port, 150051df0accSAmit Shah &port_debugfs_ops); 150151df0accSAmit Shah } 150251df0accSAmit Shah return 0; 150351df0accSAmit Shah 150451df0accSAmit Shah free_inbufs: 150551df0accSAmit Shah while ((buf = virtqueue_detach_unused_buf(port->in_vq))) 15061b637046SSjur Brændeland free_buf(buf, true); 150751df0accSAmit Shah free_device: 150851df0accSAmit Shah device_destroy(pdrvdata.class, port->dev->devt); 150951df0accSAmit Shah free_cdev: 151051df0accSAmit Shah cdev_del(port->cdev); 151151df0accSAmit Shah free_port: 151251df0accSAmit Shah kfree(port); 151351df0accSAmit Shah fail: 151451df0accSAmit Shah /* The host might want to notify management sw about port add failure */ 151551df0accSAmit Shah __send_control_msg(portdev, id, VIRTIO_CONSOLE_PORT_READY, 0); 151651df0accSAmit Shah return err; 151751df0accSAmit Shah } 151851df0accSAmit Shah 151951df0accSAmit Shah /* No users remain, remove all port-specific data. */ 152051df0accSAmit Shah static void remove_port(struct kref *kref) 152151df0accSAmit Shah { 152251df0accSAmit Shah struct port *port; 152351df0accSAmit Shah 152451df0accSAmit Shah port = container_of(kref, struct port, kref); 152551df0accSAmit Shah 152651df0accSAmit Shah kfree(port); 152751df0accSAmit Shah } 152851df0accSAmit Shah 1529a0e2dbfcSAmit Shah static void remove_port_data(struct port *port) 1530a0e2dbfcSAmit Shah { 1531a0e2dbfcSAmit Shah struct port_buffer *buf; 1532a0e2dbfcSAmit Shah 1533c6017e79SAmit Shah spin_lock_irq(&port->inbuf_lock); 1534a0e2dbfcSAmit Shah /* Remove unused data this port might have received. */ 1535a0e2dbfcSAmit Shah discard_port_data(port); 1536a0e2dbfcSAmit Shah 1537a0e2dbfcSAmit Shah /* Remove buffers we queued up for the Host to send us data in. */ 1538a0e2dbfcSAmit Shah while ((buf = virtqueue_detach_unused_buf(port->in_vq))) 15391b637046SSjur Brændeland free_buf(buf, true); 1540c6017e79SAmit Shah spin_unlock_irq(&port->inbuf_lock); 1541c6017e79SAmit Shah 1542c6017e79SAmit Shah spin_lock_irq(&port->outvq_lock); 1543c6017e79SAmit Shah reclaim_consumed_buffers(port); 1544eb34f12bSsjur.brandeland@stericsson.com 1545eb34f12bSsjur.brandeland@stericsson.com /* Free pending buffers from the out-queue. */ 1546eb34f12bSsjur.brandeland@stericsson.com while ((buf = virtqueue_detach_unused_buf(port->out_vq))) 15471b637046SSjur Brændeland free_buf(buf, true); 1548c6017e79SAmit Shah spin_unlock_irq(&port->outvq_lock); 1549a0e2dbfcSAmit Shah } 1550a0e2dbfcSAmit Shah 155151df0accSAmit Shah /* 155251df0accSAmit Shah * Port got unplugged. Remove port from portdev's list and drop the 155351df0accSAmit Shah * kref reference. If no userspace has this port opened, it will 155451df0accSAmit Shah * result in immediate removal the port. 155551df0accSAmit Shah */ 155651df0accSAmit Shah static void unplug_port(struct port *port) 155751df0accSAmit Shah { 155851df0accSAmit Shah spin_lock_irq(&port->portdev->ports_lock); 155951df0accSAmit Shah list_del(&port->list); 156051df0accSAmit Shah spin_unlock_irq(&port->portdev->ports_lock); 156151df0accSAmit Shah 15625549fb25SAmit Shah spin_lock_irq(&port->inbuf_lock); 156351df0accSAmit Shah if (port->guest_connected) { 156451df0accSAmit Shah /* Let the app know the port is going down. */ 156551df0accSAmit Shah send_sigio_to_port(port); 156692d34538SAmit Shah 156792d34538SAmit Shah /* Do this after sigio is actually sent */ 156892d34538SAmit Shah port->guest_connected = false; 156992d34538SAmit Shah port->host_connected = false; 157092d34538SAmit Shah 157192d34538SAmit Shah wake_up_interruptible(&port->waitqueue); 157251df0accSAmit Shah } 15735549fb25SAmit Shah spin_unlock_irq(&port->inbuf_lock); 157451df0accSAmit Shah 157551df0accSAmit Shah if (is_console_port(port)) { 157651df0accSAmit Shah spin_lock_irq(&pdrvdata_lock); 157751df0accSAmit Shah list_del(&port->cons.list); 157851df0accSAmit Shah spin_unlock_irq(&pdrvdata_lock); 157951df0accSAmit Shah hvc_remove(port->cons.hvc); 158051df0accSAmit Shah } 158151df0accSAmit Shah 1582a0e2dbfcSAmit Shah remove_port_data(port); 158351df0accSAmit Shah 158451df0accSAmit Shah /* 158551df0accSAmit Shah * We should just assume the device itself has gone off -- 158651df0accSAmit Shah * else a close on an open port later will try to send out a 158751df0accSAmit Shah * control message. 158851df0accSAmit Shah */ 158951df0accSAmit Shah port->portdev = NULL; 159051df0accSAmit Shah 1591ea3768b4SAmit Shah sysfs_remove_group(&port->dev->kobj, &port_attribute_group); 1592ea3768b4SAmit Shah device_destroy(pdrvdata.class, port->dev->devt); 1593ea3768b4SAmit Shah cdev_del(port->cdev); 1594ea3768b4SAmit Shah 1595ea3768b4SAmit Shah debugfs_remove(port->debugfs_file); 15963b868a40SAmit Shah kfree(port->name); 1597ea3768b4SAmit Shah 159851df0accSAmit Shah /* 159951df0accSAmit Shah * Locks around here are not necessary - a port can't be 160051df0accSAmit Shah * opened after we removed the port struct from ports_list 160151df0accSAmit Shah * above. 160251df0accSAmit Shah */ 160351df0accSAmit Shah kref_put(&port->kref, remove_port); 160451df0accSAmit Shah } 160551df0accSAmit Shah 160651df0accSAmit Shah /* Any private messages that the Host and Guest want to share */ 16071f0f9106SMichael S. Tsirkin static void handle_control_message(struct virtio_device *vdev, 16081f0f9106SMichael S. Tsirkin struct ports_device *portdev, 160951df0accSAmit Shah struct port_buffer *buf) 161051df0accSAmit Shah { 161151df0accSAmit Shah struct virtio_console_control *cpkt; 161251df0accSAmit Shah struct port *port; 161351df0accSAmit Shah size_t name_size; 161451df0accSAmit Shah int err; 161551df0accSAmit Shah 161651df0accSAmit Shah cpkt = (struct virtio_console_control *)(buf->buf + buf->offset); 161751df0accSAmit Shah 16181f0f9106SMichael S. Tsirkin port = find_port_by_id(portdev, virtio32_to_cpu(vdev, cpkt->id)); 16191f0f9106SMichael S. Tsirkin if (!port && 16201f0f9106SMichael S. Tsirkin cpkt->event != cpu_to_virtio16(vdev, VIRTIO_CONSOLE_PORT_ADD)) { 162151df0accSAmit Shah /* No valid header at start of buffer. Drop it. */ 162251df0accSAmit Shah dev_dbg(&portdev->vdev->dev, 162351df0accSAmit Shah "Invalid index %u in control packet\n", cpkt->id); 162451df0accSAmit Shah return; 162551df0accSAmit Shah } 162651df0accSAmit Shah 16271f0f9106SMichael S. Tsirkin switch (virtio16_to_cpu(vdev, cpkt->event)) { 162851df0accSAmit Shah case VIRTIO_CONSOLE_PORT_ADD: 162951df0accSAmit Shah if (port) { 163051df0accSAmit Shah dev_dbg(&portdev->vdev->dev, 163151df0accSAmit Shah "Port %u already added\n", port->id); 163251df0accSAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1); 163351df0accSAmit Shah break; 163451df0accSAmit Shah } 16351f0f9106SMichael S. Tsirkin if (virtio32_to_cpu(vdev, cpkt->id) >= 16361f0f9106SMichael S. Tsirkin portdev->config.max_nr_ports) { 163751df0accSAmit Shah dev_warn(&portdev->vdev->dev, 16381f0f9106SMichael S. Tsirkin "Request for adding port with " 16391f0f9106SMichael S. Tsirkin "out-of-bound id %u, max. supported id: %u\n", 164051df0accSAmit Shah cpkt->id, portdev->config.max_nr_ports - 1); 164151df0accSAmit Shah break; 164251df0accSAmit Shah } 16431f0f9106SMichael S. Tsirkin add_port(portdev, virtio32_to_cpu(vdev, cpkt->id)); 164451df0accSAmit Shah break; 164551df0accSAmit Shah case VIRTIO_CONSOLE_PORT_REMOVE: 164651df0accSAmit Shah unplug_port(port); 164751df0accSAmit Shah break; 164851df0accSAmit Shah case VIRTIO_CONSOLE_CONSOLE_PORT: 164951df0accSAmit Shah if (!cpkt->value) 165051df0accSAmit Shah break; 165151df0accSAmit Shah if (is_console_port(port)) 165251df0accSAmit Shah break; 165351df0accSAmit Shah 165451df0accSAmit Shah init_port_console(port); 16555e38483bSChristian Borntraeger complete(&early_console_added); 165651df0accSAmit Shah /* 165751df0accSAmit Shah * Could remove the port here in case init fails - but 165851df0accSAmit Shah * have to notify the host first. 165951df0accSAmit Shah */ 166051df0accSAmit Shah break; 166151df0accSAmit Shah case VIRTIO_CONSOLE_RESIZE: { 166251df0accSAmit Shah struct { 166351df0accSAmit Shah __u16 rows; 166451df0accSAmit Shah __u16 cols; 166551df0accSAmit Shah } size; 166651df0accSAmit Shah 166751df0accSAmit Shah if (!is_console_port(port)) 166851df0accSAmit Shah break; 166951df0accSAmit Shah 167051df0accSAmit Shah memcpy(&size, buf->buf + buf->offset + sizeof(*cpkt), 167151df0accSAmit Shah sizeof(size)); 167251df0accSAmit Shah set_console_size(port, size.rows, size.cols); 167351df0accSAmit Shah 167451df0accSAmit Shah port->cons.hvc->irq_requested = 1; 167551df0accSAmit Shah resize_console(port); 167651df0accSAmit Shah break; 167751df0accSAmit Shah } 167851df0accSAmit Shah case VIRTIO_CONSOLE_PORT_OPEN: 16791f0f9106SMichael S. Tsirkin port->host_connected = virtio16_to_cpu(vdev, cpkt->value); 168051df0accSAmit Shah wake_up_interruptible(&port->waitqueue); 168151df0accSAmit Shah /* 168251df0accSAmit Shah * If the host port got closed and the host had any 168351df0accSAmit Shah * unconsumed buffers, we'll be able to reclaim them 168451df0accSAmit Shah * now. 168551df0accSAmit Shah */ 168651df0accSAmit Shah spin_lock_irq(&port->outvq_lock); 168751df0accSAmit Shah reclaim_consumed_buffers(port); 168851df0accSAmit Shah spin_unlock_irq(&port->outvq_lock); 168951df0accSAmit Shah 169051df0accSAmit Shah /* 169151df0accSAmit Shah * If the guest is connected, it'll be interested in 169251df0accSAmit Shah * knowing the host connection state changed. 169351df0accSAmit Shah */ 1694314081f1SAmit Shah spin_lock_irq(&port->inbuf_lock); 169551df0accSAmit Shah send_sigio_to_port(port); 1696314081f1SAmit Shah spin_unlock_irq(&port->inbuf_lock); 169751df0accSAmit Shah break; 169851df0accSAmit Shah case VIRTIO_CONSOLE_PORT_NAME: 169951df0accSAmit Shah /* 1700291024efSAmit Shah * If we woke up after hibernation, we can get this 1701291024efSAmit Shah * again. Skip it in that case. 1702291024efSAmit Shah */ 1703291024efSAmit Shah if (port->name) 1704291024efSAmit Shah break; 1705291024efSAmit Shah 1706291024efSAmit Shah /* 170751df0accSAmit Shah * Skip the size of the header and the cpkt to get the size 170851df0accSAmit Shah * of the name that was sent 170951df0accSAmit Shah */ 171051df0accSAmit Shah name_size = buf->len - buf->offset - sizeof(*cpkt) + 1; 171151df0accSAmit Shah 171251df0accSAmit Shah port->name = kmalloc(name_size, GFP_KERNEL); 171351df0accSAmit Shah if (!port->name) { 171451df0accSAmit Shah dev_err(port->dev, 171551df0accSAmit Shah "Not enough space to store port name\n"); 171651df0accSAmit Shah break; 171751df0accSAmit Shah } 171851df0accSAmit Shah strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt), 171951df0accSAmit Shah name_size - 1); 172051df0accSAmit Shah port->name[name_size - 1] = 0; 172151df0accSAmit Shah 172251df0accSAmit Shah /* 172351df0accSAmit Shah * Since we only have one sysfs attribute, 'name', 172451df0accSAmit Shah * create it only if we have a name for the port. 172551df0accSAmit Shah */ 172651df0accSAmit Shah err = sysfs_create_group(&port->dev->kobj, 172751df0accSAmit Shah &port_attribute_group); 172851df0accSAmit Shah if (err) { 172951df0accSAmit Shah dev_err(port->dev, 173051df0accSAmit Shah "Error %d creating sysfs device attributes\n", 173151df0accSAmit Shah err); 173251df0accSAmit Shah } else { 173351df0accSAmit Shah /* 173451df0accSAmit Shah * Generate a udev event so that appropriate 173551df0accSAmit Shah * symlinks can be created based on udev 173651df0accSAmit Shah * rules. 173751df0accSAmit Shah */ 173851df0accSAmit Shah kobject_uevent(&port->dev->kobj, KOBJ_CHANGE); 173951df0accSAmit Shah } 174051df0accSAmit Shah break; 174151df0accSAmit Shah } 174251df0accSAmit Shah } 174351df0accSAmit Shah 174451df0accSAmit Shah static void control_work_handler(struct work_struct *work) 174551df0accSAmit Shah { 174651df0accSAmit Shah struct ports_device *portdev; 174751df0accSAmit Shah struct virtqueue *vq; 174851df0accSAmit Shah struct port_buffer *buf; 174951df0accSAmit Shah unsigned int len; 175051df0accSAmit Shah 175151df0accSAmit Shah portdev = container_of(work, struct ports_device, control_work); 175251df0accSAmit Shah vq = portdev->c_ivq; 175351df0accSAmit Shah 1754165b1b8bSAmit Shah spin_lock(&portdev->c_ivq_lock); 175551df0accSAmit Shah while ((buf = virtqueue_get_buf(vq, &len))) { 1756165b1b8bSAmit Shah spin_unlock(&portdev->c_ivq_lock); 175751df0accSAmit Shah 175851df0accSAmit Shah buf->len = len; 175951df0accSAmit Shah buf->offset = 0; 176051df0accSAmit Shah 17611f0f9106SMichael S. Tsirkin handle_control_message(vq->vdev, portdev, buf); 176251df0accSAmit Shah 1763165b1b8bSAmit Shah spin_lock(&portdev->c_ivq_lock); 176451df0accSAmit Shah if (add_inbuf(portdev->c_ivq, buf) < 0) { 176551df0accSAmit Shah dev_warn(&portdev->vdev->dev, 176651df0accSAmit Shah "Error adding buffer to queue\n"); 17671b637046SSjur Brændeland free_buf(buf, false); 176851df0accSAmit Shah } 176951df0accSAmit Shah } 1770165b1b8bSAmit Shah spin_unlock(&portdev->c_ivq_lock); 177151df0accSAmit Shah } 177251df0accSAmit Shah 1773ce86d35dSLinus Torvalds static void out_intr(struct virtqueue *vq) 1774ce86d35dSLinus Torvalds { 1775ce86d35dSLinus Torvalds struct port *port; 1776ce86d35dSLinus Torvalds 1777ce86d35dSLinus Torvalds port = find_port_by_vq(vq->vdev->priv, vq); 1778ce86d35dSLinus Torvalds if (!port) 1779ce86d35dSLinus Torvalds return; 1780ce86d35dSLinus Torvalds 1781ce86d35dSLinus Torvalds wake_up_interruptible(&port->waitqueue); 1782ce86d35dSLinus Torvalds } 1783ce86d35dSLinus Torvalds 178451df0accSAmit Shah static void in_intr(struct virtqueue *vq) 178551df0accSAmit Shah { 178651df0accSAmit Shah struct port *port; 178751df0accSAmit Shah unsigned long flags; 178851df0accSAmit Shah 178951df0accSAmit Shah port = find_port_by_vq(vq->vdev->priv, vq); 179051df0accSAmit Shah if (!port) 179151df0accSAmit Shah return; 179251df0accSAmit Shah 179351df0accSAmit Shah spin_lock_irqsave(&port->inbuf_lock, flags); 179451df0accSAmit Shah port->inbuf = get_inbuf(port); 179551df0accSAmit Shah 179651df0accSAmit Shah /* 1797aabd6a8fSSjur Brændeland * Normally the port should not accept data when the port is 1798aabd6a8fSSjur Brændeland * closed. For generic serial ports, the host won't (shouldn't) 1799aabd6a8fSSjur Brændeland * send data till the guest is connected. But this condition 180051df0accSAmit Shah * can be reached when a console port is not yet connected (no 1801aabd6a8fSSjur Brændeland * tty is spawned) and the other side sends out data over the 1802aabd6a8fSSjur Brændeland * vring, or when a remote devices start sending data before 1803aabd6a8fSSjur Brændeland * the ports are opened. 1804aabd6a8fSSjur Brændeland * 1805aabd6a8fSSjur Brændeland * A generic serial port will discard data if not connected, 1806aabd6a8fSSjur Brændeland * while console ports and rproc-serial ports accepts data at 1807aabd6a8fSSjur Brændeland * any time. rproc-serial is initiated with guest_connected to 1808aabd6a8fSSjur Brændeland * false because port_fops_open expects this. Console ports are 1809aabd6a8fSSjur Brændeland * hooked up with an HVC console and is initialized with 1810aabd6a8fSSjur Brændeland * guest_connected to true. 181151df0accSAmit Shah */ 1812aabd6a8fSSjur Brændeland 1813aabd6a8fSSjur Brændeland if (!port->guest_connected && !is_rproc_serial(port->portdev->vdev)) 181451df0accSAmit Shah discard_port_data(port); 181551df0accSAmit Shah 1816314081f1SAmit Shah /* Send a SIGIO indicating new data in case the process asked for it */ 1817314081f1SAmit Shah send_sigio_to_port(port); 1818314081f1SAmit Shah 181951df0accSAmit Shah spin_unlock_irqrestore(&port->inbuf_lock, flags); 182051df0accSAmit Shah 182151df0accSAmit Shah wake_up_interruptible(&port->waitqueue); 182251df0accSAmit Shah 182351df0accSAmit Shah if (is_console_port(port) && hvc_poll(port->cons.hvc)) 182451df0accSAmit Shah hvc_kick(); 182551df0accSAmit Shah } 182651df0accSAmit Shah 182751df0accSAmit Shah static void control_intr(struct virtqueue *vq) 182851df0accSAmit Shah { 182951df0accSAmit Shah struct ports_device *portdev; 183051df0accSAmit Shah 183151df0accSAmit Shah portdev = vq->vdev->priv; 183251df0accSAmit Shah schedule_work(&portdev->control_work); 183351df0accSAmit Shah } 183451df0accSAmit Shah 183551df0accSAmit Shah static void config_intr(struct virtio_device *vdev) 183651df0accSAmit Shah { 183751df0accSAmit Shah struct ports_device *portdev; 183851df0accSAmit Shah 183951df0accSAmit Shah portdev = vdev->priv; 184051df0accSAmit Shah 1841eeb8a7e8SMichael S. Tsirkin if (!use_multiport(portdev)) 1842eeb8a7e8SMichael S. Tsirkin schedule_work(&portdev->config_work); 1843eeb8a7e8SMichael S. Tsirkin } 1844eeb8a7e8SMichael S. Tsirkin 1845eeb8a7e8SMichael S. Tsirkin static void config_work_handler(struct work_struct *work) 1846eeb8a7e8SMichael S. Tsirkin { 1847eeb8a7e8SMichael S. Tsirkin struct ports_device *portdev; 1848eeb8a7e8SMichael S. Tsirkin 1849eeb8a7e8SMichael S. Tsirkin portdev = container_of(work, struct ports_device, control_work); 185051df0accSAmit Shah if (!use_multiport(portdev)) { 1851eeb8a7e8SMichael S. Tsirkin struct virtio_device *vdev; 185251df0accSAmit Shah struct port *port; 185351df0accSAmit Shah u16 rows, cols; 185451df0accSAmit Shah 1855eeb8a7e8SMichael S. Tsirkin vdev = portdev->vdev; 1856855e0c52SRusty Russell virtio_cread(vdev, struct virtio_console_config, cols, &cols); 1857855e0c52SRusty Russell virtio_cread(vdev, struct virtio_console_config, rows, &rows); 185851df0accSAmit Shah 185951df0accSAmit Shah port = find_port_by_id(portdev, 0); 186051df0accSAmit Shah set_console_size(port, rows, cols); 186151df0accSAmit Shah 186251df0accSAmit Shah /* 186351df0accSAmit Shah * We'll use this way of resizing only for legacy 186451df0accSAmit Shah * support. For newer userspace 186551df0accSAmit Shah * (VIRTIO_CONSOLE_F_MULTPORT+), use control messages 186651df0accSAmit Shah * to indicate console size changes so that it can be 186751df0accSAmit Shah * done per-port. 186851df0accSAmit Shah */ 186951df0accSAmit Shah resize_console(port); 187051df0accSAmit Shah } 187151df0accSAmit Shah } 187251df0accSAmit Shah 187351df0accSAmit Shah static int init_vqs(struct ports_device *portdev) 187451df0accSAmit Shah { 187551df0accSAmit Shah vq_callback_t **io_callbacks; 187651df0accSAmit Shah char **io_names; 187751df0accSAmit Shah struct virtqueue **vqs; 187851df0accSAmit Shah u32 i, j, nr_ports, nr_queues; 187951df0accSAmit Shah int err; 188051df0accSAmit Shah 188151df0accSAmit Shah nr_ports = portdev->config.max_nr_ports; 188251df0accSAmit Shah nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2; 188351df0accSAmit Shah 188451df0accSAmit Shah vqs = kmalloc(nr_queues * sizeof(struct virtqueue *), GFP_KERNEL); 188551df0accSAmit Shah io_callbacks = kmalloc(nr_queues * sizeof(vq_callback_t *), GFP_KERNEL); 188651df0accSAmit Shah io_names = kmalloc(nr_queues * sizeof(char *), GFP_KERNEL); 188751df0accSAmit Shah portdev->in_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *), 188851df0accSAmit Shah GFP_KERNEL); 188951df0accSAmit Shah portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *), 189051df0accSAmit Shah GFP_KERNEL); 189151df0accSAmit Shah if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs || 189251df0accSAmit Shah !portdev->out_vqs) { 189351df0accSAmit Shah err = -ENOMEM; 189451df0accSAmit Shah goto free; 189551df0accSAmit Shah } 189651df0accSAmit Shah 189751df0accSAmit Shah /* 189851df0accSAmit Shah * For backward compat (newer host but older guest), the host 189951df0accSAmit Shah * spawns a console port first and also inits the vqs for port 190051df0accSAmit Shah * 0 before others. 190151df0accSAmit Shah */ 190251df0accSAmit Shah j = 0; 190351df0accSAmit Shah io_callbacks[j] = in_intr; 1904ce86d35dSLinus Torvalds io_callbacks[j + 1] = out_intr; 190551df0accSAmit Shah io_names[j] = "input"; 190651df0accSAmit Shah io_names[j + 1] = "output"; 190751df0accSAmit Shah j += 2; 190851df0accSAmit Shah 190951df0accSAmit Shah if (use_multiport(portdev)) { 191051df0accSAmit Shah io_callbacks[j] = control_intr; 191151df0accSAmit Shah io_callbacks[j + 1] = NULL; 191251df0accSAmit Shah io_names[j] = "control-i"; 191351df0accSAmit Shah io_names[j + 1] = "control-o"; 191451df0accSAmit Shah 191551df0accSAmit Shah for (i = 1; i < nr_ports; i++) { 191651df0accSAmit Shah j += 2; 191751df0accSAmit Shah io_callbacks[j] = in_intr; 1918ce86d35dSLinus Torvalds io_callbacks[j + 1] = out_intr; 191951df0accSAmit Shah io_names[j] = "input"; 192051df0accSAmit Shah io_names[j + 1] = "output"; 192151df0accSAmit Shah } 192251df0accSAmit Shah } 192351df0accSAmit Shah /* Find the queues. */ 192451df0accSAmit Shah err = portdev->vdev->config->find_vqs(portdev->vdev, nr_queues, vqs, 192551df0accSAmit Shah io_callbacks, 192651df0accSAmit Shah (const char **)io_names); 192751df0accSAmit Shah if (err) 192851df0accSAmit Shah goto free; 192951df0accSAmit Shah 193051df0accSAmit Shah j = 0; 193151df0accSAmit Shah portdev->in_vqs[0] = vqs[0]; 193251df0accSAmit Shah portdev->out_vqs[0] = vqs[1]; 193351df0accSAmit Shah j += 2; 193451df0accSAmit Shah if (use_multiport(portdev)) { 193551df0accSAmit Shah portdev->c_ivq = vqs[j]; 193651df0accSAmit Shah portdev->c_ovq = vqs[j + 1]; 193751df0accSAmit Shah 193851df0accSAmit Shah for (i = 1; i < nr_ports; i++) { 193951df0accSAmit Shah j += 2; 194051df0accSAmit Shah portdev->in_vqs[i] = vqs[j]; 194151df0accSAmit Shah portdev->out_vqs[i] = vqs[j + 1]; 194251df0accSAmit Shah } 194351df0accSAmit Shah } 194451df0accSAmit Shah kfree(io_names); 194551df0accSAmit Shah kfree(io_callbacks); 194651df0accSAmit Shah kfree(vqs); 194751df0accSAmit Shah 194851df0accSAmit Shah return 0; 194951df0accSAmit Shah 195051df0accSAmit Shah free: 195151df0accSAmit Shah kfree(portdev->out_vqs); 195251df0accSAmit Shah kfree(portdev->in_vqs); 195351df0accSAmit Shah kfree(io_names); 195451df0accSAmit Shah kfree(io_callbacks); 195551df0accSAmit Shah kfree(vqs); 195651df0accSAmit Shah 195751df0accSAmit Shah return err; 195851df0accSAmit Shah } 195951df0accSAmit Shah 196051df0accSAmit Shah static const struct file_operations portdev_fops = { 196151df0accSAmit Shah .owner = THIS_MODULE, 196251df0accSAmit Shah }; 196351df0accSAmit Shah 1964a0e2dbfcSAmit Shah static void remove_vqs(struct ports_device *portdev) 1965a0e2dbfcSAmit Shah { 1966a0e2dbfcSAmit Shah portdev->vdev->config->del_vqs(portdev->vdev); 1967a0e2dbfcSAmit Shah kfree(portdev->in_vqs); 1968a0e2dbfcSAmit Shah kfree(portdev->out_vqs); 1969a0e2dbfcSAmit Shah } 1970a0e2dbfcSAmit Shah 1971a0e2dbfcSAmit Shah static void remove_controlq_data(struct ports_device *portdev) 1972a0e2dbfcSAmit Shah { 1973a0e2dbfcSAmit Shah struct port_buffer *buf; 1974a0e2dbfcSAmit Shah unsigned int len; 1975a0e2dbfcSAmit Shah 1976a0e2dbfcSAmit Shah if (!use_multiport(portdev)) 1977a0e2dbfcSAmit Shah return; 1978a0e2dbfcSAmit Shah 1979a0e2dbfcSAmit Shah while ((buf = virtqueue_get_buf(portdev->c_ivq, &len))) 19801b637046SSjur Brændeland free_buf(buf, true); 1981a0e2dbfcSAmit Shah 1982a0e2dbfcSAmit Shah while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq))) 19831b637046SSjur Brændeland free_buf(buf, true); 1984a0e2dbfcSAmit Shah } 1985a0e2dbfcSAmit Shah 198651df0accSAmit Shah /* 198751df0accSAmit Shah * Once we're further in boot, we get probed like any other virtio 198851df0accSAmit Shah * device. 198951df0accSAmit Shah * 199051df0accSAmit Shah * If the host also supports multiple console ports, we check the 199151df0accSAmit Shah * config space to see how many ports the host has spawned. We 199251df0accSAmit Shah * initialize each port found. 199351df0accSAmit Shah */ 19942223cbecSBill Pemberton static int virtcons_probe(struct virtio_device *vdev) 199551df0accSAmit Shah { 199651df0accSAmit Shah struct ports_device *portdev; 199751df0accSAmit Shah int err; 199851df0accSAmit Shah bool multiport; 19995e38483bSChristian Borntraeger bool early = early_put_chars != NULL; 20005e38483bSChristian Borntraeger 2001be8ff595SRusty Russell /* We only need a config space if features are offered */ 2002be8ff595SRusty Russell if (!vdev->config->get && 2003be8ff595SRusty Russell (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE) 2004be8ff595SRusty Russell || virtio_has_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT))) { 2005011f0e7aSMichael S. Tsirkin dev_err(&vdev->dev, "%s failure: config access disabled\n", 2006011f0e7aSMichael S. Tsirkin __func__); 2007011f0e7aSMichael S. Tsirkin return -EINVAL; 2008011f0e7aSMichael S. Tsirkin } 2009011f0e7aSMichael S. Tsirkin 20105e38483bSChristian Borntraeger /* Ensure to read early_put_chars now */ 20115e38483bSChristian Borntraeger barrier(); 201251df0accSAmit Shah 201351df0accSAmit Shah portdev = kmalloc(sizeof(*portdev), GFP_KERNEL); 201451df0accSAmit Shah if (!portdev) { 201551df0accSAmit Shah err = -ENOMEM; 201651df0accSAmit Shah goto fail; 201751df0accSAmit Shah } 201851df0accSAmit Shah 201951df0accSAmit Shah /* Attach this portdev to this virtio_device, and vice-versa. */ 202051df0accSAmit Shah portdev->vdev = vdev; 202151df0accSAmit Shah vdev->priv = portdev; 202251df0accSAmit Shah 202351df0accSAmit Shah portdev->chr_major = register_chrdev(0, "virtio-portsdev", 202451df0accSAmit Shah &portdev_fops); 202551df0accSAmit Shah if (portdev->chr_major < 0) { 202651df0accSAmit Shah dev_err(&vdev->dev, 202751df0accSAmit Shah "Error %d registering chrdev for device %u\n", 2028dc18f080SSjur Brændeland portdev->chr_major, vdev->index); 202951df0accSAmit Shah err = portdev->chr_major; 203051df0accSAmit Shah goto free; 203151df0accSAmit Shah } 203251df0accSAmit Shah 203351df0accSAmit Shah multiport = false; 203451df0accSAmit Shah portdev->config.max_nr_ports = 1; 20351b637046SSjur Brændeland 20361b637046SSjur Brændeland /* Don't test MULTIPORT at all if we're rproc: not a valid feature! */ 20371b637046SSjur Brændeland if (!is_rproc_serial(vdev) && 2038855e0c52SRusty Russell virtio_cread_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT, 2039855e0c52SRusty Russell struct virtio_console_config, max_nr_ports, 20401b637046SSjur Brændeland &portdev->config.max_nr_ports) == 0) { 204151c6d61aSSasha Levin multiport = true; 20421b637046SSjur Brændeland } 204351df0accSAmit Shah 204451df0accSAmit Shah err = init_vqs(portdev); 204551df0accSAmit Shah if (err < 0) { 204651df0accSAmit Shah dev_err(&vdev->dev, "Error %d initializing vqs\n", err); 204751df0accSAmit Shah goto free_chrdev; 204851df0accSAmit Shah } 204951df0accSAmit Shah 205051df0accSAmit Shah spin_lock_init(&portdev->ports_lock); 205151df0accSAmit Shah INIT_LIST_HEAD(&portdev->ports); 205251df0accSAmit Shah 205365eca3a2SCornelia Huck virtio_device_ready(portdev->vdev); 205465eca3a2SCornelia Huck 2055eeb8a7e8SMichael S. Tsirkin INIT_WORK(&portdev->config_work, &config_work_handler); 20564f6e24edSMichael S. Tsirkin INIT_WORK(&portdev->control_work, &control_work_handler); 20574f6e24edSMichael S. Tsirkin 205851df0accSAmit Shah if (multiport) { 205951df0accSAmit Shah unsigned int nr_added_bufs; 206051df0accSAmit Shah 2061165b1b8bSAmit Shah spin_lock_init(&portdev->c_ivq_lock); 20629ba5c80bSAmit Shah spin_lock_init(&portdev->c_ovq_lock); 206351df0accSAmit Shah 2064165b1b8bSAmit Shah nr_added_bufs = fill_queue(portdev->c_ivq, 2065165b1b8bSAmit Shah &portdev->c_ivq_lock); 206651df0accSAmit Shah if (!nr_added_bufs) { 206751df0accSAmit Shah dev_err(&vdev->dev, 206851df0accSAmit Shah "Error allocating buffers for control queue\n"); 206951df0accSAmit Shah err = -ENOMEM; 207051df0accSAmit Shah goto free_vqs; 207151df0accSAmit Shah } 207251df0accSAmit Shah } else { 207351df0accSAmit Shah /* 207451df0accSAmit Shah * For backward compatibility: Create a console port 207551df0accSAmit Shah * if we're running on older host. 207651df0accSAmit Shah */ 207751df0accSAmit Shah add_port(portdev, 0); 207851df0accSAmit Shah } 207951df0accSAmit Shah 208051df0accSAmit Shah spin_lock_irq(&pdrvdata_lock); 208151df0accSAmit Shah list_add_tail(&portdev->list, &pdrvdata.portdevs); 208251df0accSAmit Shah spin_unlock_irq(&pdrvdata_lock); 208351df0accSAmit Shah 208451df0accSAmit Shah __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID, 208551df0accSAmit Shah VIRTIO_CONSOLE_DEVICE_READY, 1); 20865e38483bSChristian Borntraeger 20875e38483bSChristian Borntraeger /* 20885e38483bSChristian Borntraeger * If there was an early virtio console, assume that there are no 20895e38483bSChristian Borntraeger * other consoles. We need to wait until the hvc_alloc matches the 20905e38483bSChristian Borntraeger * hvc_instantiate, otherwise tty_open will complain, resulting in 20915e38483bSChristian Borntraeger * a "Warning: unable to open an initial console" boot failure. 20925e38483bSChristian Borntraeger * Without multiport this is done in add_port above. With multiport 20935e38483bSChristian Borntraeger * this might take some host<->guest communication - thus we have to 20945e38483bSChristian Borntraeger * wait. 20955e38483bSChristian Borntraeger */ 20965e38483bSChristian Borntraeger if (multiport && early) 20975e38483bSChristian Borntraeger wait_for_completion(&early_console_added); 20985e38483bSChristian Borntraeger 209951df0accSAmit Shah return 0; 210051df0accSAmit Shah 210151df0accSAmit Shah free_vqs: 210251df0accSAmit Shah /* The host might want to notify mgmt sw about device add failure */ 210351df0accSAmit Shah __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID, 210451df0accSAmit Shah VIRTIO_CONSOLE_DEVICE_READY, 0); 2105a0e2dbfcSAmit Shah remove_vqs(portdev); 210651df0accSAmit Shah free_chrdev: 210751df0accSAmit Shah unregister_chrdev(portdev->chr_major, "virtio-portsdev"); 210851df0accSAmit Shah free: 210951df0accSAmit Shah kfree(portdev); 211051df0accSAmit Shah fail: 211151df0accSAmit Shah return err; 211251df0accSAmit Shah } 211351df0accSAmit Shah 211451df0accSAmit Shah static void virtcons_remove(struct virtio_device *vdev) 211551df0accSAmit Shah { 211651df0accSAmit Shah struct ports_device *portdev; 211751df0accSAmit Shah struct port *port, *port2; 211851df0accSAmit Shah 211951df0accSAmit Shah portdev = vdev->priv; 212051df0accSAmit Shah 212151df0accSAmit Shah spin_lock_irq(&pdrvdata_lock); 212251df0accSAmit Shah list_del(&portdev->list); 212351df0accSAmit Shah spin_unlock_irq(&pdrvdata_lock); 212451df0accSAmit Shah 212551df0accSAmit Shah /* Disable interrupts for vqs */ 212651df0accSAmit Shah vdev->config->reset(vdev); 212751df0accSAmit Shah /* Finish up work that's lined up */ 2128aded024aSSjur Brændeland if (use_multiport(portdev)) 212951df0accSAmit Shah cancel_work_sync(&portdev->control_work); 2130eeb8a7e8SMichael S. Tsirkin else 2131eeb8a7e8SMichael S. Tsirkin cancel_work_sync(&portdev->config_work); 213251df0accSAmit Shah 213351df0accSAmit Shah list_for_each_entry_safe(port, port2, &portdev->ports, list) 213451df0accSAmit Shah unplug_port(port); 213551df0accSAmit Shah 213651df0accSAmit Shah unregister_chrdev(portdev->chr_major, "virtio-portsdev"); 213751df0accSAmit Shah 213851df0accSAmit Shah /* 213951df0accSAmit Shah * When yanking out a device, we immediately lose the 214051df0accSAmit Shah * (device-side) queues. So there's no point in keeping the 214151df0accSAmit Shah * guest side around till we drop our final reference. This 214251df0accSAmit Shah * also means that any ports which are in an open state will 214351df0accSAmit Shah * have to just stop using the port, as the vqs are going 214451df0accSAmit Shah * away. 214551df0accSAmit Shah */ 2146a0e2dbfcSAmit Shah remove_controlq_data(portdev); 2147a0e2dbfcSAmit Shah remove_vqs(portdev); 214851df0accSAmit Shah kfree(portdev); 214951df0accSAmit Shah } 215051df0accSAmit Shah 215151df0accSAmit Shah static struct virtio_device_id id_table[] = { 215251df0accSAmit Shah { VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID }, 215351df0accSAmit Shah { 0 }, 215451df0accSAmit Shah }; 215551df0accSAmit Shah 215651df0accSAmit Shah static unsigned int features[] = { 215751df0accSAmit Shah VIRTIO_CONSOLE_F_SIZE, 215851df0accSAmit Shah VIRTIO_CONSOLE_F_MULTIPORT, 215951df0accSAmit Shah }; 216051df0accSAmit Shah 21611b637046SSjur Brændeland static struct virtio_device_id rproc_serial_id_table[] = { 21621b637046SSjur Brændeland #if IS_ENABLED(CONFIG_REMOTEPROC) 21631b637046SSjur Brændeland { VIRTIO_ID_RPROC_SERIAL, VIRTIO_DEV_ANY_ID }, 21641b637046SSjur Brændeland #endif 21651b637046SSjur Brændeland { 0 }, 21661b637046SSjur Brændeland }; 21671b637046SSjur Brændeland 21681b637046SSjur Brændeland static unsigned int rproc_serial_features[] = { 21691b637046SSjur Brændeland }; 21701b637046SSjur Brændeland 217189107000SAaron Lu #ifdef CONFIG_PM_SLEEP 21722b8f41d8SAmit Shah static int virtcons_freeze(struct virtio_device *vdev) 21732b8f41d8SAmit Shah { 21742b8f41d8SAmit Shah struct ports_device *portdev; 21752b8f41d8SAmit Shah struct port *port; 21762b8f41d8SAmit Shah 21772b8f41d8SAmit Shah portdev = vdev->priv; 21782b8f41d8SAmit Shah 21792b8f41d8SAmit Shah vdev->config->reset(vdev); 21802b8f41d8SAmit Shah 2181c743d09dSAmit Shah virtqueue_disable_cb(portdev->c_ivq); 21822b8f41d8SAmit Shah cancel_work_sync(&portdev->control_work); 2183eeb8a7e8SMichael S. Tsirkin cancel_work_sync(&portdev->config_work); 2184c743d09dSAmit Shah /* 2185c743d09dSAmit Shah * Once more: if control_work_handler() was running, it would 2186c743d09dSAmit Shah * enable the cb as the last step. 2187c743d09dSAmit Shah */ 2188c743d09dSAmit Shah virtqueue_disable_cb(portdev->c_ivq); 21892b8f41d8SAmit Shah remove_controlq_data(portdev); 21902b8f41d8SAmit Shah 21912b8f41d8SAmit Shah list_for_each_entry(port, &portdev->ports, list) { 2192c743d09dSAmit Shah virtqueue_disable_cb(port->in_vq); 2193c743d09dSAmit Shah virtqueue_disable_cb(port->out_vq); 21942b8f41d8SAmit Shah /* 21952b8f41d8SAmit Shah * We'll ask the host later if the new invocation has 21962b8f41d8SAmit Shah * the port opened or closed. 21972b8f41d8SAmit Shah */ 21982b8f41d8SAmit Shah port->host_connected = false; 21992b8f41d8SAmit Shah remove_port_data(port); 22002b8f41d8SAmit Shah } 22012b8f41d8SAmit Shah remove_vqs(portdev); 22022b8f41d8SAmit Shah 22032b8f41d8SAmit Shah return 0; 22042b8f41d8SAmit Shah } 22052b8f41d8SAmit Shah 22062b8f41d8SAmit Shah static int virtcons_restore(struct virtio_device *vdev) 22072b8f41d8SAmit Shah { 22082b8f41d8SAmit Shah struct ports_device *portdev; 22092b8f41d8SAmit Shah struct port *port; 22102b8f41d8SAmit Shah int ret; 22112b8f41d8SAmit Shah 22122b8f41d8SAmit Shah portdev = vdev->priv; 22132b8f41d8SAmit Shah 22142b8f41d8SAmit Shah ret = init_vqs(portdev); 22152b8f41d8SAmit Shah if (ret) 22162b8f41d8SAmit Shah return ret; 22172b8f41d8SAmit Shah 2218401bbdc9SMichael S. Tsirkin virtio_device_ready(portdev->vdev); 2219401bbdc9SMichael S. Tsirkin 22202b8f41d8SAmit Shah if (use_multiport(portdev)) 2221165b1b8bSAmit Shah fill_queue(portdev->c_ivq, &portdev->c_ivq_lock); 22222b8f41d8SAmit Shah 22232b8f41d8SAmit Shah list_for_each_entry(port, &portdev->ports, list) { 22242b8f41d8SAmit Shah port->in_vq = portdev->in_vqs[port->id]; 22252b8f41d8SAmit Shah port->out_vq = portdev->out_vqs[port->id]; 22262b8f41d8SAmit Shah 22272b8f41d8SAmit Shah fill_queue(port->in_vq, &port->inbuf_lock); 22282b8f41d8SAmit Shah 22292b8f41d8SAmit Shah /* Get port open/close status on the host */ 22302b8f41d8SAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1); 2231fa8b66ccSAmit Shah 2232fa8b66ccSAmit Shah /* 2233fa8b66ccSAmit Shah * If a port was open at the time of suspending, we 2234fa8b66ccSAmit Shah * have to let the host know that it's still open. 2235fa8b66ccSAmit Shah */ 2236fa8b66ccSAmit Shah if (port->guest_connected) 2237fa8b66ccSAmit Shah send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1); 22382b8f41d8SAmit Shah } 22392b8f41d8SAmit Shah return 0; 22402b8f41d8SAmit Shah } 22412b8f41d8SAmit Shah #endif 22422b8f41d8SAmit Shah 224351df0accSAmit Shah static struct virtio_driver virtio_console = { 224451df0accSAmit Shah .feature_table = features, 224551df0accSAmit Shah .feature_table_size = ARRAY_SIZE(features), 224651df0accSAmit Shah .driver.name = KBUILD_MODNAME, 224751df0accSAmit Shah .driver.owner = THIS_MODULE, 224851df0accSAmit Shah .id_table = id_table, 224951df0accSAmit Shah .probe = virtcons_probe, 225051df0accSAmit Shah .remove = virtcons_remove, 225151df0accSAmit Shah .config_changed = config_intr, 225289107000SAaron Lu #ifdef CONFIG_PM_SLEEP 22532b8f41d8SAmit Shah .freeze = virtcons_freeze, 22542b8f41d8SAmit Shah .restore = virtcons_restore, 22552b8f41d8SAmit Shah #endif 225651df0accSAmit Shah }; 225751df0accSAmit Shah 2258bcd2982aSGreg Kroah-Hartman static struct virtio_driver virtio_rproc_serial = { 22591b637046SSjur Brændeland .feature_table = rproc_serial_features, 22601b637046SSjur Brændeland .feature_table_size = ARRAY_SIZE(rproc_serial_features), 22611b637046SSjur Brændeland .driver.name = "virtio_rproc_serial", 22621b637046SSjur Brændeland .driver.owner = THIS_MODULE, 22631b637046SSjur Brændeland .id_table = rproc_serial_id_table, 22641b637046SSjur Brændeland .probe = virtcons_probe, 22651b637046SSjur Brændeland .remove = virtcons_remove, 22661b637046SSjur Brændeland }; 22671b637046SSjur Brændeland 226851df0accSAmit Shah static int __init init(void) 226951df0accSAmit Shah { 227051df0accSAmit Shah int err; 227151df0accSAmit Shah 227251df0accSAmit Shah pdrvdata.class = class_create(THIS_MODULE, "virtio-ports"); 227351df0accSAmit Shah if (IS_ERR(pdrvdata.class)) { 227451df0accSAmit Shah err = PTR_ERR(pdrvdata.class); 227551df0accSAmit Shah pr_err("Error %d creating virtio-ports class\n", err); 227651df0accSAmit Shah return err; 227751df0accSAmit Shah } 227851df0accSAmit Shah 227951df0accSAmit Shah pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL); 22803f0d0c9bSDan Carpenter if (!pdrvdata.debugfs_dir) 22813f0d0c9bSDan Carpenter pr_warning("Error creating debugfs dir for virtio-ports\n"); 228251df0accSAmit Shah INIT_LIST_HEAD(&pdrvdata.consoles); 228351df0accSAmit Shah INIT_LIST_HEAD(&pdrvdata.portdevs); 228451df0accSAmit Shah 228533e1afc3SAlexey Khoroshilov err = register_virtio_driver(&virtio_console); 228633e1afc3SAlexey Khoroshilov if (err < 0) { 228733e1afc3SAlexey Khoroshilov pr_err("Error %d registering virtio driver\n", err); 228833e1afc3SAlexey Khoroshilov goto free; 228933e1afc3SAlexey Khoroshilov } 22901b637046SSjur Brændeland err = register_virtio_driver(&virtio_rproc_serial); 22911b637046SSjur Brændeland if (err < 0) { 22921b637046SSjur Brændeland pr_err("Error %d registering virtio rproc serial driver\n", 22931b637046SSjur Brændeland err); 22941b637046SSjur Brændeland goto unregister; 22951b637046SSjur Brændeland } 229633e1afc3SAlexey Khoroshilov return 0; 22971b637046SSjur Brændeland unregister: 22981b637046SSjur Brændeland unregister_virtio_driver(&virtio_console); 229933e1afc3SAlexey Khoroshilov free: 230033e1afc3SAlexey Khoroshilov debugfs_remove_recursive(pdrvdata.debugfs_dir); 230133e1afc3SAlexey Khoroshilov class_destroy(pdrvdata.class); 230233e1afc3SAlexey Khoroshilov return err; 230351df0accSAmit Shah } 230451df0accSAmit Shah 230551df0accSAmit Shah static void __exit fini(void) 230651df0accSAmit Shah { 23071b637046SSjur Brændeland reclaim_dma_bufs(); 23081b637046SSjur Brændeland 230951df0accSAmit Shah unregister_virtio_driver(&virtio_console); 23101b637046SSjur Brændeland unregister_virtio_driver(&virtio_rproc_serial); 231151df0accSAmit Shah 231251df0accSAmit Shah class_destroy(pdrvdata.class); 231351df0accSAmit Shah debugfs_remove_recursive(pdrvdata.debugfs_dir); 231451df0accSAmit Shah } 231551df0accSAmit Shah module_init(init); 231651df0accSAmit Shah module_exit(fini); 231751df0accSAmit Shah 231851df0accSAmit Shah MODULE_DEVICE_TABLE(virtio, id_table); 231951df0accSAmit Shah MODULE_DESCRIPTION("Virtio console driver"); 232051df0accSAmit Shah MODULE_LICENSE("GPL"); 2321