blob: 6928d094451d607795b4f2a07d7599e01712f824 [file] [log] [blame]
Rusty Russella23ea922010-01-18 19:14:55 +05301/*
2 * Copyright (C) 2006, 2007, 2009 Rusty Russell, IBM Corporation
Amit Shah5084f892011-01-31 13:06:37 +05303 * Copyright (C) 2009, 2010, 2011 Red Hat, Inc.
4 * Copyright (C) 2009, 2010, 2011 Amit Shah <amit.shah@redhat.com>
Rusty Russell31610432007-10-22 11:03:39 +10005 *
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 */
Amit Shahfb08bd22009-12-21 21:36:04 +053020#include <linux/cdev.h>
Amit Shahd99393e2009-12-21 22:36:21 +053021#include <linux/debugfs.h>
Christian Borntraeger5e384832011-09-22 23:44:23 +053022#include <linux/completion.h>
Amit Shahfb08bd22009-12-21 21:36:04 +053023#include <linux/device.h>
Rusty Russell31610432007-10-22 11:03:39 +100024#include <linux/err.h>
Amit Shaha08fa922011-09-14 13:06:41 +053025#include <linux/freezer.h>
Amit Shah2030fa42009-12-21 21:49:30 +053026#include <linux/fs.h>
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +090027#include <linux/splice.h>
28#include <linux/pagemap.h>
Rusty Russell31610432007-10-22 11:03:39 +100029#include <linux/init.h>
Amit Shah38edf582010-01-18 19:15:05 +053030#include <linux/list.h>
Amit Shah2030fa42009-12-21 21:49:30 +053031#include <linux/poll.h>
32#include <linux/sched.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090033#include <linux/slab.h>
Amit Shah38edf582010-01-18 19:15:05 +053034#include <linux/spinlock.h>
Rusty Russell31610432007-10-22 11:03:39 +100035#include <linux/virtio.h>
36#include <linux/virtio_console.h>
Amit Shah2030fa42009-12-21 21:49:30 +053037#include <linux/wait.h>
Amit Shah17634ba2009-12-21 21:03:25 +053038#include <linux/workqueue.h>
Paul Gortmakerc22405c2011-07-03 13:35:48 -040039#include <linux/module.h>
Sjur Brændeland1b637042012-12-14 14:40:51 +103040#include <linux/dma-mapping.h>
41#include <linux/kconfig.h>
Amit Shah51df0ac2011-02-01 09:31:25 +053042#include "../tty/hvc/hvc_console.h"
Rusty Russell31610432007-10-22 11:03:39 +100043
Sjur Brændeland1b637042012-12-14 14:40:51 +103044#define is_rproc_enabled IS_ENABLED(CONFIG_REMOTEPROC)
45
Amit Shah38edf582010-01-18 19:15:05 +053046/*
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 */
54struct ports_driver_data {
Amit Shahfb08bd22009-12-21 21:36:04 +053055 /* Used for registering chardevs */
56 struct class *class;
57
Amit Shahd99393e2009-12-21 22:36:21 +053058 /* Used for exporting per-port information to debugfs */
59 struct dentry *debugfs_dir;
60
Amit Shah6bdf2af2010-09-02 18:11:49 +053061 /* List of all the devices we're handling */
62 struct list_head portdevs;
63
Rusty Russelld8a02bd2010-01-18 19:15:06 +053064 /*
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
Amit Shah38edf582010-01-18 19:15:05 +053076 /* All the console devices handled by this driver */
77 struct list_head consoles;
78};
79static struct ports_driver_data pdrvdata;
80
Wei Yongjun38268352013-04-08 16:13:59 +093081static DEFINE_SPINLOCK(pdrvdata_lock);
82static DECLARE_COMPLETION(early_console_added);
Amit Shah38edf582010-01-18 19:15:05 +053083
Amit Shah4f23c572010-01-18 19:15:09 +053084/* This struct holds information that's relevant only for console ports */
85struct 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
Amit Shah97788292010-05-06 02:05:08 +053092 /* The size of the console */
93 struct winsize ws;
94
Amit Shah4f23c572010-01-18 19:15:09 +053095 /*
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
Amit Shahfdb9a052010-01-18 19:15:01 +0530105struct 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;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030115
Sjur Brændeland1b637042012-12-14 14:40:51 +1030116 /* 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
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030125 /* 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];
Amit Shahfdb9a052010-01-18 19:15:01 +0530130};
131
Amit Shah17634ba2009-12-21 21:03:25 +0530132/*
133 * This is a per-device struct that stores data common to all the
134 * ports for that device (vdev->priv).
135 */
136struct ports_device {
Amit Shah6bdf2af2010-09-02 18:11:49 +0530137 /* Next portdev in the list, head is in the pdrvdata struct */
138 struct list_head list;
139
Amit Shah17634ba2009-12-21 21:03:25 +0530140 /*
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 */
Amit Shah165b1b82013-03-29 16:30:07 +0530152 spinlock_t c_ivq_lock;
Amit Shah9ba5c802013-03-29 16:30:08 +0530153 spinlock_t c_ovq_lock;
Amit Shah17634ba2009-12-21 21:03:25 +0530154
155 /* The current config space is stored here */
Amit Shahb99fa812010-05-19 22:15:46 -0600156 struct virtio_console_config config;
Amit Shah17634ba2009-12-21 21:03:25 +0530157
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;
Amit Shahfb08bd22009-12-21 21:36:04 +0530169
Amit Shahfb08bd22009-12-21 21:36:04 +0530170 /* Major number for this device. Ports will be created as minors. */
171 int chr_major;
Amit Shah17634ba2009-12-21 21:03:25 +0530172};
173
Amit Shah17e5b4f2011-09-14 13:06:46 +0530174struct port_stats {
175 unsigned long bytes_sent, bytes_received, bytes_discarded;
176};
177
Amit Shah1c85bf32010-01-18 19:15:07 +0530178/* This struct holds the per-port data */
Rusty Russell21206ed2010-01-18 19:15:00 +0530179struct port {
Amit Shah17634ba2009-12-21 21:03:25 +0530180 /* Next port in the list, head is in the ports_device */
181 struct list_head list;
182
Amit Shah1c85bf32010-01-18 19:15:07 +0530183 /* Pointer to the parent virtio_console device */
184 struct ports_device *portdev;
Amit Shahfdb9a052010-01-18 19:15:01 +0530185
186 /* The current buffer from which data has to be fed to readers */
187 struct port_buffer *inbuf;
Rusty Russell31610432007-10-22 11:03:39 +1000188
Amit Shah203baab2010-01-18 19:15:12 +0530189 /*
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
Amit Shahcdfadfc2010-05-19 22:15:50 -0600196 /* Protect the operations on the out_vq. */
197 spinlock_t outvq_lock;
198
Amit Shah1c85bf32010-01-18 19:15:07 +0530199 /* The IO vqs for this port */
200 struct virtqueue *in_vq, *out_vq;
201
Amit Shahd99393e2009-12-21 22:36:21 +0530202 /* File in the debugfs directory that exposes this port's information */
203 struct dentry *debugfs_file;
204
Amit Shah4f23c572010-01-18 19:15:09 +0530205 /*
Amit Shah17e5b4f2011-09-14 13:06:46 +0530206 * 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 /*
Amit Shah4f23c572010-01-18 19:15:09 +0530213 * The entries in this struct will be valid if this port is
214 * hooked up to an hvc console
215 */
216 struct console cons;
Amit Shah17634ba2009-12-21 21:03:25 +0530217
Amit Shahfb08bd22009-12-21 21:36:04 +0530218 /* Each port associates with a separate char device */
Amit Shahd22a6982010-09-02 18:20:59 +0530219 struct cdev *cdev;
Amit Shahfb08bd22009-12-21 21:36:04 +0530220 struct device *dev;
221
Amit Shahb353a6b2010-09-02 18:38:29 +0530222 /* Reference-counting to handle port hot-unplugs and file operations */
223 struct kref kref;
224
Amit Shah2030fa42009-12-21 21:49:30 +0530225 /* A waitqueue for poll() or blocking read operations */
226 wait_queue_head_t waitqueue;
227
Amit Shah431edb82009-12-21 21:57:40 +0530228 /* The 'name' of the port that we expose via sysfs properties */
229 char *name;
230
Amit Shah3eae0ad2010-09-02 18:47:52 +0530231 /* We can notify apps of host connect / disconnect events via SIGIO */
232 struct fasync_struct *async_queue;
233
Amit Shah17634ba2009-12-21 21:03:25 +0530234 /* The 'id' to identify the port with the Host */
235 u32 id;
Amit Shah2030fa42009-12-21 21:49:30 +0530236
Amit Shahcdfadfc2010-05-19 22:15:50 -0600237 bool outvq_full;
238
Amit Shah2030fa42009-12-21 21:49:30 +0530239 /* Is the host device open */
240 bool host_connected;
Amit Shah3c7969c2009-11-26 11:25:38 +0530241
242 /* We should allow only one process to open a port */
243 bool guest_connected;
Rusty Russell21206ed2010-01-18 19:15:00 +0530244};
Rusty Russell31610432007-10-22 11:03:39 +1000245
Rusty Russell971f3392010-01-18 19:14:56 +0530246/* This is the very early arch-specified put chars function. */
247static int (*early_put_chars)(u32, const char *, int);
248
Amit Shah38edf582010-01-18 19:15:05 +0530249static struct port *find_port_by_vtermno(u32 vtermno)
250{
251 struct port *port;
Amit Shah4f23c572010-01-18 19:15:09 +0530252 struct console *cons;
Amit Shah38edf582010-01-18 19:15:05 +0530253 unsigned long flags;
254
255 spin_lock_irqsave(&pdrvdata_lock, flags);
Amit Shah4f23c572010-01-18 19:15:09 +0530256 list_for_each_entry(cons, &pdrvdata.consoles, list) {
257 if (cons->vtermno == vtermno) {
258 port = container_of(cons, struct port, cons);
Amit Shah38edf582010-01-18 19:15:05 +0530259 goto out;
Amit Shah4f23c572010-01-18 19:15:09 +0530260 }
Amit Shah38edf582010-01-18 19:15:05 +0530261 }
262 port = NULL;
263out:
264 spin_unlock_irqrestore(&pdrvdata_lock, flags);
265 return port;
266}
267
Amit Shah04950cd2010-09-02 18:20:58 +0530268static 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);
Amit Shah057b82b2013-07-29 14:16:13 +0930275 list_for_each_entry(port, &portdev->ports, list) {
276 if (port->cdev->dev == dev) {
277 kref_get(&port->kref);
Amit Shah04950cd2010-09-02 18:20:58 +0530278 goto out;
Amit Shah057b82b2013-07-29 14:16:13 +0930279 }
280 }
Amit Shah04950cd2010-09-02 18:20:58 +0530281 port = NULL;
282out:
283 spin_unlock_irqrestore(&portdev->ports_lock, flags);
284
285 return port;
286}
287
288static 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;
301out:
302 spin_unlock_irqrestore(&pdrvdata_lock, flags);
303 return port;
304}
305
Amit Shah17634ba2009-12-21 21:03:25 +0530306static 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;
316out:
317 spin_unlock_irqrestore(&portdev->ports_lock, flags);
318
319 return port;
320}
321
Amit Shah203baab2010-01-18 19:15:12 +0530322static struct port *find_port_by_vq(struct ports_device *portdev,
323 struct virtqueue *vq)
324{
325 struct port *port;
Amit Shah203baab2010-01-18 19:15:12 +0530326 unsigned long flags;
327
Amit Shah17634ba2009-12-21 21:03:25 +0530328 spin_lock_irqsave(&portdev->ports_lock, flags);
329 list_for_each_entry(port, &portdev->ports, list)
Amit Shah203baab2010-01-18 19:15:12 +0530330 if (port->in_vq == vq || port->out_vq == vq)
331 goto out;
Amit Shah203baab2010-01-18 19:15:12 +0530332 port = NULL;
333out:
Amit Shah17634ba2009-12-21 21:03:25 +0530334 spin_unlock_irqrestore(&portdev->ports_lock, flags);
Amit Shah203baab2010-01-18 19:15:12 +0530335 return port;
336}
337
Amit Shah17634ba2009-12-21 21:03:25 +0530338static bool is_console_port(struct port *port)
339{
340 if (port->cons.hvc)
341 return true;
342 return false;
343}
344
Sjur Brændeland1b637042012-12-14 14:40:51 +1030345static bool is_rproc_serial(const struct virtio_device *vdev)
346{
347 return is_rproc_enabled && vdev->id.device == VIRTIO_ID_RPROC_SERIAL;
348}
349
Amit Shah17634ba2009-12-21 21:03:25 +0530350static 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 portdev->vdev->features[0] & (1 << VIRTIO_CONSOLE_F_MULTIPORT);
359}
360
Sjur Brændeland1b637042012-12-14 14:40:51 +1030361static DEFINE_SPINLOCK(dma_bufs_lock);
362static LIST_HEAD(pending_free_dma_bufs);
363
364static void free_buf(struct port_buffer *buf, bool can_sleep)
Amit Shahfdb9a052010-01-18 19:15:01 +0530365{
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030366 unsigned int i;
367
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030368 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
Sjur Brændeland1b637042012-12-14 14:40:51 +1030375 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
Amit Shahfdb9a052010-01-18 19:15:01 +0530394 kfree(buf);
395}
396
Sjur Brændeland1b637042012-12-14 14:40:51 +1030397static 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
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030419static struct port_buffer *alloc_buf(struct virtqueue *vq, size_t buf_size,
420 int pages)
Amit Shahfdb9a052010-01-18 19:15:01 +0530421{
422 struct port_buffer *buf;
423
Sjur Brændeland1b637042012-12-14 14:40:51 +1030424 reclaim_dma_bufs();
425
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030426 /*
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);
Amit Shahfdb9a052010-01-18 19:15:01 +0530432 if (!buf)
433 goto fail;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030434
435 buf->sgpages = pages;
436 if (pages > 0) {
Sjur Brændeland1b637042012-12-14 14:40:51 +1030437 buf->dev = NULL;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030438 buf->buf = NULL;
439 return buf;
440 }
441
Sjur Brændeland1b637042012-12-14 14:40:51 +1030442 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
Amit Shahfdb9a052010-01-18 19:15:01 +0530465 if (!buf->buf)
466 goto free_buf;
467 buf->len = 0;
468 buf->offset = 0;
469 buf->size = buf_size;
470 return buf;
471
472free_buf:
473 kfree(buf);
474fail:
475 return NULL;
476}
477
Amit Shaha3cde442010-01-18 19:15:03 +0530478/* Callers should take appropriate locks */
Amit Shahdefde662011-09-14 13:06:42 +0530479static struct port_buffer *get_inbuf(struct port *port)
Amit Shaha3cde442010-01-18 19:15:03 +0530480{
481 struct port_buffer *buf;
Amit Shaha3cde442010-01-18 19:15:03 +0530482 unsigned int len;
483
Amit Shahd25a9dd2011-09-14 13:06:43 +0530484 if (port->inbuf)
485 return port->inbuf;
486
487 buf = virtqueue_get_buf(port->in_vq, &len);
Amit Shaha3cde442010-01-18 19:15:03 +0530488 if (buf) {
489 buf->len = len;
490 buf->offset = 0;
Amit Shah17e5b4f2011-09-14 13:06:46 +0530491 port->stats.bytes_received += len;
Amit Shaha3cde442010-01-18 19:15:03 +0530492 }
493 return buf;
494}
495
Rusty Russella23ea922010-01-18 19:14:55 +0530496/*
Amit Shahe27b5192010-01-18 19:15:02 +0530497 * Create a scatter-gather list representing our input buffer and put
498 * it in the queue.
499 *
500 * Callers should take appropriate locks.
501 */
Amit Shah203baab2010-01-18 19:15:12 +0530502static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)
Amit Shahe27b5192010-01-18 19:15:02 +0530503{
504 struct scatterlist sg[1];
Amit Shah203baab2010-01-18 19:15:12 +0530505 int ret;
Amit Shah1c85bf32010-01-18 19:15:07 +0530506
Amit Shahe27b5192010-01-18 19:15:02 +0530507 sg_init_one(sg, buf->buf, buf->size);
508
Rusty Russell67979992013-03-20 15:44:29 +1030509 ret = virtqueue_add_inbuf(vq, sg, 1, buf, GFP_ATOMIC);
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300510 virtqueue_kick(vq);
Amit Shah49e86f12012-12-10 09:45:12 +1030511 if (!ret)
512 ret = vq->num_free;
Amit Shah203baab2010-01-18 19:15:12 +0530513 return ret;
514}
515
Amit Shah88f251a2009-12-21 22:15:30 +0530516/* Discard any unread data this port has. Callers lockers. */
517static void discard_port_data(struct port *port)
518{
519 struct port_buffer *buf;
Amit Shah2d24cda2011-09-14 13:06:45 +0530520 unsigned int err;
Amit Shah88f251a2009-12-21 22:15:30 +0530521
Amit Shahd7a62cd2011-03-04 14:04:33 +1030522 if (!port->portdev) {
523 /* Device has been unplugged. vqs are already gone. */
524 return;
525 }
Amit Shah2d24cda2011-09-14 13:06:45 +0530526 buf = get_inbuf(port);
Amit Shah88f251a2009-12-21 22:15:30 +0530527
Amit Shahce072a02011-09-14 13:06:44 +0530528 err = 0;
Amit Shahd6933562010-02-12 10:32:18 +0530529 while (buf) {
Amit Shah17e5b4f2011-09-14 13:06:46 +0530530 port->stats.bytes_discarded += buf->len - buf->offset;
Amit Shah2d24cda2011-09-14 13:06:45 +0530531 if (add_inbuf(port->in_vq, buf) < 0) {
Amit Shahce072a02011-09-14 13:06:44 +0530532 err++;
Sjur Brændeland1b637042012-12-14 14:40:51 +1030533 free_buf(buf, false);
Amit Shahd6933562010-02-12 10:32:18 +0530534 }
Amit Shah2d24cda2011-09-14 13:06:45 +0530535 port->inbuf = NULL;
536 buf = get_inbuf(port);
Amit Shah88f251a2009-12-21 22:15:30 +0530537 }
Amit Shahce072a02011-09-14 13:06:44 +0530538 if (err)
Amit Shahd6933562010-02-12 10:32:18 +0530539 dev_warn(port->dev, "Errors adding %d buffers back to vq\n",
Amit Shahce072a02011-09-14 13:06:44 +0530540 err);
Amit Shah88f251a2009-12-21 22:15:30 +0530541}
542
Amit Shah203baab2010-01-18 19:15:12 +0530543static bool port_has_data(struct port *port)
544{
545 unsigned long flags;
546 bool ret;
547
Amit Shahd6933562010-02-12 10:32:18 +0530548 ret = false;
Amit Shahd25a9dd2011-09-14 13:06:43 +0530549 spin_lock_irqsave(&port->inbuf_lock, flags);
550 port->inbuf = get_inbuf(port);
551 if (port->inbuf)
552 ret = true;
553
Amit Shah203baab2010-01-18 19:15:12 +0530554 spin_unlock_irqrestore(&port->inbuf_lock, flags);
Amit Shah203baab2010-01-18 19:15:12 +0530555 return ret;
556}
557
Amit Shah3425e702010-05-19 22:15:46 -0600558static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id,
559 unsigned int event, unsigned int value)
Amit Shah17634ba2009-12-21 21:03:25 +0530560{
561 struct scatterlist sg[1];
562 struct virtio_console_control cpkt;
563 struct virtqueue *vq;
Amit Shah604b2ad2010-02-24 10:36:51 +0530564 unsigned int len;
Amit Shah17634ba2009-12-21 21:03:25 +0530565
Amit Shah3425e702010-05-19 22:15:46 -0600566 if (!use_multiport(portdev))
Amit Shah17634ba2009-12-21 21:03:25 +0530567 return 0;
568
Amit Shah3425e702010-05-19 22:15:46 -0600569 cpkt.id = port_id;
Amit Shah17634ba2009-12-21 21:03:25 +0530570 cpkt.event = event;
571 cpkt.value = value;
572
Amit Shah3425e702010-05-19 22:15:46 -0600573 vq = portdev->c_ovq;
Amit Shah17634ba2009-12-21 21:03:25 +0530574
575 sg_init_one(sg, &cpkt, sizeof(cpkt));
Amit Shah9ba5c802013-03-29 16:30:08 +0530576
577 spin_lock(&portdev->c_ovq_lock);
Rusty Russell67979992013-03-20 15:44:29 +1030578 if (virtqueue_add_outbuf(vq, sg, 1, &cpkt, GFP_ATOMIC) == 0) {
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300579 virtqueue_kick(vq);
Heinz Graalfs40e4dc52013-10-29 09:40:39 +1030580 while (!virtqueue_get_buf(vq, &len)
581 && !virtqueue_is_broken(vq))
Amit Shah17634ba2009-12-21 21:03:25 +0530582 cpu_relax();
583 }
Amit Shah9ba5c802013-03-29 16:30:08 +0530584 spin_unlock(&portdev->c_ovq_lock);
Amit Shah17634ba2009-12-21 21:03:25 +0530585 return 0;
586}
587
Amit Shah3425e702010-05-19 22:15:46 -0600588static ssize_t send_control_msg(struct port *port, unsigned int event,
589 unsigned int value)
590{
Amit Shah84ec06c2010-09-02 18:11:42 +0530591 /* 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;
Amit Shah3425e702010-05-19 22:15:46 -0600595}
596
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900597
Amit Shahcdfadfc2010-05-19 22:15:50 -0600598/* Callers must take the port->outvq_lock */
599static void reclaim_consumed_buffers(struct port *port)
600{
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030601 struct port_buffer *buf;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600602 unsigned int len;
603
Amit Shahd7a62cd2011-03-04 14:04:33 +1030604 if (!port->portdev) {
605 /* Device has been unplugged. vqs are already gone. */
606 return;
607 }
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030608 while ((buf = virtqueue_get_buf(port->out_vq, &len))) {
Sjur Brændeland1b637042012-12-14 14:40:51 +1030609 free_buf(buf, false);
Amit Shahcdfadfc2010-05-19 22:15:50 -0600610 port->outvq_full = false;
611 }
612}
613
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900614static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,
615 int nents, size_t in_count,
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030616 void *data, bool nonblock)
Amit Shahf997f00b2009-12-21 17:28:51 +0530617{
Amit Shahf997f00b2009-12-21 17:28:51 +0530618 struct virtqueue *out_vq;
Rusty Russell589575a2012-10-16 23:56:15 +1030619 int err;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600620 unsigned long flags;
Amit Shahf997f00b2009-12-21 17:28:51 +0530621 unsigned int len;
622
623 out_vq = port->out_vq;
624
Amit Shahcdfadfc2010-05-19 22:15:50 -0600625 spin_lock_irqsave(&port->outvq_lock, flags);
626
627 reclaim_consumed_buffers(port);
628
Rusty Russell67979992013-03-20 15:44:29 +1030629 err = virtqueue_add_outbuf(out_vq, sg, nents, data, GFP_ATOMIC);
Amit Shahf997f00b2009-12-21 17:28:51 +0530630
631 /* Tell Host to go! */
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300632 virtqueue_kick(out_vq);
Amit Shahf997f00b2009-12-21 17:28:51 +0530633
Rusty Russell589575a2012-10-16 23:56:15 +1030634 if (err) {
Rusty Russell9ff4cfa2010-04-08 09:46:16 -0600635 in_count = 0;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600636 goto done;
Amit Shahf997f00b2009-12-21 17:28:51 +0530637 }
638
Rusty Russell589575a2012-10-16 23:56:15 +1030639 if (out_vq->num_free == 0)
Amit Shahcdfadfc2010-05-19 22:15:50 -0600640 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
Amit Shah531295e2010-10-20 13:45:43 +1030647 * 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.
Amit Shahcdfadfc2010-05-19 22:15:50 -0600653 */
Heinz Graalfs40e4dc52013-10-29 09:40:39 +1030654 while (!virtqueue_get_buf(out_vq, &len)
655 && !virtqueue_is_broken(out_vq))
Amit Shahf997f00b2009-12-21 17:28:51 +0530656 cpu_relax();
Amit Shahcdfadfc2010-05-19 22:15:50 -0600657done:
658 spin_unlock_irqrestore(&port->outvq_lock, flags);
Amit Shah17e5b4f2011-09-14 13:06:46 +0530659
660 port->stats.bytes_sent += in_count;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600661 /*
662 * We're expected to return the amount of data we wrote -- all
663 * of it
664 */
Rusty Russell9ff4cfa2010-04-08 09:46:16 -0600665 return in_count;
Amit Shahf997f00b2009-12-21 17:28:51 +0530666}
667
Amit Shah203baab2010-01-18 19:15:12 +0530668/*
669 * Give out the data that's requested from the buffer that we have
670 * queued up.
671 */
Amit Shahb766cee2009-12-21 21:26:45 +0530672static ssize_t fill_readbuf(struct port *port, char *out_buf, size_t out_count,
673 bool to_user)
Amit Shah203baab2010-01-18 19:15:12 +0530674{
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;
Amit Shahb766cee2009-12-21 21:26:45 +0530682 out_count = min(out_count, buf->len - buf->offset);
Amit Shah203baab2010-01-18 19:15:12 +0530683
Amit Shahb766cee2009-12-21 21:26:45 +0530684 if (to_user) {
685 ssize_t ret;
Amit Shah203baab2010-01-18 19:15:12 +0530686
Amit Shahb766cee2009-12-21 21:26:45 +0530687 ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count);
688 if (ret)
689 return -EFAULT;
690 } else {
691 memcpy(out_buf, buf->buf + buf->offset, out_count);
692 }
693
Amit Shah203baab2010-01-18 19:15:12 +0530694 buf->offset += out_count;
695
696 if (buf->offset == buf->len) {
697 /*
698 * We're done using all the data in this buffer.
699 * Re-queue so that the Host can send us more data.
700 */
701 spin_lock_irqsave(&port->inbuf_lock, flags);
702 port->inbuf = NULL;
703
704 if (add_inbuf(port->in_vq, buf) < 0)
Amit Shahfb08bd22009-12-21 21:36:04 +0530705 dev_warn(port->dev, "failed add_buf\n");
Amit Shah203baab2010-01-18 19:15:12 +0530706
707 spin_unlock_irqrestore(&port->inbuf_lock, flags);
708 }
Amit Shahb766cee2009-12-21 21:26:45 +0530709 /* Return the number of bytes actually copied */
Amit Shah203baab2010-01-18 19:15:12 +0530710 return out_count;
Amit Shahe27b5192010-01-18 19:15:02 +0530711}
712
Amit Shah2030fa42009-12-21 21:49:30 +0530713/* The condition that must be true for polling to end */
Amit Shah60caacd2010-05-19 22:15:49 -0600714static bool will_read_block(struct port *port)
Amit Shah2030fa42009-12-21 21:49:30 +0530715{
Amit Shah3709ea72010-09-02 18:11:43 +0530716 if (!port->guest_connected) {
717 /* Port got hot-unplugged. Let's exit. */
718 return false;
719 }
Amit Shah60caacd2010-05-19 22:15:49 -0600720 return !port_has_data(port) && port->host_connected;
Amit Shah2030fa42009-12-21 21:49:30 +0530721}
722
Amit Shahcdfadfc2010-05-19 22:15:50 -0600723static bool will_write_block(struct port *port)
724{
725 bool ret;
726
Amit Shah60e5e0b2010-05-27 13:24:40 +0530727 if (!port->guest_connected) {
728 /* Port got hot-unplugged. Let's exit. */
729 return false;
730 }
Amit Shahcdfadfc2010-05-19 22:15:50 -0600731 if (!port->host_connected)
732 return true;
733
734 spin_lock_irq(&port->outvq_lock);
735 /*
736 * Check if the Host has consumed any buffers since we last
737 * sent data (this is only applicable for nonblocking ports).
738 */
739 reclaim_consumed_buffers(port);
740 ret = port->outvq_full;
741 spin_unlock_irq(&port->outvq_lock);
742
743 return ret;
744}
745
Amit Shah2030fa42009-12-21 21:49:30 +0530746static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
747 size_t count, loff_t *offp)
748{
749 struct port *port;
750 ssize_t ret;
751
752 port = filp->private_data;
753
Amit Shah96f97a82013-07-29 14:23:21 +0930754 /* Port is hot-unplugged. */
755 if (!port->guest_connected)
756 return -ENODEV;
757
Amit Shah2030fa42009-12-21 21:49:30 +0530758 if (!port_has_data(port)) {
759 /*
760 * If nothing's connected on the host just return 0 in
761 * case of list_empty; this tells the userspace app
762 * that there's no connection
763 */
764 if (!port->host_connected)
765 return 0;
766 if (filp->f_flags & O_NONBLOCK)
767 return -EAGAIN;
768
Amit Shaha08fa922011-09-14 13:06:41 +0530769 ret = wait_event_freezable(port->waitqueue,
770 !will_read_block(port));
Amit Shah2030fa42009-12-21 21:49:30 +0530771 if (ret < 0)
772 return ret;
773 }
Amit Shah96f97a82013-07-29 14:23:21 +0930774 /* Port got hot-unplugged while we were waiting above. */
Amit Shahb3dddb92010-09-02 18:11:45 +0530775 if (!port->guest_connected)
776 return -ENODEV;
Amit Shah2030fa42009-12-21 21:49:30 +0530777 /*
778 * We could've received a disconnection message while we were
779 * waiting for more data.
780 *
781 * This check is not clubbed in the if() statement above as we
782 * might receive some data as well as the host could get
783 * disconnected after we got woken up from our wait. So we
784 * really want to give off whatever data we have and only then
785 * check for host_connected.
786 */
787 if (!port_has_data(port) && !port->host_connected)
788 return 0;
789
790 return fill_readbuf(port, ubuf, count, true);
791}
792
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900793static int wait_port_writable(struct port *port, bool nonblock)
794{
795 int ret;
796
797 if (will_write_block(port)) {
798 if (nonblock)
799 return -EAGAIN;
800
801 ret = wait_event_freezable(port->waitqueue,
802 !will_write_block(port));
803 if (ret < 0)
804 return ret;
805 }
806 /* Port got hot-unplugged. */
807 if (!port->guest_connected)
808 return -ENODEV;
809
810 return 0;
811}
812
Amit Shah2030fa42009-12-21 21:49:30 +0530813static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
814 size_t count, loff_t *offp)
815{
816 struct port *port;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030817 struct port_buffer *buf;
Amit Shah2030fa42009-12-21 21:49:30 +0530818 ssize_t ret;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600819 bool nonblock;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030820 struct scatterlist sg[1];
Amit Shah2030fa42009-12-21 21:49:30 +0530821
Amit Shah65745422010-09-14 13:26:16 +0530822 /* Userspace could be out to fool us */
823 if (!count)
824 return 0;
825
Amit Shah2030fa42009-12-21 21:49:30 +0530826 port = filp->private_data;
827
Amit Shahcdfadfc2010-05-19 22:15:50 -0600828 nonblock = filp->f_flags & O_NONBLOCK;
829
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900830 ret = wait_port_writable(port, nonblock);
831 if (ret < 0)
832 return ret;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600833
Amit Shah2030fa42009-12-21 21:49:30 +0530834 count = min((size_t)(32 * 1024), count);
835
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030836 buf = alloc_buf(port->out_vq, count, 0);
Amit Shah2030fa42009-12-21 21:49:30 +0530837 if (!buf)
838 return -ENOMEM;
839
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030840 ret = copy_from_user(buf->buf, ubuf, count);
Amit Shah2030fa42009-12-21 21:49:30 +0530841 if (ret) {
842 ret = -EFAULT;
843 goto free_buf;
844 }
845
Amit Shah531295e2010-10-20 13:45:43 +1030846 /*
847 * We now ask send_buf() to not spin for generic ports -- we
848 * can re-use the same code path that non-blocking file
849 * descriptors take for blocking file descriptors since the
850 * wait is already done and we're certain the write will go
851 * through to the host.
852 */
853 nonblock = true;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030854 sg_init_one(sg, buf->buf, count);
855 ret = __send_to_port(port, sg, 1, count, buf, nonblock);
Amit Shahcdfadfc2010-05-19 22:15:50 -0600856
857 if (nonblock && ret > 0)
858 goto out;
859
Amit Shah2030fa42009-12-21 21:49:30 +0530860free_buf:
Sjur Brændeland1b637042012-12-14 14:40:51 +1030861 free_buf(buf, true);
Amit Shahcdfadfc2010-05-19 22:15:50 -0600862out:
Amit Shah2030fa42009-12-21 21:49:30 +0530863 return ret;
864}
865
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900866struct sg_list {
867 unsigned int n;
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900868 unsigned int size;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900869 size_t len;
870 struct scatterlist *sg;
871};
872
873static int pipe_to_sg(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
874 struct splice_desc *sd)
875{
876 struct sg_list *sgl = sd->u.data;
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900877 unsigned int offset, len;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900878
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900879 if (sgl->n == sgl->size)
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900880 return 0;
881
882 /* Try lock this page */
883 if (buf->ops->steal(pipe, buf) == 0) {
884 /* Get reference and unlock page for moving */
885 get_page(buf->page);
886 unlock_page(buf->page);
887
888 len = min(buf->len, sd->len);
889 sg_set_page(&(sgl->sg[sgl->n]), buf->page, len, buf->offset);
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900890 } else {
891 /* Failback to copying a page */
892 struct page *page = alloc_page(GFP_KERNEL);
Al Viroc9efe512014-02-02 07:05:05 -0500893 char *src;
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900894
895 if (!page)
896 return -ENOMEM;
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900897
898 offset = sd->pos & ~PAGE_MASK;
899
900 len = sd->len;
901 if (len + offset > PAGE_SIZE)
902 len = PAGE_SIZE - offset;
903
Al Viroc9efe512014-02-02 07:05:05 -0500904 src = buf->ops->map(pipe, buf, 1);
905 memcpy(page_address(page) + offset, src + buf->offset, len);
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900906 buf->ops->unmap(pipe, buf, src);
907
908 sg_set_page(&(sgl->sg[sgl->n]), page, len, offset);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900909 }
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900910 sgl->n++;
911 sgl->len += len;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900912
913 return len;
914}
915
916/* Faster zero-copy write by splicing */
917static ssize_t port_fops_splice_write(struct pipe_inode_info *pipe,
918 struct file *filp, loff_t *ppos,
919 size_t len, unsigned int flags)
920{
921 struct port *port = filp->private_data;
922 struct sg_list sgl;
923 ssize_t ret;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030924 struct port_buffer *buf;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900925 struct splice_desc sd = {
926 .total_len = len,
927 .flags = flags,
928 .pos = *ppos,
929 .u.data = &sgl,
930 };
931
Sjur Brændeland1b637042012-12-14 14:40:51 +1030932 /*
933 * Rproc_serial does not yet support splice. To support splice
934 * pipe_to_sg() must allocate dma-buffers and copy content from
935 * regular pages to dma pages. And alloc_buf and free_buf must
936 * support allocating and freeing such a list of dma-buffers.
937 */
938 if (is_rproc_serial(port->out_vq->vdev))
939 return -EINVAL;
940
Yoshihiro YUNOMAE68c034f2013-07-23 11:30:49 +0930941 /*
942 * pipe->nrbufs == 0 means there are no data to transfer,
943 * so this returns just 0 for no data.
944 */
Yoshihiro YUNOMAE2b4fbf02013-07-23 11:30:49 +0930945 pipe_lock(pipe);
946 if (!pipe->nrbufs) {
947 ret = 0;
948 goto error_out;
949 }
Yoshihiro YUNOMAE68c034f2013-07-23 11:30:49 +0930950
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900951 ret = wait_port_writable(port, filp->f_flags & O_NONBLOCK);
952 if (ret < 0)
Yoshihiro YUNOMAE2b4fbf02013-07-23 11:30:49 +0930953 goto error_out;
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900954
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030955 buf = alloc_buf(port->out_vq, 0, pipe->nrbufs);
Yoshihiro YUNOMAE2b4fbf02013-07-23 11:30:49 +0930956 if (!buf) {
957 ret = -ENOMEM;
958 goto error_out;
959 }
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030960
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900961 sgl.n = 0;
962 sgl.len = 0;
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900963 sgl.size = pipe->nrbufs;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030964 sgl.sg = buf->sg;
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900965 sg_init_table(sgl.sg, sgl.size);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900966 ret = __splice_from_pipe(pipe, &sd, pipe_to_sg);
Yoshihiro YUNOMAE2b4fbf02013-07-23 11:30:49 +0930967 pipe_unlock(pipe);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900968 if (likely(ret > 0))
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030969 ret = __send_to_port(port, buf->sg, sgl.n, sgl.len, buf, true);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900970
Sjur Brændelandfe529532012-10-15 09:57:33 +0200971 if (unlikely(ret <= 0))
Sjur Brændeland1b637042012-12-14 14:40:51 +1030972 free_buf(buf, true);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900973 return ret;
Yoshihiro YUNOMAE2b4fbf02013-07-23 11:30:49 +0930974
975error_out:
976 pipe_unlock(pipe);
977 return ret;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900978}
979
Amit Shah2030fa42009-12-21 21:49:30 +0530980static unsigned int port_fops_poll(struct file *filp, poll_table *wait)
981{
982 struct port *port;
983 unsigned int ret;
984
985 port = filp->private_data;
986 poll_wait(filp, &port->waitqueue, wait);
987
Amit Shah8529a502010-09-02 18:11:44 +0530988 if (!port->guest_connected) {
989 /* Port got unplugged */
990 return POLLHUP;
991 }
Amit Shah2030fa42009-12-21 21:49:30 +0530992 ret = 0;
Hans de Goede6df7aad2010-09-16 14:43:08 +0530993 if (!will_read_block(port))
Amit Shah2030fa42009-12-21 21:49:30 +0530994 ret |= POLLIN | POLLRDNORM;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600995 if (!will_write_block(port))
Amit Shah2030fa42009-12-21 21:49:30 +0530996 ret |= POLLOUT;
997 if (!port->host_connected)
998 ret |= POLLHUP;
999
1000 return ret;
1001}
1002
Amit Shahb353a6b2010-09-02 18:38:29 +05301003static void remove_port(struct kref *kref);
1004
Amit Shah2030fa42009-12-21 21:49:30 +05301005static int port_fops_release(struct inode *inode, struct file *filp)
1006{
1007 struct port *port;
1008
1009 port = filp->private_data;
1010
1011 /* Notify host of port being closed */
1012 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
1013
Amit Shah88f251a2009-12-21 22:15:30 +05301014 spin_lock_irq(&port->inbuf_lock);
Amit Shah3c7969c2009-11-26 11:25:38 +05301015 port->guest_connected = false;
1016
Amit Shah88f251a2009-12-21 22:15:30 +05301017 discard_port_data(port);
1018
1019 spin_unlock_irq(&port->inbuf_lock);
1020
Amit Shahcdfadfc2010-05-19 22:15:50 -06001021 spin_lock_irq(&port->outvq_lock);
1022 reclaim_consumed_buffers(port);
1023 spin_unlock_irq(&port->outvq_lock);
1024
Sjur Brændeland1b637042012-12-14 14:40:51 +10301025 reclaim_dma_bufs();
Amit Shahb353a6b2010-09-02 18:38:29 +05301026 /*
1027 * Locks aren't necessary here as a port can't be opened after
1028 * unplug, and if a port isn't unplugged, a kref would already
1029 * exist for the port. Plus, taking ports_lock here would
1030 * create a dependency on other locks taken by functions
1031 * inside remove_port if we're the last holder of the port,
1032 * creating many problems.
1033 */
1034 kref_put(&port->kref, remove_port);
1035
Amit Shah2030fa42009-12-21 21:49:30 +05301036 return 0;
1037}
1038
1039static int port_fops_open(struct inode *inode, struct file *filp)
1040{
1041 struct cdev *cdev = inode->i_cdev;
1042 struct port *port;
Amit Shah8ad37e82010-09-02 18:11:48 +05301043 int ret;
Amit Shah2030fa42009-12-21 21:49:30 +05301044
Amit Shah057b82b2013-07-29 14:16:13 +09301045 /* We get the port with a kref here */
Amit Shah04950cd2010-09-02 18:20:58 +05301046 port = find_port_by_devt(cdev->dev);
Amit Shah671bdea2013-07-29 14:17:13 +09301047 if (!port) {
1048 /* Port was unplugged before we could proceed */
1049 return -ENXIO;
1050 }
Amit Shah2030fa42009-12-21 21:49:30 +05301051 filp->private_data = port;
1052
1053 /*
1054 * Don't allow opening of console port devices -- that's done
1055 * via /dev/hvc
1056 */
Amit Shah8ad37e82010-09-02 18:11:48 +05301057 if (is_console_port(port)) {
1058 ret = -ENXIO;
1059 goto out;
1060 }
Amit Shah2030fa42009-12-21 21:49:30 +05301061
Amit Shah3c7969c2009-11-26 11:25:38 +05301062 /* Allow only one process to open a particular port at a time */
1063 spin_lock_irq(&port->inbuf_lock);
1064 if (port->guest_connected) {
1065 spin_unlock_irq(&port->inbuf_lock);
Amit Shah74ff5822013-04-15 12:00:15 +09301066 ret = -EBUSY;
Amit Shah8ad37e82010-09-02 18:11:48 +05301067 goto out;
Amit Shah3c7969c2009-11-26 11:25:38 +05301068 }
1069
1070 port->guest_connected = true;
1071 spin_unlock_irq(&port->inbuf_lock);
1072
Amit Shahcdfadfc2010-05-19 22:15:50 -06001073 spin_lock_irq(&port->outvq_lock);
1074 /*
1075 * There might be a chance that we missed reclaiming a few
1076 * buffers in the window of the port getting previously closed
1077 * and opening now.
1078 */
1079 reclaim_consumed_buffers(port);
1080 spin_unlock_irq(&port->outvq_lock);
1081
Amit Shah299fb612010-09-16 14:43:09 +05301082 nonseekable_open(inode, filp);
1083
Amit Shah2030fa42009-12-21 21:49:30 +05301084 /* Notify host of port being opened */
1085 send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1);
1086
1087 return 0;
Amit Shah8ad37e82010-09-02 18:11:48 +05301088out:
Amit Shahb353a6b2010-09-02 18:38:29 +05301089 kref_put(&port->kref, remove_port);
Amit Shah8ad37e82010-09-02 18:11:48 +05301090 return ret;
Amit Shah2030fa42009-12-21 21:49:30 +05301091}
1092
Amit Shah3eae0ad2010-09-02 18:47:52 +05301093static int port_fops_fasync(int fd, struct file *filp, int mode)
1094{
1095 struct port *port;
1096
1097 port = filp->private_data;
1098 return fasync_helper(fd, filp, mode, &port->async_queue);
1099}
1100
Amit Shah2030fa42009-12-21 21:49:30 +05301101/*
1102 * The file operations that we support: programs in the guest can open
1103 * a console device, read from it, write to it, poll for data and
1104 * close it. The devices are at
1105 * /dev/vport<device number>p<port number>
1106 */
1107static const struct file_operations port_fops = {
1108 .owner = THIS_MODULE,
1109 .open = port_fops_open,
1110 .read = port_fops_read,
1111 .write = port_fops_write,
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +09001112 .splice_write = port_fops_splice_write,
Amit Shah2030fa42009-12-21 21:49:30 +05301113 .poll = port_fops_poll,
1114 .release = port_fops_release,
Amit Shah3eae0ad2010-09-02 18:47:52 +05301115 .fasync = port_fops_fasync,
Amit Shah299fb612010-09-16 14:43:09 +05301116 .llseek = no_llseek,
Amit Shah2030fa42009-12-21 21:49:30 +05301117};
1118
Amit Shahe27b5192010-01-18 19:15:02 +05301119/*
Rusty Russella23ea922010-01-18 19:14:55 +05301120 * The put_chars() callback is pretty straightforward.
Rusty Russell31610432007-10-22 11:03:39 +10001121 *
Rusty Russella23ea922010-01-18 19:14:55 +05301122 * We turn the characters into a scatter-gather list, add it to the
1123 * output queue and then kick the Host. Then we sit here waiting for
1124 * it to finish: inefficient in theory, but in practice
1125 * implementations will do it immediately (lguest's Launcher does).
1126 */
Rusty Russell31610432007-10-22 11:03:39 +10001127static int put_chars(u32 vtermno, const char *buf, int count)
1128{
Rusty Russell21206ed2010-01-18 19:15:00 +05301129 struct port *port;
Sjur Brændeland276a3e92012-12-14 13:46:42 +10301130 struct scatterlist sg[1];
Amit Shah38edf582010-01-18 19:15:05 +05301131
François Diakhaté162a6892010-03-23 18:23:15 +05301132 if (unlikely(early_put_chars))
1133 return early_put_chars(vtermno, buf, count);
1134
Amit Shah38edf582010-01-18 19:15:05 +05301135 port = find_port_by_vtermno(vtermno);
1136 if (!port)
Amit Shah6dc69f972010-05-19 22:15:47 -06001137 return -EPIPE;
Rusty Russell31610432007-10-22 11:03:39 +10001138
Sjur Brændeland276a3e92012-12-14 13:46:42 +10301139 sg_init_one(sg, buf, count);
1140 return __send_to_port(port, sg, 1, count, (void *)buf, false);
Rusty Russell31610432007-10-22 11:03:39 +10001141}
1142
Rusty Russella23ea922010-01-18 19:14:55 +05301143/*
Rusty Russella23ea922010-01-18 19:14:55 +05301144 * get_chars() is the callback from the hvc_console infrastructure
1145 * when an interrupt is received.
Rusty Russell31610432007-10-22 11:03:39 +10001146 *
Amit Shah203baab2010-01-18 19:15:12 +05301147 * We call out to fill_readbuf that gets us the required data from the
1148 * buffers that are queued up.
Rusty Russella23ea922010-01-18 19:14:55 +05301149 */
Rusty Russell31610432007-10-22 11:03:39 +10001150static int get_chars(u32 vtermno, char *buf, int count)
1151{
Rusty Russell21206ed2010-01-18 19:15:00 +05301152 struct port *port;
Rusty Russell31610432007-10-22 11:03:39 +10001153
Amit Shah6dc69f972010-05-19 22:15:47 -06001154 /* If we've not set up the port yet, we have no input to give. */
1155 if (unlikely(early_put_chars))
1156 return 0;
1157
Amit Shah38edf582010-01-18 19:15:05 +05301158 port = find_port_by_vtermno(vtermno);
1159 if (!port)
Amit Shah6dc69f972010-05-19 22:15:47 -06001160 return -EPIPE;
Rusty Russell21206ed2010-01-18 19:15:00 +05301161
1162 /* If we don't have an input queue yet, we can't get input. */
1163 BUG_ON(!port->in_vq);
1164
Amit Shahb766cee2009-12-21 21:26:45 +05301165 return fill_readbuf(port, buf, count, false);
Rusty Russell31610432007-10-22 11:03:39 +10001166}
Rusty Russell31610432007-10-22 11:03:39 +10001167
Amit Shahcb06e362010-01-18 19:15:08 +05301168static void resize_console(struct port *port)
Christian Borntraegerc2983452008-11-25 13:36:26 +01001169{
Amit Shahcb06e362010-01-18 19:15:08 +05301170 struct virtio_device *vdev;
Christian Borntraegerc2983452008-11-25 13:36:26 +01001171
Amit Shah2de16a42010-03-19 17:36:44 +05301172 /* The port could have been hot-unplugged */
Amit Shah97788292010-05-06 02:05:08 +05301173 if (!port || !is_console_port(port))
Amit Shah2de16a42010-03-19 17:36:44 +05301174 return;
1175
Amit Shahcb06e362010-01-18 19:15:08 +05301176 vdev = port->portdev->vdev;
Sjur Brændeland1b637042012-12-14 14:40:51 +10301177
1178 /* Don't test F_SIZE at all if we're rproc: not a valid feature! */
1179 if (!is_rproc_serial(vdev) &&
1180 virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE))
Amit Shah97788292010-05-06 02:05:08 +05301181 hvc_resize(port->cons.hvc, port->cons.ws);
Christian Borntraegerc2983452008-11-25 13:36:26 +01001182}
1183
Amit Shah38edf582010-01-18 19:15:05 +05301184/* We set the configuration at this point, since we now have a tty */
Christian Borntraeger91fcad12008-06-20 15:24:15 +02001185static int notifier_add_vio(struct hvc_struct *hp, int data)
1186{
Amit Shah38edf582010-01-18 19:15:05 +05301187 struct port *port;
1188
1189 port = find_port_by_vtermno(hp->vtermno);
1190 if (!port)
1191 return -EINVAL;
1192
Christian Borntraeger91fcad12008-06-20 15:24:15 +02001193 hp->irq_requested = 1;
Amit Shahcb06e362010-01-18 19:15:08 +05301194 resize_console(port);
Christian Borntraegerc2983452008-11-25 13:36:26 +01001195
Christian Borntraeger91fcad12008-06-20 15:24:15 +02001196 return 0;
1197}
1198
1199static void notifier_del_vio(struct hvc_struct *hp, int data)
1200{
1201 hp->irq_requested = 0;
1202}
1203
Amit Shah17634ba2009-12-21 21:03:25 +05301204/* The operations for console ports. */
Rusty Russell1dff3992009-11-28 12:20:26 +05301205static const struct hv_ops hv_ops = {
Rusty Russell971f3392010-01-18 19:14:56 +05301206 .get_chars = get_chars,
1207 .put_chars = put_chars,
1208 .notifier_add = notifier_add_vio,
1209 .notifier_del = notifier_del_vio,
1210 .notifier_hangup = notifier_del_vio,
1211};
1212
1213/*
1214 * Console drivers are initialized very early so boot messages can go
1215 * out, so we do things slightly differently from the generic virtio
1216 * initialization of the net and block drivers.
1217 *
1218 * At this stage, the console is output-only. It's too early to set
1219 * up a virtqueue, so we let the drivers do some boutique early-output
1220 * thing.
1221 */
1222int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int))
1223{
1224 early_put_chars = put_chars;
1225 return hvc_instantiate(0, 0, &hv_ops);
1226}
1227
Wei Yongjun38268352013-04-08 16:13:59 +09301228static int init_port_console(struct port *port)
Amit Shahcfa6d372010-01-18 19:15:10 +05301229{
1230 int ret;
1231
1232 /*
1233 * The Host's telling us this port is a console port. Hook it
1234 * up with an hvc console.
1235 *
1236 * To set up and manage our virtual console, we call
1237 * hvc_alloc().
1238 *
1239 * The first argument of hvc_alloc() is the virtual console
1240 * number. The second argument is the parameter for the
1241 * notification mechanism (like irq number). We currently
1242 * leave this as zero, virtqueues have implicit notifications.
1243 *
1244 * The third argument is a "struct hv_ops" containing the
1245 * put_chars() get_chars(), notifier_add() and notifier_del()
1246 * pointers. The final argument is the output buffer size: we
1247 * can do any size, so we put PAGE_SIZE here.
1248 */
1249 port->cons.vtermno = pdrvdata.next_vtermno;
1250
1251 port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE);
1252 if (IS_ERR(port->cons.hvc)) {
1253 ret = PTR_ERR(port->cons.hvc);
Amit Shah298add72010-01-18 16:35:23 +05301254 dev_err(port->dev,
1255 "error %d allocating hvc for port\n", ret);
Amit Shahcfa6d372010-01-18 19:15:10 +05301256 port->cons.hvc = NULL;
1257 return ret;
1258 }
1259 spin_lock_irq(&pdrvdata_lock);
1260 pdrvdata.next_vtermno++;
1261 list_add_tail(&port->cons.list, &pdrvdata.consoles);
1262 spin_unlock_irq(&pdrvdata_lock);
Amit Shah3c7969c2009-11-26 11:25:38 +05301263 port->guest_connected = true;
Amit Shahcfa6d372010-01-18 19:15:10 +05301264
Amit Shah1d051602010-05-19 22:15:49 -06001265 /*
1266 * Start using the new console output if this is the first
1267 * console to come up.
1268 */
1269 if (early_put_chars)
1270 early_put_chars = NULL;
1271
Amit Shah2030fa42009-12-21 21:49:30 +05301272 /* Notify host of port being opened */
1273 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
1274
Amit Shahcfa6d372010-01-18 19:15:10 +05301275 return 0;
1276}
1277
Amit Shah431edb82009-12-21 21:57:40 +05301278static ssize_t show_port_name(struct device *dev,
1279 struct device_attribute *attr, char *buffer)
1280{
1281 struct port *port;
1282
1283 port = dev_get_drvdata(dev);
1284
1285 return sprintf(buffer, "%s\n", port->name);
1286}
1287
1288static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL);
1289
1290static struct attribute *port_sysfs_entries[] = {
1291 &dev_attr_name.attr,
1292 NULL
1293};
1294
1295static struct attribute_group port_attribute_group = {
1296 .name = NULL, /* put in device directory */
1297 .attrs = port_sysfs_entries,
1298};
1299
Amit Shahd99393e2009-12-21 22:36:21 +05301300static ssize_t debugfs_read(struct file *filp, char __user *ubuf,
1301 size_t count, loff_t *offp)
1302{
1303 struct port *port;
1304 char *buf;
1305 ssize_t ret, out_offset, out_count;
1306
1307 out_count = 1024;
1308 buf = kmalloc(out_count, GFP_KERNEL);
1309 if (!buf)
1310 return -ENOMEM;
1311
1312 port = filp->private_data;
1313 out_offset = 0;
1314 out_offset += snprintf(buf + out_offset, out_count,
1315 "name: %s\n", port->name ? port->name : "");
1316 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1317 "guest_connected: %d\n", port->guest_connected);
1318 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1319 "host_connected: %d\n", port->host_connected);
1320 out_offset += snprintf(buf + out_offset, out_count - out_offset,
Amit Shahcdfadfc2010-05-19 22:15:50 -06001321 "outvq_full: %d\n", port->outvq_full);
1322 out_offset += snprintf(buf + out_offset, out_count - out_offset,
Amit Shah17e5b4f2011-09-14 13:06:46 +05301323 "bytes_sent: %lu\n", port->stats.bytes_sent);
1324 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1325 "bytes_received: %lu\n",
1326 port->stats.bytes_received);
1327 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1328 "bytes_discarded: %lu\n",
1329 port->stats.bytes_discarded);
1330 out_offset += snprintf(buf + out_offset, out_count - out_offset,
Amit Shahd99393e2009-12-21 22:36:21 +05301331 "is_console: %s\n",
1332 is_console_port(port) ? "yes" : "no");
1333 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1334 "console_vtermno: %u\n", port->cons.vtermno);
1335
1336 ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset);
1337 kfree(buf);
1338 return ret;
1339}
1340
1341static const struct file_operations port_debugfs_ops = {
1342 .owner = THIS_MODULE,
Stephen Boyd234e3402012-04-05 14:25:11 -07001343 .open = simple_open,
Amit Shahd99393e2009-12-21 22:36:21 +05301344 .read = debugfs_read,
1345};
1346
Amit Shah97788292010-05-06 02:05:08 +05301347static void set_console_size(struct port *port, u16 rows, u16 cols)
1348{
1349 if (!port || !is_console_port(port))
1350 return;
1351
1352 port->cons.ws.ws_row = rows;
1353 port->cons.ws.ws_col = cols;
1354}
1355
Amit Shahc446f8f2010-05-19 22:15:48 -06001356static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock)
1357{
1358 struct port_buffer *buf;
1359 unsigned int nr_added_bufs;
1360 int ret;
1361
1362 nr_added_bufs = 0;
1363 do {
Sjur Brændeland276a3e92012-12-14 13:46:42 +10301364 buf = alloc_buf(vq, PAGE_SIZE, 0);
Amit Shahc446f8f2010-05-19 22:15:48 -06001365 if (!buf)
1366 break;
1367
1368 spin_lock_irq(lock);
1369 ret = add_inbuf(vq, buf);
1370 if (ret < 0) {
1371 spin_unlock_irq(lock);
Sjur Brændeland1b637042012-12-14 14:40:51 +10301372 free_buf(buf, true);
Amit Shahc446f8f2010-05-19 22:15:48 -06001373 break;
1374 }
1375 nr_added_bufs++;
1376 spin_unlock_irq(lock);
1377 } while (ret > 0);
1378
1379 return nr_added_bufs;
1380}
1381
Amit Shah3eae0ad2010-09-02 18:47:52 +05301382static void send_sigio_to_port(struct port *port)
1383{
1384 if (port->async_queue && port->guest_connected)
1385 kill_fasync(&port->async_queue, SIGIO, POLL_OUT);
1386}
1387
Amit Shahc446f8f2010-05-19 22:15:48 -06001388static int add_port(struct ports_device *portdev, u32 id)
1389{
1390 char debugfs_name[16];
1391 struct port *port;
1392 struct port_buffer *buf;
1393 dev_t devt;
1394 unsigned int nr_added_bufs;
1395 int err;
1396
1397 port = kmalloc(sizeof(*port), GFP_KERNEL);
1398 if (!port) {
1399 err = -ENOMEM;
1400 goto fail;
1401 }
Amit Shahb353a6b2010-09-02 18:38:29 +05301402 kref_init(&port->kref);
Amit Shahc446f8f2010-05-19 22:15:48 -06001403
1404 port->portdev = portdev;
1405 port->id = id;
1406
1407 port->name = NULL;
1408 port->inbuf = NULL;
1409 port->cons.hvc = NULL;
Amit Shah3eae0ad2010-09-02 18:47:52 +05301410 port->async_queue = NULL;
Amit Shahc446f8f2010-05-19 22:15:48 -06001411
Amit Shah97788292010-05-06 02:05:08 +05301412 port->cons.ws.ws_row = port->cons.ws.ws_col = 0;
1413
Amit Shahc446f8f2010-05-19 22:15:48 -06001414 port->host_connected = port->guest_connected = false;
Amit Shah17e5b4f2011-09-14 13:06:46 +05301415 port->stats = (struct port_stats) { 0 };
Amit Shahc446f8f2010-05-19 22:15:48 -06001416
Amit Shahcdfadfc2010-05-19 22:15:50 -06001417 port->outvq_full = false;
1418
Amit Shahc446f8f2010-05-19 22:15:48 -06001419 port->in_vq = portdev->in_vqs[port->id];
1420 port->out_vq = portdev->out_vqs[port->id];
1421
Amit Shahd22a6982010-09-02 18:20:59 +05301422 port->cdev = cdev_alloc();
1423 if (!port->cdev) {
1424 dev_err(&port->portdev->vdev->dev, "Error allocating cdev\n");
1425 err = -ENOMEM;
1426 goto free_port;
1427 }
1428 port->cdev->ops = &port_fops;
Amit Shahc446f8f2010-05-19 22:15:48 -06001429
1430 devt = MKDEV(portdev->chr_major, id);
Amit Shahd22a6982010-09-02 18:20:59 +05301431 err = cdev_add(port->cdev, devt, 1);
Amit Shahc446f8f2010-05-19 22:15:48 -06001432 if (err < 0) {
1433 dev_err(&port->portdev->vdev->dev,
1434 "Error %d adding cdev for port %u\n", err, id);
Amit Shahd22a6982010-09-02 18:20:59 +05301435 goto free_cdev;
Amit Shahc446f8f2010-05-19 22:15:48 -06001436 }
1437 port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev,
1438 devt, port, "vport%up%u",
Sjur Brændelanddc18f082013-02-12 16:24:59 +10301439 port->portdev->vdev->index, id);
Amit Shahc446f8f2010-05-19 22:15:48 -06001440 if (IS_ERR(port->dev)) {
1441 err = PTR_ERR(port->dev);
1442 dev_err(&port->portdev->vdev->dev,
1443 "Error %d creating device for port %u\n",
1444 err, id);
1445 goto free_cdev;
1446 }
1447
1448 spin_lock_init(&port->inbuf_lock);
Amit Shahcdfadfc2010-05-19 22:15:50 -06001449 spin_lock_init(&port->outvq_lock);
Amit Shahc446f8f2010-05-19 22:15:48 -06001450 init_waitqueue_head(&port->waitqueue);
1451
1452 /* Fill the in_vq with buffers so the host can send us data. */
1453 nr_added_bufs = fill_queue(port->in_vq, &port->inbuf_lock);
1454 if (!nr_added_bufs) {
1455 dev_err(port->dev, "Error allocating inbufs\n");
1456 err = -ENOMEM;
1457 goto free_device;
1458 }
1459
Sjur Brændeland1b637042012-12-14 14:40:51 +10301460 if (is_rproc_serial(port->portdev->vdev))
1461 /*
1462 * For rproc_serial assume remote processor is connected.
1463 * rproc_serial does not want the console port, only
1464 * the generic port implementation.
1465 */
Sjur Brændelandaabd6a82013-03-18 19:19:14 +10301466 port->host_connected = true;
Sjur Brændeland1b637042012-12-14 14:40:51 +10301467 else if (!use_multiport(port->portdev)) {
1468 /*
1469 * If we're not using multiport support,
1470 * this has to be a console port.
1471 */
Amit Shahc446f8f2010-05-19 22:15:48 -06001472 err = init_port_console(port);
1473 if (err)
1474 goto free_inbufs;
1475 }
1476
1477 spin_lock_irq(&portdev->ports_lock);
1478 list_add_tail(&port->list, &port->portdev->ports);
1479 spin_unlock_irq(&portdev->ports_lock);
1480
1481 /*
1482 * Tell the Host we're set so that it can send us various
1483 * configuration parameters for this port (eg, port name,
1484 * caching, whether this is a console port, etc.)
1485 */
1486 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1487
1488 if (pdrvdata.debugfs_dir) {
1489 /*
1490 * Finally, create the debugfs file that we can use to
1491 * inspect a port's state at any time
1492 */
1493 sprintf(debugfs_name, "vport%up%u",
Sjur Brændelanddc18f082013-02-12 16:24:59 +10301494 port->portdev->vdev->index, id);
Amit Shahc446f8f2010-05-19 22:15:48 -06001495 port->debugfs_file = debugfs_create_file(debugfs_name, 0444,
1496 pdrvdata.debugfs_dir,
1497 port,
1498 &port_debugfs_ops);
1499 }
1500 return 0;
1501
1502free_inbufs:
1503 while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301504 free_buf(buf, true);
Amit Shahc446f8f2010-05-19 22:15:48 -06001505free_device:
1506 device_destroy(pdrvdata.class, port->dev->devt);
1507free_cdev:
Amit Shahd22a6982010-09-02 18:20:59 +05301508 cdev_del(port->cdev);
Amit Shahc446f8f2010-05-19 22:15:48 -06001509free_port:
1510 kfree(port);
1511fail:
1512 /* The host might want to notify management sw about port add failure */
Julia Lawall0643e4c2010-05-15 11:45:53 +02001513 __send_control_msg(portdev, id, VIRTIO_CONSOLE_PORT_READY, 0);
Amit Shahc446f8f2010-05-19 22:15:48 -06001514 return err;
1515}
1516
Amit Shahb353a6b2010-09-02 18:38:29 +05301517/* No users remain, remove all port-specific data. */
1518static void remove_port(struct kref *kref)
1519{
1520 struct port *port;
1521
1522 port = container_of(kref, struct port, kref);
1523
Amit Shahb353a6b2010-09-02 18:38:29 +05301524 kfree(port);
1525}
1526
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301527static void remove_port_data(struct port *port)
1528{
1529 struct port_buffer *buf;
1530
Amit Shahc6017e72013-07-29 14:23:46 +09301531 spin_lock_irq(&port->inbuf_lock);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301532 /* Remove unused data this port might have received. */
1533 discard_port_data(port);
1534
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301535 /* Remove buffers we queued up for the Host to send us data in. */
1536 while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301537 free_buf(buf, true);
Amit Shahc6017e72013-07-29 14:23:46 +09301538 spin_unlock_irq(&port->inbuf_lock);
1539
1540 spin_lock_irq(&port->outvq_lock);
1541 reclaim_consumed_buffers(port);
sjur.brandeland@stericsson.comeb34f122012-11-16 11:20:19 +10301542
1543 /* Free pending buffers from the out-queue. */
1544 while ((buf = virtqueue_detach_unused_buf(port->out_vq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301545 free_buf(buf, true);
Amit Shahc6017e72013-07-29 14:23:46 +09301546 spin_unlock_irq(&port->outvq_lock);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301547}
1548
Amit Shahb353a6b2010-09-02 18:38:29 +05301549/*
1550 * Port got unplugged. Remove port from portdev's list and drop the
1551 * kref reference. If no userspace has this port opened, it will
1552 * result in immediate removal the port.
1553 */
1554static void unplug_port(struct port *port)
Amit Shah1f7aa422009-12-21 22:27:31 +05301555{
Amit Shahb353a6b2010-09-02 18:38:29 +05301556 spin_lock_irq(&port->portdev->ports_lock);
1557 list_del(&port->list);
1558 spin_unlock_irq(&port->portdev->ports_lock);
1559
Amit Shah5549fb22013-07-29 14:24:15 +09301560 spin_lock_irq(&port->inbuf_lock);
Amit Shah00476342010-05-27 13:24:39 +05301561 if (port->guest_connected) {
Amit Shaha461e112010-09-02 18:47:54 +05301562 /* Let the app know the port is going down. */
1563 send_sigio_to_port(port);
Amit Shah92d34532013-07-29 14:21:32 +09301564
1565 /* Do this after sigio is actually sent */
1566 port->guest_connected = false;
1567 port->host_connected = false;
1568
1569 wake_up_interruptible(&port->waitqueue);
Amit Shah00476342010-05-27 13:24:39 +05301570 }
Amit Shah5549fb22013-07-29 14:24:15 +09301571 spin_unlock_irq(&port->inbuf_lock);
Amit Shah00476342010-05-27 13:24:39 +05301572
Amit Shah1f7aa422009-12-21 22:27:31 +05301573 if (is_console_port(port)) {
1574 spin_lock_irq(&pdrvdata_lock);
1575 list_del(&port->cons.list);
1576 spin_unlock_irq(&pdrvdata_lock);
1577 hvc_remove(port->cons.hvc);
1578 }
Amit Shah1f7aa422009-12-21 22:27:31 +05301579
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301580 remove_port_data(port);
Amit Shaha9cdd482010-02-12 10:32:15 +05301581
Amit Shahb353a6b2010-09-02 18:38:29 +05301582 /*
1583 * We should just assume the device itself has gone off --
1584 * else a close on an open port later will try to send out a
1585 * control message.
1586 */
1587 port->portdev = NULL;
Amit Shah1f7aa422009-12-21 22:27:31 +05301588
Amit Shahea3768b2013-07-29 14:20:29 +09301589 sysfs_remove_group(&port->dev->kobj, &port_attribute_group);
1590 device_destroy(pdrvdata.class, port->dev->devt);
1591 cdev_del(port->cdev);
1592
Amit Shahea3768b2013-07-29 14:20:29 +09301593 debugfs_remove(port->debugfs_file);
Amit Shah3b868a42013-08-07 15:54:17 +09301594 kfree(port->name);
Amit Shahea3768b2013-07-29 14:20:29 +09301595
Amit Shahb353a6b2010-09-02 18:38:29 +05301596 /*
1597 * Locks around here are not necessary - a port can't be
1598 * opened after we removed the port struct from ports_list
1599 * above.
1600 */
1601 kref_put(&port->kref, remove_port);
Amit Shah1f7aa422009-12-21 22:27:31 +05301602}
1603
Amit Shah17634ba2009-12-21 21:03:25 +05301604/* Any private messages that the Host and Guest want to share */
1605static void handle_control_message(struct ports_device *portdev,
1606 struct port_buffer *buf)
1607{
1608 struct virtio_console_control *cpkt;
1609 struct port *port;
Amit Shah431edb82009-12-21 21:57:40 +05301610 size_t name_size;
1611 int err;
Amit Shah17634ba2009-12-21 21:03:25 +05301612
1613 cpkt = (struct virtio_console_control *)(buf->buf + buf->offset);
1614
1615 port = find_port_by_id(portdev, cpkt->id);
Amit Shahf909f852010-05-19 22:15:48 -06001616 if (!port && cpkt->event != VIRTIO_CONSOLE_PORT_ADD) {
Amit Shah17634ba2009-12-21 21:03:25 +05301617 /* No valid header at start of buffer. Drop it. */
1618 dev_dbg(&portdev->vdev->dev,
1619 "Invalid index %u in control packet\n", cpkt->id);
1620 return;
1621 }
1622
1623 switch (cpkt->event) {
Amit Shahf909f852010-05-19 22:15:48 -06001624 case VIRTIO_CONSOLE_PORT_ADD:
1625 if (port) {
Amit Shah1d051602010-05-19 22:15:49 -06001626 dev_dbg(&portdev->vdev->dev,
1627 "Port %u already added\n", port->id);
Amit Shahf909f852010-05-19 22:15:48 -06001628 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1629 break;
1630 }
1631 if (cpkt->id >= portdev->config.max_nr_ports) {
1632 dev_warn(&portdev->vdev->dev,
1633 "Request for adding port with out-of-bound id %u, max. supported id: %u\n",
1634 cpkt->id, portdev->config.max_nr_ports - 1);
1635 break;
1636 }
1637 add_port(portdev, cpkt->id);
1638 break;
1639 case VIRTIO_CONSOLE_PORT_REMOVE:
Amit Shahb353a6b2010-09-02 18:38:29 +05301640 unplug_port(port);
Amit Shahf909f852010-05-19 22:15:48 -06001641 break;
Amit Shah17634ba2009-12-21 21:03:25 +05301642 case VIRTIO_CONSOLE_CONSOLE_PORT:
1643 if (!cpkt->value)
1644 break;
1645 if (is_console_port(port))
1646 break;
1647
1648 init_port_console(port);
Christian Borntraeger5e384832011-09-22 23:44:23 +05301649 complete(&early_console_added);
Amit Shah17634ba2009-12-21 21:03:25 +05301650 /*
1651 * Could remove the port here in case init fails - but
1652 * have to notify the host first.
1653 */
1654 break;
Amit Shah8345adb2010-05-06 02:05:09 +05301655 case VIRTIO_CONSOLE_RESIZE: {
1656 struct {
1657 __u16 rows;
1658 __u16 cols;
1659 } size;
1660
Amit Shah17634ba2009-12-21 21:03:25 +05301661 if (!is_console_port(port))
1662 break;
Amit Shah8345adb2010-05-06 02:05:09 +05301663
1664 memcpy(&size, buf->buf + buf->offset + sizeof(*cpkt),
1665 sizeof(size));
1666 set_console_size(port, size.rows, size.cols);
1667
Amit Shah17634ba2009-12-21 21:03:25 +05301668 port->cons.hvc->irq_requested = 1;
1669 resize_console(port);
1670 break;
Amit Shah8345adb2010-05-06 02:05:09 +05301671 }
Amit Shah2030fa42009-12-21 21:49:30 +05301672 case VIRTIO_CONSOLE_PORT_OPEN:
1673 port->host_connected = cpkt->value;
1674 wake_up_interruptible(&port->waitqueue);
Amit Shahcdfadfc2010-05-19 22:15:50 -06001675 /*
1676 * If the host port got closed and the host had any
1677 * unconsumed buffers, we'll be able to reclaim them
1678 * now.
1679 */
1680 spin_lock_irq(&port->outvq_lock);
1681 reclaim_consumed_buffers(port);
1682 spin_unlock_irq(&port->outvq_lock);
Amit Shah3eae0ad2010-09-02 18:47:52 +05301683
1684 /*
1685 * If the guest is connected, it'll be interested in
1686 * knowing the host connection state changed.
1687 */
Amit Shah314081f2013-07-29 14:25:38 +09301688 spin_lock_irq(&port->inbuf_lock);
Amit Shah3eae0ad2010-09-02 18:47:52 +05301689 send_sigio_to_port(port);
Amit Shah314081f2013-07-29 14:25:38 +09301690 spin_unlock_irq(&port->inbuf_lock);
Amit Shah2030fa42009-12-21 21:49:30 +05301691 break;
Amit Shah431edb82009-12-21 21:57:40 +05301692 case VIRTIO_CONSOLE_PORT_NAME:
1693 /*
Amit Shah291024e2011-09-14 13:06:40 +05301694 * If we woke up after hibernation, we can get this
1695 * again. Skip it in that case.
1696 */
1697 if (port->name)
1698 break;
1699
1700 /*
Amit Shah431edb82009-12-21 21:57:40 +05301701 * Skip the size of the header and the cpkt to get the size
1702 * of the name that was sent
1703 */
1704 name_size = buf->len - buf->offset - sizeof(*cpkt) + 1;
1705
1706 port->name = kmalloc(name_size, GFP_KERNEL);
1707 if (!port->name) {
1708 dev_err(port->dev,
1709 "Not enough space to store port name\n");
1710 break;
1711 }
1712 strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt),
1713 name_size - 1);
1714 port->name[name_size - 1] = 0;
1715
1716 /*
1717 * Since we only have one sysfs attribute, 'name',
1718 * create it only if we have a name for the port.
1719 */
1720 err = sysfs_create_group(&port->dev->kobj,
1721 &port_attribute_group);
Amit Shahec642132010-03-19 17:36:43 +05301722 if (err) {
Amit Shah431edb82009-12-21 21:57:40 +05301723 dev_err(port->dev,
1724 "Error %d creating sysfs device attributes\n",
1725 err);
Amit Shahec642132010-03-19 17:36:43 +05301726 } else {
1727 /*
1728 * Generate a udev event so that appropriate
1729 * symlinks can be created based on udev
1730 * rules.
1731 */
1732 kobject_uevent(&port->dev->kobj, KOBJ_CHANGE);
1733 }
Amit Shah431edb82009-12-21 21:57:40 +05301734 break;
Amit Shah17634ba2009-12-21 21:03:25 +05301735 }
1736}
1737
1738static void control_work_handler(struct work_struct *work)
1739{
1740 struct ports_device *portdev;
1741 struct virtqueue *vq;
1742 struct port_buffer *buf;
1743 unsigned int len;
1744
1745 portdev = container_of(work, struct ports_device, control_work);
1746 vq = portdev->c_ivq;
1747
Amit Shah165b1b82013-03-29 16:30:07 +05301748 spin_lock(&portdev->c_ivq_lock);
Michael S. Tsirkin505b0452010-04-12 16:18:32 +03001749 while ((buf = virtqueue_get_buf(vq, &len))) {
Amit Shah165b1b82013-03-29 16:30:07 +05301750 spin_unlock(&portdev->c_ivq_lock);
Amit Shah17634ba2009-12-21 21:03:25 +05301751
1752 buf->len = len;
1753 buf->offset = 0;
1754
1755 handle_control_message(portdev, buf);
1756
Amit Shah165b1b82013-03-29 16:30:07 +05301757 spin_lock(&portdev->c_ivq_lock);
Amit Shah17634ba2009-12-21 21:03:25 +05301758 if (add_inbuf(portdev->c_ivq, buf) < 0) {
1759 dev_warn(&portdev->vdev->dev,
1760 "Error adding buffer to queue\n");
Sjur Brændeland1b637042012-12-14 14:40:51 +10301761 free_buf(buf, false);
Amit Shah17634ba2009-12-21 21:03:25 +05301762 }
1763 }
Amit Shah165b1b82013-03-29 16:30:07 +05301764 spin_unlock(&portdev->c_ivq_lock);
Amit Shah17634ba2009-12-21 21:03:25 +05301765}
1766
Amit Shah2770c5e2011-01-31 13:06:36 +05301767static void out_intr(struct virtqueue *vq)
1768{
1769 struct port *port;
1770
1771 port = find_port_by_vq(vq->vdev->priv, vq);
1772 if (!port)
1773 return;
1774
1775 wake_up_interruptible(&port->waitqueue);
1776}
1777
Amit Shah17634ba2009-12-21 21:03:25 +05301778static void in_intr(struct virtqueue *vq)
1779{
1780 struct port *port;
1781 unsigned long flags;
1782
1783 port = find_port_by_vq(vq->vdev->priv, vq);
1784 if (!port)
1785 return;
1786
1787 spin_lock_irqsave(&port->inbuf_lock, flags);
Amit Shahd25a9dd2011-09-14 13:06:43 +05301788 port->inbuf = get_inbuf(port);
Amit Shah17634ba2009-12-21 21:03:25 +05301789
Amit Shah88f251a2009-12-21 22:15:30 +05301790 /*
Sjur Brændelandaabd6a82013-03-18 19:19:14 +10301791 * Normally the port should not accept data when the port is
1792 * closed. For generic serial ports, the host won't (shouldn't)
1793 * send data till the guest is connected. But this condition
Amit Shah88f251a2009-12-21 22:15:30 +05301794 * can be reached when a console port is not yet connected (no
Sjur Brændelandaabd6a82013-03-18 19:19:14 +10301795 * tty is spawned) and the other side sends out data over the
1796 * vring, or when a remote devices start sending data before
1797 * the ports are opened.
1798 *
1799 * A generic serial port will discard data if not connected,
1800 * while console ports and rproc-serial ports accepts data at
1801 * any time. rproc-serial is initiated with guest_connected to
1802 * false because port_fops_open expects this. Console ports are
1803 * hooked up with an HVC console and is initialized with
1804 * guest_connected to true.
Amit Shah88f251a2009-12-21 22:15:30 +05301805 */
Sjur Brændelandaabd6a82013-03-18 19:19:14 +10301806
1807 if (!port->guest_connected && !is_rproc_serial(port->portdev->vdev))
Amit Shah88f251a2009-12-21 22:15:30 +05301808 discard_port_data(port);
1809
Amit Shah314081f2013-07-29 14:25:38 +09301810 /* Send a SIGIO indicating new data in case the process asked for it */
1811 send_sigio_to_port(port);
1812
Amit Shah17634ba2009-12-21 21:03:25 +05301813 spin_unlock_irqrestore(&port->inbuf_lock, flags);
1814
Amit Shah2030fa42009-12-21 21:49:30 +05301815 wake_up_interruptible(&port->waitqueue);
1816
Amit Shah17634ba2009-12-21 21:03:25 +05301817 if (is_console_port(port) && hvc_poll(port->cons.hvc))
1818 hvc_kick();
1819}
1820
1821static void control_intr(struct virtqueue *vq)
1822{
1823 struct ports_device *portdev;
1824
1825 portdev = vq->vdev->priv;
1826 schedule_work(&portdev->control_work);
1827}
1828
Amit Shah7f5d8102009-12-21 22:22:08 +05301829static void config_intr(struct virtio_device *vdev)
1830{
1831 struct ports_device *portdev;
1832
1833 portdev = vdev->priv;
Amit Shah99f905f2010-05-19 22:15:48 -06001834
Amit Shah4038f5b72010-05-06 02:05:07 +05301835 if (!use_multiport(portdev)) {
Amit Shah97788292010-05-06 02:05:08 +05301836 struct port *port;
1837 u16 rows, cols;
1838
Rusty Russell855e0c52013-10-14 18:11:51 +10301839 virtio_cread(vdev, struct virtio_console_config, cols, &cols);
1840 virtio_cread(vdev, struct virtio_console_config, rows, &rows);
Amit Shah97788292010-05-06 02:05:08 +05301841
1842 port = find_port_by_id(portdev, 0);
1843 set_console_size(port, rows, cols);
1844
Amit Shah4038f5b72010-05-06 02:05:07 +05301845 /*
1846 * We'll use this way of resizing only for legacy
1847 * support. For newer userspace
1848 * (VIRTIO_CONSOLE_F_MULTPORT+), use control messages
1849 * to indicate console size changes so that it can be
1850 * done per-port.
1851 */
Amit Shah97788292010-05-06 02:05:08 +05301852 resize_console(port);
Amit Shah4038f5b72010-05-06 02:05:07 +05301853 }
Amit Shah7f5d8102009-12-21 22:22:08 +05301854}
1855
Amit Shah2658a79a2010-01-18 19:15:11 +05301856static int init_vqs(struct ports_device *portdev)
1857{
1858 vq_callback_t **io_callbacks;
1859 char **io_names;
1860 struct virtqueue **vqs;
Amit Shah17634ba2009-12-21 21:03:25 +05301861 u32 i, j, nr_ports, nr_queues;
Amit Shah2658a79a2010-01-18 19:15:11 +05301862 int err;
1863
Amit Shah17634ba2009-12-21 21:03:25 +05301864 nr_ports = portdev->config.max_nr_ports;
1865 nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2;
Amit Shah2658a79a2010-01-18 19:15:11 +05301866
1867 vqs = kmalloc(nr_queues * sizeof(struct virtqueue *), GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301868 io_callbacks = kmalloc(nr_queues * sizeof(vq_callback_t *), GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301869 io_names = kmalloc(nr_queues * sizeof(char *), GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301870 portdev->in_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
1871 GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301872 portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
1873 GFP_KERNEL);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001874 if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs ||
Amit Shah286f9a22011-09-14 13:06:39 +05301875 !portdev->out_vqs) {
Amit Shah2658a79a2010-01-18 19:15:11 +05301876 err = -ENOMEM;
Jiri Slaby22e132f2010-11-06 10:06:50 +01001877 goto free;
Amit Shah2658a79a2010-01-18 19:15:11 +05301878 }
1879
Amit Shah17634ba2009-12-21 21:03:25 +05301880 /*
1881 * For backward compat (newer host but older guest), the host
1882 * spawns a console port first and also inits the vqs for port
1883 * 0 before others.
1884 */
1885 j = 0;
1886 io_callbacks[j] = in_intr;
Amit Shah2770c5e2011-01-31 13:06:36 +05301887 io_callbacks[j + 1] = out_intr;
Amit Shah17634ba2009-12-21 21:03:25 +05301888 io_names[j] = "input";
1889 io_names[j + 1] = "output";
1890 j += 2;
Amit Shah2658a79a2010-01-18 19:15:11 +05301891
Amit Shah17634ba2009-12-21 21:03:25 +05301892 if (use_multiport(portdev)) {
1893 io_callbacks[j] = control_intr;
1894 io_callbacks[j + 1] = NULL;
1895 io_names[j] = "control-i";
1896 io_names[j + 1] = "control-o";
1897
1898 for (i = 1; i < nr_ports; i++) {
1899 j += 2;
1900 io_callbacks[j] = in_intr;
Amit Shah2770c5e2011-01-31 13:06:36 +05301901 io_callbacks[j + 1] = out_intr;
Amit Shah17634ba2009-12-21 21:03:25 +05301902 io_names[j] = "input";
1903 io_names[j + 1] = "output";
1904 }
1905 }
Amit Shah2658a79a2010-01-18 19:15:11 +05301906 /* Find the queues. */
1907 err = portdev->vdev->config->find_vqs(portdev->vdev, nr_queues, vqs,
1908 io_callbacks,
1909 (const char **)io_names);
1910 if (err)
Jiri Slaby22e132f2010-11-06 10:06:50 +01001911 goto free;
Amit Shah2658a79a2010-01-18 19:15:11 +05301912
Amit Shah17634ba2009-12-21 21:03:25 +05301913 j = 0;
Amit Shah2658a79a2010-01-18 19:15:11 +05301914 portdev->in_vqs[0] = vqs[0];
1915 portdev->out_vqs[0] = vqs[1];
Amit Shah17634ba2009-12-21 21:03:25 +05301916 j += 2;
1917 if (use_multiport(portdev)) {
1918 portdev->c_ivq = vqs[j];
1919 portdev->c_ovq = vqs[j + 1];
Amit Shah2658a79a2010-01-18 19:15:11 +05301920
Amit Shah17634ba2009-12-21 21:03:25 +05301921 for (i = 1; i < nr_ports; i++) {
1922 j += 2;
1923 portdev->in_vqs[i] = vqs[j];
1924 portdev->out_vqs[i] = vqs[j + 1];
1925 }
1926 }
Amit Shah2658a79a2010-01-18 19:15:11 +05301927 kfree(io_names);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001928 kfree(io_callbacks);
Amit Shah2658a79a2010-01-18 19:15:11 +05301929 kfree(vqs);
1930
1931 return 0;
1932
Jiri Slaby22e132f2010-11-06 10:06:50 +01001933free:
Amit Shah2658a79a2010-01-18 19:15:11 +05301934 kfree(portdev->out_vqs);
Amit Shah2658a79a2010-01-18 19:15:11 +05301935 kfree(portdev->in_vqs);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001936 kfree(io_names);
1937 kfree(io_callbacks);
Amit Shah2658a79a2010-01-18 19:15:11 +05301938 kfree(vqs);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001939
Amit Shah2658a79a2010-01-18 19:15:11 +05301940 return err;
1941}
1942
Amit Shahfb08bd22009-12-21 21:36:04 +05301943static const struct file_operations portdev_fops = {
1944 .owner = THIS_MODULE,
1945};
1946
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301947static void remove_vqs(struct ports_device *portdev)
1948{
1949 portdev->vdev->config->del_vqs(portdev->vdev);
1950 kfree(portdev->in_vqs);
1951 kfree(portdev->out_vqs);
1952}
1953
1954static void remove_controlq_data(struct ports_device *portdev)
1955{
1956 struct port_buffer *buf;
1957 unsigned int len;
1958
1959 if (!use_multiport(portdev))
1960 return;
1961
1962 while ((buf = virtqueue_get_buf(portdev->c_ivq, &len)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301963 free_buf(buf, true);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301964
1965 while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301966 free_buf(buf, true);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301967}
1968
Amit Shah1c85bf32010-01-18 19:15:07 +05301969/*
1970 * Once we're further in boot, we get probed like any other virtio
1971 * device.
Amit Shah17634ba2009-12-21 21:03:25 +05301972 *
1973 * If the host also supports multiple console ports, we check the
1974 * config space to see how many ports the host has spawned. We
1975 * initialize each port found.
Amit Shah1c85bf32010-01-18 19:15:07 +05301976 */
Bill Pemberton2223cbe2012-11-19 13:22:51 -05001977static int virtcons_probe(struct virtio_device *vdev)
Amit Shah1c85bf32010-01-18 19:15:07 +05301978{
Amit Shah1c85bf32010-01-18 19:15:07 +05301979 struct ports_device *portdev;
1980 int err;
Amit Shah17634ba2009-12-21 21:03:25 +05301981 bool multiport;
Christian Borntraeger5e384832011-09-22 23:44:23 +05301982 bool early = early_put_chars != NULL;
1983
1984 /* Ensure to read early_put_chars now */
1985 barrier();
Amit Shah1c85bf32010-01-18 19:15:07 +05301986
1987 portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
1988 if (!portdev) {
1989 err = -ENOMEM;
1990 goto fail;
1991 }
1992
1993 /* Attach this portdev to this virtio_device, and vice-versa. */
1994 portdev->vdev = vdev;
1995 vdev->priv = portdev;
1996
Amit Shahfb08bd22009-12-21 21:36:04 +05301997 portdev->chr_major = register_chrdev(0, "virtio-portsdev",
1998 &portdev_fops);
1999 if (portdev->chr_major < 0) {
2000 dev_err(&vdev->dev,
2001 "Error %d registering chrdev for device %u\n",
Sjur Brændelanddc18f082013-02-12 16:24:59 +10302002 portdev->chr_major, vdev->index);
Amit Shahfb08bd22009-12-21 21:36:04 +05302003 err = portdev->chr_major;
2004 goto free;
2005 }
2006
Amit Shah17634ba2009-12-21 21:03:25 +05302007 multiport = false;
Amit Shah17634ba2009-12-21 21:03:25 +05302008 portdev->config.max_nr_ports = 1;
Sjur Brændeland1b637042012-12-14 14:40:51 +10302009
2010 /* Don't test MULTIPORT at all if we're rproc: not a valid feature! */
2011 if (!is_rproc_serial(vdev) &&
Rusty Russell855e0c52013-10-14 18:11:51 +10302012 virtio_cread_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT,
2013 struct virtio_console_config, max_nr_ports,
2014 &portdev->config.max_nr_ports) == 0) {
Amit Shah17634ba2009-12-21 21:03:25 +05302015 multiport = true;
Sjur Brændeland1b637042012-12-14 14:40:51 +10302016 }
Amit Shah17634ba2009-12-21 21:03:25 +05302017
Amit Shah2658a79a2010-01-18 19:15:11 +05302018 err = init_vqs(portdev);
2019 if (err < 0) {
2020 dev_err(&vdev->dev, "Error %d initializing vqs\n", err);
Amit Shahfb08bd22009-12-21 21:36:04 +05302021 goto free_chrdev;
Amit Shah2658a79a2010-01-18 19:15:11 +05302022 }
Amit Shah1c85bf32010-01-18 19:15:07 +05302023
Amit Shah17634ba2009-12-21 21:03:25 +05302024 spin_lock_init(&portdev->ports_lock);
2025 INIT_LIST_HEAD(&portdev->ports);
2026
2027 if (multiport) {
Amit Shah335a64a5c2010-02-24 10:37:44 +05302028 unsigned int nr_added_bufs;
2029
Amit Shah165b1b82013-03-29 16:30:07 +05302030 spin_lock_init(&portdev->c_ivq_lock);
Amit Shah9ba5c802013-03-29 16:30:08 +05302031 spin_lock_init(&portdev->c_ovq_lock);
Amit Shah17634ba2009-12-21 21:03:25 +05302032 INIT_WORK(&portdev->control_work, &control_work_handler);
2033
Amit Shah165b1b82013-03-29 16:30:07 +05302034 nr_added_bufs = fill_queue(portdev->c_ivq,
2035 &portdev->c_ivq_lock);
Amit Shah335a64a5c2010-02-24 10:37:44 +05302036 if (!nr_added_bufs) {
Amit Shah22a29ea2010-02-12 10:32:17 +05302037 dev_err(&vdev->dev,
2038 "Error allocating buffers for control queue\n");
2039 err = -ENOMEM;
2040 goto free_vqs;
2041 }
Amit Shah1d051602010-05-19 22:15:49 -06002042 } else {
2043 /*
2044 * For backward compatibility: Create a console port
2045 * if we're running on older host.
2046 */
2047 add_port(portdev, 0);
Amit Shah17634ba2009-12-21 21:03:25 +05302048 }
2049
Amit Shah6bdf2af2010-09-02 18:11:49 +05302050 spin_lock_irq(&pdrvdata_lock);
2051 list_add_tail(&portdev->list, &pdrvdata.portdevs);
2052 spin_unlock_irq(&pdrvdata_lock);
2053
Amit Shahf909f852010-05-19 22:15:48 -06002054 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2055 VIRTIO_CONSOLE_DEVICE_READY, 1);
Christian Borntraeger5e384832011-09-22 23:44:23 +05302056
2057 /*
2058 * If there was an early virtio console, assume that there are no
2059 * other consoles. We need to wait until the hvc_alloc matches the
2060 * hvc_instantiate, otherwise tty_open will complain, resulting in
2061 * a "Warning: unable to open an initial console" boot failure.
2062 * Without multiport this is done in add_port above. With multiport
2063 * this might take some host<->guest communication - thus we have to
2064 * wait.
2065 */
2066 if (multiport && early)
2067 wait_for_completion(&early_console_added);
2068
Rusty Russell31610432007-10-22 11:03:39 +10002069 return 0;
2070
Amit Shah22a29ea2010-02-12 10:32:17 +05302071free_vqs:
Julia Lawall0643e4c2010-05-15 11:45:53 +02002072 /* The host might want to notify mgmt sw about device add failure */
2073 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2074 VIRTIO_CONSOLE_DEVICE_READY, 0);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05302075 remove_vqs(portdev);
Amit Shahfb08bd22009-12-21 21:36:04 +05302076free_chrdev:
2077 unregister_chrdev(portdev->chr_major, "virtio-portsdev");
Rusty Russell31610432007-10-22 11:03:39 +10002078free:
Amit Shah1c85bf32010-01-18 19:15:07 +05302079 kfree(portdev);
Rusty Russell31610432007-10-22 11:03:39 +10002080fail:
2081 return err;
2082}
2083
Amit Shah71778762010-02-12 10:32:16 +05302084static void virtcons_remove(struct virtio_device *vdev)
2085{
2086 struct ports_device *portdev;
2087 struct port *port, *port2;
Amit Shah71778762010-02-12 10:32:16 +05302088
2089 portdev = vdev->priv;
2090
Amit Shah6bdf2af2010-09-02 18:11:49 +05302091 spin_lock_irq(&pdrvdata_lock);
2092 list_del(&portdev->list);
2093 spin_unlock_irq(&pdrvdata_lock);
2094
Amit Shah02238952010-09-02 18:11:40 +05302095 /* Disable interrupts for vqs */
2096 vdev->config->reset(vdev);
2097 /* Finish up work that's lined up */
Sjur Brændelandaded0242013-01-22 09:50:26 +10302098 if (use_multiport(portdev))
2099 cancel_work_sync(&portdev->control_work);
Amit Shah71778762010-02-12 10:32:16 +05302100
2101 list_for_each_entry_safe(port, port2, &portdev->ports, list)
Amit Shahb353a6b2010-09-02 18:38:29 +05302102 unplug_port(port);
Amit Shah71778762010-02-12 10:32:16 +05302103
2104 unregister_chrdev(portdev->chr_major, "virtio-portsdev");
2105
Amit Shahe0620132010-09-02 18:38:30 +05302106 /*
2107 * When yanking out a device, we immediately lose the
2108 * (device-side) queues. So there's no point in keeping the
2109 * guest side around till we drop our final reference. This
2110 * also means that any ports which are in an open state will
2111 * have to just stop using the port, as the vqs are going
2112 * away.
2113 */
Amit Shaha0e2dbf2011-12-22 16:58:27 +05302114 remove_controlq_data(portdev);
2115 remove_vqs(portdev);
Amit Shah71778762010-02-12 10:32:16 +05302116 kfree(portdev);
2117}
2118
Rusty Russell31610432007-10-22 11:03:39 +10002119static struct virtio_device_id id_table[] = {
2120 { VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID },
2121 { 0 },
2122};
2123
Christian Borntraegerc2983452008-11-25 13:36:26 +01002124static unsigned int features[] = {
2125 VIRTIO_CONSOLE_F_SIZE,
Amit Shahb99fa812010-05-19 22:15:46 -06002126 VIRTIO_CONSOLE_F_MULTIPORT,
Christian Borntraegerc2983452008-11-25 13:36:26 +01002127};
2128
Sjur Brændeland1b637042012-12-14 14:40:51 +10302129static struct virtio_device_id rproc_serial_id_table[] = {
2130#if IS_ENABLED(CONFIG_REMOTEPROC)
2131 { VIRTIO_ID_RPROC_SERIAL, VIRTIO_DEV_ANY_ID },
2132#endif
2133 { 0 },
2134};
2135
2136static unsigned int rproc_serial_features[] = {
2137};
2138
Aaron Lu89107002013-09-17 09:25:23 +09302139#ifdef CONFIG_PM_SLEEP
Amit Shah2b8f41d2011-12-22 16:58:28 +05302140static int virtcons_freeze(struct virtio_device *vdev)
2141{
2142 struct ports_device *portdev;
2143 struct port *port;
2144
2145 portdev = vdev->priv;
2146
2147 vdev->config->reset(vdev);
2148
Amit Shahc743d092012-01-06 16:19:08 +05302149 virtqueue_disable_cb(portdev->c_ivq);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302150 cancel_work_sync(&portdev->control_work);
Amit Shahc743d092012-01-06 16:19:08 +05302151 /*
2152 * Once more: if control_work_handler() was running, it would
2153 * enable the cb as the last step.
2154 */
2155 virtqueue_disable_cb(portdev->c_ivq);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302156 remove_controlq_data(portdev);
2157
2158 list_for_each_entry(port, &portdev->ports, list) {
Amit Shahc743d092012-01-06 16:19:08 +05302159 virtqueue_disable_cb(port->in_vq);
2160 virtqueue_disable_cb(port->out_vq);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302161 /*
2162 * We'll ask the host later if the new invocation has
2163 * the port opened or closed.
2164 */
2165 port->host_connected = false;
2166 remove_port_data(port);
2167 }
2168 remove_vqs(portdev);
2169
2170 return 0;
2171}
2172
2173static int virtcons_restore(struct virtio_device *vdev)
2174{
2175 struct ports_device *portdev;
2176 struct port *port;
2177 int ret;
2178
2179 portdev = vdev->priv;
2180
2181 ret = init_vqs(portdev);
2182 if (ret)
2183 return ret;
2184
2185 if (use_multiport(portdev))
Amit Shah165b1b82013-03-29 16:30:07 +05302186 fill_queue(portdev->c_ivq, &portdev->c_ivq_lock);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302187
2188 list_for_each_entry(port, &portdev->ports, list) {
2189 port->in_vq = portdev->in_vqs[port->id];
2190 port->out_vq = portdev->out_vqs[port->id];
2191
2192 fill_queue(port->in_vq, &port->inbuf_lock);
2193
2194 /* Get port open/close status on the host */
2195 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
Amit Shahfa8b66c2012-04-25 14:40:39 +05302196
2197 /*
2198 * If a port was open at the time of suspending, we
2199 * have to let the host know that it's still open.
2200 */
2201 if (port->guest_connected)
2202 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302203 }
2204 return 0;
2205}
2206#endif
2207
Rusty Russell31610432007-10-22 11:03:39 +10002208static struct virtio_driver virtio_console = {
Christian Borntraegerc2983452008-11-25 13:36:26 +01002209 .feature_table = features,
2210 .feature_table_size = ARRAY_SIZE(features),
Rusty Russell31610432007-10-22 11:03:39 +10002211 .driver.name = KBUILD_MODNAME,
2212 .driver.owner = THIS_MODULE,
2213 .id_table = id_table,
2214 .probe = virtcons_probe,
Amit Shah71778762010-02-12 10:32:16 +05302215 .remove = virtcons_remove,
Amit Shah7f5d8102009-12-21 22:22:08 +05302216 .config_changed = config_intr,
Aaron Lu89107002013-09-17 09:25:23 +09302217#ifdef CONFIG_PM_SLEEP
Amit Shah2b8f41d2011-12-22 16:58:28 +05302218 .freeze = virtcons_freeze,
2219 .restore = virtcons_restore,
2220#endif
Rusty Russell31610432007-10-22 11:03:39 +10002221};
2222
Greg Kroah-Hartmanbcd29822012-12-21 15:12:08 -08002223static struct virtio_driver virtio_rproc_serial = {
Sjur Brændeland1b637042012-12-14 14:40:51 +10302224 .feature_table = rproc_serial_features,
2225 .feature_table_size = ARRAY_SIZE(rproc_serial_features),
2226 .driver.name = "virtio_rproc_serial",
2227 .driver.owner = THIS_MODULE,
2228 .id_table = rproc_serial_id_table,
2229 .probe = virtcons_probe,
2230 .remove = virtcons_remove,
2231};
2232
Rusty Russell31610432007-10-22 11:03:39 +10002233static int __init init(void)
2234{
Amit Shahfb08bd22009-12-21 21:36:04 +05302235 int err;
2236
2237 pdrvdata.class = class_create(THIS_MODULE, "virtio-ports");
2238 if (IS_ERR(pdrvdata.class)) {
2239 err = PTR_ERR(pdrvdata.class);
2240 pr_err("Error %d creating virtio-ports class\n", err);
2241 return err;
2242 }
Amit Shahd99393e2009-12-21 22:36:21 +05302243
2244 pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL);
Dan Carpenter3f0d0c92013-07-30 15:54:07 +09302245 if (!pdrvdata.debugfs_dir)
2246 pr_warning("Error creating debugfs dir for virtio-ports\n");
Amit Shah38edf582010-01-18 19:15:05 +05302247 INIT_LIST_HEAD(&pdrvdata.consoles);
Amit Shah6bdf2af2010-09-02 18:11:49 +05302248 INIT_LIST_HEAD(&pdrvdata.portdevs);
Amit Shah38edf582010-01-18 19:15:05 +05302249
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002250 err = register_virtio_driver(&virtio_console);
2251 if (err < 0) {
2252 pr_err("Error %d registering virtio driver\n", err);
2253 goto free;
2254 }
Sjur Brændeland1b637042012-12-14 14:40:51 +10302255 err = register_virtio_driver(&virtio_rproc_serial);
2256 if (err < 0) {
2257 pr_err("Error %d registering virtio rproc serial driver\n",
2258 err);
2259 goto unregister;
2260 }
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002261 return 0;
Sjur Brændeland1b637042012-12-14 14:40:51 +10302262unregister:
2263 unregister_virtio_driver(&virtio_console);
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002264free:
2265 if (pdrvdata.debugfs_dir)
2266 debugfs_remove_recursive(pdrvdata.debugfs_dir);
2267 class_destroy(pdrvdata.class);
2268 return err;
Rusty Russell31610432007-10-22 11:03:39 +10002269}
Amit Shah71778762010-02-12 10:32:16 +05302270
2271static void __exit fini(void)
2272{
Sjur Brændeland1b637042012-12-14 14:40:51 +10302273 reclaim_dma_bufs();
2274
Amit Shah71778762010-02-12 10:32:16 +05302275 unregister_virtio_driver(&virtio_console);
Sjur Brændeland1b637042012-12-14 14:40:51 +10302276 unregister_virtio_driver(&virtio_rproc_serial);
Amit Shah71778762010-02-12 10:32:16 +05302277
2278 class_destroy(pdrvdata.class);
2279 if (pdrvdata.debugfs_dir)
2280 debugfs_remove_recursive(pdrvdata.debugfs_dir);
2281}
Rusty Russell31610432007-10-22 11:03:39 +10002282module_init(init);
Amit Shah71778762010-02-12 10:32:16 +05302283module_exit(fini);
Rusty Russell31610432007-10-22 11:03:39 +10002284
2285MODULE_DEVICE_TABLE(virtio, id_table);
2286MODULE_DESCRIPTION("Virtio console driver");
2287MODULE_LICENSE("GPL");