1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2006, 2007, 2009 Rusty Russell, IBM Corporation
4 * Copyright (C) 2009, 2010, 2011 Red Hat, Inc.
5 * Copyright (C) 2009, 2010, 2011 Amit Shah <amit.shah@redhat.com>
7 #include <linux/cdev.h>
8 #include <linux/debugfs.h>
9 #include <linux/completion.h>
10 #include <linux/device.h>
11 #include <linux/err.h>
12 #include <linux/freezer.h>
14 #include <linux/splice.h>
15 #include <linux/pagemap.h>
16 #include <linux/idr.h>
17 #include <linux/init.h>
18 #include <linux/list.h>
19 #include <linux/poll.h>
20 #include <linux/sched.h>
21 #include <linux/slab.h>
22 #include <linux/spinlock.h>
23 #include <linux/virtio.h>
24 #include <linux/virtio_console.h>
25 #include <linux/wait.h>
26 #include <linux/workqueue.h>
27 #include <linux/module.h>
28 #include <linux/dma-mapping.h>
29 #include "../tty/hvc/hvc_console.h"
31 #define is_rproc_enabled IS_ENABLED(CONFIG_REMOTEPROC)
32 #define VIRTCONS_MAX_PORTS 0x8000
35 * This is a global struct for storing common data for all the devices
36 * this driver handles.
38 * Mainly, it has a linked list for all the consoles in one place so
39 * that callbacks from hvc for get_chars(), put_chars() work properly
40 * across multiple devices and multiple ports per device.
42 struct ports_driver_data
{
43 /* Used for exporting per-port information to debugfs */
44 struct dentry
*debugfs_dir
;
46 /* List of all the devices we're handling */
47 struct list_head portdevs
;
49 /* All the console devices handled by this driver */
50 struct list_head consoles
;
53 static struct ports_driver_data pdrvdata
;
55 static const struct class port_class
= {
56 .name
= "virtio-ports",
59 static DEFINE_SPINLOCK(pdrvdata_lock
);
60 static DECLARE_COMPLETION(early_console_added
);
62 /* This struct holds information that's relevant only for console ports */
64 /* We'll place all consoles in a list in the pdrvdata struct */
65 struct list_head list
;
67 /* The hvc device associated with this console port */
68 struct hvc_struct
*hvc
;
70 /* The size of the console */
74 * This number identifies the number that we used to register
75 * with hvc in hvc_instantiate() and hvc_alloc(); this is the
76 * number passed on by the hvc callbacks to us to
77 * differentiate between the other console ports handled by
83 static DEFINE_IDA(vtermno_ida
);
88 /* size of the buffer in *buf above */
91 /* used length of the buffer */
93 /* offset in the buf from which to consume data */
96 /* DMA address of buffer */
99 /* Device we got DMA memory from */
102 /* List of pending dma buffers to free */
103 struct list_head list
;
105 /* If sgpages == 0 then buf is used */
106 unsigned int sgpages
;
108 /* sg is used if spages > 0. sg must be the last in is struct */
109 struct scatterlist sg
[] __counted_by(sgpages
);
113 * This is a per-device struct that stores data common to all the
114 * ports for that device (vdev->priv).
116 struct ports_device
{
117 /* Next portdev in the list, head is in the pdrvdata struct */
118 struct list_head list
;
121 * Workqueue handlers where we process deferred work after
124 struct work_struct control_work
;
125 struct work_struct config_work
;
127 struct list_head ports
;
129 /* To protect the list of ports */
130 spinlock_t ports_lock
;
132 /* To protect the vq operations for the control channel */
133 spinlock_t c_ivq_lock
;
134 spinlock_t c_ovq_lock
;
136 /* max. number of ports this device can hold */
139 /* The virtio device we're associated with */
140 struct virtio_device
*vdev
;
143 * A couple of virtqueues for the control channel: one for
144 * guest->host transfers, one for host->guest transfers
146 struct virtqueue
*c_ivq
, *c_ovq
;
149 * A control packet buffer for guest->host requests, protected
152 struct virtio_console_control cpkt
;
154 /* Array of per-port IO virtqueues */
155 struct virtqueue
**in_vqs
, **out_vqs
;
157 /* Major number for this device. Ports will be created as minors. */
162 unsigned long bytes_sent
, bytes_received
, bytes_discarded
;
165 /* This struct holds the per-port data */
167 /* Next port in the list, head is in the ports_device */
168 struct list_head list
;
170 /* Pointer to the parent virtio_console device */
171 struct ports_device
*portdev
;
173 /* The current buffer from which data has to be fed to readers */
174 struct port_buffer
*inbuf
;
177 * To protect the operations on the in_vq associated with this
178 * port. Has to be a spinlock because it can be called from
179 * interrupt context (get_char()).
181 spinlock_t inbuf_lock
;
183 /* Protect the operations on the out_vq. */
184 spinlock_t outvq_lock
;
186 /* The IO vqs for this port */
187 struct virtqueue
*in_vq
, *out_vq
;
189 /* File in the debugfs directory that exposes this port's information */
190 struct dentry
*debugfs_file
;
193 * Keep count of the bytes sent, received and discarded for
194 * this port for accounting and debugging purposes. These
195 * counts are not reset across port open / close events.
197 struct port_stats stats
;
200 * The entries in this struct will be valid if this port is
201 * hooked up to an hvc console
205 /* Each port associates with a separate char device */
209 /* Reference-counting to handle port hot-unplugs and file operations */
212 /* A waitqueue for poll() or blocking read operations */
213 wait_queue_head_t waitqueue
;
215 /* The 'name' of the port that we expose via sysfs properties */
218 /* We can notify apps of host connect / disconnect events via SIGIO */
219 struct fasync_struct
*async_queue
;
221 /* The 'id' to identify the port with the Host */
226 /* Is the host device open */
229 /* We should allow only one process to open a port */
230 bool guest_connected
;
233 static struct port
*find_port_by_vtermno(u32 vtermno
)
236 struct console
*cons
;
239 spin_lock_irqsave(&pdrvdata_lock
, flags
);
240 list_for_each_entry(cons
, &pdrvdata
.consoles
, list
) {
241 if (cons
->vtermno
== vtermno
) {
242 port
= container_of(cons
, struct port
, cons
);
248 spin_unlock_irqrestore(&pdrvdata_lock
, flags
);
252 static struct port
*find_port_by_devt_in_portdev(struct ports_device
*portdev
,
258 spin_lock_irqsave(&portdev
->ports_lock
, flags
);
259 list_for_each_entry(port
, &portdev
->ports
, list
) {
260 if (port
->cdev
->dev
== dev
) {
261 kref_get(&port
->kref
);
267 spin_unlock_irqrestore(&portdev
->ports_lock
, flags
);
272 static struct port
*find_port_by_devt(dev_t dev
)
274 struct ports_device
*portdev
;
278 spin_lock_irqsave(&pdrvdata_lock
, flags
);
279 list_for_each_entry(portdev
, &pdrvdata
.portdevs
, list
) {
280 port
= find_port_by_devt_in_portdev(portdev
, dev
);
286 spin_unlock_irqrestore(&pdrvdata_lock
, flags
);
290 static struct port
*find_port_by_id(struct ports_device
*portdev
, u32 id
)
295 spin_lock_irqsave(&portdev
->ports_lock
, flags
);
296 list_for_each_entry(port
, &portdev
->ports
, list
)
301 spin_unlock_irqrestore(&portdev
->ports_lock
, flags
);
306 static struct port
*find_port_by_vq(struct ports_device
*portdev
,
307 struct virtqueue
*vq
)
312 spin_lock_irqsave(&portdev
->ports_lock
, flags
);
313 list_for_each_entry(port
, &portdev
->ports
, list
)
314 if (port
->in_vq
== vq
|| port
->out_vq
== vq
)
318 spin_unlock_irqrestore(&portdev
->ports_lock
, flags
);
322 static bool is_console_port(struct port
*port
)
329 static bool is_rproc_serial(const struct virtio_device
*vdev
)
331 return is_rproc_enabled
&& vdev
->id
.device
== VIRTIO_ID_RPROC_SERIAL
;
334 static inline bool use_multiport(struct ports_device
*portdev
)
337 * This condition can be true when put_chars is called from
342 return __virtio_test_bit(portdev
->vdev
, VIRTIO_CONSOLE_F_MULTIPORT
);
345 static DEFINE_SPINLOCK(dma_bufs_lock
);
346 static LIST_HEAD(pending_free_dma_bufs
);
348 static void free_buf(struct port_buffer
*buf
, bool can_sleep
)
352 for (i
= 0; i
< buf
->sgpages
; i
++) {
353 struct page
*page
= sg_page(&buf
->sg
[i
]);
361 } else if (is_rproc_enabled
) {
364 /* dma_free_coherent requires interrupts to be enabled. */
366 /* queue up dma-buffers to be freed later */
367 spin_lock_irqsave(&dma_bufs_lock
, flags
);
368 list_add_tail(&buf
->list
, &pending_free_dma_bufs
);
369 spin_unlock_irqrestore(&dma_bufs_lock
, flags
);
372 dma_free_coherent(buf
->dev
, buf
->size
, buf
->buf
, buf
->dma
);
374 /* Release device refcnt and allow it to be freed */
375 put_device(buf
->dev
);
381 static void reclaim_dma_bufs(void)
384 struct port_buffer
*buf
, *tmp
;
387 if (list_empty(&pending_free_dma_bufs
))
390 /* Create a copy of the pending_free_dma_bufs while holding the lock */
391 spin_lock_irqsave(&dma_bufs_lock
, flags
);
392 list_cut_position(&tmp_list
, &pending_free_dma_bufs
,
393 pending_free_dma_bufs
.prev
);
394 spin_unlock_irqrestore(&dma_bufs_lock
, flags
);
396 /* Release the dma buffers, without irqs enabled */
397 list_for_each_entry_safe(buf
, tmp
, &tmp_list
, list
) {
398 list_del(&buf
->list
);
403 static struct port_buffer
*alloc_buf(struct virtio_device
*vdev
, size_t buf_size
,
406 struct port_buffer
*buf
;
411 * Allocate buffer and the sg list. The sg list array is allocated
412 * directly after the port_buffer struct.
414 buf
= kmalloc(struct_size(buf
, sg
, pages
), GFP_KERNEL
);
418 buf
->sgpages
= pages
;
425 if (is_rproc_serial(vdev
)) {
427 * Allocate DMA memory from ancestor. When a virtio
428 * device is created by remoteproc, the DMA memory is
429 * associated with the parent device:
430 * virtioY => remoteprocX#vdevYbuffer.
432 buf
->dev
= vdev
->dev
.parent
;
436 /* Increase device refcnt to avoid freeing it */
437 get_device(buf
->dev
);
438 buf
->buf
= dma_alloc_coherent(buf
->dev
, buf_size
, &buf
->dma
,
442 buf
->buf
= kmalloc(buf_size
, GFP_KERNEL
);
449 buf
->size
= buf_size
;
458 /* Callers should take appropriate locks */
459 static struct port_buffer
*get_inbuf(struct port
*port
)
461 struct port_buffer
*buf
;
467 buf
= virtqueue_get_buf(port
->in_vq
, &len
);
469 buf
->len
= min_t(size_t, len
, buf
->size
);
471 port
->stats
.bytes_received
+= len
;
477 * Create a scatter-gather list representing our input buffer and put
480 * Callers should take appropriate locks.
482 static int add_inbuf(struct virtqueue
*vq
, struct port_buffer
*buf
)
484 struct scatterlist sg
[1];
487 sg_init_one(sg
, buf
->buf
, buf
->size
);
489 ret
= virtqueue_add_inbuf(vq
, sg
, 1, buf
, GFP_ATOMIC
);
496 /* Discard any unread data this port has. Callers lockers. */
497 static void discard_port_data(struct port
*port
)
499 struct port_buffer
*buf
;
502 if (!port
->portdev
) {
503 /* Device has been unplugged. vqs are already gone. */
506 buf
= get_inbuf(port
);
510 port
->stats
.bytes_discarded
+= buf
->len
- buf
->offset
;
511 if (add_inbuf(port
->in_vq
, buf
) < 0) {
513 free_buf(buf
, false);
516 buf
= get_inbuf(port
);
519 dev_warn(port
->dev
, "Errors adding %d buffers back to vq\n",
523 static bool port_has_data(struct port
*port
)
529 spin_lock_irqsave(&port
->inbuf_lock
, flags
);
530 port
->inbuf
= get_inbuf(port
);
534 spin_unlock_irqrestore(&port
->inbuf_lock
, flags
);
538 static ssize_t
__send_control_msg(struct ports_device
*portdev
, u32 port_id
,
539 unsigned int event
, unsigned int value
)
541 struct scatterlist sg
[1];
542 struct virtqueue
*vq
;
545 if (!use_multiport(portdev
))
550 spin_lock(&portdev
->c_ovq_lock
);
552 portdev
->cpkt
.id
= cpu_to_virtio32(portdev
->vdev
, port_id
);
553 portdev
->cpkt
.event
= cpu_to_virtio16(portdev
->vdev
, event
);
554 portdev
->cpkt
.value
= cpu_to_virtio16(portdev
->vdev
, value
);
556 sg_init_one(sg
, &portdev
->cpkt
, sizeof(struct virtio_console_control
));
558 if (virtqueue_add_outbuf(vq
, sg
, 1, &portdev
->cpkt
, GFP_ATOMIC
) == 0) {
560 while (!virtqueue_get_buf(vq
, &len
)
561 && !virtqueue_is_broken(vq
))
565 spin_unlock(&portdev
->c_ovq_lock
);
569 static ssize_t
send_control_msg(struct port
*port
, unsigned int event
,
572 /* Did the port get unplugged before userspace closed it? */
574 return __send_control_msg(port
->portdev
, port
->id
, event
, value
);
579 /* Callers must take the port->outvq_lock */
580 static void reclaim_consumed_buffers(struct port
*port
)
582 struct port_buffer
*buf
;
585 if (!port
->portdev
) {
586 /* Device has been unplugged. vqs are already gone. */
589 while ((buf
= virtqueue_get_buf(port
->out_vq
, &len
))) {
590 free_buf(buf
, false);
591 port
->outvq_full
= false;
595 static ssize_t
__send_to_port(struct port
*port
, struct scatterlist
*sg
,
596 int nents
, size_t in_count
,
597 void *data
, bool nonblock
)
599 struct virtqueue
*out_vq
;
604 out_vq
= port
->out_vq
;
606 spin_lock_irqsave(&port
->outvq_lock
, flags
);
608 reclaim_consumed_buffers(port
);
610 err
= virtqueue_add_outbuf(out_vq
, sg
, nents
, data
, GFP_ATOMIC
);
612 /* Tell Host to go! */
613 virtqueue_kick(out_vq
);
620 if (out_vq
->num_free
== 0)
621 port
->outvq_full
= true;
627 * Wait till the host acknowledges it pushed out the data we
628 * sent. This is done for data from the hvc_console; the tty
629 * operations are performed with spinlocks held so we can't
630 * sleep here. An alternative would be to copy the data to a
631 * buffer and relax the spinning requirement. The downside is
632 * we need to kmalloc a GFP_ATOMIC buffer each time the
633 * console driver writes something out.
635 while (!virtqueue_get_buf(out_vq
, &len
)
636 && !virtqueue_is_broken(out_vq
))
639 spin_unlock_irqrestore(&port
->outvq_lock
, flags
);
641 port
->stats
.bytes_sent
+= in_count
;
643 * We're expected to return the amount of data we wrote -- all
650 * Give out the data that's requested from the buffer that we have
653 static ssize_t
fill_readbuf(struct port
*port
, u8 __user
*out_buf
,
654 size_t out_count
, bool to_user
)
656 struct port_buffer
*buf
;
659 if (!out_count
|| !port_has_data(port
))
663 out_count
= min(out_count
, buf
->len
- buf
->offset
);
668 ret
= copy_to_user(out_buf
, buf
->buf
+ buf
->offset
, out_count
);
672 memcpy((__force u8
*)out_buf
, buf
->buf
+ buf
->offset
,
676 buf
->offset
+= out_count
;
678 if (buf
->offset
== buf
->len
) {
680 * We're done using all the data in this buffer.
681 * Re-queue so that the Host can send us more data.
683 spin_lock_irqsave(&port
->inbuf_lock
, flags
);
686 if (add_inbuf(port
->in_vq
, buf
) < 0)
687 dev_warn(port
->dev
, "failed add_buf\n");
689 spin_unlock_irqrestore(&port
->inbuf_lock
, flags
);
691 /* Return the number of bytes actually copied */
695 /* The condition that must be true for polling to end */
696 static bool will_read_block(struct port
*port
)
698 if (!port
->guest_connected
) {
699 /* Port got hot-unplugged. Let's exit. */
702 return !port_has_data(port
) && port
->host_connected
;
705 static bool will_write_block(struct port
*port
)
709 if (!port
->guest_connected
) {
710 /* Port got hot-unplugged. Let's exit. */
713 if (!port
->host_connected
)
716 spin_lock_irq(&port
->outvq_lock
);
718 * Check if the Host has consumed any buffers since we last
719 * sent data (this is only applicable for nonblocking ports).
721 reclaim_consumed_buffers(port
);
722 ret
= port
->outvq_full
;
723 spin_unlock_irq(&port
->outvq_lock
);
728 static ssize_t
port_fops_read(struct file
*filp
, char __user
*ubuf
,
729 size_t count
, loff_t
*offp
)
734 port
= filp
->private_data
;
736 /* Port is hot-unplugged. */
737 if (!port
->guest_connected
)
740 if (!port_has_data(port
)) {
742 * If nothing's connected on the host just return 0 in
743 * case of list_empty; this tells the userspace app
744 * that there's no connection
746 if (!port
->host_connected
)
748 if (filp
->f_flags
& O_NONBLOCK
)
751 ret
= wait_event_freezable(port
->waitqueue
,
752 !will_read_block(port
));
756 /* Port got hot-unplugged while we were waiting above. */
757 if (!port
->guest_connected
)
760 * We could've received a disconnection message while we were
761 * waiting for more data.
763 * This check is not clubbed in the if() statement above as we
764 * might receive some data as well as the host could get
765 * disconnected after we got woken up from our wait. So we
766 * really want to give off whatever data we have and only then
767 * check for host_connected.
769 if (!port_has_data(port
) && !port
->host_connected
)
772 return fill_readbuf(port
, ubuf
, count
, true);
775 static int wait_port_writable(struct port
*port
, bool nonblock
)
779 if (will_write_block(port
)) {
783 ret
= wait_event_freezable(port
->waitqueue
,
784 !will_write_block(port
));
788 /* Port got hot-unplugged. */
789 if (!port
->guest_connected
)
795 static ssize_t
port_fops_write(struct file
*filp
, const char __user
*ubuf
,
796 size_t count
, loff_t
*offp
)
799 struct port_buffer
*buf
;
802 struct scatterlist sg
[1];
804 /* Userspace could be out to fool us */
808 port
= filp
->private_data
;
810 nonblock
= filp
->f_flags
& O_NONBLOCK
;
812 ret
= wait_port_writable(port
, nonblock
);
816 count
= min((size_t)(32 * 1024), count
);
818 buf
= alloc_buf(port
->portdev
->vdev
, count
, 0);
822 ret
= copy_from_user(buf
->buf
, ubuf
, count
);
829 * We now ask send_buf() to not spin for generic ports -- we
830 * can re-use the same code path that non-blocking file
831 * descriptors take for blocking file descriptors since the
832 * wait is already done and we're certain the write will go
833 * through to the host.
836 sg_init_one(sg
, buf
->buf
, count
);
837 ret
= __send_to_port(port
, sg
, 1, count
, buf
, nonblock
);
839 if (nonblock
&& ret
> 0)
852 struct scatterlist
*sg
;
855 static int pipe_to_sg(struct pipe_inode_info
*pipe
, struct pipe_buffer
*buf
,
856 struct splice_desc
*sd
)
858 struct sg_list
*sgl
= sd
->u
.data
;
859 unsigned int offset
, len
;
861 if (sgl
->n
== sgl
->size
)
864 /* Try lock this page */
865 if (pipe_buf_try_steal(pipe
, buf
)) {
866 /* Get reference and unlock page for moving */
868 unlock_page(buf
->page
);
870 len
= min(buf
->len
, sd
->len
);
871 sg_set_page(&(sgl
->sg
[sgl
->n
]), buf
->page
, len
, buf
->offset
);
873 /* Failback to copying a page */
874 struct page
*page
= alloc_page(GFP_KERNEL
);
880 offset
= sd
->pos
& ~PAGE_MASK
;
883 if (len
+ offset
> PAGE_SIZE
)
884 len
= PAGE_SIZE
- offset
;
886 src
= kmap_atomic(buf
->page
);
887 memcpy(page_address(page
) + offset
, src
+ buf
->offset
, len
);
890 sg_set_page(&(sgl
->sg
[sgl
->n
]), page
, len
, offset
);
898 /* Faster zero-copy write by splicing */
899 static ssize_t
port_fops_splice_write(struct pipe_inode_info
*pipe
,
900 struct file
*filp
, loff_t
*ppos
,
901 size_t len
, unsigned int flags
)
903 struct port
*port
= filp
->private_data
;
906 struct port_buffer
*buf
;
907 struct splice_desc sd
= {
913 unsigned int occupancy
;
916 * Rproc_serial does not yet support splice. To support splice
917 * pipe_to_sg() must allocate dma-buffers and copy content from
918 * regular pages to dma pages. And alloc_buf and free_buf must
919 * support allocating and freeing such a list of dma-buffers.
921 if (is_rproc_serial(port
->out_vq
->vdev
))
926 if (pipe_empty(pipe
->head
, pipe
->tail
))
929 ret
= wait_port_writable(port
, filp
->f_flags
& O_NONBLOCK
);
933 occupancy
= pipe_occupancy(pipe
->head
, pipe
->tail
);
934 buf
= alloc_buf(port
->portdev
->vdev
, 0, occupancy
);
943 sgl
.size
= occupancy
;
945 sg_init_table(sgl
.sg
, sgl
.size
);
946 ret
= __splice_from_pipe(pipe
, &sd
, pipe_to_sg
);
949 ret
= __send_to_port(port
, buf
->sg
, sgl
.n
, sgl
.len
, buf
, true);
951 if (unlikely(ret
<= 0))
960 static __poll_t
port_fops_poll(struct file
*filp
, poll_table
*wait
)
965 port
= filp
->private_data
;
966 poll_wait(filp
, &port
->waitqueue
, wait
);
968 if (!port
->guest_connected
) {
969 /* Port got unplugged */
973 if (!will_read_block(port
))
974 ret
|= EPOLLIN
| EPOLLRDNORM
;
975 if (!will_write_block(port
))
977 if (!port
->host_connected
)
983 static void remove_port(struct kref
*kref
);
985 static int port_fops_release(struct inode
*inode
, struct file
*filp
)
989 port
= filp
->private_data
;
991 /* Notify host of port being closed */
992 send_control_msg(port
, VIRTIO_CONSOLE_PORT_OPEN
, 0);
994 spin_lock_irq(&port
->inbuf_lock
);
995 port
->guest_connected
= false;
997 discard_port_data(port
);
999 spin_unlock_irq(&port
->inbuf_lock
);
1001 spin_lock_irq(&port
->outvq_lock
);
1002 reclaim_consumed_buffers(port
);
1003 spin_unlock_irq(&port
->outvq_lock
);
1007 * Locks aren't necessary here as a port can't be opened after
1008 * unplug, and if a port isn't unplugged, a kref would already
1009 * exist for the port. Plus, taking ports_lock here would
1010 * create a dependency on other locks taken by functions
1011 * inside remove_port if we're the last holder of the port,
1012 * creating many problems.
1014 kref_put(&port
->kref
, remove_port
);
1019 static int port_fops_open(struct inode
*inode
, struct file
*filp
)
1021 struct cdev
*cdev
= inode
->i_cdev
;
1025 /* We get the port with a kref here */
1026 port
= find_port_by_devt(cdev
->dev
);
1028 /* Port was unplugged before we could proceed */
1031 filp
->private_data
= port
;
1034 * Don't allow opening of console port devices -- that's done
1037 if (is_console_port(port
)) {
1042 /* Allow only one process to open a particular port at a time */
1043 spin_lock_irq(&port
->inbuf_lock
);
1044 if (port
->guest_connected
) {
1045 spin_unlock_irq(&port
->inbuf_lock
);
1050 port
->guest_connected
= true;
1051 spin_unlock_irq(&port
->inbuf_lock
);
1053 spin_lock_irq(&port
->outvq_lock
);
1055 * There might be a chance that we missed reclaiming a few
1056 * buffers in the window of the port getting previously closed
1059 reclaim_consumed_buffers(port
);
1060 spin_unlock_irq(&port
->outvq_lock
);
1062 nonseekable_open(inode
, filp
);
1064 /* Notify host of port being opened */
1065 send_control_msg(filp
->private_data
, VIRTIO_CONSOLE_PORT_OPEN
, 1);
1069 kref_put(&port
->kref
, remove_port
);
1073 static int port_fops_fasync(int fd
, struct file
*filp
, int mode
)
1077 port
= filp
->private_data
;
1078 return fasync_helper(fd
, filp
, mode
, &port
->async_queue
);
1082 * The file operations that we support: programs in the guest can open
1083 * a console device, read from it, write to it, poll for data and
1084 * close it. The devices are at
1085 * /dev/vport<device number>p<port number>
1087 static const struct file_operations port_fops
= {
1088 .owner
= THIS_MODULE
,
1089 .open
= port_fops_open
,
1090 .read
= port_fops_read
,
1091 .write
= port_fops_write
,
1092 .splice_write
= port_fops_splice_write
,
1093 .poll
= port_fops_poll
,
1094 .release
= port_fops_release
,
1095 .fasync
= port_fops_fasync
,
1096 .llseek
= no_llseek
,
1100 * The put_chars() callback is pretty straightforward.
1102 * We turn the characters into a scatter-gather list, add it to the
1103 * output queue and then kick the Host. Then we sit here waiting for
1104 * it to finish: inefficient in theory, but in practice
1105 * implementations will do it immediately.
1107 static ssize_t
put_chars(u32 vtermno
, const u8
*buf
, size_t count
)
1110 struct scatterlist sg
[1];
1114 port
= find_port_by_vtermno(vtermno
);
1118 data
= kmemdup(buf
, count
, GFP_ATOMIC
);
1122 sg_init_one(sg
, data
, count
);
1123 ret
= __send_to_port(port
, sg
, 1, count
, data
, false);
1129 * get_chars() is the callback from the hvc_console infrastructure
1130 * when an interrupt is received.
1132 * We call out to fill_readbuf that gets us the required data from the
1133 * buffers that are queued up.
1135 static ssize_t
get_chars(u32 vtermno
, u8
*buf
, size_t count
)
1139 port
= find_port_by_vtermno(vtermno
);
1143 /* If we don't have an input queue yet, we can't get input. */
1144 BUG_ON(!port
->in_vq
);
1146 return fill_readbuf(port
, (__force u8 __user
*)buf
, count
, false);
1149 static void resize_console(struct port
*port
)
1151 struct virtio_device
*vdev
;
1153 /* The port could have been hot-unplugged */
1154 if (!port
|| !is_console_port(port
))
1157 vdev
= port
->portdev
->vdev
;
1159 /* Don't test F_SIZE at all if we're rproc: not a valid feature! */
1160 if (!is_rproc_serial(vdev
) &&
1161 virtio_has_feature(vdev
, VIRTIO_CONSOLE_F_SIZE
))
1162 hvc_resize(port
->cons
.hvc
, port
->cons
.ws
);
1165 /* We set the configuration at this point, since we now have a tty */
1166 static int notifier_add_vio(struct hvc_struct
*hp
, int data
)
1170 port
= find_port_by_vtermno(hp
->vtermno
);
1174 hp
->irq_requested
= 1;
1175 resize_console(port
);
1180 static void notifier_del_vio(struct hvc_struct
*hp
, int data
)
1182 hp
->irq_requested
= 0;
1185 /* The operations for console ports. */
1186 static const struct hv_ops hv_ops
= {
1187 .get_chars
= get_chars
,
1188 .put_chars
= put_chars
,
1189 .notifier_add
= notifier_add_vio
,
1190 .notifier_del
= notifier_del_vio
,
1191 .notifier_hangup
= notifier_del_vio
,
1194 static int init_port_console(struct port
*port
)
1199 * The Host's telling us this port is a console port. Hook it
1200 * up with an hvc console.
1202 * To set up and manage our virtual console, we call
1205 * The first argument of hvc_alloc() is the virtual console
1206 * number. The second argument is the parameter for the
1207 * notification mechanism (like irq number). We currently
1208 * leave this as zero, virtqueues have implicit notifications.
1210 * The third argument is a "struct hv_ops" containing the
1211 * put_chars() get_chars(), notifier_add() and notifier_del()
1212 * pointers. The final argument is the output buffer size: we
1213 * can do any size, so we put PAGE_SIZE here.
1215 ret
= ida_alloc_min(&vtermno_ida
, 1, GFP_KERNEL
);
1219 port
->cons
.vtermno
= ret
;
1220 port
->cons
.hvc
= hvc_alloc(port
->cons
.vtermno
, 0, &hv_ops
, PAGE_SIZE
);
1221 if (IS_ERR(port
->cons
.hvc
)) {
1222 ret
= PTR_ERR(port
->cons
.hvc
);
1224 "error %d allocating hvc for port\n", ret
);
1225 port
->cons
.hvc
= NULL
;
1226 ida_free(&vtermno_ida
, port
->cons
.vtermno
);
1229 spin_lock_irq(&pdrvdata_lock
);
1230 list_add_tail(&port
->cons
.list
, &pdrvdata
.consoles
);
1231 spin_unlock_irq(&pdrvdata_lock
);
1232 port
->guest_connected
= true;
1234 /* Notify host of port being opened */
1235 send_control_msg(port
, VIRTIO_CONSOLE_PORT_OPEN
, 1);
1240 static ssize_t
show_port_name(struct device
*dev
,
1241 struct device_attribute
*attr
, char *buffer
)
1245 port
= dev_get_drvdata(dev
);
1247 return sprintf(buffer
, "%s\n", port
->name
);
1250 static DEVICE_ATTR(name
, S_IRUGO
, show_port_name
, NULL
);
1252 static struct attribute
*port_sysfs_entries
[] = {
1253 &dev_attr_name
.attr
,
1257 static const struct attribute_group port_attribute_group
= {
1258 .name
= NULL
, /* put in device directory */
1259 .attrs
= port_sysfs_entries
,
1262 static int port_debugfs_show(struct seq_file
*s
, void *data
)
1264 struct port
*port
= s
->private;
1266 seq_printf(s
, "name: %s\n", port
->name
? port
->name
: "");
1267 seq_printf(s
, "guest_connected: %d\n", port
->guest_connected
);
1268 seq_printf(s
, "host_connected: %d\n", port
->host_connected
);
1269 seq_printf(s
, "outvq_full: %d\n", port
->outvq_full
);
1270 seq_printf(s
, "bytes_sent: %lu\n", port
->stats
.bytes_sent
);
1271 seq_printf(s
, "bytes_received: %lu\n", port
->stats
.bytes_received
);
1272 seq_printf(s
, "bytes_discarded: %lu\n", port
->stats
.bytes_discarded
);
1273 seq_printf(s
, "is_console: %s\n",
1274 is_console_port(port
) ? "yes" : "no");
1275 seq_printf(s
, "console_vtermno: %u\n", port
->cons
.vtermno
);
1280 DEFINE_SHOW_ATTRIBUTE(port_debugfs
);
1282 static void set_console_size(struct port
*port
, u16 rows
, u16 cols
)
1284 if (!port
|| !is_console_port(port
))
1287 port
->cons
.ws
.ws_row
= rows
;
1288 port
->cons
.ws
.ws_col
= cols
;
1291 static int fill_queue(struct virtqueue
*vq
, spinlock_t
*lock
)
1293 struct port_buffer
*buf
;
1299 buf
= alloc_buf(vq
->vdev
, PAGE_SIZE
, 0);
1303 spin_lock_irq(lock
);
1304 ret
= add_inbuf(vq
, buf
);
1306 spin_unlock_irq(lock
);
1307 free_buf(buf
, true);
1311 spin_unlock_irq(lock
);
1314 return nr_added_bufs
;
1317 static void send_sigio_to_port(struct port
*port
)
1319 if (port
->async_queue
&& port
->guest_connected
)
1320 kill_fasync(&port
->async_queue
, SIGIO
, POLL_OUT
);
1323 static int add_port(struct ports_device
*portdev
, u32 id
)
1325 char debugfs_name
[16];
1330 port
= kmalloc(sizeof(*port
), GFP_KERNEL
);
1335 kref_init(&port
->kref
);
1337 port
->portdev
= portdev
;
1342 port
->cons
.hvc
= NULL
;
1343 port
->async_queue
= NULL
;
1345 port
->cons
.ws
.ws_row
= port
->cons
.ws
.ws_col
= 0;
1346 port
->cons
.vtermno
= 0;
1348 port
->host_connected
= port
->guest_connected
= false;
1349 port
->stats
= (struct port_stats
) { 0 };
1351 port
->outvq_full
= false;
1353 port
->in_vq
= portdev
->in_vqs
[port
->id
];
1354 port
->out_vq
= portdev
->out_vqs
[port
->id
];
1356 port
->cdev
= cdev_alloc();
1358 dev_err(&port
->portdev
->vdev
->dev
, "Error allocating cdev\n");
1362 port
->cdev
->ops
= &port_fops
;
1364 devt
= MKDEV(portdev
->chr_major
, id
);
1365 err
= cdev_add(port
->cdev
, devt
, 1);
1367 dev_err(&port
->portdev
->vdev
->dev
,
1368 "Error %d adding cdev for port %u\n", err
, id
);
1371 port
->dev
= device_create(&port_class
, &port
->portdev
->vdev
->dev
,
1372 devt
, port
, "vport%up%u",
1373 port
->portdev
->vdev
->index
, id
);
1374 if (IS_ERR(port
->dev
)) {
1375 err
= PTR_ERR(port
->dev
);
1376 dev_err(&port
->portdev
->vdev
->dev
,
1377 "Error %d creating device for port %u\n",
1382 spin_lock_init(&port
->inbuf_lock
);
1383 spin_lock_init(&port
->outvq_lock
);
1384 init_waitqueue_head(&port
->waitqueue
);
1386 /* We can safely ignore ENOSPC because it means
1387 * the queue already has buffers. Buffers are removed
1388 * only by virtcons_remove(), not by unplug_port()
1390 err
= fill_queue(port
->in_vq
, &port
->inbuf_lock
);
1391 if (err
< 0 && err
!= -ENOSPC
) {
1392 dev_err(port
->dev
, "Error allocating inbufs\n");
1396 if (is_rproc_serial(port
->portdev
->vdev
))
1398 * For rproc_serial assume remote processor is connected.
1399 * rproc_serial does not want the console port, only
1400 * the generic port implementation.
1402 port
->host_connected
= true;
1403 else if (!use_multiport(port
->portdev
)) {
1405 * If we're not using multiport support,
1406 * this has to be a console port.
1408 err
= init_port_console(port
);
1413 spin_lock_irq(&portdev
->ports_lock
);
1414 list_add_tail(&port
->list
, &port
->portdev
->ports
);
1415 spin_unlock_irq(&portdev
->ports_lock
);
1418 * Tell the Host we're set so that it can send us various
1419 * configuration parameters for this port (eg, port name,
1420 * caching, whether this is a console port, etc.)
1422 send_control_msg(port
, VIRTIO_CONSOLE_PORT_READY
, 1);
1425 * Finally, create the debugfs file that we can use to
1426 * inspect a port's state at any time
1428 snprintf(debugfs_name
, sizeof(debugfs_name
), "vport%up%u",
1429 port
->portdev
->vdev
->index
, id
);
1430 port
->debugfs_file
= debugfs_create_file(debugfs_name
, 0444,
1431 pdrvdata
.debugfs_dir
,
1432 port
, &port_debugfs_fops
);
1437 device_destroy(&port_class
, port
->dev
->devt
);
1439 cdev_del(port
->cdev
);
1443 /* The host might want to notify management sw about port add failure */
1444 __send_control_msg(portdev
, id
, VIRTIO_CONSOLE_PORT_READY
, 0);
1448 /* No users remain, remove all port-specific data. */
1449 static void remove_port(struct kref
*kref
)
1453 port
= container_of(kref
, struct port
, kref
);
1458 static void remove_port_data(struct port
*port
)
1460 spin_lock_irq(&port
->inbuf_lock
);
1461 /* Remove unused data this port might have received. */
1462 discard_port_data(port
);
1463 spin_unlock_irq(&port
->inbuf_lock
);
1465 spin_lock_irq(&port
->outvq_lock
);
1466 reclaim_consumed_buffers(port
);
1467 spin_unlock_irq(&port
->outvq_lock
);
1471 * Port got unplugged. Remove port from portdev's list and drop the
1472 * kref reference. If no userspace has this port opened, it will
1473 * result in immediate removal the port.
1475 static void unplug_port(struct port
*port
)
1477 spin_lock_irq(&port
->portdev
->ports_lock
);
1478 list_del(&port
->list
);
1479 spin_unlock_irq(&port
->portdev
->ports_lock
);
1481 spin_lock_irq(&port
->inbuf_lock
);
1482 if (port
->guest_connected
) {
1483 /* Let the app know the port is going down. */
1484 send_sigio_to_port(port
);
1486 /* Do this after sigio is actually sent */
1487 port
->guest_connected
= false;
1488 port
->host_connected
= false;
1490 wake_up_interruptible(&port
->waitqueue
);
1492 spin_unlock_irq(&port
->inbuf_lock
);
1494 if (is_console_port(port
)) {
1495 spin_lock_irq(&pdrvdata_lock
);
1496 list_del(&port
->cons
.list
);
1497 spin_unlock_irq(&pdrvdata_lock
);
1498 hvc_remove(port
->cons
.hvc
);
1499 ida_free(&vtermno_ida
, port
->cons
.vtermno
);
1502 remove_port_data(port
);
1505 * We should just assume the device itself has gone off --
1506 * else a close on an open port later will try to send out a
1509 port
->portdev
= NULL
;
1511 sysfs_remove_group(&port
->dev
->kobj
, &port_attribute_group
);
1512 device_destroy(&port_class
, port
->dev
->devt
);
1513 cdev_del(port
->cdev
);
1515 debugfs_remove(port
->debugfs_file
);
1519 * Locks around here are not necessary - a port can't be
1520 * opened after we removed the port struct from ports_list
1523 kref_put(&port
->kref
, remove_port
);
1526 /* Any private messages that the Host and Guest want to share */
1527 static void handle_control_message(struct virtio_device
*vdev
,
1528 struct ports_device
*portdev
,
1529 struct port_buffer
*buf
)
1531 struct virtio_console_control
*cpkt
;
1536 cpkt
= (struct virtio_console_control
*)(buf
->buf
+ buf
->offset
);
1538 port
= find_port_by_id(portdev
, virtio32_to_cpu(vdev
, cpkt
->id
));
1540 cpkt
->event
!= cpu_to_virtio16(vdev
, VIRTIO_CONSOLE_PORT_ADD
)) {
1541 /* No valid header at start of buffer. Drop it. */
1542 dev_dbg(&portdev
->vdev
->dev
,
1543 "Invalid index %u in control packet\n", cpkt
->id
);
1547 switch (virtio16_to_cpu(vdev
, cpkt
->event
)) {
1548 case VIRTIO_CONSOLE_PORT_ADD
:
1550 dev_dbg(&portdev
->vdev
->dev
,
1551 "Port %u already added\n", port
->id
);
1552 send_control_msg(port
, VIRTIO_CONSOLE_PORT_READY
, 1);
1555 if (virtio32_to_cpu(vdev
, cpkt
->id
) >=
1556 portdev
->max_nr_ports
) {
1557 dev_warn(&portdev
->vdev
->dev
,
1558 "Request for adding port with "
1559 "out-of-bound id %u, max. supported id: %u\n",
1560 cpkt
->id
, portdev
->max_nr_ports
- 1);
1563 add_port(portdev
, virtio32_to_cpu(vdev
, cpkt
->id
));
1565 case VIRTIO_CONSOLE_PORT_REMOVE
:
1568 case VIRTIO_CONSOLE_CONSOLE_PORT
:
1571 if (is_console_port(port
))
1574 init_port_console(port
);
1575 complete(&early_console_added
);
1577 * Could remove the port here in case init fails - but
1578 * have to notify the host first.
1581 case VIRTIO_CONSOLE_RESIZE
: {
1587 if (!is_console_port(port
))
1590 memcpy(&size
, buf
->buf
+ buf
->offset
+ sizeof(*cpkt
),
1592 set_console_size(port
, size
.rows
, size
.cols
);
1594 port
->cons
.hvc
->irq_requested
= 1;
1595 resize_console(port
);
1598 case VIRTIO_CONSOLE_PORT_OPEN
:
1599 port
->host_connected
= virtio16_to_cpu(vdev
, cpkt
->value
);
1600 wake_up_interruptible(&port
->waitqueue
);
1602 * If the host port got closed and the host had any
1603 * unconsumed buffers, we'll be able to reclaim them
1606 spin_lock_irq(&port
->outvq_lock
);
1607 reclaim_consumed_buffers(port
);
1608 spin_unlock_irq(&port
->outvq_lock
);
1611 * If the guest is connected, it'll be interested in
1612 * knowing the host connection state changed.
1614 spin_lock_irq(&port
->inbuf_lock
);
1615 send_sigio_to_port(port
);
1616 spin_unlock_irq(&port
->inbuf_lock
);
1618 case VIRTIO_CONSOLE_PORT_NAME
:
1620 * If we woke up after hibernation, we can get this
1621 * again. Skip it in that case.
1627 * Skip the size of the header and the cpkt to get the size
1628 * of the name that was sent
1630 name_size
= buf
->len
- buf
->offset
- sizeof(*cpkt
) + 1;
1632 port
->name
= kmalloc(name_size
, GFP_KERNEL
);
1635 "Not enough space to store port name\n");
1638 strscpy(port
->name
, buf
->buf
+ buf
->offset
+ sizeof(*cpkt
),
1642 * Since we only have one sysfs attribute, 'name',
1643 * create it only if we have a name for the port.
1645 err
= sysfs_create_group(&port
->dev
->kobj
,
1646 &port_attribute_group
);
1649 "Error %d creating sysfs device attributes\n",
1653 * Generate a udev event so that appropriate
1654 * symlinks can be created based on udev
1657 kobject_uevent(&port
->dev
->kobj
, KOBJ_CHANGE
);
1663 static void control_work_handler(struct work_struct
*work
)
1665 struct ports_device
*portdev
;
1666 struct virtqueue
*vq
;
1667 struct port_buffer
*buf
;
1670 portdev
= container_of(work
, struct ports_device
, control_work
);
1671 vq
= portdev
->c_ivq
;
1673 spin_lock(&portdev
->c_ivq_lock
);
1674 while ((buf
= virtqueue_get_buf(vq
, &len
))) {
1675 spin_unlock(&portdev
->c_ivq_lock
);
1677 buf
->len
= min_t(size_t, len
, buf
->size
);
1680 handle_control_message(vq
->vdev
, portdev
, buf
);
1682 spin_lock(&portdev
->c_ivq_lock
);
1683 if (add_inbuf(portdev
->c_ivq
, buf
) < 0) {
1684 dev_warn(&portdev
->vdev
->dev
,
1685 "Error adding buffer to queue\n");
1686 free_buf(buf
, false);
1689 spin_unlock(&portdev
->c_ivq_lock
);
1692 static void flush_bufs(struct virtqueue
*vq
, bool can_sleep
)
1694 struct port_buffer
*buf
;
1697 while ((buf
= virtqueue_get_buf(vq
, &len
)))
1698 free_buf(buf
, can_sleep
);
1701 static void out_intr(struct virtqueue
*vq
)
1705 port
= find_port_by_vq(vq
->vdev
->priv
, vq
);
1707 flush_bufs(vq
, false);
1711 wake_up_interruptible(&port
->waitqueue
);
1714 static void in_intr(struct virtqueue
*vq
)
1717 unsigned long flags
;
1719 port
= find_port_by_vq(vq
->vdev
->priv
, vq
);
1721 flush_bufs(vq
, false);
1725 spin_lock_irqsave(&port
->inbuf_lock
, flags
);
1726 port
->inbuf
= get_inbuf(port
);
1729 * Normally the port should not accept data when the port is
1730 * closed. For generic serial ports, the host won't (shouldn't)
1731 * send data till the guest is connected. But this condition
1732 * can be reached when a console port is not yet connected (no
1733 * tty is spawned) and the other side sends out data over the
1734 * vring, or when a remote devices start sending data before
1735 * the ports are opened.
1737 * A generic serial port will discard data if not connected,
1738 * while console ports and rproc-serial ports accepts data at
1739 * any time. rproc-serial is initiated with guest_connected to
1740 * false because port_fops_open expects this. Console ports are
1741 * hooked up with an HVC console and is initialized with
1742 * guest_connected to true.
1745 if (!port
->guest_connected
&& !is_rproc_serial(port
->portdev
->vdev
))
1746 discard_port_data(port
);
1748 /* Send a SIGIO indicating new data in case the process asked for it */
1749 send_sigio_to_port(port
);
1751 spin_unlock_irqrestore(&port
->inbuf_lock
, flags
);
1753 wake_up_interruptible(&port
->waitqueue
);
1755 if (is_console_port(port
) && hvc_poll(port
->cons
.hvc
))
1759 static void control_intr(struct virtqueue
*vq
)
1761 struct ports_device
*portdev
;
1763 portdev
= vq
->vdev
->priv
;
1764 schedule_work(&portdev
->control_work
);
1767 static void config_intr(struct virtio_device
*vdev
)
1769 struct ports_device
*portdev
;
1771 portdev
= vdev
->priv
;
1773 if (!use_multiport(portdev
))
1774 schedule_work(&portdev
->config_work
);
1777 static void config_work_handler(struct work_struct
*work
)
1779 struct ports_device
*portdev
;
1781 portdev
= container_of(work
, struct ports_device
, config_work
);
1782 if (!use_multiport(portdev
)) {
1783 struct virtio_device
*vdev
;
1787 vdev
= portdev
->vdev
;
1788 virtio_cread(vdev
, struct virtio_console_config
, cols
, &cols
);
1789 virtio_cread(vdev
, struct virtio_console_config
, rows
, &rows
);
1791 port
= find_port_by_id(portdev
, 0);
1792 set_console_size(port
, rows
, cols
);
1795 * We'll use this way of resizing only for legacy
1796 * support. For newer userspace
1797 * (VIRTIO_CONSOLE_F_MULTPORT+), use control messages
1798 * to indicate console size changes so that it can be
1801 resize_console(port
);
1805 static int init_vqs(struct ports_device
*portdev
)
1807 struct virtqueue_info
*vqs_info
;
1808 struct virtqueue
**vqs
;
1809 u32 i
, j
, nr_ports
, nr_queues
;
1812 nr_ports
= portdev
->max_nr_ports
;
1813 nr_queues
= use_multiport(portdev
) ? (nr_ports
+ 1) * 2 : 2;
1815 vqs
= kmalloc_array(nr_queues
, sizeof(struct virtqueue
*), GFP_KERNEL
);
1816 vqs_info
= kcalloc(nr_queues
, sizeof(*vqs_info
), GFP_KERNEL
);
1817 portdev
->in_vqs
= kmalloc_array(nr_ports
, sizeof(struct virtqueue
*),
1819 portdev
->out_vqs
= kmalloc_array(nr_ports
, sizeof(struct virtqueue
*),
1821 if (!vqs
|| !vqs_info
|| !portdev
->in_vqs
|| !portdev
->out_vqs
) {
1827 * For backward compat (newer host but older guest), the host
1828 * spawns a console port first and also inits the vqs for port
1832 vqs_info
[j
].callback
= in_intr
;
1833 vqs_info
[j
+ 1].callback
= out_intr
;
1834 vqs_info
[j
].name
= "input";
1835 vqs_info
[j
+ 1].name
= "output";
1838 if (use_multiport(portdev
)) {
1839 vqs_info
[j
].callback
= control_intr
;
1840 vqs_info
[j
].name
= "control-i";
1841 vqs_info
[j
+ 1].name
= "control-o";
1843 for (i
= 1; i
< nr_ports
; i
++) {
1845 vqs_info
[j
].callback
= in_intr
;
1846 vqs_info
[j
+ 1].callback
= out_intr
;
1847 vqs_info
[j
].name
= "input";
1848 vqs_info
[j
+ 1].name
= "output";
1851 /* Find the queues. */
1852 err
= virtio_find_vqs(portdev
->vdev
, nr_queues
, vqs
, vqs_info
, NULL
);
1857 portdev
->in_vqs
[0] = vqs
[0];
1858 portdev
->out_vqs
[0] = vqs
[1];
1860 if (use_multiport(portdev
)) {
1861 portdev
->c_ivq
= vqs
[j
];
1862 portdev
->c_ovq
= vqs
[j
+ 1];
1864 for (i
= 1; i
< nr_ports
; i
++) {
1866 portdev
->in_vqs
[i
] = vqs
[j
];
1867 portdev
->out_vqs
[i
] = vqs
[j
+ 1];
1876 kfree(portdev
->out_vqs
);
1877 kfree(portdev
->in_vqs
);
1884 static const struct file_operations portdev_fops
= {
1885 .owner
= THIS_MODULE
,
1888 static void remove_vqs(struct ports_device
*portdev
)
1890 struct virtqueue
*vq
;
1892 virtio_device_for_each_vq(portdev
->vdev
, vq
) {
1893 struct port_buffer
*buf
;
1895 flush_bufs(vq
, true);
1896 while ((buf
= virtqueue_detach_unused_buf(vq
)))
1897 free_buf(buf
, true);
1900 portdev
->vdev
->config
->del_vqs(portdev
->vdev
);
1901 kfree(portdev
->in_vqs
);
1902 kfree(portdev
->out_vqs
);
1905 static void virtcons_remove(struct virtio_device
*vdev
)
1907 struct ports_device
*portdev
;
1908 struct port
*port
, *port2
;
1910 portdev
= vdev
->priv
;
1912 spin_lock_irq(&pdrvdata_lock
);
1913 list_del(&portdev
->list
);
1914 spin_unlock_irq(&pdrvdata_lock
);
1916 /* Device is going away, exit any polling for buffers */
1917 virtio_break_device(vdev
);
1918 if (use_multiport(portdev
))
1919 flush_work(&portdev
->control_work
);
1921 flush_work(&portdev
->config_work
);
1923 /* Disable interrupts for vqs */
1924 virtio_reset_device(vdev
);
1925 /* Finish up work that's lined up */
1926 if (use_multiport(portdev
))
1927 cancel_work_sync(&portdev
->control_work
);
1929 cancel_work_sync(&portdev
->config_work
);
1931 list_for_each_entry_safe(port
, port2
, &portdev
->ports
, list
)
1934 unregister_chrdev(portdev
->chr_major
, "virtio-portsdev");
1937 * When yanking out a device, we immediately lose the
1938 * (device-side) queues. So there's no point in keeping the
1939 * guest side around till we drop our final reference. This
1940 * also means that any ports which are in an open state will
1941 * have to just stop using the port, as the vqs are going
1944 remove_vqs(portdev
);
1949 * Once we're further in boot, we get probed like any other virtio
1952 * If the host also supports multiple console ports, we check the
1953 * config space to see how many ports the host has spawned. We
1954 * initialize each port found.
1956 static int virtcons_probe(struct virtio_device
*vdev
)
1958 struct ports_device
*portdev
;
1962 /* We only need a config space if features are offered */
1963 if (!vdev
->config
->get
&&
1964 (virtio_has_feature(vdev
, VIRTIO_CONSOLE_F_SIZE
)
1965 || virtio_has_feature(vdev
, VIRTIO_CONSOLE_F_MULTIPORT
))) {
1966 dev_err(&vdev
->dev
, "%s failure: config access disabled\n",
1971 portdev
= kmalloc(sizeof(*portdev
), GFP_KERNEL
);
1977 /* Attach this portdev to this virtio_device, and vice-versa. */
1978 portdev
->vdev
= vdev
;
1979 vdev
->priv
= portdev
;
1981 portdev
->chr_major
= register_chrdev(0, "virtio-portsdev",
1983 if (portdev
->chr_major
< 0) {
1985 "Error %d registering chrdev for device %u\n",
1986 portdev
->chr_major
, vdev
->index
);
1987 err
= portdev
->chr_major
;
1992 portdev
->max_nr_ports
= 1;
1994 /* Don't test MULTIPORT at all if we're rproc: not a valid feature! */
1995 if (!is_rproc_serial(vdev
) &&
1996 virtio_cread_feature(vdev
, VIRTIO_CONSOLE_F_MULTIPORT
,
1997 struct virtio_console_config
, max_nr_ports
,
1998 &portdev
->max_nr_ports
) == 0) {
1999 if (portdev
->max_nr_ports
== 0 ||
2000 portdev
->max_nr_ports
> VIRTCONS_MAX_PORTS
) {
2002 "Invalidate max_nr_ports %d",
2003 portdev
->max_nr_ports
);
2010 err
= init_vqs(portdev
);
2012 dev_err(&vdev
->dev
, "Error %d initializing vqs\n", err
);
2016 spin_lock_init(&portdev
->ports_lock
);
2017 INIT_LIST_HEAD(&portdev
->ports
);
2018 INIT_LIST_HEAD(&portdev
->list
);
2020 virtio_device_ready(portdev
->vdev
);
2022 INIT_WORK(&portdev
->config_work
, &config_work_handler
);
2023 INIT_WORK(&portdev
->control_work
, &control_work_handler
);
2026 spin_lock_init(&portdev
->c_ivq_lock
);
2027 spin_lock_init(&portdev
->c_ovq_lock
);
2029 err
= fill_queue(portdev
->c_ivq
, &portdev
->c_ivq_lock
);
2032 "Error allocating buffers for control queue\n");
2034 * The host might want to notify mgmt sw about device
2037 __send_control_msg(portdev
, VIRTIO_CONSOLE_BAD_ID
,
2038 VIRTIO_CONSOLE_DEVICE_READY
, 0);
2039 /* Device was functional: we need full cleanup. */
2040 virtcons_remove(vdev
);
2045 * For backward compatibility: Create a console port
2046 * if we're running on older host.
2048 add_port(portdev
, 0);
2051 spin_lock_irq(&pdrvdata_lock
);
2052 list_add_tail(&portdev
->list
, &pdrvdata
.portdevs
);
2053 spin_unlock_irq(&pdrvdata_lock
);
2055 __send_control_msg(portdev
, VIRTIO_CONSOLE_BAD_ID
,
2056 VIRTIO_CONSOLE_DEVICE_READY
, 1);
2061 unregister_chrdev(portdev
->chr_major
, "virtio-portsdev");
2068 static const struct virtio_device_id id_table
[] = {
2069 { VIRTIO_ID_CONSOLE
, VIRTIO_DEV_ANY_ID
},
2072 MODULE_DEVICE_TABLE(virtio
, id_table
);
2074 static const unsigned int features
[] = {
2075 VIRTIO_CONSOLE_F_SIZE
,
2076 VIRTIO_CONSOLE_F_MULTIPORT
,
2079 static const struct virtio_device_id rproc_serial_id_table
[] = {
2080 #if IS_ENABLED(CONFIG_REMOTEPROC)
2081 { VIRTIO_ID_RPROC_SERIAL
, VIRTIO_DEV_ANY_ID
},
2085 MODULE_DEVICE_TABLE(virtio
, rproc_serial_id_table
);
2087 static const unsigned int rproc_serial_features
[] = {
2090 #ifdef CONFIG_PM_SLEEP
2091 static int virtcons_freeze(struct virtio_device
*vdev
)
2093 struct ports_device
*portdev
;
2096 portdev
= vdev
->priv
;
2098 virtio_reset_device(vdev
);
2100 if (use_multiport(portdev
))
2101 virtqueue_disable_cb(portdev
->c_ivq
);
2102 cancel_work_sync(&portdev
->control_work
);
2103 cancel_work_sync(&portdev
->config_work
);
2105 * Once more: if control_work_handler() was running, it would
2106 * enable the cb as the last step.
2108 if (use_multiport(portdev
))
2109 virtqueue_disable_cb(portdev
->c_ivq
);
2111 list_for_each_entry(port
, &portdev
->ports
, list
) {
2112 virtqueue_disable_cb(port
->in_vq
);
2113 virtqueue_disable_cb(port
->out_vq
);
2115 * We'll ask the host later if the new invocation has
2116 * the port opened or closed.
2118 port
->host_connected
= false;
2119 remove_port_data(port
);
2121 remove_vqs(portdev
);
2126 static int virtcons_restore(struct virtio_device
*vdev
)
2128 struct ports_device
*portdev
;
2132 portdev
= vdev
->priv
;
2134 ret
= init_vqs(portdev
);
2138 virtio_device_ready(portdev
->vdev
);
2140 if (use_multiport(portdev
))
2141 fill_queue(portdev
->c_ivq
, &portdev
->c_ivq_lock
);
2143 list_for_each_entry(port
, &portdev
->ports
, list
) {
2144 port
->in_vq
= portdev
->in_vqs
[port
->id
];
2145 port
->out_vq
= portdev
->out_vqs
[port
->id
];
2147 fill_queue(port
->in_vq
, &port
->inbuf_lock
);
2149 /* Get port open/close status on the host */
2150 send_control_msg(port
, VIRTIO_CONSOLE_PORT_READY
, 1);
2153 * If a port was open at the time of suspending, we
2154 * have to let the host know that it's still open.
2156 if (port
->guest_connected
)
2157 send_control_msg(port
, VIRTIO_CONSOLE_PORT_OPEN
, 1);
2163 static struct virtio_driver virtio_console
= {
2164 .feature_table
= features
,
2165 .feature_table_size
= ARRAY_SIZE(features
),
2166 .driver
.name
= KBUILD_MODNAME
,
2167 .id_table
= id_table
,
2168 .probe
= virtcons_probe
,
2169 .remove
= virtcons_remove
,
2170 .config_changed
= config_intr
,
2171 #ifdef CONFIG_PM_SLEEP
2172 .freeze
= virtcons_freeze
,
2173 .restore
= virtcons_restore
,
2177 static struct virtio_driver virtio_rproc_serial
= {
2178 .feature_table
= rproc_serial_features
,
2179 .feature_table_size
= ARRAY_SIZE(rproc_serial_features
),
2180 .driver
.name
= "virtio_rproc_serial",
2181 .id_table
= rproc_serial_id_table
,
2182 .probe
= virtcons_probe
,
2183 .remove
= virtcons_remove
,
2186 static int __init
virtio_console_init(void)
2190 err
= class_register(&port_class
);
2194 pdrvdata
.debugfs_dir
= debugfs_create_dir("virtio-ports", NULL
);
2195 INIT_LIST_HEAD(&pdrvdata
.consoles
);
2196 INIT_LIST_HEAD(&pdrvdata
.portdevs
);
2198 err
= register_virtio_driver(&virtio_console
);
2200 pr_err("Error %d registering virtio driver\n", err
);
2203 err
= register_virtio_driver(&virtio_rproc_serial
);
2205 pr_err("Error %d registering virtio rproc serial driver\n",
2211 unregister_virtio_driver(&virtio_console
);
2213 debugfs_remove_recursive(pdrvdata
.debugfs_dir
);
2214 class_unregister(&port_class
);
2218 static void __exit
virtio_console_fini(void)
2222 unregister_virtio_driver(&virtio_console
);
2223 unregister_virtio_driver(&virtio_rproc_serial
);
2225 class_unregister(&port_class
);
2226 debugfs_remove_recursive(pdrvdata
.debugfs_dir
);
2228 module_init(virtio_console_init
);
2229 module_exit(virtio_console_fini
);
2231 MODULE_DESCRIPTION("Virtio console driver");
2232 MODULE_LICENSE("GPL");