blob: ce5f3fc25d6dbf1f7c45ff4cad6d2349da202d1a [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
81DEFINE_SPINLOCK(pdrvdata_lock);
Christian Borntraeger5e384832011-09-22 23:44:23 +053082DECLARE_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);
275 list_for_each_entry(port, &portdev->ports, list)
Amit Shahd22a6982010-09-02 18:20:59 +0530276 if (port->cdev->dev == dev)
Amit Shah04950cd2010-09-02 18:20:58 +0530277 goto out;
278 port = NULL;
279out:
280 spin_unlock_irqrestore(&portdev->ports_lock, flags);
281
282 return port;
283}
284
285static struct port *find_port_by_devt(dev_t dev)
286{
287 struct ports_device *portdev;
288 struct port *port;
289 unsigned long flags;
290
291 spin_lock_irqsave(&pdrvdata_lock, flags);
292 list_for_each_entry(portdev, &pdrvdata.portdevs, list) {
293 port = find_port_by_devt_in_portdev(portdev, dev);
294 if (port)
295 goto out;
296 }
297 port = NULL;
298out:
299 spin_unlock_irqrestore(&pdrvdata_lock, flags);
300 return port;
301}
302
Amit Shah17634ba2009-12-21 21:03:25 +0530303static struct port *find_port_by_id(struct ports_device *portdev, u32 id)
304{
305 struct port *port;
306 unsigned long flags;
307
308 spin_lock_irqsave(&portdev->ports_lock, flags);
309 list_for_each_entry(port, &portdev->ports, list)
310 if (port->id == id)
311 goto out;
312 port = NULL;
313out:
314 spin_unlock_irqrestore(&portdev->ports_lock, flags);
315
316 return port;
317}
318
Amit Shah203baab2010-01-18 19:15:12 +0530319static struct port *find_port_by_vq(struct ports_device *portdev,
320 struct virtqueue *vq)
321{
322 struct port *port;
Amit Shah203baab2010-01-18 19:15:12 +0530323 unsigned long flags;
324
Amit Shah17634ba2009-12-21 21:03:25 +0530325 spin_lock_irqsave(&portdev->ports_lock, flags);
326 list_for_each_entry(port, &portdev->ports, list)
Amit Shah203baab2010-01-18 19:15:12 +0530327 if (port->in_vq == vq || port->out_vq == vq)
328 goto out;
Amit Shah203baab2010-01-18 19:15:12 +0530329 port = NULL;
330out:
Amit Shah17634ba2009-12-21 21:03:25 +0530331 spin_unlock_irqrestore(&portdev->ports_lock, flags);
Amit Shah203baab2010-01-18 19:15:12 +0530332 return port;
333}
334
Amit Shah17634ba2009-12-21 21:03:25 +0530335static bool is_console_port(struct port *port)
336{
337 if (port->cons.hvc)
338 return true;
339 return false;
340}
341
Sjur Brændeland1b637042012-12-14 14:40:51 +1030342static bool is_rproc_serial(const struct virtio_device *vdev)
343{
344 return is_rproc_enabled && vdev->id.device == VIRTIO_ID_RPROC_SERIAL;
345}
346
Amit Shah17634ba2009-12-21 21:03:25 +0530347static inline bool use_multiport(struct ports_device *portdev)
348{
349 /*
350 * This condition can be true when put_chars is called from
351 * early_init
352 */
353 if (!portdev->vdev)
354 return 0;
355 return portdev->vdev->features[0] & (1 << VIRTIO_CONSOLE_F_MULTIPORT);
356}
357
Sjur Brændeland1b637042012-12-14 14:40:51 +1030358static DEFINE_SPINLOCK(dma_bufs_lock);
359static LIST_HEAD(pending_free_dma_bufs);
360
361static void free_buf(struct port_buffer *buf, bool can_sleep)
Amit Shahfdb9a052010-01-18 19:15:01 +0530362{
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030363 unsigned int i;
364
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030365 for (i = 0; i < buf->sgpages; i++) {
366 struct page *page = sg_page(&buf->sg[i]);
367 if (!page)
368 break;
369 put_page(page);
370 }
371
Sjur Brændeland1b637042012-12-14 14:40:51 +1030372 if (!buf->dev) {
373 kfree(buf->buf);
374 } else if (is_rproc_enabled) {
375 unsigned long flags;
376
377 /* dma_free_coherent requires interrupts to be enabled. */
378 if (!can_sleep) {
379 /* queue up dma-buffers to be freed later */
380 spin_lock_irqsave(&dma_bufs_lock, flags);
381 list_add_tail(&buf->list, &pending_free_dma_bufs);
382 spin_unlock_irqrestore(&dma_bufs_lock, flags);
383 return;
384 }
385 dma_free_coherent(buf->dev, buf->size, buf->buf, buf->dma);
386
387 /* Release device refcnt and allow it to be freed */
388 put_device(buf->dev);
389 }
390
Amit Shahfdb9a052010-01-18 19:15:01 +0530391 kfree(buf);
392}
393
Sjur Brændeland1b637042012-12-14 14:40:51 +1030394static void reclaim_dma_bufs(void)
395{
396 unsigned long flags;
397 struct port_buffer *buf, *tmp;
398 LIST_HEAD(tmp_list);
399
400 if (list_empty(&pending_free_dma_bufs))
401 return;
402
403 /* Create a copy of the pending_free_dma_bufs while holding the lock */
404 spin_lock_irqsave(&dma_bufs_lock, flags);
405 list_cut_position(&tmp_list, &pending_free_dma_bufs,
406 pending_free_dma_bufs.prev);
407 spin_unlock_irqrestore(&dma_bufs_lock, flags);
408
409 /* Release the dma buffers, without irqs enabled */
410 list_for_each_entry_safe(buf, tmp, &tmp_list, list) {
411 list_del(&buf->list);
412 free_buf(buf, true);
413 }
414}
415
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030416static struct port_buffer *alloc_buf(struct virtqueue *vq, size_t buf_size,
417 int pages)
Amit Shahfdb9a052010-01-18 19:15:01 +0530418{
419 struct port_buffer *buf;
420
Sjur Brændeland1b637042012-12-14 14:40:51 +1030421 reclaim_dma_bufs();
422
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030423 /*
424 * Allocate buffer and the sg list. The sg list array is allocated
425 * directly after the port_buffer struct.
426 */
427 buf = kmalloc(sizeof(*buf) + sizeof(struct scatterlist) * pages,
428 GFP_KERNEL);
Amit Shahfdb9a052010-01-18 19:15:01 +0530429 if (!buf)
430 goto fail;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030431
432 buf->sgpages = pages;
433 if (pages > 0) {
Sjur Brændeland1b637042012-12-14 14:40:51 +1030434 buf->dev = NULL;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030435 buf->buf = NULL;
436 return buf;
437 }
438
Sjur Brændeland1b637042012-12-14 14:40:51 +1030439 if (is_rproc_serial(vq->vdev)) {
440 /*
441 * Allocate DMA memory from ancestor. When a virtio
442 * device is created by remoteproc, the DMA memory is
443 * associated with the grandparent device:
444 * vdev => rproc => platform-dev.
445 * The code here would have been less quirky if
446 * DMA_MEMORY_INCLUDES_CHILDREN had been supported
447 * in dma-coherent.c
448 */
449 if (!vq->vdev->dev.parent || !vq->vdev->dev.parent->parent)
450 goto free_buf;
451 buf->dev = vq->vdev->dev.parent->parent;
452
453 /* Increase device refcnt to avoid freeing it */
454 get_device(buf->dev);
455 buf->buf = dma_alloc_coherent(buf->dev, buf_size, &buf->dma,
456 GFP_KERNEL);
457 } else {
458 buf->dev = NULL;
459 buf->buf = kmalloc(buf_size, GFP_KERNEL);
460 }
461
Amit Shahfdb9a052010-01-18 19:15:01 +0530462 if (!buf->buf)
463 goto free_buf;
464 buf->len = 0;
465 buf->offset = 0;
466 buf->size = buf_size;
467 return buf;
468
469free_buf:
470 kfree(buf);
471fail:
472 return NULL;
473}
474
Amit Shaha3cde442010-01-18 19:15:03 +0530475/* Callers should take appropriate locks */
Amit Shahdefde662011-09-14 13:06:42 +0530476static struct port_buffer *get_inbuf(struct port *port)
Amit Shaha3cde442010-01-18 19:15:03 +0530477{
478 struct port_buffer *buf;
Amit Shaha3cde442010-01-18 19:15:03 +0530479 unsigned int len;
480
Amit Shahd25a9dd2011-09-14 13:06:43 +0530481 if (port->inbuf)
482 return port->inbuf;
483
484 buf = virtqueue_get_buf(port->in_vq, &len);
Amit Shaha3cde442010-01-18 19:15:03 +0530485 if (buf) {
486 buf->len = len;
487 buf->offset = 0;
Amit Shah17e5b4f2011-09-14 13:06:46 +0530488 port->stats.bytes_received += len;
Amit Shaha3cde442010-01-18 19:15:03 +0530489 }
490 return buf;
491}
492
Rusty Russella23ea922010-01-18 19:14:55 +0530493/*
Amit Shahe27b5192010-01-18 19:15:02 +0530494 * Create a scatter-gather list representing our input buffer and put
495 * it in the queue.
496 *
497 * Callers should take appropriate locks.
498 */
Amit Shah203baab2010-01-18 19:15:12 +0530499static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)
Amit Shahe27b5192010-01-18 19:15:02 +0530500{
501 struct scatterlist sg[1];
Amit Shah203baab2010-01-18 19:15:12 +0530502 int ret;
Amit Shah1c85bf32010-01-18 19:15:07 +0530503
Amit Shahe27b5192010-01-18 19:15:02 +0530504 sg_init_one(sg, buf->buf, buf->size);
505
Rusty Russellf96fde42012-01-12 15:44:42 +1030506 ret = virtqueue_add_buf(vq, sg, 0, 1, buf, GFP_ATOMIC);
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300507 virtqueue_kick(vq);
Amit Shah49e86f12012-12-10 09:45:12 +1030508 if (!ret)
509 ret = vq->num_free;
Amit Shah203baab2010-01-18 19:15:12 +0530510 return ret;
511}
512
Amit Shah88f251a2009-12-21 22:15:30 +0530513/* Discard any unread data this port has. Callers lockers. */
514static void discard_port_data(struct port *port)
515{
516 struct port_buffer *buf;
Amit Shah2d24cda2011-09-14 13:06:45 +0530517 unsigned int err;
Amit Shah88f251a2009-12-21 22:15:30 +0530518
Amit Shahd7a62cd2011-03-04 14:04:33 +1030519 if (!port->portdev) {
520 /* Device has been unplugged. vqs are already gone. */
521 return;
522 }
Amit Shah2d24cda2011-09-14 13:06:45 +0530523 buf = get_inbuf(port);
Amit Shah88f251a2009-12-21 22:15:30 +0530524
Amit Shahce072a02011-09-14 13:06:44 +0530525 err = 0;
Amit Shahd6933562010-02-12 10:32:18 +0530526 while (buf) {
Amit Shah17e5b4f2011-09-14 13:06:46 +0530527 port->stats.bytes_discarded += buf->len - buf->offset;
Amit Shah2d24cda2011-09-14 13:06:45 +0530528 if (add_inbuf(port->in_vq, buf) < 0) {
Amit Shahce072a02011-09-14 13:06:44 +0530529 err++;
Sjur Brændeland1b637042012-12-14 14:40:51 +1030530 free_buf(buf, false);
Amit Shahd6933562010-02-12 10:32:18 +0530531 }
Amit Shah2d24cda2011-09-14 13:06:45 +0530532 port->inbuf = NULL;
533 buf = get_inbuf(port);
Amit Shah88f251a2009-12-21 22:15:30 +0530534 }
Amit Shahce072a02011-09-14 13:06:44 +0530535 if (err)
Amit Shahd6933562010-02-12 10:32:18 +0530536 dev_warn(port->dev, "Errors adding %d buffers back to vq\n",
Amit Shahce072a02011-09-14 13:06:44 +0530537 err);
Amit Shah88f251a2009-12-21 22:15:30 +0530538}
539
Amit Shah203baab2010-01-18 19:15:12 +0530540static bool port_has_data(struct port *port)
541{
542 unsigned long flags;
543 bool ret;
544
Amit Shahd6933562010-02-12 10:32:18 +0530545 ret = false;
Amit Shahd25a9dd2011-09-14 13:06:43 +0530546 spin_lock_irqsave(&port->inbuf_lock, flags);
547 port->inbuf = get_inbuf(port);
548 if (port->inbuf)
549 ret = true;
550
Amit Shah203baab2010-01-18 19:15:12 +0530551 spin_unlock_irqrestore(&port->inbuf_lock, flags);
Amit Shah203baab2010-01-18 19:15:12 +0530552 return ret;
553}
554
Amit Shah3425e702010-05-19 22:15:46 -0600555static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id,
556 unsigned int event, unsigned int value)
Amit Shah17634ba2009-12-21 21:03:25 +0530557{
558 struct scatterlist sg[1];
559 struct virtio_console_control cpkt;
560 struct virtqueue *vq;
Amit Shah604b2ad2010-02-24 10:36:51 +0530561 unsigned int len;
Amit Shah17634ba2009-12-21 21:03:25 +0530562
Amit Shah3425e702010-05-19 22:15:46 -0600563 if (!use_multiport(portdev))
Amit Shah17634ba2009-12-21 21:03:25 +0530564 return 0;
565
Amit Shah3425e702010-05-19 22:15:46 -0600566 cpkt.id = port_id;
Amit Shah17634ba2009-12-21 21:03:25 +0530567 cpkt.event = event;
568 cpkt.value = value;
569
Amit Shah3425e702010-05-19 22:15:46 -0600570 vq = portdev->c_ovq;
Amit Shah17634ba2009-12-21 21:03:25 +0530571
572 sg_init_one(sg, &cpkt, sizeof(cpkt));
Amit Shah9ba5c802013-03-29 16:30:08 +0530573
574 spin_lock(&portdev->c_ovq_lock);
Rusty Russell589575a2012-10-16 23:56:15 +1030575 if (virtqueue_add_buf(vq, sg, 1, 0, &cpkt, GFP_ATOMIC) == 0) {
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300576 virtqueue_kick(vq);
577 while (!virtqueue_get_buf(vq, &len))
Amit Shah17634ba2009-12-21 21:03:25 +0530578 cpu_relax();
579 }
Amit Shah9ba5c802013-03-29 16:30:08 +0530580 spin_unlock(&portdev->c_ovq_lock);
Amit Shah17634ba2009-12-21 21:03:25 +0530581 return 0;
582}
583
Amit Shah3425e702010-05-19 22:15:46 -0600584static ssize_t send_control_msg(struct port *port, unsigned int event,
585 unsigned int value)
586{
Amit Shah84ec06c2010-09-02 18:11:42 +0530587 /* Did the port get unplugged before userspace closed it? */
588 if (port->portdev)
589 return __send_control_msg(port->portdev, port->id, event, value);
590 return 0;
Amit Shah3425e702010-05-19 22:15:46 -0600591}
592
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900593
Amit Shahcdfadfc2010-05-19 22:15:50 -0600594/* Callers must take the port->outvq_lock */
595static void reclaim_consumed_buffers(struct port *port)
596{
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030597 struct port_buffer *buf;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600598 unsigned int len;
599
Amit Shahd7a62cd2011-03-04 14:04:33 +1030600 if (!port->portdev) {
601 /* Device has been unplugged. vqs are already gone. */
602 return;
603 }
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030604 while ((buf = virtqueue_get_buf(port->out_vq, &len))) {
Sjur Brændeland1b637042012-12-14 14:40:51 +1030605 free_buf(buf, false);
Amit Shahcdfadfc2010-05-19 22:15:50 -0600606 port->outvq_full = false;
607 }
608}
609
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900610static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,
611 int nents, size_t in_count,
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030612 void *data, bool nonblock)
Amit Shahf997f00b2009-12-21 17:28:51 +0530613{
Amit Shahf997f00b2009-12-21 17:28:51 +0530614 struct virtqueue *out_vq;
Rusty Russell589575a2012-10-16 23:56:15 +1030615 int err;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600616 unsigned long flags;
Amit Shahf997f00b2009-12-21 17:28:51 +0530617 unsigned int len;
618
619 out_vq = port->out_vq;
620
Amit Shahcdfadfc2010-05-19 22:15:50 -0600621 spin_lock_irqsave(&port->outvq_lock, flags);
622
623 reclaim_consumed_buffers(port);
624
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030625 err = virtqueue_add_buf(out_vq, sg, nents, 0, data, GFP_ATOMIC);
Amit Shahf997f00b2009-12-21 17:28:51 +0530626
627 /* Tell Host to go! */
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300628 virtqueue_kick(out_vq);
Amit Shahf997f00b2009-12-21 17:28:51 +0530629
Rusty Russell589575a2012-10-16 23:56:15 +1030630 if (err) {
Rusty Russell9ff4cfa2010-04-08 09:46:16 -0600631 in_count = 0;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600632 goto done;
Amit Shahf997f00b2009-12-21 17:28:51 +0530633 }
634
Rusty Russell589575a2012-10-16 23:56:15 +1030635 if (out_vq->num_free == 0)
Amit Shahcdfadfc2010-05-19 22:15:50 -0600636 port->outvq_full = true;
637
638 if (nonblock)
639 goto done;
640
641 /*
642 * Wait till the host acknowledges it pushed out the data we
Amit Shah531295e2010-10-20 13:45:43 +1030643 * sent. This is done for data from the hvc_console; the tty
644 * operations are performed with spinlocks held so we can't
645 * sleep here. An alternative would be to copy the data to a
646 * buffer and relax the spinning requirement. The downside is
647 * we need to kmalloc a GFP_ATOMIC buffer each time the
648 * console driver writes something out.
Amit Shahcdfadfc2010-05-19 22:15:50 -0600649 */
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300650 while (!virtqueue_get_buf(out_vq, &len))
Amit Shahf997f00b2009-12-21 17:28:51 +0530651 cpu_relax();
Amit Shahcdfadfc2010-05-19 22:15:50 -0600652done:
653 spin_unlock_irqrestore(&port->outvq_lock, flags);
Amit Shah17e5b4f2011-09-14 13:06:46 +0530654
655 port->stats.bytes_sent += in_count;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600656 /*
657 * We're expected to return the amount of data we wrote -- all
658 * of it
659 */
Rusty Russell9ff4cfa2010-04-08 09:46:16 -0600660 return in_count;
Amit Shahf997f00b2009-12-21 17:28:51 +0530661}
662
Amit Shah203baab2010-01-18 19:15:12 +0530663/*
664 * Give out the data that's requested from the buffer that we have
665 * queued up.
666 */
Amit Shahb766cee2009-12-21 21:26:45 +0530667static ssize_t fill_readbuf(struct port *port, char *out_buf, size_t out_count,
668 bool to_user)
Amit Shah203baab2010-01-18 19:15:12 +0530669{
670 struct port_buffer *buf;
671 unsigned long flags;
672
673 if (!out_count || !port_has_data(port))
674 return 0;
675
676 buf = port->inbuf;
Amit Shahb766cee2009-12-21 21:26:45 +0530677 out_count = min(out_count, buf->len - buf->offset);
Amit Shah203baab2010-01-18 19:15:12 +0530678
Amit Shahb766cee2009-12-21 21:26:45 +0530679 if (to_user) {
680 ssize_t ret;
Amit Shah203baab2010-01-18 19:15:12 +0530681
Amit Shahb766cee2009-12-21 21:26:45 +0530682 ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count);
683 if (ret)
684 return -EFAULT;
685 } else {
686 memcpy(out_buf, buf->buf + buf->offset, out_count);
687 }
688
Amit Shah203baab2010-01-18 19:15:12 +0530689 buf->offset += out_count;
690
691 if (buf->offset == buf->len) {
692 /*
693 * We're done using all the data in this buffer.
694 * Re-queue so that the Host can send us more data.
695 */
696 spin_lock_irqsave(&port->inbuf_lock, flags);
697 port->inbuf = NULL;
698
699 if (add_inbuf(port->in_vq, buf) < 0)
Amit Shahfb08bd22009-12-21 21:36:04 +0530700 dev_warn(port->dev, "failed add_buf\n");
Amit Shah203baab2010-01-18 19:15:12 +0530701
702 spin_unlock_irqrestore(&port->inbuf_lock, flags);
703 }
Amit Shahb766cee2009-12-21 21:26:45 +0530704 /* Return the number of bytes actually copied */
Amit Shah203baab2010-01-18 19:15:12 +0530705 return out_count;
Amit Shahe27b5192010-01-18 19:15:02 +0530706}
707
Amit Shah2030fa42009-12-21 21:49:30 +0530708/* The condition that must be true for polling to end */
Amit Shah60caacd2010-05-19 22:15:49 -0600709static bool will_read_block(struct port *port)
Amit Shah2030fa42009-12-21 21:49:30 +0530710{
Amit Shah3709ea72010-09-02 18:11:43 +0530711 if (!port->guest_connected) {
712 /* Port got hot-unplugged. Let's exit. */
713 return false;
714 }
Amit Shah60caacd2010-05-19 22:15:49 -0600715 return !port_has_data(port) && port->host_connected;
Amit Shah2030fa42009-12-21 21:49:30 +0530716}
717
Amit Shahcdfadfc2010-05-19 22:15:50 -0600718static bool will_write_block(struct port *port)
719{
720 bool ret;
721
Amit Shah60e5e0b2010-05-27 13:24:40 +0530722 if (!port->guest_connected) {
723 /* Port got hot-unplugged. Let's exit. */
724 return false;
725 }
Amit Shahcdfadfc2010-05-19 22:15:50 -0600726 if (!port->host_connected)
727 return true;
728
729 spin_lock_irq(&port->outvq_lock);
730 /*
731 * Check if the Host has consumed any buffers since we last
732 * sent data (this is only applicable for nonblocking ports).
733 */
734 reclaim_consumed_buffers(port);
735 ret = port->outvq_full;
736 spin_unlock_irq(&port->outvq_lock);
737
738 return ret;
739}
740
Amit Shah2030fa42009-12-21 21:49:30 +0530741static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
742 size_t count, loff_t *offp)
743{
744 struct port *port;
745 ssize_t ret;
746
747 port = filp->private_data;
748
749 if (!port_has_data(port)) {
750 /*
751 * If nothing's connected on the host just return 0 in
752 * case of list_empty; this tells the userspace app
753 * that there's no connection
754 */
755 if (!port->host_connected)
756 return 0;
757 if (filp->f_flags & O_NONBLOCK)
758 return -EAGAIN;
759
Amit Shaha08fa922011-09-14 13:06:41 +0530760 ret = wait_event_freezable(port->waitqueue,
761 !will_read_block(port));
Amit Shah2030fa42009-12-21 21:49:30 +0530762 if (ret < 0)
763 return ret;
764 }
Amit Shahb3dddb92010-09-02 18:11:45 +0530765 /* Port got hot-unplugged. */
766 if (!port->guest_connected)
767 return -ENODEV;
Amit Shah2030fa42009-12-21 21:49:30 +0530768 /*
769 * We could've received a disconnection message while we were
770 * waiting for more data.
771 *
772 * This check is not clubbed in the if() statement above as we
773 * might receive some data as well as the host could get
774 * disconnected after we got woken up from our wait. So we
775 * really want to give off whatever data we have and only then
776 * check for host_connected.
777 */
778 if (!port_has_data(port) && !port->host_connected)
779 return 0;
780
781 return fill_readbuf(port, ubuf, count, true);
782}
783
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900784static int wait_port_writable(struct port *port, bool nonblock)
785{
786 int ret;
787
788 if (will_write_block(port)) {
789 if (nonblock)
790 return -EAGAIN;
791
792 ret = wait_event_freezable(port->waitqueue,
793 !will_write_block(port));
794 if (ret < 0)
795 return ret;
796 }
797 /* Port got hot-unplugged. */
798 if (!port->guest_connected)
799 return -ENODEV;
800
801 return 0;
802}
803
Amit Shah2030fa42009-12-21 21:49:30 +0530804static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
805 size_t count, loff_t *offp)
806{
807 struct port *port;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030808 struct port_buffer *buf;
Amit Shah2030fa42009-12-21 21:49:30 +0530809 ssize_t ret;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600810 bool nonblock;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030811 struct scatterlist sg[1];
Amit Shah2030fa42009-12-21 21:49:30 +0530812
Amit Shah65745422010-09-14 13:26:16 +0530813 /* Userspace could be out to fool us */
814 if (!count)
815 return 0;
816
Amit Shah2030fa42009-12-21 21:49:30 +0530817 port = filp->private_data;
818
Amit Shahcdfadfc2010-05-19 22:15:50 -0600819 nonblock = filp->f_flags & O_NONBLOCK;
820
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900821 ret = wait_port_writable(port, nonblock);
822 if (ret < 0)
823 return ret;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600824
Amit Shah2030fa42009-12-21 21:49:30 +0530825 count = min((size_t)(32 * 1024), count);
826
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030827 buf = alloc_buf(port->out_vq, count, 0);
Amit Shah2030fa42009-12-21 21:49:30 +0530828 if (!buf)
829 return -ENOMEM;
830
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030831 ret = copy_from_user(buf->buf, ubuf, count);
Amit Shah2030fa42009-12-21 21:49:30 +0530832 if (ret) {
833 ret = -EFAULT;
834 goto free_buf;
835 }
836
Amit Shah531295e2010-10-20 13:45:43 +1030837 /*
838 * We now ask send_buf() to not spin for generic ports -- we
839 * can re-use the same code path that non-blocking file
840 * descriptors take for blocking file descriptors since the
841 * wait is already done and we're certain the write will go
842 * through to the host.
843 */
844 nonblock = true;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030845 sg_init_one(sg, buf->buf, count);
846 ret = __send_to_port(port, sg, 1, count, buf, nonblock);
Amit Shahcdfadfc2010-05-19 22:15:50 -0600847
848 if (nonblock && ret > 0)
849 goto out;
850
Amit Shah2030fa42009-12-21 21:49:30 +0530851free_buf:
Sjur Brændeland1b637042012-12-14 14:40:51 +1030852 free_buf(buf, true);
Amit Shahcdfadfc2010-05-19 22:15:50 -0600853out:
Amit Shah2030fa42009-12-21 21:49:30 +0530854 return ret;
855}
856
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900857struct sg_list {
858 unsigned int n;
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900859 unsigned int size;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900860 size_t len;
861 struct scatterlist *sg;
862};
863
864static int pipe_to_sg(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
865 struct splice_desc *sd)
866{
867 struct sg_list *sgl = sd->u.data;
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900868 unsigned int offset, len;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900869
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900870 if (sgl->n == sgl->size)
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900871 return 0;
872
873 /* Try lock this page */
874 if (buf->ops->steal(pipe, buf) == 0) {
875 /* Get reference and unlock page for moving */
876 get_page(buf->page);
877 unlock_page(buf->page);
878
879 len = min(buf->len, sd->len);
880 sg_set_page(&(sgl->sg[sgl->n]), buf->page, len, buf->offset);
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900881 } else {
882 /* Failback to copying a page */
883 struct page *page = alloc_page(GFP_KERNEL);
884 char *src = buf->ops->map(pipe, buf, 1);
885 char *dst;
886
887 if (!page)
888 return -ENOMEM;
889 dst = kmap(page);
890
891 offset = sd->pos & ~PAGE_MASK;
892
893 len = sd->len;
894 if (len + offset > PAGE_SIZE)
895 len = PAGE_SIZE - offset;
896
897 memcpy(dst + offset, src + buf->offset, len);
898
899 kunmap(page);
900 buf->ops->unmap(pipe, buf, src);
901
902 sg_set_page(&(sgl->sg[sgl->n]), page, len, offset);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900903 }
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900904 sgl->n++;
905 sgl->len += len;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900906
907 return len;
908}
909
910/* Faster zero-copy write by splicing */
911static ssize_t port_fops_splice_write(struct pipe_inode_info *pipe,
912 struct file *filp, loff_t *ppos,
913 size_t len, unsigned int flags)
914{
915 struct port *port = filp->private_data;
916 struct sg_list sgl;
917 ssize_t ret;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030918 struct port_buffer *buf;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900919 struct splice_desc sd = {
920 .total_len = len,
921 .flags = flags,
922 .pos = *ppos,
923 .u.data = &sgl,
924 };
925
Sjur Brændeland1b637042012-12-14 14:40:51 +1030926 /*
927 * Rproc_serial does not yet support splice. To support splice
928 * pipe_to_sg() must allocate dma-buffers and copy content from
929 * regular pages to dma pages. And alloc_buf and free_buf must
930 * support allocating and freeing such a list of dma-buffers.
931 */
932 if (is_rproc_serial(port->out_vq->vdev))
933 return -EINVAL;
934
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900935 ret = wait_port_writable(port, filp->f_flags & O_NONBLOCK);
936 if (ret < 0)
937 return ret;
938
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030939 buf = alloc_buf(port->out_vq, 0, pipe->nrbufs);
940 if (!buf)
941 return -ENOMEM;
942
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900943 sgl.n = 0;
944 sgl.len = 0;
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900945 sgl.size = pipe->nrbufs;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030946 sgl.sg = buf->sg;
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900947 sg_init_table(sgl.sg, sgl.size);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900948 ret = __splice_from_pipe(pipe, &sd, pipe_to_sg);
949 if (likely(ret > 0))
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030950 ret = __send_to_port(port, buf->sg, sgl.n, sgl.len, buf, true);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900951
Sjur Brændelandfe529532012-10-15 09:57:33 +0200952 if (unlikely(ret <= 0))
Sjur Brændeland1b637042012-12-14 14:40:51 +1030953 free_buf(buf, true);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900954 return ret;
955}
956
Amit Shah2030fa42009-12-21 21:49:30 +0530957static unsigned int port_fops_poll(struct file *filp, poll_table *wait)
958{
959 struct port *port;
960 unsigned int ret;
961
962 port = filp->private_data;
963 poll_wait(filp, &port->waitqueue, wait);
964
Amit Shah8529a502010-09-02 18:11:44 +0530965 if (!port->guest_connected) {
966 /* Port got unplugged */
967 return POLLHUP;
968 }
Amit Shah2030fa42009-12-21 21:49:30 +0530969 ret = 0;
Hans de Goede6df7aad2010-09-16 14:43:08 +0530970 if (!will_read_block(port))
Amit Shah2030fa42009-12-21 21:49:30 +0530971 ret |= POLLIN | POLLRDNORM;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600972 if (!will_write_block(port))
Amit Shah2030fa42009-12-21 21:49:30 +0530973 ret |= POLLOUT;
974 if (!port->host_connected)
975 ret |= POLLHUP;
976
977 return ret;
978}
979
Amit Shahb353a6b2010-09-02 18:38:29 +0530980static void remove_port(struct kref *kref);
981
Amit Shah2030fa42009-12-21 21:49:30 +0530982static int port_fops_release(struct inode *inode, struct file *filp)
983{
984 struct port *port;
985
986 port = filp->private_data;
987
988 /* Notify host of port being closed */
989 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
990
Amit Shah88f251a2009-12-21 22:15:30 +0530991 spin_lock_irq(&port->inbuf_lock);
Amit Shah3c7969c2009-11-26 11:25:38 +0530992 port->guest_connected = false;
993
Amit Shah88f251a2009-12-21 22:15:30 +0530994 discard_port_data(port);
995
996 spin_unlock_irq(&port->inbuf_lock);
997
Amit Shahcdfadfc2010-05-19 22:15:50 -0600998 spin_lock_irq(&port->outvq_lock);
999 reclaim_consumed_buffers(port);
1000 spin_unlock_irq(&port->outvq_lock);
1001
Sjur Brændeland1b637042012-12-14 14:40:51 +10301002 reclaim_dma_bufs();
Amit Shahb353a6b2010-09-02 18:38:29 +05301003 /*
1004 * Locks aren't necessary here as a port can't be opened after
1005 * unplug, and if a port isn't unplugged, a kref would already
1006 * exist for the port. Plus, taking ports_lock here would
1007 * create a dependency on other locks taken by functions
1008 * inside remove_port if we're the last holder of the port,
1009 * creating many problems.
1010 */
1011 kref_put(&port->kref, remove_port);
1012
Amit Shah2030fa42009-12-21 21:49:30 +05301013 return 0;
1014}
1015
1016static int port_fops_open(struct inode *inode, struct file *filp)
1017{
1018 struct cdev *cdev = inode->i_cdev;
1019 struct port *port;
Amit Shah8ad37e82010-09-02 18:11:48 +05301020 int ret;
Amit Shah2030fa42009-12-21 21:49:30 +05301021
Amit Shah04950cd2010-09-02 18:20:58 +05301022 port = find_port_by_devt(cdev->dev);
Amit Shah2030fa42009-12-21 21:49:30 +05301023 filp->private_data = port;
1024
Amit Shahb353a6b2010-09-02 18:38:29 +05301025 /* Prevent against a port getting hot-unplugged at the same time */
1026 spin_lock_irq(&port->portdev->ports_lock);
1027 kref_get(&port->kref);
1028 spin_unlock_irq(&port->portdev->ports_lock);
1029
Amit Shah2030fa42009-12-21 21:49:30 +05301030 /*
1031 * Don't allow opening of console port devices -- that's done
1032 * via /dev/hvc
1033 */
Amit Shah8ad37e82010-09-02 18:11:48 +05301034 if (is_console_port(port)) {
1035 ret = -ENXIO;
1036 goto out;
1037 }
Amit Shah2030fa42009-12-21 21:49:30 +05301038
Amit Shah3c7969c2009-11-26 11:25:38 +05301039 /* Allow only one process to open a particular port at a time */
1040 spin_lock_irq(&port->inbuf_lock);
1041 if (port->guest_connected) {
1042 spin_unlock_irq(&port->inbuf_lock);
Amit Shah8ad37e82010-09-02 18:11:48 +05301043 ret = -EMFILE;
1044 goto out;
Amit Shah3c7969c2009-11-26 11:25:38 +05301045 }
1046
1047 port->guest_connected = true;
1048 spin_unlock_irq(&port->inbuf_lock);
1049
Amit Shahcdfadfc2010-05-19 22:15:50 -06001050 spin_lock_irq(&port->outvq_lock);
1051 /*
1052 * There might be a chance that we missed reclaiming a few
1053 * buffers in the window of the port getting previously closed
1054 * and opening now.
1055 */
1056 reclaim_consumed_buffers(port);
1057 spin_unlock_irq(&port->outvq_lock);
1058
Amit Shah299fb612010-09-16 14:43:09 +05301059 nonseekable_open(inode, filp);
1060
Amit Shah2030fa42009-12-21 21:49:30 +05301061 /* Notify host of port being opened */
1062 send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1);
1063
1064 return 0;
Amit Shah8ad37e82010-09-02 18:11:48 +05301065out:
Amit Shahb353a6b2010-09-02 18:38:29 +05301066 kref_put(&port->kref, remove_port);
Amit Shah8ad37e82010-09-02 18:11:48 +05301067 return ret;
Amit Shah2030fa42009-12-21 21:49:30 +05301068}
1069
Amit Shah3eae0ad2010-09-02 18:47:52 +05301070static int port_fops_fasync(int fd, struct file *filp, int mode)
1071{
1072 struct port *port;
1073
1074 port = filp->private_data;
1075 return fasync_helper(fd, filp, mode, &port->async_queue);
1076}
1077
Amit Shah2030fa42009-12-21 21:49:30 +05301078/*
1079 * The file operations that we support: programs in the guest can open
1080 * a console device, read from it, write to it, poll for data and
1081 * close it. The devices are at
1082 * /dev/vport<device number>p<port number>
1083 */
1084static const struct file_operations port_fops = {
1085 .owner = THIS_MODULE,
1086 .open = port_fops_open,
1087 .read = port_fops_read,
1088 .write = port_fops_write,
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +09001089 .splice_write = port_fops_splice_write,
Amit Shah2030fa42009-12-21 21:49:30 +05301090 .poll = port_fops_poll,
1091 .release = port_fops_release,
Amit Shah3eae0ad2010-09-02 18:47:52 +05301092 .fasync = port_fops_fasync,
Amit Shah299fb612010-09-16 14:43:09 +05301093 .llseek = no_llseek,
Amit Shah2030fa42009-12-21 21:49:30 +05301094};
1095
Amit Shahe27b5192010-01-18 19:15:02 +05301096/*
Rusty Russella23ea922010-01-18 19:14:55 +05301097 * The put_chars() callback is pretty straightforward.
Rusty Russell31610432007-10-22 11:03:39 +10001098 *
Rusty Russella23ea922010-01-18 19:14:55 +05301099 * We turn the characters into a scatter-gather list, add it to the
1100 * output queue and then kick the Host. Then we sit here waiting for
1101 * it to finish: inefficient in theory, but in practice
1102 * implementations will do it immediately (lguest's Launcher does).
1103 */
Rusty Russell31610432007-10-22 11:03:39 +10001104static int put_chars(u32 vtermno, const char *buf, int count)
1105{
Rusty Russell21206ed2010-01-18 19:15:00 +05301106 struct port *port;
Sjur Brændeland276a3e92012-12-14 13:46:42 +10301107 struct scatterlist sg[1];
Amit Shah38edf582010-01-18 19:15:05 +05301108
François Diakhaté162a6892010-03-23 18:23:15 +05301109 if (unlikely(early_put_chars))
1110 return early_put_chars(vtermno, buf, count);
1111
Amit Shah38edf582010-01-18 19:15:05 +05301112 port = find_port_by_vtermno(vtermno);
1113 if (!port)
Amit Shah6dc69f972010-05-19 22:15:47 -06001114 return -EPIPE;
Rusty Russell31610432007-10-22 11:03:39 +10001115
Sjur Brændeland276a3e92012-12-14 13:46:42 +10301116 sg_init_one(sg, buf, count);
1117 return __send_to_port(port, sg, 1, count, (void *)buf, false);
Rusty Russell31610432007-10-22 11:03:39 +10001118}
1119
Rusty Russella23ea922010-01-18 19:14:55 +05301120/*
Rusty Russella23ea922010-01-18 19:14:55 +05301121 * get_chars() is the callback from the hvc_console infrastructure
1122 * when an interrupt is received.
Rusty Russell31610432007-10-22 11:03:39 +10001123 *
Amit Shah203baab2010-01-18 19:15:12 +05301124 * We call out to fill_readbuf that gets us the required data from the
1125 * buffers that are queued up.
Rusty Russella23ea922010-01-18 19:14:55 +05301126 */
Rusty Russell31610432007-10-22 11:03:39 +10001127static int get_chars(u32 vtermno, char *buf, int count)
1128{
Rusty Russell21206ed2010-01-18 19:15:00 +05301129 struct port *port;
Rusty Russell31610432007-10-22 11:03:39 +10001130
Amit Shah6dc69f972010-05-19 22:15:47 -06001131 /* If we've not set up the port yet, we have no input to give. */
1132 if (unlikely(early_put_chars))
1133 return 0;
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 Russell21206ed2010-01-18 19:15:00 +05301138
1139 /* If we don't have an input queue yet, we can't get input. */
1140 BUG_ON(!port->in_vq);
1141
Amit Shahb766cee2009-12-21 21:26:45 +05301142 return fill_readbuf(port, buf, count, false);
Rusty Russell31610432007-10-22 11:03:39 +10001143}
Rusty Russell31610432007-10-22 11:03:39 +10001144
Amit Shahcb06e362010-01-18 19:15:08 +05301145static void resize_console(struct port *port)
Christian Borntraegerc2983452008-11-25 13:36:26 +01001146{
Amit Shahcb06e362010-01-18 19:15:08 +05301147 struct virtio_device *vdev;
Christian Borntraegerc2983452008-11-25 13:36:26 +01001148
Amit Shah2de16a42010-03-19 17:36:44 +05301149 /* The port could have been hot-unplugged */
Amit Shah97788292010-05-06 02:05:08 +05301150 if (!port || !is_console_port(port))
Amit Shah2de16a42010-03-19 17:36:44 +05301151 return;
1152
Amit Shahcb06e362010-01-18 19:15:08 +05301153 vdev = port->portdev->vdev;
Sjur Brændeland1b637042012-12-14 14:40:51 +10301154
1155 /* Don't test F_SIZE at all if we're rproc: not a valid feature! */
1156 if (!is_rproc_serial(vdev) &&
1157 virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE))
Amit Shah97788292010-05-06 02:05:08 +05301158 hvc_resize(port->cons.hvc, port->cons.ws);
Christian Borntraegerc2983452008-11-25 13:36:26 +01001159}
1160
Amit Shah38edf582010-01-18 19:15:05 +05301161/* We set the configuration at this point, since we now have a tty */
Christian Borntraeger91fcad12008-06-20 15:24:15 +02001162static int notifier_add_vio(struct hvc_struct *hp, int data)
1163{
Amit Shah38edf582010-01-18 19:15:05 +05301164 struct port *port;
1165
1166 port = find_port_by_vtermno(hp->vtermno);
1167 if (!port)
1168 return -EINVAL;
1169
Christian Borntraeger91fcad12008-06-20 15:24:15 +02001170 hp->irq_requested = 1;
Amit Shahcb06e362010-01-18 19:15:08 +05301171 resize_console(port);
Christian Borntraegerc2983452008-11-25 13:36:26 +01001172
Christian Borntraeger91fcad12008-06-20 15:24:15 +02001173 return 0;
1174}
1175
1176static void notifier_del_vio(struct hvc_struct *hp, int data)
1177{
1178 hp->irq_requested = 0;
1179}
1180
Amit Shah17634ba2009-12-21 21:03:25 +05301181/* The operations for console ports. */
Rusty Russell1dff3992009-11-28 12:20:26 +05301182static const struct hv_ops hv_ops = {
Rusty Russell971f3392010-01-18 19:14:56 +05301183 .get_chars = get_chars,
1184 .put_chars = put_chars,
1185 .notifier_add = notifier_add_vio,
1186 .notifier_del = notifier_del_vio,
1187 .notifier_hangup = notifier_del_vio,
1188};
1189
1190/*
1191 * Console drivers are initialized very early so boot messages can go
1192 * out, so we do things slightly differently from the generic virtio
1193 * initialization of the net and block drivers.
1194 *
1195 * At this stage, the console is output-only. It's too early to set
1196 * up a virtqueue, so we let the drivers do some boutique early-output
1197 * thing.
1198 */
1199int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int))
1200{
1201 early_put_chars = put_chars;
1202 return hvc_instantiate(0, 0, &hv_ops);
1203}
1204
Amit Shah17634ba2009-12-21 21:03:25 +05301205int init_port_console(struct port *port)
Amit Shahcfa6d372010-01-18 19:15:10 +05301206{
1207 int ret;
1208
1209 /*
1210 * The Host's telling us this port is a console port. Hook it
1211 * up with an hvc console.
1212 *
1213 * To set up and manage our virtual console, we call
1214 * hvc_alloc().
1215 *
1216 * The first argument of hvc_alloc() is the virtual console
1217 * number. The second argument is the parameter for the
1218 * notification mechanism (like irq number). We currently
1219 * leave this as zero, virtqueues have implicit notifications.
1220 *
1221 * The third argument is a "struct hv_ops" containing the
1222 * put_chars() get_chars(), notifier_add() and notifier_del()
1223 * pointers. The final argument is the output buffer size: we
1224 * can do any size, so we put PAGE_SIZE here.
1225 */
1226 port->cons.vtermno = pdrvdata.next_vtermno;
1227
1228 port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE);
1229 if (IS_ERR(port->cons.hvc)) {
1230 ret = PTR_ERR(port->cons.hvc);
Amit Shah298add72010-01-18 16:35:23 +05301231 dev_err(port->dev,
1232 "error %d allocating hvc for port\n", ret);
Amit Shahcfa6d372010-01-18 19:15:10 +05301233 port->cons.hvc = NULL;
1234 return ret;
1235 }
1236 spin_lock_irq(&pdrvdata_lock);
1237 pdrvdata.next_vtermno++;
1238 list_add_tail(&port->cons.list, &pdrvdata.consoles);
1239 spin_unlock_irq(&pdrvdata_lock);
Amit Shah3c7969c2009-11-26 11:25:38 +05301240 port->guest_connected = true;
Amit Shahcfa6d372010-01-18 19:15:10 +05301241
Amit Shah1d051602010-05-19 22:15:49 -06001242 /*
1243 * Start using the new console output if this is the first
1244 * console to come up.
1245 */
1246 if (early_put_chars)
1247 early_put_chars = NULL;
1248
Amit Shah2030fa42009-12-21 21:49:30 +05301249 /* Notify host of port being opened */
1250 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
1251
Amit Shahcfa6d372010-01-18 19:15:10 +05301252 return 0;
1253}
1254
Amit Shah431edb82009-12-21 21:57:40 +05301255static ssize_t show_port_name(struct device *dev,
1256 struct device_attribute *attr, char *buffer)
1257{
1258 struct port *port;
1259
1260 port = dev_get_drvdata(dev);
1261
1262 return sprintf(buffer, "%s\n", port->name);
1263}
1264
1265static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL);
1266
1267static struct attribute *port_sysfs_entries[] = {
1268 &dev_attr_name.attr,
1269 NULL
1270};
1271
1272static struct attribute_group port_attribute_group = {
1273 .name = NULL, /* put in device directory */
1274 .attrs = port_sysfs_entries,
1275};
1276
Amit Shahd99393e2009-12-21 22:36:21 +05301277static ssize_t debugfs_read(struct file *filp, char __user *ubuf,
1278 size_t count, loff_t *offp)
1279{
1280 struct port *port;
1281 char *buf;
1282 ssize_t ret, out_offset, out_count;
1283
1284 out_count = 1024;
1285 buf = kmalloc(out_count, GFP_KERNEL);
1286 if (!buf)
1287 return -ENOMEM;
1288
1289 port = filp->private_data;
1290 out_offset = 0;
1291 out_offset += snprintf(buf + out_offset, out_count,
1292 "name: %s\n", port->name ? port->name : "");
1293 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1294 "guest_connected: %d\n", port->guest_connected);
1295 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1296 "host_connected: %d\n", port->host_connected);
1297 out_offset += snprintf(buf + out_offset, out_count - out_offset,
Amit Shahcdfadfc2010-05-19 22:15:50 -06001298 "outvq_full: %d\n", port->outvq_full);
1299 out_offset += snprintf(buf + out_offset, out_count - out_offset,
Amit Shah17e5b4f2011-09-14 13:06:46 +05301300 "bytes_sent: %lu\n", port->stats.bytes_sent);
1301 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1302 "bytes_received: %lu\n",
1303 port->stats.bytes_received);
1304 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1305 "bytes_discarded: %lu\n",
1306 port->stats.bytes_discarded);
1307 out_offset += snprintf(buf + out_offset, out_count - out_offset,
Amit Shahd99393e2009-12-21 22:36:21 +05301308 "is_console: %s\n",
1309 is_console_port(port) ? "yes" : "no");
1310 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1311 "console_vtermno: %u\n", port->cons.vtermno);
1312
1313 ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset);
1314 kfree(buf);
1315 return ret;
1316}
1317
1318static const struct file_operations port_debugfs_ops = {
1319 .owner = THIS_MODULE,
Stephen Boyd234e3402012-04-05 14:25:11 -07001320 .open = simple_open,
Amit Shahd99393e2009-12-21 22:36:21 +05301321 .read = debugfs_read,
1322};
1323
Amit Shah97788292010-05-06 02:05:08 +05301324static void set_console_size(struct port *port, u16 rows, u16 cols)
1325{
1326 if (!port || !is_console_port(port))
1327 return;
1328
1329 port->cons.ws.ws_row = rows;
1330 port->cons.ws.ws_col = cols;
1331}
1332
Amit Shahc446f8f2010-05-19 22:15:48 -06001333static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock)
1334{
1335 struct port_buffer *buf;
1336 unsigned int nr_added_bufs;
1337 int ret;
1338
1339 nr_added_bufs = 0;
1340 do {
Sjur Brændeland276a3e92012-12-14 13:46:42 +10301341 buf = alloc_buf(vq, PAGE_SIZE, 0);
Amit Shahc446f8f2010-05-19 22:15:48 -06001342 if (!buf)
1343 break;
1344
1345 spin_lock_irq(lock);
1346 ret = add_inbuf(vq, buf);
1347 if (ret < 0) {
1348 spin_unlock_irq(lock);
Sjur Brændeland1b637042012-12-14 14:40:51 +10301349 free_buf(buf, true);
Amit Shahc446f8f2010-05-19 22:15:48 -06001350 break;
1351 }
1352 nr_added_bufs++;
1353 spin_unlock_irq(lock);
1354 } while (ret > 0);
1355
1356 return nr_added_bufs;
1357}
1358
Amit Shah3eae0ad2010-09-02 18:47:52 +05301359static void send_sigio_to_port(struct port *port)
1360{
1361 if (port->async_queue && port->guest_connected)
1362 kill_fasync(&port->async_queue, SIGIO, POLL_OUT);
1363}
1364
Amit Shahc446f8f2010-05-19 22:15:48 -06001365static int add_port(struct ports_device *portdev, u32 id)
1366{
1367 char debugfs_name[16];
1368 struct port *port;
1369 struct port_buffer *buf;
1370 dev_t devt;
1371 unsigned int nr_added_bufs;
1372 int err;
1373
1374 port = kmalloc(sizeof(*port), GFP_KERNEL);
1375 if (!port) {
1376 err = -ENOMEM;
1377 goto fail;
1378 }
Amit Shahb353a6b2010-09-02 18:38:29 +05301379 kref_init(&port->kref);
Amit Shahc446f8f2010-05-19 22:15:48 -06001380
1381 port->portdev = portdev;
1382 port->id = id;
1383
1384 port->name = NULL;
1385 port->inbuf = NULL;
1386 port->cons.hvc = NULL;
Amit Shah3eae0ad2010-09-02 18:47:52 +05301387 port->async_queue = NULL;
Amit Shahc446f8f2010-05-19 22:15:48 -06001388
Amit Shah97788292010-05-06 02:05:08 +05301389 port->cons.ws.ws_row = port->cons.ws.ws_col = 0;
1390
Amit Shahc446f8f2010-05-19 22:15:48 -06001391 port->host_connected = port->guest_connected = false;
Amit Shah17e5b4f2011-09-14 13:06:46 +05301392 port->stats = (struct port_stats) { 0 };
Amit Shahc446f8f2010-05-19 22:15:48 -06001393
Amit Shahcdfadfc2010-05-19 22:15:50 -06001394 port->outvq_full = false;
1395
Amit Shahc446f8f2010-05-19 22:15:48 -06001396 port->in_vq = portdev->in_vqs[port->id];
1397 port->out_vq = portdev->out_vqs[port->id];
1398
Amit Shahd22a6982010-09-02 18:20:59 +05301399 port->cdev = cdev_alloc();
1400 if (!port->cdev) {
1401 dev_err(&port->portdev->vdev->dev, "Error allocating cdev\n");
1402 err = -ENOMEM;
1403 goto free_port;
1404 }
1405 port->cdev->ops = &port_fops;
Amit Shahc446f8f2010-05-19 22:15:48 -06001406
1407 devt = MKDEV(portdev->chr_major, id);
Amit Shahd22a6982010-09-02 18:20:59 +05301408 err = cdev_add(port->cdev, devt, 1);
Amit Shahc446f8f2010-05-19 22:15:48 -06001409 if (err < 0) {
1410 dev_err(&port->portdev->vdev->dev,
1411 "Error %d adding cdev for port %u\n", err, id);
Amit Shahd22a6982010-09-02 18:20:59 +05301412 goto free_cdev;
Amit Shahc446f8f2010-05-19 22:15:48 -06001413 }
1414 port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev,
1415 devt, port, "vport%up%u",
Sjur Brændelanddc18f082013-02-12 16:24:59 +10301416 port->portdev->vdev->index, id);
Amit Shahc446f8f2010-05-19 22:15:48 -06001417 if (IS_ERR(port->dev)) {
1418 err = PTR_ERR(port->dev);
1419 dev_err(&port->portdev->vdev->dev,
1420 "Error %d creating device for port %u\n",
1421 err, id);
1422 goto free_cdev;
1423 }
1424
1425 spin_lock_init(&port->inbuf_lock);
Amit Shahcdfadfc2010-05-19 22:15:50 -06001426 spin_lock_init(&port->outvq_lock);
Amit Shahc446f8f2010-05-19 22:15:48 -06001427 init_waitqueue_head(&port->waitqueue);
1428
1429 /* Fill the in_vq with buffers so the host can send us data. */
1430 nr_added_bufs = fill_queue(port->in_vq, &port->inbuf_lock);
1431 if (!nr_added_bufs) {
1432 dev_err(port->dev, "Error allocating inbufs\n");
1433 err = -ENOMEM;
1434 goto free_device;
1435 }
1436
Sjur Brændeland1b637042012-12-14 14:40:51 +10301437 if (is_rproc_serial(port->portdev->vdev))
1438 /*
1439 * For rproc_serial assume remote processor is connected.
1440 * rproc_serial does not want the console port, only
1441 * the generic port implementation.
1442 */
Sjur Brændelandaabd6a82013-03-18 19:19:14 +10301443 port->host_connected = true;
Sjur Brændeland1b637042012-12-14 14:40:51 +10301444 else if (!use_multiport(port->portdev)) {
1445 /*
1446 * If we're not using multiport support,
1447 * this has to be a console port.
1448 */
Amit Shahc446f8f2010-05-19 22:15:48 -06001449 err = init_port_console(port);
1450 if (err)
1451 goto free_inbufs;
1452 }
1453
1454 spin_lock_irq(&portdev->ports_lock);
1455 list_add_tail(&port->list, &port->portdev->ports);
1456 spin_unlock_irq(&portdev->ports_lock);
1457
1458 /*
1459 * Tell the Host we're set so that it can send us various
1460 * configuration parameters for this port (eg, port name,
1461 * caching, whether this is a console port, etc.)
1462 */
1463 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1464
1465 if (pdrvdata.debugfs_dir) {
1466 /*
1467 * Finally, create the debugfs file that we can use to
1468 * inspect a port's state at any time
1469 */
1470 sprintf(debugfs_name, "vport%up%u",
Sjur Brændelanddc18f082013-02-12 16:24:59 +10301471 port->portdev->vdev->index, id);
Amit Shahc446f8f2010-05-19 22:15:48 -06001472 port->debugfs_file = debugfs_create_file(debugfs_name, 0444,
1473 pdrvdata.debugfs_dir,
1474 port,
1475 &port_debugfs_ops);
1476 }
1477 return 0;
1478
1479free_inbufs:
1480 while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301481 free_buf(buf, true);
Amit Shahc446f8f2010-05-19 22:15:48 -06001482free_device:
1483 device_destroy(pdrvdata.class, port->dev->devt);
1484free_cdev:
Amit Shahd22a6982010-09-02 18:20:59 +05301485 cdev_del(port->cdev);
Amit Shahc446f8f2010-05-19 22:15:48 -06001486free_port:
1487 kfree(port);
1488fail:
1489 /* The host might want to notify management sw about port add failure */
Julia Lawall0643e4c2010-05-15 11:45:53 +02001490 __send_control_msg(portdev, id, VIRTIO_CONSOLE_PORT_READY, 0);
Amit Shahc446f8f2010-05-19 22:15:48 -06001491 return err;
1492}
1493
Amit Shahb353a6b2010-09-02 18:38:29 +05301494/* No users remain, remove all port-specific data. */
1495static void remove_port(struct kref *kref)
1496{
1497 struct port *port;
1498
1499 port = container_of(kref, struct port, kref);
1500
1501 sysfs_remove_group(&port->dev->kobj, &port_attribute_group);
1502 device_destroy(pdrvdata.class, port->dev->devt);
1503 cdev_del(port->cdev);
1504
1505 kfree(port->name);
1506
1507 debugfs_remove(port->debugfs_file);
1508
1509 kfree(port);
1510}
1511
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301512static void remove_port_data(struct port *port)
1513{
1514 struct port_buffer *buf;
1515
1516 /* Remove unused data this port might have received. */
1517 discard_port_data(port);
1518
1519 reclaim_consumed_buffers(port);
1520
1521 /* Remove buffers we queued up for the Host to send us data in. */
1522 while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301523 free_buf(buf, true);
sjur.brandeland@stericsson.comeb34f122012-11-16 11:20:19 +10301524
1525 /* Free pending buffers from the out-queue. */
1526 while ((buf = virtqueue_detach_unused_buf(port->out_vq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301527 free_buf(buf, true);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301528}
1529
Amit Shahb353a6b2010-09-02 18:38:29 +05301530/*
1531 * Port got unplugged. Remove port from portdev's list and drop the
1532 * kref reference. If no userspace has this port opened, it will
1533 * result in immediate removal the port.
1534 */
1535static void unplug_port(struct port *port)
Amit Shah1f7aa422009-12-21 22:27:31 +05301536{
Amit Shahb353a6b2010-09-02 18:38:29 +05301537 spin_lock_irq(&port->portdev->ports_lock);
1538 list_del(&port->list);
1539 spin_unlock_irq(&port->portdev->ports_lock);
1540
Amit Shah00476342010-05-27 13:24:39 +05301541 if (port->guest_connected) {
1542 port->guest_connected = false;
1543 port->host_connected = false;
1544 wake_up_interruptible(&port->waitqueue);
Amit Shaha461e112010-09-02 18:47:54 +05301545
1546 /* Let the app know the port is going down. */
1547 send_sigio_to_port(port);
Amit Shah00476342010-05-27 13:24:39 +05301548 }
1549
Amit Shah1f7aa422009-12-21 22:27:31 +05301550 if (is_console_port(port)) {
1551 spin_lock_irq(&pdrvdata_lock);
1552 list_del(&port->cons.list);
1553 spin_unlock_irq(&pdrvdata_lock);
1554 hvc_remove(port->cons.hvc);
1555 }
Amit Shah1f7aa422009-12-21 22:27:31 +05301556
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301557 remove_port_data(port);
Amit Shaha9cdd482010-02-12 10:32:15 +05301558
Amit Shahb353a6b2010-09-02 18:38:29 +05301559 /*
1560 * We should just assume the device itself has gone off --
1561 * else a close on an open port later will try to send out a
1562 * control message.
1563 */
1564 port->portdev = NULL;
Amit Shah1f7aa422009-12-21 22:27:31 +05301565
Amit Shahb353a6b2010-09-02 18:38:29 +05301566 /*
1567 * Locks around here are not necessary - a port can't be
1568 * opened after we removed the port struct from ports_list
1569 * above.
1570 */
1571 kref_put(&port->kref, remove_port);
Amit Shah1f7aa422009-12-21 22:27:31 +05301572}
1573
Amit Shah17634ba2009-12-21 21:03:25 +05301574/* Any private messages that the Host and Guest want to share */
1575static void handle_control_message(struct ports_device *portdev,
1576 struct port_buffer *buf)
1577{
1578 struct virtio_console_control *cpkt;
1579 struct port *port;
Amit Shah431edb82009-12-21 21:57:40 +05301580 size_t name_size;
1581 int err;
Amit Shah17634ba2009-12-21 21:03:25 +05301582
1583 cpkt = (struct virtio_console_control *)(buf->buf + buf->offset);
1584
1585 port = find_port_by_id(portdev, cpkt->id);
Amit Shahf909f852010-05-19 22:15:48 -06001586 if (!port && cpkt->event != VIRTIO_CONSOLE_PORT_ADD) {
Amit Shah17634ba2009-12-21 21:03:25 +05301587 /* No valid header at start of buffer. Drop it. */
1588 dev_dbg(&portdev->vdev->dev,
1589 "Invalid index %u in control packet\n", cpkt->id);
1590 return;
1591 }
1592
1593 switch (cpkt->event) {
Amit Shahf909f852010-05-19 22:15:48 -06001594 case VIRTIO_CONSOLE_PORT_ADD:
1595 if (port) {
Amit Shah1d051602010-05-19 22:15:49 -06001596 dev_dbg(&portdev->vdev->dev,
1597 "Port %u already added\n", port->id);
Amit Shahf909f852010-05-19 22:15:48 -06001598 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1599 break;
1600 }
1601 if (cpkt->id >= portdev->config.max_nr_ports) {
1602 dev_warn(&portdev->vdev->dev,
1603 "Request for adding port with out-of-bound id %u, max. supported id: %u\n",
1604 cpkt->id, portdev->config.max_nr_ports - 1);
1605 break;
1606 }
1607 add_port(portdev, cpkt->id);
1608 break;
1609 case VIRTIO_CONSOLE_PORT_REMOVE:
Amit Shahb353a6b2010-09-02 18:38:29 +05301610 unplug_port(port);
Amit Shahf909f852010-05-19 22:15:48 -06001611 break;
Amit Shah17634ba2009-12-21 21:03:25 +05301612 case VIRTIO_CONSOLE_CONSOLE_PORT:
1613 if (!cpkt->value)
1614 break;
1615 if (is_console_port(port))
1616 break;
1617
1618 init_port_console(port);
Christian Borntraeger5e384832011-09-22 23:44:23 +05301619 complete(&early_console_added);
Amit Shah17634ba2009-12-21 21:03:25 +05301620 /*
1621 * Could remove the port here in case init fails - but
1622 * have to notify the host first.
1623 */
1624 break;
Amit Shah8345adb2010-05-06 02:05:09 +05301625 case VIRTIO_CONSOLE_RESIZE: {
1626 struct {
1627 __u16 rows;
1628 __u16 cols;
1629 } size;
1630
Amit Shah17634ba2009-12-21 21:03:25 +05301631 if (!is_console_port(port))
1632 break;
Amit Shah8345adb2010-05-06 02:05:09 +05301633
1634 memcpy(&size, buf->buf + buf->offset + sizeof(*cpkt),
1635 sizeof(size));
1636 set_console_size(port, size.rows, size.cols);
1637
Amit Shah17634ba2009-12-21 21:03:25 +05301638 port->cons.hvc->irq_requested = 1;
1639 resize_console(port);
1640 break;
Amit Shah8345adb2010-05-06 02:05:09 +05301641 }
Amit Shah2030fa42009-12-21 21:49:30 +05301642 case VIRTIO_CONSOLE_PORT_OPEN:
1643 port->host_connected = cpkt->value;
1644 wake_up_interruptible(&port->waitqueue);
Amit Shahcdfadfc2010-05-19 22:15:50 -06001645 /*
1646 * If the host port got closed and the host had any
1647 * unconsumed buffers, we'll be able to reclaim them
1648 * now.
1649 */
1650 spin_lock_irq(&port->outvq_lock);
1651 reclaim_consumed_buffers(port);
1652 spin_unlock_irq(&port->outvq_lock);
Amit Shah3eae0ad2010-09-02 18:47:52 +05301653
1654 /*
1655 * If the guest is connected, it'll be interested in
1656 * knowing the host connection state changed.
1657 */
1658 send_sigio_to_port(port);
Amit Shah2030fa42009-12-21 21:49:30 +05301659 break;
Amit Shah431edb82009-12-21 21:57:40 +05301660 case VIRTIO_CONSOLE_PORT_NAME:
1661 /*
Amit Shah291024e2011-09-14 13:06:40 +05301662 * If we woke up after hibernation, we can get this
1663 * again. Skip it in that case.
1664 */
1665 if (port->name)
1666 break;
1667
1668 /*
Amit Shah431edb82009-12-21 21:57:40 +05301669 * Skip the size of the header and the cpkt to get the size
1670 * of the name that was sent
1671 */
1672 name_size = buf->len - buf->offset - sizeof(*cpkt) + 1;
1673
1674 port->name = kmalloc(name_size, GFP_KERNEL);
1675 if (!port->name) {
1676 dev_err(port->dev,
1677 "Not enough space to store port name\n");
1678 break;
1679 }
1680 strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt),
1681 name_size - 1);
1682 port->name[name_size - 1] = 0;
1683
1684 /*
1685 * Since we only have one sysfs attribute, 'name',
1686 * create it only if we have a name for the port.
1687 */
1688 err = sysfs_create_group(&port->dev->kobj,
1689 &port_attribute_group);
Amit Shahec642132010-03-19 17:36:43 +05301690 if (err) {
Amit Shah431edb82009-12-21 21:57:40 +05301691 dev_err(port->dev,
1692 "Error %d creating sysfs device attributes\n",
1693 err);
Amit Shahec642132010-03-19 17:36:43 +05301694 } else {
1695 /*
1696 * Generate a udev event so that appropriate
1697 * symlinks can be created based on udev
1698 * rules.
1699 */
1700 kobject_uevent(&port->dev->kobj, KOBJ_CHANGE);
1701 }
Amit Shah431edb82009-12-21 21:57:40 +05301702 break;
Amit Shah17634ba2009-12-21 21:03:25 +05301703 }
1704}
1705
1706static void control_work_handler(struct work_struct *work)
1707{
1708 struct ports_device *portdev;
1709 struct virtqueue *vq;
1710 struct port_buffer *buf;
1711 unsigned int len;
1712
1713 portdev = container_of(work, struct ports_device, control_work);
1714 vq = portdev->c_ivq;
1715
Amit Shah165b1b82013-03-29 16:30:07 +05301716 spin_lock(&portdev->c_ivq_lock);
Michael S. Tsirkin505b0452010-04-12 16:18:32 +03001717 while ((buf = virtqueue_get_buf(vq, &len))) {
Amit Shah165b1b82013-03-29 16:30:07 +05301718 spin_unlock(&portdev->c_ivq_lock);
Amit Shah17634ba2009-12-21 21:03:25 +05301719
1720 buf->len = len;
1721 buf->offset = 0;
1722
1723 handle_control_message(portdev, buf);
1724
Amit Shah165b1b82013-03-29 16:30:07 +05301725 spin_lock(&portdev->c_ivq_lock);
Amit Shah17634ba2009-12-21 21:03:25 +05301726 if (add_inbuf(portdev->c_ivq, buf) < 0) {
1727 dev_warn(&portdev->vdev->dev,
1728 "Error adding buffer to queue\n");
Sjur Brændeland1b637042012-12-14 14:40:51 +10301729 free_buf(buf, false);
Amit Shah17634ba2009-12-21 21:03:25 +05301730 }
1731 }
Amit Shah165b1b82013-03-29 16:30:07 +05301732 spin_unlock(&portdev->c_ivq_lock);
Amit Shah17634ba2009-12-21 21:03:25 +05301733}
1734
Amit Shah2770c5e2011-01-31 13:06:36 +05301735static void out_intr(struct virtqueue *vq)
1736{
1737 struct port *port;
1738
1739 port = find_port_by_vq(vq->vdev->priv, vq);
1740 if (!port)
1741 return;
1742
1743 wake_up_interruptible(&port->waitqueue);
1744}
1745
Amit Shah17634ba2009-12-21 21:03:25 +05301746static void in_intr(struct virtqueue *vq)
1747{
1748 struct port *port;
1749 unsigned long flags;
1750
1751 port = find_port_by_vq(vq->vdev->priv, vq);
1752 if (!port)
1753 return;
1754
1755 spin_lock_irqsave(&port->inbuf_lock, flags);
Amit Shahd25a9dd2011-09-14 13:06:43 +05301756 port->inbuf = get_inbuf(port);
Amit Shah17634ba2009-12-21 21:03:25 +05301757
Amit Shah88f251a2009-12-21 22:15:30 +05301758 /*
Sjur Brændelandaabd6a82013-03-18 19:19:14 +10301759 * Normally the port should not accept data when the port is
1760 * closed. For generic serial ports, the host won't (shouldn't)
1761 * send data till the guest is connected. But this condition
Amit Shah88f251a2009-12-21 22:15:30 +05301762 * can be reached when a console port is not yet connected (no
Sjur Brændelandaabd6a82013-03-18 19:19:14 +10301763 * tty is spawned) and the other side sends out data over the
1764 * vring, or when a remote devices start sending data before
1765 * the ports are opened.
1766 *
1767 * A generic serial port will discard data if not connected,
1768 * while console ports and rproc-serial ports accepts data at
1769 * any time. rproc-serial is initiated with guest_connected to
1770 * false because port_fops_open expects this. Console ports are
1771 * hooked up with an HVC console and is initialized with
1772 * guest_connected to true.
Amit Shah88f251a2009-12-21 22:15:30 +05301773 */
Sjur Brændelandaabd6a82013-03-18 19:19:14 +10301774
1775 if (!port->guest_connected && !is_rproc_serial(port->portdev->vdev))
Amit Shah88f251a2009-12-21 22:15:30 +05301776 discard_port_data(port);
1777
Amit Shah17634ba2009-12-21 21:03:25 +05301778 spin_unlock_irqrestore(&port->inbuf_lock, flags);
1779
Amit Shah2030fa42009-12-21 21:49:30 +05301780 wake_up_interruptible(&port->waitqueue);
1781
Amit Shah55f6bcc2010-09-02 18:47:53 +05301782 /* Send a SIGIO indicating new data in case the process asked for it */
1783 send_sigio_to_port(port);
1784
Amit Shah17634ba2009-12-21 21:03:25 +05301785 if (is_console_port(port) && hvc_poll(port->cons.hvc))
1786 hvc_kick();
1787}
1788
1789static void control_intr(struct virtqueue *vq)
1790{
1791 struct ports_device *portdev;
1792
1793 portdev = vq->vdev->priv;
1794 schedule_work(&portdev->control_work);
1795}
1796
Amit Shah7f5d8102009-12-21 22:22:08 +05301797static void config_intr(struct virtio_device *vdev)
1798{
1799 struct ports_device *portdev;
1800
1801 portdev = vdev->priv;
Amit Shah99f905f2010-05-19 22:15:48 -06001802
Amit Shah4038f5b72010-05-06 02:05:07 +05301803 if (!use_multiport(portdev)) {
Amit Shah97788292010-05-06 02:05:08 +05301804 struct port *port;
1805 u16 rows, cols;
1806
1807 vdev->config->get(vdev,
1808 offsetof(struct virtio_console_config, cols),
1809 &cols, sizeof(u16));
1810 vdev->config->get(vdev,
1811 offsetof(struct virtio_console_config, rows),
1812 &rows, sizeof(u16));
1813
1814 port = find_port_by_id(portdev, 0);
1815 set_console_size(port, rows, cols);
1816
Amit Shah4038f5b72010-05-06 02:05:07 +05301817 /*
1818 * We'll use this way of resizing only for legacy
1819 * support. For newer userspace
1820 * (VIRTIO_CONSOLE_F_MULTPORT+), use control messages
1821 * to indicate console size changes so that it can be
1822 * done per-port.
1823 */
Amit Shah97788292010-05-06 02:05:08 +05301824 resize_console(port);
Amit Shah4038f5b72010-05-06 02:05:07 +05301825 }
Amit Shah7f5d8102009-12-21 22:22:08 +05301826}
1827
Amit Shah2658a79a2010-01-18 19:15:11 +05301828static int init_vqs(struct ports_device *portdev)
1829{
1830 vq_callback_t **io_callbacks;
1831 char **io_names;
1832 struct virtqueue **vqs;
Amit Shah17634ba2009-12-21 21:03:25 +05301833 u32 i, j, nr_ports, nr_queues;
Amit Shah2658a79a2010-01-18 19:15:11 +05301834 int err;
1835
Amit Shah17634ba2009-12-21 21:03:25 +05301836 nr_ports = portdev->config.max_nr_ports;
1837 nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2;
Amit Shah2658a79a2010-01-18 19:15:11 +05301838
1839 vqs = kmalloc(nr_queues * sizeof(struct virtqueue *), GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301840 io_callbacks = kmalloc(nr_queues * sizeof(vq_callback_t *), GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301841 io_names = kmalloc(nr_queues * sizeof(char *), GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301842 portdev->in_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
1843 GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301844 portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
1845 GFP_KERNEL);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001846 if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs ||
Amit Shah286f9a22011-09-14 13:06:39 +05301847 !portdev->out_vqs) {
Amit Shah2658a79a2010-01-18 19:15:11 +05301848 err = -ENOMEM;
Jiri Slaby22e132f2010-11-06 10:06:50 +01001849 goto free;
Amit Shah2658a79a2010-01-18 19:15:11 +05301850 }
1851
Amit Shah17634ba2009-12-21 21:03:25 +05301852 /*
1853 * For backward compat (newer host but older guest), the host
1854 * spawns a console port first and also inits the vqs for port
1855 * 0 before others.
1856 */
1857 j = 0;
1858 io_callbacks[j] = in_intr;
Amit Shah2770c5e2011-01-31 13:06:36 +05301859 io_callbacks[j + 1] = out_intr;
Amit Shah17634ba2009-12-21 21:03:25 +05301860 io_names[j] = "input";
1861 io_names[j + 1] = "output";
1862 j += 2;
Amit Shah2658a79a2010-01-18 19:15:11 +05301863
Amit Shah17634ba2009-12-21 21:03:25 +05301864 if (use_multiport(portdev)) {
1865 io_callbacks[j] = control_intr;
1866 io_callbacks[j + 1] = NULL;
1867 io_names[j] = "control-i";
1868 io_names[j + 1] = "control-o";
1869
1870 for (i = 1; i < nr_ports; i++) {
1871 j += 2;
1872 io_callbacks[j] = in_intr;
Amit Shah2770c5e2011-01-31 13:06:36 +05301873 io_callbacks[j + 1] = out_intr;
Amit Shah17634ba2009-12-21 21:03:25 +05301874 io_names[j] = "input";
1875 io_names[j + 1] = "output";
1876 }
1877 }
Amit Shah2658a79a2010-01-18 19:15:11 +05301878 /* Find the queues. */
1879 err = portdev->vdev->config->find_vqs(portdev->vdev, nr_queues, vqs,
1880 io_callbacks,
1881 (const char **)io_names);
1882 if (err)
Jiri Slaby22e132f2010-11-06 10:06:50 +01001883 goto free;
Amit Shah2658a79a2010-01-18 19:15:11 +05301884
Amit Shah17634ba2009-12-21 21:03:25 +05301885 j = 0;
Amit Shah2658a79a2010-01-18 19:15:11 +05301886 portdev->in_vqs[0] = vqs[0];
1887 portdev->out_vqs[0] = vqs[1];
Amit Shah17634ba2009-12-21 21:03:25 +05301888 j += 2;
1889 if (use_multiport(portdev)) {
1890 portdev->c_ivq = vqs[j];
1891 portdev->c_ovq = vqs[j + 1];
Amit Shah2658a79a2010-01-18 19:15:11 +05301892
Amit Shah17634ba2009-12-21 21:03:25 +05301893 for (i = 1; i < nr_ports; i++) {
1894 j += 2;
1895 portdev->in_vqs[i] = vqs[j];
1896 portdev->out_vqs[i] = vqs[j + 1];
1897 }
1898 }
Amit Shah2658a79a2010-01-18 19:15:11 +05301899 kfree(io_names);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001900 kfree(io_callbacks);
Amit Shah2658a79a2010-01-18 19:15:11 +05301901 kfree(vqs);
1902
1903 return 0;
1904
Jiri Slaby22e132f2010-11-06 10:06:50 +01001905free:
Amit Shah2658a79a2010-01-18 19:15:11 +05301906 kfree(portdev->out_vqs);
Amit Shah2658a79a2010-01-18 19:15:11 +05301907 kfree(portdev->in_vqs);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001908 kfree(io_names);
1909 kfree(io_callbacks);
Amit Shah2658a79a2010-01-18 19:15:11 +05301910 kfree(vqs);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001911
Amit Shah2658a79a2010-01-18 19:15:11 +05301912 return err;
1913}
1914
Amit Shahfb08bd22009-12-21 21:36:04 +05301915static const struct file_operations portdev_fops = {
1916 .owner = THIS_MODULE,
1917};
1918
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301919static void remove_vqs(struct ports_device *portdev)
1920{
1921 portdev->vdev->config->del_vqs(portdev->vdev);
1922 kfree(portdev->in_vqs);
1923 kfree(portdev->out_vqs);
1924}
1925
1926static void remove_controlq_data(struct ports_device *portdev)
1927{
1928 struct port_buffer *buf;
1929 unsigned int len;
1930
1931 if (!use_multiport(portdev))
1932 return;
1933
1934 while ((buf = virtqueue_get_buf(portdev->c_ivq, &len)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301935 free_buf(buf, true);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301936
1937 while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301938 free_buf(buf, true);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301939}
1940
Amit Shah1c85bf32010-01-18 19:15:07 +05301941/*
1942 * Once we're further in boot, we get probed like any other virtio
1943 * device.
Amit Shah17634ba2009-12-21 21:03:25 +05301944 *
1945 * If the host also supports multiple console ports, we check the
1946 * config space to see how many ports the host has spawned. We
1947 * initialize each port found.
Amit Shah1c85bf32010-01-18 19:15:07 +05301948 */
Bill Pemberton2223cbe2012-11-19 13:22:51 -05001949static int virtcons_probe(struct virtio_device *vdev)
Amit Shah1c85bf32010-01-18 19:15:07 +05301950{
Amit Shah1c85bf32010-01-18 19:15:07 +05301951 struct ports_device *portdev;
1952 int err;
Amit Shah17634ba2009-12-21 21:03:25 +05301953 bool multiport;
Christian Borntraeger5e384832011-09-22 23:44:23 +05301954 bool early = early_put_chars != NULL;
1955
1956 /* Ensure to read early_put_chars now */
1957 barrier();
Amit Shah1c85bf32010-01-18 19:15:07 +05301958
1959 portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
1960 if (!portdev) {
1961 err = -ENOMEM;
1962 goto fail;
1963 }
1964
1965 /* Attach this portdev to this virtio_device, and vice-versa. */
1966 portdev->vdev = vdev;
1967 vdev->priv = portdev;
1968
Amit Shahfb08bd22009-12-21 21:36:04 +05301969 portdev->chr_major = register_chrdev(0, "virtio-portsdev",
1970 &portdev_fops);
1971 if (portdev->chr_major < 0) {
1972 dev_err(&vdev->dev,
1973 "Error %d registering chrdev for device %u\n",
Sjur Brændelanddc18f082013-02-12 16:24:59 +10301974 portdev->chr_major, vdev->index);
Amit Shahfb08bd22009-12-21 21:36:04 +05301975 err = portdev->chr_major;
1976 goto free;
1977 }
1978
Amit Shah17634ba2009-12-21 21:03:25 +05301979 multiport = false;
Amit Shah17634ba2009-12-21 21:03:25 +05301980 portdev->config.max_nr_ports = 1;
Sjur Brændeland1b637042012-12-14 14:40:51 +10301981
1982 /* Don't test MULTIPORT at all if we're rproc: not a valid feature! */
1983 if (!is_rproc_serial(vdev) &&
1984 virtio_config_val(vdev, VIRTIO_CONSOLE_F_MULTIPORT,
1985 offsetof(struct virtio_console_config,
1986 max_nr_ports),
1987 &portdev->config.max_nr_ports) == 0) {
Amit Shah17634ba2009-12-21 21:03:25 +05301988 multiport = true;
Sjur Brændeland1b637042012-12-14 14:40:51 +10301989 }
Amit Shah17634ba2009-12-21 21:03:25 +05301990
Amit Shah2658a79a2010-01-18 19:15:11 +05301991 err = init_vqs(portdev);
1992 if (err < 0) {
1993 dev_err(&vdev->dev, "Error %d initializing vqs\n", err);
Amit Shahfb08bd22009-12-21 21:36:04 +05301994 goto free_chrdev;
Amit Shah2658a79a2010-01-18 19:15:11 +05301995 }
Amit Shah1c85bf32010-01-18 19:15:07 +05301996
Amit Shah17634ba2009-12-21 21:03:25 +05301997 spin_lock_init(&portdev->ports_lock);
1998 INIT_LIST_HEAD(&portdev->ports);
1999
2000 if (multiport) {
Amit Shah335a64a5c2010-02-24 10:37:44 +05302001 unsigned int nr_added_bufs;
2002
Amit Shah165b1b82013-03-29 16:30:07 +05302003 spin_lock_init(&portdev->c_ivq_lock);
Amit Shah9ba5c802013-03-29 16:30:08 +05302004 spin_lock_init(&portdev->c_ovq_lock);
Amit Shah17634ba2009-12-21 21:03:25 +05302005 INIT_WORK(&portdev->control_work, &control_work_handler);
2006
Amit Shah165b1b82013-03-29 16:30:07 +05302007 nr_added_bufs = fill_queue(portdev->c_ivq,
2008 &portdev->c_ivq_lock);
Amit Shah335a64a5c2010-02-24 10:37:44 +05302009 if (!nr_added_bufs) {
Amit Shah22a29ea2010-02-12 10:32:17 +05302010 dev_err(&vdev->dev,
2011 "Error allocating buffers for control queue\n");
2012 err = -ENOMEM;
2013 goto free_vqs;
2014 }
Amit Shah1d051602010-05-19 22:15:49 -06002015 } else {
2016 /*
2017 * For backward compatibility: Create a console port
2018 * if we're running on older host.
2019 */
2020 add_port(portdev, 0);
Amit Shah17634ba2009-12-21 21:03:25 +05302021 }
2022
Amit Shah6bdf2af2010-09-02 18:11:49 +05302023 spin_lock_irq(&pdrvdata_lock);
2024 list_add_tail(&portdev->list, &pdrvdata.portdevs);
2025 spin_unlock_irq(&pdrvdata_lock);
2026
Amit Shahf909f852010-05-19 22:15:48 -06002027 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2028 VIRTIO_CONSOLE_DEVICE_READY, 1);
Christian Borntraeger5e384832011-09-22 23:44:23 +05302029
2030 /*
2031 * If there was an early virtio console, assume that there are no
2032 * other consoles. We need to wait until the hvc_alloc matches the
2033 * hvc_instantiate, otherwise tty_open will complain, resulting in
2034 * a "Warning: unable to open an initial console" boot failure.
2035 * Without multiport this is done in add_port above. With multiport
2036 * this might take some host<->guest communication - thus we have to
2037 * wait.
2038 */
2039 if (multiport && early)
2040 wait_for_completion(&early_console_added);
2041
Rusty Russell31610432007-10-22 11:03:39 +10002042 return 0;
2043
Amit Shah22a29ea2010-02-12 10:32:17 +05302044free_vqs:
Julia Lawall0643e4c2010-05-15 11:45:53 +02002045 /* The host might want to notify mgmt sw about device add failure */
2046 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2047 VIRTIO_CONSOLE_DEVICE_READY, 0);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05302048 remove_vqs(portdev);
Amit Shahfb08bd22009-12-21 21:36:04 +05302049free_chrdev:
2050 unregister_chrdev(portdev->chr_major, "virtio-portsdev");
Rusty Russell31610432007-10-22 11:03:39 +10002051free:
Amit Shah1c85bf32010-01-18 19:15:07 +05302052 kfree(portdev);
Rusty Russell31610432007-10-22 11:03:39 +10002053fail:
2054 return err;
2055}
2056
Amit Shah71778762010-02-12 10:32:16 +05302057static void virtcons_remove(struct virtio_device *vdev)
2058{
2059 struct ports_device *portdev;
2060 struct port *port, *port2;
Amit Shah71778762010-02-12 10:32:16 +05302061
2062 portdev = vdev->priv;
2063
Amit Shah6bdf2af2010-09-02 18:11:49 +05302064 spin_lock_irq(&pdrvdata_lock);
2065 list_del(&portdev->list);
2066 spin_unlock_irq(&pdrvdata_lock);
2067
Amit Shah02238952010-09-02 18:11:40 +05302068 /* Disable interrupts for vqs */
2069 vdev->config->reset(vdev);
2070 /* Finish up work that's lined up */
Sjur Brændelandaded0242013-01-22 09:50:26 +10302071 if (use_multiport(portdev))
2072 cancel_work_sync(&portdev->control_work);
Amit Shah71778762010-02-12 10:32:16 +05302073
2074 list_for_each_entry_safe(port, port2, &portdev->ports, list)
Amit Shahb353a6b2010-09-02 18:38:29 +05302075 unplug_port(port);
Amit Shah71778762010-02-12 10:32:16 +05302076
2077 unregister_chrdev(portdev->chr_major, "virtio-portsdev");
2078
Amit Shahe0620132010-09-02 18:38:30 +05302079 /*
2080 * When yanking out a device, we immediately lose the
2081 * (device-side) queues. So there's no point in keeping the
2082 * guest side around till we drop our final reference. This
2083 * also means that any ports which are in an open state will
2084 * have to just stop using the port, as the vqs are going
2085 * away.
2086 */
Amit Shaha0e2dbf2011-12-22 16:58:27 +05302087 remove_controlq_data(portdev);
2088 remove_vqs(portdev);
Amit Shah71778762010-02-12 10:32:16 +05302089 kfree(portdev);
2090}
2091
Rusty Russell31610432007-10-22 11:03:39 +10002092static struct virtio_device_id id_table[] = {
2093 { VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID },
2094 { 0 },
2095};
2096
Christian Borntraegerc2983452008-11-25 13:36:26 +01002097static unsigned int features[] = {
2098 VIRTIO_CONSOLE_F_SIZE,
Amit Shahb99fa812010-05-19 22:15:46 -06002099 VIRTIO_CONSOLE_F_MULTIPORT,
Christian Borntraegerc2983452008-11-25 13:36:26 +01002100};
2101
Sjur Brændeland1b637042012-12-14 14:40:51 +10302102static struct virtio_device_id rproc_serial_id_table[] = {
2103#if IS_ENABLED(CONFIG_REMOTEPROC)
2104 { VIRTIO_ID_RPROC_SERIAL, VIRTIO_DEV_ANY_ID },
2105#endif
2106 { 0 },
2107};
2108
2109static unsigned int rproc_serial_features[] = {
2110};
2111
Amit Shah2b8f41d2011-12-22 16:58:28 +05302112#ifdef CONFIG_PM
2113static int virtcons_freeze(struct virtio_device *vdev)
2114{
2115 struct ports_device *portdev;
2116 struct port *port;
2117
2118 portdev = vdev->priv;
2119
2120 vdev->config->reset(vdev);
2121
Amit Shahc743d092012-01-06 16:19:08 +05302122 virtqueue_disable_cb(portdev->c_ivq);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302123 cancel_work_sync(&portdev->control_work);
Amit Shahc743d092012-01-06 16:19:08 +05302124 /*
2125 * Once more: if control_work_handler() was running, it would
2126 * enable the cb as the last step.
2127 */
2128 virtqueue_disable_cb(portdev->c_ivq);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302129 remove_controlq_data(portdev);
2130
2131 list_for_each_entry(port, &portdev->ports, list) {
Amit Shahc743d092012-01-06 16:19:08 +05302132 virtqueue_disable_cb(port->in_vq);
2133 virtqueue_disable_cb(port->out_vq);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302134 /*
2135 * We'll ask the host later if the new invocation has
2136 * the port opened or closed.
2137 */
2138 port->host_connected = false;
2139 remove_port_data(port);
2140 }
2141 remove_vqs(portdev);
2142
2143 return 0;
2144}
2145
2146static int virtcons_restore(struct virtio_device *vdev)
2147{
2148 struct ports_device *portdev;
2149 struct port *port;
2150 int ret;
2151
2152 portdev = vdev->priv;
2153
2154 ret = init_vqs(portdev);
2155 if (ret)
2156 return ret;
2157
2158 if (use_multiport(portdev))
Amit Shah165b1b82013-03-29 16:30:07 +05302159 fill_queue(portdev->c_ivq, &portdev->c_ivq_lock);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302160
2161 list_for_each_entry(port, &portdev->ports, list) {
2162 port->in_vq = portdev->in_vqs[port->id];
2163 port->out_vq = portdev->out_vqs[port->id];
2164
2165 fill_queue(port->in_vq, &port->inbuf_lock);
2166
2167 /* Get port open/close status on the host */
2168 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
Amit Shahfa8b66c2012-04-25 14:40:39 +05302169
2170 /*
2171 * If a port was open at the time of suspending, we
2172 * have to let the host know that it's still open.
2173 */
2174 if (port->guest_connected)
2175 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302176 }
2177 return 0;
2178}
2179#endif
2180
Rusty Russell31610432007-10-22 11:03:39 +10002181static struct virtio_driver virtio_console = {
Christian Borntraegerc2983452008-11-25 13:36:26 +01002182 .feature_table = features,
2183 .feature_table_size = ARRAY_SIZE(features),
Rusty Russell31610432007-10-22 11:03:39 +10002184 .driver.name = KBUILD_MODNAME,
2185 .driver.owner = THIS_MODULE,
2186 .id_table = id_table,
2187 .probe = virtcons_probe,
Amit Shah71778762010-02-12 10:32:16 +05302188 .remove = virtcons_remove,
Amit Shah7f5d8102009-12-21 22:22:08 +05302189 .config_changed = config_intr,
Amit Shah2b8f41d2011-12-22 16:58:28 +05302190#ifdef CONFIG_PM
2191 .freeze = virtcons_freeze,
2192 .restore = virtcons_restore,
2193#endif
Rusty Russell31610432007-10-22 11:03:39 +10002194};
2195
Greg Kroah-Hartmanbcd29822012-12-21 15:12:08 -08002196static struct virtio_driver virtio_rproc_serial = {
Sjur Brændeland1b637042012-12-14 14:40:51 +10302197 .feature_table = rproc_serial_features,
2198 .feature_table_size = ARRAY_SIZE(rproc_serial_features),
2199 .driver.name = "virtio_rproc_serial",
2200 .driver.owner = THIS_MODULE,
2201 .id_table = rproc_serial_id_table,
2202 .probe = virtcons_probe,
2203 .remove = virtcons_remove,
2204};
2205
Rusty Russell31610432007-10-22 11:03:39 +10002206static int __init init(void)
2207{
Amit Shahfb08bd22009-12-21 21:36:04 +05302208 int err;
2209
2210 pdrvdata.class = class_create(THIS_MODULE, "virtio-ports");
2211 if (IS_ERR(pdrvdata.class)) {
2212 err = PTR_ERR(pdrvdata.class);
2213 pr_err("Error %d creating virtio-ports class\n", err);
2214 return err;
2215 }
Amit Shahd99393e2009-12-21 22:36:21 +05302216
2217 pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL);
2218 if (!pdrvdata.debugfs_dir) {
2219 pr_warning("Error %ld creating debugfs dir for virtio-ports\n",
2220 PTR_ERR(pdrvdata.debugfs_dir));
2221 }
Amit Shah38edf582010-01-18 19:15:05 +05302222 INIT_LIST_HEAD(&pdrvdata.consoles);
Amit Shah6bdf2af2010-09-02 18:11:49 +05302223 INIT_LIST_HEAD(&pdrvdata.portdevs);
Amit Shah38edf582010-01-18 19:15:05 +05302224
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002225 err = register_virtio_driver(&virtio_console);
2226 if (err < 0) {
2227 pr_err("Error %d registering virtio driver\n", err);
2228 goto free;
2229 }
Sjur Brændeland1b637042012-12-14 14:40:51 +10302230 err = register_virtio_driver(&virtio_rproc_serial);
2231 if (err < 0) {
2232 pr_err("Error %d registering virtio rproc serial driver\n",
2233 err);
2234 goto unregister;
2235 }
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002236 return 0;
Sjur Brændeland1b637042012-12-14 14:40:51 +10302237unregister:
2238 unregister_virtio_driver(&virtio_console);
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002239free:
2240 if (pdrvdata.debugfs_dir)
2241 debugfs_remove_recursive(pdrvdata.debugfs_dir);
2242 class_destroy(pdrvdata.class);
2243 return err;
Rusty Russell31610432007-10-22 11:03:39 +10002244}
Amit Shah71778762010-02-12 10:32:16 +05302245
2246static void __exit fini(void)
2247{
Sjur Brændeland1b637042012-12-14 14:40:51 +10302248 reclaim_dma_bufs();
2249
Amit Shah71778762010-02-12 10:32:16 +05302250 unregister_virtio_driver(&virtio_console);
Sjur Brændeland1b637042012-12-14 14:40:51 +10302251 unregister_virtio_driver(&virtio_rproc_serial);
Amit Shah71778762010-02-12 10:32:16 +05302252
2253 class_destroy(pdrvdata.class);
2254 if (pdrvdata.debugfs_dir)
2255 debugfs_remove_recursive(pdrvdata.debugfs_dir);
2256}
Rusty Russell31610432007-10-22 11:03:39 +10002257module_init(init);
Amit Shah71778762010-02-12 10:32:16 +05302258module_exit(fini);
Rusty Russell31610432007-10-22 11:03:39 +10002259
2260MODULE_DEVICE_TABLE(virtio, id_table);
2261MODULE_DESCRIPTION("Virtio console driver");
2262MODULE_LICENSE("GPL");