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 DEFINE_SPINLOCK(pdrvdata_lock
);
82 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 */
154 /* The current config space is stored here */
155 struct virtio_console_config config
;
157 /* The virtio device we're associated with */
158 struct virtio_device
*vdev
;
161 * A couple of virtqueues for the control channel: one for
162 * guest->host transfers, one for host->guest transfers
164 struct virtqueue
*c_ivq
, *c_ovq
;
166 /* Array of per-port IO virtqueues */
167 struct virtqueue
**in_vqs
, **out_vqs
;
169 /* Major number for this device. Ports will be created as minors. */
174 unsigned long bytes_sent
, bytes_received
, bytes_discarded
;
177 /* This struct holds the per-port data */
179 /* Next port in the list, head is in the ports_device */
180 struct list_head list
;
182 /* Pointer to the parent virtio_console device */
183 struct ports_device
*portdev
;
185 /* The current buffer from which data has to be fed to readers */
186 struct port_buffer
*inbuf
;
189 * To protect the operations on the in_vq associated with this
190 * port. Has to be a spinlock because it can be called from
191 * interrupt context (get_char()).
193 spinlock_t inbuf_lock
;
195 /* Protect the operations on the out_vq. */
196 spinlock_t outvq_lock
;
198 /* The IO vqs for this port */
199 struct virtqueue
*in_vq
, *out_vq
;
201 /* File in the debugfs directory that exposes this port's information */
202 struct dentry
*debugfs_file
;
205 * Keep count of the bytes sent, received and discarded for
206 * this port for accounting and debugging purposes. These
207 * counts are not reset across port open / close events.
209 struct port_stats stats
;
212 * The entries in this struct will be valid if this port is
213 * hooked up to an hvc console
217 /* Each port associates with a separate char device */
221 /* Reference-counting to handle port hot-unplugs and file operations */
224 /* A waitqueue for poll() or blocking read operations */
225 wait_queue_head_t waitqueue
;
227 /* The 'name' of the port that we expose via sysfs properties */
230 /* We can notify apps of host connect / disconnect events via SIGIO */
231 struct fasync_struct
*async_queue
;
233 /* The 'id' to identify the port with the Host */
238 /* Is the host device open */
241 /* We should allow only one process to open a port */
242 bool guest_connected
;
245 /* This is the very early arch-specified put chars function. */
246 static int (*early_put_chars
)(u32
, const char *, int);
248 static struct port
*find_port_by_vtermno(u32 vtermno
)
251 struct console
*cons
;
254 spin_lock_irqsave(&pdrvdata_lock
, flags
);
255 list_for_each_entry(cons
, &pdrvdata
.consoles
, list
) {
256 if (cons
->vtermno
== vtermno
) {
257 port
= container_of(cons
, struct port
, cons
);
263 spin_unlock_irqrestore(&pdrvdata_lock
, flags
);
267 static struct port
*find_port_by_devt_in_portdev(struct ports_device
*portdev
,
273 spin_lock_irqsave(&portdev
->ports_lock
, flags
);
274 list_for_each_entry(port
, &portdev
->ports
, list
)
275 if (port
->cdev
->dev
== dev
)
279 spin_unlock_irqrestore(&portdev
->ports_lock
, flags
);
284 static struct port
*find_port_by_devt(dev_t dev
)
286 struct ports_device
*portdev
;
290 spin_lock_irqsave(&pdrvdata_lock
, flags
);
291 list_for_each_entry(portdev
, &pdrvdata
.portdevs
, list
) {
292 port
= find_port_by_devt_in_portdev(portdev
, dev
);
298 spin_unlock_irqrestore(&pdrvdata_lock
, flags
);
302 static struct port
*find_port_by_id(struct ports_device
*portdev
, u32 id
)
307 spin_lock_irqsave(&portdev
->ports_lock
, flags
);
308 list_for_each_entry(port
, &portdev
->ports
, list
)
313 spin_unlock_irqrestore(&portdev
->ports_lock
, flags
);
318 static struct port
*find_port_by_vq(struct ports_device
*portdev
,
319 struct virtqueue
*vq
)
324 spin_lock_irqsave(&portdev
->ports_lock
, flags
);
325 list_for_each_entry(port
, &portdev
->ports
, list
)
326 if (port
->in_vq
== vq
|| port
->out_vq
== vq
)
330 spin_unlock_irqrestore(&portdev
->ports_lock
, flags
);
334 static bool is_console_port(struct port
*port
)
341 static bool is_rproc_serial(const struct virtio_device
*vdev
)
343 return is_rproc_enabled
&& vdev
->id
.device
== VIRTIO_ID_RPROC_SERIAL
;
346 static inline bool use_multiport(struct ports_device
*portdev
)
349 * This condition can be true when put_chars is called from
354 return portdev
->vdev
->features
[0] & (1 << VIRTIO_CONSOLE_F_MULTIPORT
);
357 static DEFINE_SPINLOCK(dma_bufs_lock
);
358 static LIST_HEAD(pending_free_dma_bufs
);
360 static void free_buf(struct port_buffer
*buf
, bool can_sleep
)
364 for (i
= 0; i
< buf
->sgpages
; i
++) {
365 struct page
*page
= sg_page(&buf
->sg
[i
]);
373 } else if (is_rproc_enabled
) {
376 /* dma_free_coherent requires interrupts to be enabled. */
378 /* queue up dma-buffers to be freed later */
379 spin_lock_irqsave(&dma_bufs_lock
, flags
);
380 list_add_tail(&buf
->list
, &pending_free_dma_bufs
);
381 spin_unlock_irqrestore(&dma_bufs_lock
, flags
);
384 dma_free_coherent(buf
->dev
, buf
->size
, buf
->buf
, buf
->dma
);
386 /* Release device refcnt and allow it to be freed */
387 put_device(buf
->dev
);
393 static void reclaim_dma_bufs(void)
396 struct port_buffer
*buf
, *tmp
;
399 if (list_empty(&pending_free_dma_bufs
))
402 /* Create a copy of the pending_free_dma_bufs while holding the lock */
403 spin_lock_irqsave(&dma_bufs_lock
, flags
);
404 list_cut_position(&tmp_list
, &pending_free_dma_bufs
,
405 pending_free_dma_bufs
.prev
);
406 spin_unlock_irqrestore(&dma_bufs_lock
, flags
);
408 /* Release the dma buffers, without irqs enabled */
409 list_for_each_entry_safe(buf
, tmp
, &tmp_list
, list
) {
410 list_del(&buf
->list
);
415 static struct port_buffer
*alloc_buf(struct virtqueue
*vq
, size_t buf_size
,
418 struct port_buffer
*buf
;
423 * Allocate buffer and the sg list. The sg list array is allocated
424 * directly after the port_buffer struct.
426 buf
= kmalloc(sizeof(*buf
) + sizeof(struct scatterlist
) * pages
,
431 buf
->sgpages
= pages
;
438 if (is_rproc_serial(vq
->vdev
)) {
440 * Allocate DMA memory from ancestor. When a virtio
441 * device is created by remoteproc, the DMA memory is
442 * associated with the grandparent device:
443 * vdev => rproc => platform-dev.
444 * The code here would have been less quirky if
445 * DMA_MEMORY_INCLUDES_CHILDREN had been supported
448 if (!vq
->vdev
->dev
.parent
|| !vq
->vdev
->dev
.parent
->parent
)
450 buf
->dev
= vq
->vdev
->dev
.parent
->parent
;
452 /* Increase device refcnt to avoid freeing it */
453 get_device(buf
->dev
);
454 buf
->buf
= dma_alloc_coherent(buf
->dev
, buf_size
, &buf
->dma
,
458 buf
->buf
= kmalloc(buf_size
, GFP_KERNEL
);
465 buf
->size
= buf_size
;
474 /* Callers should take appropriate locks */
475 static struct port_buffer
*get_inbuf(struct port
*port
)
477 struct port_buffer
*buf
;
483 buf
= virtqueue_get_buf(port
->in_vq
, &len
);
487 port
->stats
.bytes_received
+= len
;
493 * Create a scatter-gather list representing our input buffer and put
496 * Callers should take appropriate locks.
498 static int add_inbuf(struct virtqueue
*vq
, struct port_buffer
*buf
)
500 struct scatterlist sg
[1];
503 sg_init_one(sg
, buf
->buf
, buf
->size
);
505 ret
= virtqueue_add_buf(vq
, sg
, 0, 1, buf
, GFP_ATOMIC
);
512 /* Discard any unread data this port has. Callers lockers. */
513 static void discard_port_data(struct port
*port
)
515 struct port_buffer
*buf
;
518 if (!port
->portdev
) {
519 /* Device has been unplugged. vqs are already gone. */
522 buf
= get_inbuf(port
);
526 port
->stats
.bytes_discarded
+= buf
->len
- buf
->offset
;
527 if (add_inbuf(port
->in_vq
, buf
) < 0) {
529 free_buf(buf
, false);
532 buf
= get_inbuf(port
);
535 dev_warn(port
->dev
, "Errors adding %d buffers back to vq\n",
539 static bool port_has_data(struct port
*port
)
545 spin_lock_irqsave(&port
->inbuf_lock
, flags
);
546 port
->inbuf
= get_inbuf(port
);
550 spin_unlock_irqrestore(&port
->inbuf_lock
, flags
);
554 static ssize_t
__send_control_msg(struct ports_device
*portdev
, u32 port_id
,
555 unsigned int event
, unsigned int value
)
557 struct scatterlist sg
[1];
558 struct virtio_console_control cpkt
;
559 struct virtqueue
*vq
;
562 if (!use_multiport(portdev
))
571 sg_init_one(sg
, &cpkt
, sizeof(cpkt
));
572 if (virtqueue_add_buf(vq
, sg
, 1, 0, &cpkt
, GFP_ATOMIC
) == 0) {
574 while (!virtqueue_get_buf(vq
, &len
))
580 static ssize_t
send_control_msg(struct port
*port
, unsigned int event
,
583 /* Did the port get unplugged before userspace closed it? */
585 return __send_control_msg(port
->portdev
, port
->id
, event
, value
);
590 /* Callers must take the port->outvq_lock */
591 static void reclaim_consumed_buffers(struct port
*port
)
593 struct port_buffer
*buf
;
596 if (!port
->portdev
) {
597 /* Device has been unplugged. vqs are already gone. */
600 while ((buf
= virtqueue_get_buf(port
->out_vq
, &len
))) {
601 free_buf(buf
, false);
602 port
->outvq_full
= false;
606 static ssize_t
__send_to_port(struct port
*port
, struct scatterlist
*sg
,
607 int nents
, size_t in_count
,
608 void *data
, bool nonblock
)
610 struct virtqueue
*out_vq
;
615 out_vq
= port
->out_vq
;
617 spin_lock_irqsave(&port
->outvq_lock
, flags
);
619 reclaim_consumed_buffers(port
);
621 err
= virtqueue_add_buf(out_vq
, sg
, nents
, 0, data
, GFP_ATOMIC
);
623 /* Tell Host to go! */
624 virtqueue_kick(out_vq
);
631 if (out_vq
->num_free
== 0)
632 port
->outvq_full
= true;
638 * Wait till the host acknowledges it pushed out the data we
639 * sent. This is done for data from the hvc_console; the tty
640 * operations are performed with spinlocks held so we can't
641 * sleep here. An alternative would be to copy the data to a
642 * buffer and relax the spinning requirement. The downside is
643 * we need to kmalloc a GFP_ATOMIC buffer each time the
644 * console driver writes something out.
646 while (!virtqueue_get_buf(out_vq
, &len
))
649 spin_unlock_irqrestore(&port
->outvq_lock
, flags
);
651 port
->stats
.bytes_sent
+= in_count
;
653 * We're expected to return the amount of data we wrote -- all
660 * Give out the data that's requested from the buffer that we have
663 static ssize_t
fill_readbuf(struct port
*port
, char *out_buf
, size_t out_count
,
666 struct port_buffer
*buf
;
669 if (!out_count
|| !port_has_data(port
))
673 out_count
= min(out_count
, buf
->len
- buf
->offset
);
678 ret
= copy_to_user(out_buf
, buf
->buf
+ buf
->offset
, out_count
);
682 memcpy(out_buf
, buf
->buf
+ buf
->offset
, out_count
);
685 buf
->offset
+= out_count
;
687 if (buf
->offset
== buf
->len
) {
689 * We're done using all the data in this buffer.
690 * Re-queue so that the Host can send us more data.
692 spin_lock_irqsave(&port
->inbuf_lock
, flags
);
695 if (add_inbuf(port
->in_vq
, buf
) < 0)
696 dev_warn(port
->dev
, "failed add_buf\n");
698 spin_unlock_irqrestore(&port
->inbuf_lock
, flags
);
700 /* Return the number of bytes actually copied */
704 /* The condition that must be true for polling to end */
705 static bool will_read_block(struct port
*port
)
707 if (!port
->guest_connected
) {
708 /* Port got hot-unplugged. Let's exit. */
711 return !port_has_data(port
) && port
->host_connected
;
714 static bool will_write_block(struct port
*port
)
718 if (!port
->guest_connected
) {
719 /* Port got hot-unplugged. Let's exit. */
722 if (!port
->host_connected
)
725 spin_lock_irq(&port
->outvq_lock
);
727 * Check if the Host has consumed any buffers since we last
728 * sent data (this is only applicable for nonblocking ports).
730 reclaim_consumed_buffers(port
);
731 ret
= port
->outvq_full
;
732 spin_unlock_irq(&port
->outvq_lock
);
737 static ssize_t
port_fops_read(struct file
*filp
, char __user
*ubuf
,
738 size_t count
, loff_t
*offp
)
743 port
= filp
->private_data
;
745 if (!port_has_data(port
)) {
747 * If nothing's connected on the host just return 0 in
748 * case of list_empty; this tells the userspace app
749 * that there's no connection
751 if (!port
->host_connected
)
753 if (filp
->f_flags
& O_NONBLOCK
)
756 ret
= wait_event_freezable(port
->waitqueue
,
757 !will_read_block(port
));
761 /* Port got hot-unplugged. */
762 if (!port
->guest_connected
)
765 * We could've received a disconnection message while we were
766 * waiting for more data.
768 * This check is not clubbed in the if() statement above as we
769 * might receive some data as well as the host could get
770 * disconnected after we got woken up from our wait. So we
771 * really want to give off whatever data we have and only then
772 * check for host_connected.
774 if (!port_has_data(port
) && !port
->host_connected
)
777 return fill_readbuf(port
, ubuf
, count
, true);
780 static int wait_port_writable(struct port
*port
, bool nonblock
)
784 if (will_write_block(port
)) {
788 ret
= wait_event_freezable(port
->waitqueue
,
789 !will_write_block(port
));
793 /* Port got hot-unplugged. */
794 if (!port
->guest_connected
)
800 static ssize_t
port_fops_write(struct file
*filp
, const char __user
*ubuf
,
801 size_t count
, loff_t
*offp
)
804 struct port_buffer
*buf
;
807 struct scatterlist sg
[1];
809 /* Userspace could be out to fool us */
813 port
= filp
->private_data
;
815 nonblock
= filp
->f_flags
& O_NONBLOCK
;
817 ret
= wait_port_writable(port
, nonblock
);
821 count
= min((size_t)(32 * 1024), count
);
823 buf
= alloc_buf(port
->out_vq
, count
, 0);
827 ret
= copy_from_user(buf
->buf
, ubuf
, count
);
834 * We now ask send_buf() to not spin for generic ports -- we
835 * can re-use the same code path that non-blocking file
836 * descriptors take for blocking file descriptors since the
837 * wait is already done and we're certain the write will go
838 * through to the host.
841 sg_init_one(sg
, buf
->buf
, count
);
842 ret
= __send_to_port(port
, sg
, 1, count
, buf
, nonblock
);
844 if (nonblock
&& ret
> 0)
857 struct scatterlist
*sg
;
860 static int pipe_to_sg(struct pipe_inode_info
*pipe
, struct pipe_buffer
*buf
,
861 struct splice_desc
*sd
)
863 struct sg_list
*sgl
= sd
->u
.data
;
864 unsigned int offset
, len
;
866 if (sgl
->n
== sgl
->size
)
869 /* Try lock this page */
870 if (buf
->ops
->steal(pipe
, buf
) == 0) {
871 /* Get reference and unlock page for moving */
873 unlock_page(buf
->page
);
875 len
= min(buf
->len
, sd
->len
);
876 sg_set_page(&(sgl
->sg
[sgl
->n
]), buf
->page
, len
, buf
->offset
);
878 /* Failback to copying a page */
879 struct page
*page
= alloc_page(GFP_KERNEL
);
880 char *src
= buf
->ops
->map(pipe
, buf
, 1);
887 offset
= sd
->pos
& ~PAGE_MASK
;
890 if (len
+ offset
> PAGE_SIZE
)
891 len
= PAGE_SIZE
- offset
;
893 memcpy(dst
+ offset
, src
+ buf
->offset
, len
);
896 buf
->ops
->unmap(pipe
, buf
, src
);
898 sg_set_page(&(sgl
->sg
[sgl
->n
]), page
, len
, offset
);
906 /* Faster zero-copy write by splicing */
907 static ssize_t
port_fops_splice_write(struct pipe_inode_info
*pipe
,
908 struct file
*filp
, loff_t
*ppos
,
909 size_t len
, unsigned int flags
)
911 struct port
*port
= filp
->private_data
;
914 struct port_buffer
*buf
;
915 struct splice_desc sd
= {
923 * Rproc_serial does not yet support splice. To support splice
924 * pipe_to_sg() must allocate dma-buffers and copy content from
925 * regular pages to dma pages. And alloc_buf and free_buf must
926 * support allocating and freeing such a list of dma-buffers.
928 if (is_rproc_serial(port
->out_vq
->vdev
))
931 ret
= wait_port_writable(port
, filp
->f_flags
& O_NONBLOCK
);
935 buf
= alloc_buf(port
->out_vq
, 0, pipe
->nrbufs
);
941 sgl
.size
= pipe
->nrbufs
;
943 sg_init_table(sgl
.sg
, sgl
.size
);
944 ret
= __splice_from_pipe(pipe
, &sd
, pipe_to_sg
);
946 ret
= __send_to_port(port
, buf
->sg
, sgl
.n
, sgl
.len
, buf
, true);
948 if (unlikely(ret
<= 0))
953 static unsigned int port_fops_poll(struct file
*filp
, poll_table
*wait
)
958 port
= filp
->private_data
;
959 poll_wait(filp
, &port
->waitqueue
, wait
);
961 if (!port
->guest_connected
) {
962 /* Port got unplugged */
966 if (!will_read_block(port
))
967 ret
|= POLLIN
| POLLRDNORM
;
968 if (!will_write_block(port
))
970 if (!port
->host_connected
)
976 static void remove_port(struct kref
*kref
);
978 static int port_fops_release(struct inode
*inode
, struct file
*filp
)
982 port
= filp
->private_data
;
984 /* Notify host of port being closed */
985 send_control_msg(port
, VIRTIO_CONSOLE_PORT_OPEN
, 0);
987 spin_lock_irq(&port
->inbuf_lock
);
988 port
->guest_connected
= false;
990 discard_port_data(port
);
992 spin_unlock_irq(&port
->inbuf_lock
);
994 spin_lock_irq(&port
->outvq_lock
);
995 reclaim_consumed_buffers(port
);
996 spin_unlock_irq(&port
->outvq_lock
);
1000 * Locks aren't necessary here as a port can't be opened after
1001 * unplug, and if a port isn't unplugged, a kref would already
1002 * exist for the port. Plus, taking ports_lock here would
1003 * create a dependency on other locks taken by functions
1004 * inside remove_port if we're the last holder of the port,
1005 * creating many problems.
1007 kref_put(&port
->kref
, remove_port
);
1012 static int port_fops_open(struct inode
*inode
, struct file
*filp
)
1014 struct cdev
*cdev
= inode
->i_cdev
;
1018 port
= find_port_by_devt(cdev
->dev
);
1019 filp
->private_data
= port
;
1021 /* Prevent against a port getting hot-unplugged at the same time */
1022 spin_lock_irq(&port
->portdev
->ports_lock
);
1023 kref_get(&port
->kref
);
1024 spin_unlock_irq(&port
->portdev
->ports_lock
);
1027 * Don't allow opening of console port devices -- that's done
1030 if (is_console_port(port
)) {
1035 /* Allow only one process to open a particular port at a time */
1036 spin_lock_irq(&port
->inbuf_lock
);
1037 if (port
->guest_connected
) {
1038 spin_unlock_irq(&port
->inbuf_lock
);
1043 port
->guest_connected
= true;
1044 spin_unlock_irq(&port
->inbuf_lock
);
1046 spin_lock_irq(&port
->outvq_lock
);
1048 * There might be a chance that we missed reclaiming a few
1049 * buffers in the window of the port getting previously closed
1052 reclaim_consumed_buffers(port
);
1053 spin_unlock_irq(&port
->outvq_lock
);
1055 nonseekable_open(inode
, filp
);
1057 /* Notify host of port being opened */
1058 send_control_msg(filp
->private_data
, VIRTIO_CONSOLE_PORT_OPEN
, 1);
1062 kref_put(&port
->kref
, remove_port
);
1066 static int port_fops_fasync(int fd
, struct file
*filp
, int mode
)
1070 port
= filp
->private_data
;
1071 return fasync_helper(fd
, filp
, mode
, &port
->async_queue
);
1075 * The file operations that we support: programs in the guest can open
1076 * a console device, read from it, write to it, poll for data and
1077 * close it. The devices are at
1078 * /dev/vport<device number>p<port number>
1080 static const struct file_operations port_fops
= {
1081 .owner
= THIS_MODULE
,
1082 .open
= port_fops_open
,
1083 .read
= port_fops_read
,
1084 .write
= port_fops_write
,
1085 .splice_write
= port_fops_splice_write
,
1086 .poll
= port_fops_poll
,
1087 .release
= port_fops_release
,
1088 .fasync
= port_fops_fasync
,
1089 .llseek
= no_llseek
,
1093 * The put_chars() callback is pretty straightforward.
1095 * We turn the characters into a scatter-gather list, add it to the
1096 * output queue and then kick the Host. Then we sit here waiting for
1097 * it to finish: inefficient in theory, but in practice
1098 * implementations will do it immediately (lguest's Launcher does).
1100 static int put_chars(u32 vtermno
, const char *buf
, int count
)
1103 struct scatterlist sg
[1];
1105 if (unlikely(early_put_chars
))
1106 return early_put_chars(vtermno
, buf
, count
);
1108 port
= find_port_by_vtermno(vtermno
);
1112 sg_init_one(sg
, buf
, count
);
1113 return __send_to_port(port
, sg
, 1, count
, (void *)buf
, false);
1117 * get_chars() is the callback from the hvc_console infrastructure
1118 * when an interrupt is received.
1120 * We call out to fill_readbuf that gets us the required data from the
1121 * buffers that are queued up.
1123 static int get_chars(u32 vtermno
, char *buf
, int count
)
1127 /* If we've not set up the port yet, we have no input to give. */
1128 if (unlikely(early_put_chars
))
1131 port
= find_port_by_vtermno(vtermno
);
1135 /* If we don't have an input queue yet, we can't get input. */
1136 BUG_ON(!port
->in_vq
);
1138 return fill_readbuf(port
, buf
, count
, false);
1141 static void resize_console(struct port
*port
)
1143 struct virtio_device
*vdev
;
1145 /* The port could have been hot-unplugged */
1146 if (!port
|| !is_console_port(port
))
1149 vdev
= port
->portdev
->vdev
;
1151 /* Don't test F_SIZE at all if we're rproc: not a valid feature! */
1152 if (!is_rproc_serial(vdev
) &&
1153 virtio_has_feature(vdev
, VIRTIO_CONSOLE_F_SIZE
))
1154 hvc_resize(port
->cons
.hvc
, port
->cons
.ws
);
1157 /* We set the configuration at this point, since we now have a tty */
1158 static int notifier_add_vio(struct hvc_struct
*hp
, int data
)
1162 port
= find_port_by_vtermno(hp
->vtermno
);
1166 hp
->irq_requested
= 1;
1167 resize_console(port
);
1172 static void notifier_del_vio(struct hvc_struct
*hp
, int data
)
1174 hp
->irq_requested
= 0;
1177 /* The operations for console ports. */
1178 static const struct hv_ops hv_ops
= {
1179 .get_chars
= get_chars
,
1180 .put_chars
= put_chars
,
1181 .notifier_add
= notifier_add_vio
,
1182 .notifier_del
= notifier_del_vio
,
1183 .notifier_hangup
= notifier_del_vio
,
1187 * Console drivers are initialized very early so boot messages can go
1188 * out, so we do things slightly differently from the generic virtio
1189 * initialization of the net and block drivers.
1191 * At this stage, the console is output-only. It's too early to set
1192 * up a virtqueue, so we let the drivers do some boutique early-output
1195 int __init
virtio_cons_early_init(int (*put_chars
)(u32
, const char *, int))
1197 early_put_chars
= put_chars
;
1198 return hvc_instantiate(0, 0, &hv_ops
);
1201 int init_port_console(struct port
*port
)
1206 * The Host's telling us this port is a console port. Hook it
1207 * up with an hvc console.
1209 * To set up and manage our virtual console, we call
1212 * The first argument of hvc_alloc() is the virtual console
1213 * number. The second argument is the parameter for the
1214 * notification mechanism (like irq number). We currently
1215 * leave this as zero, virtqueues have implicit notifications.
1217 * The third argument is a "struct hv_ops" containing the
1218 * put_chars() get_chars(), notifier_add() and notifier_del()
1219 * pointers. The final argument is the output buffer size: we
1220 * can do any size, so we put PAGE_SIZE here.
1222 port
->cons
.vtermno
= pdrvdata
.next_vtermno
;
1224 port
->cons
.hvc
= hvc_alloc(port
->cons
.vtermno
, 0, &hv_ops
, PAGE_SIZE
);
1225 if (IS_ERR(port
->cons
.hvc
)) {
1226 ret
= PTR_ERR(port
->cons
.hvc
);
1228 "error %d allocating hvc for port\n", ret
);
1229 port
->cons
.hvc
= NULL
;
1232 spin_lock_irq(&pdrvdata_lock
);
1233 pdrvdata
.next_vtermno
++;
1234 list_add_tail(&port
->cons
.list
, &pdrvdata
.consoles
);
1235 spin_unlock_irq(&pdrvdata_lock
);
1236 port
->guest_connected
= true;
1239 * Start using the new console output if this is the first
1240 * console to come up.
1242 if (early_put_chars
)
1243 early_put_chars
= NULL
;
1245 /* Notify host of port being opened */
1246 send_control_msg(port
, VIRTIO_CONSOLE_PORT_OPEN
, 1);
1251 static ssize_t
show_port_name(struct device
*dev
,
1252 struct device_attribute
*attr
, char *buffer
)
1256 port
= dev_get_drvdata(dev
);
1258 return sprintf(buffer
, "%s\n", port
->name
);
1261 static DEVICE_ATTR(name
, S_IRUGO
, show_port_name
, NULL
);
1263 static struct attribute
*port_sysfs_entries
[] = {
1264 &dev_attr_name
.attr
,
1268 static struct attribute_group port_attribute_group
= {
1269 .name
= NULL
, /* put in device directory */
1270 .attrs
= port_sysfs_entries
,
1273 static ssize_t
debugfs_read(struct file
*filp
, char __user
*ubuf
,
1274 size_t count
, loff_t
*offp
)
1278 ssize_t ret
, out_offset
, out_count
;
1281 buf
= kmalloc(out_count
, GFP_KERNEL
);
1285 port
= filp
->private_data
;
1287 out_offset
+= snprintf(buf
+ out_offset
, out_count
,
1288 "name: %s\n", port
->name
? port
->name
: "");
1289 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1290 "guest_connected: %d\n", port
->guest_connected
);
1291 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1292 "host_connected: %d\n", port
->host_connected
);
1293 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1294 "outvq_full: %d\n", port
->outvq_full
);
1295 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1296 "bytes_sent: %lu\n", port
->stats
.bytes_sent
);
1297 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1298 "bytes_received: %lu\n",
1299 port
->stats
.bytes_received
);
1300 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1301 "bytes_discarded: %lu\n",
1302 port
->stats
.bytes_discarded
);
1303 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1305 is_console_port(port
) ? "yes" : "no");
1306 out_offset
+= snprintf(buf
+ out_offset
, out_count
- out_offset
,
1307 "console_vtermno: %u\n", port
->cons
.vtermno
);
1309 ret
= simple_read_from_buffer(ubuf
, count
, offp
, buf
, out_offset
);
1314 static const struct file_operations port_debugfs_ops
= {
1315 .owner
= THIS_MODULE
,
1316 .open
= simple_open
,
1317 .read
= debugfs_read
,
1320 static void set_console_size(struct port
*port
, u16 rows
, u16 cols
)
1322 if (!port
|| !is_console_port(port
))
1325 port
->cons
.ws
.ws_row
= rows
;
1326 port
->cons
.ws
.ws_col
= cols
;
1329 static unsigned int fill_queue(struct virtqueue
*vq
, spinlock_t
*lock
)
1331 struct port_buffer
*buf
;
1332 unsigned int nr_added_bufs
;
1337 buf
= alloc_buf(vq
, PAGE_SIZE
, 0);
1341 spin_lock_irq(lock
);
1342 ret
= add_inbuf(vq
, buf
);
1344 spin_unlock_irq(lock
);
1345 free_buf(buf
, true);
1349 spin_unlock_irq(lock
);
1352 return nr_added_bufs
;
1355 static void send_sigio_to_port(struct port
*port
)
1357 if (port
->async_queue
&& port
->guest_connected
)
1358 kill_fasync(&port
->async_queue
, SIGIO
, POLL_OUT
);
1361 static int add_port(struct ports_device
*portdev
, u32 id
)
1363 char debugfs_name
[16];
1365 struct port_buffer
*buf
;
1367 unsigned int nr_added_bufs
;
1370 port
= kmalloc(sizeof(*port
), GFP_KERNEL
);
1375 kref_init(&port
->kref
);
1377 port
->portdev
= portdev
;
1382 port
->cons
.hvc
= NULL
;
1383 port
->async_queue
= NULL
;
1385 port
->cons
.ws
.ws_row
= port
->cons
.ws
.ws_col
= 0;
1387 port
->host_connected
= port
->guest_connected
= false;
1388 port
->stats
= (struct port_stats
) { 0 };
1390 port
->outvq_full
= false;
1392 port
->in_vq
= portdev
->in_vqs
[port
->id
];
1393 port
->out_vq
= portdev
->out_vqs
[port
->id
];
1395 port
->cdev
= cdev_alloc();
1397 dev_err(&port
->portdev
->vdev
->dev
, "Error allocating cdev\n");
1401 port
->cdev
->ops
= &port_fops
;
1403 devt
= MKDEV(portdev
->chr_major
, id
);
1404 err
= cdev_add(port
->cdev
, devt
, 1);
1406 dev_err(&port
->portdev
->vdev
->dev
,
1407 "Error %d adding cdev for port %u\n", err
, id
);
1410 port
->dev
= device_create(pdrvdata
.class, &port
->portdev
->vdev
->dev
,
1411 devt
, port
, "vport%up%u",
1412 port
->portdev
->vdev
->index
, id
);
1413 if (IS_ERR(port
->dev
)) {
1414 err
= PTR_ERR(port
->dev
);
1415 dev_err(&port
->portdev
->vdev
->dev
,
1416 "Error %d creating device for port %u\n",
1421 spin_lock_init(&port
->inbuf_lock
);
1422 spin_lock_init(&port
->outvq_lock
);
1423 init_waitqueue_head(&port
->waitqueue
);
1425 /* Fill the in_vq with buffers so the host can send us data. */
1426 nr_added_bufs
= fill_queue(port
->in_vq
, &port
->inbuf_lock
);
1427 if (!nr_added_bufs
) {
1428 dev_err(port
->dev
, "Error allocating inbufs\n");
1433 if (is_rproc_serial(port
->portdev
->vdev
))
1435 * For rproc_serial assume remote processor is connected.
1436 * rproc_serial does not want the console port, only
1437 * the generic port implementation.
1439 port
->host_connected
= port
->guest_connected
= true;
1440 else if (!use_multiport(port
->portdev
)) {
1442 * If we're not using multiport support,
1443 * this has to be a console port.
1445 err
= init_port_console(port
);
1450 spin_lock_irq(&portdev
->ports_lock
);
1451 list_add_tail(&port
->list
, &port
->portdev
->ports
);
1452 spin_unlock_irq(&portdev
->ports_lock
);
1455 * Tell the Host we're set so that it can send us various
1456 * configuration parameters for this port (eg, port name,
1457 * caching, whether this is a console port, etc.)
1459 send_control_msg(port
, VIRTIO_CONSOLE_PORT_READY
, 1);
1461 if (pdrvdata
.debugfs_dir
) {
1463 * Finally, create the debugfs file that we can use to
1464 * inspect a port's state at any time
1466 sprintf(debugfs_name
, "vport%up%u",
1467 port
->portdev
->vdev
->index
, id
);
1468 port
->debugfs_file
= debugfs_create_file(debugfs_name
, 0444,
1469 pdrvdata
.debugfs_dir
,
1476 while ((buf
= virtqueue_detach_unused_buf(port
->in_vq
)))
1477 free_buf(buf
, true);
1479 device_destroy(pdrvdata
.class, port
->dev
->devt
);
1481 cdev_del(port
->cdev
);
1485 /* The host might want to notify management sw about port add failure */
1486 __send_control_msg(portdev
, id
, VIRTIO_CONSOLE_PORT_READY
, 0);
1490 /* No users remain, remove all port-specific data. */
1491 static void remove_port(struct kref
*kref
)
1495 port
= container_of(kref
, struct port
, kref
);
1497 sysfs_remove_group(&port
->dev
->kobj
, &port_attribute_group
);
1498 device_destroy(pdrvdata
.class, port
->dev
->devt
);
1499 cdev_del(port
->cdev
);
1503 debugfs_remove(port
->debugfs_file
);
1508 static void remove_port_data(struct port
*port
)
1510 struct port_buffer
*buf
;
1512 /* Remove unused data this port might have received. */
1513 discard_port_data(port
);
1515 reclaim_consumed_buffers(port
);
1517 /* Remove buffers we queued up for the Host to send us data in. */
1518 while ((buf
= virtqueue_detach_unused_buf(port
->in_vq
)))
1519 free_buf(buf
, true);
1521 /* Free pending buffers from the out-queue. */
1522 while ((buf
= virtqueue_detach_unused_buf(port
->out_vq
)))
1523 free_buf(buf
, true);
1527 * Port got unplugged. Remove port from portdev's list and drop the
1528 * kref reference. If no userspace has this port opened, it will
1529 * result in immediate removal the port.
1531 static void unplug_port(struct port
*port
)
1533 spin_lock_irq(&port
->portdev
->ports_lock
);
1534 list_del(&port
->list
);
1535 spin_unlock_irq(&port
->portdev
->ports_lock
);
1537 if (port
->guest_connected
) {
1538 port
->guest_connected
= false;
1539 port
->host_connected
= false;
1540 wake_up_interruptible(&port
->waitqueue
);
1542 /* Let the app know the port is going down. */
1543 send_sigio_to_port(port
);
1546 if (is_console_port(port
)) {
1547 spin_lock_irq(&pdrvdata_lock
);
1548 list_del(&port
->cons
.list
);
1549 spin_unlock_irq(&pdrvdata_lock
);
1550 hvc_remove(port
->cons
.hvc
);
1553 remove_port_data(port
);
1556 * We should just assume the device itself has gone off --
1557 * else a close on an open port later will try to send out a
1560 port
->portdev
= NULL
;
1563 * Locks around here are not necessary - a port can't be
1564 * opened after we removed the port struct from ports_list
1567 kref_put(&port
->kref
, remove_port
);
1570 /* Any private messages that the Host and Guest want to share */
1571 static void handle_control_message(struct ports_device
*portdev
,
1572 struct port_buffer
*buf
)
1574 struct virtio_console_control
*cpkt
;
1579 cpkt
= (struct virtio_console_control
*)(buf
->buf
+ buf
->offset
);
1581 port
= find_port_by_id(portdev
, cpkt
->id
);
1582 if (!port
&& cpkt
->event
!= VIRTIO_CONSOLE_PORT_ADD
) {
1583 /* No valid header at start of buffer. Drop it. */
1584 dev_dbg(&portdev
->vdev
->dev
,
1585 "Invalid index %u in control packet\n", cpkt
->id
);
1589 switch (cpkt
->event
) {
1590 case VIRTIO_CONSOLE_PORT_ADD
:
1592 dev_dbg(&portdev
->vdev
->dev
,
1593 "Port %u already added\n", port
->id
);
1594 send_control_msg(port
, VIRTIO_CONSOLE_PORT_READY
, 1);
1597 if (cpkt
->id
>= portdev
->config
.max_nr_ports
) {
1598 dev_warn(&portdev
->vdev
->dev
,
1599 "Request for adding port with out-of-bound id %u, max. supported id: %u\n",
1600 cpkt
->id
, portdev
->config
.max_nr_ports
- 1);
1603 add_port(portdev
, cpkt
->id
);
1605 case VIRTIO_CONSOLE_PORT_REMOVE
:
1608 case VIRTIO_CONSOLE_CONSOLE_PORT
:
1611 if (is_console_port(port
))
1614 init_port_console(port
);
1615 complete(&early_console_added
);
1617 * Could remove the port here in case init fails - but
1618 * have to notify the host first.
1621 case VIRTIO_CONSOLE_RESIZE
: {
1627 if (!is_console_port(port
))
1630 memcpy(&size
, buf
->buf
+ buf
->offset
+ sizeof(*cpkt
),
1632 set_console_size(port
, size
.rows
, size
.cols
);
1634 port
->cons
.hvc
->irq_requested
= 1;
1635 resize_console(port
);
1638 case VIRTIO_CONSOLE_PORT_OPEN
:
1639 port
->host_connected
= cpkt
->value
;
1640 wake_up_interruptible(&port
->waitqueue
);
1642 * If the host port got closed and the host had any
1643 * unconsumed buffers, we'll be able to reclaim them
1646 spin_lock_irq(&port
->outvq_lock
);
1647 reclaim_consumed_buffers(port
);
1648 spin_unlock_irq(&port
->outvq_lock
);
1651 * If the guest is connected, it'll be interested in
1652 * knowing the host connection state changed.
1654 send_sigio_to_port(port
);
1656 case VIRTIO_CONSOLE_PORT_NAME
:
1658 * If we woke up after hibernation, we can get this
1659 * again. Skip it in that case.
1665 * Skip the size of the header and the cpkt to get the size
1666 * of the name that was sent
1668 name_size
= buf
->len
- buf
->offset
- sizeof(*cpkt
) + 1;
1670 port
->name
= kmalloc(name_size
, GFP_KERNEL
);
1673 "Not enough space to store port name\n");
1676 strncpy(port
->name
, buf
->buf
+ buf
->offset
+ sizeof(*cpkt
),
1678 port
->name
[name_size
- 1] = 0;
1681 * Since we only have one sysfs attribute, 'name',
1682 * create it only if we have a name for the port.
1684 err
= sysfs_create_group(&port
->dev
->kobj
,
1685 &port_attribute_group
);
1688 "Error %d creating sysfs device attributes\n",
1692 * Generate a udev event so that appropriate
1693 * symlinks can be created based on udev
1696 kobject_uevent(&port
->dev
->kobj
, KOBJ_CHANGE
);
1702 static void control_work_handler(struct work_struct
*work
)
1704 struct ports_device
*portdev
;
1705 struct virtqueue
*vq
;
1706 struct port_buffer
*buf
;
1709 portdev
= container_of(work
, struct ports_device
, control_work
);
1710 vq
= portdev
->c_ivq
;
1712 spin_lock(&portdev
->cvq_lock
);
1713 while ((buf
= virtqueue_get_buf(vq
, &len
))) {
1714 spin_unlock(&portdev
->cvq_lock
);
1719 handle_control_message(portdev
, buf
);
1721 spin_lock(&portdev
->cvq_lock
);
1722 if (add_inbuf(portdev
->c_ivq
, buf
) < 0) {
1723 dev_warn(&portdev
->vdev
->dev
,
1724 "Error adding buffer to queue\n");
1725 free_buf(buf
, false);
1728 spin_unlock(&portdev
->cvq_lock
);
1731 static void out_intr(struct virtqueue
*vq
)
1735 port
= find_port_by_vq(vq
->vdev
->priv
, vq
);
1739 wake_up_interruptible(&port
->waitqueue
);
1742 static void in_intr(struct virtqueue
*vq
)
1745 unsigned long flags
;
1747 port
= find_port_by_vq(vq
->vdev
->priv
, vq
);
1751 spin_lock_irqsave(&port
->inbuf_lock
, flags
);
1752 port
->inbuf
= get_inbuf(port
);
1755 * Don't queue up data when port is closed. This condition
1756 * can be reached when a console port is not yet connected (no
1757 * tty is spawned) and the host sends out data to console
1758 * ports. For generic serial ports, the host won't
1759 * (shouldn't) send data till the guest is connected.
1761 if (!port
->guest_connected
)
1762 discard_port_data(port
);
1764 spin_unlock_irqrestore(&port
->inbuf_lock
, flags
);
1766 wake_up_interruptible(&port
->waitqueue
);
1768 /* Send a SIGIO indicating new data in case the process asked for it */
1769 send_sigio_to_port(port
);
1771 if (is_console_port(port
) && hvc_poll(port
->cons
.hvc
))
1775 static void control_intr(struct virtqueue
*vq
)
1777 struct ports_device
*portdev
;
1779 portdev
= vq
->vdev
->priv
;
1780 schedule_work(&portdev
->control_work
);
1783 static void config_intr(struct virtio_device
*vdev
)
1785 struct ports_device
*portdev
;
1787 portdev
= vdev
->priv
;
1789 if (!use_multiport(portdev
)) {
1793 vdev
->config
->get(vdev
,
1794 offsetof(struct virtio_console_config
, cols
),
1795 &cols
, sizeof(u16
));
1796 vdev
->config
->get(vdev
,
1797 offsetof(struct virtio_console_config
, rows
),
1798 &rows
, sizeof(u16
));
1800 port
= find_port_by_id(portdev
, 0);
1801 set_console_size(port
, rows
, cols
);
1804 * We'll use this way of resizing only for legacy
1805 * support. For newer userspace
1806 * (VIRTIO_CONSOLE_F_MULTPORT+), use control messages
1807 * to indicate console size changes so that it can be
1810 resize_console(port
);
1814 static int init_vqs(struct ports_device
*portdev
)
1816 vq_callback_t
**io_callbacks
;
1818 struct virtqueue
**vqs
;
1819 u32 i
, j
, nr_ports
, nr_queues
;
1822 nr_ports
= portdev
->config
.max_nr_ports
;
1823 nr_queues
= use_multiport(portdev
) ? (nr_ports
+ 1) * 2 : 2;
1825 vqs
= kmalloc(nr_queues
* sizeof(struct virtqueue
*), GFP_KERNEL
);
1826 io_callbacks
= kmalloc(nr_queues
* sizeof(vq_callback_t
*), GFP_KERNEL
);
1827 io_names
= kmalloc(nr_queues
* sizeof(char *), GFP_KERNEL
);
1828 portdev
->in_vqs
= kmalloc(nr_ports
* sizeof(struct virtqueue
*),
1830 portdev
->out_vqs
= kmalloc(nr_ports
* sizeof(struct virtqueue
*),
1832 if (!vqs
|| !io_callbacks
|| !io_names
|| !portdev
->in_vqs
||
1833 !portdev
->out_vqs
) {
1839 * For backward compat (newer host but older guest), the host
1840 * spawns a console port first and also inits the vqs for port
1844 io_callbacks
[j
] = in_intr
;
1845 io_callbacks
[j
+ 1] = out_intr
;
1846 io_names
[j
] = "input";
1847 io_names
[j
+ 1] = "output";
1850 if (use_multiport(portdev
)) {
1851 io_callbacks
[j
] = control_intr
;
1852 io_callbacks
[j
+ 1] = NULL
;
1853 io_names
[j
] = "control-i";
1854 io_names
[j
+ 1] = "control-o";
1856 for (i
= 1; i
< nr_ports
; i
++) {
1858 io_callbacks
[j
] = in_intr
;
1859 io_callbacks
[j
+ 1] = out_intr
;
1860 io_names
[j
] = "input";
1861 io_names
[j
+ 1] = "output";
1864 /* Find the queues. */
1865 err
= portdev
->vdev
->config
->find_vqs(portdev
->vdev
, nr_queues
, vqs
,
1867 (const char **)io_names
);
1872 portdev
->in_vqs
[0] = vqs
[0];
1873 portdev
->out_vqs
[0] = vqs
[1];
1875 if (use_multiport(portdev
)) {
1876 portdev
->c_ivq
= vqs
[j
];
1877 portdev
->c_ovq
= vqs
[j
+ 1];
1879 for (i
= 1; i
< nr_ports
; i
++) {
1881 portdev
->in_vqs
[i
] = vqs
[j
];
1882 portdev
->out_vqs
[i
] = vqs
[j
+ 1];
1886 kfree(io_callbacks
);
1892 kfree(portdev
->out_vqs
);
1893 kfree(portdev
->in_vqs
);
1895 kfree(io_callbacks
);
1901 static const struct file_operations portdev_fops
= {
1902 .owner
= THIS_MODULE
,
1905 static void remove_vqs(struct ports_device
*portdev
)
1907 portdev
->vdev
->config
->del_vqs(portdev
->vdev
);
1908 kfree(portdev
->in_vqs
);
1909 kfree(portdev
->out_vqs
);
1912 static void remove_controlq_data(struct ports_device
*portdev
)
1914 struct port_buffer
*buf
;
1917 if (!use_multiport(portdev
))
1920 while ((buf
= virtqueue_get_buf(portdev
->c_ivq
, &len
)))
1921 free_buf(buf
, true);
1923 while ((buf
= virtqueue_detach_unused_buf(portdev
->c_ivq
)))
1924 free_buf(buf
, true);
1928 * Once we're further in boot, we get probed like any other virtio
1931 * If the host also supports multiple console ports, we check the
1932 * config space to see how many ports the host has spawned. We
1933 * initialize each port found.
1935 static int virtcons_probe(struct virtio_device
*vdev
)
1937 struct ports_device
*portdev
;
1940 bool early
= early_put_chars
!= NULL
;
1942 /* Ensure to read early_put_chars now */
1945 portdev
= kmalloc(sizeof(*portdev
), GFP_KERNEL
);
1951 /* Attach this portdev to this virtio_device, and vice-versa. */
1952 portdev
->vdev
= vdev
;
1953 vdev
->priv
= portdev
;
1955 portdev
->chr_major
= register_chrdev(0, "virtio-portsdev",
1957 if (portdev
->chr_major
< 0) {
1959 "Error %d registering chrdev for device %u\n",
1960 portdev
->chr_major
, vdev
->index
);
1961 err
= portdev
->chr_major
;
1966 portdev
->config
.max_nr_ports
= 1;
1968 /* Don't test MULTIPORT at all if we're rproc: not a valid feature! */
1969 if (!is_rproc_serial(vdev
) &&
1970 virtio_config_val(vdev
, VIRTIO_CONSOLE_F_MULTIPORT
,
1971 offsetof(struct virtio_console_config
,
1973 &portdev
->config
.max_nr_ports
) == 0) {
1977 err
= init_vqs(portdev
);
1979 dev_err(&vdev
->dev
, "Error %d initializing vqs\n", err
);
1983 spin_lock_init(&portdev
->ports_lock
);
1984 INIT_LIST_HEAD(&portdev
->ports
);
1987 unsigned int nr_added_bufs
;
1989 spin_lock_init(&portdev
->cvq_lock
);
1990 INIT_WORK(&portdev
->control_work
, &control_work_handler
);
1992 nr_added_bufs
= fill_queue(portdev
->c_ivq
, &portdev
->cvq_lock
);
1993 if (!nr_added_bufs
) {
1995 "Error allocating buffers for control queue\n");
2001 * For backward compatibility: Create a console port
2002 * if we're running on older host.
2004 add_port(portdev
, 0);
2007 spin_lock_irq(&pdrvdata_lock
);
2008 list_add_tail(&portdev
->list
, &pdrvdata
.portdevs
);
2009 spin_unlock_irq(&pdrvdata_lock
);
2011 __send_control_msg(portdev
, VIRTIO_CONSOLE_BAD_ID
,
2012 VIRTIO_CONSOLE_DEVICE_READY
, 1);
2015 * If there was an early virtio console, assume that there are no
2016 * other consoles. We need to wait until the hvc_alloc matches the
2017 * hvc_instantiate, otherwise tty_open will complain, resulting in
2018 * a "Warning: unable to open an initial console" boot failure.
2019 * Without multiport this is done in add_port above. With multiport
2020 * this might take some host<->guest communication - thus we have to
2023 if (multiport
&& early
)
2024 wait_for_completion(&early_console_added
);
2029 /* The host might want to notify mgmt sw about device add failure */
2030 __send_control_msg(portdev
, VIRTIO_CONSOLE_BAD_ID
,
2031 VIRTIO_CONSOLE_DEVICE_READY
, 0);
2032 remove_vqs(portdev
);
2034 unregister_chrdev(portdev
->chr_major
, "virtio-portsdev");
2041 static void virtcons_remove(struct virtio_device
*vdev
)
2043 struct ports_device
*portdev
;
2044 struct port
*port
, *port2
;
2046 portdev
= vdev
->priv
;
2048 spin_lock_irq(&pdrvdata_lock
);
2049 list_del(&portdev
->list
);
2050 spin_unlock_irq(&pdrvdata_lock
);
2052 /* Disable interrupts for vqs */
2053 vdev
->config
->reset(vdev
);
2054 /* Finish up work that's lined up */
2055 if (use_multiport(portdev
))
2056 cancel_work_sync(&portdev
->control_work
);
2058 list_for_each_entry_safe(port
, port2
, &portdev
->ports
, list
)
2061 unregister_chrdev(portdev
->chr_major
, "virtio-portsdev");
2064 * When yanking out a device, we immediately lose the
2065 * (device-side) queues. So there's no point in keeping the
2066 * guest side around till we drop our final reference. This
2067 * also means that any ports which are in an open state will
2068 * have to just stop using the port, as the vqs are going
2071 remove_controlq_data(portdev
);
2072 remove_vqs(portdev
);
2076 static struct virtio_device_id id_table
[] = {
2077 { VIRTIO_ID_CONSOLE
, VIRTIO_DEV_ANY_ID
},
2081 static unsigned int features
[] = {
2082 VIRTIO_CONSOLE_F_SIZE
,
2083 VIRTIO_CONSOLE_F_MULTIPORT
,
2086 static struct virtio_device_id rproc_serial_id_table
[] = {
2087 #if IS_ENABLED(CONFIG_REMOTEPROC)
2088 { VIRTIO_ID_RPROC_SERIAL
, VIRTIO_DEV_ANY_ID
},
2093 static unsigned int rproc_serial_features
[] = {
2097 static int virtcons_freeze(struct virtio_device
*vdev
)
2099 struct ports_device
*portdev
;
2102 portdev
= vdev
->priv
;
2104 vdev
->config
->reset(vdev
);
2106 virtqueue_disable_cb(portdev
->c_ivq
);
2107 cancel_work_sync(&portdev
->control_work
);
2109 * Once more: if control_work_handler() was running, it would
2110 * enable the cb as the last step.
2112 virtqueue_disable_cb(portdev
->c_ivq
);
2113 remove_controlq_data(portdev
);
2115 list_for_each_entry(port
, &portdev
->ports
, list
) {
2116 virtqueue_disable_cb(port
->in_vq
);
2117 virtqueue_disable_cb(port
->out_vq
);
2119 * We'll ask the host later if the new invocation has
2120 * the port opened or closed.
2122 port
->host_connected
= false;
2123 remove_port_data(port
);
2125 remove_vqs(portdev
);
2130 static int virtcons_restore(struct virtio_device
*vdev
)
2132 struct ports_device
*portdev
;
2136 portdev
= vdev
->priv
;
2138 ret
= init_vqs(portdev
);
2142 if (use_multiport(portdev
))
2143 fill_queue(portdev
->c_ivq
, &portdev
->cvq_lock
);
2145 list_for_each_entry(port
, &portdev
->ports
, list
) {
2146 port
->in_vq
= portdev
->in_vqs
[port
->id
];
2147 port
->out_vq
= portdev
->out_vqs
[port
->id
];
2149 fill_queue(port
->in_vq
, &port
->inbuf_lock
);
2151 /* Get port open/close status on the host */
2152 send_control_msg(port
, VIRTIO_CONSOLE_PORT_READY
, 1);
2155 * If a port was open at the time of suspending, we
2156 * have to let the host know that it's still open.
2158 if (port
->guest_connected
)
2159 send_control_msg(port
, VIRTIO_CONSOLE_PORT_OPEN
, 1);
2165 static struct virtio_driver virtio_console
= {
2166 .feature_table
= features
,
2167 .feature_table_size
= ARRAY_SIZE(features
),
2168 .driver
.name
= KBUILD_MODNAME
,
2169 .driver
.owner
= THIS_MODULE
,
2170 .id_table
= id_table
,
2171 .probe
= virtcons_probe
,
2172 .remove
= virtcons_remove
,
2173 .config_changed
= config_intr
,
2175 .freeze
= virtcons_freeze
,
2176 .restore
= virtcons_restore
,
2180 static struct virtio_driver virtio_rproc_serial
= {
2181 .feature_table
= rproc_serial_features
,
2182 .feature_table_size
= ARRAY_SIZE(rproc_serial_features
),
2183 .driver
.name
= "virtio_rproc_serial",
2184 .driver
.owner
= THIS_MODULE
,
2185 .id_table
= rproc_serial_id_table
,
2186 .probe
= virtcons_probe
,
2187 .remove
= virtcons_remove
,
2190 static int __init
init(void)
2194 pdrvdata
.class = class_create(THIS_MODULE
, "virtio-ports");
2195 if (IS_ERR(pdrvdata
.class)) {
2196 err
= PTR_ERR(pdrvdata
.class);
2197 pr_err("Error %d creating virtio-ports class\n", err
);
2201 pdrvdata
.debugfs_dir
= debugfs_create_dir("virtio-ports", NULL
);
2202 if (!pdrvdata
.debugfs_dir
) {
2203 pr_warning("Error %ld creating debugfs dir for virtio-ports\n",
2204 PTR_ERR(pdrvdata
.debugfs_dir
));
2206 INIT_LIST_HEAD(&pdrvdata
.consoles
);
2207 INIT_LIST_HEAD(&pdrvdata
.portdevs
);
2209 err
= register_virtio_driver(&virtio_console
);
2211 pr_err("Error %d registering virtio driver\n", err
);
2214 err
= register_virtio_driver(&virtio_rproc_serial
);
2216 pr_err("Error %d registering virtio rproc serial driver\n",
2222 unregister_virtio_driver(&virtio_console
);
2224 if (pdrvdata
.debugfs_dir
)
2225 debugfs_remove_recursive(pdrvdata
.debugfs_dir
);
2226 class_destroy(pdrvdata
.class);
2230 static void __exit
fini(void)
2234 unregister_virtio_driver(&virtio_console
);
2235 unregister_virtio_driver(&virtio_rproc_serial
);
2237 class_destroy(pdrvdata
.class);
2238 if (pdrvdata
.debugfs_dir
)
2239 debugfs_remove_recursive(pdrvdata
.debugfs_dir
);
2244 MODULE_DEVICE_TABLE(virtio
, id_table
);
2245 MODULE_DESCRIPTION("Virtio console driver");
2246 MODULE_LICENSE("GPL");