2 * Copyright (C) 2006, 2007, 2009 Rusty Russell, IBM Corporation
3 * Copyright (C) 2009, 2010, 2011 Red Hat, Inc.
4 * Copyright (C) 2009, 2010, 2011 Amit Shah <amit.shah@redhat.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 #include <linux/cdev.h>
21 #include <linux/debugfs.h>
22 #include <linux/completion.h>
23 #include <linux/device.h>
24 #include <linux/err.h>
25 #include <linux/freezer.h>
27 #include <linux/splice.h>
28 #include <linux/pagemap.h>
29 #include <linux/init.h>
30 #include <linux/list.h>
31 #include <linux/poll.h>
32 #include <linux/sched.h>
33 #include <linux/slab.h>
34 #include <linux/spinlock.h>
35 #include <linux/virtio.h>
36 #include <linux/virtio_console.h>
37 #include <linux/wait.h>
38 #include <linux/workqueue.h>
39 #include <linux/module.h>
40 #include <linux/dma-mapping.h>
41 #include <linux/kconfig.h>
42 #include "../tty/hvc/hvc_console.h"
44 #define is_rproc_enabled IS_ENABLED(CONFIG_REMOTEPROC)
47 * This is a global struct for storing common data for all the devices
48 * this driver handles.
50 * Mainly, it has a linked list for all the consoles in one place so
51 * that callbacks from hvc for get_chars(), put_chars() work properly
52 * across multiple devices and multiple ports per device.
54 struct ports_driver_data
{
55 /* Used for registering chardevs */
58 /* Used for exporting per-port information to debugfs */
59 struct dentry
*debugfs_dir
;
61 /* List of all the devices we're handling */
62 struct list_head portdevs
;
65 * This is used to keep track of the number of hvc consoles
66 * spawned by this driver. This number is given as the first
67 * argument to hvc_alloc(). To correctly map an initial
68 * console spawned via hvc_instantiate to the console being
69 * hooked up via hvc_alloc, we need to pass the same vtermno.
71 * We also just assume the first console being initialised was
72 * the first one that got used as the initial console.
74 unsigned int next_vtermno
;
76 /* All the console devices handled by this driver */
77 struct list_head consoles
;
79 static struct ports_driver_data pdrvdata
;
81 static DEFINE_SPINLOCK(pdrvdata_lock
);
82 static DECLARE_COMPLETION(early_console_added
);
84 /* This struct holds information that's relevant only for console ports */
86 /* We'll place all consoles in a list in the pdrvdata struct */
87 struct list_head list
;
89 /* The hvc device associated with this console port */
90 struct hvc_struct
*hvc
;
92 /* The size of the console */
96 * This number identifies the number that we used to register
97 * with hvc in hvc_instantiate() and hvc_alloc(); this is the
98 * number passed on by the hvc callbacks to us to
99 * differentiate between the other console ports handled by
108 /* size of the buffer in *buf above */
111 /* used length of the buffer */
113 /* offset in the buf from which to consume data */
116 /* DMA address of buffer */
119 /* Device we got DMA memory from */
122 /* List of pending dma buffers to free */
123 struct list_head list
;
125 /* If sgpages == 0 then buf is used */
126 unsigned int sgpages
;
128 /* sg is used if spages > 0. sg must be the last in is struct */
129 struct scatterlist sg
[0];
133 * This is a per-device struct that stores data common to all the
134 * ports for that device (vdev->priv).
136 struct ports_device
{
137 /* Next portdev in the list, head is in the pdrvdata struct */
138 struct list_head list
;
141 * Workqueue handlers where we process deferred work after
144 struct work_struct control_work
;
146 struct list_head ports
;
148 /* To protect the list of ports */
149 spinlock_t ports_lock
;
151 /* To protect the vq operations for the control channel */
152 spinlock_t c_ivq_lock
;
153 spinlock_t c_ovq_lock
;
155 /* The current config space is stored here */
156 struct virtio_console_config config
;
158 /* The virtio device we're associated with */
159 struct virtio_device
*vdev
;
162 * A couple of virtqueues for the control channel: one for
163 * guest->host transfers, one for host->guest transfers
165 struct virtqueue
*c_ivq
, *c_ovq
;
167 /* Array of per-port IO virtqueues */
168 struct virtqueue
**in_vqs
, **out_vqs
;
170 /* Major number for this device. Ports will be created as minors. */
175 unsigned long bytes_sent
, bytes_received
, bytes_discarded
;
178 /* This struct holds the per-port data */
180 /* Next port in the list, head is in the ports_device */
181 struct list_head list
;
183 /* Pointer to the parent virtio_console device */
184 struct ports_device
*portdev
;
186 /* The current buffer from which data has to be fed to readers */
187 struct port_buffer
*inbuf
;
190 * To protect the operations on the in_vq associated with this
191 * port. Has to be a spinlock because it can be called from
192 * interrupt context (get_char()).
194 spinlock_t inbuf_lock
;
196 /* Protect the operations on the out_vq. */
197 spinlock_t outvq_lock
;
199 /* The IO vqs for this port */
200 struct virtqueue
*in_vq
, *out_vq
;
202 /* File in the debugfs directory that exposes this port's information */
203 struct dentry
*debugfs_file
;
206 * Keep count of the bytes sent, received and discarded for
207 * this port for accounting and debugging purposes. These
208 * counts are not reset across port open / close events.
210 struct port_stats stats
;
213 * The entries in this struct will be valid if this port is
214 * hooked up to an hvc console
218 /* Each port associates with a separate char device */
222 /* Reference-counting to handle port hot-unplugs and file operations */
225 /* A waitqueue for poll() or blocking read operations */
226 wait_queue_head_t waitqueue
;
228 /* The 'name' of the port that we expose via sysfs properties */
231 /* We can notify apps of host connect / disconnect events via SIGIO */
232 struct fasync_struct
*async_queue
;
234 /* The 'id' to identify the port with the Host */
239 /* Is the host device open */
242 /* We should allow only one process to open a port */
243 bool guest_connected
;
246 /* This is the very early arch-specified put chars function. */
247 static int (*early_put_chars
)(u32
, const char *, int);
249 static struct port
*find_port_by_vtermno(u32 vtermno
)
252 struct console
*cons
;
255 spin_lock_irqsave(&pdrvdata_lock
, flags
);
256 list_for_each_entry(cons
, &pdrvdata
.consoles
, list
) {
257 if (cons
->vtermno
== vtermno
) {
258 port
= container_of(cons
, struct port
, cons
);
264 spin_unlock_irqrestore(&pdrvdata_lock
, flags
);
268 static struct port
*find_port_by_devt_in_portdev(struct ports_device
*portdev
,
274 spin_lock_irqsave(&portdev
->ports_lock
, flags
);
275 list_for_each_entry(port
, &portdev
->ports
, list
) {
276 if (port
->cdev
->dev
== dev
) {
277 kref_get(&port
->kref
);
283 spin_unlock_irqrestore(&portdev
->ports_lock
, flags
);
288 static struct port
*find_port_by_devt(dev_t dev
)
290 struct ports_device
*portdev
;
294 spin_lock_irqsave(&pdrvdata_lock
, flags
);
295 list_for_each_entry(portdev
, &pdrvdata
.portdevs
, list
) {
296 port
= find_port_by_devt_in_portdev(portdev
, dev
);
302 spin_unlock_irqrestore(&pdrvdata_lock
, flags
);
306 static struct port
*find_port_by_id(struct ports_device
*portdev
, u32 id
)
311 spin_lock_irqsave(&portdev
->ports_lock
, flags
);
312 list_for_each_entry(port
, &portdev
->ports
, list
)
317 spin_unlock_irqrestore(&portdev
->ports_lock
, flags
);
322 static struct port
*find_port_by_vq(struct ports_device
*portdev
,
323 struct virtqueue
*vq
)
328 spin_lock_irqsave(&portdev
->ports_lock
, flags
);
329 list_for_each_entry(port
, &portdev
->ports
, list
)
330 if (port
->in_vq
== vq
|| port
->out_vq
== vq
)
334 spin_unlock_irqrestore(&portdev
->ports_lock
, flags
);
338 static bool is_console_port(struct port
*port
)
345 static bool is_rproc_serial(const struct virtio_device
*vdev
)
347 return is_rproc_enabled
&& vdev
->id
.device
== VIRTIO_ID_RPROC_SERIAL
;
350 static inline bool use_multiport(struct ports_device
*portdev
)
353 * This condition can be true when put_chars is called from
358 return portdev
->vdev
->features
[0] & (1 << VIRTIO_CONSOLE_F_MULTIPORT
);
361 static DEFINE_SPINLOCK(dma_bufs_lock
);
362 static LIST_HEAD(pending_free_dma_bufs
);
364 static void free_buf(struct port_buffer
*buf
, bool can_sleep
)
368 for (i
= 0; i
< buf
->sgpages
; i
++) {
369 struct page
*page
= sg_page(&buf
->sg
[i
]);
377 } else if (is_rproc_enabled
) {
380 /* dma_free_coherent requires interrupts to be enabled. */
382 /* queue up dma-buffers to be freed later */
383 spin_lock_irqsave(&dma_bufs_lock
, flags
);
384 list_add_tail(&buf
->list
, &pending_free_dma_bufs
);
385 spin_unlock_irqrestore(&dma_bufs_lock
, flags
);
388 dma_free_coherent(buf
->dev
, buf
->size
, buf
->buf
, buf
->dma
);
390 /* Release device refcnt and allow it to be freed */
391 put_device(buf
->dev
);
397 static void reclaim_dma_bufs(void)
400 struct port_buffer
*buf
, *tmp
;
403 if (list_empty(&pending_free_dma_bufs
))
406 /* Create a copy of the pending_free_dma_bufs while holding the lock */
407 spin_lock_irqsave(&dma_bufs_lock
, flags
);
408 list_cut_position(&tmp_list
, &pending_free_dma_bufs
,
409 pending_free_dma_bufs
.prev
);
410 spin_unlock_irqrestore(&dma_bufs_lock
, flags
);
412 /* Release the dma buffers, without irqs enabled */
413 list_for_each_entry_safe(buf
, tmp
, &tmp_list
, list
) {
414 list_del(&buf
->list
);
419 static struct port_buffer
*alloc_buf(struct virtqueue
*vq
, size_t buf_size
,
422 struct port_buffer
*buf
;
427 * Allocate buffer and the sg list. The sg list array is allocated
428 * directly after the port_buffer struct.
430 buf
= kmalloc(sizeof(*buf
) + sizeof(struct scatterlist
) * pages
,
435 buf
->sgpages
= pages
;
442 if (is_rproc_serial(vq
->vdev
)) {
444 * Allocate DMA memory from ancestor. When a virtio
445 * device is created by remoteproc, the DMA memory is
446 * associated with the grandparent device:
447 * vdev => rproc => platform-dev.
448 * The code here would have been less quirky if
449 * DMA_MEMORY_INCLUDES_CHILDREN had been supported
452 if (!vq
->vdev
->dev
.parent
|| !vq
->vdev
->dev
.parent
->parent
)
454 buf
->dev
= vq
->vdev
->dev
.parent
->parent
;
456 /* Increase device refcnt to avoid freeing it */
457 get_device(buf
->dev
);
458 buf
->buf
= dma_alloc_coherent(buf
->dev
, buf_size
, &buf
->dma
,
462 buf
->buf
= kmalloc(buf_size
, GFP_KERNEL
);
469 buf
->size
= buf_size
;
478 /* Callers should take appropriate locks */
479 static struct port_buffer
*get_inbuf(struct port
*port
)
481 struct port_buffer
*buf
;
487 buf
= virtqueue_get_buf(port
->in_vq
, &len
);
491 port
->stats
.bytes_received
+= len
;
497 * Create a scatter-gather list representing our input buffer and put
500 * Callers should take appropriate locks.
502 static int add_inbuf(struct virtqueue
*vq
, struct port_buffer
*buf
)
504 struct scatterlist sg
[1];
507 sg_init_one(sg
, buf
->buf
, buf
->size
);
509 ret
= virtqueue_add_inbuf(vq
, sg
, 1, buf
, GFP_ATOMIC
);
516 /* Discard any unread data this port has. Callers lockers. */
517 static void discard_port_data(struct port
*port
)
519 struct port_buffer
*buf
;
522 if (!port
->portdev
) {
523 /* Device has been unplugged. vqs are already gone. */
526 buf
= get_inbuf(port
);
530 port
->stats
.bytes_discarded
+= buf
->len
- buf
->offset
;
531 if (add_inbuf(port
->in_vq
, buf
) < 0) {
533 free_buf(buf
, false);
536 buf
= get_inbuf(port
);
539 dev_warn(port
->dev
, "Errors adding %d buffers back to vq\n",
543 static bool port_has_data(struct port
*port
)
549 spin_lock_irqsave(&port
->inbuf_lock
, flags
);
550 port
->inbuf
= get_inbuf(port
);
554 spin_unlock_irqrestore(&port
->inbuf_lock
, flags
);
558 static ssize_t
__send_control_msg(struct ports_device
*portdev
, u32 port_id
,
559 unsigned int event
, unsigned int value
)
561 struct scatterlist sg
[1];
562 struct virtio_console_control cpkt
;
563 struct virtqueue
*vq
;
566 if (!use_multiport(portdev
))
575 sg_init_one(sg
, &cpkt
, sizeof(cpkt
));
577 spin_lock(&portdev
->c_ovq_lock
);
578 if (virtqueue_add_outbuf(vq
, sg
, 1, &cpkt
, GFP_ATOMIC
) == 0) {
580 while (!virtqueue_get_buf(vq
, &len
)
581 && !virtqueue_is_broken(vq
))
584 spin_unlock(&portdev
->c_ovq_lock
);
588 static ssize_t
send_control_msg(struct port
*port
, unsigned int event
,
591 /* Did the port get unplugged before userspace closed it? */
593 return __send_control_msg(port
->portdev
, port
->id
, event
, value
);
598 /* Callers must take the port->outvq_lock */
599 static void reclaim_consumed_buffers(struct port
*port
)
601 struct port_buffer
*buf
;
604 if (!port
->portdev
) {
605 /* Device has been unplugged. vqs are already gone. */
608 while ((buf
= virtqueue_get_buf(port
->out_vq
, &len
))) {
609 free_buf(buf
, false);
610 port
->outvq_full
= false;
614 static ssize_t
__send_to_port(struct port
*port
, struct scatterlist
*sg
,
615 int nents
, size_t in_count
,
616 void *data
, bool nonblock
)
618 struct virtqueue
*out_vq
;
623 out_vq
= port
->out_vq
;
625 spin_lock_irqsave(&port
->outvq_lock
, flags
);
627 reclaim_consumed_buffers(port
);
629 err
= virtqueue_add_outbuf(out_vq
, sg
, nents
, data
, GFP_ATOMIC
);
631 /* Tell Host to go! */
632 virtqueue_kick(out_vq
);
639 if (out_vq
->num_free
== 0)
640 port
->outvq_full
= true;
646 * Wait till the host acknowledges it pushed out the data we
647 * sent. This is done for data from the hvc_console; the tty
648 * operations are performed with spinlocks held so we can't
649 * sleep here. An alternative would be to copy the data to a
650 * buffer and relax the spinning requirement. The downside is
651 * we need to kmalloc a GFP_ATOMIC buffer each time the
652 * console driver writes something out.
654 while (!virtqueue_get_buf(out_vq
, &len
)
655 && !virtqueue_is_broken(out_vq
))
658 spin_unlock_irqrestore(&port
->outvq_lock
, flags
);
660 port
->stats
.bytes_sent
+= in_count
;
662 * We're expected to return the amount of data we wrote -- all
669 * Give out the data that's requested from the buffer that we have
672 static ssize_t
fill_readbuf(struct port
*port
, char *out_buf
, size_t out_count
,
675 struct port_buffer
*buf
;
678 if (!out_count
|| !port_has_data(port
))
682 out_count
= min(out_count
, buf
->len
- buf
->offset
);
687 ret
= copy_to_user(out_buf
, buf
->buf
+ buf
->offset
, out_count
);
691 memcpy(out_buf
, buf
->buf
+ buf
->offset
, out_count
);
694 buf
->offset
+= out_count
;
696 if (buf
->offset
== buf
->len
) {
698 * We're done using all the data in this buffer.
699 * Re-queue so that the Host can send us more data.
701 spin_lock_irqsave(&port
->inbuf_lock
, flags
);
704 if (add_inbuf(port
->in_vq
, buf
) < 0)
705 dev_warn(port
->dev
, "failed add_buf\n");
707 spin_unlock_irqrestore(&port
->inbuf_lock
, flags
);
709 /* Return the number of bytes actually copied */
713 /* The condition that must be true for polling to end */
714 static bool will_read_block(struct port
*port
)
716 if (!port
->guest_connected
) {
717 /* Port got hot-unplugged. Let's exit. */
720 return !port_has_data(port
) && port
->host_connected
;
723 static bool will_write_block(struct port
*port
)
727 if (!port
->guest_connected
) {
728 /* Port got hot-unplugged. Let's exit. */
731 if (!port
->host_connected
)
734 spin_lock_irq(&port
->outvq_lock
);
736 * Check if the Host has consumed any buffers since we last
737 * sent data (this is only applicable for nonblocking ports).
739 reclaim_consumed_buffers(port
);
740 ret
= port
->outvq_full
;
741 spin_unlock_irq(&port
->outvq_lock
);
746 static ssize_t
port_fops_read(struct file
*filp
, char __user
*ubuf
,
747 size_t count
, loff_t
*offp
)
752 port
= filp
->private_data
;
754 /* Port is hot-unplugged. */
755 if (!port
->guest_connected
)
758 if (!port_has_data(port
)) {
760 * If nothing's connected on the host just return 0 in
761 * case of list_empty; this tells the userspace app
762 * that there's no connection
764 if (!port
->host_connected
)
766 if (filp
->f_flags
& O_NONBLOCK
)
769 ret
= wait_event_freezable(port
->waitqueue
,
770 !will_read_block(port
));
774 /* Port got hot-unplugged while we were waiting above. */
775 if (!port
->guest_connected
)
778 * We could've received a disconnection message while we were
779 * waiting for more data.
781 * This check is not clubbed in the if() statement above as we
782 * might receive some data as well as the host could get
783 * disconnected after we got woken up from our wait. So we
784 * really want to give off whatever data we have and only then
785 * check for host_connected.
787 if (!port_has_data(port
) && !port
->host_connected
)
790 return fill_readbuf(port
, ubuf
, count
, true);
793 static int wait_port_writable(struct port
*port
, bool nonblock
)
797 if (will_write_block(port
)) {
801 ret
= wait_event_freezable(port
->waitqueue
,
802 !will_write_block(port
));
806 /* Port got hot-unplugged. */
807 if (!port
->guest_connected
)
813 static ssize_t
port_fops_write(struct file
*filp
, const char __user
*ubuf
,
814 size_t count
, loff_t
*offp
)
817 struct port_buffer
*buf
;
820 struct scatterlist sg
[1];
822 /* Userspace could be out to fool us */
826 port
= filp
->private_data
;
828 nonblock
= filp
->f_flags
& O_NONBLOCK
;
830 ret
= wait_port_writable(port
, nonblock
);
834 count
= min((size_t)(32 * 1024), count
);
836 buf
= alloc_buf(port
->out_vq
, count
, 0);
840 ret
= copy_from_user(buf
->buf
, ubuf
, count
);
847 * We now ask send_buf() to not spin for generic ports -- we
848 * can re-use the same code path that non-blocking file
849 * descriptors take for blocking file descriptors since the
850 * wait is already done and we're certain the write will go
851 * through to the host.
854 sg_init_one(sg
, buf
->buf
, count
);
855 ret
= __send_to_port(port
, sg
, 1, count
, buf
, nonblock
);
857 if (nonblock
&& ret
> 0)
870 struct scatterlist
*sg
;
873 static int pipe_to_sg(struct pipe_inode_info
*pipe
, struct pipe_buffer
*buf
,
874 struct splice_desc
*sd
)
876 struct sg_list
*sgl
= sd
->u
.data
;
877 unsigned int offset
, len
;
879 if (sgl
->n
== sgl
->size
)
882 /* Try lock this page */
883 if (buf
->ops
->steal(pipe
, buf
) == 0) {
884 /* Get reference and unlock page for moving */
886 unlock_page(buf
->page
);
888 len
= min(buf
->len
, sd
->len
);
889 sg_set_page(&(sgl
->sg
[sgl
->n
]), buf
->page
, len
, buf
->offset
);
891 /* Failback to copying a page */
892 struct page
*page
= alloc_page(GFP_KERNEL
);
893 char *src
= buf
->ops
->map(pipe
, buf
, 1);
900 offset
= sd
->pos
& ~PAGE_MASK
;
903 if (len
+ offset
> PAGE_SIZE
)
904 len
= PAGE_SIZE
- offset
;
906 memcpy(dst
+ offset
, src
+ buf
->offset
, len
);
909 buf
->ops
->unmap(pipe
, buf
, src
);
911 sg_set_page(&(sgl
->sg
[sgl
->n
]), page
, len
, offset
);
919 /* Faster zero-copy write by splicing */
920 static ssize_t
port_fops_splice_write(struct pipe_inode_info
*pipe
,
921 struct file
*filp
, loff_t
*ppos
,
922 size_t len
, unsigned int flags
)
924 struct port
*port
= filp
->private_data
;
927 struct port_buffer
*buf
;
928 struct splice_desc sd
= {
936 * Rproc_serial does not yet support splice. To support splice
937 * pipe_to_sg() must allocate dma-buffers and copy content from
938 * regular pages to dma pages. And alloc_buf and free_buf must
939 * support allocating and freeing such a list of dma-buffers.
941 if (is_rproc_serial(port
->out_vq
->vdev
))
945 * pipe->nrbufs == 0 means there are no data to transfer,
946 * so this returns just 0 for no data.
954 ret
= wait_port_writable(port
, filp
->f_flags
& O_NONBLOCK
);
958 buf
= alloc_buf(port
->out_vq
, 0, pipe
->nrbufs
);
966 sgl
.size
= pipe
->nrbufs
;
968 sg_init_table(sgl
.sg
, sgl
.size
);
969 ret
= __splice_from_pipe(pipe
, &sd
, pipe_to_sg
);
972 ret
= __send_to_port(port
, buf
->sg
, sgl
.n
, sgl
.len
, buf
, true);
974 if (unlikely(ret
<= 0))
983 static unsigned int port_fops_poll(struct file
*filp
, poll_table
*wait
)
988 port
= filp
->private_data
;
989 poll_wait(filp
, &port
->waitqueue
, wait
);
991 if (!port
->guest_connected
) {
992 /* Port got unplugged */
996 if (!will_read_block(port
))
997 ret
|= POLLIN
| POLLRDNORM
;
998 if (!will_write_block(port
))
1000 if (!port
->host_connected
)
1006 static void remove_port(struct kref
*kref
);
1008 static int port_fops_release(struct inode
*inode
, struct file
*filp
)
1012 port
= filp
->private_data
;
1014 /* Notify host of port being closed */
1015 send_control_msg(port
, VIRTIO_CONSOLE_PORT_OPEN
, 0);
1017 spin_lock_irq(&port
->inbuf_lock
);
1018 port
->guest_connected
= false;
1020 discard_port_data(port
);
1022 spin_unlock_irq(&port
->inbuf_lock
);
1024 spin_lock_irq(&port
->outvq_lock
);
1025 reclaim_consumed_buffers(port
);
1026 spin_unlock_irq(&port
->outvq_lock
);
1030 * Locks aren't necessary here as a port can't be opened after
1031 * unplug, and if a port isn't unplugged, a kref would already
1032 * exist for the port. Plus, taking ports_lock here would
1033 * create a dependency on other locks taken by functions
1034 * inside remove_port if we're the last holder of the port,
1035 * creating many problems.
1037 kref_put(&port
->kref
, remove_port
);
1042 static int port_fops_open(struct inode
*inode
, struct file
*filp
)
1044 struct cdev
*cdev
= inode
->i_cdev
;
1048 /* We get the port with a kref here */
1049 port
= find_port_by_devt(cdev
->dev
);
1051 /* Port was unplugged before we could proceed */
1054 filp
->private_data
= port
;
1057 * Don't allow opening of console port devices -- that's done
1060 if (is_console_port(port
)) {
1065 /* Allow only one process to open a particular port at a time */
1066 spin_lock_irq(&port
->inbuf_lock
);
1067 if (port
->guest_connected
) {
1068 spin_unlock_irq(&port
->inbuf_lock
);
1073 port
->guest_connected
= true;
1074 spin_unlock_irq(&port
->inbuf_lock
);
1076 spin_lock_irq(&port
->outvq_lock
);
1078 * There might be a chance that we missed reclaiming a few
1079 * buffers in the window of the port getting previously closed
1082 reclaim_consumed_buffers(port
);
1083 spin_unlock_irq(&port
->outvq_lock
);
1085 nonseekable_open(inode
, filp
);
1087 /* Notify host of port being opened */
1088 send_control_msg(filp
->private_data
, VIRTIO_CONSOLE_PORT_OPEN
, 1);
1092 kref_put(&port
->kref
, remove_port
);
1096 static int port_fops_fasync(int fd
, struct file
*filp
, int mode
)
1100 port
= filp
->private_data
;
1101 return fasync_helper(fd
, filp
, mode
, &port
->async_queue
);
1105 * The file operations that we support: programs in the guest can open
1106 * a console device, read from it, write to it, poll for data and
1107 * close it. The devices are at
1108 * /dev/vport<device number>p<port number>
1110 static const struct file_operations port_fops
= {
1111 .owner
= THIS_MODULE
,
1112 .open
= port_fops_open
,
1113 .read
= port_fops_read
,
1114 .write
= port_fops_write
,
1115 .splice_write
= port_fops_splice_write
,
1116 .poll
= port_fops_poll
,
1117 .release
= port_fops_release
,
1118 .fasync
= port_fops_fasync
,
1119 .llseek
= no_llseek
,
1123 * The put_chars() callback is pretty straightforward.
1125 * We turn the characters into a scatter-gather list, add it to the
1126 * output queue and then kick the Host. Then we sit here waiting for
1127 * it to finish: inefficient in theory, but in practice
1128 * implementations will do it immediately (lguest's Launcher does).
1130 static int put_chars(u32 vtermno
, const char *buf
, int count
)
1133 struct scatterlist sg
[1];
1135 if (unlikely(early_put_chars
))
1136 return early_put_chars(vtermno
, buf
, count
);
1138 port
= find_port_by_vtermno(vtermno
);
1142 sg_init_one(sg
, buf
, count
);
1143 return __send_to_port(port
, sg
, 1, count
, (void *)buf
, false);
1147 * get_chars() is the callback from the hvc_console infrastructure
1148 * when an interrupt is received.
1150 * We call out to fill_readbuf that gets us the required data from the
1151 * buffers that are queued up.
1153 static int get_chars(u32 vtermno
, char *buf
, int count
)
1157 /* If we've not set up the port yet, we have no input to give. */
1158 if (unlikely(early_put_chars
))
1161 port
= find_port_by_vtermno(vtermno
);
1165 /* If we don't have an input queue yet, we can't get input. */
1166 BUG_ON(!port
->in_vq
);
1168 return fill_readbuf(port
, buf
, count
, false);
1171 static void resize_console(struct port
*port
)
1173 struct virtio_device
*vdev
;
1175 /* The port could have been hot-unplugged */
1176 if (!port
|| !is_console_port(port
))
1179 vdev
= port
->portdev
->vdev
;
1181 /* Don't test F_SIZE at all if we're rproc: not a valid feature! */
1182 if (!is_rproc_serial(vdev
) &&
1183 virtio_has_feature(vdev
, VIRTIO_CONSOLE_F_SIZE
))
1184 hvc_resize(port
->cons
.hvc
, port
->cons
.ws
);
1187 /* We set the configuration at this point, since we now have a tty */
1188 static int notifier_add_vio(struct hvc_struct
*hp
, int data
)
1192 port
= find_port_by_vtermno(hp
->vtermno
);
1196 hp
->irq_requested
= 1;
1197 resize_console(port
);
1202 static void notifier_del_vio(struct hvc_struct
*hp
, int data
)
1204 hp
->irq_requested
= 0;
1207 /* The operations for console ports. */
1208 static const struct hv_ops hv_ops
= {
1209 .get_chars
= get_chars
,
1210 .put_chars
= put_chars
,
1211 .notifier_add
= notifier_add_vio
,
1212 .notifier_del
= notifier_del_vio
,
1213 .notifier_hangup
= notifier_del_vio
,
1217 * Console drivers are initialized very early so boot messages can go
1218 * out, so we do things slightly differently from the generic virtio
1219 * initialization of the net and block drivers.
1221 * At this stage, the console is output-only. It's too early to set
1222 * up a virtqueue, so we let the drivers do some boutique early-output
1225 int __init
virtio_cons_early_init(int (*put_chars
)(u32
, const char *, int))
1227 early_put_chars
= put_chars
;
1228 return hvc_instantiate(0, 0, &hv_ops
);
1231 static int init_port_console(struct port
*port
)
1236 * The Host's telling us this port is a console port. Hook it
1237 * up with an hvc console.
1239 * To set up and manage our virtual console, we call
1242 * The first argument of hvc_alloc() is the virtual console
1243 * number. The second argument is the parameter for the
1244 * notification mechanism (like irq number). We currently
1245 * leave this as zero, virtqueues have implicit notifications.
1247 * The third argument is a "struct hv_ops" containing the
1248 * put_chars() get_chars(), notifier_add() and notifier_del()
1249 * pointers. The final argument is the output buffer size: we
1250 * can do any size, so we put PAGE_SIZE here.
1252 port
->cons
.vtermno
= pdrvdata
.next_vtermno
;
1254 port
->cons
.hvc
= hvc_alloc(port
->cons
.vtermno
, 0, &hv_ops
, PAGE_SIZE
);
1255 if (IS_ERR(port
->cons
.hvc
)) {
1256 ret
= PTR_ERR(port
->cons
.hvc
);
1258 "error %d allocating hvc for port\n", ret
);
1259 port
->cons
.hvc
= NULL
;
1262 spin_lock_irq(&pdrvdata_lock
);
1263 pdrvdata
.next_vtermno
++;
1264 list_add_tail(&port
->cons
.list
, &pdrvdata
.consoles
);
1265 spin_unlock_irq(&pdrvdata_lock
);
1266 port
->guest_connected
= true;
1269 * Start using the new console output if this is the first
1270 * console to come up.
1272 if (early_put_chars
)
1273 early_put_chars
= NULL
;
1275 /* Notify host of port being opened */
1276 send_control_msg(port
, VIRTIO_CONSOLE_PORT_OPEN
, 1);
1281 static ssize_t
show_port_name(struct device
*dev
,
1282 struct device_attribute
*attr
, char *buffer
)
1286 port
= dev_get_drvdata(dev
);
1288 return sprintf(buffer
, "%s\n", port
->name
);
1291 static DEVICE_ATTR(name
, S_IRUGO
, show_port_name
, NULL
);
1293 static struct attribute
*port_sysfs_entries
[] = {
1294 &dev_attr_name
.attr
,
1298 static struct attribute_group port_attribute_group
= {
1299 .name
= NULL
, /* put in device directory */
1300 .attrs
= port_sysfs_entries
,
1303 static ssize_t
debugfs_read(struct file
*filp
, char __user
*ubuf
,
1304 size_t count
, loff_t
*offp
)
1308 ssize_t ret
, out_offset
, out_count
;
1311 buf
= kmalloc(out_count
, GFP_KERNEL
);
1315 port
= filp
->private_data
;
1317 out_offset
+= snprintf(buf
+ out_offset
, out_count
,
1318 "name: %s\n", port
->name
? port
->name
: "");
1319 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1320 "guest_connected: %d\n", port
->guest_connected
);
1321 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1322 "host_connected: %d\n", port
->host_connected
);
1323 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1324 "outvq_full: %d\n", port
->outvq_full
);
1325 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1326 "bytes_sent: %lu\n", port
->stats
.bytes_sent
);
1327 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1328 "bytes_received: %lu\n",
1329 port
->stats
.bytes_received
);
1330 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1331 "bytes_discarded: %lu\n",
1332 port
->stats
.bytes_discarded
);
1333 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1335 is_console_port(port
) ? "yes" : "no");
1336 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1337 "console_vtermno: %u\n", port
->cons
.vtermno
);
1339 ret
= simple_read_from_buffer(ubuf
, count
, offp
, buf
, out_offset
);
1344 static const struct file_operations port_debugfs_ops
= {
1345 .owner
= THIS_MODULE
,
1346 .open
= simple_open
,
1347 .read
= debugfs_read
,
1350 static void set_console_size(struct port
*port
, u16 rows
, u16 cols
)
1352 if (!port
|| !is_console_port(port
))
1355 port
->cons
.ws
.ws_row
= rows
;
1356 port
->cons
.ws
.ws_col
= cols
;
1359 static unsigned int fill_queue(struct virtqueue
*vq
, spinlock_t
*lock
)
1361 struct port_buffer
*buf
;
1362 unsigned int nr_added_bufs
;
1367 buf
= alloc_buf(vq
, PAGE_SIZE
, 0);
1371 spin_lock_irq(lock
);
1372 ret
= add_inbuf(vq
, buf
);
1374 spin_unlock_irq(lock
);
1375 free_buf(buf
, true);
1379 spin_unlock_irq(lock
);
1382 return nr_added_bufs
;
1385 static void send_sigio_to_port(struct port
*port
)
1387 if (port
->async_queue
&& port
->guest_connected
)
1388 kill_fasync(&port
->async_queue
, SIGIO
, POLL_OUT
);
1391 static int add_port(struct ports_device
*portdev
, u32 id
)
1393 char debugfs_name
[16];
1395 struct port_buffer
*buf
;
1397 unsigned int nr_added_bufs
;
1400 port
= kmalloc(sizeof(*port
), GFP_KERNEL
);
1405 kref_init(&port
->kref
);
1407 port
->portdev
= portdev
;
1412 port
->cons
.hvc
= NULL
;
1413 port
->async_queue
= NULL
;
1415 port
->cons
.ws
.ws_row
= port
->cons
.ws
.ws_col
= 0;
1417 port
->host_connected
= port
->guest_connected
= false;
1418 port
->stats
= (struct port_stats
) { 0 };
1420 port
->outvq_full
= false;
1422 port
->in_vq
= portdev
->in_vqs
[port
->id
];
1423 port
->out_vq
= portdev
->out_vqs
[port
->id
];
1425 port
->cdev
= cdev_alloc();
1427 dev_err(&port
->portdev
->vdev
->dev
, "Error allocating cdev\n");
1431 port
->cdev
->ops
= &port_fops
;
1433 devt
= MKDEV(portdev
->chr_major
, id
);
1434 err
= cdev_add(port
->cdev
, devt
, 1);
1436 dev_err(&port
->portdev
->vdev
->dev
,
1437 "Error %d adding cdev for port %u\n", err
, id
);
1440 port
->dev
= device_create(pdrvdata
.class, &port
->portdev
->vdev
->dev
,
1441 devt
, port
, "vport%up%u",
1442 port
->portdev
->vdev
->index
, id
);
1443 if (IS_ERR(port
->dev
)) {
1444 err
= PTR_ERR(port
->dev
);
1445 dev_err(&port
->portdev
->vdev
->dev
,
1446 "Error %d creating device for port %u\n",
1451 spin_lock_init(&port
->inbuf_lock
);
1452 spin_lock_init(&port
->outvq_lock
);
1453 init_waitqueue_head(&port
->waitqueue
);
1455 /* Fill the in_vq with buffers so the host can send us data. */
1456 nr_added_bufs
= fill_queue(port
->in_vq
, &port
->inbuf_lock
);
1457 if (!nr_added_bufs
) {
1458 dev_err(port
->dev
, "Error allocating inbufs\n");
1463 if (is_rproc_serial(port
->portdev
->vdev
))
1465 * For rproc_serial assume remote processor is connected.
1466 * rproc_serial does not want the console port, only
1467 * the generic port implementation.
1469 port
->host_connected
= true;
1470 else if (!use_multiport(port
->portdev
)) {
1472 * If we're not using multiport support,
1473 * this has to be a console port.
1475 err
= init_port_console(port
);
1480 spin_lock_irq(&portdev
->ports_lock
);
1481 list_add_tail(&port
->list
, &port
->portdev
->ports
);
1482 spin_unlock_irq(&portdev
->ports_lock
);
1485 * Tell the Host we're set so that it can send us various
1486 * configuration parameters for this port (eg, port name,
1487 * caching, whether this is a console port, etc.)
1489 send_control_msg(port
, VIRTIO_CONSOLE_PORT_READY
, 1);
1491 if (pdrvdata
.debugfs_dir
) {
1493 * Finally, create the debugfs file that we can use to
1494 * inspect a port's state at any time
1496 sprintf(debugfs_name
, "vport%up%u",
1497 port
->portdev
->vdev
->index
, id
);
1498 port
->debugfs_file
= debugfs_create_file(debugfs_name
, 0444,
1499 pdrvdata
.debugfs_dir
,
1506 while ((buf
= virtqueue_detach_unused_buf(port
->in_vq
)))
1507 free_buf(buf
, true);
1509 device_destroy(pdrvdata
.class, port
->dev
->devt
);
1511 cdev_del(port
->cdev
);
1515 /* The host might want to notify management sw about port add failure */
1516 __send_control_msg(portdev
, id
, VIRTIO_CONSOLE_PORT_READY
, 0);
1520 /* No users remain, remove all port-specific data. */
1521 static void remove_port(struct kref
*kref
)
1525 port
= container_of(kref
, struct port
, kref
);
1530 static void remove_port_data(struct port
*port
)
1532 struct port_buffer
*buf
;
1534 spin_lock_irq(&port
->inbuf_lock
);
1535 /* Remove unused data this port might have received. */
1536 discard_port_data(port
);
1538 /* Remove buffers we queued up for the Host to send us data in. */
1539 while ((buf
= virtqueue_detach_unused_buf(port
->in_vq
)))
1540 free_buf(buf
, true);
1541 spin_unlock_irq(&port
->inbuf_lock
);
1543 spin_lock_irq(&port
->outvq_lock
);
1544 reclaim_consumed_buffers(port
);
1546 /* Free pending buffers from the out-queue. */
1547 while ((buf
= virtqueue_detach_unused_buf(port
->out_vq
)))
1548 free_buf(buf
, true);
1549 spin_unlock_irq(&port
->outvq_lock
);
1553 * Port got unplugged. Remove port from portdev's list and drop the
1554 * kref reference. If no userspace has this port opened, it will
1555 * result in immediate removal the port.
1557 static void unplug_port(struct port
*port
)
1559 spin_lock_irq(&port
->portdev
->ports_lock
);
1560 list_del(&port
->list
);
1561 spin_unlock_irq(&port
->portdev
->ports_lock
);
1563 spin_lock_irq(&port
->inbuf_lock
);
1564 if (port
->guest_connected
) {
1565 /* Let the app know the port is going down. */
1566 send_sigio_to_port(port
);
1568 /* Do this after sigio is actually sent */
1569 port
->guest_connected
= false;
1570 port
->host_connected
= false;
1572 wake_up_interruptible(&port
->waitqueue
);
1574 spin_unlock_irq(&port
->inbuf_lock
);
1576 if (is_console_port(port
)) {
1577 spin_lock_irq(&pdrvdata_lock
);
1578 list_del(&port
->cons
.list
);
1579 spin_unlock_irq(&pdrvdata_lock
);
1580 hvc_remove(port
->cons
.hvc
);
1583 remove_port_data(port
);
1586 * We should just assume the device itself has gone off --
1587 * else a close on an open port later will try to send out a
1590 port
->portdev
= NULL
;
1592 sysfs_remove_group(&port
->dev
->kobj
, &port_attribute_group
);
1593 device_destroy(pdrvdata
.class, port
->dev
->devt
);
1594 cdev_del(port
->cdev
);
1596 debugfs_remove(port
->debugfs_file
);
1600 * Locks around here are not necessary - a port can't be
1601 * opened after we removed the port struct from ports_list
1604 kref_put(&port
->kref
, remove_port
);
1607 /* Any private messages that the Host and Guest want to share */
1608 static void handle_control_message(struct ports_device
*portdev
,
1609 struct port_buffer
*buf
)
1611 struct virtio_console_control
*cpkt
;
1616 cpkt
= (struct virtio_console_control
*)(buf
->buf
+ buf
->offset
);
1618 port
= find_port_by_id(portdev
, cpkt
->id
);
1619 if (!port
&& cpkt
->event
!= VIRTIO_CONSOLE_PORT_ADD
) {
1620 /* No valid header at start of buffer. Drop it. */
1621 dev_dbg(&portdev
->vdev
->dev
,
1622 "Invalid index %u in control packet\n", cpkt
->id
);
1626 switch (cpkt
->event
) {
1627 case VIRTIO_CONSOLE_PORT_ADD
:
1629 dev_dbg(&portdev
->vdev
->dev
,
1630 "Port %u already added\n", port
->id
);
1631 send_control_msg(port
, VIRTIO_CONSOLE_PORT_READY
, 1);
1634 if (cpkt
->id
>= portdev
->config
.max_nr_ports
) {
1635 dev_warn(&portdev
->vdev
->dev
,
1636 "Request for adding port with out-of-bound id %u, max. supported id: %u\n",
1637 cpkt
->id
, portdev
->config
.max_nr_ports
- 1);
1640 add_port(portdev
, cpkt
->id
);
1642 case VIRTIO_CONSOLE_PORT_REMOVE
:
1645 case VIRTIO_CONSOLE_CONSOLE_PORT
:
1648 if (is_console_port(port
))
1651 init_port_console(port
);
1652 complete(&early_console_added
);
1654 * Could remove the port here in case init fails - but
1655 * have to notify the host first.
1658 case VIRTIO_CONSOLE_RESIZE
: {
1664 if (!is_console_port(port
))
1667 memcpy(&size
, buf
->buf
+ buf
->offset
+ sizeof(*cpkt
),
1669 set_console_size(port
, size
.rows
, size
.cols
);
1671 port
->cons
.hvc
->irq_requested
= 1;
1672 resize_console(port
);
1675 case VIRTIO_CONSOLE_PORT_OPEN
:
1676 port
->host_connected
= cpkt
->value
;
1677 wake_up_interruptible(&port
->waitqueue
);
1679 * If the host port got closed and the host had any
1680 * unconsumed buffers, we'll be able to reclaim them
1683 spin_lock_irq(&port
->outvq_lock
);
1684 reclaim_consumed_buffers(port
);
1685 spin_unlock_irq(&port
->outvq_lock
);
1688 * If the guest is connected, it'll be interested in
1689 * knowing the host connection state changed.
1691 spin_lock_irq(&port
->inbuf_lock
);
1692 send_sigio_to_port(port
);
1693 spin_unlock_irq(&port
->inbuf_lock
);
1695 case VIRTIO_CONSOLE_PORT_NAME
:
1697 * If we woke up after hibernation, we can get this
1698 * again. Skip it in that case.
1704 * Skip the size of the header and the cpkt to get the size
1705 * of the name that was sent
1707 name_size
= buf
->len
- buf
->offset
- sizeof(*cpkt
) + 1;
1709 port
->name
= kmalloc(name_size
, GFP_KERNEL
);
1712 "Not enough space to store port name\n");
1715 strncpy(port
->name
, buf
->buf
+ buf
->offset
+ sizeof(*cpkt
),
1717 port
->name
[name_size
- 1] = 0;
1720 * Since we only have one sysfs attribute, 'name',
1721 * create it only if we have a name for the port.
1723 err
= sysfs_create_group(&port
->dev
->kobj
,
1724 &port_attribute_group
);
1727 "Error %d creating sysfs device attributes\n",
1731 * Generate a udev event so that appropriate
1732 * symlinks can be created based on udev
1735 kobject_uevent(&port
->dev
->kobj
, KOBJ_CHANGE
);
1741 static void control_work_handler(struct work_struct
*work
)
1743 struct ports_device
*portdev
;
1744 struct virtqueue
*vq
;
1745 struct port_buffer
*buf
;
1748 portdev
= container_of(work
, struct ports_device
, control_work
);
1749 vq
= portdev
->c_ivq
;
1751 spin_lock(&portdev
->c_ivq_lock
);
1752 while ((buf
= virtqueue_get_buf(vq
, &len
))) {
1753 spin_unlock(&portdev
->c_ivq_lock
);
1758 handle_control_message(portdev
, buf
);
1760 spin_lock(&portdev
->c_ivq_lock
);
1761 if (add_inbuf(portdev
->c_ivq
, buf
) < 0) {
1762 dev_warn(&portdev
->vdev
->dev
,
1763 "Error adding buffer to queue\n");
1764 free_buf(buf
, false);
1767 spin_unlock(&portdev
->c_ivq_lock
);
1770 static void out_intr(struct virtqueue
*vq
)
1774 port
= find_port_by_vq(vq
->vdev
->priv
, vq
);
1778 wake_up_interruptible(&port
->waitqueue
);
1781 static void in_intr(struct virtqueue
*vq
)
1784 unsigned long flags
;
1786 port
= find_port_by_vq(vq
->vdev
->priv
, vq
);
1790 spin_lock_irqsave(&port
->inbuf_lock
, flags
);
1791 port
->inbuf
= get_inbuf(port
);
1794 * Normally the port should not accept data when the port is
1795 * closed. For generic serial ports, the host won't (shouldn't)
1796 * send data till the guest is connected. But this condition
1797 * can be reached when a console port is not yet connected (no
1798 * tty is spawned) and the other side sends out data over the
1799 * vring, or when a remote devices start sending data before
1800 * the ports are opened.
1802 * A generic serial port will discard data if not connected,
1803 * while console ports and rproc-serial ports accepts data at
1804 * any time. rproc-serial is initiated with guest_connected to
1805 * false because port_fops_open expects this. Console ports are
1806 * hooked up with an HVC console and is initialized with
1807 * guest_connected to true.
1810 if (!port
->guest_connected
&& !is_rproc_serial(port
->portdev
->vdev
))
1811 discard_port_data(port
);
1813 /* Send a SIGIO indicating new data in case the process asked for it */
1814 send_sigio_to_port(port
);
1816 spin_unlock_irqrestore(&port
->inbuf_lock
, flags
);
1818 wake_up_interruptible(&port
->waitqueue
);
1820 if (is_console_port(port
) && hvc_poll(port
->cons
.hvc
))
1824 static void control_intr(struct virtqueue
*vq
)
1826 struct ports_device
*portdev
;
1828 portdev
= vq
->vdev
->priv
;
1829 schedule_work(&portdev
->control_work
);
1832 static void config_intr(struct virtio_device
*vdev
)
1834 struct ports_device
*portdev
;
1836 portdev
= vdev
->priv
;
1838 if (!use_multiport(portdev
)) {
1842 virtio_cread(vdev
, struct virtio_console_config
, cols
, &cols
);
1843 virtio_cread(vdev
, struct virtio_console_config
, rows
, &rows
);
1845 port
= find_port_by_id(portdev
, 0);
1846 set_console_size(port
, rows
, cols
);
1849 * We'll use this way of resizing only for legacy
1850 * support. For newer userspace
1851 * (VIRTIO_CONSOLE_F_MULTPORT+), use control messages
1852 * to indicate console size changes so that it can be
1855 resize_console(port
);
1859 static int init_vqs(struct ports_device
*portdev
)
1861 vq_callback_t
**io_callbacks
;
1863 struct virtqueue
**vqs
;
1864 u32 i
, j
, nr_ports
, nr_queues
;
1867 nr_ports
= portdev
->config
.max_nr_ports
;
1868 nr_queues
= use_multiport(portdev
) ? (nr_ports
+ 1) * 2 : 2;
1870 vqs
= kmalloc(nr_queues
* sizeof(struct virtqueue
*), GFP_KERNEL
);
1871 io_callbacks
= kmalloc(nr_queues
* sizeof(vq_callback_t
*), GFP_KERNEL
);
1872 io_names
= kmalloc(nr_queues
* sizeof(char *), GFP_KERNEL
);
1873 portdev
->in_vqs
= kmalloc(nr_ports
* sizeof(struct virtqueue
*),
1875 portdev
->out_vqs
= kmalloc(nr_ports
* sizeof(struct virtqueue
*),
1877 if (!vqs
|| !io_callbacks
|| !io_names
|| !portdev
->in_vqs
||
1878 !portdev
->out_vqs
) {
1884 * For backward compat (newer host but older guest), the host
1885 * spawns a console port first and also inits the vqs for port
1889 io_callbacks
[j
] = in_intr
;
1890 io_callbacks
[j
+ 1] = out_intr
;
1891 io_names
[j
] = "input";
1892 io_names
[j
+ 1] = "output";
1895 if (use_multiport(portdev
)) {
1896 io_callbacks
[j
] = control_intr
;
1897 io_callbacks
[j
+ 1] = NULL
;
1898 io_names
[j
] = "control-i";
1899 io_names
[j
+ 1] = "control-o";
1901 for (i
= 1; i
< nr_ports
; i
++) {
1903 io_callbacks
[j
] = in_intr
;
1904 io_callbacks
[j
+ 1] = out_intr
;
1905 io_names
[j
] = "input";
1906 io_names
[j
+ 1] = "output";
1909 /* Find the queues. */
1910 err
= portdev
->vdev
->config
->find_vqs(portdev
->vdev
, nr_queues
, vqs
,
1912 (const char **)io_names
);
1917 portdev
->in_vqs
[0] = vqs
[0];
1918 portdev
->out_vqs
[0] = vqs
[1];
1920 if (use_multiport(portdev
)) {
1921 portdev
->c_ivq
= vqs
[j
];
1922 portdev
->c_ovq
= vqs
[j
+ 1];
1924 for (i
= 1; i
< nr_ports
; i
++) {
1926 portdev
->in_vqs
[i
] = vqs
[j
];
1927 portdev
->out_vqs
[i
] = vqs
[j
+ 1];
1931 kfree(io_callbacks
);
1937 kfree(portdev
->out_vqs
);
1938 kfree(portdev
->in_vqs
);
1940 kfree(io_callbacks
);
1946 static const struct file_operations portdev_fops
= {
1947 .owner
= THIS_MODULE
,
1950 static void remove_vqs(struct ports_device
*portdev
)
1952 portdev
->vdev
->config
->del_vqs(portdev
->vdev
);
1953 kfree(portdev
->in_vqs
);
1954 kfree(portdev
->out_vqs
);
1957 static void remove_controlq_data(struct ports_device
*portdev
)
1959 struct port_buffer
*buf
;
1962 if (!use_multiport(portdev
))
1965 while ((buf
= virtqueue_get_buf(portdev
->c_ivq
, &len
)))
1966 free_buf(buf
, true);
1968 while ((buf
= virtqueue_detach_unused_buf(portdev
->c_ivq
)))
1969 free_buf(buf
, true);
1973 * Once we're further in boot, we get probed like any other virtio
1976 * If the host also supports multiple console ports, we check the
1977 * config space to see how many ports the host has spawned. We
1978 * initialize each port found.
1980 static int virtcons_probe(struct virtio_device
*vdev
)
1982 struct ports_device
*portdev
;
1985 bool early
= early_put_chars
!= NULL
;
1987 /* Ensure to read early_put_chars now */
1990 portdev
= kmalloc(sizeof(*portdev
), GFP_KERNEL
);
1996 /* Attach this portdev to this virtio_device, and vice-versa. */
1997 portdev
->vdev
= vdev
;
1998 vdev
->priv
= portdev
;
2000 portdev
->chr_major
= register_chrdev(0, "virtio-portsdev",
2002 if (portdev
->chr_major
< 0) {
2004 "Error %d registering chrdev for device %u\n",
2005 portdev
->chr_major
, vdev
->index
);
2006 err
= portdev
->chr_major
;
2011 portdev
->config
.max_nr_ports
= 1;
2013 /* Don't test MULTIPORT at all if we're rproc: not a valid feature! */
2014 if (!is_rproc_serial(vdev
) &&
2015 virtio_cread_feature(vdev
, VIRTIO_CONSOLE_F_MULTIPORT
,
2016 struct virtio_console_config
, max_nr_ports
,
2017 &portdev
->config
.max_nr_ports
) == 0) {
2021 err
= init_vqs(portdev
);
2023 dev_err(&vdev
->dev
, "Error %d initializing vqs\n", err
);
2027 spin_lock_init(&portdev
->ports_lock
);
2028 INIT_LIST_HEAD(&portdev
->ports
);
2031 unsigned int nr_added_bufs
;
2033 spin_lock_init(&portdev
->c_ivq_lock
);
2034 spin_lock_init(&portdev
->c_ovq_lock
);
2035 INIT_WORK(&portdev
->control_work
, &control_work_handler
);
2037 nr_added_bufs
= fill_queue(portdev
->c_ivq
,
2038 &portdev
->c_ivq_lock
);
2039 if (!nr_added_bufs
) {
2041 "Error allocating buffers for control queue\n");
2047 * For backward compatibility: Create a console port
2048 * if we're running on older host.
2050 add_port(portdev
, 0);
2053 spin_lock_irq(&pdrvdata_lock
);
2054 list_add_tail(&portdev
->list
, &pdrvdata
.portdevs
);
2055 spin_unlock_irq(&pdrvdata_lock
);
2057 __send_control_msg(portdev
, VIRTIO_CONSOLE_BAD_ID
,
2058 VIRTIO_CONSOLE_DEVICE_READY
, 1);
2061 * If there was an early virtio console, assume that there are no
2062 * other consoles. We need to wait until the hvc_alloc matches the
2063 * hvc_instantiate, otherwise tty_open will complain, resulting in
2064 * a "Warning: unable to open an initial console" boot failure.
2065 * Without multiport this is done in add_port above. With multiport
2066 * this might take some host<->guest communication - thus we have to
2069 if (multiport
&& early
)
2070 wait_for_completion(&early_console_added
);
2075 /* The host might want to notify mgmt sw about device add failure */
2076 __send_control_msg(portdev
, VIRTIO_CONSOLE_BAD_ID
,
2077 VIRTIO_CONSOLE_DEVICE_READY
, 0);
2078 remove_vqs(portdev
);
2080 unregister_chrdev(portdev
->chr_major
, "virtio-portsdev");
2087 static void virtcons_remove(struct virtio_device
*vdev
)
2089 struct ports_device
*portdev
;
2090 struct port
*port
, *port2
;
2092 portdev
= vdev
->priv
;
2094 spin_lock_irq(&pdrvdata_lock
);
2095 list_del(&portdev
->list
);
2096 spin_unlock_irq(&pdrvdata_lock
);
2098 /* Disable interrupts for vqs */
2099 vdev
->config
->reset(vdev
);
2100 /* Finish up work that's lined up */
2101 if (use_multiport(portdev
))
2102 cancel_work_sync(&portdev
->control_work
);
2104 list_for_each_entry_safe(port
, port2
, &portdev
->ports
, list
)
2107 unregister_chrdev(portdev
->chr_major
, "virtio-portsdev");
2110 * When yanking out a device, we immediately lose the
2111 * (device-side) queues. So there's no point in keeping the
2112 * guest side around till we drop our final reference. This
2113 * also means that any ports which are in an open state will
2114 * have to just stop using the port, as the vqs are going
2117 remove_controlq_data(portdev
);
2118 remove_vqs(portdev
);
2122 static struct virtio_device_id id_table
[] = {
2123 { VIRTIO_ID_CONSOLE
, VIRTIO_DEV_ANY_ID
},
2127 static unsigned int features
[] = {
2128 VIRTIO_CONSOLE_F_SIZE
,
2129 VIRTIO_CONSOLE_F_MULTIPORT
,
2132 static struct virtio_device_id rproc_serial_id_table
[] = {
2133 #if IS_ENABLED(CONFIG_REMOTEPROC)
2134 { VIRTIO_ID_RPROC_SERIAL
, VIRTIO_DEV_ANY_ID
},
2139 static unsigned int rproc_serial_features
[] = {
2142 #ifdef CONFIG_PM_SLEEP
2143 static int virtcons_freeze(struct virtio_device
*vdev
)
2145 struct ports_device
*portdev
;
2148 portdev
= vdev
->priv
;
2150 vdev
->config
->reset(vdev
);
2152 virtqueue_disable_cb(portdev
->c_ivq
);
2153 cancel_work_sync(&portdev
->control_work
);
2155 * Once more: if control_work_handler() was running, it would
2156 * enable the cb as the last step.
2158 virtqueue_disable_cb(portdev
->c_ivq
);
2159 remove_controlq_data(portdev
);
2161 list_for_each_entry(port
, &portdev
->ports
, list
) {
2162 virtqueue_disable_cb(port
->in_vq
);
2163 virtqueue_disable_cb(port
->out_vq
);
2165 * We'll ask the host later if the new invocation has
2166 * the port opened or closed.
2168 port
->host_connected
= false;
2169 remove_port_data(port
);
2171 remove_vqs(portdev
);
2176 static int virtcons_restore(struct virtio_device
*vdev
)
2178 struct ports_device
*portdev
;
2182 portdev
= vdev
->priv
;
2184 ret
= init_vqs(portdev
);
2188 if (use_multiport(portdev
))
2189 fill_queue(portdev
->c_ivq
, &portdev
->c_ivq_lock
);
2191 list_for_each_entry(port
, &portdev
->ports
, list
) {
2192 port
->in_vq
= portdev
->in_vqs
[port
->id
];
2193 port
->out_vq
= portdev
->out_vqs
[port
->id
];
2195 fill_queue(port
->in_vq
, &port
->inbuf_lock
);
2197 /* Get port open/close status on the host */
2198 send_control_msg(port
, VIRTIO_CONSOLE_PORT_READY
, 1);
2201 * If a port was open at the time of suspending, we
2202 * have to let the host know that it's still open.
2204 if (port
->guest_connected
)
2205 send_control_msg(port
, VIRTIO_CONSOLE_PORT_OPEN
, 1);
2211 static struct virtio_driver virtio_console
= {
2212 .feature_table
= features
,
2213 .feature_table_size
= ARRAY_SIZE(features
),
2214 .driver
.name
= KBUILD_MODNAME
,
2215 .driver
.owner
= THIS_MODULE
,
2216 .id_table
= id_table
,
2217 .probe
= virtcons_probe
,
2218 .remove
= virtcons_remove
,
2219 .config_changed
= config_intr
,
2220 #ifdef CONFIG_PM_SLEEP
2221 .freeze
= virtcons_freeze
,
2222 .restore
= virtcons_restore
,
2226 static struct virtio_driver virtio_rproc_serial
= {
2227 .feature_table
= rproc_serial_features
,
2228 .feature_table_size
= ARRAY_SIZE(rproc_serial_features
),
2229 .driver
.name
= "virtio_rproc_serial",
2230 .driver
.owner
= THIS_MODULE
,
2231 .id_table
= rproc_serial_id_table
,
2232 .probe
= virtcons_probe
,
2233 .remove
= virtcons_remove
,
2236 static int __init
init(void)
2240 pdrvdata
.class = class_create(THIS_MODULE
, "virtio-ports");
2241 if (IS_ERR(pdrvdata
.class)) {
2242 err
= PTR_ERR(pdrvdata
.class);
2243 pr_err("Error %d creating virtio-ports class\n", err
);
2247 pdrvdata
.debugfs_dir
= debugfs_create_dir("virtio-ports", NULL
);
2248 if (!pdrvdata
.debugfs_dir
)
2249 pr_warning("Error creating debugfs dir for virtio-ports\n");
2250 INIT_LIST_HEAD(&pdrvdata
.consoles
);
2251 INIT_LIST_HEAD(&pdrvdata
.portdevs
);
2253 err
= register_virtio_driver(&virtio_console
);
2255 pr_err("Error %d registering virtio driver\n", err
);
2258 err
= register_virtio_driver(&virtio_rproc_serial
);
2260 pr_err("Error %d registering virtio rproc serial driver\n",
2266 unregister_virtio_driver(&virtio_console
);
2268 if (pdrvdata
.debugfs_dir
)
2269 debugfs_remove_recursive(pdrvdata
.debugfs_dir
);
2270 class_destroy(pdrvdata
.class);
2274 static void __exit
fini(void)
2278 unregister_virtio_driver(&virtio_console
);
2279 unregister_virtio_driver(&virtio_rproc_serial
);
2281 class_destroy(pdrvdata
.class);
2282 if (pdrvdata
.debugfs_dir
)
2283 debugfs_remove_recursive(pdrvdata
.debugfs_dir
);
2288 MODULE_DEVICE_TABLE(virtio
, id_table
);
2289 MODULE_DESCRIPTION("Virtio console driver");
2290 MODULE_LICENSE("GPL");