blob: 684b0d53764f38d218b8cff41d5a9e0c3e248979 [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
Amit Shahfb08bd22009-12-21 21:36:04 +053064 /* Number of devices this driver is handling */
65 unsigned int index;
66
Rusty Russelld8a02bd2010-01-18 19:15:06 +053067 /*
68 * This is used to keep track of the number of hvc consoles
69 * spawned by this driver. This number is given as the first
70 * argument to hvc_alloc(). To correctly map an initial
71 * console spawned via hvc_instantiate to the console being
72 * hooked up via hvc_alloc, we need to pass the same vtermno.
73 *
74 * We also just assume the first console being initialised was
75 * the first one that got used as the initial console.
76 */
77 unsigned int next_vtermno;
78
Amit Shah38edf582010-01-18 19:15:05 +053079 /* All the console devices handled by this driver */
80 struct list_head consoles;
81};
82static struct ports_driver_data pdrvdata;
83
84DEFINE_SPINLOCK(pdrvdata_lock);
Christian Borntraeger5e384832011-09-22 23:44:23 +053085DECLARE_COMPLETION(early_console_added);
Amit Shah38edf582010-01-18 19:15:05 +053086
Amit Shah4f23c572010-01-18 19:15:09 +053087/* This struct holds information that's relevant only for console ports */
88struct console {
89 /* We'll place all consoles in a list in the pdrvdata struct */
90 struct list_head list;
91
92 /* The hvc device associated with this console port */
93 struct hvc_struct *hvc;
94
Amit Shah97788292010-05-06 02:05:08 +053095 /* The size of the console */
96 struct winsize ws;
97
Amit Shah4f23c572010-01-18 19:15:09 +053098 /*
99 * This number identifies the number that we used to register
100 * with hvc in hvc_instantiate() and hvc_alloc(); this is the
101 * number passed on by the hvc callbacks to us to
102 * differentiate between the other console ports handled by
103 * this driver
104 */
105 u32 vtermno;
106};
107
Amit Shahfdb9a052010-01-18 19:15:01 +0530108struct port_buffer {
109 char *buf;
110
111 /* size of the buffer in *buf above */
112 size_t size;
113
114 /* used length of the buffer */
115 size_t len;
116 /* offset in the buf from which to consume data */
117 size_t offset;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030118
Sjur Brændeland1b637042012-12-14 14:40:51 +1030119 /* DMA address of buffer */
120 dma_addr_t dma;
121
122 /* Device we got DMA memory from */
123 struct device *dev;
124
125 /* List of pending dma buffers to free */
126 struct list_head list;
127
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030128 /* If sgpages == 0 then buf is used */
129 unsigned int sgpages;
130
131 /* sg is used if spages > 0. sg must be the last in is struct */
132 struct scatterlist sg[0];
Amit Shahfdb9a052010-01-18 19:15:01 +0530133};
134
Amit Shah17634ba2009-12-21 21:03:25 +0530135/*
136 * This is a per-device struct that stores data common to all the
137 * ports for that device (vdev->priv).
138 */
139struct ports_device {
Amit Shah6bdf2af2010-09-02 18:11:49 +0530140 /* Next portdev in the list, head is in the pdrvdata struct */
141 struct list_head list;
142
Amit Shah17634ba2009-12-21 21:03:25 +0530143 /*
144 * Workqueue handlers where we process deferred work after
145 * notification
146 */
147 struct work_struct control_work;
148
149 struct list_head ports;
150
151 /* To protect the list of ports */
152 spinlock_t ports_lock;
153
154 /* To protect the vq operations for the control channel */
155 spinlock_t cvq_lock;
156
157 /* The current config space is stored here */
Amit Shahb99fa812010-05-19 22:15:46 -0600158 struct virtio_console_config config;
Amit Shah17634ba2009-12-21 21:03:25 +0530159
160 /* The virtio device we're associated with */
161 struct virtio_device *vdev;
162
163 /*
164 * A couple of virtqueues for the control channel: one for
165 * guest->host transfers, one for host->guest transfers
166 */
167 struct virtqueue *c_ivq, *c_ovq;
168
169 /* Array of per-port IO virtqueues */
170 struct virtqueue **in_vqs, **out_vqs;
Amit Shahfb08bd22009-12-21 21:36:04 +0530171
172 /* Used for numbering devices for sysfs and debugfs */
173 unsigned int drv_index;
174
175 /* Major number for this device. Ports will be created as minors. */
176 int chr_major;
Amit Shah17634ba2009-12-21 21:03:25 +0530177};
178
Amit Shah17e5b4f2011-09-14 13:06:46 +0530179struct port_stats {
180 unsigned long bytes_sent, bytes_received, bytes_discarded;
181};
182
Amit Shah1c85bf32010-01-18 19:15:07 +0530183/* This struct holds the per-port data */
Rusty Russell21206ed2010-01-18 19:15:00 +0530184struct port {
Amit Shah17634ba2009-12-21 21:03:25 +0530185 /* Next port in the list, head is in the ports_device */
186 struct list_head list;
187
Amit Shah1c85bf32010-01-18 19:15:07 +0530188 /* Pointer to the parent virtio_console device */
189 struct ports_device *portdev;
Amit Shahfdb9a052010-01-18 19:15:01 +0530190
191 /* The current buffer from which data has to be fed to readers */
192 struct port_buffer *inbuf;
Rusty Russell31610432007-10-22 11:03:39 +1000193
Amit Shah203baab2010-01-18 19:15:12 +0530194 /*
195 * To protect the operations on the in_vq associated with this
196 * port. Has to be a spinlock because it can be called from
197 * interrupt context (get_char()).
198 */
199 spinlock_t inbuf_lock;
200
Amit Shahcdfadfc2010-05-19 22:15:50 -0600201 /* Protect the operations on the out_vq. */
202 spinlock_t outvq_lock;
203
Amit Shah1c85bf32010-01-18 19:15:07 +0530204 /* The IO vqs for this port */
205 struct virtqueue *in_vq, *out_vq;
206
Amit Shahd99393e2009-12-21 22:36:21 +0530207 /* File in the debugfs directory that exposes this port's information */
208 struct dentry *debugfs_file;
209
Amit Shah4f23c572010-01-18 19:15:09 +0530210 /*
Amit Shah17e5b4f2011-09-14 13:06:46 +0530211 * Keep count of the bytes sent, received and discarded for
212 * this port for accounting and debugging purposes. These
213 * counts are not reset across port open / close events.
214 */
215 struct port_stats stats;
216
217 /*
Amit Shah4f23c572010-01-18 19:15:09 +0530218 * The entries in this struct will be valid if this port is
219 * hooked up to an hvc console
220 */
221 struct console cons;
Amit Shah17634ba2009-12-21 21:03:25 +0530222
Amit Shahfb08bd22009-12-21 21:36:04 +0530223 /* Each port associates with a separate char device */
Amit Shahd22a6982010-09-02 18:20:59 +0530224 struct cdev *cdev;
Amit Shahfb08bd22009-12-21 21:36:04 +0530225 struct device *dev;
226
Amit Shahb353a6b2010-09-02 18:38:29 +0530227 /* Reference-counting to handle port hot-unplugs and file operations */
228 struct kref kref;
229
Amit Shah2030fa42009-12-21 21:49:30 +0530230 /* A waitqueue for poll() or blocking read operations */
231 wait_queue_head_t waitqueue;
232
Amit Shah431edb82009-12-21 21:57:40 +0530233 /* The 'name' of the port that we expose via sysfs properties */
234 char *name;
235
Amit Shah3eae0ad2010-09-02 18:47:52 +0530236 /* We can notify apps of host connect / disconnect events via SIGIO */
237 struct fasync_struct *async_queue;
238
Amit Shah17634ba2009-12-21 21:03:25 +0530239 /* The 'id' to identify the port with the Host */
240 u32 id;
Amit Shah2030fa42009-12-21 21:49:30 +0530241
Amit Shahcdfadfc2010-05-19 22:15:50 -0600242 bool outvq_full;
243
Amit Shah2030fa42009-12-21 21:49:30 +0530244 /* Is the host device open */
245 bool host_connected;
Amit Shah3c7969c2009-11-26 11:25:38 +0530246
247 /* We should allow only one process to open a port */
248 bool guest_connected;
Rusty Russell21206ed2010-01-18 19:15:00 +0530249};
Rusty Russell31610432007-10-22 11:03:39 +1000250
Rusty Russell971f3392010-01-18 19:14:56 +0530251/* This is the very early arch-specified put chars function. */
252static int (*early_put_chars)(u32, const char *, int);
253
Amit Shah38edf582010-01-18 19:15:05 +0530254static struct port *find_port_by_vtermno(u32 vtermno)
255{
256 struct port *port;
Amit Shah4f23c572010-01-18 19:15:09 +0530257 struct console *cons;
Amit Shah38edf582010-01-18 19:15:05 +0530258 unsigned long flags;
259
260 spin_lock_irqsave(&pdrvdata_lock, flags);
Amit Shah4f23c572010-01-18 19:15:09 +0530261 list_for_each_entry(cons, &pdrvdata.consoles, list) {
262 if (cons->vtermno == vtermno) {
263 port = container_of(cons, struct port, cons);
Amit Shah38edf582010-01-18 19:15:05 +0530264 goto out;
Amit Shah4f23c572010-01-18 19:15:09 +0530265 }
Amit Shah38edf582010-01-18 19:15:05 +0530266 }
267 port = NULL;
268out:
269 spin_unlock_irqrestore(&pdrvdata_lock, flags);
270 return port;
271}
272
Amit Shah04950cd2010-09-02 18:20:58 +0530273static struct port *find_port_by_devt_in_portdev(struct ports_device *portdev,
274 dev_t dev)
275{
276 struct port *port;
277 unsigned long flags;
278
279 spin_lock_irqsave(&portdev->ports_lock, flags);
280 list_for_each_entry(port, &portdev->ports, list)
Amit Shahd22a6982010-09-02 18:20:59 +0530281 if (port->cdev->dev == dev)
Amit Shah04950cd2010-09-02 18:20:58 +0530282 goto out;
283 port = NULL;
284out:
285 spin_unlock_irqrestore(&portdev->ports_lock, flags);
286
287 return port;
288}
289
290static struct port *find_port_by_devt(dev_t dev)
291{
292 struct ports_device *portdev;
293 struct port *port;
294 unsigned long flags;
295
296 spin_lock_irqsave(&pdrvdata_lock, flags);
297 list_for_each_entry(portdev, &pdrvdata.portdevs, list) {
298 port = find_port_by_devt_in_portdev(portdev, dev);
299 if (port)
300 goto out;
301 }
302 port = NULL;
303out:
304 spin_unlock_irqrestore(&pdrvdata_lock, flags);
305 return port;
306}
307
Amit Shah17634ba2009-12-21 21:03:25 +0530308static struct port *find_port_by_id(struct ports_device *portdev, u32 id)
309{
310 struct port *port;
311 unsigned long flags;
312
313 spin_lock_irqsave(&portdev->ports_lock, flags);
314 list_for_each_entry(port, &portdev->ports, list)
315 if (port->id == id)
316 goto out;
317 port = NULL;
318out:
319 spin_unlock_irqrestore(&portdev->ports_lock, flags);
320
321 return port;
322}
323
Amit Shah203baab2010-01-18 19:15:12 +0530324static struct port *find_port_by_vq(struct ports_device *portdev,
325 struct virtqueue *vq)
326{
327 struct port *port;
Amit Shah203baab2010-01-18 19:15:12 +0530328 unsigned long flags;
329
Amit Shah17634ba2009-12-21 21:03:25 +0530330 spin_lock_irqsave(&portdev->ports_lock, flags);
331 list_for_each_entry(port, &portdev->ports, list)
Amit Shah203baab2010-01-18 19:15:12 +0530332 if (port->in_vq == vq || port->out_vq == vq)
333 goto out;
Amit Shah203baab2010-01-18 19:15:12 +0530334 port = NULL;
335out:
Amit Shah17634ba2009-12-21 21:03:25 +0530336 spin_unlock_irqrestore(&portdev->ports_lock, flags);
Amit Shah203baab2010-01-18 19:15:12 +0530337 return port;
338}
339
Amit Shah17634ba2009-12-21 21:03:25 +0530340static bool is_console_port(struct port *port)
341{
342 if (port->cons.hvc)
343 return true;
344 return false;
345}
346
Sjur Brændeland1b637042012-12-14 14:40:51 +1030347static bool is_rproc_serial(const struct virtio_device *vdev)
348{
349 return is_rproc_enabled && vdev->id.device == VIRTIO_ID_RPROC_SERIAL;
350}
351
Amit Shah17634ba2009-12-21 21:03:25 +0530352static inline bool use_multiport(struct ports_device *portdev)
353{
354 /*
355 * This condition can be true when put_chars is called from
356 * early_init
357 */
358 if (!portdev->vdev)
359 return 0;
360 return portdev->vdev->features[0] & (1 << VIRTIO_CONSOLE_F_MULTIPORT);
361}
362
Sjur Brændeland1b637042012-12-14 14:40:51 +1030363static DEFINE_SPINLOCK(dma_bufs_lock);
364static LIST_HEAD(pending_free_dma_bufs);
365
366static void free_buf(struct port_buffer *buf, bool can_sleep)
Amit Shahfdb9a052010-01-18 19:15:01 +0530367{
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030368 unsigned int i;
369
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030370 for (i = 0; i < buf->sgpages; i++) {
371 struct page *page = sg_page(&buf->sg[i]);
372 if (!page)
373 break;
374 put_page(page);
375 }
376
Sjur Brændeland1b637042012-12-14 14:40:51 +1030377 if (!buf->dev) {
378 kfree(buf->buf);
379 } else if (is_rproc_enabled) {
380 unsigned long flags;
381
382 /* dma_free_coherent requires interrupts to be enabled. */
383 if (!can_sleep) {
384 /* queue up dma-buffers to be freed later */
385 spin_lock_irqsave(&dma_bufs_lock, flags);
386 list_add_tail(&buf->list, &pending_free_dma_bufs);
387 spin_unlock_irqrestore(&dma_bufs_lock, flags);
388 return;
389 }
390 dma_free_coherent(buf->dev, buf->size, buf->buf, buf->dma);
391
392 /* Release device refcnt and allow it to be freed */
393 put_device(buf->dev);
394 }
395
Amit Shahfdb9a052010-01-18 19:15:01 +0530396 kfree(buf);
397}
398
Sjur Brændeland1b637042012-12-14 14:40:51 +1030399static void reclaim_dma_bufs(void)
400{
401 unsigned long flags;
402 struct port_buffer *buf, *tmp;
403 LIST_HEAD(tmp_list);
404
405 if (list_empty(&pending_free_dma_bufs))
406 return;
407
408 /* Create a copy of the pending_free_dma_bufs while holding the lock */
409 spin_lock_irqsave(&dma_bufs_lock, flags);
410 list_cut_position(&tmp_list, &pending_free_dma_bufs,
411 pending_free_dma_bufs.prev);
412 spin_unlock_irqrestore(&dma_bufs_lock, flags);
413
414 /* Release the dma buffers, without irqs enabled */
415 list_for_each_entry_safe(buf, tmp, &tmp_list, list) {
416 list_del(&buf->list);
417 free_buf(buf, true);
418 }
419}
420
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030421static struct port_buffer *alloc_buf(struct virtqueue *vq, size_t buf_size,
422 int pages)
Amit Shahfdb9a052010-01-18 19:15:01 +0530423{
424 struct port_buffer *buf;
425
Sjur Brændeland1b637042012-12-14 14:40:51 +1030426 reclaim_dma_bufs();
427
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030428 /*
429 * Allocate buffer and the sg list. The sg list array is allocated
430 * directly after the port_buffer struct.
431 */
432 buf = kmalloc(sizeof(*buf) + sizeof(struct scatterlist) * pages,
433 GFP_KERNEL);
Amit Shahfdb9a052010-01-18 19:15:01 +0530434 if (!buf)
435 goto fail;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030436
437 buf->sgpages = pages;
438 if (pages > 0) {
Sjur Brændeland1b637042012-12-14 14:40:51 +1030439 buf->dev = NULL;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030440 buf->buf = NULL;
441 return buf;
442 }
443
Sjur Brændeland1b637042012-12-14 14:40:51 +1030444 if (is_rproc_serial(vq->vdev)) {
445 /*
446 * Allocate DMA memory from ancestor. When a virtio
447 * device is created by remoteproc, the DMA memory is
448 * associated with the grandparent device:
449 * vdev => rproc => platform-dev.
450 * The code here would have been less quirky if
451 * DMA_MEMORY_INCLUDES_CHILDREN had been supported
452 * in dma-coherent.c
453 */
454 if (!vq->vdev->dev.parent || !vq->vdev->dev.parent->parent)
455 goto free_buf;
456 buf->dev = vq->vdev->dev.parent->parent;
457
458 /* Increase device refcnt to avoid freeing it */
459 get_device(buf->dev);
460 buf->buf = dma_alloc_coherent(buf->dev, buf_size, &buf->dma,
461 GFP_KERNEL);
462 } else {
463 buf->dev = NULL;
464 buf->buf = kmalloc(buf_size, GFP_KERNEL);
465 }
466
Amit Shahfdb9a052010-01-18 19:15:01 +0530467 if (!buf->buf)
468 goto free_buf;
469 buf->len = 0;
470 buf->offset = 0;
471 buf->size = buf_size;
472 return buf;
473
474free_buf:
475 kfree(buf);
476fail:
477 return NULL;
478}
479
Amit Shaha3cde442010-01-18 19:15:03 +0530480/* Callers should take appropriate locks */
Amit Shahdefde662011-09-14 13:06:42 +0530481static struct port_buffer *get_inbuf(struct port *port)
Amit Shaha3cde442010-01-18 19:15:03 +0530482{
483 struct port_buffer *buf;
Amit Shaha3cde442010-01-18 19:15:03 +0530484 unsigned int len;
485
Amit Shahd25a9dd2011-09-14 13:06:43 +0530486 if (port->inbuf)
487 return port->inbuf;
488
489 buf = virtqueue_get_buf(port->in_vq, &len);
Amit Shaha3cde442010-01-18 19:15:03 +0530490 if (buf) {
491 buf->len = len;
492 buf->offset = 0;
Amit Shah17e5b4f2011-09-14 13:06:46 +0530493 port->stats.bytes_received += len;
Amit Shaha3cde442010-01-18 19:15:03 +0530494 }
495 return buf;
496}
497
Rusty Russella23ea922010-01-18 19:14:55 +0530498/*
Amit Shahe27b5192010-01-18 19:15:02 +0530499 * Create a scatter-gather list representing our input buffer and put
500 * it in the queue.
501 *
502 * Callers should take appropriate locks.
503 */
Amit Shah203baab2010-01-18 19:15:12 +0530504static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)
Amit Shahe27b5192010-01-18 19:15:02 +0530505{
506 struct scatterlist sg[1];
Amit Shah203baab2010-01-18 19:15:12 +0530507 int ret;
Amit Shah1c85bf32010-01-18 19:15:07 +0530508
Amit Shahe27b5192010-01-18 19:15:02 +0530509 sg_init_one(sg, buf->buf, buf->size);
510
Rusty Russellf96fde42012-01-12 15:44:42 +1030511 ret = virtqueue_add_buf(vq, sg, 0, 1, buf, GFP_ATOMIC);
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300512 virtqueue_kick(vq);
Amit Shah49e86f12012-12-10 09:45:12 +1030513 if (!ret)
514 ret = vq->num_free;
Amit Shah203baab2010-01-18 19:15:12 +0530515 return ret;
516}
517
Amit Shah88f251a2009-12-21 22:15:30 +0530518/* Discard any unread data this port has. Callers lockers. */
519static void discard_port_data(struct port *port)
520{
521 struct port_buffer *buf;
Amit Shah2d24cda2011-09-14 13:06:45 +0530522 unsigned int err;
Amit Shah88f251a2009-12-21 22:15:30 +0530523
Amit Shahd7a62cd2011-03-04 14:04:33 +1030524 if (!port->portdev) {
525 /* Device has been unplugged. vqs are already gone. */
526 return;
527 }
Amit Shah2d24cda2011-09-14 13:06:45 +0530528 buf = get_inbuf(port);
Amit Shah88f251a2009-12-21 22:15:30 +0530529
Amit Shahce072a02011-09-14 13:06:44 +0530530 err = 0;
Amit Shahd6933562010-02-12 10:32:18 +0530531 while (buf) {
Amit Shah17e5b4f2011-09-14 13:06:46 +0530532 port->stats.bytes_discarded += buf->len - buf->offset;
Amit Shah2d24cda2011-09-14 13:06:45 +0530533 if (add_inbuf(port->in_vq, buf) < 0) {
Amit Shahce072a02011-09-14 13:06:44 +0530534 err++;
Sjur Brændeland1b637042012-12-14 14:40:51 +1030535 free_buf(buf, false);
Amit Shahd6933562010-02-12 10:32:18 +0530536 }
Amit Shah2d24cda2011-09-14 13:06:45 +0530537 port->inbuf = NULL;
538 buf = get_inbuf(port);
Amit Shah88f251a2009-12-21 22:15:30 +0530539 }
Amit Shahce072a02011-09-14 13:06:44 +0530540 if (err)
Amit Shahd6933562010-02-12 10:32:18 +0530541 dev_warn(port->dev, "Errors adding %d buffers back to vq\n",
Amit Shahce072a02011-09-14 13:06:44 +0530542 err);
Amit Shah88f251a2009-12-21 22:15:30 +0530543}
544
Amit Shah203baab2010-01-18 19:15:12 +0530545static bool port_has_data(struct port *port)
546{
547 unsigned long flags;
548 bool ret;
549
Amit Shahd6933562010-02-12 10:32:18 +0530550 ret = false;
Amit Shahd25a9dd2011-09-14 13:06:43 +0530551 spin_lock_irqsave(&port->inbuf_lock, flags);
552 port->inbuf = get_inbuf(port);
553 if (port->inbuf)
554 ret = true;
555
Amit Shah203baab2010-01-18 19:15:12 +0530556 spin_unlock_irqrestore(&port->inbuf_lock, flags);
Amit Shah203baab2010-01-18 19:15:12 +0530557 return ret;
558}
559
Amit Shah3425e702010-05-19 22:15:46 -0600560static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id,
561 unsigned int event, unsigned int value)
Amit Shah17634ba2009-12-21 21:03:25 +0530562{
563 struct scatterlist sg[1];
564 struct virtio_console_control cpkt;
565 struct virtqueue *vq;
Amit Shah604b2ad2010-02-24 10:36:51 +0530566 unsigned int len;
Amit Shah17634ba2009-12-21 21:03:25 +0530567
Amit Shah3425e702010-05-19 22:15:46 -0600568 if (!use_multiport(portdev))
Amit Shah17634ba2009-12-21 21:03:25 +0530569 return 0;
570
Amit Shah3425e702010-05-19 22:15:46 -0600571 cpkt.id = port_id;
Amit Shah17634ba2009-12-21 21:03:25 +0530572 cpkt.event = event;
573 cpkt.value = value;
574
Amit Shah3425e702010-05-19 22:15:46 -0600575 vq = portdev->c_ovq;
Amit Shah17634ba2009-12-21 21:03:25 +0530576
577 sg_init_one(sg, &cpkt, sizeof(cpkt));
Rusty Russell589575a2012-10-16 23:56:15 +1030578 if (virtqueue_add_buf(vq, sg, 1, 0, &cpkt, GFP_ATOMIC) == 0) {
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300579 virtqueue_kick(vq);
580 while (!virtqueue_get_buf(vq, &len))
Amit Shah17634ba2009-12-21 21:03:25 +0530581 cpu_relax();
582 }
583 return 0;
584}
585
Amit Shah3425e702010-05-19 22:15:46 -0600586static ssize_t send_control_msg(struct port *port, unsigned int event,
587 unsigned int value)
588{
Amit Shah84ec06c2010-09-02 18:11:42 +0530589 /* Did the port get unplugged before userspace closed it? */
590 if (port->portdev)
591 return __send_control_msg(port->portdev, port->id, event, value);
592 return 0;
Amit Shah3425e702010-05-19 22:15:46 -0600593}
594
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900595
Amit Shahcdfadfc2010-05-19 22:15:50 -0600596/* Callers must take the port->outvq_lock */
597static void reclaim_consumed_buffers(struct port *port)
598{
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030599 struct port_buffer *buf;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600600 unsigned int len;
601
Amit Shahd7a62cd2011-03-04 14:04:33 +1030602 if (!port->portdev) {
603 /* Device has been unplugged. vqs are already gone. */
604 return;
605 }
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030606 while ((buf = virtqueue_get_buf(port->out_vq, &len))) {
Sjur Brændeland1b637042012-12-14 14:40:51 +1030607 free_buf(buf, false);
Amit Shahcdfadfc2010-05-19 22:15:50 -0600608 port->outvq_full = false;
609 }
610}
611
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900612static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,
613 int nents, size_t in_count,
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030614 void *data, bool nonblock)
Amit Shahf997f00b2009-12-21 17:28:51 +0530615{
Amit Shahf997f00b2009-12-21 17:28:51 +0530616 struct virtqueue *out_vq;
Rusty Russell589575a2012-10-16 23:56:15 +1030617 int err;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600618 unsigned long flags;
Amit Shahf997f00b2009-12-21 17:28:51 +0530619 unsigned int len;
620
621 out_vq = port->out_vq;
622
Amit Shahcdfadfc2010-05-19 22:15:50 -0600623 spin_lock_irqsave(&port->outvq_lock, flags);
624
625 reclaim_consumed_buffers(port);
626
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030627 err = virtqueue_add_buf(out_vq, sg, nents, 0, data, GFP_ATOMIC);
Amit Shahf997f00b2009-12-21 17:28:51 +0530628
629 /* Tell Host to go! */
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300630 virtqueue_kick(out_vq);
Amit Shahf997f00b2009-12-21 17:28:51 +0530631
Rusty Russell589575a2012-10-16 23:56:15 +1030632 if (err) {
Rusty Russell9ff4cfa2010-04-08 09:46:16 -0600633 in_count = 0;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600634 goto done;
Amit Shahf997f00b2009-12-21 17:28:51 +0530635 }
636
Rusty Russell589575a2012-10-16 23:56:15 +1030637 if (out_vq->num_free == 0)
Amit Shahcdfadfc2010-05-19 22:15:50 -0600638 port->outvq_full = true;
639
640 if (nonblock)
641 goto done;
642
643 /*
644 * Wait till the host acknowledges it pushed out the data we
Amit Shah531295e2010-10-20 13:45:43 +1030645 * sent. This is done for data from the hvc_console; the tty
646 * operations are performed with spinlocks held so we can't
647 * sleep here. An alternative would be to copy the data to a
648 * buffer and relax the spinning requirement. The downside is
649 * we need to kmalloc a GFP_ATOMIC buffer each time the
650 * console driver writes something out.
Amit Shahcdfadfc2010-05-19 22:15:50 -0600651 */
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300652 while (!virtqueue_get_buf(out_vq, &len))
Amit Shahf997f00b2009-12-21 17:28:51 +0530653 cpu_relax();
Amit Shahcdfadfc2010-05-19 22:15:50 -0600654done:
655 spin_unlock_irqrestore(&port->outvq_lock, flags);
Amit Shah17e5b4f2011-09-14 13:06:46 +0530656
657 port->stats.bytes_sent += in_count;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600658 /*
659 * We're expected to return the amount of data we wrote -- all
660 * of it
661 */
Rusty Russell9ff4cfa2010-04-08 09:46:16 -0600662 return in_count;
Amit Shahf997f00b2009-12-21 17:28:51 +0530663}
664
Amit Shah203baab2010-01-18 19:15:12 +0530665/*
666 * Give out the data that's requested from the buffer that we have
667 * queued up.
668 */
Amit Shahb766cee2009-12-21 21:26:45 +0530669static ssize_t fill_readbuf(struct port *port, char *out_buf, size_t out_count,
670 bool to_user)
Amit Shah203baab2010-01-18 19:15:12 +0530671{
672 struct port_buffer *buf;
673 unsigned long flags;
674
675 if (!out_count || !port_has_data(port))
676 return 0;
677
678 buf = port->inbuf;
Amit Shahb766cee2009-12-21 21:26:45 +0530679 out_count = min(out_count, buf->len - buf->offset);
Amit Shah203baab2010-01-18 19:15:12 +0530680
Amit Shahb766cee2009-12-21 21:26:45 +0530681 if (to_user) {
682 ssize_t ret;
Amit Shah203baab2010-01-18 19:15:12 +0530683
Amit Shahb766cee2009-12-21 21:26:45 +0530684 ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count);
685 if (ret)
686 return -EFAULT;
687 } else {
688 memcpy(out_buf, buf->buf + buf->offset, out_count);
689 }
690
Amit Shah203baab2010-01-18 19:15:12 +0530691 buf->offset += out_count;
692
693 if (buf->offset == buf->len) {
694 /*
695 * We're done using all the data in this buffer.
696 * Re-queue so that the Host can send us more data.
697 */
698 spin_lock_irqsave(&port->inbuf_lock, flags);
699 port->inbuf = NULL;
700
701 if (add_inbuf(port->in_vq, buf) < 0)
Amit Shahfb08bd22009-12-21 21:36:04 +0530702 dev_warn(port->dev, "failed add_buf\n");
Amit Shah203baab2010-01-18 19:15:12 +0530703
704 spin_unlock_irqrestore(&port->inbuf_lock, flags);
705 }
Amit Shahb766cee2009-12-21 21:26:45 +0530706 /* Return the number of bytes actually copied */
Amit Shah203baab2010-01-18 19:15:12 +0530707 return out_count;
Amit Shahe27b5192010-01-18 19:15:02 +0530708}
709
Amit Shah2030fa42009-12-21 21:49:30 +0530710/* The condition that must be true for polling to end */
Amit Shah60caacd2010-05-19 22:15:49 -0600711static bool will_read_block(struct port *port)
Amit Shah2030fa42009-12-21 21:49:30 +0530712{
Amit Shah3709ea72010-09-02 18:11:43 +0530713 if (!port->guest_connected) {
714 /* Port got hot-unplugged. Let's exit. */
715 return false;
716 }
Amit Shah60caacd2010-05-19 22:15:49 -0600717 return !port_has_data(port) && port->host_connected;
Amit Shah2030fa42009-12-21 21:49:30 +0530718}
719
Amit Shahcdfadfc2010-05-19 22:15:50 -0600720static bool will_write_block(struct port *port)
721{
722 bool ret;
723
Amit Shah60e5e0b2010-05-27 13:24:40 +0530724 if (!port->guest_connected) {
725 /* Port got hot-unplugged. Let's exit. */
726 return false;
727 }
Amit Shahcdfadfc2010-05-19 22:15:50 -0600728 if (!port->host_connected)
729 return true;
730
731 spin_lock_irq(&port->outvq_lock);
732 /*
733 * Check if the Host has consumed any buffers since we last
734 * sent data (this is only applicable for nonblocking ports).
735 */
736 reclaim_consumed_buffers(port);
737 ret = port->outvq_full;
738 spin_unlock_irq(&port->outvq_lock);
739
740 return ret;
741}
742
Amit Shah2030fa42009-12-21 21:49:30 +0530743static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
744 size_t count, loff_t *offp)
745{
746 struct port *port;
747 ssize_t ret;
748
749 port = filp->private_data;
750
751 if (!port_has_data(port)) {
752 /*
753 * If nothing's connected on the host just return 0 in
754 * case of list_empty; this tells the userspace app
755 * that there's no connection
756 */
757 if (!port->host_connected)
758 return 0;
759 if (filp->f_flags & O_NONBLOCK)
760 return -EAGAIN;
761
Amit Shaha08fa922011-09-14 13:06:41 +0530762 ret = wait_event_freezable(port->waitqueue,
763 !will_read_block(port));
Amit Shah2030fa42009-12-21 21:49:30 +0530764 if (ret < 0)
765 return ret;
766 }
Amit Shahb3dddb92010-09-02 18:11:45 +0530767 /* Port got hot-unplugged. */
768 if (!port->guest_connected)
769 return -ENODEV;
Amit Shah2030fa42009-12-21 21:49:30 +0530770 /*
771 * We could've received a disconnection message while we were
772 * waiting for more data.
773 *
774 * This check is not clubbed in the if() statement above as we
775 * might receive some data as well as the host could get
776 * disconnected after we got woken up from our wait. So we
777 * really want to give off whatever data we have and only then
778 * check for host_connected.
779 */
780 if (!port_has_data(port) && !port->host_connected)
781 return 0;
782
783 return fill_readbuf(port, ubuf, count, true);
784}
785
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900786static int wait_port_writable(struct port *port, bool nonblock)
787{
788 int ret;
789
790 if (will_write_block(port)) {
791 if (nonblock)
792 return -EAGAIN;
793
794 ret = wait_event_freezable(port->waitqueue,
795 !will_write_block(port));
796 if (ret < 0)
797 return ret;
798 }
799 /* Port got hot-unplugged. */
800 if (!port->guest_connected)
801 return -ENODEV;
802
803 return 0;
804}
805
Amit Shah2030fa42009-12-21 21:49:30 +0530806static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
807 size_t count, loff_t *offp)
808{
809 struct port *port;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030810 struct port_buffer *buf;
Amit Shah2030fa42009-12-21 21:49:30 +0530811 ssize_t ret;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600812 bool nonblock;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030813 struct scatterlist sg[1];
Amit Shah2030fa42009-12-21 21:49:30 +0530814
Amit Shah65745422010-09-14 13:26:16 +0530815 /* Userspace could be out to fool us */
816 if (!count)
817 return 0;
818
Amit Shah2030fa42009-12-21 21:49:30 +0530819 port = filp->private_data;
820
Amit Shahcdfadfc2010-05-19 22:15:50 -0600821 nonblock = filp->f_flags & O_NONBLOCK;
822
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900823 ret = wait_port_writable(port, nonblock);
824 if (ret < 0)
825 return ret;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600826
Amit Shah2030fa42009-12-21 21:49:30 +0530827 count = min((size_t)(32 * 1024), count);
828
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030829 buf = alloc_buf(port->out_vq, count, 0);
Amit Shah2030fa42009-12-21 21:49:30 +0530830 if (!buf)
831 return -ENOMEM;
832
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030833 ret = copy_from_user(buf->buf, ubuf, count);
Amit Shah2030fa42009-12-21 21:49:30 +0530834 if (ret) {
835 ret = -EFAULT;
836 goto free_buf;
837 }
838
Amit Shah531295e2010-10-20 13:45:43 +1030839 /*
840 * We now ask send_buf() to not spin for generic ports -- we
841 * can re-use the same code path that non-blocking file
842 * descriptors take for blocking file descriptors since the
843 * wait is already done and we're certain the write will go
844 * through to the host.
845 */
846 nonblock = true;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030847 sg_init_one(sg, buf->buf, count);
848 ret = __send_to_port(port, sg, 1, count, buf, nonblock);
Amit Shahcdfadfc2010-05-19 22:15:50 -0600849
850 if (nonblock && ret > 0)
851 goto out;
852
Amit Shah2030fa42009-12-21 21:49:30 +0530853free_buf:
Sjur Brændeland1b637042012-12-14 14:40:51 +1030854 free_buf(buf, true);
Amit Shahcdfadfc2010-05-19 22:15:50 -0600855out:
Amit Shah2030fa42009-12-21 21:49:30 +0530856 return ret;
857}
858
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900859struct sg_list {
860 unsigned int n;
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900861 unsigned int size;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900862 size_t len;
863 struct scatterlist *sg;
864};
865
866static int pipe_to_sg(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
867 struct splice_desc *sd)
868{
869 struct sg_list *sgl = sd->u.data;
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900870 unsigned int offset, len;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900871
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900872 if (sgl->n == sgl->size)
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900873 return 0;
874
875 /* Try lock this page */
876 if (buf->ops->steal(pipe, buf) == 0) {
877 /* Get reference and unlock page for moving */
878 get_page(buf->page);
879 unlock_page(buf->page);
880
881 len = min(buf->len, sd->len);
882 sg_set_page(&(sgl->sg[sgl->n]), buf->page, len, buf->offset);
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900883 } else {
884 /* Failback to copying a page */
885 struct page *page = alloc_page(GFP_KERNEL);
886 char *src = buf->ops->map(pipe, buf, 1);
887 char *dst;
888
889 if (!page)
890 return -ENOMEM;
891 dst = kmap(page);
892
893 offset = sd->pos & ~PAGE_MASK;
894
895 len = sd->len;
896 if (len + offset > PAGE_SIZE)
897 len = PAGE_SIZE - offset;
898
899 memcpy(dst + offset, src + buf->offset, len);
900
901 kunmap(page);
902 buf->ops->unmap(pipe, buf, src);
903
904 sg_set_page(&(sgl->sg[sgl->n]), page, len, offset);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900905 }
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900906 sgl->n++;
907 sgl->len += len;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900908
909 return len;
910}
911
912/* Faster zero-copy write by splicing */
913static ssize_t port_fops_splice_write(struct pipe_inode_info *pipe,
914 struct file *filp, loff_t *ppos,
915 size_t len, unsigned int flags)
916{
917 struct port *port = filp->private_data;
918 struct sg_list sgl;
919 ssize_t ret;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030920 struct port_buffer *buf;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900921 struct splice_desc sd = {
922 .total_len = len,
923 .flags = flags,
924 .pos = *ppos,
925 .u.data = &sgl,
926 };
927
Sjur Brændeland1b637042012-12-14 14:40:51 +1030928 /*
929 * Rproc_serial does not yet support splice. To support splice
930 * pipe_to_sg() must allocate dma-buffers and copy content from
931 * regular pages to dma pages. And alloc_buf and free_buf must
932 * support allocating and freeing such a list of dma-buffers.
933 */
934 if (is_rproc_serial(port->out_vq->vdev))
935 return -EINVAL;
936
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900937 ret = wait_port_writable(port, filp->f_flags & O_NONBLOCK);
938 if (ret < 0)
939 return ret;
940
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030941 buf = alloc_buf(port->out_vq, 0, pipe->nrbufs);
942 if (!buf)
943 return -ENOMEM;
944
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900945 sgl.n = 0;
946 sgl.len = 0;
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900947 sgl.size = pipe->nrbufs;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030948 sgl.sg = buf->sg;
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900949 sg_init_table(sgl.sg, sgl.size);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900950 ret = __splice_from_pipe(pipe, &sd, pipe_to_sg);
951 if (likely(ret > 0))
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030952 ret = __send_to_port(port, buf->sg, sgl.n, sgl.len, buf, true);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900953
Sjur Brændelandfe529532012-10-15 09:57:33 +0200954 if (unlikely(ret <= 0))
Sjur Brændeland1b637042012-12-14 14:40:51 +1030955 free_buf(buf, true);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900956 return ret;
957}
958
Amit Shah2030fa42009-12-21 21:49:30 +0530959static unsigned int port_fops_poll(struct file *filp, poll_table *wait)
960{
961 struct port *port;
962 unsigned int ret;
963
964 port = filp->private_data;
965 poll_wait(filp, &port->waitqueue, wait);
966
Amit Shah8529a502010-09-02 18:11:44 +0530967 if (!port->guest_connected) {
968 /* Port got unplugged */
969 return POLLHUP;
970 }
Amit Shah2030fa42009-12-21 21:49:30 +0530971 ret = 0;
Hans de Goede6df7aad2010-09-16 14:43:08 +0530972 if (!will_read_block(port))
Amit Shah2030fa42009-12-21 21:49:30 +0530973 ret |= POLLIN | POLLRDNORM;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600974 if (!will_write_block(port))
Amit Shah2030fa42009-12-21 21:49:30 +0530975 ret |= POLLOUT;
976 if (!port->host_connected)
977 ret |= POLLHUP;
978
979 return ret;
980}
981
Amit Shahb353a6b2010-09-02 18:38:29 +0530982static void remove_port(struct kref *kref);
983
Amit Shah2030fa42009-12-21 21:49:30 +0530984static int port_fops_release(struct inode *inode, struct file *filp)
985{
986 struct port *port;
987
988 port = filp->private_data;
989
990 /* Notify host of port being closed */
991 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
992
Amit Shah88f251a2009-12-21 22:15:30 +0530993 spin_lock_irq(&port->inbuf_lock);
Amit Shah3c7969c2009-11-26 11:25:38 +0530994 port->guest_connected = false;
995
Amit Shah88f251a2009-12-21 22:15:30 +0530996 discard_port_data(port);
997
998 spin_unlock_irq(&port->inbuf_lock);
999
Amit Shahcdfadfc2010-05-19 22:15:50 -06001000 spin_lock_irq(&port->outvq_lock);
1001 reclaim_consumed_buffers(port);
1002 spin_unlock_irq(&port->outvq_lock);
1003
Sjur Brændeland1b637042012-12-14 14:40:51 +10301004 reclaim_dma_bufs();
Amit Shahb353a6b2010-09-02 18:38:29 +05301005 /*
1006 * Locks aren't necessary here as a port can't be opened after
1007 * unplug, and if a port isn't unplugged, a kref would already
1008 * exist for the port. Plus, taking ports_lock here would
1009 * create a dependency on other locks taken by functions
1010 * inside remove_port if we're the last holder of the port,
1011 * creating many problems.
1012 */
1013 kref_put(&port->kref, remove_port);
1014
Amit Shah2030fa42009-12-21 21:49:30 +05301015 return 0;
1016}
1017
1018static int port_fops_open(struct inode *inode, struct file *filp)
1019{
1020 struct cdev *cdev = inode->i_cdev;
1021 struct port *port;
Amit Shah8ad37e82010-09-02 18:11:48 +05301022 int ret;
Amit Shah2030fa42009-12-21 21:49:30 +05301023
Amit Shah04950cd2010-09-02 18:20:58 +05301024 port = find_port_by_devt(cdev->dev);
Amit Shah2030fa42009-12-21 21:49:30 +05301025 filp->private_data = port;
1026
Amit Shahb353a6b2010-09-02 18:38:29 +05301027 /* Prevent against a port getting hot-unplugged at the same time */
1028 spin_lock_irq(&port->portdev->ports_lock);
1029 kref_get(&port->kref);
1030 spin_unlock_irq(&port->portdev->ports_lock);
1031
Amit Shah2030fa42009-12-21 21:49:30 +05301032 /*
1033 * Don't allow opening of console port devices -- that's done
1034 * via /dev/hvc
1035 */
Amit Shah8ad37e82010-09-02 18:11:48 +05301036 if (is_console_port(port)) {
1037 ret = -ENXIO;
1038 goto out;
1039 }
Amit Shah2030fa42009-12-21 21:49:30 +05301040
Amit Shah3c7969c2009-11-26 11:25:38 +05301041 /* Allow only one process to open a particular port at a time */
1042 spin_lock_irq(&port->inbuf_lock);
1043 if (port->guest_connected) {
1044 spin_unlock_irq(&port->inbuf_lock);
Amit Shah8ad37e82010-09-02 18:11:48 +05301045 ret = -EMFILE;
1046 goto out;
Amit Shah3c7969c2009-11-26 11:25:38 +05301047 }
1048
1049 port->guest_connected = true;
1050 spin_unlock_irq(&port->inbuf_lock);
1051
Amit Shahcdfadfc2010-05-19 22:15:50 -06001052 spin_lock_irq(&port->outvq_lock);
1053 /*
1054 * There might be a chance that we missed reclaiming a few
1055 * buffers in the window of the port getting previously closed
1056 * and opening now.
1057 */
1058 reclaim_consumed_buffers(port);
1059 spin_unlock_irq(&port->outvq_lock);
1060
Amit Shah299fb612010-09-16 14:43:09 +05301061 nonseekable_open(inode, filp);
1062
Amit Shah2030fa42009-12-21 21:49:30 +05301063 /* Notify host of port being opened */
1064 send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1);
1065
1066 return 0;
Amit Shah8ad37e82010-09-02 18:11:48 +05301067out:
Amit Shahb353a6b2010-09-02 18:38:29 +05301068 kref_put(&port->kref, remove_port);
Amit Shah8ad37e82010-09-02 18:11:48 +05301069 return ret;
Amit Shah2030fa42009-12-21 21:49:30 +05301070}
1071
Amit Shah3eae0ad2010-09-02 18:47:52 +05301072static int port_fops_fasync(int fd, struct file *filp, int mode)
1073{
1074 struct port *port;
1075
1076 port = filp->private_data;
1077 return fasync_helper(fd, filp, mode, &port->async_queue);
1078}
1079
Amit Shah2030fa42009-12-21 21:49:30 +05301080/*
1081 * The file operations that we support: programs in the guest can open
1082 * a console device, read from it, write to it, poll for data and
1083 * close it. The devices are at
1084 * /dev/vport<device number>p<port number>
1085 */
1086static const struct file_operations port_fops = {
1087 .owner = THIS_MODULE,
1088 .open = port_fops_open,
1089 .read = port_fops_read,
1090 .write = port_fops_write,
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +09001091 .splice_write = port_fops_splice_write,
Amit Shah2030fa42009-12-21 21:49:30 +05301092 .poll = port_fops_poll,
1093 .release = port_fops_release,
Amit Shah3eae0ad2010-09-02 18:47:52 +05301094 .fasync = port_fops_fasync,
Amit Shah299fb612010-09-16 14:43:09 +05301095 .llseek = no_llseek,
Amit Shah2030fa42009-12-21 21:49:30 +05301096};
1097
Amit Shahe27b5192010-01-18 19:15:02 +05301098/*
Rusty Russella23ea922010-01-18 19:14:55 +05301099 * The put_chars() callback is pretty straightforward.
Rusty Russell31610432007-10-22 11:03:39 +10001100 *
Rusty Russella23ea922010-01-18 19:14:55 +05301101 * We turn the characters into a scatter-gather list, add it to the
1102 * output queue and then kick the Host. Then we sit here waiting for
1103 * it to finish: inefficient in theory, but in practice
1104 * implementations will do it immediately (lguest's Launcher does).
1105 */
Rusty Russell31610432007-10-22 11:03:39 +10001106static int put_chars(u32 vtermno, const char *buf, int count)
1107{
Rusty Russell21206ed2010-01-18 19:15:00 +05301108 struct port *port;
Sjur Brændeland276a3e92012-12-14 13:46:42 +10301109 struct scatterlist sg[1];
Amit Shah38edf582010-01-18 19:15:05 +05301110
François Diakhaté162a6892010-03-23 18:23:15 +05301111 if (unlikely(early_put_chars))
1112 return early_put_chars(vtermno, buf, count);
1113
Amit Shah38edf582010-01-18 19:15:05 +05301114 port = find_port_by_vtermno(vtermno);
1115 if (!port)
Amit Shah6dc69f972010-05-19 22:15:47 -06001116 return -EPIPE;
Rusty Russell31610432007-10-22 11:03:39 +10001117
Sjur Brændeland276a3e92012-12-14 13:46:42 +10301118 sg_init_one(sg, buf, count);
1119 return __send_to_port(port, sg, 1, count, (void *)buf, false);
Rusty Russell31610432007-10-22 11:03:39 +10001120}
1121
Rusty Russella23ea922010-01-18 19:14:55 +05301122/*
Rusty Russella23ea922010-01-18 19:14:55 +05301123 * get_chars() is the callback from the hvc_console infrastructure
1124 * when an interrupt is received.
Rusty Russell31610432007-10-22 11:03:39 +10001125 *
Amit Shah203baab2010-01-18 19:15:12 +05301126 * We call out to fill_readbuf that gets us the required data from the
1127 * buffers that are queued up.
Rusty Russella23ea922010-01-18 19:14:55 +05301128 */
Rusty Russell31610432007-10-22 11:03:39 +10001129static int get_chars(u32 vtermno, char *buf, int count)
1130{
Rusty Russell21206ed2010-01-18 19:15:00 +05301131 struct port *port;
Rusty Russell31610432007-10-22 11:03:39 +10001132
Amit Shah6dc69f972010-05-19 22:15:47 -06001133 /* If we've not set up the port yet, we have no input to give. */
1134 if (unlikely(early_put_chars))
1135 return 0;
1136
Amit Shah38edf582010-01-18 19:15:05 +05301137 port = find_port_by_vtermno(vtermno);
1138 if (!port)
Amit Shah6dc69f972010-05-19 22:15:47 -06001139 return -EPIPE;
Rusty Russell21206ed2010-01-18 19:15:00 +05301140
1141 /* If we don't have an input queue yet, we can't get input. */
1142 BUG_ON(!port->in_vq);
1143
Amit Shahb766cee2009-12-21 21:26:45 +05301144 return fill_readbuf(port, buf, count, false);
Rusty Russell31610432007-10-22 11:03:39 +10001145}
Rusty Russell31610432007-10-22 11:03:39 +10001146
Amit Shahcb06e362010-01-18 19:15:08 +05301147static void resize_console(struct port *port)
Christian Borntraegerc2983452008-11-25 13:36:26 +01001148{
Amit Shahcb06e362010-01-18 19:15:08 +05301149 struct virtio_device *vdev;
Christian Borntraegerc2983452008-11-25 13:36:26 +01001150
Amit Shah2de16a42010-03-19 17:36:44 +05301151 /* The port could have been hot-unplugged */
Amit Shah97788292010-05-06 02:05:08 +05301152 if (!port || !is_console_port(port))
Amit Shah2de16a42010-03-19 17:36:44 +05301153 return;
1154
Amit Shahcb06e362010-01-18 19:15:08 +05301155 vdev = port->portdev->vdev;
Sjur Brændeland1b637042012-12-14 14:40:51 +10301156
1157 /* Don't test F_SIZE at all if we're rproc: not a valid feature! */
1158 if (!is_rproc_serial(vdev) &&
1159 virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE))
Amit Shah97788292010-05-06 02:05:08 +05301160 hvc_resize(port->cons.hvc, port->cons.ws);
Christian Borntraegerc2983452008-11-25 13:36:26 +01001161}
1162
Amit Shah38edf582010-01-18 19:15:05 +05301163/* We set the configuration at this point, since we now have a tty */
Christian Borntraeger91fcad12008-06-20 15:24:15 +02001164static int notifier_add_vio(struct hvc_struct *hp, int data)
1165{
Amit Shah38edf582010-01-18 19:15:05 +05301166 struct port *port;
1167
1168 port = find_port_by_vtermno(hp->vtermno);
1169 if (!port)
1170 return -EINVAL;
1171
Christian Borntraeger91fcad12008-06-20 15:24:15 +02001172 hp->irq_requested = 1;
Amit Shahcb06e362010-01-18 19:15:08 +05301173 resize_console(port);
Christian Borntraegerc2983452008-11-25 13:36:26 +01001174
Christian Borntraeger91fcad12008-06-20 15:24:15 +02001175 return 0;
1176}
1177
1178static void notifier_del_vio(struct hvc_struct *hp, int data)
1179{
1180 hp->irq_requested = 0;
1181}
1182
Amit Shah17634ba2009-12-21 21:03:25 +05301183/* The operations for console ports. */
Rusty Russell1dff3992009-11-28 12:20:26 +05301184static const struct hv_ops hv_ops = {
Rusty Russell971f3392010-01-18 19:14:56 +05301185 .get_chars = get_chars,
1186 .put_chars = put_chars,
1187 .notifier_add = notifier_add_vio,
1188 .notifier_del = notifier_del_vio,
1189 .notifier_hangup = notifier_del_vio,
1190};
1191
1192/*
1193 * Console drivers are initialized very early so boot messages can go
1194 * out, so we do things slightly differently from the generic virtio
1195 * initialization of the net and block drivers.
1196 *
1197 * At this stage, the console is output-only. It's too early to set
1198 * up a virtqueue, so we let the drivers do some boutique early-output
1199 * thing.
1200 */
1201int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int))
1202{
1203 early_put_chars = put_chars;
1204 return hvc_instantiate(0, 0, &hv_ops);
1205}
1206
Amit Shah17634ba2009-12-21 21:03:25 +05301207int init_port_console(struct port *port)
Amit Shahcfa6d372010-01-18 19:15:10 +05301208{
1209 int ret;
1210
1211 /*
1212 * The Host's telling us this port is a console port. Hook it
1213 * up with an hvc console.
1214 *
1215 * To set up and manage our virtual console, we call
1216 * hvc_alloc().
1217 *
1218 * The first argument of hvc_alloc() is the virtual console
1219 * number. The second argument is the parameter for the
1220 * notification mechanism (like irq number). We currently
1221 * leave this as zero, virtqueues have implicit notifications.
1222 *
1223 * The third argument is a "struct hv_ops" containing the
1224 * put_chars() get_chars(), notifier_add() and notifier_del()
1225 * pointers. The final argument is the output buffer size: we
1226 * can do any size, so we put PAGE_SIZE here.
1227 */
1228 port->cons.vtermno = pdrvdata.next_vtermno;
1229
1230 port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE);
1231 if (IS_ERR(port->cons.hvc)) {
1232 ret = PTR_ERR(port->cons.hvc);
Amit Shah298add72010-01-18 16:35:23 +05301233 dev_err(port->dev,
1234 "error %d allocating hvc for port\n", ret);
Amit Shahcfa6d372010-01-18 19:15:10 +05301235 port->cons.hvc = NULL;
1236 return ret;
1237 }
1238 spin_lock_irq(&pdrvdata_lock);
1239 pdrvdata.next_vtermno++;
1240 list_add_tail(&port->cons.list, &pdrvdata.consoles);
1241 spin_unlock_irq(&pdrvdata_lock);
Amit Shah3c7969c2009-11-26 11:25:38 +05301242 port->guest_connected = true;
Amit Shahcfa6d372010-01-18 19:15:10 +05301243
Amit Shah1d051602010-05-19 22:15:49 -06001244 /*
1245 * Start using the new console output if this is the first
1246 * console to come up.
1247 */
1248 if (early_put_chars)
1249 early_put_chars = NULL;
1250
Amit Shah2030fa42009-12-21 21:49:30 +05301251 /* Notify host of port being opened */
1252 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
1253
Amit Shahcfa6d372010-01-18 19:15:10 +05301254 return 0;
1255}
1256
Amit Shah431edb82009-12-21 21:57:40 +05301257static ssize_t show_port_name(struct device *dev,
1258 struct device_attribute *attr, char *buffer)
1259{
1260 struct port *port;
1261
1262 port = dev_get_drvdata(dev);
1263
1264 return sprintf(buffer, "%s\n", port->name);
1265}
1266
1267static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL);
1268
1269static struct attribute *port_sysfs_entries[] = {
1270 &dev_attr_name.attr,
1271 NULL
1272};
1273
1274static struct attribute_group port_attribute_group = {
1275 .name = NULL, /* put in device directory */
1276 .attrs = port_sysfs_entries,
1277};
1278
Amit Shahd99393e2009-12-21 22:36:21 +05301279static ssize_t debugfs_read(struct file *filp, char __user *ubuf,
1280 size_t count, loff_t *offp)
1281{
1282 struct port *port;
1283 char *buf;
1284 ssize_t ret, out_offset, out_count;
1285
1286 out_count = 1024;
1287 buf = kmalloc(out_count, GFP_KERNEL);
1288 if (!buf)
1289 return -ENOMEM;
1290
1291 port = filp->private_data;
1292 out_offset = 0;
1293 out_offset += snprintf(buf + out_offset, out_count,
1294 "name: %s\n", port->name ? port->name : "");
1295 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1296 "guest_connected: %d\n", port->guest_connected);
1297 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1298 "host_connected: %d\n", port->host_connected);
1299 out_offset += snprintf(buf + out_offset, out_count - out_offset,
Amit Shahcdfadfc2010-05-19 22:15:50 -06001300 "outvq_full: %d\n", port->outvq_full);
1301 out_offset += snprintf(buf + out_offset, out_count - out_offset,
Amit Shah17e5b4f2011-09-14 13:06:46 +05301302 "bytes_sent: %lu\n", port->stats.bytes_sent);
1303 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1304 "bytes_received: %lu\n",
1305 port->stats.bytes_received);
1306 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1307 "bytes_discarded: %lu\n",
1308 port->stats.bytes_discarded);
1309 out_offset += snprintf(buf + out_offset, out_count - out_offset,
Amit Shahd99393e2009-12-21 22:36:21 +05301310 "is_console: %s\n",
1311 is_console_port(port) ? "yes" : "no");
1312 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1313 "console_vtermno: %u\n", port->cons.vtermno);
1314
1315 ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset);
1316 kfree(buf);
1317 return ret;
1318}
1319
1320static const struct file_operations port_debugfs_ops = {
1321 .owner = THIS_MODULE,
Stephen Boyd234e3402012-04-05 14:25:11 -07001322 .open = simple_open,
Amit Shahd99393e2009-12-21 22:36:21 +05301323 .read = debugfs_read,
1324};
1325
Amit Shah97788292010-05-06 02:05:08 +05301326static void set_console_size(struct port *port, u16 rows, u16 cols)
1327{
1328 if (!port || !is_console_port(port))
1329 return;
1330
1331 port->cons.ws.ws_row = rows;
1332 port->cons.ws.ws_col = cols;
1333}
1334
Amit Shahc446f8f2010-05-19 22:15:48 -06001335static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock)
1336{
1337 struct port_buffer *buf;
1338 unsigned int nr_added_bufs;
1339 int ret;
1340
1341 nr_added_bufs = 0;
1342 do {
Sjur Brændeland276a3e92012-12-14 13:46:42 +10301343 buf = alloc_buf(vq, PAGE_SIZE, 0);
Amit Shahc446f8f2010-05-19 22:15:48 -06001344 if (!buf)
1345 break;
1346
1347 spin_lock_irq(lock);
1348 ret = add_inbuf(vq, buf);
1349 if (ret < 0) {
1350 spin_unlock_irq(lock);
Sjur Brændeland1b637042012-12-14 14:40:51 +10301351 free_buf(buf, true);
Amit Shahc446f8f2010-05-19 22:15:48 -06001352 break;
1353 }
1354 nr_added_bufs++;
1355 spin_unlock_irq(lock);
1356 } while (ret > 0);
1357
1358 return nr_added_bufs;
1359}
1360
Amit Shah3eae0ad2010-09-02 18:47:52 +05301361static void send_sigio_to_port(struct port *port)
1362{
1363 if (port->async_queue && port->guest_connected)
1364 kill_fasync(&port->async_queue, SIGIO, POLL_OUT);
1365}
1366
Amit Shahc446f8f2010-05-19 22:15:48 -06001367static int add_port(struct ports_device *portdev, u32 id)
1368{
1369 char debugfs_name[16];
1370 struct port *port;
1371 struct port_buffer *buf;
1372 dev_t devt;
1373 unsigned int nr_added_bufs;
1374 int err;
1375
1376 port = kmalloc(sizeof(*port), GFP_KERNEL);
1377 if (!port) {
1378 err = -ENOMEM;
1379 goto fail;
1380 }
Amit Shahb353a6b2010-09-02 18:38:29 +05301381 kref_init(&port->kref);
Amit Shahc446f8f2010-05-19 22:15:48 -06001382
1383 port->portdev = portdev;
1384 port->id = id;
1385
1386 port->name = NULL;
1387 port->inbuf = NULL;
1388 port->cons.hvc = NULL;
Amit Shah3eae0ad2010-09-02 18:47:52 +05301389 port->async_queue = NULL;
Amit Shahc446f8f2010-05-19 22:15:48 -06001390
Amit Shah97788292010-05-06 02:05:08 +05301391 port->cons.ws.ws_row = port->cons.ws.ws_col = 0;
1392
Amit Shahc446f8f2010-05-19 22:15:48 -06001393 port->host_connected = port->guest_connected = false;
Amit Shah17e5b4f2011-09-14 13:06:46 +05301394 port->stats = (struct port_stats) { 0 };
Amit Shahc446f8f2010-05-19 22:15:48 -06001395
Amit Shahcdfadfc2010-05-19 22:15:50 -06001396 port->outvq_full = false;
1397
Amit Shahc446f8f2010-05-19 22:15:48 -06001398 port->in_vq = portdev->in_vqs[port->id];
1399 port->out_vq = portdev->out_vqs[port->id];
1400
Amit Shahd22a6982010-09-02 18:20:59 +05301401 port->cdev = cdev_alloc();
1402 if (!port->cdev) {
1403 dev_err(&port->portdev->vdev->dev, "Error allocating cdev\n");
1404 err = -ENOMEM;
1405 goto free_port;
1406 }
1407 port->cdev->ops = &port_fops;
Amit Shahc446f8f2010-05-19 22:15:48 -06001408
1409 devt = MKDEV(portdev->chr_major, id);
Amit Shahd22a6982010-09-02 18:20:59 +05301410 err = cdev_add(port->cdev, devt, 1);
Amit Shahc446f8f2010-05-19 22:15:48 -06001411 if (err < 0) {
1412 dev_err(&port->portdev->vdev->dev,
1413 "Error %d adding cdev for port %u\n", err, id);
Amit Shahd22a6982010-09-02 18:20:59 +05301414 goto free_cdev;
Amit Shahc446f8f2010-05-19 22:15:48 -06001415 }
1416 port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev,
1417 devt, port, "vport%up%u",
1418 port->portdev->drv_index, id);
1419 if (IS_ERR(port->dev)) {
1420 err = PTR_ERR(port->dev);
1421 dev_err(&port->portdev->vdev->dev,
1422 "Error %d creating device for port %u\n",
1423 err, id);
1424 goto free_cdev;
1425 }
1426
1427 spin_lock_init(&port->inbuf_lock);
Amit Shahcdfadfc2010-05-19 22:15:50 -06001428 spin_lock_init(&port->outvq_lock);
Amit Shahc446f8f2010-05-19 22:15:48 -06001429 init_waitqueue_head(&port->waitqueue);
1430
1431 /* Fill the in_vq with buffers so the host can send us data. */
1432 nr_added_bufs = fill_queue(port->in_vq, &port->inbuf_lock);
1433 if (!nr_added_bufs) {
1434 dev_err(port->dev, "Error allocating inbufs\n");
1435 err = -ENOMEM;
1436 goto free_device;
1437 }
1438
Sjur Brændeland1b637042012-12-14 14:40:51 +10301439 if (is_rproc_serial(port->portdev->vdev))
1440 /*
1441 * For rproc_serial assume remote processor is connected.
1442 * rproc_serial does not want the console port, only
1443 * the generic port implementation.
1444 */
1445 port->host_connected = true;
1446 else if (!use_multiport(port->portdev)) {
1447 /*
1448 * If we're not using multiport support,
1449 * this has to be a console port.
1450 */
Amit Shahc446f8f2010-05-19 22:15:48 -06001451 err = init_port_console(port);
1452 if (err)
1453 goto free_inbufs;
1454 }
1455
1456 spin_lock_irq(&portdev->ports_lock);
1457 list_add_tail(&port->list, &port->portdev->ports);
1458 spin_unlock_irq(&portdev->ports_lock);
1459
1460 /*
1461 * Tell the Host we're set so that it can send us various
1462 * configuration parameters for this port (eg, port name,
1463 * caching, whether this is a console port, etc.)
1464 */
1465 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1466
1467 if (pdrvdata.debugfs_dir) {
1468 /*
1469 * Finally, create the debugfs file that we can use to
1470 * inspect a port's state at any time
1471 */
1472 sprintf(debugfs_name, "vport%up%u",
1473 port->portdev->drv_index, id);
1474 port->debugfs_file = debugfs_create_file(debugfs_name, 0444,
1475 pdrvdata.debugfs_dir,
1476 port,
1477 &port_debugfs_ops);
1478 }
1479 return 0;
1480
1481free_inbufs:
1482 while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301483 free_buf(buf, true);
Amit Shahc446f8f2010-05-19 22:15:48 -06001484free_device:
1485 device_destroy(pdrvdata.class, port->dev->devt);
1486free_cdev:
Amit Shahd22a6982010-09-02 18:20:59 +05301487 cdev_del(port->cdev);
Amit Shahc446f8f2010-05-19 22:15:48 -06001488free_port:
1489 kfree(port);
1490fail:
1491 /* The host might want to notify management sw about port add failure */
Julia Lawall0643e4c2010-05-15 11:45:53 +02001492 __send_control_msg(portdev, id, VIRTIO_CONSOLE_PORT_READY, 0);
Amit Shahc446f8f2010-05-19 22:15:48 -06001493 return err;
1494}
1495
Amit Shahb353a6b2010-09-02 18:38:29 +05301496/* No users remain, remove all port-specific data. */
1497static void remove_port(struct kref *kref)
1498{
1499 struct port *port;
1500
1501 port = container_of(kref, struct port, kref);
1502
1503 sysfs_remove_group(&port->dev->kobj, &port_attribute_group);
1504 device_destroy(pdrvdata.class, port->dev->devt);
1505 cdev_del(port->cdev);
1506
1507 kfree(port->name);
1508
1509 debugfs_remove(port->debugfs_file);
1510
1511 kfree(port);
1512}
1513
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301514static void remove_port_data(struct port *port)
1515{
1516 struct port_buffer *buf;
1517
1518 /* Remove unused data this port might have received. */
1519 discard_port_data(port);
1520
1521 reclaim_consumed_buffers(port);
1522
1523 /* Remove buffers we queued up for the Host to send us data in. */
1524 while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301525 free_buf(buf, true);
sjur.brandeland@stericsson.comeb34f122012-11-16 11:20:19 +10301526
1527 /* Free pending buffers from the out-queue. */
1528 while ((buf = virtqueue_detach_unused_buf(port->out_vq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301529 free_buf(buf, true);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301530}
1531
Amit Shahb353a6b2010-09-02 18:38:29 +05301532/*
1533 * Port got unplugged. Remove port from portdev's list and drop the
1534 * kref reference. If no userspace has this port opened, it will
1535 * result in immediate removal the port.
1536 */
1537static void unplug_port(struct port *port)
Amit Shah1f7aa422009-12-21 22:27:31 +05301538{
Amit Shahb353a6b2010-09-02 18:38:29 +05301539 spin_lock_irq(&port->portdev->ports_lock);
1540 list_del(&port->list);
1541 spin_unlock_irq(&port->portdev->ports_lock);
1542
Amit Shah00476342010-05-27 13:24:39 +05301543 if (port->guest_connected) {
1544 port->guest_connected = false;
1545 port->host_connected = false;
1546 wake_up_interruptible(&port->waitqueue);
Amit Shaha461e112010-09-02 18:47:54 +05301547
1548 /* Let the app know the port is going down. */
1549 send_sigio_to_port(port);
Amit Shah00476342010-05-27 13:24:39 +05301550 }
1551
Amit Shah1f7aa422009-12-21 22:27:31 +05301552 if (is_console_port(port)) {
1553 spin_lock_irq(&pdrvdata_lock);
1554 list_del(&port->cons.list);
1555 spin_unlock_irq(&pdrvdata_lock);
1556 hvc_remove(port->cons.hvc);
1557 }
Amit Shah1f7aa422009-12-21 22:27:31 +05301558
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301559 remove_port_data(port);
Amit Shaha9cdd482010-02-12 10:32:15 +05301560
Amit Shahb353a6b2010-09-02 18:38:29 +05301561 /*
1562 * We should just assume the device itself has gone off --
1563 * else a close on an open port later will try to send out a
1564 * control message.
1565 */
1566 port->portdev = NULL;
Amit Shah1f7aa422009-12-21 22:27:31 +05301567
Amit Shahb353a6b2010-09-02 18:38:29 +05301568 /*
1569 * Locks around here are not necessary - a port can't be
1570 * opened after we removed the port struct from ports_list
1571 * above.
1572 */
1573 kref_put(&port->kref, remove_port);
Amit Shah1f7aa422009-12-21 22:27:31 +05301574}
1575
Amit Shah17634ba2009-12-21 21:03:25 +05301576/* Any private messages that the Host and Guest want to share */
1577static void handle_control_message(struct ports_device *portdev,
1578 struct port_buffer *buf)
1579{
1580 struct virtio_console_control *cpkt;
1581 struct port *port;
Amit Shah431edb82009-12-21 21:57:40 +05301582 size_t name_size;
1583 int err;
Amit Shah17634ba2009-12-21 21:03:25 +05301584
1585 cpkt = (struct virtio_console_control *)(buf->buf + buf->offset);
1586
1587 port = find_port_by_id(portdev, cpkt->id);
Amit Shahf909f852010-05-19 22:15:48 -06001588 if (!port && cpkt->event != VIRTIO_CONSOLE_PORT_ADD) {
Amit Shah17634ba2009-12-21 21:03:25 +05301589 /* No valid header at start of buffer. Drop it. */
1590 dev_dbg(&portdev->vdev->dev,
1591 "Invalid index %u in control packet\n", cpkt->id);
1592 return;
1593 }
1594
1595 switch (cpkt->event) {
Amit Shahf909f852010-05-19 22:15:48 -06001596 case VIRTIO_CONSOLE_PORT_ADD:
1597 if (port) {
Amit Shah1d051602010-05-19 22:15:49 -06001598 dev_dbg(&portdev->vdev->dev,
1599 "Port %u already added\n", port->id);
Amit Shahf909f852010-05-19 22:15:48 -06001600 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1601 break;
1602 }
1603 if (cpkt->id >= portdev->config.max_nr_ports) {
1604 dev_warn(&portdev->vdev->dev,
1605 "Request for adding port with out-of-bound id %u, max. supported id: %u\n",
1606 cpkt->id, portdev->config.max_nr_ports - 1);
1607 break;
1608 }
1609 add_port(portdev, cpkt->id);
1610 break;
1611 case VIRTIO_CONSOLE_PORT_REMOVE:
Amit Shahb353a6b2010-09-02 18:38:29 +05301612 unplug_port(port);
Amit Shahf909f852010-05-19 22:15:48 -06001613 break;
Amit Shah17634ba2009-12-21 21:03:25 +05301614 case VIRTIO_CONSOLE_CONSOLE_PORT:
1615 if (!cpkt->value)
1616 break;
1617 if (is_console_port(port))
1618 break;
1619
1620 init_port_console(port);
Christian Borntraeger5e384832011-09-22 23:44:23 +05301621 complete(&early_console_added);
Amit Shah17634ba2009-12-21 21:03:25 +05301622 /*
1623 * Could remove the port here in case init fails - but
1624 * have to notify the host first.
1625 */
1626 break;
Amit Shah8345adb2010-05-06 02:05:09 +05301627 case VIRTIO_CONSOLE_RESIZE: {
1628 struct {
1629 __u16 rows;
1630 __u16 cols;
1631 } size;
1632
Amit Shah17634ba2009-12-21 21:03:25 +05301633 if (!is_console_port(port))
1634 break;
Amit Shah8345adb2010-05-06 02:05:09 +05301635
1636 memcpy(&size, buf->buf + buf->offset + sizeof(*cpkt),
1637 sizeof(size));
1638 set_console_size(port, size.rows, size.cols);
1639
Amit Shah17634ba2009-12-21 21:03:25 +05301640 port->cons.hvc->irq_requested = 1;
1641 resize_console(port);
1642 break;
Amit Shah8345adb2010-05-06 02:05:09 +05301643 }
Amit Shah2030fa42009-12-21 21:49:30 +05301644 case VIRTIO_CONSOLE_PORT_OPEN:
1645 port->host_connected = cpkt->value;
1646 wake_up_interruptible(&port->waitqueue);
Amit Shahcdfadfc2010-05-19 22:15:50 -06001647 /*
1648 * If the host port got closed and the host had any
1649 * unconsumed buffers, we'll be able to reclaim them
1650 * now.
1651 */
1652 spin_lock_irq(&port->outvq_lock);
1653 reclaim_consumed_buffers(port);
1654 spin_unlock_irq(&port->outvq_lock);
Amit Shah3eae0ad2010-09-02 18:47:52 +05301655
1656 /*
1657 * If the guest is connected, it'll be interested in
1658 * knowing the host connection state changed.
1659 */
1660 send_sigio_to_port(port);
Amit Shah2030fa42009-12-21 21:49:30 +05301661 break;
Amit Shah431edb82009-12-21 21:57:40 +05301662 case VIRTIO_CONSOLE_PORT_NAME:
1663 /*
Amit Shah291024e2011-09-14 13:06:40 +05301664 * If we woke up after hibernation, we can get this
1665 * again. Skip it in that case.
1666 */
1667 if (port->name)
1668 break;
1669
1670 /*
Amit Shah431edb82009-12-21 21:57:40 +05301671 * Skip the size of the header and the cpkt to get the size
1672 * of the name that was sent
1673 */
1674 name_size = buf->len - buf->offset - sizeof(*cpkt) + 1;
1675
1676 port->name = kmalloc(name_size, GFP_KERNEL);
1677 if (!port->name) {
1678 dev_err(port->dev,
1679 "Not enough space to store port name\n");
1680 break;
1681 }
1682 strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt),
1683 name_size - 1);
1684 port->name[name_size - 1] = 0;
1685
1686 /*
1687 * Since we only have one sysfs attribute, 'name',
1688 * create it only if we have a name for the port.
1689 */
1690 err = sysfs_create_group(&port->dev->kobj,
1691 &port_attribute_group);
Amit Shahec642132010-03-19 17:36:43 +05301692 if (err) {
Amit Shah431edb82009-12-21 21:57:40 +05301693 dev_err(port->dev,
1694 "Error %d creating sysfs device attributes\n",
1695 err);
Amit Shahec642132010-03-19 17:36:43 +05301696 } else {
1697 /*
1698 * Generate a udev event so that appropriate
1699 * symlinks can be created based on udev
1700 * rules.
1701 */
1702 kobject_uevent(&port->dev->kobj, KOBJ_CHANGE);
1703 }
Amit Shah431edb82009-12-21 21:57:40 +05301704 break;
Amit Shah17634ba2009-12-21 21:03:25 +05301705 }
1706}
1707
1708static void control_work_handler(struct work_struct *work)
1709{
1710 struct ports_device *portdev;
1711 struct virtqueue *vq;
1712 struct port_buffer *buf;
1713 unsigned int len;
1714
1715 portdev = container_of(work, struct ports_device, control_work);
1716 vq = portdev->c_ivq;
1717
1718 spin_lock(&portdev->cvq_lock);
Michael S. Tsirkin505b0452010-04-12 16:18:32 +03001719 while ((buf = virtqueue_get_buf(vq, &len))) {
Amit Shah17634ba2009-12-21 21:03:25 +05301720 spin_unlock(&portdev->cvq_lock);
1721
1722 buf->len = len;
1723 buf->offset = 0;
1724
1725 handle_control_message(portdev, buf);
1726
1727 spin_lock(&portdev->cvq_lock);
1728 if (add_inbuf(portdev->c_ivq, buf) < 0) {
1729 dev_warn(&portdev->vdev->dev,
1730 "Error adding buffer to queue\n");
Sjur Brændeland1b637042012-12-14 14:40:51 +10301731 free_buf(buf, false);
Amit Shah17634ba2009-12-21 21:03:25 +05301732 }
1733 }
1734 spin_unlock(&portdev->cvq_lock);
1735}
1736
Amit Shah2770c5e2011-01-31 13:06:36 +05301737static void out_intr(struct virtqueue *vq)
1738{
1739 struct port *port;
1740
1741 port = find_port_by_vq(vq->vdev->priv, vq);
1742 if (!port)
1743 return;
1744
1745 wake_up_interruptible(&port->waitqueue);
1746}
1747
Amit Shah17634ba2009-12-21 21:03:25 +05301748static void in_intr(struct virtqueue *vq)
1749{
1750 struct port *port;
1751 unsigned long flags;
1752
1753 port = find_port_by_vq(vq->vdev->priv, vq);
1754 if (!port)
1755 return;
1756
1757 spin_lock_irqsave(&port->inbuf_lock, flags);
Amit Shahd25a9dd2011-09-14 13:06:43 +05301758 port->inbuf = get_inbuf(port);
Amit Shah17634ba2009-12-21 21:03:25 +05301759
Amit Shah88f251a2009-12-21 22:15:30 +05301760 /*
1761 * Don't queue up data when port is closed. This condition
1762 * can be reached when a console port is not yet connected (no
1763 * tty is spawned) and the host sends out data to console
1764 * ports. For generic serial ports, the host won't
1765 * (shouldn't) send data till the guest is connected.
1766 */
1767 if (!port->guest_connected)
1768 discard_port_data(port);
1769
Amit Shah17634ba2009-12-21 21:03:25 +05301770 spin_unlock_irqrestore(&port->inbuf_lock, flags);
1771
Amit Shah2030fa42009-12-21 21:49:30 +05301772 wake_up_interruptible(&port->waitqueue);
1773
Amit Shah55f6bcc2010-09-02 18:47:53 +05301774 /* Send a SIGIO indicating new data in case the process asked for it */
1775 send_sigio_to_port(port);
1776
Amit Shah17634ba2009-12-21 21:03:25 +05301777 if (is_console_port(port) && hvc_poll(port->cons.hvc))
1778 hvc_kick();
1779}
1780
1781static void control_intr(struct virtqueue *vq)
1782{
1783 struct ports_device *portdev;
1784
1785 portdev = vq->vdev->priv;
1786 schedule_work(&portdev->control_work);
1787}
1788
Amit Shah7f5d8102009-12-21 22:22:08 +05301789static void config_intr(struct virtio_device *vdev)
1790{
1791 struct ports_device *portdev;
1792
1793 portdev = vdev->priv;
Amit Shah99f905f2010-05-19 22:15:48 -06001794
Amit Shah4038f5b72010-05-06 02:05:07 +05301795 if (!use_multiport(portdev)) {
Amit Shah97788292010-05-06 02:05:08 +05301796 struct port *port;
1797 u16 rows, cols;
1798
1799 vdev->config->get(vdev,
1800 offsetof(struct virtio_console_config, cols),
1801 &cols, sizeof(u16));
1802 vdev->config->get(vdev,
1803 offsetof(struct virtio_console_config, rows),
1804 &rows, sizeof(u16));
1805
1806 port = find_port_by_id(portdev, 0);
1807 set_console_size(port, rows, cols);
1808
Amit Shah4038f5b72010-05-06 02:05:07 +05301809 /*
1810 * We'll use this way of resizing only for legacy
1811 * support. For newer userspace
1812 * (VIRTIO_CONSOLE_F_MULTPORT+), use control messages
1813 * to indicate console size changes so that it can be
1814 * done per-port.
1815 */
Amit Shah97788292010-05-06 02:05:08 +05301816 resize_console(port);
Amit Shah4038f5b72010-05-06 02:05:07 +05301817 }
Amit Shah7f5d8102009-12-21 22:22:08 +05301818}
1819
Amit Shah2658a79a2010-01-18 19:15:11 +05301820static int init_vqs(struct ports_device *portdev)
1821{
1822 vq_callback_t **io_callbacks;
1823 char **io_names;
1824 struct virtqueue **vqs;
Amit Shah17634ba2009-12-21 21:03:25 +05301825 u32 i, j, nr_ports, nr_queues;
Amit Shah2658a79a2010-01-18 19:15:11 +05301826 int err;
1827
Amit Shah17634ba2009-12-21 21:03:25 +05301828 nr_ports = portdev->config.max_nr_ports;
1829 nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2;
Amit Shah2658a79a2010-01-18 19:15:11 +05301830
1831 vqs = kmalloc(nr_queues * sizeof(struct virtqueue *), GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301832 io_callbacks = kmalloc(nr_queues * sizeof(vq_callback_t *), GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301833 io_names = kmalloc(nr_queues * sizeof(char *), GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301834 portdev->in_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
1835 GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301836 portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
1837 GFP_KERNEL);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001838 if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs ||
Amit Shah286f9a22011-09-14 13:06:39 +05301839 !portdev->out_vqs) {
Amit Shah2658a79a2010-01-18 19:15:11 +05301840 err = -ENOMEM;
Jiri Slaby22e132f2010-11-06 10:06:50 +01001841 goto free;
Amit Shah2658a79a2010-01-18 19:15:11 +05301842 }
1843
Amit Shah17634ba2009-12-21 21:03:25 +05301844 /*
1845 * For backward compat (newer host but older guest), the host
1846 * spawns a console port first and also inits the vqs for port
1847 * 0 before others.
1848 */
1849 j = 0;
1850 io_callbacks[j] = in_intr;
Amit Shah2770c5e2011-01-31 13:06:36 +05301851 io_callbacks[j + 1] = out_intr;
Amit Shah17634ba2009-12-21 21:03:25 +05301852 io_names[j] = "input";
1853 io_names[j + 1] = "output";
1854 j += 2;
Amit Shah2658a79a2010-01-18 19:15:11 +05301855
Amit Shah17634ba2009-12-21 21:03:25 +05301856 if (use_multiport(portdev)) {
1857 io_callbacks[j] = control_intr;
1858 io_callbacks[j + 1] = NULL;
1859 io_names[j] = "control-i";
1860 io_names[j + 1] = "control-o";
1861
1862 for (i = 1; i < nr_ports; i++) {
1863 j += 2;
1864 io_callbacks[j] = in_intr;
Amit Shah2770c5e2011-01-31 13:06:36 +05301865 io_callbacks[j + 1] = out_intr;
Amit Shah17634ba2009-12-21 21:03:25 +05301866 io_names[j] = "input";
1867 io_names[j + 1] = "output";
1868 }
1869 }
Amit Shah2658a79a2010-01-18 19:15:11 +05301870 /* Find the queues. */
1871 err = portdev->vdev->config->find_vqs(portdev->vdev, nr_queues, vqs,
1872 io_callbacks,
1873 (const char **)io_names);
1874 if (err)
Jiri Slaby22e132f2010-11-06 10:06:50 +01001875 goto free;
Amit Shah2658a79a2010-01-18 19:15:11 +05301876
Amit Shah17634ba2009-12-21 21:03:25 +05301877 j = 0;
Amit Shah2658a79a2010-01-18 19:15:11 +05301878 portdev->in_vqs[0] = vqs[0];
1879 portdev->out_vqs[0] = vqs[1];
Amit Shah17634ba2009-12-21 21:03:25 +05301880 j += 2;
1881 if (use_multiport(portdev)) {
1882 portdev->c_ivq = vqs[j];
1883 portdev->c_ovq = vqs[j + 1];
Amit Shah2658a79a2010-01-18 19:15:11 +05301884
Amit Shah17634ba2009-12-21 21:03:25 +05301885 for (i = 1; i < nr_ports; i++) {
1886 j += 2;
1887 portdev->in_vqs[i] = vqs[j];
1888 portdev->out_vqs[i] = vqs[j + 1];
1889 }
1890 }
Amit Shah2658a79a2010-01-18 19:15:11 +05301891 kfree(io_names);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001892 kfree(io_callbacks);
Amit Shah2658a79a2010-01-18 19:15:11 +05301893 kfree(vqs);
1894
1895 return 0;
1896
Jiri Slaby22e132f2010-11-06 10:06:50 +01001897free:
Amit Shah2658a79a2010-01-18 19:15:11 +05301898 kfree(portdev->out_vqs);
Amit Shah2658a79a2010-01-18 19:15:11 +05301899 kfree(portdev->in_vqs);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001900 kfree(io_names);
1901 kfree(io_callbacks);
Amit Shah2658a79a2010-01-18 19:15:11 +05301902 kfree(vqs);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001903
Amit Shah2658a79a2010-01-18 19:15:11 +05301904 return err;
1905}
1906
Amit Shahfb08bd22009-12-21 21:36:04 +05301907static const struct file_operations portdev_fops = {
1908 .owner = THIS_MODULE,
1909};
1910
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301911static void remove_vqs(struct ports_device *portdev)
1912{
1913 portdev->vdev->config->del_vqs(portdev->vdev);
1914 kfree(portdev->in_vqs);
1915 kfree(portdev->out_vqs);
1916}
1917
1918static void remove_controlq_data(struct ports_device *portdev)
1919{
1920 struct port_buffer *buf;
1921 unsigned int len;
1922
1923 if (!use_multiport(portdev))
1924 return;
1925
1926 while ((buf = virtqueue_get_buf(portdev->c_ivq, &len)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301927 free_buf(buf, true);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301928
1929 while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301930 free_buf(buf, true);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301931}
1932
Amit Shah1c85bf32010-01-18 19:15:07 +05301933/*
1934 * Once we're further in boot, we get probed like any other virtio
1935 * device.
Amit Shah17634ba2009-12-21 21:03:25 +05301936 *
1937 * If the host also supports multiple console ports, we check the
1938 * config space to see how many ports the host has spawned. We
1939 * initialize each port found.
Amit Shah1c85bf32010-01-18 19:15:07 +05301940 */
Bill Pemberton2223cbe2012-11-19 13:22:51 -05001941static int virtcons_probe(struct virtio_device *vdev)
Amit Shah1c85bf32010-01-18 19:15:07 +05301942{
Amit Shah1c85bf32010-01-18 19:15:07 +05301943 struct ports_device *portdev;
1944 int err;
Amit Shah17634ba2009-12-21 21:03:25 +05301945 bool multiport;
Christian Borntraeger5e384832011-09-22 23:44:23 +05301946 bool early = early_put_chars != NULL;
1947
1948 /* Ensure to read early_put_chars now */
1949 barrier();
Amit Shah1c85bf32010-01-18 19:15:07 +05301950
1951 portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
1952 if (!portdev) {
1953 err = -ENOMEM;
1954 goto fail;
1955 }
1956
1957 /* Attach this portdev to this virtio_device, and vice-versa. */
1958 portdev->vdev = vdev;
1959 vdev->priv = portdev;
1960
Amit Shahfb08bd22009-12-21 21:36:04 +05301961 spin_lock_irq(&pdrvdata_lock);
1962 portdev->drv_index = pdrvdata.index++;
1963 spin_unlock_irq(&pdrvdata_lock);
1964
1965 portdev->chr_major = register_chrdev(0, "virtio-portsdev",
1966 &portdev_fops);
1967 if (portdev->chr_major < 0) {
1968 dev_err(&vdev->dev,
1969 "Error %d registering chrdev for device %u\n",
1970 portdev->chr_major, portdev->drv_index);
1971 err = portdev->chr_major;
1972 goto free;
1973 }
1974
Amit Shah17634ba2009-12-21 21:03:25 +05301975 multiport = false;
Amit Shah17634ba2009-12-21 21:03:25 +05301976 portdev->config.max_nr_ports = 1;
Sjur Brændeland1b637042012-12-14 14:40:51 +10301977
1978 /* Don't test MULTIPORT at all if we're rproc: not a valid feature! */
1979 if (!is_rproc_serial(vdev) &&
1980 virtio_config_val(vdev, VIRTIO_CONSOLE_F_MULTIPORT,
1981 offsetof(struct virtio_console_config,
1982 max_nr_ports),
1983 &portdev->config.max_nr_ports) == 0) {
Amit Shah17634ba2009-12-21 21:03:25 +05301984 multiport = true;
Sjur Brændeland1b637042012-12-14 14:40:51 +10301985 }
Amit Shah17634ba2009-12-21 21:03:25 +05301986
Amit Shah2658a79a2010-01-18 19:15:11 +05301987 err = init_vqs(portdev);
1988 if (err < 0) {
1989 dev_err(&vdev->dev, "Error %d initializing vqs\n", err);
Amit Shahfb08bd22009-12-21 21:36:04 +05301990 goto free_chrdev;
Amit Shah2658a79a2010-01-18 19:15:11 +05301991 }
Amit Shah1c85bf32010-01-18 19:15:07 +05301992
Amit Shah17634ba2009-12-21 21:03:25 +05301993 spin_lock_init(&portdev->ports_lock);
1994 INIT_LIST_HEAD(&portdev->ports);
1995
1996 if (multiport) {
Amit Shah335a64a5c2010-02-24 10:37:44 +05301997 unsigned int nr_added_bufs;
1998
Amit Shah17634ba2009-12-21 21:03:25 +05301999 spin_lock_init(&portdev->cvq_lock);
2000 INIT_WORK(&portdev->control_work, &control_work_handler);
2001
Amit Shah335a64a5c2010-02-24 10:37:44 +05302002 nr_added_bufs = fill_queue(portdev->c_ivq, &portdev->cvq_lock);
2003 if (!nr_added_bufs) {
Amit Shah22a29ea2010-02-12 10:32:17 +05302004 dev_err(&vdev->dev,
2005 "Error allocating buffers for control queue\n");
2006 err = -ENOMEM;
2007 goto free_vqs;
2008 }
Amit Shah1d051602010-05-19 22:15:49 -06002009 } else {
2010 /*
2011 * For backward compatibility: Create a console port
2012 * if we're running on older host.
2013 */
2014 add_port(portdev, 0);
Amit Shah17634ba2009-12-21 21:03:25 +05302015 }
2016
Amit Shah6bdf2af2010-09-02 18:11:49 +05302017 spin_lock_irq(&pdrvdata_lock);
2018 list_add_tail(&portdev->list, &pdrvdata.portdevs);
2019 spin_unlock_irq(&pdrvdata_lock);
2020
Amit Shahf909f852010-05-19 22:15:48 -06002021 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2022 VIRTIO_CONSOLE_DEVICE_READY, 1);
Christian Borntraeger5e384832011-09-22 23:44:23 +05302023
2024 /*
2025 * If there was an early virtio console, assume that there are no
2026 * other consoles. We need to wait until the hvc_alloc matches the
2027 * hvc_instantiate, otherwise tty_open will complain, resulting in
2028 * a "Warning: unable to open an initial console" boot failure.
2029 * Without multiport this is done in add_port above. With multiport
2030 * this might take some host<->guest communication - thus we have to
2031 * wait.
2032 */
2033 if (multiport && early)
2034 wait_for_completion(&early_console_added);
2035
Rusty Russell31610432007-10-22 11:03:39 +10002036 return 0;
2037
Amit Shah22a29ea2010-02-12 10:32:17 +05302038free_vqs:
Julia Lawall0643e4c2010-05-15 11:45:53 +02002039 /* The host might want to notify mgmt sw about device add failure */
2040 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2041 VIRTIO_CONSOLE_DEVICE_READY, 0);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05302042 remove_vqs(portdev);
Amit Shahfb08bd22009-12-21 21:36:04 +05302043free_chrdev:
2044 unregister_chrdev(portdev->chr_major, "virtio-portsdev");
Rusty Russell31610432007-10-22 11:03:39 +10002045free:
Amit Shah1c85bf32010-01-18 19:15:07 +05302046 kfree(portdev);
Rusty Russell31610432007-10-22 11:03:39 +10002047fail:
2048 return err;
2049}
2050
Amit Shah71778762010-02-12 10:32:16 +05302051static void virtcons_remove(struct virtio_device *vdev)
2052{
2053 struct ports_device *portdev;
2054 struct port *port, *port2;
Amit Shah71778762010-02-12 10:32:16 +05302055
2056 portdev = vdev->priv;
2057
Amit Shah6bdf2af2010-09-02 18:11:49 +05302058 spin_lock_irq(&pdrvdata_lock);
2059 list_del(&portdev->list);
2060 spin_unlock_irq(&pdrvdata_lock);
2061
Amit Shah02238952010-09-02 18:11:40 +05302062 /* Disable interrupts for vqs */
2063 vdev->config->reset(vdev);
2064 /* Finish up work that's lined up */
Amit Shah71778762010-02-12 10:32:16 +05302065 cancel_work_sync(&portdev->control_work);
Amit Shah71778762010-02-12 10:32:16 +05302066
2067 list_for_each_entry_safe(port, port2, &portdev->ports, list)
Amit Shahb353a6b2010-09-02 18:38:29 +05302068 unplug_port(port);
Amit Shah71778762010-02-12 10:32:16 +05302069
2070 unregister_chrdev(portdev->chr_major, "virtio-portsdev");
2071
Amit Shahe0620132010-09-02 18:38:30 +05302072 /*
2073 * When yanking out a device, we immediately lose the
2074 * (device-side) queues. So there's no point in keeping the
2075 * guest side around till we drop our final reference. This
2076 * also means that any ports which are in an open state will
2077 * have to just stop using the port, as the vqs are going
2078 * away.
2079 */
Amit Shaha0e2dbf2011-12-22 16:58:27 +05302080 remove_controlq_data(portdev);
2081 remove_vqs(portdev);
Amit Shah71778762010-02-12 10:32:16 +05302082 kfree(portdev);
2083}
2084
Rusty Russell31610432007-10-22 11:03:39 +10002085static struct virtio_device_id id_table[] = {
2086 { VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID },
2087 { 0 },
2088};
2089
Christian Borntraegerc2983452008-11-25 13:36:26 +01002090static unsigned int features[] = {
2091 VIRTIO_CONSOLE_F_SIZE,
Amit Shahb99fa812010-05-19 22:15:46 -06002092 VIRTIO_CONSOLE_F_MULTIPORT,
Christian Borntraegerc2983452008-11-25 13:36:26 +01002093};
2094
Sjur Brændeland1b637042012-12-14 14:40:51 +10302095static struct virtio_device_id rproc_serial_id_table[] = {
2096#if IS_ENABLED(CONFIG_REMOTEPROC)
2097 { VIRTIO_ID_RPROC_SERIAL, VIRTIO_DEV_ANY_ID },
2098#endif
2099 { 0 },
2100};
2101
2102static unsigned int rproc_serial_features[] = {
2103};
2104
Amit Shah2b8f41d2011-12-22 16:58:28 +05302105#ifdef CONFIG_PM
2106static int virtcons_freeze(struct virtio_device *vdev)
2107{
2108 struct ports_device *portdev;
2109 struct port *port;
2110
2111 portdev = vdev->priv;
2112
2113 vdev->config->reset(vdev);
2114
Amit Shahc743d092012-01-06 16:19:08 +05302115 virtqueue_disable_cb(portdev->c_ivq);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302116 cancel_work_sync(&portdev->control_work);
Amit Shahc743d092012-01-06 16:19:08 +05302117 /*
2118 * Once more: if control_work_handler() was running, it would
2119 * enable the cb as the last step.
2120 */
2121 virtqueue_disable_cb(portdev->c_ivq);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302122 remove_controlq_data(portdev);
2123
2124 list_for_each_entry(port, &portdev->ports, list) {
Amit Shahc743d092012-01-06 16:19:08 +05302125 virtqueue_disable_cb(port->in_vq);
2126 virtqueue_disable_cb(port->out_vq);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302127 /*
2128 * We'll ask the host later if the new invocation has
2129 * the port opened or closed.
2130 */
2131 port->host_connected = false;
2132 remove_port_data(port);
2133 }
2134 remove_vqs(portdev);
2135
2136 return 0;
2137}
2138
2139static int virtcons_restore(struct virtio_device *vdev)
2140{
2141 struct ports_device *portdev;
2142 struct port *port;
2143 int ret;
2144
2145 portdev = vdev->priv;
2146
2147 ret = init_vqs(portdev);
2148 if (ret)
2149 return ret;
2150
2151 if (use_multiport(portdev))
2152 fill_queue(portdev->c_ivq, &portdev->cvq_lock);
2153
2154 list_for_each_entry(port, &portdev->ports, list) {
2155 port->in_vq = portdev->in_vqs[port->id];
2156 port->out_vq = portdev->out_vqs[port->id];
2157
2158 fill_queue(port->in_vq, &port->inbuf_lock);
2159
2160 /* Get port open/close status on the host */
2161 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
Amit Shahfa8b66c2012-04-25 14:40:39 +05302162
2163 /*
2164 * If a port was open at the time of suspending, we
2165 * have to let the host know that it's still open.
2166 */
2167 if (port->guest_connected)
2168 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302169 }
2170 return 0;
2171}
2172#endif
2173
Rusty Russell31610432007-10-22 11:03:39 +10002174static struct virtio_driver virtio_console = {
Christian Borntraegerc2983452008-11-25 13:36:26 +01002175 .feature_table = features,
2176 .feature_table_size = ARRAY_SIZE(features),
Rusty Russell31610432007-10-22 11:03:39 +10002177 .driver.name = KBUILD_MODNAME,
2178 .driver.owner = THIS_MODULE,
2179 .id_table = id_table,
2180 .probe = virtcons_probe,
Amit Shah71778762010-02-12 10:32:16 +05302181 .remove = virtcons_remove,
Amit Shah7f5d8102009-12-21 22:22:08 +05302182 .config_changed = config_intr,
Amit Shah2b8f41d2011-12-22 16:58:28 +05302183#ifdef CONFIG_PM
2184 .freeze = virtcons_freeze,
2185 .restore = virtcons_restore,
2186#endif
Rusty Russell31610432007-10-22 11:03:39 +10002187};
2188
Greg Kroah-Hartmanbcd29822012-12-21 15:12:08 -08002189static struct virtio_driver virtio_rproc_serial = {
Sjur Brændeland1b637042012-12-14 14:40:51 +10302190 .feature_table = rproc_serial_features,
2191 .feature_table_size = ARRAY_SIZE(rproc_serial_features),
2192 .driver.name = "virtio_rproc_serial",
2193 .driver.owner = THIS_MODULE,
2194 .id_table = rproc_serial_id_table,
2195 .probe = virtcons_probe,
2196 .remove = virtcons_remove,
2197};
2198
Rusty Russell31610432007-10-22 11:03:39 +10002199static int __init init(void)
2200{
Amit Shahfb08bd22009-12-21 21:36:04 +05302201 int err;
2202
2203 pdrvdata.class = class_create(THIS_MODULE, "virtio-ports");
2204 if (IS_ERR(pdrvdata.class)) {
2205 err = PTR_ERR(pdrvdata.class);
2206 pr_err("Error %d creating virtio-ports class\n", err);
2207 return err;
2208 }
Amit Shahd99393e2009-12-21 22:36:21 +05302209
2210 pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL);
2211 if (!pdrvdata.debugfs_dir) {
2212 pr_warning("Error %ld creating debugfs dir for virtio-ports\n",
2213 PTR_ERR(pdrvdata.debugfs_dir));
2214 }
Amit Shah38edf582010-01-18 19:15:05 +05302215 INIT_LIST_HEAD(&pdrvdata.consoles);
Amit Shah6bdf2af2010-09-02 18:11:49 +05302216 INIT_LIST_HEAD(&pdrvdata.portdevs);
Amit Shah38edf582010-01-18 19:15:05 +05302217
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002218 err = register_virtio_driver(&virtio_console);
2219 if (err < 0) {
2220 pr_err("Error %d registering virtio driver\n", err);
2221 goto free;
2222 }
Sjur Brændeland1b637042012-12-14 14:40:51 +10302223 err = register_virtio_driver(&virtio_rproc_serial);
2224 if (err < 0) {
2225 pr_err("Error %d registering virtio rproc serial driver\n",
2226 err);
2227 goto unregister;
2228 }
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002229 return 0;
Sjur Brændeland1b637042012-12-14 14:40:51 +10302230unregister:
2231 unregister_virtio_driver(&virtio_console);
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002232free:
2233 if (pdrvdata.debugfs_dir)
2234 debugfs_remove_recursive(pdrvdata.debugfs_dir);
2235 class_destroy(pdrvdata.class);
2236 return err;
Rusty Russell31610432007-10-22 11:03:39 +10002237}
Amit Shah71778762010-02-12 10:32:16 +05302238
2239static void __exit fini(void)
2240{
Sjur Brændeland1b637042012-12-14 14:40:51 +10302241 reclaim_dma_bufs();
2242
Amit Shah71778762010-02-12 10:32:16 +05302243 unregister_virtio_driver(&virtio_console);
Sjur Brændeland1b637042012-12-14 14:40:51 +10302244 unregister_virtio_driver(&virtio_rproc_serial);
Amit Shah71778762010-02-12 10:32:16 +05302245
2246 class_destroy(pdrvdata.class);
2247 if (pdrvdata.debugfs_dir)
2248 debugfs_remove_recursive(pdrvdata.debugfs_dir);
2249}
Rusty Russell31610432007-10-22 11:03:39 +10002250module_init(init);
Amit Shah71778762010-02-12 10:32:16 +05302251module_exit(fini);
Rusty Russell31610432007-10-22 11:03:39 +10002252
2253MODULE_DEVICE_TABLE(virtio, id_table);
2254MODULE_DESCRIPTION("Virtio console driver");
2255MODULE_LICENSE("GPL");