xref: /openbmc/linux/drivers/char/virtio_console.c (revision c819e2cf)
1 /*
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>
5  *
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.
10  *
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.
15  *
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
19  */
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>
26 #include <linux/fs.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"
43 
44 #define is_rproc_enabled IS_ENABLED(CONFIG_REMOTEPROC)
45 
46 /*
47  * This is a global struct for storing common data for all the devices
48  * this driver handles.
49  *
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.
53  */
54 struct ports_driver_data {
55 	/* Used for registering chardevs */
56 	struct class *class;
57 
58 	/* Used for exporting per-port information to debugfs */
59 	struct dentry *debugfs_dir;
60 
61 	/* List of all the devices we're handling */
62 	struct list_head portdevs;
63 
64 	/*
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.
70 	 *
71 	 * We also just assume the first console being initialised was
72 	 * the first one that got used as the initial console.
73 	 */
74 	unsigned int next_vtermno;
75 
76 	/* All the console devices handled by this driver */
77 	struct list_head consoles;
78 };
79 static struct ports_driver_data pdrvdata;
80 
81 static DEFINE_SPINLOCK(pdrvdata_lock);
82 static DECLARE_COMPLETION(early_console_added);
83 
84 /* This struct holds information that's relevant only for console ports */
85 struct console {
86 	/* We'll place all consoles in a list in the pdrvdata struct */
87 	struct list_head list;
88 
89 	/* The hvc device associated with this console port */
90 	struct hvc_struct *hvc;
91 
92 	/* The size of the console */
93 	struct winsize ws;
94 
95 	/*
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
100 	 * this driver
101 	 */
102 	u32 vtermno;
103 };
104 
105 struct port_buffer {
106 	char *buf;
107 
108 	/* size of the buffer in *buf above */
109 	size_t size;
110 
111 	/* used length of the buffer */
112 	size_t len;
113 	/* offset in the buf from which to consume data */
114 	size_t offset;
115 
116 	/* DMA address of buffer */
117 	dma_addr_t dma;
118 
119 	/* Device we got DMA memory from */
120 	struct device *dev;
121 
122 	/* List of pending dma buffers to free */
123 	struct list_head list;
124 
125 	/* If sgpages == 0 then buf is used */
126 	unsigned int sgpages;
127 
128 	/* sg is used if spages > 0. sg must be the last in is struct */
129 	struct scatterlist sg[0];
130 };
131 
132 /*
133  * This is a per-device struct that stores data common to all the
134  * ports for that device (vdev->priv).
135  */
136 struct ports_device {
137 	/* Next portdev in the list, head is in the pdrvdata struct */
138 	struct list_head list;
139 
140 	/*
141 	 * Workqueue handlers where we process deferred work after
142 	 * notification
143 	 */
144 	struct work_struct control_work;
145 
146 	struct list_head ports;
147 
148 	/* To protect the list of ports */
149 	spinlock_t ports_lock;
150 
151 	/* To protect the vq operations for the control channel */
152 	spinlock_t c_ivq_lock;
153 	spinlock_t c_ovq_lock;
154 
155 	/* The current config space is stored here */
156 	struct virtio_console_config config;
157 
158 	/* The virtio device we're associated with */
159 	struct virtio_device *vdev;
160 
161 	/*
162 	 * A couple of virtqueues for the control channel: one for
163 	 * guest->host transfers, one for host->guest transfers
164 	 */
165 	struct virtqueue *c_ivq, *c_ovq;
166 
167 	/* Array of per-port IO virtqueues */
168 	struct virtqueue **in_vqs, **out_vqs;
169 
170 	/* Major number for this device.  Ports will be created as minors. */
171 	int chr_major;
172 };
173 
174 struct port_stats {
175 	unsigned long bytes_sent, bytes_received, bytes_discarded;
176 };
177 
178 /* This struct holds the per-port data */
179 struct port {
180 	/* Next port in the list, head is in the ports_device */
181 	struct list_head list;
182 
183 	/* Pointer to the parent virtio_console device */
184 	struct ports_device *portdev;
185 
186 	/* The current buffer from which data has to be fed to readers */
187 	struct port_buffer *inbuf;
188 
189 	/*
190 	 * To protect the operations on the in_vq associated with this
191 	 * port.  Has to be a spinlock because it can be called from
192 	 * interrupt context (get_char()).
193 	 */
194 	spinlock_t inbuf_lock;
195 
196 	/* Protect the operations on the out_vq. */
197 	spinlock_t outvq_lock;
198 
199 	/* The IO vqs for this port */
200 	struct virtqueue *in_vq, *out_vq;
201 
202 	/* File in the debugfs directory that exposes this port's information */
203 	struct dentry *debugfs_file;
204 
205 	/*
206 	 * Keep count of the bytes sent, received and discarded for
207 	 * this port for accounting and debugging purposes.  These
208 	 * counts are not reset across port open / close events.
209 	 */
210 	struct port_stats stats;
211 
212 	/*
213 	 * The entries in this struct will be valid if this port is
214 	 * hooked up to an hvc console
215 	 */
216 	struct console cons;
217 
218 	/* Each port associates with a separate char device */
219 	struct cdev *cdev;
220 	struct device *dev;
221 
222 	/* Reference-counting to handle port hot-unplugs and file operations */
223 	struct kref kref;
224 
225 	/* A waitqueue for poll() or blocking read operations */
226 	wait_queue_head_t waitqueue;
227 
228 	/* The 'name' of the port that we expose via sysfs properties */
229 	char *name;
230 
231 	/* We can notify apps of host connect / disconnect events via SIGIO */
232 	struct fasync_struct *async_queue;
233 
234 	/* The 'id' to identify the port with the Host */
235 	u32 id;
236 
237 	bool outvq_full;
238 
239 	/* Is the host device open */
240 	bool host_connected;
241 
242 	/* We should allow only one process to open a port */
243 	bool guest_connected;
244 };
245 
246 /* This is the very early arch-specified put chars function. */
247 static int (*early_put_chars)(u32, const char *, int);
248 
249 static struct port *find_port_by_vtermno(u32 vtermno)
250 {
251 	struct port *port;
252 	struct console *cons;
253 	unsigned long flags;
254 
255 	spin_lock_irqsave(&pdrvdata_lock, flags);
256 	list_for_each_entry(cons, &pdrvdata.consoles, list) {
257 		if (cons->vtermno == vtermno) {
258 			port = container_of(cons, struct port, cons);
259 			goto out;
260 		}
261 	}
262 	port = NULL;
263 out:
264 	spin_unlock_irqrestore(&pdrvdata_lock, flags);
265 	return port;
266 }
267 
268 static struct port *find_port_by_devt_in_portdev(struct ports_device *portdev,
269 						 dev_t dev)
270 {
271 	struct port *port;
272 	unsigned long flags;
273 
274 	spin_lock_irqsave(&portdev->ports_lock, flags);
275 	list_for_each_entry(port, &portdev->ports, list) {
276 		if (port->cdev->dev == dev) {
277 			kref_get(&port->kref);
278 			goto out;
279 		}
280 	}
281 	port = NULL;
282 out:
283 	spin_unlock_irqrestore(&portdev->ports_lock, flags);
284 
285 	return port;
286 }
287 
288 static struct port *find_port_by_devt(dev_t dev)
289 {
290 	struct ports_device *portdev;
291 	struct port *port;
292 	unsigned long flags;
293 
294 	spin_lock_irqsave(&pdrvdata_lock, flags);
295 	list_for_each_entry(portdev, &pdrvdata.portdevs, list) {
296 		port = find_port_by_devt_in_portdev(portdev, dev);
297 		if (port)
298 			goto out;
299 	}
300 	port = NULL;
301 out:
302 	spin_unlock_irqrestore(&pdrvdata_lock, flags);
303 	return port;
304 }
305 
306 static struct port *find_port_by_id(struct ports_device *portdev, u32 id)
307 {
308 	struct port *port;
309 	unsigned long flags;
310 
311 	spin_lock_irqsave(&portdev->ports_lock, flags);
312 	list_for_each_entry(port, &portdev->ports, list)
313 		if (port->id == id)
314 			goto out;
315 	port = NULL;
316 out:
317 	spin_unlock_irqrestore(&portdev->ports_lock, flags);
318 
319 	return port;
320 }
321 
322 static struct port *find_port_by_vq(struct ports_device *portdev,
323 				    struct virtqueue *vq)
324 {
325 	struct port *port;
326 	unsigned long flags;
327 
328 	spin_lock_irqsave(&portdev->ports_lock, flags);
329 	list_for_each_entry(port, &portdev->ports, list)
330 		if (port->in_vq == vq || port->out_vq == vq)
331 			goto out;
332 	port = NULL;
333 out:
334 	spin_unlock_irqrestore(&portdev->ports_lock, flags);
335 	return port;
336 }
337 
338 static bool is_console_port(struct port *port)
339 {
340 	if (port->cons.hvc)
341 		return true;
342 	return false;
343 }
344 
345 static bool is_rproc_serial(const struct virtio_device *vdev)
346 {
347 	return is_rproc_enabled && vdev->id.device == VIRTIO_ID_RPROC_SERIAL;
348 }
349 
350 static inline bool use_multiport(struct ports_device *portdev)
351 {
352 	/*
353 	 * This condition can be true when put_chars is called from
354 	 * early_init
355 	 */
356 	if (!portdev->vdev)
357 		return 0;
358 	return __virtio_test_bit(portdev->vdev, VIRTIO_CONSOLE_F_MULTIPORT);
359 }
360 
361 static DEFINE_SPINLOCK(dma_bufs_lock);
362 static LIST_HEAD(pending_free_dma_bufs);
363 
364 static void free_buf(struct port_buffer *buf, bool can_sleep)
365 {
366 	unsigned int i;
367 
368 	for (i = 0; i < buf->sgpages; i++) {
369 		struct page *page = sg_page(&buf->sg[i]);
370 		if (!page)
371 			break;
372 		put_page(page);
373 	}
374 
375 	if (!buf->dev) {
376 		kfree(buf->buf);
377 	} else if (is_rproc_enabled) {
378 		unsigned long flags;
379 
380 		/* dma_free_coherent requires interrupts to be enabled. */
381 		if (!can_sleep) {
382 			/* queue up dma-buffers to be freed later */
383 			spin_lock_irqsave(&dma_bufs_lock, flags);
384 			list_add_tail(&buf->list, &pending_free_dma_bufs);
385 			spin_unlock_irqrestore(&dma_bufs_lock, flags);
386 			return;
387 		}
388 		dma_free_coherent(buf->dev, buf->size, buf->buf, buf->dma);
389 
390 		/* Release device refcnt and allow it to be freed */
391 		put_device(buf->dev);
392 	}
393 
394 	kfree(buf);
395 }
396 
397 static void reclaim_dma_bufs(void)
398 {
399 	unsigned long flags;
400 	struct port_buffer *buf, *tmp;
401 	LIST_HEAD(tmp_list);
402 
403 	if (list_empty(&pending_free_dma_bufs))
404 		return;
405 
406 	/* Create a copy of the pending_free_dma_bufs while holding the lock */
407 	spin_lock_irqsave(&dma_bufs_lock, flags);
408 	list_cut_position(&tmp_list, &pending_free_dma_bufs,
409 			  pending_free_dma_bufs.prev);
410 	spin_unlock_irqrestore(&dma_bufs_lock, flags);
411 
412 	/* Release the dma buffers, without irqs enabled */
413 	list_for_each_entry_safe(buf, tmp, &tmp_list, list) {
414 		list_del(&buf->list);
415 		free_buf(buf, true);
416 	}
417 }
418 
419 static struct port_buffer *alloc_buf(struct virtqueue *vq, size_t buf_size,
420 				     int pages)
421 {
422 	struct port_buffer *buf;
423 
424 	reclaim_dma_bufs();
425 
426 	/*
427 	 * Allocate buffer and the sg list. The sg list array is allocated
428 	 * directly after the port_buffer struct.
429 	 */
430 	buf = kmalloc(sizeof(*buf) + sizeof(struct scatterlist) * pages,
431 		      GFP_KERNEL);
432 	if (!buf)
433 		goto fail;
434 
435 	buf->sgpages = pages;
436 	if (pages > 0) {
437 		buf->dev = NULL;
438 		buf->buf = NULL;
439 		return buf;
440 	}
441 
442 	if (is_rproc_serial(vq->vdev)) {
443 		/*
444 		 * Allocate DMA memory from ancestor. When a virtio
445 		 * device is created by remoteproc, the DMA memory is
446 		 * associated with the grandparent device:
447 		 * vdev => rproc => platform-dev.
448 		 * The code here would have been less quirky if
449 		 * DMA_MEMORY_INCLUDES_CHILDREN had been supported
450 		 * in dma-coherent.c
451 		 */
452 		if (!vq->vdev->dev.parent || !vq->vdev->dev.parent->parent)
453 			goto free_buf;
454 		buf->dev = vq->vdev->dev.parent->parent;
455 
456 		/* Increase device refcnt to avoid freeing it */
457 		get_device(buf->dev);
458 		buf->buf = dma_alloc_coherent(buf->dev, buf_size, &buf->dma,
459 					      GFP_KERNEL);
460 	} else {
461 		buf->dev = NULL;
462 		buf->buf = kmalloc(buf_size, GFP_KERNEL);
463 	}
464 
465 	if (!buf->buf)
466 		goto free_buf;
467 	buf->len = 0;
468 	buf->offset = 0;
469 	buf->size = buf_size;
470 	return buf;
471 
472 free_buf:
473 	kfree(buf);
474 fail:
475 	return NULL;
476 }
477 
478 /* Callers should take appropriate locks */
479 static struct port_buffer *get_inbuf(struct port *port)
480 {
481 	struct port_buffer *buf;
482 	unsigned int len;
483 
484 	if (port->inbuf)
485 		return port->inbuf;
486 
487 	buf = virtqueue_get_buf(port->in_vq, &len);
488 	if (buf) {
489 		buf->len = len;
490 		buf->offset = 0;
491 		port->stats.bytes_received += len;
492 	}
493 	return buf;
494 }
495 
496 /*
497  * Create a scatter-gather list representing our input buffer and put
498  * it in the queue.
499  *
500  * Callers should take appropriate locks.
501  */
502 static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)
503 {
504 	struct scatterlist sg[1];
505 	int ret;
506 
507 	sg_init_one(sg, buf->buf, buf->size);
508 
509 	ret = virtqueue_add_inbuf(vq, sg, 1, buf, GFP_ATOMIC);
510 	virtqueue_kick(vq);
511 	if (!ret)
512 		ret = vq->num_free;
513 	return ret;
514 }
515 
516 /* Discard any unread data this port has. Callers lockers. */
517 static void discard_port_data(struct port *port)
518 {
519 	struct port_buffer *buf;
520 	unsigned int err;
521 
522 	if (!port->portdev) {
523 		/* Device has been unplugged.  vqs are already gone. */
524 		return;
525 	}
526 	buf = get_inbuf(port);
527 
528 	err = 0;
529 	while (buf) {
530 		port->stats.bytes_discarded += buf->len - buf->offset;
531 		if (add_inbuf(port->in_vq, buf) < 0) {
532 			err++;
533 			free_buf(buf, false);
534 		}
535 		port->inbuf = NULL;
536 		buf = get_inbuf(port);
537 	}
538 	if (err)
539 		dev_warn(port->dev, "Errors adding %d buffers back to vq\n",
540 			 err);
541 }
542 
543 static bool port_has_data(struct port *port)
544 {
545 	unsigned long flags;
546 	bool ret;
547 
548 	ret = false;
549 	spin_lock_irqsave(&port->inbuf_lock, flags);
550 	port->inbuf = get_inbuf(port);
551 	if (port->inbuf)
552 		ret = true;
553 
554 	spin_unlock_irqrestore(&port->inbuf_lock, flags);
555 	return ret;
556 }
557 
558 static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id,
559 				  unsigned int event, unsigned int value)
560 {
561 	struct scatterlist sg[1];
562 	struct virtio_console_control cpkt;
563 	struct virtqueue *vq;
564 	unsigned int len;
565 
566 	if (!use_multiport(portdev))
567 		return 0;
568 
569 	cpkt.id = cpu_to_virtio32(portdev->vdev, port_id);
570 	cpkt.event = cpu_to_virtio16(portdev->vdev, event);
571 	cpkt.value = cpu_to_virtio16(portdev->vdev, value);
572 
573 	vq = portdev->c_ovq;
574 
575 	sg_init_one(sg, &cpkt, sizeof(cpkt));
576 
577 	spin_lock(&portdev->c_ovq_lock);
578 	if (virtqueue_add_outbuf(vq, sg, 1, &cpkt, GFP_ATOMIC) == 0) {
579 		virtqueue_kick(vq);
580 		while (!virtqueue_get_buf(vq, &len)
581 			&& !virtqueue_is_broken(vq))
582 			cpu_relax();
583 	}
584 	spin_unlock(&portdev->c_ovq_lock);
585 	return 0;
586 }
587 
588 static ssize_t send_control_msg(struct port *port, unsigned int event,
589 				unsigned int value)
590 {
591 	/* Did the port get unplugged before userspace closed it? */
592 	if (port->portdev)
593 		return __send_control_msg(port->portdev, port->id, event, value);
594 	return 0;
595 }
596 
597 
598 /* Callers must take the port->outvq_lock */
599 static void reclaim_consumed_buffers(struct port *port)
600 {
601 	struct port_buffer *buf;
602 	unsigned int len;
603 
604 	if (!port->portdev) {
605 		/* Device has been unplugged.  vqs are already gone. */
606 		return;
607 	}
608 	while ((buf = virtqueue_get_buf(port->out_vq, &len))) {
609 		free_buf(buf, false);
610 		port->outvq_full = false;
611 	}
612 }
613 
614 static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,
615 			      int nents, size_t in_count,
616 			      void *data, bool nonblock)
617 {
618 	struct virtqueue *out_vq;
619 	int err;
620 	unsigned long flags;
621 	unsigned int len;
622 
623 	out_vq = port->out_vq;
624 
625 	spin_lock_irqsave(&port->outvq_lock, flags);
626 
627 	reclaim_consumed_buffers(port);
628 
629 	err = virtqueue_add_outbuf(out_vq, sg, nents, data, GFP_ATOMIC);
630 
631 	/* Tell Host to go! */
632 	virtqueue_kick(out_vq);
633 
634 	if (err) {
635 		in_count = 0;
636 		goto done;
637 	}
638 
639 	if (out_vq->num_free == 0)
640 		port->outvq_full = true;
641 
642 	if (nonblock)
643 		goto done;
644 
645 	/*
646 	 * Wait till the host acknowledges it pushed out the data we
647 	 * sent.  This is done for data from the hvc_console; the tty
648 	 * operations are performed with spinlocks held so we can't
649 	 * sleep here.  An alternative would be to copy the data to a
650 	 * buffer and relax the spinning requirement.  The downside is
651 	 * we need to kmalloc a GFP_ATOMIC buffer each time the
652 	 * console driver writes something out.
653 	 */
654 	while (!virtqueue_get_buf(out_vq, &len)
655 		&& !virtqueue_is_broken(out_vq))
656 		cpu_relax();
657 done:
658 	spin_unlock_irqrestore(&port->outvq_lock, flags);
659 
660 	port->stats.bytes_sent += in_count;
661 	/*
662 	 * We're expected to return the amount of data we wrote -- all
663 	 * of it
664 	 */
665 	return in_count;
666 }
667 
668 /*
669  * Give out the data that's requested from the buffer that we have
670  * queued up.
671  */
672 static ssize_t fill_readbuf(struct port *port, char __user *out_buf,
673 			    size_t out_count, bool to_user)
674 {
675 	struct port_buffer *buf;
676 	unsigned long flags;
677 
678 	if (!out_count || !port_has_data(port))
679 		return 0;
680 
681 	buf = port->inbuf;
682 	out_count = min(out_count, buf->len - buf->offset);
683 
684 	if (to_user) {
685 		ssize_t ret;
686 
687 		ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count);
688 		if (ret)
689 			return -EFAULT;
690 	} else {
691 		memcpy((__force char *)out_buf, buf->buf + buf->offset,
692 		       out_count);
693 	}
694 
695 	buf->offset += out_count;
696 
697 	if (buf->offset == buf->len) {
698 		/*
699 		 * We're done using all the data in this buffer.
700 		 * Re-queue so that the Host can send us more data.
701 		 */
702 		spin_lock_irqsave(&port->inbuf_lock, flags);
703 		port->inbuf = NULL;
704 
705 		if (add_inbuf(port->in_vq, buf) < 0)
706 			dev_warn(port->dev, "failed add_buf\n");
707 
708 		spin_unlock_irqrestore(&port->inbuf_lock, flags);
709 	}
710 	/* Return the number of bytes actually copied */
711 	return out_count;
712 }
713 
714 /* The condition that must be true for polling to end */
715 static bool will_read_block(struct port *port)
716 {
717 	if (!port->guest_connected) {
718 		/* Port got hot-unplugged. Let's exit. */
719 		return false;
720 	}
721 	return !port_has_data(port) && port->host_connected;
722 }
723 
724 static bool will_write_block(struct port *port)
725 {
726 	bool ret;
727 
728 	if (!port->guest_connected) {
729 		/* Port got hot-unplugged. Let's exit. */
730 		return false;
731 	}
732 	if (!port->host_connected)
733 		return true;
734 
735 	spin_lock_irq(&port->outvq_lock);
736 	/*
737 	 * Check if the Host has consumed any buffers since we last
738 	 * sent data (this is only applicable for nonblocking ports).
739 	 */
740 	reclaim_consumed_buffers(port);
741 	ret = port->outvq_full;
742 	spin_unlock_irq(&port->outvq_lock);
743 
744 	return ret;
745 }
746 
747 static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
748 			      size_t count, loff_t *offp)
749 {
750 	struct port *port;
751 	ssize_t ret;
752 
753 	port = filp->private_data;
754 
755 	/* Port is hot-unplugged. */
756 	if (!port->guest_connected)
757 		return -ENODEV;
758 
759 	if (!port_has_data(port)) {
760 		/*
761 		 * If nothing's connected on the host just return 0 in
762 		 * case of list_empty; this tells the userspace app
763 		 * that there's no connection
764 		 */
765 		if (!port->host_connected)
766 			return 0;
767 		if (filp->f_flags & O_NONBLOCK)
768 			return -EAGAIN;
769 
770 		ret = wait_event_freezable(port->waitqueue,
771 					   !will_read_block(port));
772 		if (ret < 0)
773 			return ret;
774 	}
775 	/* Port got hot-unplugged while we were waiting above. */
776 	if (!port->guest_connected)
777 		return -ENODEV;
778 	/*
779 	 * We could've received a disconnection message while we were
780 	 * waiting for more data.
781 	 *
782 	 * This check is not clubbed in the if() statement above as we
783 	 * might receive some data as well as the host could get
784 	 * disconnected after we got woken up from our wait.  So we
785 	 * really want to give off whatever data we have and only then
786 	 * check for host_connected.
787 	 */
788 	if (!port_has_data(port) && !port->host_connected)
789 		return 0;
790 
791 	return fill_readbuf(port, ubuf, count, true);
792 }
793 
794 static int wait_port_writable(struct port *port, bool nonblock)
795 {
796 	int ret;
797 
798 	if (will_write_block(port)) {
799 		if (nonblock)
800 			return -EAGAIN;
801 
802 		ret = wait_event_freezable(port->waitqueue,
803 					   !will_write_block(port));
804 		if (ret < 0)
805 			return ret;
806 	}
807 	/* Port got hot-unplugged. */
808 	if (!port->guest_connected)
809 		return -ENODEV;
810 
811 	return 0;
812 }
813 
814 static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
815 			       size_t count, loff_t *offp)
816 {
817 	struct port *port;
818 	struct port_buffer *buf;
819 	ssize_t ret;
820 	bool nonblock;
821 	struct scatterlist sg[1];
822 
823 	/* Userspace could be out to fool us */
824 	if (!count)
825 		return 0;
826 
827 	port = filp->private_data;
828 
829 	nonblock = filp->f_flags & O_NONBLOCK;
830 
831 	ret = wait_port_writable(port, nonblock);
832 	if (ret < 0)
833 		return ret;
834 
835 	count = min((size_t)(32 * 1024), count);
836 
837 	buf = alloc_buf(port->out_vq, count, 0);
838 	if (!buf)
839 		return -ENOMEM;
840 
841 	ret = copy_from_user(buf->buf, ubuf, count);
842 	if (ret) {
843 		ret = -EFAULT;
844 		goto free_buf;
845 	}
846 
847 	/*
848 	 * We now ask send_buf() to not spin for generic ports -- we
849 	 * can re-use the same code path that non-blocking file
850 	 * descriptors take for blocking file descriptors since the
851 	 * wait is already done and we're certain the write will go
852 	 * through to the host.
853 	 */
854 	nonblock = true;
855 	sg_init_one(sg, buf->buf, count);
856 	ret = __send_to_port(port, sg, 1, count, buf, nonblock);
857 
858 	if (nonblock && ret > 0)
859 		goto out;
860 
861 free_buf:
862 	free_buf(buf, true);
863 out:
864 	return ret;
865 }
866 
867 struct sg_list {
868 	unsigned int n;
869 	unsigned int size;
870 	size_t len;
871 	struct scatterlist *sg;
872 };
873 
874 static int pipe_to_sg(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
875 			struct splice_desc *sd)
876 {
877 	struct sg_list *sgl = sd->u.data;
878 	unsigned int offset, len;
879 
880 	if (sgl->n == sgl->size)
881 		return 0;
882 
883 	/* Try lock this page */
884 	if (buf->ops->steal(pipe, buf) == 0) {
885 		/* Get reference and unlock page for moving */
886 		get_page(buf->page);
887 		unlock_page(buf->page);
888 
889 		len = min(buf->len, sd->len);
890 		sg_set_page(&(sgl->sg[sgl->n]), buf->page, len, buf->offset);
891 	} else {
892 		/* Failback to copying a page */
893 		struct page *page = alloc_page(GFP_KERNEL);
894 		char *src;
895 
896 		if (!page)
897 			return -ENOMEM;
898 
899 		offset = sd->pos & ~PAGE_MASK;
900 
901 		len = sd->len;
902 		if (len + offset > PAGE_SIZE)
903 			len = PAGE_SIZE - offset;
904 
905 		src = kmap_atomic(buf->page);
906 		memcpy(page_address(page) + offset, src + buf->offset, len);
907 		kunmap_atomic(src);
908 
909 		sg_set_page(&(sgl->sg[sgl->n]), page, len, offset);
910 	}
911 	sgl->n++;
912 	sgl->len += len;
913 
914 	return len;
915 }
916 
917 /* Faster zero-copy write by splicing */
918 static ssize_t port_fops_splice_write(struct pipe_inode_info *pipe,
919 				      struct file *filp, loff_t *ppos,
920 				      size_t len, unsigned int flags)
921 {
922 	struct port *port = filp->private_data;
923 	struct sg_list sgl;
924 	ssize_t ret;
925 	struct port_buffer *buf;
926 	struct splice_desc sd = {
927 		.total_len = len,
928 		.flags = flags,
929 		.pos = *ppos,
930 		.u.data = &sgl,
931 	};
932 
933 	/*
934 	 * Rproc_serial does not yet support splice. To support splice
935 	 * pipe_to_sg() must allocate dma-buffers and copy content from
936 	 * regular pages to dma pages. And alloc_buf and free_buf must
937 	 * support allocating and freeing such a list of dma-buffers.
938 	 */
939 	if (is_rproc_serial(port->out_vq->vdev))
940 		return -EINVAL;
941 
942 	/*
943 	 * pipe->nrbufs == 0 means there are no data to transfer,
944 	 * so this returns just 0 for no data.
945 	 */
946 	pipe_lock(pipe);
947 	if (!pipe->nrbufs) {
948 		ret = 0;
949 		goto error_out;
950 	}
951 
952 	ret = wait_port_writable(port, filp->f_flags & O_NONBLOCK);
953 	if (ret < 0)
954 		goto error_out;
955 
956 	buf = alloc_buf(port->out_vq, 0, pipe->nrbufs);
957 	if (!buf) {
958 		ret = -ENOMEM;
959 		goto error_out;
960 	}
961 
962 	sgl.n = 0;
963 	sgl.len = 0;
964 	sgl.size = pipe->nrbufs;
965 	sgl.sg = buf->sg;
966 	sg_init_table(sgl.sg, sgl.size);
967 	ret = __splice_from_pipe(pipe, &sd, pipe_to_sg);
968 	pipe_unlock(pipe);
969 	if (likely(ret > 0))
970 		ret = __send_to_port(port, buf->sg, sgl.n, sgl.len, buf, true);
971 
972 	if (unlikely(ret <= 0))
973 		free_buf(buf, true);
974 	return ret;
975 
976 error_out:
977 	pipe_unlock(pipe);
978 	return ret;
979 }
980 
981 static unsigned int port_fops_poll(struct file *filp, poll_table *wait)
982 {
983 	struct port *port;
984 	unsigned int ret;
985 
986 	port = filp->private_data;
987 	poll_wait(filp, &port->waitqueue, wait);
988 
989 	if (!port->guest_connected) {
990 		/* Port got unplugged */
991 		return POLLHUP;
992 	}
993 	ret = 0;
994 	if (!will_read_block(port))
995 		ret |= POLLIN | POLLRDNORM;
996 	if (!will_write_block(port))
997 		ret |= POLLOUT;
998 	if (!port->host_connected)
999 		ret |= POLLHUP;
1000 
1001 	return ret;
1002 }
1003 
1004 static void remove_port(struct kref *kref);
1005 
1006 static int port_fops_release(struct inode *inode, struct file *filp)
1007 {
1008 	struct port *port;
1009 
1010 	port = filp->private_data;
1011 
1012 	/* Notify host of port being closed */
1013 	send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
1014 
1015 	spin_lock_irq(&port->inbuf_lock);
1016 	port->guest_connected = false;
1017 
1018 	discard_port_data(port);
1019 
1020 	spin_unlock_irq(&port->inbuf_lock);
1021 
1022 	spin_lock_irq(&port->outvq_lock);
1023 	reclaim_consumed_buffers(port);
1024 	spin_unlock_irq(&port->outvq_lock);
1025 
1026 	reclaim_dma_bufs();
1027 	/*
1028 	 * Locks aren't necessary here as a port can't be opened after
1029 	 * unplug, and if a port isn't unplugged, a kref would already
1030 	 * exist for the port.  Plus, taking ports_lock here would
1031 	 * create a dependency on other locks taken by functions
1032 	 * inside remove_port if we're the last holder of the port,
1033 	 * creating many problems.
1034 	 */
1035 	kref_put(&port->kref, remove_port);
1036 
1037 	return 0;
1038 }
1039 
1040 static int port_fops_open(struct inode *inode, struct file *filp)
1041 {
1042 	struct cdev *cdev = inode->i_cdev;
1043 	struct port *port;
1044 	int ret;
1045 
1046 	/* We get the port with a kref here */
1047 	port = find_port_by_devt(cdev->dev);
1048 	if (!port) {
1049 		/* Port was unplugged before we could proceed */
1050 		return -ENXIO;
1051 	}
1052 	filp->private_data = port;
1053 
1054 	/*
1055 	 * Don't allow opening of console port devices -- that's done
1056 	 * via /dev/hvc
1057 	 */
1058 	if (is_console_port(port)) {
1059 		ret = -ENXIO;
1060 		goto out;
1061 	}
1062 
1063 	/* Allow only one process to open a particular port at a time */
1064 	spin_lock_irq(&port->inbuf_lock);
1065 	if (port->guest_connected) {
1066 		spin_unlock_irq(&port->inbuf_lock);
1067 		ret = -EBUSY;
1068 		goto out;
1069 	}
1070 
1071 	port->guest_connected = true;
1072 	spin_unlock_irq(&port->inbuf_lock);
1073 
1074 	spin_lock_irq(&port->outvq_lock);
1075 	/*
1076 	 * There might be a chance that we missed reclaiming a few
1077 	 * buffers in the window of the port getting previously closed
1078 	 * and opening now.
1079 	 */
1080 	reclaim_consumed_buffers(port);
1081 	spin_unlock_irq(&port->outvq_lock);
1082 
1083 	nonseekable_open(inode, filp);
1084 
1085 	/* Notify host of port being opened */
1086 	send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1);
1087 
1088 	return 0;
1089 out:
1090 	kref_put(&port->kref, remove_port);
1091 	return ret;
1092 }
1093 
1094 static int port_fops_fasync(int fd, struct file *filp, int mode)
1095 {
1096 	struct port *port;
1097 
1098 	port = filp->private_data;
1099 	return fasync_helper(fd, filp, mode, &port->async_queue);
1100 }
1101 
1102 /*
1103  * The file operations that we support: programs in the guest can open
1104  * a console device, read from it, write to it, poll for data and
1105  * close it.  The devices are at
1106  *   /dev/vport<device number>p<port number>
1107  */
1108 static const struct file_operations port_fops = {
1109 	.owner = THIS_MODULE,
1110 	.open  = port_fops_open,
1111 	.read  = port_fops_read,
1112 	.write = port_fops_write,
1113 	.splice_write = port_fops_splice_write,
1114 	.poll  = port_fops_poll,
1115 	.release = port_fops_release,
1116 	.fasync = port_fops_fasync,
1117 	.llseek = no_llseek,
1118 };
1119 
1120 /*
1121  * The put_chars() callback is pretty straightforward.
1122  *
1123  * We turn the characters into a scatter-gather list, add it to the
1124  * output queue and then kick the Host.  Then we sit here waiting for
1125  * it to finish: inefficient in theory, but in practice
1126  * implementations will do it immediately (lguest's Launcher does).
1127  */
1128 static int put_chars(u32 vtermno, const char *buf, int count)
1129 {
1130 	struct port *port;
1131 	struct scatterlist sg[1];
1132 
1133 	if (unlikely(early_put_chars))
1134 		return early_put_chars(vtermno, buf, count);
1135 
1136 	port = find_port_by_vtermno(vtermno);
1137 	if (!port)
1138 		return -EPIPE;
1139 
1140 	sg_init_one(sg, buf, count);
1141 	return __send_to_port(port, sg, 1, count, (void *)buf, false);
1142 }
1143 
1144 /*
1145  * get_chars() is the callback from the hvc_console infrastructure
1146  * when an interrupt is received.
1147  *
1148  * We call out to fill_readbuf that gets us the required data from the
1149  * buffers that are queued up.
1150  */
1151 static int get_chars(u32 vtermno, char *buf, int count)
1152 {
1153 	struct port *port;
1154 
1155 	/* If we've not set up the port yet, we have no input to give. */
1156 	if (unlikely(early_put_chars))
1157 		return 0;
1158 
1159 	port = find_port_by_vtermno(vtermno);
1160 	if (!port)
1161 		return -EPIPE;
1162 
1163 	/* If we don't have an input queue yet, we can't get input. */
1164 	BUG_ON(!port->in_vq);
1165 
1166 	return fill_readbuf(port, (__force char __user *)buf, count, false);
1167 }
1168 
1169 static void resize_console(struct port *port)
1170 {
1171 	struct virtio_device *vdev;
1172 
1173 	/* The port could have been hot-unplugged */
1174 	if (!port || !is_console_port(port))
1175 		return;
1176 
1177 	vdev = port->portdev->vdev;
1178 
1179 	/* Don't test F_SIZE at all if we're rproc: not a valid feature! */
1180 	if (!is_rproc_serial(vdev) &&
1181 	    virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE))
1182 		hvc_resize(port->cons.hvc, port->cons.ws);
1183 }
1184 
1185 /* We set the configuration at this point, since we now have a tty */
1186 static int notifier_add_vio(struct hvc_struct *hp, int data)
1187 {
1188 	struct port *port;
1189 
1190 	port = find_port_by_vtermno(hp->vtermno);
1191 	if (!port)
1192 		return -EINVAL;
1193 
1194 	hp->irq_requested = 1;
1195 	resize_console(port);
1196 
1197 	return 0;
1198 }
1199 
1200 static void notifier_del_vio(struct hvc_struct *hp, int data)
1201 {
1202 	hp->irq_requested = 0;
1203 }
1204 
1205 /* The operations for console ports. */
1206 static const struct hv_ops hv_ops = {
1207 	.get_chars = get_chars,
1208 	.put_chars = put_chars,
1209 	.notifier_add = notifier_add_vio,
1210 	.notifier_del = notifier_del_vio,
1211 	.notifier_hangup = notifier_del_vio,
1212 };
1213 
1214 /*
1215  * Console drivers are initialized very early so boot messages can go
1216  * out, so we do things slightly differently from the generic virtio
1217  * initialization of the net and block drivers.
1218  *
1219  * At this stage, the console is output-only.  It's too early to set
1220  * up a virtqueue, so we let the drivers do some boutique early-output
1221  * thing.
1222  */
1223 int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int))
1224 {
1225 	early_put_chars = put_chars;
1226 	return hvc_instantiate(0, 0, &hv_ops);
1227 }
1228 
1229 static int init_port_console(struct port *port)
1230 {
1231 	int ret;
1232 
1233 	/*
1234 	 * The Host's telling us this port is a console port.  Hook it
1235 	 * up with an hvc console.
1236 	 *
1237 	 * To set up and manage our virtual console, we call
1238 	 * hvc_alloc().
1239 	 *
1240 	 * The first argument of hvc_alloc() is the virtual console
1241 	 * number.  The second argument is the parameter for the
1242 	 * notification mechanism (like irq number).  We currently
1243 	 * leave this as zero, virtqueues have implicit notifications.
1244 	 *
1245 	 * The third argument is a "struct hv_ops" containing the
1246 	 * put_chars() get_chars(), notifier_add() and notifier_del()
1247 	 * pointers.  The final argument is the output buffer size: we
1248 	 * can do any size, so we put PAGE_SIZE here.
1249 	 */
1250 	port->cons.vtermno = pdrvdata.next_vtermno;
1251 
1252 	port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE);
1253 	if (IS_ERR(port->cons.hvc)) {
1254 		ret = PTR_ERR(port->cons.hvc);
1255 		dev_err(port->dev,
1256 			"error %d allocating hvc for port\n", ret);
1257 		port->cons.hvc = NULL;
1258 		return ret;
1259 	}
1260 	spin_lock_irq(&pdrvdata_lock);
1261 	pdrvdata.next_vtermno++;
1262 	list_add_tail(&port->cons.list, &pdrvdata.consoles);
1263 	spin_unlock_irq(&pdrvdata_lock);
1264 	port->guest_connected = true;
1265 
1266 	/*
1267 	 * Start using the new console output if this is the first
1268 	 * console to come up.
1269 	 */
1270 	if (early_put_chars)
1271 		early_put_chars = NULL;
1272 
1273 	/* Notify host of port being opened */
1274 	send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
1275 
1276 	return 0;
1277 }
1278 
1279 static ssize_t show_port_name(struct device *dev,
1280 			      struct device_attribute *attr, char *buffer)
1281 {
1282 	struct port *port;
1283 
1284 	port = dev_get_drvdata(dev);
1285 
1286 	return sprintf(buffer, "%s\n", port->name);
1287 }
1288 
1289 static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL);
1290 
1291 static struct attribute *port_sysfs_entries[] = {
1292 	&dev_attr_name.attr,
1293 	NULL
1294 };
1295 
1296 static struct attribute_group port_attribute_group = {
1297 	.name = NULL,		/* put in device directory */
1298 	.attrs = port_sysfs_entries,
1299 };
1300 
1301 static ssize_t debugfs_read(struct file *filp, char __user *ubuf,
1302 			    size_t count, loff_t *offp)
1303 {
1304 	struct port *port;
1305 	char *buf;
1306 	ssize_t ret, out_offset, out_count;
1307 
1308 	out_count = 1024;
1309 	buf = kmalloc(out_count, GFP_KERNEL);
1310 	if (!buf)
1311 		return -ENOMEM;
1312 
1313 	port = filp->private_data;
1314 	out_offset = 0;
1315 	out_offset += snprintf(buf + out_offset, out_count,
1316 			       "name: %s\n", port->name ? port->name : "");
1317 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
1318 			       "guest_connected: %d\n", port->guest_connected);
1319 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
1320 			       "host_connected: %d\n", port->host_connected);
1321 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
1322 			       "outvq_full: %d\n", port->outvq_full);
1323 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
1324 			       "bytes_sent: %lu\n", port->stats.bytes_sent);
1325 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
1326 			       "bytes_received: %lu\n",
1327 			       port->stats.bytes_received);
1328 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
1329 			       "bytes_discarded: %lu\n",
1330 			       port->stats.bytes_discarded);
1331 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
1332 			       "is_console: %s\n",
1333 			       is_console_port(port) ? "yes" : "no");
1334 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
1335 			       "console_vtermno: %u\n", port->cons.vtermno);
1336 
1337 	ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset);
1338 	kfree(buf);
1339 	return ret;
1340 }
1341 
1342 static const struct file_operations port_debugfs_ops = {
1343 	.owner = THIS_MODULE,
1344 	.open  = simple_open,
1345 	.read  = debugfs_read,
1346 };
1347 
1348 static void set_console_size(struct port *port, u16 rows, u16 cols)
1349 {
1350 	if (!port || !is_console_port(port))
1351 		return;
1352 
1353 	port->cons.ws.ws_row = rows;
1354 	port->cons.ws.ws_col = cols;
1355 }
1356 
1357 static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock)
1358 {
1359 	struct port_buffer *buf;
1360 	unsigned int nr_added_bufs;
1361 	int ret;
1362 
1363 	nr_added_bufs = 0;
1364 	do {
1365 		buf = alloc_buf(vq, PAGE_SIZE, 0);
1366 		if (!buf)
1367 			break;
1368 
1369 		spin_lock_irq(lock);
1370 		ret = add_inbuf(vq, buf);
1371 		if (ret < 0) {
1372 			spin_unlock_irq(lock);
1373 			free_buf(buf, true);
1374 			break;
1375 		}
1376 		nr_added_bufs++;
1377 		spin_unlock_irq(lock);
1378 	} while (ret > 0);
1379 
1380 	return nr_added_bufs;
1381 }
1382 
1383 static void send_sigio_to_port(struct port *port)
1384 {
1385 	if (port->async_queue && port->guest_connected)
1386 		kill_fasync(&port->async_queue, SIGIO, POLL_OUT);
1387 }
1388 
1389 static int add_port(struct ports_device *portdev, u32 id)
1390 {
1391 	char debugfs_name[16];
1392 	struct port *port;
1393 	struct port_buffer *buf;
1394 	dev_t devt;
1395 	unsigned int nr_added_bufs;
1396 	int err;
1397 
1398 	port = kmalloc(sizeof(*port), GFP_KERNEL);
1399 	if (!port) {
1400 		err = -ENOMEM;
1401 		goto fail;
1402 	}
1403 	kref_init(&port->kref);
1404 
1405 	port->portdev = portdev;
1406 	port->id = id;
1407 
1408 	port->name = NULL;
1409 	port->inbuf = NULL;
1410 	port->cons.hvc = NULL;
1411 	port->async_queue = NULL;
1412 
1413 	port->cons.ws.ws_row = port->cons.ws.ws_col = 0;
1414 
1415 	port->host_connected = port->guest_connected = false;
1416 	port->stats = (struct port_stats) { 0 };
1417 
1418 	port->outvq_full = false;
1419 
1420 	port->in_vq = portdev->in_vqs[port->id];
1421 	port->out_vq = portdev->out_vqs[port->id];
1422 
1423 	port->cdev = cdev_alloc();
1424 	if (!port->cdev) {
1425 		dev_err(&port->portdev->vdev->dev, "Error allocating cdev\n");
1426 		err = -ENOMEM;
1427 		goto free_port;
1428 	}
1429 	port->cdev->ops = &port_fops;
1430 
1431 	devt = MKDEV(portdev->chr_major, id);
1432 	err = cdev_add(port->cdev, devt, 1);
1433 	if (err < 0) {
1434 		dev_err(&port->portdev->vdev->dev,
1435 			"Error %d adding cdev for port %u\n", err, id);
1436 		goto free_cdev;
1437 	}
1438 	port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev,
1439 				  devt, port, "vport%up%u",
1440 				  port->portdev->vdev->index, id);
1441 	if (IS_ERR(port->dev)) {
1442 		err = PTR_ERR(port->dev);
1443 		dev_err(&port->portdev->vdev->dev,
1444 			"Error %d creating device for port %u\n",
1445 			err, id);
1446 		goto free_cdev;
1447 	}
1448 
1449 	spin_lock_init(&port->inbuf_lock);
1450 	spin_lock_init(&port->outvq_lock);
1451 	init_waitqueue_head(&port->waitqueue);
1452 
1453 	/* Fill the in_vq with buffers so the host can send us data. */
1454 	nr_added_bufs = fill_queue(port->in_vq, &port->inbuf_lock);
1455 	if (!nr_added_bufs) {
1456 		dev_err(port->dev, "Error allocating inbufs\n");
1457 		err = -ENOMEM;
1458 		goto free_device;
1459 	}
1460 
1461 	if (is_rproc_serial(port->portdev->vdev))
1462 		/*
1463 		 * For rproc_serial assume remote processor is connected.
1464 		 * rproc_serial does not want the console port, only
1465 		 * the generic port implementation.
1466 		 */
1467 		port->host_connected = true;
1468 	else if (!use_multiport(port->portdev)) {
1469 		/*
1470 		 * If we're not using multiport support,
1471 		 * this has to be a console port.
1472 		 */
1473 		err = init_port_console(port);
1474 		if (err)
1475 			goto free_inbufs;
1476 	}
1477 
1478 	spin_lock_irq(&portdev->ports_lock);
1479 	list_add_tail(&port->list, &port->portdev->ports);
1480 	spin_unlock_irq(&portdev->ports_lock);
1481 
1482 	/*
1483 	 * Tell the Host we're set so that it can send us various
1484 	 * configuration parameters for this port (eg, port name,
1485 	 * caching, whether this is a console port, etc.)
1486 	 */
1487 	send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1488 
1489 	if (pdrvdata.debugfs_dir) {
1490 		/*
1491 		 * Finally, create the debugfs file that we can use to
1492 		 * inspect a port's state at any time
1493 		 */
1494 		sprintf(debugfs_name, "vport%up%u",
1495 			port->portdev->vdev->index, id);
1496 		port->debugfs_file = debugfs_create_file(debugfs_name, 0444,
1497 							 pdrvdata.debugfs_dir,
1498 							 port,
1499 							 &port_debugfs_ops);
1500 	}
1501 	return 0;
1502 
1503 free_inbufs:
1504 	while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
1505 		free_buf(buf, true);
1506 free_device:
1507 	device_destroy(pdrvdata.class, port->dev->devt);
1508 free_cdev:
1509 	cdev_del(port->cdev);
1510 free_port:
1511 	kfree(port);
1512 fail:
1513 	/* The host might want to notify management sw about port add failure */
1514 	__send_control_msg(portdev, id, VIRTIO_CONSOLE_PORT_READY, 0);
1515 	return err;
1516 }
1517 
1518 /* No users remain, remove all port-specific data. */
1519 static void remove_port(struct kref *kref)
1520 {
1521 	struct port *port;
1522 
1523 	port = container_of(kref, struct port, kref);
1524 
1525 	kfree(port);
1526 }
1527 
1528 static void remove_port_data(struct port *port)
1529 {
1530 	struct port_buffer *buf;
1531 
1532 	spin_lock_irq(&port->inbuf_lock);
1533 	/* Remove unused data this port might have received. */
1534 	discard_port_data(port);
1535 
1536 	/* Remove buffers we queued up for the Host to send us data in. */
1537 	while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
1538 		free_buf(buf, true);
1539 	spin_unlock_irq(&port->inbuf_lock);
1540 
1541 	spin_lock_irq(&port->outvq_lock);
1542 	reclaim_consumed_buffers(port);
1543 
1544 	/* Free pending buffers from the out-queue. */
1545 	while ((buf = virtqueue_detach_unused_buf(port->out_vq)))
1546 		free_buf(buf, true);
1547 	spin_unlock_irq(&port->outvq_lock);
1548 }
1549 
1550 /*
1551  * Port got unplugged.  Remove port from portdev's list and drop the
1552  * kref reference.  If no userspace has this port opened, it will
1553  * result in immediate removal the port.
1554  */
1555 static void unplug_port(struct port *port)
1556 {
1557 	spin_lock_irq(&port->portdev->ports_lock);
1558 	list_del(&port->list);
1559 	spin_unlock_irq(&port->portdev->ports_lock);
1560 
1561 	spin_lock_irq(&port->inbuf_lock);
1562 	if (port->guest_connected) {
1563 		/* Let the app know the port is going down. */
1564 		send_sigio_to_port(port);
1565 
1566 		/* Do this after sigio is actually sent */
1567 		port->guest_connected = false;
1568 		port->host_connected = false;
1569 
1570 		wake_up_interruptible(&port->waitqueue);
1571 	}
1572 	spin_unlock_irq(&port->inbuf_lock);
1573 
1574 	if (is_console_port(port)) {
1575 		spin_lock_irq(&pdrvdata_lock);
1576 		list_del(&port->cons.list);
1577 		spin_unlock_irq(&pdrvdata_lock);
1578 		hvc_remove(port->cons.hvc);
1579 	}
1580 
1581 	remove_port_data(port);
1582 
1583 	/*
1584 	 * We should just assume the device itself has gone off --
1585 	 * else a close on an open port later will try to send out a
1586 	 * control message.
1587 	 */
1588 	port->portdev = NULL;
1589 
1590 	sysfs_remove_group(&port->dev->kobj, &port_attribute_group);
1591 	device_destroy(pdrvdata.class, port->dev->devt);
1592 	cdev_del(port->cdev);
1593 
1594 	debugfs_remove(port->debugfs_file);
1595 	kfree(port->name);
1596 
1597 	/*
1598 	 * Locks around here are not necessary - a port can't be
1599 	 * opened after we removed the port struct from ports_list
1600 	 * above.
1601 	 */
1602 	kref_put(&port->kref, remove_port);
1603 }
1604 
1605 /* Any private messages that the Host and Guest want to share */
1606 static void handle_control_message(struct virtio_device *vdev,
1607 				   struct ports_device *portdev,
1608 				   struct port_buffer *buf)
1609 {
1610 	struct virtio_console_control *cpkt;
1611 	struct port *port;
1612 	size_t name_size;
1613 	int err;
1614 
1615 	cpkt = (struct virtio_console_control *)(buf->buf + buf->offset);
1616 
1617 	port = find_port_by_id(portdev, virtio32_to_cpu(vdev, cpkt->id));
1618 	if (!port &&
1619 	    cpkt->event != cpu_to_virtio16(vdev, VIRTIO_CONSOLE_PORT_ADD)) {
1620 		/* No valid header at start of buffer.  Drop it. */
1621 		dev_dbg(&portdev->vdev->dev,
1622 			"Invalid index %u in control packet\n", cpkt->id);
1623 		return;
1624 	}
1625 
1626 	switch (virtio16_to_cpu(vdev, cpkt->event)) {
1627 	case VIRTIO_CONSOLE_PORT_ADD:
1628 		if (port) {
1629 			dev_dbg(&portdev->vdev->dev,
1630 				"Port %u already added\n", port->id);
1631 			send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1632 			break;
1633 		}
1634 		if (virtio32_to_cpu(vdev, cpkt->id) >=
1635 		    portdev->config.max_nr_ports) {
1636 			dev_warn(&portdev->vdev->dev,
1637 				"Request for adding port with "
1638 				"out-of-bound id %u, max. supported id: %u\n",
1639 				cpkt->id, portdev->config.max_nr_ports - 1);
1640 			break;
1641 		}
1642 		add_port(portdev, virtio32_to_cpu(vdev, cpkt->id));
1643 		break;
1644 	case VIRTIO_CONSOLE_PORT_REMOVE:
1645 		unplug_port(port);
1646 		break;
1647 	case VIRTIO_CONSOLE_CONSOLE_PORT:
1648 		if (!cpkt->value)
1649 			break;
1650 		if (is_console_port(port))
1651 			break;
1652 
1653 		init_port_console(port);
1654 		complete(&early_console_added);
1655 		/*
1656 		 * Could remove the port here in case init fails - but
1657 		 * have to notify the host first.
1658 		 */
1659 		break;
1660 	case VIRTIO_CONSOLE_RESIZE: {
1661 		struct {
1662 			__u16 rows;
1663 			__u16 cols;
1664 		} size;
1665 
1666 		if (!is_console_port(port))
1667 			break;
1668 
1669 		memcpy(&size, buf->buf + buf->offset + sizeof(*cpkt),
1670 		       sizeof(size));
1671 		set_console_size(port, size.rows, size.cols);
1672 
1673 		port->cons.hvc->irq_requested = 1;
1674 		resize_console(port);
1675 		break;
1676 	}
1677 	case VIRTIO_CONSOLE_PORT_OPEN:
1678 		port->host_connected = virtio16_to_cpu(vdev, cpkt->value);
1679 		wake_up_interruptible(&port->waitqueue);
1680 		/*
1681 		 * If the host port got closed and the host had any
1682 		 * unconsumed buffers, we'll be able to reclaim them
1683 		 * now.
1684 		 */
1685 		spin_lock_irq(&port->outvq_lock);
1686 		reclaim_consumed_buffers(port);
1687 		spin_unlock_irq(&port->outvq_lock);
1688 
1689 		/*
1690 		 * If the guest is connected, it'll be interested in
1691 		 * knowing the host connection state changed.
1692 		 */
1693 		spin_lock_irq(&port->inbuf_lock);
1694 		send_sigio_to_port(port);
1695 		spin_unlock_irq(&port->inbuf_lock);
1696 		break;
1697 	case VIRTIO_CONSOLE_PORT_NAME:
1698 		/*
1699 		 * If we woke up after hibernation, we can get this
1700 		 * again.  Skip it in that case.
1701 		 */
1702 		if (port->name)
1703 			break;
1704 
1705 		/*
1706 		 * Skip the size of the header and the cpkt to get the size
1707 		 * of the name that was sent
1708 		 */
1709 		name_size = buf->len - buf->offset - sizeof(*cpkt) + 1;
1710 
1711 		port->name = kmalloc(name_size, GFP_KERNEL);
1712 		if (!port->name) {
1713 			dev_err(port->dev,
1714 				"Not enough space to store port name\n");
1715 			break;
1716 		}
1717 		strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt),
1718 			name_size - 1);
1719 		port->name[name_size - 1] = 0;
1720 
1721 		/*
1722 		 * Since we only have one sysfs attribute, 'name',
1723 		 * create it only if we have a name for the port.
1724 		 */
1725 		err = sysfs_create_group(&port->dev->kobj,
1726 					 &port_attribute_group);
1727 		if (err) {
1728 			dev_err(port->dev,
1729 				"Error %d creating sysfs device attributes\n",
1730 				err);
1731 		} else {
1732 			/*
1733 			 * Generate a udev event so that appropriate
1734 			 * symlinks can be created based on udev
1735 			 * rules.
1736 			 */
1737 			kobject_uevent(&port->dev->kobj, KOBJ_CHANGE);
1738 		}
1739 		break;
1740 	}
1741 }
1742 
1743 static void control_work_handler(struct work_struct *work)
1744 {
1745 	struct ports_device *portdev;
1746 	struct virtqueue *vq;
1747 	struct port_buffer *buf;
1748 	unsigned int len;
1749 
1750 	portdev = container_of(work, struct ports_device, control_work);
1751 	vq = portdev->c_ivq;
1752 
1753 	spin_lock(&portdev->c_ivq_lock);
1754 	while ((buf = virtqueue_get_buf(vq, &len))) {
1755 		spin_unlock(&portdev->c_ivq_lock);
1756 
1757 		buf->len = len;
1758 		buf->offset = 0;
1759 
1760 		handle_control_message(vq->vdev, portdev, buf);
1761 
1762 		spin_lock(&portdev->c_ivq_lock);
1763 		if (add_inbuf(portdev->c_ivq, buf) < 0) {
1764 			dev_warn(&portdev->vdev->dev,
1765 				 "Error adding buffer to queue\n");
1766 			free_buf(buf, false);
1767 		}
1768 	}
1769 	spin_unlock(&portdev->c_ivq_lock);
1770 }
1771 
1772 static void out_intr(struct virtqueue *vq)
1773 {
1774 	struct port *port;
1775 
1776 	port = find_port_by_vq(vq->vdev->priv, vq);
1777 	if (!port)
1778 		return;
1779 
1780 	wake_up_interruptible(&port->waitqueue);
1781 }
1782 
1783 static void in_intr(struct virtqueue *vq)
1784 {
1785 	struct port *port;
1786 	unsigned long flags;
1787 
1788 	port = find_port_by_vq(vq->vdev->priv, vq);
1789 	if (!port)
1790 		return;
1791 
1792 	spin_lock_irqsave(&port->inbuf_lock, flags);
1793 	port->inbuf = get_inbuf(port);
1794 
1795 	/*
1796 	 * Normally the port should not accept data when the port is
1797 	 * closed. For generic serial ports, the host won't (shouldn't)
1798 	 * send data till the guest is connected. But this condition
1799 	 * can be reached when a console port is not yet connected (no
1800 	 * tty is spawned) and the other side sends out data over the
1801 	 * vring, or when a remote devices start sending data before
1802 	 * the ports are opened.
1803 	 *
1804 	 * A generic serial port will discard data if not connected,
1805 	 * while console ports and rproc-serial ports accepts data at
1806 	 * any time. rproc-serial is initiated with guest_connected to
1807 	 * false because port_fops_open expects this. Console ports are
1808 	 * hooked up with an HVC console and is initialized with
1809 	 * guest_connected to true.
1810 	 */
1811 
1812 	if (!port->guest_connected && !is_rproc_serial(port->portdev->vdev))
1813 		discard_port_data(port);
1814 
1815 	/* Send a SIGIO indicating new data in case the process asked for it */
1816 	send_sigio_to_port(port);
1817 
1818 	spin_unlock_irqrestore(&port->inbuf_lock, flags);
1819 
1820 	wake_up_interruptible(&port->waitqueue);
1821 
1822 	if (is_console_port(port) && hvc_poll(port->cons.hvc))
1823 		hvc_kick();
1824 }
1825 
1826 static void control_intr(struct virtqueue *vq)
1827 {
1828 	struct ports_device *portdev;
1829 
1830 	portdev = vq->vdev->priv;
1831 	schedule_work(&portdev->control_work);
1832 }
1833 
1834 static void config_intr(struct virtio_device *vdev)
1835 {
1836 	struct ports_device *portdev;
1837 
1838 	portdev = vdev->priv;
1839 
1840 	if (!use_multiport(portdev)) {
1841 		struct port *port;
1842 		u16 rows, cols;
1843 
1844 		virtio_cread(vdev, struct virtio_console_config, cols, &cols);
1845 		virtio_cread(vdev, struct virtio_console_config, rows, &rows);
1846 
1847 		port = find_port_by_id(portdev, 0);
1848 		set_console_size(port, rows, cols);
1849 
1850 		/*
1851 		 * We'll use this way of resizing only for legacy
1852 		 * support.  For newer userspace
1853 		 * (VIRTIO_CONSOLE_F_MULTPORT+), use control messages
1854 		 * to indicate console size changes so that it can be
1855 		 * done per-port.
1856 		 */
1857 		resize_console(port);
1858 	}
1859 }
1860 
1861 static int init_vqs(struct ports_device *portdev)
1862 {
1863 	vq_callback_t **io_callbacks;
1864 	char **io_names;
1865 	struct virtqueue **vqs;
1866 	u32 i, j, nr_ports, nr_queues;
1867 	int err;
1868 
1869 	nr_ports = portdev->config.max_nr_ports;
1870 	nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2;
1871 
1872 	vqs = kmalloc(nr_queues * sizeof(struct virtqueue *), GFP_KERNEL);
1873 	io_callbacks = kmalloc(nr_queues * sizeof(vq_callback_t *), GFP_KERNEL);
1874 	io_names = kmalloc(nr_queues * sizeof(char *), GFP_KERNEL);
1875 	portdev->in_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
1876 				  GFP_KERNEL);
1877 	portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
1878 				   GFP_KERNEL);
1879 	if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs ||
1880 	    !portdev->out_vqs) {
1881 		err = -ENOMEM;
1882 		goto free;
1883 	}
1884 
1885 	/*
1886 	 * For backward compat (newer host but older guest), the host
1887 	 * spawns a console port first and also inits the vqs for port
1888 	 * 0 before others.
1889 	 */
1890 	j = 0;
1891 	io_callbacks[j] = in_intr;
1892 	io_callbacks[j + 1] = out_intr;
1893 	io_names[j] = "input";
1894 	io_names[j + 1] = "output";
1895 	j += 2;
1896 
1897 	if (use_multiport(portdev)) {
1898 		io_callbacks[j] = control_intr;
1899 		io_callbacks[j + 1] = NULL;
1900 		io_names[j] = "control-i";
1901 		io_names[j + 1] = "control-o";
1902 
1903 		for (i = 1; i < nr_ports; i++) {
1904 			j += 2;
1905 			io_callbacks[j] = in_intr;
1906 			io_callbacks[j + 1] = out_intr;
1907 			io_names[j] = "input";
1908 			io_names[j + 1] = "output";
1909 		}
1910 	}
1911 	/* Find the queues. */
1912 	err = portdev->vdev->config->find_vqs(portdev->vdev, nr_queues, vqs,
1913 					      io_callbacks,
1914 					      (const char **)io_names);
1915 	if (err)
1916 		goto free;
1917 
1918 	j = 0;
1919 	portdev->in_vqs[0] = vqs[0];
1920 	portdev->out_vqs[0] = vqs[1];
1921 	j += 2;
1922 	if (use_multiport(portdev)) {
1923 		portdev->c_ivq = vqs[j];
1924 		portdev->c_ovq = vqs[j + 1];
1925 
1926 		for (i = 1; i < nr_ports; i++) {
1927 			j += 2;
1928 			portdev->in_vqs[i] = vqs[j];
1929 			portdev->out_vqs[i] = vqs[j + 1];
1930 		}
1931 	}
1932 	kfree(io_names);
1933 	kfree(io_callbacks);
1934 	kfree(vqs);
1935 
1936 	return 0;
1937 
1938 free:
1939 	kfree(portdev->out_vqs);
1940 	kfree(portdev->in_vqs);
1941 	kfree(io_names);
1942 	kfree(io_callbacks);
1943 	kfree(vqs);
1944 
1945 	return err;
1946 }
1947 
1948 static const struct file_operations portdev_fops = {
1949 	.owner = THIS_MODULE,
1950 };
1951 
1952 static void remove_vqs(struct ports_device *portdev)
1953 {
1954 	portdev->vdev->config->del_vqs(portdev->vdev);
1955 	kfree(portdev->in_vqs);
1956 	kfree(portdev->out_vqs);
1957 }
1958 
1959 static void remove_controlq_data(struct ports_device *portdev)
1960 {
1961 	struct port_buffer *buf;
1962 	unsigned int len;
1963 
1964 	if (!use_multiport(portdev))
1965 		return;
1966 
1967 	while ((buf = virtqueue_get_buf(portdev->c_ivq, &len)))
1968 		free_buf(buf, true);
1969 
1970 	while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq)))
1971 		free_buf(buf, true);
1972 }
1973 
1974 /*
1975  * Once we're further in boot, we get probed like any other virtio
1976  * device.
1977  *
1978  * If the host also supports multiple console ports, we check the
1979  * config space to see how many ports the host has spawned.  We
1980  * initialize each port found.
1981  */
1982 static int virtcons_probe(struct virtio_device *vdev)
1983 {
1984 	struct ports_device *portdev;
1985 	int err;
1986 	bool multiport;
1987 	bool early = early_put_chars != NULL;
1988 
1989 	/* Ensure to read early_put_chars now */
1990 	barrier();
1991 
1992 	portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
1993 	if (!portdev) {
1994 		err = -ENOMEM;
1995 		goto fail;
1996 	}
1997 
1998 	/* Attach this portdev to this virtio_device, and vice-versa. */
1999 	portdev->vdev = vdev;
2000 	vdev->priv = portdev;
2001 
2002 	portdev->chr_major = register_chrdev(0, "virtio-portsdev",
2003 					     &portdev_fops);
2004 	if (portdev->chr_major < 0) {
2005 		dev_err(&vdev->dev,
2006 			"Error %d registering chrdev for device %u\n",
2007 			portdev->chr_major, vdev->index);
2008 		err = portdev->chr_major;
2009 		goto free;
2010 	}
2011 
2012 	multiport = false;
2013 	portdev->config.max_nr_ports = 1;
2014 
2015 	/* Don't test MULTIPORT at all if we're rproc: not a valid feature! */
2016 	if (!is_rproc_serial(vdev) &&
2017 	    virtio_cread_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT,
2018 				 struct virtio_console_config, max_nr_ports,
2019 				 &portdev->config.max_nr_ports) == 0) {
2020 		multiport = true;
2021 	}
2022 
2023 	err = init_vqs(portdev);
2024 	if (err < 0) {
2025 		dev_err(&vdev->dev, "Error %d initializing vqs\n", err);
2026 		goto free_chrdev;
2027 	}
2028 
2029 	spin_lock_init(&portdev->ports_lock);
2030 	INIT_LIST_HEAD(&portdev->ports);
2031 
2032 	virtio_device_ready(portdev->vdev);
2033 
2034 	if (multiport) {
2035 		unsigned int nr_added_bufs;
2036 
2037 		spin_lock_init(&portdev->c_ivq_lock);
2038 		spin_lock_init(&portdev->c_ovq_lock);
2039 		INIT_WORK(&portdev->control_work, &control_work_handler);
2040 
2041 		nr_added_bufs = fill_queue(portdev->c_ivq,
2042 					   &portdev->c_ivq_lock);
2043 		if (!nr_added_bufs) {
2044 			dev_err(&vdev->dev,
2045 				"Error allocating buffers for control queue\n");
2046 			err = -ENOMEM;
2047 			goto free_vqs;
2048 		}
2049 	} else {
2050 		/*
2051 		 * For backward compatibility: Create a console port
2052 		 * if we're running on older host.
2053 		 */
2054 		add_port(portdev, 0);
2055 	}
2056 
2057 	spin_lock_irq(&pdrvdata_lock);
2058 	list_add_tail(&portdev->list, &pdrvdata.portdevs);
2059 	spin_unlock_irq(&pdrvdata_lock);
2060 
2061 	__send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2062 			   VIRTIO_CONSOLE_DEVICE_READY, 1);
2063 
2064 	/*
2065 	 * If there was an early virtio console, assume that there are no
2066 	 * other consoles. We need to wait until the hvc_alloc matches the
2067 	 * hvc_instantiate, otherwise tty_open will complain, resulting in
2068 	 * a "Warning: unable to open an initial console" boot failure.
2069 	 * Without multiport this is done in add_port above. With multiport
2070 	 * this might take some host<->guest communication - thus we have to
2071 	 * wait.
2072 	 */
2073 	if (multiport && early)
2074 		wait_for_completion(&early_console_added);
2075 
2076 	return 0;
2077 
2078 free_vqs:
2079 	/* The host might want to notify mgmt sw about device add failure */
2080 	__send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2081 			   VIRTIO_CONSOLE_DEVICE_READY, 0);
2082 	remove_vqs(portdev);
2083 free_chrdev:
2084 	unregister_chrdev(portdev->chr_major, "virtio-portsdev");
2085 free:
2086 	kfree(portdev);
2087 fail:
2088 	return err;
2089 }
2090 
2091 static void virtcons_remove(struct virtio_device *vdev)
2092 {
2093 	struct ports_device *portdev;
2094 	struct port *port, *port2;
2095 
2096 	portdev = vdev->priv;
2097 
2098 	spin_lock_irq(&pdrvdata_lock);
2099 	list_del(&portdev->list);
2100 	spin_unlock_irq(&pdrvdata_lock);
2101 
2102 	/* Disable interrupts for vqs */
2103 	vdev->config->reset(vdev);
2104 	/* Finish up work that's lined up */
2105 	if (use_multiport(portdev))
2106 		cancel_work_sync(&portdev->control_work);
2107 
2108 	list_for_each_entry_safe(port, port2, &portdev->ports, list)
2109 		unplug_port(port);
2110 
2111 	unregister_chrdev(portdev->chr_major, "virtio-portsdev");
2112 
2113 	/*
2114 	 * When yanking out a device, we immediately lose the
2115 	 * (device-side) queues.  So there's no point in keeping the
2116 	 * guest side around till we drop our final reference.  This
2117 	 * also means that any ports which are in an open state will
2118 	 * have to just stop using the port, as the vqs are going
2119 	 * away.
2120 	 */
2121 	remove_controlq_data(portdev);
2122 	remove_vqs(portdev);
2123 	kfree(portdev);
2124 }
2125 
2126 static struct virtio_device_id id_table[] = {
2127 	{ VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID },
2128 	{ 0 },
2129 };
2130 
2131 static unsigned int features[] = {
2132 	VIRTIO_CONSOLE_F_SIZE,
2133 	VIRTIO_CONSOLE_F_MULTIPORT,
2134 };
2135 
2136 static struct virtio_device_id rproc_serial_id_table[] = {
2137 #if IS_ENABLED(CONFIG_REMOTEPROC)
2138 	{ VIRTIO_ID_RPROC_SERIAL, VIRTIO_DEV_ANY_ID },
2139 #endif
2140 	{ 0 },
2141 };
2142 
2143 static unsigned int rproc_serial_features[] = {
2144 };
2145 
2146 #ifdef CONFIG_PM_SLEEP
2147 static int virtcons_freeze(struct virtio_device *vdev)
2148 {
2149 	struct ports_device *portdev;
2150 	struct port *port;
2151 
2152 	portdev = vdev->priv;
2153 
2154 	vdev->config->reset(vdev);
2155 
2156 	virtqueue_disable_cb(portdev->c_ivq);
2157 	cancel_work_sync(&portdev->control_work);
2158 	/*
2159 	 * Once more: if control_work_handler() was running, it would
2160 	 * enable the cb as the last step.
2161 	 */
2162 	virtqueue_disable_cb(portdev->c_ivq);
2163 	remove_controlq_data(portdev);
2164 
2165 	list_for_each_entry(port, &portdev->ports, list) {
2166 		virtqueue_disable_cb(port->in_vq);
2167 		virtqueue_disable_cb(port->out_vq);
2168 		/*
2169 		 * We'll ask the host later if the new invocation has
2170 		 * the port opened or closed.
2171 		 */
2172 		port->host_connected = false;
2173 		remove_port_data(port);
2174 	}
2175 	remove_vqs(portdev);
2176 
2177 	return 0;
2178 }
2179 
2180 static int virtcons_restore(struct virtio_device *vdev)
2181 {
2182 	struct ports_device *portdev;
2183 	struct port *port;
2184 	int ret;
2185 
2186 	portdev = vdev->priv;
2187 
2188 	ret = init_vqs(portdev);
2189 	if (ret)
2190 		return ret;
2191 
2192 	virtio_device_ready(portdev->vdev);
2193 
2194 	if (use_multiport(portdev))
2195 		fill_queue(portdev->c_ivq, &portdev->c_ivq_lock);
2196 
2197 	list_for_each_entry(port, &portdev->ports, list) {
2198 		port->in_vq = portdev->in_vqs[port->id];
2199 		port->out_vq = portdev->out_vqs[port->id];
2200 
2201 		fill_queue(port->in_vq, &port->inbuf_lock);
2202 
2203 		/* Get port open/close status on the host */
2204 		send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
2205 
2206 		/*
2207 		 * If a port was open at the time of suspending, we
2208 		 * have to let the host know that it's still open.
2209 		 */
2210 		if (port->guest_connected)
2211 			send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
2212 	}
2213 	return 0;
2214 }
2215 #endif
2216 
2217 static struct virtio_driver virtio_console = {
2218 	.feature_table = features,
2219 	.feature_table_size = ARRAY_SIZE(features),
2220 	.driver.name =	KBUILD_MODNAME,
2221 	.driver.owner =	THIS_MODULE,
2222 	.id_table =	id_table,
2223 	.probe =	virtcons_probe,
2224 	.remove =	virtcons_remove,
2225 	.config_changed = config_intr,
2226 #ifdef CONFIG_PM_SLEEP
2227 	.freeze =	virtcons_freeze,
2228 	.restore =	virtcons_restore,
2229 #endif
2230 };
2231 
2232 static struct virtio_driver virtio_rproc_serial = {
2233 	.feature_table = rproc_serial_features,
2234 	.feature_table_size = ARRAY_SIZE(rproc_serial_features),
2235 	.driver.name =	"virtio_rproc_serial",
2236 	.driver.owner =	THIS_MODULE,
2237 	.id_table =	rproc_serial_id_table,
2238 	.probe =	virtcons_probe,
2239 	.remove =	virtcons_remove,
2240 };
2241 
2242 static int __init init(void)
2243 {
2244 	int err;
2245 
2246 	pdrvdata.class = class_create(THIS_MODULE, "virtio-ports");
2247 	if (IS_ERR(pdrvdata.class)) {
2248 		err = PTR_ERR(pdrvdata.class);
2249 		pr_err("Error %d creating virtio-ports class\n", err);
2250 		return err;
2251 	}
2252 
2253 	pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL);
2254 	if (!pdrvdata.debugfs_dir)
2255 		pr_warning("Error creating debugfs dir for virtio-ports\n");
2256 	INIT_LIST_HEAD(&pdrvdata.consoles);
2257 	INIT_LIST_HEAD(&pdrvdata.portdevs);
2258 
2259 	err = register_virtio_driver(&virtio_console);
2260 	if (err < 0) {
2261 		pr_err("Error %d registering virtio driver\n", err);
2262 		goto free;
2263 	}
2264 	err = register_virtio_driver(&virtio_rproc_serial);
2265 	if (err < 0) {
2266 		pr_err("Error %d registering virtio rproc serial driver\n",
2267 		       err);
2268 		goto unregister;
2269 	}
2270 	return 0;
2271 unregister:
2272 	unregister_virtio_driver(&virtio_console);
2273 free:
2274 	debugfs_remove_recursive(pdrvdata.debugfs_dir);
2275 	class_destroy(pdrvdata.class);
2276 	return err;
2277 }
2278 
2279 static void __exit fini(void)
2280 {
2281 	reclaim_dma_bufs();
2282 
2283 	unregister_virtio_driver(&virtio_console);
2284 	unregister_virtio_driver(&virtio_rproc_serial);
2285 
2286 	class_destroy(pdrvdata.class);
2287 	debugfs_remove_recursive(pdrvdata.debugfs_dir);
2288 }
2289 module_init(init);
2290 module_exit(fini);
2291 
2292 MODULE_DEVICE_TABLE(virtio, id_table);
2293 MODULE_DESCRIPTION("Virtio console driver");
2294 MODULE_LICENSE("GPL");
2295