blob: e905d5f5305180cd7cc77a8690e51ae53bed3fec [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 */
152 spinlock_t cvq_lock;
153
154 /* The current config space is stored here */
Amit Shahb99fa812010-05-19 22:15:46 -0600155 struct virtio_console_config config;
Amit Shah17634ba2009-12-21 21:03:25 +0530156
157 /* The virtio device we're associated with */
158 struct virtio_device *vdev;
159
160 /*
161 * A couple of virtqueues for the control channel: one for
162 * guest->host transfers, one for host->guest transfers
163 */
164 struct virtqueue *c_ivq, *c_ovq;
165
166 /* Array of per-port IO virtqueues */
167 struct virtqueue **in_vqs, **out_vqs;
Amit Shahfb08bd22009-12-21 21:36:04 +0530168
Amit Shahfb08bd22009-12-21 21:36:04 +0530169 /* Major number for this device. Ports will be created as minors. */
170 int chr_major;
Amit Shah17634ba2009-12-21 21:03:25 +0530171};
172
Amit Shah17e5b4f2011-09-14 13:06:46 +0530173struct port_stats {
174 unsigned long bytes_sent, bytes_received, bytes_discarded;
175};
176
Amit Shah1c85bf32010-01-18 19:15:07 +0530177/* This struct holds the per-port data */
Rusty Russell21206ed2010-01-18 19:15:00 +0530178struct port {
Amit Shah17634ba2009-12-21 21:03:25 +0530179 /* Next port in the list, head is in the ports_device */
180 struct list_head list;
181
Amit Shah1c85bf32010-01-18 19:15:07 +0530182 /* Pointer to the parent virtio_console device */
183 struct ports_device *portdev;
Amit Shahfdb9a052010-01-18 19:15:01 +0530184
185 /* The current buffer from which data has to be fed to readers */
186 struct port_buffer *inbuf;
Rusty Russell31610432007-10-22 11:03:39 +1000187
Amit Shah203baab2010-01-18 19:15:12 +0530188 /*
189 * To protect the operations on the in_vq associated with this
190 * port. Has to be a spinlock because it can be called from
191 * interrupt context (get_char()).
192 */
193 spinlock_t inbuf_lock;
194
Amit Shahcdfadfc2010-05-19 22:15:50 -0600195 /* Protect the operations on the out_vq. */
196 spinlock_t outvq_lock;
197
Amit Shah1c85bf32010-01-18 19:15:07 +0530198 /* The IO vqs for this port */
199 struct virtqueue *in_vq, *out_vq;
200
Amit Shahd99393e2009-12-21 22:36:21 +0530201 /* File in the debugfs directory that exposes this port's information */
202 struct dentry *debugfs_file;
203
Amit Shah4f23c572010-01-18 19:15:09 +0530204 /*
Amit Shah17e5b4f2011-09-14 13:06:46 +0530205 * Keep count of the bytes sent, received and discarded for
206 * this port for accounting and debugging purposes. These
207 * counts are not reset across port open / close events.
208 */
209 struct port_stats stats;
210
211 /*
Amit Shah4f23c572010-01-18 19:15:09 +0530212 * The entries in this struct will be valid if this port is
213 * hooked up to an hvc console
214 */
215 struct console cons;
Amit Shah17634ba2009-12-21 21:03:25 +0530216
Amit Shahfb08bd22009-12-21 21:36:04 +0530217 /* Each port associates with a separate char device */
Amit Shahd22a6982010-09-02 18:20:59 +0530218 struct cdev *cdev;
Amit Shahfb08bd22009-12-21 21:36:04 +0530219 struct device *dev;
220
Amit Shahb353a6b2010-09-02 18:38:29 +0530221 /* Reference-counting to handle port hot-unplugs and file operations */
222 struct kref kref;
223
Amit Shah2030fa42009-12-21 21:49:30 +0530224 /* A waitqueue for poll() or blocking read operations */
225 wait_queue_head_t waitqueue;
226
Amit Shah431edb82009-12-21 21:57:40 +0530227 /* The 'name' of the port that we expose via sysfs properties */
228 char *name;
229
Amit Shah3eae0ad2010-09-02 18:47:52 +0530230 /* We can notify apps of host connect / disconnect events via SIGIO */
231 struct fasync_struct *async_queue;
232
Amit Shah17634ba2009-12-21 21:03:25 +0530233 /* The 'id' to identify the port with the Host */
234 u32 id;
Amit Shah2030fa42009-12-21 21:49:30 +0530235
Amit Shahcdfadfc2010-05-19 22:15:50 -0600236 bool outvq_full;
237
Amit Shah2030fa42009-12-21 21:49:30 +0530238 /* Is the host device open */
239 bool host_connected;
Amit Shah3c7969c2009-11-26 11:25:38 +0530240
241 /* We should allow only one process to open a port */
242 bool guest_connected;
Rusty Russell21206ed2010-01-18 19:15:00 +0530243};
Rusty Russell31610432007-10-22 11:03:39 +1000244
Rusty Russell971f3392010-01-18 19:14:56 +0530245/* This is the very early arch-specified put chars function. */
246static int (*early_put_chars)(u32, const char *, int);
247
Amit Shah38edf582010-01-18 19:15:05 +0530248static struct port *find_port_by_vtermno(u32 vtermno)
249{
250 struct port *port;
Amit Shah4f23c572010-01-18 19:15:09 +0530251 struct console *cons;
Amit Shah38edf582010-01-18 19:15:05 +0530252 unsigned long flags;
253
254 spin_lock_irqsave(&pdrvdata_lock, flags);
Amit Shah4f23c572010-01-18 19:15:09 +0530255 list_for_each_entry(cons, &pdrvdata.consoles, list) {
256 if (cons->vtermno == vtermno) {
257 port = container_of(cons, struct port, cons);
Amit Shah38edf582010-01-18 19:15:05 +0530258 goto out;
Amit Shah4f23c572010-01-18 19:15:09 +0530259 }
Amit Shah38edf582010-01-18 19:15:05 +0530260 }
261 port = NULL;
262out:
263 spin_unlock_irqrestore(&pdrvdata_lock, flags);
264 return port;
265}
266
Amit Shah04950cd2010-09-02 18:20:58 +0530267static struct port *find_port_by_devt_in_portdev(struct ports_device *portdev,
268 dev_t dev)
269{
270 struct port *port;
271 unsigned long flags;
272
273 spin_lock_irqsave(&portdev->ports_lock, flags);
274 list_for_each_entry(port, &portdev->ports, list)
Amit Shahd22a6982010-09-02 18:20:59 +0530275 if (port->cdev->dev == dev)
Amit Shah04950cd2010-09-02 18:20:58 +0530276 goto out;
277 port = NULL;
278out:
279 spin_unlock_irqrestore(&portdev->ports_lock, flags);
280
281 return port;
282}
283
284static struct port *find_port_by_devt(dev_t dev)
285{
286 struct ports_device *portdev;
287 struct port *port;
288 unsigned long flags;
289
290 spin_lock_irqsave(&pdrvdata_lock, flags);
291 list_for_each_entry(portdev, &pdrvdata.portdevs, list) {
292 port = find_port_by_devt_in_portdev(portdev, dev);
293 if (port)
294 goto out;
295 }
296 port = NULL;
297out:
298 spin_unlock_irqrestore(&pdrvdata_lock, flags);
299 return port;
300}
301
Amit Shah17634ba2009-12-21 21:03:25 +0530302static struct port *find_port_by_id(struct ports_device *portdev, u32 id)
303{
304 struct port *port;
305 unsigned long flags;
306
307 spin_lock_irqsave(&portdev->ports_lock, flags);
308 list_for_each_entry(port, &portdev->ports, list)
309 if (port->id == id)
310 goto out;
311 port = NULL;
312out:
313 spin_unlock_irqrestore(&portdev->ports_lock, flags);
314
315 return port;
316}
317
Amit Shah203baab2010-01-18 19:15:12 +0530318static struct port *find_port_by_vq(struct ports_device *portdev,
319 struct virtqueue *vq)
320{
321 struct port *port;
Amit Shah203baab2010-01-18 19:15:12 +0530322 unsigned long flags;
323
Amit Shah17634ba2009-12-21 21:03:25 +0530324 spin_lock_irqsave(&portdev->ports_lock, flags);
325 list_for_each_entry(port, &portdev->ports, list)
Amit Shah203baab2010-01-18 19:15:12 +0530326 if (port->in_vq == vq || port->out_vq == vq)
327 goto out;
Amit Shah203baab2010-01-18 19:15:12 +0530328 port = NULL;
329out:
Amit Shah17634ba2009-12-21 21:03:25 +0530330 spin_unlock_irqrestore(&portdev->ports_lock, flags);
Amit Shah203baab2010-01-18 19:15:12 +0530331 return port;
332}
333
Amit Shah17634ba2009-12-21 21:03:25 +0530334static bool is_console_port(struct port *port)
335{
336 if (port->cons.hvc)
337 return true;
338 return false;
339}
340
Sjur Brændeland1b637042012-12-14 14:40:51 +1030341static bool is_rproc_serial(const struct virtio_device *vdev)
342{
343 return is_rproc_enabled && vdev->id.device == VIRTIO_ID_RPROC_SERIAL;
344}
345
Amit Shah17634ba2009-12-21 21:03:25 +0530346static inline bool use_multiport(struct ports_device *portdev)
347{
348 /*
349 * This condition can be true when put_chars is called from
350 * early_init
351 */
352 if (!portdev->vdev)
353 return 0;
354 return portdev->vdev->features[0] & (1 << VIRTIO_CONSOLE_F_MULTIPORT);
355}
356
Sjur Brændeland1b637042012-12-14 14:40:51 +1030357static DEFINE_SPINLOCK(dma_bufs_lock);
358static LIST_HEAD(pending_free_dma_bufs);
359
360static void free_buf(struct port_buffer *buf, bool can_sleep)
Amit Shahfdb9a052010-01-18 19:15:01 +0530361{
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030362 unsigned int i;
363
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030364 for (i = 0; i < buf->sgpages; i++) {
365 struct page *page = sg_page(&buf->sg[i]);
366 if (!page)
367 break;
368 put_page(page);
369 }
370
Sjur Brændeland1b637042012-12-14 14:40:51 +1030371 if (!buf->dev) {
372 kfree(buf->buf);
373 } else if (is_rproc_enabled) {
374 unsigned long flags;
375
376 /* dma_free_coherent requires interrupts to be enabled. */
377 if (!can_sleep) {
378 /* queue up dma-buffers to be freed later */
379 spin_lock_irqsave(&dma_bufs_lock, flags);
380 list_add_tail(&buf->list, &pending_free_dma_bufs);
381 spin_unlock_irqrestore(&dma_bufs_lock, flags);
382 return;
383 }
384 dma_free_coherent(buf->dev, buf->size, buf->buf, buf->dma);
385
386 /* Release device refcnt and allow it to be freed */
387 put_device(buf->dev);
388 }
389
Amit Shahfdb9a052010-01-18 19:15:01 +0530390 kfree(buf);
391}
392
Sjur Brændeland1b637042012-12-14 14:40:51 +1030393static void reclaim_dma_bufs(void)
394{
395 unsigned long flags;
396 struct port_buffer *buf, *tmp;
397 LIST_HEAD(tmp_list);
398
399 if (list_empty(&pending_free_dma_bufs))
400 return;
401
402 /* Create a copy of the pending_free_dma_bufs while holding the lock */
403 spin_lock_irqsave(&dma_bufs_lock, flags);
404 list_cut_position(&tmp_list, &pending_free_dma_bufs,
405 pending_free_dma_bufs.prev);
406 spin_unlock_irqrestore(&dma_bufs_lock, flags);
407
408 /* Release the dma buffers, without irqs enabled */
409 list_for_each_entry_safe(buf, tmp, &tmp_list, list) {
410 list_del(&buf->list);
411 free_buf(buf, true);
412 }
413}
414
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030415static struct port_buffer *alloc_buf(struct virtqueue *vq, size_t buf_size,
416 int pages)
Amit Shahfdb9a052010-01-18 19:15:01 +0530417{
418 struct port_buffer *buf;
419
Sjur Brændeland1b637042012-12-14 14:40:51 +1030420 reclaim_dma_bufs();
421
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030422 /*
423 * Allocate buffer and the sg list. The sg list array is allocated
424 * directly after the port_buffer struct.
425 */
426 buf = kmalloc(sizeof(*buf) + sizeof(struct scatterlist) * pages,
427 GFP_KERNEL);
Amit Shahfdb9a052010-01-18 19:15:01 +0530428 if (!buf)
429 goto fail;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030430
431 buf->sgpages = pages;
432 if (pages > 0) {
Sjur Brændeland1b637042012-12-14 14:40:51 +1030433 buf->dev = NULL;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030434 buf->buf = NULL;
435 return buf;
436 }
437
Sjur Brændeland1b637042012-12-14 14:40:51 +1030438 if (is_rproc_serial(vq->vdev)) {
439 /*
440 * Allocate DMA memory from ancestor. When a virtio
441 * device is created by remoteproc, the DMA memory is
442 * associated with the grandparent device:
443 * vdev => rproc => platform-dev.
444 * The code here would have been less quirky if
445 * DMA_MEMORY_INCLUDES_CHILDREN had been supported
446 * in dma-coherent.c
447 */
448 if (!vq->vdev->dev.parent || !vq->vdev->dev.parent->parent)
449 goto free_buf;
450 buf->dev = vq->vdev->dev.parent->parent;
451
452 /* Increase device refcnt to avoid freeing it */
453 get_device(buf->dev);
454 buf->buf = dma_alloc_coherent(buf->dev, buf_size, &buf->dma,
455 GFP_KERNEL);
456 } else {
457 buf->dev = NULL;
458 buf->buf = kmalloc(buf_size, GFP_KERNEL);
459 }
460
Amit Shahfdb9a052010-01-18 19:15:01 +0530461 if (!buf->buf)
462 goto free_buf;
463 buf->len = 0;
464 buf->offset = 0;
465 buf->size = buf_size;
466 return buf;
467
468free_buf:
469 kfree(buf);
470fail:
471 return NULL;
472}
473
Amit Shaha3cde442010-01-18 19:15:03 +0530474/* Callers should take appropriate locks */
Amit Shahdefde662011-09-14 13:06:42 +0530475static struct port_buffer *get_inbuf(struct port *port)
Amit Shaha3cde442010-01-18 19:15:03 +0530476{
477 struct port_buffer *buf;
Amit Shaha3cde442010-01-18 19:15:03 +0530478 unsigned int len;
479
Amit Shahd25a9dd2011-09-14 13:06:43 +0530480 if (port->inbuf)
481 return port->inbuf;
482
483 buf = virtqueue_get_buf(port->in_vq, &len);
Amit Shaha3cde442010-01-18 19:15:03 +0530484 if (buf) {
485 buf->len = len;
486 buf->offset = 0;
Amit Shah17e5b4f2011-09-14 13:06:46 +0530487 port->stats.bytes_received += len;
Amit Shaha3cde442010-01-18 19:15:03 +0530488 }
489 return buf;
490}
491
Rusty Russella23ea922010-01-18 19:14:55 +0530492/*
Amit Shahe27b5192010-01-18 19:15:02 +0530493 * Create a scatter-gather list representing our input buffer and put
494 * it in the queue.
495 *
496 * Callers should take appropriate locks.
497 */
Amit Shah203baab2010-01-18 19:15:12 +0530498static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)
Amit Shahe27b5192010-01-18 19:15:02 +0530499{
500 struct scatterlist sg[1];
Amit Shah203baab2010-01-18 19:15:12 +0530501 int ret;
Amit Shah1c85bf32010-01-18 19:15:07 +0530502
Amit Shahe27b5192010-01-18 19:15:02 +0530503 sg_init_one(sg, buf->buf, buf->size);
504
Rusty Russellf96fde42012-01-12 15:44:42 +1030505 ret = virtqueue_add_buf(vq, sg, 0, 1, buf, GFP_ATOMIC);
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300506 virtqueue_kick(vq);
Amit Shah49e86f12012-12-10 09:45:12 +1030507 if (!ret)
508 ret = vq->num_free;
Amit Shah203baab2010-01-18 19:15:12 +0530509 return ret;
510}
511
Amit Shah88f251a2009-12-21 22:15:30 +0530512/* Discard any unread data this port has. Callers lockers. */
513static void discard_port_data(struct port *port)
514{
515 struct port_buffer *buf;
Amit Shah2d24cda2011-09-14 13:06:45 +0530516 unsigned int err;
Amit Shah88f251a2009-12-21 22:15:30 +0530517
Amit Shahd7a62cd2011-03-04 14:04:33 +1030518 if (!port->portdev) {
519 /* Device has been unplugged. vqs are already gone. */
520 return;
521 }
Amit Shah2d24cda2011-09-14 13:06:45 +0530522 buf = get_inbuf(port);
Amit Shah88f251a2009-12-21 22:15:30 +0530523
Amit Shahce072a02011-09-14 13:06:44 +0530524 err = 0;
Amit Shahd6933562010-02-12 10:32:18 +0530525 while (buf) {
Amit Shah17e5b4f2011-09-14 13:06:46 +0530526 port->stats.bytes_discarded += buf->len - buf->offset;
Amit Shah2d24cda2011-09-14 13:06:45 +0530527 if (add_inbuf(port->in_vq, buf) < 0) {
Amit Shahce072a02011-09-14 13:06:44 +0530528 err++;
Sjur Brændeland1b637042012-12-14 14:40:51 +1030529 free_buf(buf, false);
Amit Shahd6933562010-02-12 10:32:18 +0530530 }
Amit Shah2d24cda2011-09-14 13:06:45 +0530531 port->inbuf = NULL;
532 buf = get_inbuf(port);
Amit Shah88f251a2009-12-21 22:15:30 +0530533 }
Amit Shahce072a02011-09-14 13:06:44 +0530534 if (err)
Amit Shahd6933562010-02-12 10:32:18 +0530535 dev_warn(port->dev, "Errors adding %d buffers back to vq\n",
Amit Shahce072a02011-09-14 13:06:44 +0530536 err);
Amit Shah88f251a2009-12-21 22:15:30 +0530537}
538
Amit Shah203baab2010-01-18 19:15:12 +0530539static bool port_has_data(struct port *port)
540{
541 unsigned long flags;
542 bool ret;
543
Amit Shahd6933562010-02-12 10:32:18 +0530544 ret = false;
Amit Shahd25a9dd2011-09-14 13:06:43 +0530545 spin_lock_irqsave(&port->inbuf_lock, flags);
546 port->inbuf = get_inbuf(port);
547 if (port->inbuf)
548 ret = true;
549
Amit Shah203baab2010-01-18 19:15:12 +0530550 spin_unlock_irqrestore(&port->inbuf_lock, flags);
Amit Shah203baab2010-01-18 19:15:12 +0530551 return ret;
552}
553
Amit Shah3425e702010-05-19 22:15:46 -0600554static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id,
555 unsigned int event, unsigned int value)
Amit Shah17634ba2009-12-21 21:03:25 +0530556{
557 struct scatterlist sg[1];
558 struct virtio_console_control cpkt;
559 struct virtqueue *vq;
Amit Shah604b2ad2010-02-24 10:36:51 +0530560 unsigned int len;
Amit Shah17634ba2009-12-21 21:03:25 +0530561
Amit Shah3425e702010-05-19 22:15:46 -0600562 if (!use_multiport(portdev))
Amit Shah17634ba2009-12-21 21:03:25 +0530563 return 0;
564
Amit Shah3425e702010-05-19 22:15:46 -0600565 cpkt.id = port_id;
Amit Shah17634ba2009-12-21 21:03:25 +0530566 cpkt.event = event;
567 cpkt.value = value;
568
Amit Shah3425e702010-05-19 22:15:46 -0600569 vq = portdev->c_ovq;
Amit Shah17634ba2009-12-21 21:03:25 +0530570
571 sg_init_one(sg, &cpkt, sizeof(cpkt));
Rusty Russell589575a2012-10-16 23:56:15 +1030572 if (virtqueue_add_buf(vq, sg, 1, 0, &cpkt, GFP_ATOMIC) == 0) {
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300573 virtqueue_kick(vq);
574 while (!virtqueue_get_buf(vq, &len))
Amit Shah17634ba2009-12-21 21:03:25 +0530575 cpu_relax();
576 }
577 return 0;
578}
579
Amit Shah3425e702010-05-19 22:15:46 -0600580static ssize_t send_control_msg(struct port *port, unsigned int event,
581 unsigned int value)
582{
Amit Shah84ec06c2010-09-02 18:11:42 +0530583 /* Did the port get unplugged before userspace closed it? */
584 if (port->portdev)
585 return __send_control_msg(port->portdev, port->id, event, value);
586 return 0;
Amit Shah3425e702010-05-19 22:15:46 -0600587}
588
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900589
Amit Shahcdfadfc2010-05-19 22:15:50 -0600590/* Callers must take the port->outvq_lock */
591static void reclaim_consumed_buffers(struct port *port)
592{
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030593 struct port_buffer *buf;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600594 unsigned int len;
595
Amit Shahd7a62cd2011-03-04 14:04:33 +1030596 if (!port->portdev) {
597 /* Device has been unplugged. vqs are already gone. */
598 return;
599 }
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030600 while ((buf = virtqueue_get_buf(port->out_vq, &len))) {
Sjur Brændeland1b637042012-12-14 14:40:51 +1030601 free_buf(buf, false);
Amit Shahcdfadfc2010-05-19 22:15:50 -0600602 port->outvq_full = false;
603 }
604}
605
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900606static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,
607 int nents, size_t in_count,
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030608 void *data, bool nonblock)
Amit Shahf997f00b2009-12-21 17:28:51 +0530609{
Amit Shahf997f00b2009-12-21 17:28:51 +0530610 struct virtqueue *out_vq;
Rusty Russell589575a2012-10-16 23:56:15 +1030611 int err;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600612 unsigned long flags;
Amit Shahf997f00b2009-12-21 17:28:51 +0530613 unsigned int len;
614
615 out_vq = port->out_vq;
616
Amit Shahcdfadfc2010-05-19 22:15:50 -0600617 spin_lock_irqsave(&port->outvq_lock, flags);
618
619 reclaim_consumed_buffers(port);
620
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030621 err = virtqueue_add_buf(out_vq, sg, nents, 0, data, GFP_ATOMIC);
Amit Shahf997f00b2009-12-21 17:28:51 +0530622
623 /* Tell Host to go! */
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300624 virtqueue_kick(out_vq);
Amit Shahf997f00b2009-12-21 17:28:51 +0530625
Rusty Russell589575a2012-10-16 23:56:15 +1030626 if (err) {
Rusty Russell9ff4cfa2010-04-08 09:46:16 -0600627 in_count = 0;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600628 goto done;
Amit Shahf997f00b2009-12-21 17:28:51 +0530629 }
630
Rusty Russell589575a2012-10-16 23:56:15 +1030631 if (out_vq->num_free == 0)
Amit Shahcdfadfc2010-05-19 22:15:50 -0600632 port->outvq_full = true;
633
634 if (nonblock)
635 goto done;
636
637 /*
638 * Wait till the host acknowledges it pushed out the data we
Amit Shah531295e2010-10-20 13:45:43 +1030639 * sent. This is done for data from the hvc_console; the tty
640 * operations are performed with spinlocks held so we can't
641 * sleep here. An alternative would be to copy the data to a
642 * buffer and relax the spinning requirement. The downside is
643 * we need to kmalloc a GFP_ATOMIC buffer each time the
644 * console driver writes something out.
Amit Shahcdfadfc2010-05-19 22:15:50 -0600645 */
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300646 while (!virtqueue_get_buf(out_vq, &len))
Amit Shahf997f00b2009-12-21 17:28:51 +0530647 cpu_relax();
Amit Shahcdfadfc2010-05-19 22:15:50 -0600648done:
649 spin_unlock_irqrestore(&port->outvq_lock, flags);
Amit Shah17e5b4f2011-09-14 13:06:46 +0530650
651 port->stats.bytes_sent += in_count;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600652 /*
653 * We're expected to return the amount of data we wrote -- all
654 * of it
655 */
Rusty Russell9ff4cfa2010-04-08 09:46:16 -0600656 return in_count;
Amit Shahf997f00b2009-12-21 17:28:51 +0530657}
658
Amit Shah203baab2010-01-18 19:15:12 +0530659/*
660 * Give out the data that's requested from the buffer that we have
661 * queued up.
662 */
Amit Shahb766cee2009-12-21 21:26:45 +0530663static ssize_t fill_readbuf(struct port *port, char *out_buf, size_t out_count,
664 bool to_user)
Amit Shah203baab2010-01-18 19:15:12 +0530665{
666 struct port_buffer *buf;
667 unsigned long flags;
668
669 if (!out_count || !port_has_data(port))
670 return 0;
671
672 buf = port->inbuf;
Amit Shahb766cee2009-12-21 21:26:45 +0530673 out_count = min(out_count, buf->len - buf->offset);
Amit Shah203baab2010-01-18 19:15:12 +0530674
Amit Shahb766cee2009-12-21 21:26:45 +0530675 if (to_user) {
676 ssize_t ret;
Amit Shah203baab2010-01-18 19:15:12 +0530677
Amit Shahb766cee2009-12-21 21:26:45 +0530678 ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count);
679 if (ret)
680 return -EFAULT;
681 } else {
682 memcpy(out_buf, buf->buf + buf->offset, out_count);
683 }
684
Amit Shah203baab2010-01-18 19:15:12 +0530685 buf->offset += out_count;
686
687 if (buf->offset == buf->len) {
688 /*
689 * We're done using all the data in this buffer.
690 * Re-queue so that the Host can send us more data.
691 */
692 spin_lock_irqsave(&port->inbuf_lock, flags);
693 port->inbuf = NULL;
694
695 if (add_inbuf(port->in_vq, buf) < 0)
Amit Shahfb08bd22009-12-21 21:36:04 +0530696 dev_warn(port->dev, "failed add_buf\n");
Amit Shah203baab2010-01-18 19:15:12 +0530697
698 spin_unlock_irqrestore(&port->inbuf_lock, flags);
699 }
Amit Shahb766cee2009-12-21 21:26:45 +0530700 /* Return the number of bytes actually copied */
Amit Shah203baab2010-01-18 19:15:12 +0530701 return out_count;
Amit Shahe27b5192010-01-18 19:15:02 +0530702}
703
Amit Shah2030fa42009-12-21 21:49:30 +0530704/* The condition that must be true for polling to end */
Amit Shah60caacd2010-05-19 22:15:49 -0600705static bool will_read_block(struct port *port)
Amit Shah2030fa42009-12-21 21:49:30 +0530706{
Amit Shah3709ea72010-09-02 18:11:43 +0530707 if (!port->guest_connected) {
708 /* Port got hot-unplugged. Let's exit. */
709 return false;
710 }
Amit Shah60caacd2010-05-19 22:15:49 -0600711 return !port_has_data(port) && port->host_connected;
Amit Shah2030fa42009-12-21 21:49:30 +0530712}
713
Amit Shahcdfadfc2010-05-19 22:15:50 -0600714static bool will_write_block(struct port *port)
715{
716 bool ret;
717
Amit Shah60e5e0b2010-05-27 13:24:40 +0530718 if (!port->guest_connected) {
719 /* Port got hot-unplugged. Let's exit. */
720 return false;
721 }
Amit Shahcdfadfc2010-05-19 22:15:50 -0600722 if (!port->host_connected)
723 return true;
724
725 spin_lock_irq(&port->outvq_lock);
726 /*
727 * Check if the Host has consumed any buffers since we last
728 * sent data (this is only applicable for nonblocking ports).
729 */
730 reclaim_consumed_buffers(port);
731 ret = port->outvq_full;
732 spin_unlock_irq(&port->outvq_lock);
733
734 return ret;
735}
736
Amit Shah2030fa42009-12-21 21:49:30 +0530737static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
738 size_t count, loff_t *offp)
739{
740 struct port *port;
741 ssize_t ret;
742
743 port = filp->private_data;
744
745 if (!port_has_data(port)) {
746 /*
747 * If nothing's connected on the host just return 0 in
748 * case of list_empty; this tells the userspace app
749 * that there's no connection
750 */
751 if (!port->host_connected)
752 return 0;
753 if (filp->f_flags & O_NONBLOCK)
754 return -EAGAIN;
755
Amit Shaha08fa922011-09-14 13:06:41 +0530756 ret = wait_event_freezable(port->waitqueue,
757 !will_read_block(port));
Amit Shah2030fa42009-12-21 21:49:30 +0530758 if (ret < 0)
759 return ret;
760 }
Amit Shahb3dddb92010-09-02 18:11:45 +0530761 /* Port got hot-unplugged. */
762 if (!port->guest_connected)
763 return -ENODEV;
Amit Shah2030fa42009-12-21 21:49:30 +0530764 /*
765 * We could've received a disconnection message while we were
766 * waiting for more data.
767 *
768 * This check is not clubbed in the if() statement above as we
769 * might receive some data as well as the host could get
770 * disconnected after we got woken up from our wait. So we
771 * really want to give off whatever data we have and only then
772 * check for host_connected.
773 */
774 if (!port_has_data(port) && !port->host_connected)
775 return 0;
776
777 return fill_readbuf(port, ubuf, count, true);
778}
779
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900780static int wait_port_writable(struct port *port, bool nonblock)
781{
782 int ret;
783
784 if (will_write_block(port)) {
785 if (nonblock)
786 return -EAGAIN;
787
788 ret = wait_event_freezable(port->waitqueue,
789 !will_write_block(port));
790 if (ret < 0)
791 return ret;
792 }
793 /* Port got hot-unplugged. */
794 if (!port->guest_connected)
795 return -ENODEV;
796
797 return 0;
798}
799
Amit Shah2030fa42009-12-21 21:49:30 +0530800static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
801 size_t count, loff_t *offp)
802{
803 struct port *port;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030804 struct port_buffer *buf;
Amit Shah2030fa42009-12-21 21:49:30 +0530805 ssize_t ret;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600806 bool nonblock;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030807 struct scatterlist sg[1];
Amit Shah2030fa42009-12-21 21:49:30 +0530808
Amit Shah65745422010-09-14 13:26:16 +0530809 /* Userspace could be out to fool us */
810 if (!count)
811 return 0;
812
Amit Shah2030fa42009-12-21 21:49:30 +0530813 port = filp->private_data;
814
Amit Shahcdfadfc2010-05-19 22:15:50 -0600815 nonblock = filp->f_flags & O_NONBLOCK;
816
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900817 ret = wait_port_writable(port, nonblock);
818 if (ret < 0)
819 return ret;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600820
Amit Shah2030fa42009-12-21 21:49:30 +0530821 count = min((size_t)(32 * 1024), count);
822
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030823 buf = alloc_buf(port->out_vq, count, 0);
Amit Shah2030fa42009-12-21 21:49:30 +0530824 if (!buf)
825 return -ENOMEM;
826
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030827 ret = copy_from_user(buf->buf, ubuf, count);
Amit Shah2030fa42009-12-21 21:49:30 +0530828 if (ret) {
829 ret = -EFAULT;
830 goto free_buf;
831 }
832
Amit Shah531295e2010-10-20 13:45:43 +1030833 /*
834 * We now ask send_buf() to not spin for generic ports -- we
835 * can re-use the same code path that non-blocking file
836 * descriptors take for blocking file descriptors since the
837 * wait is already done and we're certain the write will go
838 * through to the host.
839 */
840 nonblock = true;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030841 sg_init_one(sg, buf->buf, count);
842 ret = __send_to_port(port, sg, 1, count, buf, nonblock);
Amit Shahcdfadfc2010-05-19 22:15:50 -0600843
844 if (nonblock && ret > 0)
845 goto out;
846
Amit Shah2030fa42009-12-21 21:49:30 +0530847free_buf:
Sjur Brændeland1b637042012-12-14 14:40:51 +1030848 free_buf(buf, true);
Amit Shahcdfadfc2010-05-19 22:15:50 -0600849out:
Amit Shah2030fa42009-12-21 21:49:30 +0530850 return ret;
851}
852
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900853struct sg_list {
854 unsigned int n;
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900855 unsigned int size;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900856 size_t len;
857 struct scatterlist *sg;
858};
859
860static int pipe_to_sg(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
861 struct splice_desc *sd)
862{
863 struct sg_list *sgl = sd->u.data;
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900864 unsigned int offset, len;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900865
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900866 if (sgl->n == sgl->size)
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900867 return 0;
868
869 /* Try lock this page */
870 if (buf->ops->steal(pipe, buf) == 0) {
871 /* Get reference and unlock page for moving */
872 get_page(buf->page);
873 unlock_page(buf->page);
874
875 len = min(buf->len, sd->len);
876 sg_set_page(&(sgl->sg[sgl->n]), buf->page, len, buf->offset);
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900877 } else {
878 /* Failback to copying a page */
879 struct page *page = alloc_page(GFP_KERNEL);
880 char *src = buf->ops->map(pipe, buf, 1);
881 char *dst;
882
883 if (!page)
884 return -ENOMEM;
885 dst = kmap(page);
886
887 offset = sd->pos & ~PAGE_MASK;
888
889 len = sd->len;
890 if (len + offset > PAGE_SIZE)
891 len = PAGE_SIZE - offset;
892
893 memcpy(dst + offset, src + buf->offset, len);
894
895 kunmap(page);
896 buf->ops->unmap(pipe, buf, src);
897
898 sg_set_page(&(sgl->sg[sgl->n]), page, len, offset);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900899 }
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900900 sgl->n++;
901 sgl->len += len;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900902
903 return len;
904}
905
906/* Faster zero-copy write by splicing */
907static ssize_t port_fops_splice_write(struct pipe_inode_info *pipe,
908 struct file *filp, loff_t *ppos,
909 size_t len, unsigned int flags)
910{
911 struct port *port = filp->private_data;
912 struct sg_list sgl;
913 ssize_t ret;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030914 struct port_buffer *buf;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900915 struct splice_desc sd = {
916 .total_len = len,
917 .flags = flags,
918 .pos = *ppos,
919 .u.data = &sgl,
920 };
921
Sjur Brændeland1b637042012-12-14 14:40:51 +1030922 /*
923 * Rproc_serial does not yet support splice. To support splice
924 * pipe_to_sg() must allocate dma-buffers and copy content from
925 * regular pages to dma pages. And alloc_buf and free_buf must
926 * support allocating and freeing such a list of dma-buffers.
927 */
928 if (is_rproc_serial(port->out_vq->vdev))
929 return -EINVAL;
930
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900931 ret = wait_port_writable(port, filp->f_flags & O_NONBLOCK);
932 if (ret < 0)
933 return ret;
934
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030935 buf = alloc_buf(port->out_vq, 0, pipe->nrbufs);
936 if (!buf)
937 return -ENOMEM;
938
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900939 sgl.n = 0;
940 sgl.len = 0;
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900941 sgl.size = pipe->nrbufs;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030942 sgl.sg = buf->sg;
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900943 sg_init_table(sgl.sg, sgl.size);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900944 ret = __splice_from_pipe(pipe, &sd, pipe_to_sg);
945 if (likely(ret > 0))
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030946 ret = __send_to_port(port, buf->sg, sgl.n, sgl.len, buf, true);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900947
Sjur Brændelandfe529532012-10-15 09:57:33 +0200948 if (unlikely(ret <= 0))
Sjur Brændeland1b637042012-12-14 14:40:51 +1030949 free_buf(buf, true);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900950 return ret;
951}
952
Amit Shah2030fa42009-12-21 21:49:30 +0530953static unsigned int port_fops_poll(struct file *filp, poll_table *wait)
954{
955 struct port *port;
956 unsigned int ret;
957
958 port = filp->private_data;
959 poll_wait(filp, &port->waitqueue, wait);
960
Amit Shah8529a502010-09-02 18:11:44 +0530961 if (!port->guest_connected) {
962 /* Port got unplugged */
963 return POLLHUP;
964 }
Amit Shah2030fa42009-12-21 21:49:30 +0530965 ret = 0;
Hans de Goede6df7aad2010-09-16 14:43:08 +0530966 if (!will_read_block(port))
Amit Shah2030fa42009-12-21 21:49:30 +0530967 ret |= POLLIN | POLLRDNORM;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600968 if (!will_write_block(port))
Amit Shah2030fa42009-12-21 21:49:30 +0530969 ret |= POLLOUT;
970 if (!port->host_connected)
971 ret |= POLLHUP;
972
973 return ret;
974}
975
Amit Shahb353a6b2010-09-02 18:38:29 +0530976static void remove_port(struct kref *kref);
977
Amit Shah2030fa42009-12-21 21:49:30 +0530978static int port_fops_release(struct inode *inode, struct file *filp)
979{
980 struct port *port;
981
982 port = filp->private_data;
983
984 /* Notify host of port being closed */
985 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
986
Amit Shah88f251a2009-12-21 22:15:30 +0530987 spin_lock_irq(&port->inbuf_lock);
Amit Shah3c7969c2009-11-26 11:25:38 +0530988 port->guest_connected = false;
989
Amit Shah88f251a2009-12-21 22:15:30 +0530990 discard_port_data(port);
991
992 spin_unlock_irq(&port->inbuf_lock);
993
Amit Shahcdfadfc2010-05-19 22:15:50 -0600994 spin_lock_irq(&port->outvq_lock);
995 reclaim_consumed_buffers(port);
996 spin_unlock_irq(&port->outvq_lock);
997
Sjur Brændeland1b637042012-12-14 14:40:51 +1030998 reclaim_dma_bufs();
Amit Shahb353a6b2010-09-02 18:38:29 +0530999 /*
1000 * Locks aren't necessary here as a port can't be opened after
1001 * unplug, and if a port isn't unplugged, a kref would already
1002 * exist for the port. Plus, taking ports_lock here would
1003 * create a dependency on other locks taken by functions
1004 * inside remove_port if we're the last holder of the port,
1005 * creating many problems.
1006 */
1007 kref_put(&port->kref, remove_port);
1008
Amit Shah2030fa42009-12-21 21:49:30 +05301009 return 0;
1010}
1011
1012static int port_fops_open(struct inode *inode, struct file *filp)
1013{
1014 struct cdev *cdev = inode->i_cdev;
1015 struct port *port;
Amit Shah8ad37e82010-09-02 18:11:48 +05301016 int ret;
Amit Shah2030fa42009-12-21 21:49:30 +05301017
Amit Shah04950cd2010-09-02 18:20:58 +05301018 port = find_port_by_devt(cdev->dev);
Amit Shah2030fa42009-12-21 21:49:30 +05301019 filp->private_data = port;
1020
Amit Shahb353a6b2010-09-02 18:38:29 +05301021 /* Prevent against a port getting hot-unplugged at the same time */
1022 spin_lock_irq(&port->portdev->ports_lock);
1023 kref_get(&port->kref);
1024 spin_unlock_irq(&port->portdev->ports_lock);
1025
Amit Shah2030fa42009-12-21 21:49:30 +05301026 /*
1027 * Don't allow opening of console port devices -- that's done
1028 * via /dev/hvc
1029 */
Amit Shah8ad37e82010-09-02 18:11:48 +05301030 if (is_console_port(port)) {
1031 ret = -ENXIO;
1032 goto out;
1033 }
Amit Shah2030fa42009-12-21 21:49:30 +05301034
Amit Shah3c7969c2009-11-26 11:25:38 +05301035 /* Allow only one process to open a particular port at a time */
1036 spin_lock_irq(&port->inbuf_lock);
1037 if (port->guest_connected) {
1038 spin_unlock_irq(&port->inbuf_lock);
Amit Shah8ad37e82010-09-02 18:11:48 +05301039 ret = -EMFILE;
1040 goto out;
Amit Shah3c7969c2009-11-26 11:25:38 +05301041 }
1042
1043 port->guest_connected = true;
1044 spin_unlock_irq(&port->inbuf_lock);
1045
Amit Shahcdfadfc2010-05-19 22:15:50 -06001046 spin_lock_irq(&port->outvq_lock);
1047 /*
1048 * There might be a chance that we missed reclaiming a few
1049 * buffers in the window of the port getting previously closed
1050 * and opening now.
1051 */
1052 reclaim_consumed_buffers(port);
1053 spin_unlock_irq(&port->outvq_lock);
1054
Amit Shah299fb612010-09-16 14:43:09 +05301055 nonseekable_open(inode, filp);
1056
Amit Shah2030fa42009-12-21 21:49:30 +05301057 /* Notify host of port being opened */
1058 send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1);
1059
1060 return 0;
Amit Shah8ad37e82010-09-02 18:11:48 +05301061out:
Amit Shahb353a6b2010-09-02 18:38:29 +05301062 kref_put(&port->kref, remove_port);
Amit Shah8ad37e82010-09-02 18:11:48 +05301063 return ret;
Amit Shah2030fa42009-12-21 21:49:30 +05301064}
1065
Amit Shah3eae0ad2010-09-02 18:47:52 +05301066static int port_fops_fasync(int fd, struct file *filp, int mode)
1067{
1068 struct port *port;
1069
1070 port = filp->private_data;
1071 return fasync_helper(fd, filp, mode, &port->async_queue);
1072}
1073
Amit Shah2030fa42009-12-21 21:49:30 +05301074/*
1075 * The file operations that we support: programs in the guest can open
1076 * a console device, read from it, write to it, poll for data and
1077 * close it. The devices are at
1078 * /dev/vport<device number>p<port number>
1079 */
1080static const struct file_operations port_fops = {
1081 .owner = THIS_MODULE,
1082 .open = port_fops_open,
1083 .read = port_fops_read,
1084 .write = port_fops_write,
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +09001085 .splice_write = port_fops_splice_write,
Amit Shah2030fa42009-12-21 21:49:30 +05301086 .poll = port_fops_poll,
1087 .release = port_fops_release,
Amit Shah3eae0ad2010-09-02 18:47:52 +05301088 .fasync = port_fops_fasync,
Amit Shah299fb612010-09-16 14:43:09 +05301089 .llseek = no_llseek,
Amit Shah2030fa42009-12-21 21:49:30 +05301090};
1091
Amit Shahe27b5192010-01-18 19:15:02 +05301092/*
Rusty Russella23ea922010-01-18 19:14:55 +05301093 * The put_chars() callback is pretty straightforward.
Rusty Russell31610432007-10-22 11:03:39 +10001094 *
Rusty Russella23ea922010-01-18 19:14:55 +05301095 * We turn the characters into a scatter-gather list, add it to the
1096 * output queue and then kick the Host. Then we sit here waiting for
1097 * it to finish: inefficient in theory, but in practice
1098 * implementations will do it immediately (lguest's Launcher does).
1099 */
Rusty Russell31610432007-10-22 11:03:39 +10001100static int put_chars(u32 vtermno, const char *buf, int count)
1101{
Rusty Russell21206ed2010-01-18 19:15:00 +05301102 struct port *port;
Sjur Brændeland276a3e92012-12-14 13:46:42 +10301103 struct scatterlist sg[1];
Amit Shah38edf582010-01-18 19:15:05 +05301104
François Diakhaté162a6892010-03-23 18:23:15 +05301105 if (unlikely(early_put_chars))
1106 return early_put_chars(vtermno, buf, count);
1107
Amit Shah38edf582010-01-18 19:15:05 +05301108 port = find_port_by_vtermno(vtermno);
1109 if (!port)
Amit Shah6dc69f972010-05-19 22:15:47 -06001110 return -EPIPE;
Rusty Russell31610432007-10-22 11:03:39 +10001111
Sjur Brændeland276a3e92012-12-14 13:46:42 +10301112 sg_init_one(sg, buf, count);
1113 return __send_to_port(port, sg, 1, count, (void *)buf, false);
Rusty Russell31610432007-10-22 11:03:39 +10001114}
1115
Rusty Russella23ea922010-01-18 19:14:55 +05301116/*
Rusty Russella23ea922010-01-18 19:14:55 +05301117 * get_chars() is the callback from the hvc_console infrastructure
1118 * when an interrupt is received.
Rusty Russell31610432007-10-22 11:03:39 +10001119 *
Amit Shah203baab2010-01-18 19:15:12 +05301120 * We call out to fill_readbuf that gets us the required data from the
1121 * buffers that are queued up.
Rusty Russella23ea922010-01-18 19:14:55 +05301122 */
Rusty Russell31610432007-10-22 11:03:39 +10001123static int get_chars(u32 vtermno, char *buf, int count)
1124{
Rusty Russell21206ed2010-01-18 19:15:00 +05301125 struct port *port;
Rusty Russell31610432007-10-22 11:03:39 +10001126
Amit Shah6dc69f972010-05-19 22:15:47 -06001127 /* If we've not set up the port yet, we have no input to give. */
1128 if (unlikely(early_put_chars))
1129 return 0;
1130
Amit Shah38edf582010-01-18 19:15:05 +05301131 port = find_port_by_vtermno(vtermno);
1132 if (!port)
Amit Shah6dc69f972010-05-19 22:15:47 -06001133 return -EPIPE;
Rusty Russell21206ed2010-01-18 19:15:00 +05301134
1135 /* If we don't have an input queue yet, we can't get input. */
1136 BUG_ON(!port->in_vq);
1137
Amit Shahb766cee2009-12-21 21:26:45 +05301138 return fill_readbuf(port, buf, count, false);
Rusty Russell31610432007-10-22 11:03:39 +10001139}
Rusty Russell31610432007-10-22 11:03:39 +10001140
Amit Shahcb06e362010-01-18 19:15:08 +05301141static void resize_console(struct port *port)
Christian Borntraegerc2983452008-11-25 13:36:26 +01001142{
Amit Shahcb06e362010-01-18 19:15:08 +05301143 struct virtio_device *vdev;
Christian Borntraegerc2983452008-11-25 13:36:26 +01001144
Amit Shah2de16a42010-03-19 17:36:44 +05301145 /* The port could have been hot-unplugged */
Amit Shah97788292010-05-06 02:05:08 +05301146 if (!port || !is_console_port(port))
Amit Shah2de16a42010-03-19 17:36:44 +05301147 return;
1148
Amit Shahcb06e362010-01-18 19:15:08 +05301149 vdev = port->portdev->vdev;
Sjur Brændeland1b637042012-12-14 14:40:51 +10301150
1151 /* Don't test F_SIZE at all if we're rproc: not a valid feature! */
1152 if (!is_rproc_serial(vdev) &&
1153 virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE))
Amit Shah97788292010-05-06 02:05:08 +05301154 hvc_resize(port->cons.hvc, port->cons.ws);
Christian Borntraegerc2983452008-11-25 13:36:26 +01001155}
1156
Amit Shah38edf582010-01-18 19:15:05 +05301157/* We set the configuration at this point, since we now have a tty */
Christian Borntraeger91fcad12008-06-20 15:24:15 +02001158static int notifier_add_vio(struct hvc_struct *hp, int data)
1159{
Amit Shah38edf582010-01-18 19:15:05 +05301160 struct port *port;
1161
1162 port = find_port_by_vtermno(hp->vtermno);
1163 if (!port)
1164 return -EINVAL;
1165
Christian Borntraeger91fcad12008-06-20 15:24:15 +02001166 hp->irq_requested = 1;
Amit Shahcb06e362010-01-18 19:15:08 +05301167 resize_console(port);
Christian Borntraegerc2983452008-11-25 13:36:26 +01001168
Christian Borntraeger91fcad12008-06-20 15:24:15 +02001169 return 0;
1170}
1171
1172static void notifier_del_vio(struct hvc_struct *hp, int data)
1173{
1174 hp->irq_requested = 0;
1175}
1176
Amit Shah17634ba2009-12-21 21:03:25 +05301177/* The operations for console ports. */
Rusty Russell1dff3992009-11-28 12:20:26 +05301178static const struct hv_ops hv_ops = {
Rusty Russell971f3392010-01-18 19:14:56 +05301179 .get_chars = get_chars,
1180 .put_chars = put_chars,
1181 .notifier_add = notifier_add_vio,
1182 .notifier_del = notifier_del_vio,
1183 .notifier_hangup = notifier_del_vio,
1184};
1185
1186/*
1187 * Console drivers are initialized very early so boot messages can go
1188 * out, so we do things slightly differently from the generic virtio
1189 * initialization of the net and block drivers.
1190 *
1191 * At this stage, the console is output-only. It's too early to set
1192 * up a virtqueue, so we let the drivers do some boutique early-output
1193 * thing.
1194 */
1195int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int))
1196{
1197 early_put_chars = put_chars;
1198 return hvc_instantiate(0, 0, &hv_ops);
1199}
1200
Amit Shah17634ba2009-12-21 21:03:25 +05301201int init_port_console(struct port *port)
Amit Shahcfa6d372010-01-18 19:15:10 +05301202{
1203 int ret;
1204
1205 /*
1206 * The Host's telling us this port is a console port. Hook it
1207 * up with an hvc console.
1208 *
1209 * To set up and manage our virtual console, we call
1210 * hvc_alloc().
1211 *
1212 * The first argument of hvc_alloc() is the virtual console
1213 * number. The second argument is the parameter for the
1214 * notification mechanism (like irq number). We currently
1215 * leave this as zero, virtqueues have implicit notifications.
1216 *
1217 * The third argument is a "struct hv_ops" containing the
1218 * put_chars() get_chars(), notifier_add() and notifier_del()
1219 * pointers. The final argument is the output buffer size: we
1220 * can do any size, so we put PAGE_SIZE here.
1221 */
1222 port->cons.vtermno = pdrvdata.next_vtermno;
1223
1224 port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE);
1225 if (IS_ERR(port->cons.hvc)) {
1226 ret = PTR_ERR(port->cons.hvc);
Amit Shah298add72010-01-18 16:35:23 +05301227 dev_err(port->dev,
1228 "error %d allocating hvc for port\n", ret);
Amit Shahcfa6d372010-01-18 19:15:10 +05301229 port->cons.hvc = NULL;
1230 return ret;
1231 }
1232 spin_lock_irq(&pdrvdata_lock);
1233 pdrvdata.next_vtermno++;
1234 list_add_tail(&port->cons.list, &pdrvdata.consoles);
1235 spin_unlock_irq(&pdrvdata_lock);
Amit Shah3c7969c2009-11-26 11:25:38 +05301236 port->guest_connected = true;
Amit Shahcfa6d372010-01-18 19:15:10 +05301237
Amit Shah1d051602010-05-19 22:15:49 -06001238 /*
1239 * Start using the new console output if this is the first
1240 * console to come up.
1241 */
1242 if (early_put_chars)
1243 early_put_chars = NULL;
1244
Amit Shah2030fa42009-12-21 21:49:30 +05301245 /* Notify host of port being opened */
1246 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
1247
Amit Shahcfa6d372010-01-18 19:15:10 +05301248 return 0;
1249}
1250
Amit Shah431edb82009-12-21 21:57:40 +05301251static ssize_t show_port_name(struct device *dev,
1252 struct device_attribute *attr, char *buffer)
1253{
1254 struct port *port;
1255
1256 port = dev_get_drvdata(dev);
1257
1258 return sprintf(buffer, "%s\n", port->name);
1259}
1260
1261static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL);
1262
1263static struct attribute *port_sysfs_entries[] = {
1264 &dev_attr_name.attr,
1265 NULL
1266};
1267
1268static struct attribute_group port_attribute_group = {
1269 .name = NULL, /* put in device directory */
1270 .attrs = port_sysfs_entries,
1271};
1272
Amit Shahd99393e2009-12-21 22:36:21 +05301273static ssize_t debugfs_read(struct file *filp, char __user *ubuf,
1274 size_t count, loff_t *offp)
1275{
1276 struct port *port;
1277 char *buf;
1278 ssize_t ret, out_offset, out_count;
1279
1280 out_count = 1024;
1281 buf = kmalloc(out_count, GFP_KERNEL);
1282 if (!buf)
1283 return -ENOMEM;
1284
1285 port = filp->private_data;
1286 out_offset = 0;
1287 out_offset += snprintf(buf + out_offset, out_count,
1288 "name: %s\n", port->name ? port->name : "");
1289 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1290 "guest_connected: %d\n", port->guest_connected);
1291 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1292 "host_connected: %d\n", port->host_connected);
1293 out_offset += snprintf(buf + out_offset, out_count - out_offset,
Amit Shahcdfadfc2010-05-19 22:15:50 -06001294 "outvq_full: %d\n", port->outvq_full);
1295 out_offset += snprintf(buf + out_offset, out_count - out_offset,
Amit Shah17e5b4f2011-09-14 13:06:46 +05301296 "bytes_sent: %lu\n", port->stats.bytes_sent);
1297 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1298 "bytes_received: %lu\n",
1299 port->stats.bytes_received);
1300 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1301 "bytes_discarded: %lu\n",
1302 port->stats.bytes_discarded);
1303 out_offset += snprintf(buf + out_offset, out_count - out_offset,
Amit Shahd99393e2009-12-21 22:36:21 +05301304 "is_console: %s\n",
1305 is_console_port(port) ? "yes" : "no");
1306 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1307 "console_vtermno: %u\n", port->cons.vtermno);
1308
1309 ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset);
1310 kfree(buf);
1311 return ret;
1312}
1313
1314static const struct file_operations port_debugfs_ops = {
1315 .owner = THIS_MODULE,
Stephen Boyd234e3402012-04-05 14:25:11 -07001316 .open = simple_open,
Amit Shahd99393e2009-12-21 22:36:21 +05301317 .read = debugfs_read,
1318};
1319
Amit Shah97788292010-05-06 02:05:08 +05301320static void set_console_size(struct port *port, u16 rows, u16 cols)
1321{
1322 if (!port || !is_console_port(port))
1323 return;
1324
1325 port->cons.ws.ws_row = rows;
1326 port->cons.ws.ws_col = cols;
1327}
1328
Amit Shahc446f8f2010-05-19 22:15:48 -06001329static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock)
1330{
1331 struct port_buffer *buf;
1332 unsigned int nr_added_bufs;
1333 int ret;
1334
1335 nr_added_bufs = 0;
1336 do {
Sjur Brændeland276a3e92012-12-14 13:46:42 +10301337 buf = alloc_buf(vq, PAGE_SIZE, 0);
Amit Shahc446f8f2010-05-19 22:15:48 -06001338 if (!buf)
1339 break;
1340
1341 spin_lock_irq(lock);
1342 ret = add_inbuf(vq, buf);
1343 if (ret < 0) {
1344 spin_unlock_irq(lock);
Sjur Brændeland1b637042012-12-14 14:40:51 +10301345 free_buf(buf, true);
Amit Shahc446f8f2010-05-19 22:15:48 -06001346 break;
1347 }
1348 nr_added_bufs++;
1349 spin_unlock_irq(lock);
1350 } while (ret > 0);
1351
1352 return nr_added_bufs;
1353}
1354
Amit Shah3eae0ad2010-09-02 18:47:52 +05301355static void send_sigio_to_port(struct port *port)
1356{
1357 if (port->async_queue && port->guest_connected)
1358 kill_fasync(&port->async_queue, SIGIO, POLL_OUT);
1359}
1360
Amit Shahc446f8f2010-05-19 22:15:48 -06001361static int add_port(struct ports_device *portdev, u32 id)
1362{
1363 char debugfs_name[16];
1364 struct port *port;
1365 struct port_buffer *buf;
1366 dev_t devt;
1367 unsigned int nr_added_bufs;
1368 int err;
1369
1370 port = kmalloc(sizeof(*port), GFP_KERNEL);
1371 if (!port) {
1372 err = -ENOMEM;
1373 goto fail;
1374 }
Amit Shahb353a6b2010-09-02 18:38:29 +05301375 kref_init(&port->kref);
Amit Shahc446f8f2010-05-19 22:15:48 -06001376
1377 port->portdev = portdev;
1378 port->id = id;
1379
1380 port->name = NULL;
1381 port->inbuf = NULL;
1382 port->cons.hvc = NULL;
Amit Shah3eae0ad2010-09-02 18:47:52 +05301383 port->async_queue = NULL;
Amit Shahc446f8f2010-05-19 22:15:48 -06001384
Amit Shah97788292010-05-06 02:05:08 +05301385 port->cons.ws.ws_row = port->cons.ws.ws_col = 0;
1386
Amit Shahc446f8f2010-05-19 22:15:48 -06001387 port->host_connected = port->guest_connected = false;
Amit Shah17e5b4f2011-09-14 13:06:46 +05301388 port->stats = (struct port_stats) { 0 };
Amit Shahc446f8f2010-05-19 22:15:48 -06001389
Amit Shahcdfadfc2010-05-19 22:15:50 -06001390 port->outvq_full = false;
1391
Amit Shahc446f8f2010-05-19 22:15:48 -06001392 port->in_vq = portdev->in_vqs[port->id];
1393 port->out_vq = portdev->out_vqs[port->id];
1394
Amit Shahd22a6982010-09-02 18:20:59 +05301395 port->cdev = cdev_alloc();
1396 if (!port->cdev) {
1397 dev_err(&port->portdev->vdev->dev, "Error allocating cdev\n");
1398 err = -ENOMEM;
1399 goto free_port;
1400 }
1401 port->cdev->ops = &port_fops;
Amit Shahc446f8f2010-05-19 22:15:48 -06001402
1403 devt = MKDEV(portdev->chr_major, id);
Amit Shahd22a6982010-09-02 18:20:59 +05301404 err = cdev_add(port->cdev, devt, 1);
Amit Shahc446f8f2010-05-19 22:15:48 -06001405 if (err < 0) {
1406 dev_err(&port->portdev->vdev->dev,
1407 "Error %d adding cdev for port %u\n", err, id);
Amit Shahd22a6982010-09-02 18:20:59 +05301408 goto free_cdev;
Amit Shahc446f8f2010-05-19 22:15:48 -06001409 }
1410 port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev,
1411 devt, port, "vport%up%u",
Sjur Brændelanddc18f082013-02-12 16:24:59 +10301412 port->portdev->vdev->index, id);
Amit Shahc446f8f2010-05-19 22:15:48 -06001413 if (IS_ERR(port->dev)) {
1414 err = PTR_ERR(port->dev);
1415 dev_err(&port->portdev->vdev->dev,
1416 "Error %d creating device for port %u\n",
1417 err, id);
1418 goto free_cdev;
1419 }
1420
1421 spin_lock_init(&port->inbuf_lock);
Amit Shahcdfadfc2010-05-19 22:15:50 -06001422 spin_lock_init(&port->outvq_lock);
Amit Shahc446f8f2010-05-19 22:15:48 -06001423 init_waitqueue_head(&port->waitqueue);
1424
1425 /* Fill the in_vq with buffers so the host can send us data. */
1426 nr_added_bufs = fill_queue(port->in_vq, &port->inbuf_lock);
1427 if (!nr_added_bufs) {
1428 dev_err(port->dev, "Error allocating inbufs\n");
1429 err = -ENOMEM;
1430 goto free_device;
1431 }
1432
Sjur Brændeland1b637042012-12-14 14:40:51 +10301433 if (is_rproc_serial(port->portdev->vdev))
1434 /*
1435 * For rproc_serial assume remote processor is connected.
1436 * rproc_serial does not want the console port, only
1437 * the generic port implementation.
1438 */
Sjur Brændeland8078db72013-02-13 20:57:21 +10301439 port->host_connected = port->guest_connected = true;
Sjur Brændeland1b637042012-12-14 14:40:51 +10301440 else if (!use_multiport(port->portdev)) {
1441 /*
1442 * If we're not using multiport support,
1443 * this has to be a console port.
1444 */
Amit Shahc446f8f2010-05-19 22:15:48 -06001445 err = init_port_console(port);
1446 if (err)
1447 goto free_inbufs;
1448 }
1449
1450 spin_lock_irq(&portdev->ports_lock);
1451 list_add_tail(&port->list, &port->portdev->ports);
1452 spin_unlock_irq(&portdev->ports_lock);
1453
1454 /*
1455 * Tell the Host we're set so that it can send us various
1456 * configuration parameters for this port (eg, port name,
1457 * caching, whether this is a console port, etc.)
1458 */
1459 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1460
1461 if (pdrvdata.debugfs_dir) {
1462 /*
1463 * Finally, create the debugfs file that we can use to
1464 * inspect a port's state at any time
1465 */
1466 sprintf(debugfs_name, "vport%up%u",
Sjur Brændelanddc18f082013-02-12 16:24:59 +10301467 port->portdev->vdev->index, id);
Amit Shahc446f8f2010-05-19 22:15:48 -06001468 port->debugfs_file = debugfs_create_file(debugfs_name, 0444,
1469 pdrvdata.debugfs_dir,
1470 port,
1471 &port_debugfs_ops);
1472 }
1473 return 0;
1474
1475free_inbufs:
1476 while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301477 free_buf(buf, true);
Amit Shahc446f8f2010-05-19 22:15:48 -06001478free_device:
1479 device_destroy(pdrvdata.class, port->dev->devt);
1480free_cdev:
Amit Shahd22a6982010-09-02 18:20:59 +05301481 cdev_del(port->cdev);
Amit Shahc446f8f2010-05-19 22:15:48 -06001482free_port:
1483 kfree(port);
1484fail:
1485 /* The host might want to notify management sw about port add failure */
Julia Lawall0643e4c2010-05-15 11:45:53 +02001486 __send_control_msg(portdev, id, VIRTIO_CONSOLE_PORT_READY, 0);
Amit Shahc446f8f2010-05-19 22:15:48 -06001487 return err;
1488}
1489
Amit Shahb353a6b2010-09-02 18:38:29 +05301490/* No users remain, remove all port-specific data. */
1491static void remove_port(struct kref *kref)
1492{
1493 struct port *port;
1494
1495 port = container_of(kref, struct port, kref);
1496
1497 sysfs_remove_group(&port->dev->kobj, &port_attribute_group);
1498 device_destroy(pdrvdata.class, port->dev->devt);
1499 cdev_del(port->cdev);
1500
1501 kfree(port->name);
1502
1503 debugfs_remove(port->debugfs_file);
1504
1505 kfree(port);
1506}
1507
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301508static void remove_port_data(struct port *port)
1509{
1510 struct port_buffer *buf;
1511
1512 /* Remove unused data this port might have received. */
1513 discard_port_data(port);
1514
1515 reclaim_consumed_buffers(port);
1516
1517 /* Remove buffers we queued up for the Host to send us data in. */
1518 while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301519 free_buf(buf, true);
sjur.brandeland@stericsson.comeb34f122012-11-16 11:20:19 +10301520
1521 /* Free pending buffers from the out-queue. */
1522 while ((buf = virtqueue_detach_unused_buf(port->out_vq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301523 free_buf(buf, true);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301524}
1525
Amit Shahb353a6b2010-09-02 18:38:29 +05301526/*
1527 * Port got unplugged. Remove port from portdev's list and drop the
1528 * kref reference. If no userspace has this port opened, it will
1529 * result in immediate removal the port.
1530 */
1531static void unplug_port(struct port *port)
Amit Shah1f7aa422009-12-21 22:27:31 +05301532{
Amit Shahb353a6b2010-09-02 18:38:29 +05301533 spin_lock_irq(&port->portdev->ports_lock);
1534 list_del(&port->list);
1535 spin_unlock_irq(&port->portdev->ports_lock);
1536
Amit Shah00476342010-05-27 13:24:39 +05301537 if (port->guest_connected) {
1538 port->guest_connected = false;
1539 port->host_connected = false;
1540 wake_up_interruptible(&port->waitqueue);
Amit Shaha461e112010-09-02 18:47:54 +05301541
1542 /* Let the app know the port is going down. */
1543 send_sigio_to_port(port);
Amit Shah00476342010-05-27 13:24:39 +05301544 }
1545
Amit Shah1f7aa422009-12-21 22:27:31 +05301546 if (is_console_port(port)) {
1547 spin_lock_irq(&pdrvdata_lock);
1548 list_del(&port->cons.list);
1549 spin_unlock_irq(&pdrvdata_lock);
1550 hvc_remove(port->cons.hvc);
1551 }
Amit Shah1f7aa422009-12-21 22:27:31 +05301552
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301553 remove_port_data(port);
Amit Shaha9cdd482010-02-12 10:32:15 +05301554
Amit Shahb353a6b2010-09-02 18:38:29 +05301555 /*
1556 * We should just assume the device itself has gone off --
1557 * else a close on an open port later will try to send out a
1558 * control message.
1559 */
1560 port->portdev = NULL;
Amit Shah1f7aa422009-12-21 22:27:31 +05301561
Amit Shahb353a6b2010-09-02 18:38:29 +05301562 /*
1563 * Locks around here are not necessary - a port can't be
1564 * opened after we removed the port struct from ports_list
1565 * above.
1566 */
1567 kref_put(&port->kref, remove_port);
Amit Shah1f7aa422009-12-21 22:27:31 +05301568}
1569
Amit Shah17634ba2009-12-21 21:03:25 +05301570/* Any private messages that the Host and Guest want to share */
1571static void handle_control_message(struct ports_device *portdev,
1572 struct port_buffer *buf)
1573{
1574 struct virtio_console_control *cpkt;
1575 struct port *port;
Amit Shah431edb82009-12-21 21:57:40 +05301576 size_t name_size;
1577 int err;
Amit Shah17634ba2009-12-21 21:03:25 +05301578
1579 cpkt = (struct virtio_console_control *)(buf->buf + buf->offset);
1580
1581 port = find_port_by_id(portdev, cpkt->id);
Amit Shahf909f852010-05-19 22:15:48 -06001582 if (!port && cpkt->event != VIRTIO_CONSOLE_PORT_ADD) {
Amit Shah17634ba2009-12-21 21:03:25 +05301583 /* No valid header at start of buffer. Drop it. */
1584 dev_dbg(&portdev->vdev->dev,
1585 "Invalid index %u in control packet\n", cpkt->id);
1586 return;
1587 }
1588
1589 switch (cpkt->event) {
Amit Shahf909f852010-05-19 22:15:48 -06001590 case VIRTIO_CONSOLE_PORT_ADD:
1591 if (port) {
Amit Shah1d051602010-05-19 22:15:49 -06001592 dev_dbg(&portdev->vdev->dev,
1593 "Port %u already added\n", port->id);
Amit Shahf909f852010-05-19 22:15:48 -06001594 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1595 break;
1596 }
1597 if (cpkt->id >= portdev->config.max_nr_ports) {
1598 dev_warn(&portdev->vdev->dev,
1599 "Request for adding port with out-of-bound id %u, max. supported id: %u\n",
1600 cpkt->id, portdev->config.max_nr_ports - 1);
1601 break;
1602 }
1603 add_port(portdev, cpkt->id);
1604 break;
1605 case VIRTIO_CONSOLE_PORT_REMOVE:
Amit Shahb353a6b2010-09-02 18:38:29 +05301606 unplug_port(port);
Amit Shahf909f852010-05-19 22:15:48 -06001607 break;
Amit Shah17634ba2009-12-21 21:03:25 +05301608 case VIRTIO_CONSOLE_CONSOLE_PORT:
1609 if (!cpkt->value)
1610 break;
1611 if (is_console_port(port))
1612 break;
1613
1614 init_port_console(port);
Christian Borntraeger5e384832011-09-22 23:44:23 +05301615 complete(&early_console_added);
Amit Shah17634ba2009-12-21 21:03:25 +05301616 /*
1617 * Could remove the port here in case init fails - but
1618 * have to notify the host first.
1619 */
1620 break;
Amit Shah8345adb2010-05-06 02:05:09 +05301621 case VIRTIO_CONSOLE_RESIZE: {
1622 struct {
1623 __u16 rows;
1624 __u16 cols;
1625 } size;
1626
Amit Shah17634ba2009-12-21 21:03:25 +05301627 if (!is_console_port(port))
1628 break;
Amit Shah8345adb2010-05-06 02:05:09 +05301629
1630 memcpy(&size, buf->buf + buf->offset + sizeof(*cpkt),
1631 sizeof(size));
1632 set_console_size(port, size.rows, size.cols);
1633
Amit Shah17634ba2009-12-21 21:03:25 +05301634 port->cons.hvc->irq_requested = 1;
1635 resize_console(port);
1636 break;
Amit Shah8345adb2010-05-06 02:05:09 +05301637 }
Amit Shah2030fa42009-12-21 21:49:30 +05301638 case VIRTIO_CONSOLE_PORT_OPEN:
1639 port->host_connected = cpkt->value;
1640 wake_up_interruptible(&port->waitqueue);
Amit Shahcdfadfc2010-05-19 22:15:50 -06001641 /*
1642 * If the host port got closed and the host had any
1643 * unconsumed buffers, we'll be able to reclaim them
1644 * now.
1645 */
1646 spin_lock_irq(&port->outvq_lock);
1647 reclaim_consumed_buffers(port);
1648 spin_unlock_irq(&port->outvq_lock);
Amit Shah3eae0ad2010-09-02 18:47:52 +05301649
1650 /*
1651 * If the guest is connected, it'll be interested in
1652 * knowing the host connection state changed.
1653 */
1654 send_sigio_to_port(port);
Amit Shah2030fa42009-12-21 21:49:30 +05301655 break;
Amit Shah431edb82009-12-21 21:57:40 +05301656 case VIRTIO_CONSOLE_PORT_NAME:
1657 /*
Amit Shah291024e2011-09-14 13:06:40 +05301658 * If we woke up after hibernation, we can get this
1659 * again. Skip it in that case.
1660 */
1661 if (port->name)
1662 break;
1663
1664 /*
Amit Shah431edb82009-12-21 21:57:40 +05301665 * Skip the size of the header and the cpkt to get the size
1666 * of the name that was sent
1667 */
1668 name_size = buf->len - buf->offset - sizeof(*cpkt) + 1;
1669
1670 port->name = kmalloc(name_size, GFP_KERNEL);
1671 if (!port->name) {
1672 dev_err(port->dev,
1673 "Not enough space to store port name\n");
1674 break;
1675 }
1676 strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt),
1677 name_size - 1);
1678 port->name[name_size - 1] = 0;
1679
1680 /*
1681 * Since we only have one sysfs attribute, 'name',
1682 * create it only if we have a name for the port.
1683 */
1684 err = sysfs_create_group(&port->dev->kobj,
1685 &port_attribute_group);
Amit Shahec642132010-03-19 17:36:43 +05301686 if (err) {
Amit Shah431edb82009-12-21 21:57:40 +05301687 dev_err(port->dev,
1688 "Error %d creating sysfs device attributes\n",
1689 err);
Amit Shahec642132010-03-19 17:36:43 +05301690 } else {
1691 /*
1692 * Generate a udev event so that appropriate
1693 * symlinks can be created based on udev
1694 * rules.
1695 */
1696 kobject_uevent(&port->dev->kobj, KOBJ_CHANGE);
1697 }
Amit Shah431edb82009-12-21 21:57:40 +05301698 break;
Amit Shah17634ba2009-12-21 21:03:25 +05301699 }
1700}
1701
1702static void control_work_handler(struct work_struct *work)
1703{
1704 struct ports_device *portdev;
1705 struct virtqueue *vq;
1706 struct port_buffer *buf;
1707 unsigned int len;
1708
1709 portdev = container_of(work, struct ports_device, control_work);
1710 vq = portdev->c_ivq;
1711
1712 spin_lock(&portdev->cvq_lock);
Michael S. Tsirkin505b0452010-04-12 16:18:32 +03001713 while ((buf = virtqueue_get_buf(vq, &len))) {
Amit Shah17634ba2009-12-21 21:03:25 +05301714 spin_unlock(&portdev->cvq_lock);
1715
1716 buf->len = len;
1717 buf->offset = 0;
1718
1719 handle_control_message(portdev, buf);
1720
1721 spin_lock(&portdev->cvq_lock);
1722 if (add_inbuf(portdev->c_ivq, buf) < 0) {
1723 dev_warn(&portdev->vdev->dev,
1724 "Error adding buffer to queue\n");
Sjur Brændeland1b637042012-12-14 14:40:51 +10301725 free_buf(buf, false);
Amit Shah17634ba2009-12-21 21:03:25 +05301726 }
1727 }
1728 spin_unlock(&portdev->cvq_lock);
1729}
1730
Amit Shah2770c5e2011-01-31 13:06:36 +05301731static void out_intr(struct virtqueue *vq)
1732{
1733 struct port *port;
1734
1735 port = find_port_by_vq(vq->vdev->priv, vq);
1736 if (!port)
1737 return;
1738
1739 wake_up_interruptible(&port->waitqueue);
1740}
1741
Amit Shah17634ba2009-12-21 21:03:25 +05301742static void in_intr(struct virtqueue *vq)
1743{
1744 struct port *port;
1745 unsigned long flags;
1746
1747 port = find_port_by_vq(vq->vdev->priv, vq);
1748 if (!port)
1749 return;
1750
1751 spin_lock_irqsave(&port->inbuf_lock, flags);
Amit Shahd25a9dd2011-09-14 13:06:43 +05301752 port->inbuf = get_inbuf(port);
Amit Shah17634ba2009-12-21 21:03:25 +05301753
Amit Shah88f251a2009-12-21 22:15:30 +05301754 /*
1755 * Don't queue up data when port is closed. This condition
1756 * can be reached when a console port is not yet connected (no
1757 * tty is spawned) and the host sends out data to console
1758 * ports. For generic serial ports, the host won't
1759 * (shouldn't) send data till the guest is connected.
1760 */
1761 if (!port->guest_connected)
1762 discard_port_data(port);
1763
Amit Shah17634ba2009-12-21 21:03:25 +05301764 spin_unlock_irqrestore(&port->inbuf_lock, flags);
1765
Amit Shah2030fa42009-12-21 21:49:30 +05301766 wake_up_interruptible(&port->waitqueue);
1767
Amit Shah55f6bcc2010-09-02 18:47:53 +05301768 /* Send a SIGIO indicating new data in case the process asked for it */
1769 send_sigio_to_port(port);
1770
Amit Shah17634ba2009-12-21 21:03:25 +05301771 if (is_console_port(port) && hvc_poll(port->cons.hvc))
1772 hvc_kick();
1773}
1774
1775static void control_intr(struct virtqueue *vq)
1776{
1777 struct ports_device *portdev;
1778
1779 portdev = vq->vdev->priv;
1780 schedule_work(&portdev->control_work);
1781}
1782
Amit Shah7f5d8102009-12-21 22:22:08 +05301783static void config_intr(struct virtio_device *vdev)
1784{
1785 struct ports_device *portdev;
1786
1787 portdev = vdev->priv;
Amit Shah99f905f2010-05-19 22:15:48 -06001788
Amit Shah4038f5b72010-05-06 02:05:07 +05301789 if (!use_multiport(portdev)) {
Amit Shah97788292010-05-06 02:05:08 +05301790 struct port *port;
1791 u16 rows, cols;
1792
1793 vdev->config->get(vdev,
1794 offsetof(struct virtio_console_config, cols),
1795 &cols, sizeof(u16));
1796 vdev->config->get(vdev,
1797 offsetof(struct virtio_console_config, rows),
1798 &rows, sizeof(u16));
1799
1800 port = find_port_by_id(portdev, 0);
1801 set_console_size(port, rows, cols);
1802
Amit Shah4038f5b72010-05-06 02:05:07 +05301803 /*
1804 * We'll use this way of resizing only for legacy
1805 * support. For newer userspace
1806 * (VIRTIO_CONSOLE_F_MULTPORT+), use control messages
1807 * to indicate console size changes so that it can be
1808 * done per-port.
1809 */
Amit Shah97788292010-05-06 02:05:08 +05301810 resize_console(port);
Amit Shah4038f5b72010-05-06 02:05:07 +05301811 }
Amit Shah7f5d8102009-12-21 22:22:08 +05301812}
1813
Amit Shah2658a79a2010-01-18 19:15:11 +05301814static int init_vqs(struct ports_device *portdev)
1815{
1816 vq_callback_t **io_callbacks;
1817 char **io_names;
1818 struct virtqueue **vqs;
Amit Shah17634ba2009-12-21 21:03:25 +05301819 u32 i, j, nr_ports, nr_queues;
Amit Shah2658a79a2010-01-18 19:15:11 +05301820 int err;
1821
Amit Shah17634ba2009-12-21 21:03:25 +05301822 nr_ports = portdev->config.max_nr_ports;
1823 nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2;
Amit Shah2658a79a2010-01-18 19:15:11 +05301824
1825 vqs = kmalloc(nr_queues * sizeof(struct virtqueue *), GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301826 io_callbacks = kmalloc(nr_queues * sizeof(vq_callback_t *), GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301827 io_names = kmalloc(nr_queues * sizeof(char *), GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301828 portdev->in_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
1829 GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301830 portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
1831 GFP_KERNEL);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001832 if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs ||
Amit Shah286f9a22011-09-14 13:06:39 +05301833 !portdev->out_vqs) {
Amit Shah2658a79a2010-01-18 19:15:11 +05301834 err = -ENOMEM;
Jiri Slaby22e132f2010-11-06 10:06:50 +01001835 goto free;
Amit Shah2658a79a2010-01-18 19:15:11 +05301836 }
1837
Amit Shah17634ba2009-12-21 21:03:25 +05301838 /*
1839 * For backward compat (newer host but older guest), the host
1840 * spawns a console port first and also inits the vqs for port
1841 * 0 before others.
1842 */
1843 j = 0;
1844 io_callbacks[j] = in_intr;
Amit Shah2770c5e2011-01-31 13:06:36 +05301845 io_callbacks[j + 1] = out_intr;
Amit Shah17634ba2009-12-21 21:03:25 +05301846 io_names[j] = "input";
1847 io_names[j + 1] = "output";
1848 j += 2;
Amit Shah2658a79a2010-01-18 19:15:11 +05301849
Amit Shah17634ba2009-12-21 21:03:25 +05301850 if (use_multiport(portdev)) {
1851 io_callbacks[j] = control_intr;
1852 io_callbacks[j + 1] = NULL;
1853 io_names[j] = "control-i";
1854 io_names[j + 1] = "control-o";
1855
1856 for (i = 1; i < nr_ports; i++) {
1857 j += 2;
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 }
1863 }
Amit Shah2658a79a2010-01-18 19:15:11 +05301864 /* Find the queues. */
1865 err = portdev->vdev->config->find_vqs(portdev->vdev, nr_queues, vqs,
1866 io_callbacks,
1867 (const char **)io_names);
1868 if (err)
Jiri Slaby22e132f2010-11-06 10:06:50 +01001869 goto free;
Amit Shah2658a79a2010-01-18 19:15:11 +05301870
Amit Shah17634ba2009-12-21 21:03:25 +05301871 j = 0;
Amit Shah2658a79a2010-01-18 19:15:11 +05301872 portdev->in_vqs[0] = vqs[0];
1873 portdev->out_vqs[0] = vqs[1];
Amit Shah17634ba2009-12-21 21:03:25 +05301874 j += 2;
1875 if (use_multiport(portdev)) {
1876 portdev->c_ivq = vqs[j];
1877 portdev->c_ovq = vqs[j + 1];
Amit Shah2658a79a2010-01-18 19:15:11 +05301878
Amit Shah17634ba2009-12-21 21:03:25 +05301879 for (i = 1; i < nr_ports; i++) {
1880 j += 2;
1881 portdev->in_vqs[i] = vqs[j];
1882 portdev->out_vqs[i] = vqs[j + 1];
1883 }
1884 }
Amit Shah2658a79a2010-01-18 19:15:11 +05301885 kfree(io_names);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001886 kfree(io_callbacks);
Amit Shah2658a79a2010-01-18 19:15:11 +05301887 kfree(vqs);
1888
1889 return 0;
1890
Jiri Slaby22e132f2010-11-06 10:06:50 +01001891free:
Amit Shah2658a79a2010-01-18 19:15:11 +05301892 kfree(portdev->out_vqs);
Amit Shah2658a79a2010-01-18 19:15:11 +05301893 kfree(portdev->in_vqs);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001894 kfree(io_names);
1895 kfree(io_callbacks);
Amit Shah2658a79a2010-01-18 19:15:11 +05301896 kfree(vqs);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001897
Amit Shah2658a79a2010-01-18 19:15:11 +05301898 return err;
1899}
1900
Amit Shahfb08bd22009-12-21 21:36:04 +05301901static const struct file_operations portdev_fops = {
1902 .owner = THIS_MODULE,
1903};
1904
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301905static void remove_vqs(struct ports_device *portdev)
1906{
1907 portdev->vdev->config->del_vqs(portdev->vdev);
1908 kfree(portdev->in_vqs);
1909 kfree(portdev->out_vqs);
1910}
1911
1912static void remove_controlq_data(struct ports_device *portdev)
1913{
1914 struct port_buffer *buf;
1915 unsigned int len;
1916
1917 if (!use_multiport(portdev))
1918 return;
1919
1920 while ((buf = virtqueue_get_buf(portdev->c_ivq, &len)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301921 free_buf(buf, true);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301922
1923 while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301924 free_buf(buf, true);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301925}
1926
Amit Shah1c85bf32010-01-18 19:15:07 +05301927/*
1928 * Once we're further in boot, we get probed like any other virtio
1929 * device.
Amit Shah17634ba2009-12-21 21:03:25 +05301930 *
1931 * If the host also supports multiple console ports, we check the
1932 * config space to see how many ports the host has spawned. We
1933 * initialize each port found.
Amit Shah1c85bf32010-01-18 19:15:07 +05301934 */
Bill Pemberton2223cbe2012-11-19 13:22:51 -05001935static int virtcons_probe(struct virtio_device *vdev)
Amit Shah1c85bf32010-01-18 19:15:07 +05301936{
Amit Shah1c85bf32010-01-18 19:15:07 +05301937 struct ports_device *portdev;
1938 int err;
Amit Shah17634ba2009-12-21 21:03:25 +05301939 bool multiport;
Christian Borntraeger5e384832011-09-22 23:44:23 +05301940 bool early = early_put_chars != NULL;
1941
1942 /* Ensure to read early_put_chars now */
1943 barrier();
Amit Shah1c85bf32010-01-18 19:15:07 +05301944
1945 portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
1946 if (!portdev) {
1947 err = -ENOMEM;
1948 goto fail;
1949 }
1950
1951 /* Attach this portdev to this virtio_device, and vice-versa. */
1952 portdev->vdev = vdev;
1953 vdev->priv = portdev;
1954
Amit Shahfb08bd22009-12-21 21:36:04 +05301955 portdev->chr_major = register_chrdev(0, "virtio-portsdev",
1956 &portdev_fops);
1957 if (portdev->chr_major < 0) {
1958 dev_err(&vdev->dev,
1959 "Error %d registering chrdev for device %u\n",
Sjur Brændelanddc18f082013-02-12 16:24:59 +10301960 portdev->chr_major, vdev->index);
Amit Shahfb08bd22009-12-21 21:36:04 +05301961 err = portdev->chr_major;
1962 goto free;
1963 }
1964
Amit Shah17634ba2009-12-21 21:03:25 +05301965 multiport = false;
Amit Shah17634ba2009-12-21 21:03:25 +05301966 portdev->config.max_nr_ports = 1;
Sjur Brændeland1b637042012-12-14 14:40:51 +10301967
1968 /* Don't test MULTIPORT at all if we're rproc: not a valid feature! */
1969 if (!is_rproc_serial(vdev) &&
1970 virtio_config_val(vdev, VIRTIO_CONSOLE_F_MULTIPORT,
1971 offsetof(struct virtio_console_config,
1972 max_nr_ports),
1973 &portdev->config.max_nr_ports) == 0) {
Amit Shah17634ba2009-12-21 21:03:25 +05301974 multiport = true;
Sjur Brændeland1b637042012-12-14 14:40:51 +10301975 }
Amit Shah17634ba2009-12-21 21:03:25 +05301976
Amit Shah2658a79a2010-01-18 19:15:11 +05301977 err = init_vqs(portdev);
1978 if (err < 0) {
1979 dev_err(&vdev->dev, "Error %d initializing vqs\n", err);
Amit Shahfb08bd22009-12-21 21:36:04 +05301980 goto free_chrdev;
Amit Shah2658a79a2010-01-18 19:15:11 +05301981 }
Amit Shah1c85bf32010-01-18 19:15:07 +05301982
Amit Shah17634ba2009-12-21 21:03:25 +05301983 spin_lock_init(&portdev->ports_lock);
1984 INIT_LIST_HEAD(&portdev->ports);
1985
1986 if (multiport) {
Amit Shah335a64a5c2010-02-24 10:37:44 +05301987 unsigned int nr_added_bufs;
1988
Amit Shah17634ba2009-12-21 21:03:25 +05301989 spin_lock_init(&portdev->cvq_lock);
1990 INIT_WORK(&portdev->control_work, &control_work_handler);
1991
Amit Shah335a64a5c2010-02-24 10:37:44 +05301992 nr_added_bufs = fill_queue(portdev->c_ivq, &portdev->cvq_lock);
1993 if (!nr_added_bufs) {
Amit Shah22a29ea2010-02-12 10:32:17 +05301994 dev_err(&vdev->dev,
1995 "Error allocating buffers for control queue\n");
1996 err = -ENOMEM;
1997 goto free_vqs;
1998 }
Amit Shah1d051602010-05-19 22:15:49 -06001999 } else {
2000 /*
2001 * For backward compatibility: Create a console port
2002 * if we're running on older host.
2003 */
2004 add_port(portdev, 0);
Amit Shah17634ba2009-12-21 21:03:25 +05302005 }
2006
Amit Shah6bdf2af2010-09-02 18:11:49 +05302007 spin_lock_irq(&pdrvdata_lock);
2008 list_add_tail(&portdev->list, &pdrvdata.portdevs);
2009 spin_unlock_irq(&pdrvdata_lock);
2010
Amit Shahf909f852010-05-19 22:15:48 -06002011 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2012 VIRTIO_CONSOLE_DEVICE_READY, 1);
Christian Borntraeger5e384832011-09-22 23:44:23 +05302013
2014 /*
2015 * If there was an early virtio console, assume that there are no
2016 * other consoles. We need to wait until the hvc_alloc matches the
2017 * hvc_instantiate, otherwise tty_open will complain, resulting in
2018 * a "Warning: unable to open an initial console" boot failure.
2019 * Without multiport this is done in add_port above. With multiport
2020 * this might take some host<->guest communication - thus we have to
2021 * wait.
2022 */
2023 if (multiport && early)
2024 wait_for_completion(&early_console_added);
2025
Rusty Russell31610432007-10-22 11:03:39 +10002026 return 0;
2027
Amit Shah22a29ea2010-02-12 10:32:17 +05302028free_vqs:
Julia Lawall0643e4c2010-05-15 11:45:53 +02002029 /* The host might want to notify mgmt sw about device add failure */
2030 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2031 VIRTIO_CONSOLE_DEVICE_READY, 0);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05302032 remove_vqs(portdev);
Amit Shahfb08bd22009-12-21 21:36:04 +05302033free_chrdev:
2034 unregister_chrdev(portdev->chr_major, "virtio-portsdev");
Rusty Russell31610432007-10-22 11:03:39 +10002035free:
Amit Shah1c85bf32010-01-18 19:15:07 +05302036 kfree(portdev);
Rusty Russell31610432007-10-22 11:03:39 +10002037fail:
2038 return err;
2039}
2040
Amit Shah71778762010-02-12 10:32:16 +05302041static void virtcons_remove(struct virtio_device *vdev)
2042{
2043 struct ports_device *portdev;
2044 struct port *port, *port2;
Amit Shah71778762010-02-12 10:32:16 +05302045
2046 portdev = vdev->priv;
2047
Amit Shah6bdf2af2010-09-02 18:11:49 +05302048 spin_lock_irq(&pdrvdata_lock);
2049 list_del(&portdev->list);
2050 spin_unlock_irq(&pdrvdata_lock);
2051
Amit Shah02238952010-09-02 18:11:40 +05302052 /* Disable interrupts for vqs */
2053 vdev->config->reset(vdev);
2054 /* Finish up work that's lined up */
Sjur Brændelandaded0242013-01-22 09:50:26 +10302055 if (use_multiport(portdev))
2056 cancel_work_sync(&portdev->control_work);
Amit Shah71778762010-02-12 10:32:16 +05302057
2058 list_for_each_entry_safe(port, port2, &portdev->ports, list)
Amit Shahb353a6b2010-09-02 18:38:29 +05302059 unplug_port(port);
Amit Shah71778762010-02-12 10:32:16 +05302060
2061 unregister_chrdev(portdev->chr_major, "virtio-portsdev");
2062
Amit Shahe0620132010-09-02 18:38:30 +05302063 /*
2064 * When yanking out a device, we immediately lose the
2065 * (device-side) queues. So there's no point in keeping the
2066 * guest side around till we drop our final reference. This
2067 * also means that any ports which are in an open state will
2068 * have to just stop using the port, as the vqs are going
2069 * away.
2070 */
Amit Shaha0e2dbf2011-12-22 16:58:27 +05302071 remove_controlq_data(portdev);
2072 remove_vqs(portdev);
Amit Shah71778762010-02-12 10:32:16 +05302073 kfree(portdev);
2074}
2075
Rusty Russell31610432007-10-22 11:03:39 +10002076static struct virtio_device_id id_table[] = {
2077 { VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID },
2078 { 0 },
2079};
2080
Christian Borntraegerc2983452008-11-25 13:36:26 +01002081static unsigned int features[] = {
2082 VIRTIO_CONSOLE_F_SIZE,
Amit Shahb99fa812010-05-19 22:15:46 -06002083 VIRTIO_CONSOLE_F_MULTIPORT,
Christian Borntraegerc2983452008-11-25 13:36:26 +01002084};
2085
Sjur Brændeland1b637042012-12-14 14:40:51 +10302086static struct virtio_device_id rproc_serial_id_table[] = {
2087#if IS_ENABLED(CONFIG_REMOTEPROC)
2088 { VIRTIO_ID_RPROC_SERIAL, VIRTIO_DEV_ANY_ID },
2089#endif
2090 { 0 },
2091};
2092
2093static unsigned int rproc_serial_features[] = {
2094};
2095
Amit Shah2b8f41d2011-12-22 16:58:28 +05302096#ifdef CONFIG_PM
2097static int virtcons_freeze(struct virtio_device *vdev)
2098{
2099 struct ports_device *portdev;
2100 struct port *port;
2101
2102 portdev = vdev->priv;
2103
2104 vdev->config->reset(vdev);
2105
Amit Shahc743d092012-01-06 16:19:08 +05302106 virtqueue_disable_cb(portdev->c_ivq);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302107 cancel_work_sync(&portdev->control_work);
Amit Shahc743d092012-01-06 16:19:08 +05302108 /*
2109 * Once more: if control_work_handler() was running, it would
2110 * enable the cb as the last step.
2111 */
2112 virtqueue_disable_cb(portdev->c_ivq);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302113 remove_controlq_data(portdev);
2114
2115 list_for_each_entry(port, &portdev->ports, list) {
Amit Shahc743d092012-01-06 16:19:08 +05302116 virtqueue_disable_cb(port->in_vq);
2117 virtqueue_disable_cb(port->out_vq);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302118 /*
2119 * We'll ask the host later if the new invocation has
2120 * the port opened or closed.
2121 */
2122 port->host_connected = false;
2123 remove_port_data(port);
2124 }
2125 remove_vqs(portdev);
2126
2127 return 0;
2128}
2129
2130static int virtcons_restore(struct virtio_device *vdev)
2131{
2132 struct ports_device *portdev;
2133 struct port *port;
2134 int ret;
2135
2136 portdev = vdev->priv;
2137
2138 ret = init_vqs(portdev);
2139 if (ret)
2140 return ret;
2141
2142 if (use_multiport(portdev))
2143 fill_queue(portdev->c_ivq, &portdev->cvq_lock);
2144
2145 list_for_each_entry(port, &portdev->ports, list) {
2146 port->in_vq = portdev->in_vqs[port->id];
2147 port->out_vq = portdev->out_vqs[port->id];
2148
2149 fill_queue(port->in_vq, &port->inbuf_lock);
2150
2151 /* Get port open/close status on the host */
2152 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
Amit Shahfa8b66c2012-04-25 14:40:39 +05302153
2154 /*
2155 * If a port was open at the time of suspending, we
2156 * have to let the host know that it's still open.
2157 */
2158 if (port->guest_connected)
2159 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302160 }
2161 return 0;
2162}
2163#endif
2164
Rusty Russell31610432007-10-22 11:03:39 +10002165static struct virtio_driver virtio_console = {
Christian Borntraegerc2983452008-11-25 13:36:26 +01002166 .feature_table = features,
2167 .feature_table_size = ARRAY_SIZE(features),
Rusty Russell31610432007-10-22 11:03:39 +10002168 .driver.name = KBUILD_MODNAME,
2169 .driver.owner = THIS_MODULE,
2170 .id_table = id_table,
2171 .probe = virtcons_probe,
Amit Shah71778762010-02-12 10:32:16 +05302172 .remove = virtcons_remove,
Amit Shah7f5d8102009-12-21 22:22:08 +05302173 .config_changed = config_intr,
Amit Shah2b8f41d2011-12-22 16:58:28 +05302174#ifdef CONFIG_PM
2175 .freeze = virtcons_freeze,
2176 .restore = virtcons_restore,
2177#endif
Rusty Russell31610432007-10-22 11:03:39 +10002178};
2179
Greg Kroah-Hartmanbcd29822012-12-21 15:12:08 -08002180static struct virtio_driver virtio_rproc_serial = {
Sjur Brændeland1b637042012-12-14 14:40:51 +10302181 .feature_table = rproc_serial_features,
2182 .feature_table_size = ARRAY_SIZE(rproc_serial_features),
2183 .driver.name = "virtio_rproc_serial",
2184 .driver.owner = THIS_MODULE,
2185 .id_table = rproc_serial_id_table,
2186 .probe = virtcons_probe,
2187 .remove = virtcons_remove,
2188};
2189
Rusty Russell31610432007-10-22 11:03:39 +10002190static int __init init(void)
2191{
Amit Shahfb08bd22009-12-21 21:36:04 +05302192 int err;
2193
2194 pdrvdata.class = class_create(THIS_MODULE, "virtio-ports");
2195 if (IS_ERR(pdrvdata.class)) {
2196 err = PTR_ERR(pdrvdata.class);
2197 pr_err("Error %d creating virtio-ports class\n", err);
2198 return err;
2199 }
Amit Shahd99393e2009-12-21 22:36:21 +05302200
2201 pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL);
2202 if (!pdrvdata.debugfs_dir) {
2203 pr_warning("Error %ld creating debugfs dir for virtio-ports\n",
2204 PTR_ERR(pdrvdata.debugfs_dir));
2205 }
Amit Shah38edf582010-01-18 19:15:05 +05302206 INIT_LIST_HEAD(&pdrvdata.consoles);
Amit Shah6bdf2af2010-09-02 18:11:49 +05302207 INIT_LIST_HEAD(&pdrvdata.portdevs);
Amit Shah38edf582010-01-18 19:15:05 +05302208
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002209 err = register_virtio_driver(&virtio_console);
2210 if (err < 0) {
2211 pr_err("Error %d registering virtio driver\n", err);
2212 goto free;
2213 }
Sjur Brændeland1b637042012-12-14 14:40:51 +10302214 err = register_virtio_driver(&virtio_rproc_serial);
2215 if (err < 0) {
2216 pr_err("Error %d registering virtio rproc serial driver\n",
2217 err);
2218 goto unregister;
2219 }
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002220 return 0;
Sjur Brændeland1b637042012-12-14 14:40:51 +10302221unregister:
2222 unregister_virtio_driver(&virtio_console);
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002223free:
2224 if (pdrvdata.debugfs_dir)
2225 debugfs_remove_recursive(pdrvdata.debugfs_dir);
2226 class_destroy(pdrvdata.class);
2227 return err;
Rusty Russell31610432007-10-22 11:03:39 +10002228}
Amit Shah71778762010-02-12 10:32:16 +05302229
2230static void __exit fini(void)
2231{
Sjur Brændeland1b637042012-12-14 14:40:51 +10302232 reclaim_dma_bufs();
2233
Amit Shah71778762010-02-12 10:32:16 +05302234 unregister_virtio_driver(&virtio_console);
Sjur Brændeland1b637042012-12-14 14:40:51 +10302235 unregister_virtio_driver(&virtio_rproc_serial);
Amit Shah71778762010-02-12 10:32:16 +05302236
2237 class_destroy(pdrvdata.class);
2238 if (pdrvdata.debugfs_dir)
2239 debugfs_remove_recursive(pdrvdata.debugfs_dir);
2240}
Rusty Russell31610432007-10-22 11:03:39 +10002241module_init(init);
Amit Shah71778762010-02-12 10:32:16 +05302242module_exit(fini);
Rusty Russell31610432007-10-22 11:03:39 +10002243
2244MODULE_DEVICE_TABLE(virtio, id_table);
2245MODULE_DESCRIPTION("Virtio console driver");
2246MODULE_LICENSE("GPL");