blob: d2406fe2553396a807a169ddd93b656a4876a537 [file] [log] [blame]
Rusty Russella23ea922010-01-18 19:14:55 +05301/*
2 * Copyright (C) 2006, 2007, 2009 Rusty Russell, IBM Corporation
Amit Shah5084f892011-01-31 13:06:37 +05303 * Copyright (C) 2009, 2010, 2011 Red Hat, Inc.
4 * Copyright (C) 2009, 2010, 2011 Amit Shah <amit.shah@redhat.com>
Rusty Russell31610432007-10-22 11:03:39 +10005 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
Amit Shahfb08bd22009-12-21 21:36:04 +053020#include <linux/cdev.h>
Amit Shahd99393e2009-12-21 22:36:21 +053021#include <linux/debugfs.h>
Christian Borntraeger5e384832011-09-22 23:44:23 +053022#include <linux/completion.h>
Amit Shahfb08bd22009-12-21 21:36:04 +053023#include <linux/device.h>
Rusty Russell31610432007-10-22 11:03:39 +100024#include <linux/err.h>
Amit Shaha08fa922011-09-14 13:06:41 +053025#include <linux/freezer.h>
Amit Shah2030fa42009-12-21 21:49:30 +053026#include <linux/fs.h>
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +090027#include <linux/splice.h>
28#include <linux/pagemap.h>
Rusty Russell31610432007-10-22 11:03:39 +100029#include <linux/init.h>
Amit Shah38edf582010-01-18 19:15:05 +053030#include <linux/list.h>
Amit Shah2030fa42009-12-21 21:49:30 +053031#include <linux/poll.h>
32#include <linux/sched.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090033#include <linux/slab.h>
Amit Shah38edf582010-01-18 19:15:05 +053034#include <linux/spinlock.h>
Rusty Russell31610432007-10-22 11:03:39 +100035#include <linux/virtio.h>
36#include <linux/virtio_console.h>
Amit Shah2030fa42009-12-21 21:49:30 +053037#include <linux/wait.h>
Amit Shah17634ba2009-12-21 21:03:25 +053038#include <linux/workqueue.h>
Paul Gortmakerc22405c2011-07-03 13:35:48 -040039#include <linux/module.h>
Sjur Brændeland1b637042012-12-14 14:40:51 +103040#include <linux/dma-mapping.h>
41#include <linux/kconfig.h>
Amit Shah51df0ac2011-02-01 09:31:25 +053042#include "../tty/hvc/hvc_console.h"
Rusty Russell31610432007-10-22 11:03:39 +100043
Sjur Brændeland1b637042012-12-14 14:40:51 +103044#define is_rproc_enabled IS_ENABLED(CONFIG_REMOTEPROC)
45
Amit Shah38edf582010-01-18 19:15:05 +053046/*
47 * This is a global struct for storing common data for all the devices
48 * this driver handles.
49 *
50 * Mainly, it has a linked list for all the consoles in one place so
51 * that callbacks from hvc for get_chars(), put_chars() work properly
52 * across multiple devices and multiple ports per device.
53 */
54struct ports_driver_data {
Amit Shahfb08bd22009-12-21 21:36:04 +053055 /* Used for registering chardevs */
56 struct class *class;
57
Amit Shahd99393e2009-12-21 22:36:21 +053058 /* Used for exporting per-port information to debugfs */
59 struct dentry *debugfs_dir;
60
Amit Shah6bdf2af2010-09-02 18:11:49 +053061 /* List of all the devices we're handling */
62 struct list_head portdevs;
63
Rusty Russelld8a02bd2010-01-18 19:15:06 +053064 /*
65 * This is used to keep track of the number of hvc consoles
66 * spawned by this driver. This number is given as the first
67 * argument to hvc_alloc(). To correctly map an initial
68 * console spawned via hvc_instantiate to the console being
69 * hooked up via hvc_alloc, we need to pass the same vtermno.
70 *
71 * We also just assume the first console being initialised was
72 * the first one that got used as the initial console.
73 */
74 unsigned int next_vtermno;
75
Amit Shah38edf582010-01-18 19:15:05 +053076 /* All the console devices handled by this driver */
77 struct list_head consoles;
78};
79static struct ports_driver_data pdrvdata;
80
Wei Yongjun38268352013-04-08 16:13:59 +093081static DEFINE_SPINLOCK(pdrvdata_lock);
82static DECLARE_COMPLETION(early_console_added);
Amit Shah38edf582010-01-18 19:15:05 +053083
Amit Shah4f23c572010-01-18 19:15:09 +053084/* This struct holds information that's relevant only for console ports */
85struct console {
86 /* We'll place all consoles in a list in the pdrvdata struct */
87 struct list_head list;
88
89 /* The hvc device associated with this console port */
90 struct hvc_struct *hvc;
91
Amit Shah97788292010-05-06 02:05:08 +053092 /* The size of the console */
93 struct winsize ws;
94
Amit Shah4f23c572010-01-18 19:15:09 +053095 /*
96 * This number identifies the number that we used to register
97 * with hvc in hvc_instantiate() and hvc_alloc(); this is the
98 * number passed on by the hvc callbacks to us to
99 * differentiate between the other console ports handled by
100 * this driver
101 */
102 u32 vtermno;
103};
104
Amit Shahfdb9a052010-01-18 19:15:01 +0530105struct port_buffer {
106 char *buf;
107
108 /* size of the buffer in *buf above */
109 size_t size;
110
111 /* used length of the buffer */
112 size_t len;
113 /* offset in the buf from which to consume data */
114 size_t offset;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030115
Sjur Brændeland1b637042012-12-14 14:40:51 +1030116 /* DMA address of buffer */
117 dma_addr_t dma;
118
119 /* Device we got DMA memory from */
120 struct device *dev;
121
122 /* List of pending dma buffers to free */
123 struct list_head list;
124
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030125 /* If sgpages == 0 then buf is used */
126 unsigned int sgpages;
127
128 /* sg is used if spages > 0. sg must be the last in is struct */
129 struct scatterlist sg[0];
Amit Shahfdb9a052010-01-18 19:15:01 +0530130};
131
Amit Shah17634ba2009-12-21 21:03:25 +0530132/*
133 * This is a per-device struct that stores data common to all the
134 * ports for that device (vdev->priv).
135 */
136struct ports_device {
Amit Shah6bdf2af2010-09-02 18:11:49 +0530137 /* Next portdev in the list, head is in the pdrvdata struct */
138 struct list_head list;
139
Amit Shah17634ba2009-12-21 21:03:25 +0530140 /*
141 * Workqueue handlers where we process deferred work after
142 * notification
143 */
144 struct work_struct control_work;
Michael S. Tsirkineeb8a7e2015-03-05 10:45:49 +1030145 struct work_struct config_work;
Amit Shah17634ba2009-12-21 21:03:25 +0530146
147 struct list_head ports;
148
149 /* To protect the list of ports */
150 spinlock_t ports_lock;
151
152 /* To protect the vq operations for the control channel */
Amit Shah165b1b82013-03-29 16:30:07 +0530153 spinlock_t c_ivq_lock;
Amit Shah9ba5c802013-03-29 16:30:08 +0530154 spinlock_t c_ovq_lock;
Amit Shah17634ba2009-12-21 21:03:25 +0530155
156 /* The current config space is stored here */
Amit Shahb99fa812010-05-19 22:15:46 -0600157 struct virtio_console_config config;
Amit Shah17634ba2009-12-21 21:03:25 +0530158
159 /* The virtio device we're associated with */
160 struct virtio_device *vdev;
161
162 /*
163 * A couple of virtqueues for the control channel: one for
164 * guest->host transfers, one for host->guest transfers
165 */
166 struct virtqueue *c_ivq, *c_ovq;
167
168 /* Array of per-port IO virtqueues */
169 struct virtqueue **in_vqs, **out_vqs;
Amit Shahfb08bd22009-12-21 21:36:04 +0530170
Amit Shahfb08bd22009-12-21 21:36:04 +0530171 /* Major number for this device. Ports will be created as minors. */
172 int chr_major;
Amit Shah17634ba2009-12-21 21:03:25 +0530173};
174
Amit Shah17e5b4f2011-09-14 13:06:46 +0530175struct port_stats {
176 unsigned long bytes_sent, bytes_received, bytes_discarded;
177};
178
Amit Shah1c85bf32010-01-18 19:15:07 +0530179/* This struct holds the per-port data */
Rusty Russell21206ed2010-01-18 19:15:00 +0530180struct port {
Amit Shah17634ba2009-12-21 21:03:25 +0530181 /* Next port in the list, head is in the ports_device */
182 struct list_head list;
183
Amit Shah1c85bf32010-01-18 19:15:07 +0530184 /* Pointer to the parent virtio_console device */
185 struct ports_device *portdev;
Amit Shahfdb9a052010-01-18 19:15:01 +0530186
187 /* The current buffer from which data has to be fed to readers */
188 struct port_buffer *inbuf;
Rusty Russell31610432007-10-22 11:03:39 +1000189
Amit Shah203baab2010-01-18 19:15:12 +0530190 /*
191 * To protect the operations on the in_vq associated with this
192 * port. Has to be a spinlock because it can be called from
193 * interrupt context (get_char()).
194 */
195 spinlock_t inbuf_lock;
196
Amit Shahcdfadfc2010-05-19 22:15:50 -0600197 /* Protect the operations on the out_vq. */
198 spinlock_t outvq_lock;
199
Amit Shah1c85bf32010-01-18 19:15:07 +0530200 /* The IO vqs for this port */
201 struct virtqueue *in_vq, *out_vq;
202
Amit Shahd99393e2009-12-21 22:36:21 +0530203 /* File in the debugfs directory that exposes this port's information */
204 struct dentry *debugfs_file;
205
Amit Shah4f23c572010-01-18 19:15:09 +0530206 /*
Amit Shah17e5b4f2011-09-14 13:06:46 +0530207 * Keep count of the bytes sent, received and discarded for
208 * this port for accounting and debugging purposes. These
209 * counts are not reset across port open / close events.
210 */
211 struct port_stats stats;
212
213 /*
Amit Shah4f23c572010-01-18 19:15:09 +0530214 * The entries in this struct will be valid if this port is
215 * hooked up to an hvc console
216 */
217 struct console cons;
Amit Shah17634ba2009-12-21 21:03:25 +0530218
Amit Shahfb08bd22009-12-21 21:36:04 +0530219 /* Each port associates with a separate char device */
Amit Shahd22a6982010-09-02 18:20:59 +0530220 struct cdev *cdev;
Amit Shahfb08bd22009-12-21 21:36:04 +0530221 struct device *dev;
222
Amit Shahb353a6b2010-09-02 18:38:29 +0530223 /* Reference-counting to handle port hot-unplugs and file operations */
224 struct kref kref;
225
Amit Shah2030fa42009-12-21 21:49:30 +0530226 /* A waitqueue for poll() or blocking read operations */
227 wait_queue_head_t waitqueue;
228
Amit Shah431edb82009-12-21 21:57:40 +0530229 /* The 'name' of the port that we expose via sysfs properties */
230 char *name;
231
Amit Shah3eae0ad2010-09-02 18:47:52 +0530232 /* We can notify apps of host connect / disconnect events via SIGIO */
233 struct fasync_struct *async_queue;
234
Amit Shah17634ba2009-12-21 21:03:25 +0530235 /* The 'id' to identify the port with the Host */
236 u32 id;
Amit Shah2030fa42009-12-21 21:49:30 +0530237
Amit Shahcdfadfc2010-05-19 22:15:50 -0600238 bool outvq_full;
239
Amit Shah2030fa42009-12-21 21:49:30 +0530240 /* Is the host device open */
241 bool host_connected;
Amit Shah3c7969c2009-11-26 11:25:38 +0530242
243 /* We should allow only one process to open a port */
244 bool guest_connected;
Rusty Russell21206ed2010-01-18 19:15:00 +0530245};
Rusty Russell31610432007-10-22 11:03:39 +1000246
Rusty Russell971f3392010-01-18 19:14:56 +0530247/* This is the very early arch-specified put chars function. */
248static int (*early_put_chars)(u32, const char *, int);
249
Amit Shah38edf582010-01-18 19:15:05 +0530250static struct port *find_port_by_vtermno(u32 vtermno)
251{
252 struct port *port;
Amit Shah4f23c572010-01-18 19:15:09 +0530253 struct console *cons;
Amit Shah38edf582010-01-18 19:15:05 +0530254 unsigned long flags;
255
256 spin_lock_irqsave(&pdrvdata_lock, flags);
Amit Shah4f23c572010-01-18 19:15:09 +0530257 list_for_each_entry(cons, &pdrvdata.consoles, list) {
258 if (cons->vtermno == vtermno) {
259 port = container_of(cons, struct port, cons);
Amit Shah38edf582010-01-18 19:15:05 +0530260 goto out;
Amit Shah4f23c572010-01-18 19:15:09 +0530261 }
Amit Shah38edf582010-01-18 19:15:05 +0530262 }
263 port = NULL;
264out:
265 spin_unlock_irqrestore(&pdrvdata_lock, flags);
266 return port;
267}
268
Amit Shah04950cd2010-09-02 18:20:58 +0530269static struct port *find_port_by_devt_in_portdev(struct ports_device *portdev,
270 dev_t dev)
271{
272 struct port *port;
273 unsigned long flags;
274
275 spin_lock_irqsave(&portdev->ports_lock, flags);
Amit Shah057b82b2013-07-29 14:16:13 +0930276 list_for_each_entry(port, &portdev->ports, list) {
277 if (port->cdev->dev == dev) {
278 kref_get(&port->kref);
Amit Shah04950cd2010-09-02 18:20:58 +0530279 goto out;
Amit Shah057b82b2013-07-29 14:16:13 +0930280 }
281 }
Amit Shah04950cd2010-09-02 18:20:58 +0530282 port = NULL;
283out:
284 spin_unlock_irqrestore(&portdev->ports_lock, flags);
285
286 return port;
287}
288
289static struct port *find_port_by_devt(dev_t dev)
290{
291 struct ports_device *portdev;
292 struct port *port;
293 unsigned long flags;
294
295 spin_lock_irqsave(&pdrvdata_lock, flags);
296 list_for_each_entry(portdev, &pdrvdata.portdevs, list) {
297 port = find_port_by_devt_in_portdev(portdev, dev);
298 if (port)
299 goto out;
300 }
301 port = NULL;
302out:
303 spin_unlock_irqrestore(&pdrvdata_lock, flags);
304 return port;
305}
306
Amit Shah17634ba2009-12-21 21:03:25 +0530307static struct port *find_port_by_id(struct ports_device *portdev, u32 id)
308{
309 struct port *port;
310 unsigned long flags;
311
312 spin_lock_irqsave(&portdev->ports_lock, flags);
313 list_for_each_entry(port, &portdev->ports, list)
314 if (port->id == id)
315 goto out;
316 port = NULL;
317out:
318 spin_unlock_irqrestore(&portdev->ports_lock, flags);
319
320 return port;
321}
322
Amit Shah203baab2010-01-18 19:15:12 +0530323static struct port *find_port_by_vq(struct ports_device *portdev,
324 struct virtqueue *vq)
325{
326 struct port *port;
Amit Shah203baab2010-01-18 19:15:12 +0530327 unsigned long flags;
328
Amit Shah17634ba2009-12-21 21:03:25 +0530329 spin_lock_irqsave(&portdev->ports_lock, flags);
330 list_for_each_entry(port, &portdev->ports, list)
Amit Shah203baab2010-01-18 19:15:12 +0530331 if (port->in_vq == vq || port->out_vq == vq)
332 goto out;
Amit Shah203baab2010-01-18 19:15:12 +0530333 port = NULL;
334out:
Amit Shah17634ba2009-12-21 21:03:25 +0530335 spin_unlock_irqrestore(&portdev->ports_lock, flags);
Amit Shah203baab2010-01-18 19:15:12 +0530336 return port;
337}
338
Amit Shah17634ba2009-12-21 21:03:25 +0530339static bool is_console_port(struct port *port)
340{
341 if (port->cons.hvc)
342 return true;
343 return false;
344}
345
Sjur Brændeland1b637042012-12-14 14:40:51 +1030346static bool is_rproc_serial(const struct virtio_device *vdev)
347{
348 return is_rproc_enabled && vdev->id.device == VIRTIO_ID_RPROC_SERIAL;
349}
350
Amit Shah17634ba2009-12-21 21:03:25 +0530351static inline bool use_multiport(struct ports_device *portdev)
352{
353 /*
354 * This condition can be true when put_chars is called from
355 * early_init
356 */
357 if (!portdev->vdev)
Joe Perchesf580d732015-03-30 16:46:10 -0700358 return false;
Michael S. Tsirkine16e12b2014-10-07 16:39:42 +0200359 return __virtio_test_bit(portdev->vdev, VIRTIO_CONSOLE_F_MULTIPORT);
Amit Shah17634ba2009-12-21 21:03:25 +0530360}
361
Sjur Brændeland1b637042012-12-14 14:40:51 +1030362static DEFINE_SPINLOCK(dma_bufs_lock);
363static LIST_HEAD(pending_free_dma_bufs);
364
365static void free_buf(struct port_buffer *buf, bool can_sleep)
Amit Shahfdb9a052010-01-18 19:15:01 +0530366{
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030367 unsigned int i;
368
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030369 for (i = 0; i < buf->sgpages; i++) {
370 struct page *page = sg_page(&buf->sg[i]);
371 if (!page)
372 break;
373 put_page(page);
374 }
375
Sjur Brændeland1b637042012-12-14 14:40:51 +1030376 if (!buf->dev) {
377 kfree(buf->buf);
378 } else if (is_rproc_enabled) {
379 unsigned long flags;
380
381 /* dma_free_coherent requires interrupts to be enabled. */
382 if (!can_sleep) {
383 /* queue up dma-buffers to be freed later */
384 spin_lock_irqsave(&dma_bufs_lock, flags);
385 list_add_tail(&buf->list, &pending_free_dma_bufs);
386 spin_unlock_irqrestore(&dma_bufs_lock, flags);
387 return;
388 }
389 dma_free_coherent(buf->dev, buf->size, buf->buf, buf->dma);
390
391 /* Release device refcnt and allow it to be freed */
392 put_device(buf->dev);
393 }
394
Amit Shahfdb9a052010-01-18 19:15:01 +0530395 kfree(buf);
396}
397
Sjur Brændeland1b637042012-12-14 14:40:51 +1030398static void reclaim_dma_bufs(void)
399{
400 unsigned long flags;
401 struct port_buffer *buf, *tmp;
402 LIST_HEAD(tmp_list);
403
404 if (list_empty(&pending_free_dma_bufs))
405 return;
406
407 /* Create a copy of the pending_free_dma_bufs while holding the lock */
408 spin_lock_irqsave(&dma_bufs_lock, flags);
409 list_cut_position(&tmp_list, &pending_free_dma_bufs,
410 pending_free_dma_bufs.prev);
411 spin_unlock_irqrestore(&dma_bufs_lock, flags);
412
413 /* Release the dma buffers, without irqs enabled */
414 list_for_each_entry_safe(buf, tmp, &tmp_list, list) {
415 list_del(&buf->list);
416 free_buf(buf, true);
417 }
418}
419
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030420static struct port_buffer *alloc_buf(struct virtqueue *vq, size_t buf_size,
421 int pages)
Amit Shahfdb9a052010-01-18 19:15:01 +0530422{
423 struct port_buffer *buf;
424
Sjur Brændeland1b637042012-12-14 14:40:51 +1030425 reclaim_dma_bufs();
426
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030427 /*
428 * Allocate buffer and the sg list. The sg list array is allocated
429 * directly after the port_buffer struct.
430 */
431 buf = kmalloc(sizeof(*buf) + sizeof(struct scatterlist) * pages,
432 GFP_KERNEL);
Amit Shahfdb9a052010-01-18 19:15:01 +0530433 if (!buf)
434 goto fail;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030435
436 buf->sgpages = pages;
437 if (pages > 0) {
Sjur Brændeland1b637042012-12-14 14:40:51 +1030438 buf->dev = NULL;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030439 buf->buf = NULL;
440 return buf;
441 }
442
Sjur Brændeland1b637042012-12-14 14:40:51 +1030443 if (is_rproc_serial(vq->vdev)) {
444 /*
445 * Allocate DMA memory from ancestor. When a virtio
446 * device is created by remoteproc, the DMA memory is
447 * associated with the grandparent device:
448 * vdev => rproc => platform-dev.
449 * The code here would have been less quirky if
450 * DMA_MEMORY_INCLUDES_CHILDREN had been supported
451 * in dma-coherent.c
452 */
453 if (!vq->vdev->dev.parent || !vq->vdev->dev.parent->parent)
454 goto free_buf;
455 buf->dev = vq->vdev->dev.parent->parent;
456
457 /* Increase device refcnt to avoid freeing it */
458 get_device(buf->dev);
459 buf->buf = dma_alloc_coherent(buf->dev, buf_size, &buf->dma,
460 GFP_KERNEL);
461 } else {
462 buf->dev = NULL;
463 buf->buf = kmalloc(buf_size, GFP_KERNEL);
464 }
465
Amit Shahfdb9a052010-01-18 19:15:01 +0530466 if (!buf->buf)
467 goto free_buf;
468 buf->len = 0;
469 buf->offset = 0;
470 buf->size = buf_size;
471 return buf;
472
473free_buf:
474 kfree(buf);
475fail:
476 return NULL;
477}
478
Amit Shaha3cde442010-01-18 19:15:03 +0530479/* Callers should take appropriate locks */
Amit Shahdefde662011-09-14 13:06:42 +0530480static struct port_buffer *get_inbuf(struct port *port)
Amit Shaha3cde442010-01-18 19:15:03 +0530481{
482 struct port_buffer *buf;
Amit Shaha3cde442010-01-18 19:15:03 +0530483 unsigned int len;
484
Amit Shahd25a9dd2011-09-14 13:06:43 +0530485 if (port->inbuf)
486 return port->inbuf;
487
488 buf = virtqueue_get_buf(port->in_vq, &len);
Amit Shaha3cde442010-01-18 19:15:03 +0530489 if (buf) {
490 buf->len = len;
491 buf->offset = 0;
Amit Shah17e5b4f2011-09-14 13:06:46 +0530492 port->stats.bytes_received += len;
Amit Shaha3cde442010-01-18 19:15:03 +0530493 }
494 return buf;
495}
496
Rusty Russella23ea922010-01-18 19:14:55 +0530497/*
Amit Shahe27b5192010-01-18 19:15:02 +0530498 * Create a scatter-gather list representing our input buffer and put
499 * it in the queue.
500 *
501 * Callers should take appropriate locks.
502 */
Amit Shah203baab2010-01-18 19:15:12 +0530503static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)
Amit Shahe27b5192010-01-18 19:15:02 +0530504{
505 struct scatterlist sg[1];
Amit Shah203baab2010-01-18 19:15:12 +0530506 int ret;
Amit Shah1c85bf32010-01-18 19:15:07 +0530507
Amit Shahe27b5192010-01-18 19:15:02 +0530508 sg_init_one(sg, buf->buf, buf->size);
509
Rusty Russell67979992013-03-20 15:44:29 +1030510 ret = virtqueue_add_inbuf(vq, sg, 1, buf, GFP_ATOMIC);
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300511 virtqueue_kick(vq);
Amit Shah49e86f12012-12-10 09:45:12 +1030512 if (!ret)
513 ret = vq->num_free;
Amit Shah203baab2010-01-18 19:15:12 +0530514 return ret;
515}
516
Amit Shah88f251a2009-12-21 22:15:30 +0530517/* Discard any unread data this port has. Callers lockers. */
518static void discard_port_data(struct port *port)
519{
520 struct port_buffer *buf;
Amit Shah2d24cda2011-09-14 13:06:45 +0530521 unsigned int err;
Amit Shah88f251a2009-12-21 22:15:30 +0530522
Amit Shahd7a62cd2011-03-04 14:04:33 +1030523 if (!port->portdev) {
524 /* Device has been unplugged. vqs are already gone. */
525 return;
526 }
Amit Shah2d24cda2011-09-14 13:06:45 +0530527 buf = get_inbuf(port);
Amit Shah88f251a2009-12-21 22:15:30 +0530528
Amit Shahce072a02011-09-14 13:06:44 +0530529 err = 0;
Amit Shahd6933562010-02-12 10:32:18 +0530530 while (buf) {
Amit Shah17e5b4f2011-09-14 13:06:46 +0530531 port->stats.bytes_discarded += buf->len - buf->offset;
Amit Shah2d24cda2011-09-14 13:06:45 +0530532 if (add_inbuf(port->in_vq, buf) < 0) {
Amit Shahce072a02011-09-14 13:06:44 +0530533 err++;
Sjur Brændeland1b637042012-12-14 14:40:51 +1030534 free_buf(buf, false);
Amit Shahd6933562010-02-12 10:32:18 +0530535 }
Amit Shah2d24cda2011-09-14 13:06:45 +0530536 port->inbuf = NULL;
537 buf = get_inbuf(port);
Amit Shah88f251a2009-12-21 22:15:30 +0530538 }
Amit Shahce072a02011-09-14 13:06:44 +0530539 if (err)
Amit Shahd6933562010-02-12 10:32:18 +0530540 dev_warn(port->dev, "Errors adding %d buffers back to vq\n",
Amit Shahce072a02011-09-14 13:06:44 +0530541 err);
Amit Shah88f251a2009-12-21 22:15:30 +0530542}
543
Amit Shah203baab2010-01-18 19:15:12 +0530544static bool port_has_data(struct port *port)
545{
546 unsigned long flags;
547 bool ret;
548
Amit Shahd6933562010-02-12 10:32:18 +0530549 ret = false;
Amit Shahd25a9dd2011-09-14 13:06:43 +0530550 spin_lock_irqsave(&port->inbuf_lock, flags);
551 port->inbuf = get_inbuf(port);
552 if (port->inbuf)
553 ret = true;
554
Amit Shah203baab2010-01-18 19:15:12 +0530555 spin_unlock_irqrestore(&port->inbuf_lock, flags);
Amit Shah203baab2010-01-18 19:15:12 +0530556 return ret;
557}
558
Amit Shah3425e702010-05-19 22:15:46 -0600559static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id,
560 unsigned int event, unsigned int value)
Amit Shah17634ba2009-12-21 21:03:25 +0530561{
562 struct scatterlist sg[1];
563 struct virtio_console_control cpkt;
564 struct virtqueue *vq;
Amit Shah604b2ad2010-02-24 10:36:51 +0530565 unsigned int len;
Amit Shah17634ba2009-12-21 21:03:25 +0530566
Amit Shah3425e702010-05-19 22:15:46 -0600567 if (!use_multiport(portdev))
Amit Shah17634ba2009-12-21 21:03:25 +0530568 return 0;
569
Michael S. Tsirkin1f0f9102014-12-01 13:17:40 +0200570 cpkt.id = cpu_to_virtio32(portdev->vdev, port_id);
571 cpkt.event = cpu_to_virtio16(portdev->vdev, event);
572 cpkt.value = cpu_to_virtio16(portdev->vdev, value);
Amit Shah17634ba2009-12-21 21:03:25 +0530573
Amit Shah3425e702010-05-19 22:15:46 -0600574 vq = portdev->c_ovq;
Amit Shah17634ba2009-12-21 21:03:25 +0530575
576 sg_init_one(sg, &cpkt, sizeof(cpkt));
Amit Shah9ba5c802013-03-29 16:30:08 +0530577
578 spin_lock(&portdev->c_ovq_lock);
Rusty Russell67979992013-03-20 15:44:29 +1030579 if (virtqueue_add_outbuf(vq, sg, 1, &cpkt, GFP_ATOMIC) == 0) {
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300580 virtqueue_kick(vq);
Heinz Graalfs40e4dc52013-10-29 09:40:39 +1030581 while (!virtqueue_get_buf(vq, &len)
582 && !virtqueue_is_broken(vq))
Amit Shah17634ba2009-12-21 21:03:25 +0530583 cpu_relax();
584 }
Amit Shah9ba5c802013-03-29 16:30:08 +0530585 spin_unlock(&portdev->c_ovq_lock);
Amit Shah17634ba2009-12-21 21:03:25 +0530586 return 0;
587}
588
Amit Shah3425e702010-05-19 22:15:46 -0600589static ssize_t send_control_msg(struct port *port, unsigned int event,
590 unsigned int value)
591{
Amit Shah84ec06c2010-09-02 18:11:42 +0530592 /* Did the port get unplugged before userspace closed it? */
593 if (port->portdev)
594 return __send_control_msg(port->portdev, port->id, event, value);
595 return 0;
Amit Shah3425e702010-05-19 22:15:46 -0600596}
597
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900598
Amit Shahcdfadfc2010-05-19 22:15:50 -0600599/* Callers must take the port->outvq_lock */
600static void reclaim_consumed_buffers(struct port *port)
601{
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030602 struct port_buffer *buf;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600603 unsigned int len;
604
Amit Shahd7a62cd2011-03-04 14:04:33 +1030605 if (!port->portdev) {
606 /* Device has been unplugged. vqs are already gone. */
607 return;
608 }
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030609 while ((buf = virtqueue_get_buf(port->out_vq, &len))) {
Sjur Brændeland1b637042012-12-14 14:40:51 +1030610 free_buf(buf, false);
Amit Shahcdfadfc2010-05-19 22:15:50 -0600611 port->outvq_full = false;
612 }
613}
614
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900615static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,
616 int nents, size_t in_count,
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030617 void *data, bool nonblock)
Amit Shahf997f00b2009-12-21 17:28:51 +0530618{
Amit Shahf997f00b2009-12-21 17:28:51 +0530619 struct virtqueue *out_vq;
Rusty Russell589575a2012-10-16 23:56:15 +1030620 int err;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600621 unsigned long flags;
Amit Shahf997f00b2009-12-21 17:28:51 +0530622 unsigned int len;
623
624 out_vq = port->out_vq;
625
Amit Shahcdfadfc2010-05-19 22:15:50 -0600626 spin_lock_irqsave(&port->outvq_lock, flags);
627
628 reclaim_consumed_buffers(port);
629
Rusty Russell67979992013-03-20 15:44:29 +1030630 err = virtqueue_add_outbuf(out_vq, sg, nents, data, GFP_ATOMIC);
Amit Shahf997f00b2009-12-21 17:28:51 +0530631
632 /* Tell Host to go! */
Michael S. Tsirkin505b0452010-04-12 16:18:32 +0300633 virtqueue_kick(out_vq);
Amit Shahf997f00b2009-12-21 17:28:51 +0530634
Rusty Russell589575a2012-10-16 23:56:15 +1030635 if (err) {
Rusty Russell9ff4cfa2010-04-08 09:46:16 -0600636 in_count = 0;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600637 goto done;
Amit Shahf997f00b2009-12-21 17:28:51 +0530638 }
639
Rusty Russell589575a2012-10-16 23:56:15 +1030640 if (out_vq->num_free == 0)
Amit Shahcdfadfc2010-05-19 22:15:50 -0600641 port->outvq_full = true;
642
643 if (nonblock)
644 goto done;
645
646 /*
647 * Wait till the host acknowledges it pushed out the data we
Amit Shah531295e2010-10-20 13:45:43 +1030648 * sent. This is done for data from the hvc_console; the tty
649 * operations are performed with spinlocks held so we can't
650 * sleep here. An alternative would be to copy the data to a
651 * buffer and relax the spinning requirement. The downside is
652 * we need to kmalloc a GFP_ATOMIC buffer each time the
653 * console driver writes something out.
Amit Shahcdfadfc2010-05-19 22:15:50 -0600654 */
Heinz Graalfs40e4dc52013-10-29 09:40:39 +1030655 while (!virtqueue_get_buf(out_vq, &len)
656 && !virtqueue_is_broken(out_vq))
Amit Shahf997f00b2009-12-21 17:28:51 +0530657 cpu_relax();
Amit Shahcdfadfc2010-05-19 22:15:50 -0600658done:
659 spin_unlock_irqrestore(&port->outvq_lock, flags);
Amit Shah17e5b4f2011-09-14 13:06:46 +0530660
661 port->stats.bytes_sent += in_count;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600662 /*
663 * We're expected to return the amount of data we wrote -- all
664 * of it
665 */
Rusty Russell9ff4cfa2010-04-08 09:46:16 -0600666 return in_count;
Amit Shahf997f00b2009-12-21 17:28:51 +0530667}
668
Amit Shah203baab2010-01-18 19:15:12 +0530669/*
670 * Give out the data that's requested from the buffer that we have
671 * queued up.
672 */
Michael S. Tsirkin48b36062014-12-01 13:31:45 +0200673static ssize_t fill_readbuf(struct port *port, char __user *out_buf,
674 size_t out_count, bool to_user)
Amit Shah203baab2010-01-18 19:15:12 +0530675{
676 struct port_buffer *buf;
677 unsigned long flags;
678
679 if (!out_count || !port_has_data(port))
680 return 0;
681
682 buf = port->inbuf;
Amit Shahb766cee2009-12-21 21:26:45 +0530683 out_count = min(out_count, buf->len - buf->offset);
Amit Shah203baab2010-01-18 19:15:12 +0530684
Amit Shahb766cee2009-12-21 21:26:45 +0530685 if (to_user) {
686 ssize_t ret;
Amit Shah203baab2010-01-18 19:15:12 +0530687
Amit Shahb766cee2009-12-21 21:26:45 +0530688 ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count);
689 if (ret)
690 return -EFAULT;
691 } else {
Michael S. Tsirkin48b36062014-12-01 13:31:45 +0200692 memcpy((__force char *)out_buf, buf->buf + buf->offset,
693 out_count);
Amit Shahb766cee2009-12-21 21:26:45 +0530694 }
695
Amit Shah203baab2010-01-18 19:15:12 +0530696 buf->offset += out_count;
697
698 if (buf->offset == buf->len) {
699 /*
700 * We're done using all the data in this buffer.
701 * Re-queue so that the Host can send us more data.
702 */
703 spin_lock_irqsave(&port->inbuf_lock, flags);
704 port->inbuf = NULL;
705
706 if (add_inbuf(port->in_vq, buf) < 0)
Amit Shahfb08bd22009-12-21 21:36:04 +0530707 dev_warn(port->dev, "failed add_buf\n");
Amit Shah203baab2010-01-18 19:15:12 +0530708
709 spin_unlock_irqrestore(&port->inbuf_lock, flags);
710 }
Amit Shahb766cee2009-12-21 21:26:45 +0530711 /* Return the number of bytes actually copied */
Amit Shah203baab2010-01-18 19:15:12 +0530712 return out_count;
Amit Shahe27b5192010-01-18 19:15:02 +0530713}
714
Amit Shah2030fa42009-12-21 21:49:30 +0530715/* The condition that must be true for polling to end */
Amit Shah60caacd2010-05-19 22:15:49 -0600716static bool will_read_block(struct port *port)
Amit Shah2030fa42009-12-21 21:49:30 +0530717{
Amit Shah3709ea72010-09-02 18:11:43 +0530718 if (!port->guest_connected) {
719 /* Port got hot-unplugged. Let's exit. */
720 return false;
721 }
Amit Shah60caacd2010-05-19 22:15:49 -0600722 return !port_has_data(port) && port->host_connected;
Amit Shah2030fa42009-12-21 21:49:30 +0530723}
724
Amit Shahcdfadfc2010-05-19 22:15:50 -0600725static bool will_write_block(struct port *port)
726{
727 bool ret;
728
Amit Shah60e5e0b2010-05-27 13:24:40 +0530729 if (!port->guest_connected) {
730 /* Port got hot-unplugged. Let's exit. */
731 return false;
732 }
Amit Shahcdfadfc2010-05-19 22:15:50 -0600733 if (!port->host_connected)
734 return true;
735
736 spin_lock_irq(&port->outvq_lock);
737 /*
738 * Check if the Host has consumed any buffers since we last
739 * sent data (this is only applicable for nonblocking ports).
740 */
741 reclaim_consumed_buffers(port);
742 ret = port->outvq_full;
743 spin_unlock_irq(&port->outvq_lock);
744
745 return ret;
746}
747
Amit Shah2030fa42009-12-21 21:49:30 +0530748static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
749 size_t count, loff_t *offp)
750{
751 struct port *port;
752 ssize_t ret;
753
754 port = filp->private_data;
755
Amit Shah96f97a82013-07-29 14:23:21 +0930756 /* Port is hot-unplugged. */
757 if (!port->guest_connected)
758 return -ENODEV;
759
Amit Shah2030fa42009-12-21 21:49:30 +0530760 if (!port_has_data(port)) {
761 /*
762 * If nothing's connected on the host just return 0 in
763 * case of list_empty; this tells the userspace app
764 * that there's no connection
765 */
766 if (!port->host_connected)
767 return 0;
768 if (filp->f_flags & O_NONBLOCK)
769 return -EAGAIN;
770
Amit Shaha08fa922011-09-14 13:06:41 +0530771 ret = wait_event_freezable(port->waitqueue,
772 !will_read_block(port));
Amit Shah2030fa42009-12-21 21:49:30 +0530773 if (ret < 0)
774 return ret;
775 }
Amit Shah96f97a82013-07-29 14:23:21 +0930776 /* Port got hot-unplugged while we were waiting above. */
Amit Shahb3dddb92010-09-02 18:11:45 +0530777 if (!port->guest_connected)
778 return -ENODEV;
Amit Shah2030fa42009-12-21 21:49:30 +0530779 /*
780 * We could've received a disconnection message while we were
781 * waiting for more data.
782 *
783 * This check is not clubbed in the if() statement above as we
784 * might receive some data as well as the host could get
785 * disconnected after we got woken up from our wait. So we
786 * really want to give off whatever data we have and only then
787 * check for host_connected.
788 */
789 if (!port_has_data(port) && !port->host_connected)
790 return 0;
791
792 return fill_readbuf(port, ubuf, count, true);
793}
794
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900795static int wait_port_writable(struct port *port, bool nonblock)
796{
797 int ret;
798
799 if (will_write_block(port)) {
800 if (nonblock)
801 return -EAGAIN;
802
803 ret = wait_event_freezable(port->waitqueue,
804 !will_write_block(port));
805 if (ret < 0)
806 return ret;
807 }
808 /* Port got hot-unplugged. */
809 if (!port->guest_connected)
810 return -ENODEV;
811
812 return 0;
813}
814
Amit Shah2030fa42009-12-21 21:49:30 +0530815static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
816 size_t count, loff_t *offp)
817{
818 struct port *port;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030819 struct port_buffer *buf;
Amit Shah2030fa42009-12-21 21:49:30 +0530820 ssize_t ret;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600821 bool nonblock;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030822 struct scatterlist sg[1];
Amit Shah2030fa42009-12-21 21:49:30 +0530823
Amit Shah65745422010-09-14 13:26:16 +0530824 /* Userspace could be out to fool us */
825 if (!count)
826 return 0;
827
Amit Shah2030fa42009-12-21 21:49:30 +0530828 port = filp->private_data;
829
Amit Shahcdfadfc2010-05-19 22:15:50 -0600830 nonblock = filp->f_flags & O_NONBLOCK;
831
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900832 ret = wait_port_writable(port, nonblock);
833 if (ret < 0)
834 return ret;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600835
Amit Shah2030fa42009-12-21 21:49:30 +0530836 count = min((size_t)(32 * 1024), count);
837
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030838 buf = alloc_buf(port->out_vq, count, 0);
Amit Shah2030fa42009-12-21 21:49:30 +0530839 if (!buf)
840 return -ENOMEM;
841
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030842 ret = copy_from_user(buf->buf, ubuf, count);
Amit Shah2030fa42009-12-21 21:49:30 +0530843 if (ret) {
844 ret = -EFAULT;
845 goto free_buf;
846 }
847
Amit Shah531295e2010-10-20 13:45:43 +1030848 /*
849 * We now ask send_buf() to not spin for generic ports -- we
850 * can re-use the same code path that non-blocking file
851 * descriptors take for blocking file descriptors since the
852 * wait is already done and we're certain the write will go
853 * through to the host.
854 */
855 nonblock = true;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030856 sg_init_one(sg, buf->buf, count);
857 ret = __send_to_port(port, sg, 1, count, buf, nonblock);
Amit Shahcdfadfc2010-05-19 22:15:50 -0600858
859 if (nonblock && ret > 0)
860 goto out;
861
Amit Shah2030fa42009-12-21 21:49:30 +0530862free_buf:
Sjur Brændeland1b637042012-12-14 14:40:51 +1030863 free_buf(buf, true);
Amit Shahcdfadfc2010-05-19 22:15:50 -0600864out:
Amit Shah2030fa42009-12-21 21:49:30 +0530865 return ret;
866}
867
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900868struct sg_list {
869 unsigned int n;
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900870 unsigned int size;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900871 size_t len;
872 struct scatterlist *sg;
873};
874
875static int pipe_to_sg(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
876 struct splice_desc *sd)
877{
878 struct sg_list *sgl = sd->u.data;
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900879 unsigned int offset, len;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900880
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900881 if (sgl->n == sgl->size)
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900882 return 0;
883
884 /* Try lock this page */
885 if (buf->ops->steal(pipe, buf) == 0) {
886 /* Get reference and unlock page for moving */
887 get_page(buf->page);
888 unlock_page(buf->page);
889
890 len = min(buf->len, sd->len);
891 sg_set_page(&(sgl->sg[sgl->n]), buf->page, len, buf->offset);
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900892 } else {
893 /* Failback to copying a page */
894 struct page *page = alloc_page(GFP_KERNEL);
Al Viroc9efe512014-02-02 07:05:05 -0500895 char *src;
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900896
897 if (!page)
898 return -ENOMEM;
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900899
900 offset = sd->pos & ~PAGE_MASK;
901
902 len = sd->len;
903 if (len + offset > PAGE_SIZE)
904 len = PAGE_SIZE - offset;
905
Al Virofbb32752014-02-02 21:09:54 -0500906 src = kmap_atomic(buf->page);
Al Viroc9efe512014-02-02 07:05:05 -0500907 memcpy(page_address(page) + offset, src + buf->offset, len);
Al Virofbb32752014-02-02 21:09:54 -0500908 kunmap_atomic(src);
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900909
910 sg_set_page(&(sgl->sg[sgl->n]), page, len, offset);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900911 }
Masami Hiramatsuec8fc872012-08-09 21:30:50 +0900912 sgl->n++;
913 sgl->len += len;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900914
915 return len;
916}
917
918/* Faster zero-copy write by splicing */
919static ssize_t port_fops_splice_write(struct pipe_inode_info *pipe,
920 struct file *filp, loff_t *ppos,
921 size_t len, unsigned int flags)
922{
923 struct port *port = filp->private_data;
924 struct sg_list sgl;
925 ssize_t ret;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030926 struct port_buffer *buf;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900927 struct splice_desc sd = {
928 .total_len = len,
929 .flags = flags,
930 .pos = *ppos,
931 .u.data = &sgl,
932 };
933
Sjur Brændeland1b637042012-12-14 14:40:51 +1030934 /*
935 * Rproc_serial does not yet support splice. To support splice
936 * pipe_to_sg() must allocate dma-buffers and copy content from
937 * regular pages to dma pages. And alloc_buf and free_buf must
938 * support allocating and freeing such a list of dma-buffers.
939 */
940 if (is_rproc_serial(port->out_vq->vdev))
941 return -EINVAL;
942
Yoshihiro YUNOMAE68c034f2013-07-23 11:30:49 +0930943 /*
944 * pipe->nrbufs == 0 means there are no data to transfer,
945 * so this returns just 0 for no data.
946 */
Yoshihiro YUNOMAE2b4fbf02013-07-23 11:30:49 +0930947 pipe_lock(pipe);
948 if (!pipe->nrbufs) {
949 ret = 0;
950 goto error_out;
951 }
Yoshihiro YUNOMAE68c034f2013-07-23 11:30:49 +0930952
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900953 ret = wait_port_writable(port, filp->f_flags & O_NONBLOCK);
954 if (ret < 0)
Yoshihiro YUNOMAE2b4fbf02013-07-23 11:30:49 +0930955 goto error_out;
Masami Hiramatsuefe75d22012-08-09 21:31:00 +0900956
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030957 buf = alloc_buf(port->out_vq, 0, pipe->nrbufs);
Yoshihiro YUNOMAE2b4fbf02013-07-23 11:30:49 +0930958 if (!buf) {
959 ret = -ENOMEM;
960 goto error_out;
961 }
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030962
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900963 sgl.n = 0;
964 sgl.len = 0;
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900965 sgl.size = pipe->nrbufs;
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030966 sgl.sg = buf->sg;
Masami Hiramatsu8ca84a52012-08-09 21:31:20 +0900967 sg_init_table(sgl.sg, sgl.size);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900968 ret = __splice_from_pipe(pipe, &sd, pipe_to_sg);
Yoshihiro YUNOMAE2b4fbf02013-07-23 11:30:49 +0930969 pipe_unlock(pipe);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900970 if (likely(ret > 0))
Sjur Brændeland276a3e92012-12-14 13:46:42 +1030971 ret = __send_to_port(port, buf->sg, sgl.n, sgl.len, buf, true);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900972
Sjur Brændelandfe529532012-10-15 09:57:33 +0200973 if (unlikely(ret <= 0))
Sjur Brændeland1b637042012-12-14 14:40:51 +1030974 free_buf(buf, true);
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900975 return ret;
Yoshihiro YUNOMAE2b4fbf02013-07-23 11:30:49 +0930976
977error_out:
978 pipe_unlock(pipe);
979 return ret;
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +0900980}
981
Amit Shah2030fa42009-12-21 21:49:30 +0530982static unsigned int port_fops_poll(struct file *filp, poll_table *wait)
983{
984 struct port *port;
985 unsigned int ret;
986
987 port = filp->private_data;
988 poll_wait(filp, &port->waitqueue, wait);
989
Amit Shah8529a502010-09-02 18:11:44 +0530990 if (!port->guest_connected) {
991 /* Port got unplugged */
992 return POLLHUP;
993 }
Amit Shah2030fa42009-12-21 21:49:30 +0530994 ret = 0;
Hans de Goede6df7aad2010-09-16 14:43:08 +0530995 if (!will_read_block(port))
Amit Shah2030fa42009-12-21 21:49:30 +0530996 ret |= POLLIN | POLLRDNORM;
Amit Shahcdfadfc2010-05-19 22:15:50 -0600997 if (!will_write_block(port))
Amit Shah2030fa42009-12-21 21:49:30 +0530998 ret |= POLLOUT;
999 if (!port->host_connected)
1000 ret |= POLLHUP;
1001
1002 return ret;
1003}
1004
Amit Shahb353a6b2010-09-02 18:38:29 +05301005static void remove_port(struct kref *kref);
1006
Amit Shah2030fa42009-12-21 21:49:30 +05301007static int port_fops_release(struct inode *inode, struct file *filp)
1008{
1009 struct port *port;
1010
1011 port = filp->private_data;
1012
1013 /* Notify host of port being closed */
1014 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
1015
Amit Shah88f251a2009-12-21 22:15:30 +05301016 spin_lock_irq(&port->inbuf_lock);
Amit Shah3c7969c2009-11-26 11:25:38 +05301017 port->guest_connected = false;
1018
Amit Shah88f251a2009-12-21 22:15:30 +05301019 discard_port_data(port);
1020
1021 spin_unlock_irq(&port->inbuf_lock);
1022
Amit Shahcdfadfc2010-05-19 22:15:50 -06001023 spin_lock_irq(&port->outvq_lock);
1024 reclaim_consumed_buffers(port);
1025 spin_unlock_irq(&port->outvq_lock);
1026
Sjur Brændeland1b637042012-12-14 14:40:51 +10301027 reclaim_dma_bufs();
Amit Shahb353a6b2010-09-02 18:38:29 +05301028 /*
1029 * Locks aren't necessary here as a port can't be opened after
1030 * unplug, and if a port isn't unplugged, a kref would already
1031 * exist for the port. Plus, taking ports_lock here would
1032 * create a dependency on other locks taken by functions
1033 * inside remove_port if we're the last holder of the port,
1034 * creating many problems.
1035 */
1036 kref_put(&port->kref, remove_port);
1037
Amit Shah2030fa42009-12-21 21:49:30 +05301038 return 0;
1039}
1040
1041static int port_fops_open(struct inode *inode, struct file *filp)
1042{
1043 struct cdev *cdev = inode->i_cdev;
1044 struct port *port;
Amit Shah8ad37e82010-09-02 18:11:48 +05301045 int ret;
Amit Shah2030fa42009-12-21 21:49:30 +05301046
Amit Shah057b82b2013-07-29 14:16:13 +09301047 /* We get the port with a kref here */
Amit Shah04950cd2010-09-02 18:20:58 +05301048 port = find_port_by_devt(cdev->dev);
Amit Shah671bdea2013-07-29 14:17:13 +09301049 if (!port) {
1050 /* Port was unplugged before we could proceed */
1051 return -ENXIO;
1052 }
Amit Shah2030fa42009-12-21 21:49:30 +05301053 filp->private_data = port;
1054
1055 /*
1056 * Don't allow opening of console port devices -- that's done
1057 * via /dev/hvc
1058 */
Amit Shah8ad37e82010-09-02 18:11:48 +05301059 if (is_console_port(port)) {
1060 ret = -ENXIO;
1061 goto out;
1062 }
Amit Shah2030fa42009-12-21 21:49:30 +05301063
Amit Shah3c7969c2009-11-26 11:25:38 +05301064 /* Allow only one process to open a particular port at a time */
1065 spin_lock_irq(&port->inbuf_lock);
1066 if (port->guest_connected) {
1067 spin_unlock_irq(&port->inbuf_lock);
Amit Shah74ff5822013-04-15 12:00:15 +09301068 ret = -EBUSY;
Amit Shah8ad37e82010-09-02 18:11:48 +05301069 goto out;
Amit Shah3c7969c2009-11-26 11:25:38 +05301070 }
1071
1072 port->guest_connected = true;
1073 spin_unlock_irq(&port->inbuf_lock);
1074
Amit Shahcdfadfc2010-05-19 22:15:50 -06001075 spin_lock_irq(&port->outvq_lock);
1076 /*
1077 * There might be a chance that we missed reclaiming a few
1078 * buffers in the window of the port getting previously closed
1079 * and opening now.
1080 */
1081 reclaim_consumed_buffers(port);
1082 spin_unlock_irq(&port->outvq_lock);
1083
Amit Shah299fb612010-09-16 14:43:09 +05301084 nonseekable_open(inode, filp);
1085
Amit Shah2030fa42009-12-21 21:49:30 +05301086 /* Notify host of port being opened */
1087 send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1);
1088
1089 return 0;
Amit Shah8ad37e82010-09-02 18:11:48 +05301090out:
Amit Shahb353a6b2010-09-02 18:38:29 +05301091 kref_put(&port->kref, remove_port);
Amit Shah8ad37e82010-09-02 18:11:48 +05301092 return ret;
Amit Shah2030fa42009-12-21 21:49:30 +05301093}
1094
Amit Shah3eae0ad2010-09-02 18:47:52 +05301095static int port_fops_fasync(int fd, struct file *filp, int mode)
1096{
1097 struct port *port;
1098
1099 port = filp->private_data;
1100 return fasync_helper(fd, filp, mode, &port->async_queue);
1101}
1102
Amit Shah2030fa42009-12-21 21:49:30 +05301103/*
1104 * The file operations that we support: programs in the guest can open
1105 * a console device, read from it, write to it, poll for data and
1106 * close it. The devices are at
1107 * /dev/vport<device number>p<port number>
1108 */
1109static const struct file_operations port_fops = {
1110 .owner = THIS_MODULE,
1111 .open = port_fops_open,
1112 .read = port_fops_read,
1113 .write = port_fops_write,
Masami Hiramatsueb5e89f2012-08-09 21:30:39 +09001114 .splice_write = port_fops_splice_write,
Amit Shah2030fa42009-12-21 21:49:30 +05301115 .poll = port_fops_poll,
1116 .release = port_fops_release,
Amit Shah3eae0ad2010-09-02 18:47:52 +05301117 .fasync = port_fops_fasync,
Amit Shah299fb612010-09-16 14:43:09 +05301118 .llseek = no_llseek,
Amit Shah2030fa42009-12-21 21:49:30 +05301119};
1120
Amit Shahe27b5192010-01-18 19:15:02 +05301121/*
Rusty Russella23ea922010-01-18 19:14:55 +05301122 * The put_chars() callback is pretty straightforward.
Rusty Russell31610432007-10-22 11:03:39 +10001123 *
Rusty Russella23ea922010-01-18 19:14:55 +05301124 * We turn the characters into a scatter-gather list, add it to the
1125 * output queue and then kick the Host. Then we sit here waiting for
1126 * it to finish: inefficient in theory, but in practice
1127 * implementations will do it immediately (lguest's Launcher does).
1128 */
Rusty Russell31610432007-10-22 11:03:39 +10001129static int put_chars(u32 vtermno, const char *buf, int count)
1130{
Rusty Russell21206ed2010-01-18 19:15:00 +05301131 struct port *port;
Sjur Brændeland276a3e92012-12-14 13:46:42 +10301132 struct scatterlist sg[1];
Amit Shah38edf582010-01-18 19:15:05 +05301133
François Diakhaté162a6892010-03-23 18:23:15 +05301134 if (unlikely(early_put_chars))
1135 return early_put_chars(vtermno, buf, count);
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 Russell31610432007-10-22 11:03:39 +10001140
Sjur Brændeland276a3e92012-12-14 13:46:42 +10301141 sg_init_one(sg, buf, count);
1142 return __send_to_port(port, sg, 1, count, (void *)buf, false);
Rusty Russell31610432007-10-22 11:03:39 +10001143}
1144
Rusty Russella23ea922010-01-18 19:14:55 +05301145/*
Rusty Russella23ea922010-01-18 19:14:55 +05301146 * get_chars() is the callback from the hvc_console infrastructure
1147 * when an interrupt is received.
Rusty Russell31610432007-10-22 11:03:39 +10001148 *
Amit Shah203baab2010-01-18 19:15:12 +05301149 * We call out to fill_readbuf that gets us the required data from the
1150 * buffers that are queued up.
Rusty Russella23ea922010-01-18 19:14:55 +05301151 */
Rusty Russell31610432007-10-22 11:03:39 +10001152static int get_chars(u32 vtermno, char *buf, int count)
1153{
Rusty Russell21206ed2010-01-18 19:15:00 +05301154 struct port *port;
Rusty Russell31610432007-10-22 11:03:39 +10001155
Amit Shah6dc69f972010-05-19 22:15:47 -06001156 /* If we've not set up the port yet, we have no input to give. */
1157 if (unlikely(early_put_chars))
1158 return 0;
1159
Amit Shah38edf582010-01-18 19:15:05 +05301160 port = find_port_by_vtermno(vtermno);
1161 if (!port)
Amit Shah6dc69f972010-05-19 22:15:47 -06001162 return -EPIPE;
Rusty Russell21206ed2010-01-18 19:15:00 +05301163
1164 /* If we don't have an input queue yet, we can't get input. */
1165 BUG_ON(!port->in_vq);
1166
Michael S. Tsirkin48b36062014-12-01 13:31:45 +02001167 return fill_readbuf(port, (__force char __user *)buf, count, false);
Rusty Russell31610432007-10-22 11:03:39 +10001168}
Rusty Russell31610432007-10-22 11:03:39 +10001169
Amit Shahcb06e362010-01-18 19:15:08 +05301170static void resize_console(struct port *port)
Christian Borntraegerc2983452008-11-25 13:36:26 +01001171{
Amit Shahcb06e362010-01-18 19:15:08 +05301172 struct virtio_device *vdev;
Christian Borntraegerc2983452008-11-25 13:36:26 +01001173
Amit Shah2de16a42010-03-19 17:36:44 +05301174 /* The port could have been hot-unplugged */
Amit Shah97788292010-05-06 02:05:08 +05301175 if (!port || !is_console_port(port))
Amit Shah2de16a42010-03-19 17:36:44 +05301176 return;
1177
Amit Shahcb06e362010-01-18 19:15:08 +05301178 vdev = port->portdev->vdev;
Sjur Brændeland1b637042012-12-14 14:40:51 +10301179
1180 /* Don't test F_SIZE at all if we're rproc: not a valid feature! */
1181 if (!is_rproc_serial(vdev) &&
1182 virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE))
Amit Shah97788292010-05-06 02:05:08 +05301183 hvc_resize(port->cons.hvc, port->cons.ws);
Christian Borntraegerc2983452008-11-25 13:36:26 +01001184}
1185
Amit Shah38edf582010-01-18 19:15:05 +05301186/* We set the configuration at this point, since we now have a tty */
Christian Borntraeger91fcad12008-06-20 15:24:15 +02001187static int notifier_add_vio(struct hvc_struct *hp, int data)
1188{
Amit Shah38edf582010-01-18 19:15:05 +05301189 struct port *port;
1190
1191 port = find_port_by_vtermno(hp->vtermno);
1192 if (!port)
1193 return -EINVAL;
1194
Christian Borntraeger91fcad12008-06-20 15:24:15 +02001195 hp->irq_requested = 1;
Amit Shahcb06e362010-01-18 19:15:08 +05301196 resize_console(port);
Christian Borntraegerc2983452008-11-25 13:36:26 +01001197
Christian Borntraeger91fcad12008-06-20 15:24:15 +02001198 return 0;
1199}
1200
1201static void notifier_del_vio(struct hvc_struct *hp, int data)
1202{
1203 hp->irq_requested = 0;
1204}
1205
Amit Shah17634ba2009-12-21 21:03:25 +05301206/* The operations for console ports. */
Rusty Russell1dff3992009-11-28 12:20:26 +05301207static const struct hv_ops hv_ops = {
Rusty Russell971f3392010-01-18 19:14:56 +05301208 .get_chars = get_chars,
1209 .put_chars = put_chars,
1210 .notifier_add = notifier_add_vio,
1211 .notifier_del = notifier_del_vio,
1212 .notifier_hangup = notifier_del_vio,
1213};
1214
1215/*
1216 * Console drivers are initialized very early so boot messages can go
1217 * out, so we do things slightly differently from the generic virtio
1218 * initialization of the net and block drivers.
1219 *
1220 * At this stage, the console is output-only. It's too early to set
1221 * up a virtqueue, so we let the drivers do some boutique early-output
1222 * thing.
1223 */
1224int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int))
1225{
1226 early_put_chars = put_chars;
1227 return hvc_instantiate(0, 0, &hv_ops);
1228}
1229
Wei Yongjun38268352013-04-08 16:13:59 +09301230static int init_port_console(struct port *port)
Amit Shahcfa6d372010-01-18 19:15:10 +05301231{
1232 int ret;
1233
1234 /*
1235 * The Host's telling us this port is a console port. Hook it
1236 * up with an hvc console.
1237 *
1238 * To set up and manage our virtual console, we call
1239 * hvc_alloc().
1240 *
1241 * The first argument of hvc_alloc() is the virtual console
1242 * number. The second argument is the parameter for the
1243 * notification mechanism (like irq number). We currently
1244 * leave this as zero, virtqueues have implicit notifications.
1245 *
1246 * The third argument is a "struct hv_ops" containing the
1247 * put_chars() get_chars(), notifier_add() and notifier_del()
1248 * pointers. The final argument is the output buffer size: we
1249 * can do any size, so we put PAGE_SIZE here.
1250 */
1251 port->cons.vtermno = pdrvdata.next_vtermno;
1252
1253 port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE);
1254 if (IS_ERR(port->cons.hvc)) {
1255 ret = PTR_ERR(port->cons.hvc);
Amit Shah298add72010-01-18 16:35:23 +05301256 dev_err(port->dev,
1257 "error %d allocating hvc for port\n", ret);
Amit Shahcfa6d372010-01-18 19:15:10 +05301258 port->cons.hvc = NULL;
1259 return ret;
1260 }
1261 spin_lock_irq(&pdrvdata_lock);
1262 pdrvdata.next_vtermno++;
1263 list_add_tail(&port->cons.list, &pdrvdata.consoles);
1264 spin_unlock_irq(&pdrvdata_lock);
Amit Shah3c7969c2009-11-26 11:25:38 +05301265 port->guest_connected = true;
Amit Shahcfa6d372010-01-18 19:15:10 +05301266
Amit Shah1d051602010-05-19 22:15:49 -06001267 /*
1268 * Start using the new console output if this is the first
1269 * console to come up.
1270 */
1271 if (early_put_chars)
1272 early_put_chars = NULL;
1273
Amit Shah2030fa42009-12-21 21:49:30 +05301274 /* Notify host of port being opened */
1275 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
1276
Amit Shahcfa6d372010-01-18 19:15:10 +05301277 return 0;
1278}
1279
Amit Shah431edb82009-12-21 21:57:40 +05301280static ssize_t show_port_name(struct device *dev,
1281 struct device_attribute *attr, char *buffer)
1282{
1283 struct port *port;
1284
1285 port = dev_get_drvdata(dev);
1286
1287 return sprintf(buffer, "%s\n", port->name);
1288}
1289
1290static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL);
1291
1292static struct attribute *port_sysfs_entries[] = {
1293 &dev_attr_name.attr,
1294 NULL
1295};
1296
1297static struct attribute_group port_attribute_group = {
1298 .name = NULL, /* put in device directory */
1299 .attrs = port_sysfs_entries,
1300};
1301
Amit Shahd99393e2009-12-21 22:36:21 +05301302static ssize_t debugfs_read(struct file *filp, char __user *ubuf,
1303 size_t count, loff_t *offp)
1304{
1305 struct port *port;
1306 char *buf;
1307 ssize_t ret, out_offset, out_count;
1308
1309 out_count = 1024;
1310 buf = kmalloc(out_count, GFP_KERNEL);
1311 if (!buf)
1312 return -ENOMEM;
1313
1314 port = filp->private_data;
1315 out_offset = 0;
1316 out_offset += snprintf(buf + out_offset, out_count,
1317 "name: %s\n", port->name ? port->name : "");
1318 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1319 "guest_connected: %d\n", port->guest_connected);
1320 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1321 "host_connected: %d\n", port->host_connected);
1322 out_offset += snprintf(buf + out_offset, out_count - out_offset,
Amit Shahcdfadfc2010-05-19 22:15:50 -06001323 "outvq_full: %d\n", port->outvq_full);
1324 out_offset += snprintf(buf + out_offset, out_count - out_offset,
Amit Shah17e5b4f2011-09-14 13:06:46 +05301325 "bytes_sent: %lu\n", port->stats.bytes_sent);
1326 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1327 "bytes_received: %lu\n",
1328 port->stats.bytes_received);
1329 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1330 "bytes_discarded: %lu\n",
1331 port->stats.bytes_discarded);
1332 out_offset += snprintf(buf + out_offset, out_count - out_offset,
Amit Shahd99393e2009-12-21 22:36:21 +05301333 "is_console: %s\n",
1334 is_console_port(port) ? "yes" : "no");
1335 out_offset += snprintf(buf + out_offset, out_count - out_offset,
1336 "console_vtermno: %u\n", port->cons.vtermno);
1337
1338 ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset);
1339 kfree(buf);
1340 return ret;
1341}
1342
1343static const struct file_operations port_debugfs_ops = {
1344 .owner = THIS_MODULE,
Stephen Boyd234e3402012-04-05 14:25:11 -07001345 .open = simple_open,
Amit Shahd99393e2009-12-21 22:36:21 +05301346 .read = debugfs_read,
1347};
1348
Amit Shah97788292010-05-06 02:05:08 +05301349static void set_console_size(struct port *port, u16 rows, u16 cols)
1350{
1351 if (!port || !is_console_port(port))
1352 return;
1353
1354 port->cons.ws.ws_row = rows;
1355 port->cons.ws.ws_col = cols;
1356}
1357
Amit Shahc446f8f2010-05-19 22:15:48 -06001358static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock)
1359{
1360 struct port_buffer *buf;
1361 unsigned int nr_added_bufs;
1362 int ret;
1363
1364 nr_added_bufs = 0;
1365 do {
Sjur Brændeland276a3e92012-12-14 13:46:42 +10301366 buf = alloc_buf(vq, PAGE_SIZE, 0);
Amit Shahc446f8f2010-05-19 22:15:48 -06001367 if (!buf)
1368 break;
1369
1370 spin_lock_irq(lock);
1371 ret = add_inbuf(vq, buf);
1372 if (ret < 0) {
1373 spin_unlock_irq(lock);
Sjur Brændeland1b637042012-12-14 14:40:51 +10301374 free_buf(buf, true);
Amit Shahc446f8f2010-05-19 22:15:48 -06001375 break;
1376 }
1377 nr_added_bufs++;
1378 spin_unlock_irq(lock);
1379 } while (ret > 0);
1380
1381 return nr_added_bufs;
1382}
1383
Amit Shah3eae0ad2010-09-02 18:47:52 +05301384static void send_sigio_to_port(struct port *port)
1385{
1386 if (port->async_queue && port->guest_connected)
1387 kill_fasync(&port->async_queue, SIGIO, POLL_OUT);
1388}
1389
Amit Shahc446f8f2010-05-19 22:15:48 -06001390static int add_port(struct ports_device *portdev, u32 id)
1391{
1392 char debugfs_name[16];
1393 struct port *port;
1394 struct port_buffer *buf;
1395 dev_t devt;
1396 unsigned int nr_added_bufs;
1397 int err;
1398
1399 port = kmalloc(sizeof(*port), GFP_KERNEL);
1400 if (!port) {
1401 err = -ENOMEM;
1402 goto fail;
1403 }
Amit Shahb353a6b2010-09-02 18:38:29 +05301404 kref_init(&port->kref);
Amit Shahc446f8f2010-05-19 22:15:48 -06001405
1406 port->portdev = portdev;
1407 port->id = id;
1408
1409 port->name = NULL;
1410 port->inbuf = NULL;
1411 port->cons.hvc = NULL;
Amit Shah3eae0ad2010-09-02 18:47:52 +05301412 port->async_queue = NULL;
Amit Shahc446f8f2010-05-19 22:15:48 -06001413
Amit Shah97788292010-05-06 02:05:08 +05301414 port->cons.ws.ws_row = port->cons.ws.ws_col = 0;
1415
Amit Shahc446f8f2010-05-19 22:15:48 -06001416 port->host_connected = port->guest_connected = false;
Amit Shah17e5b4f2011-09-14 13:06:46 +05301417 port->stats = (struct port_stats) { 0 };
Amit Shahc446f8f2010-05-19 22:15:48 -06001418
Amit Shahcdfadfc2010-05-19 22:15:50 -06001419 port->outvq_full = false;
1420
Amit Shahc446f8f2010-05-19 22:15:48 -06001421 port->in_vq = portdev->in_vqs[port->id];
1422 port->out_vq = portdev->out_vqs[port->id];
1423
Amit Shahd22a6982010-09-02 18:20:59 +05301424 port->cdev = cdev_alloc();
1425 if (!port->cdev) {
1426 dev_err(&port->portdev->vdev->dev, "Error allocating cdev\n");
1427 err = -ENOMEM;
1428 goto free_port;
1429 }
1430 port->cdev->ops = &port_fops;
Amit Shahc446f8f2010-05-19 22:15:48 -06001431
1432 devt = MKDEV(portdev->chr_major, id);
Amit Shahd22a6982010-09-02 18:20:59 +05301433 err = cdev_add(port->cdev, devt, 1);
Amit Shahc446f8f2010-05-19 22:15:48 -06001434 if (err < 0) {
1435 dev_err(&port->portdev->vdev->dev,
1436 "Error %d adding cdev for port %u\n", err, id);
Amit Shahd22a6982010-09-02 18:20:59 +05301437 goto free_cdev;
Amit Shahc446f8f2010-05-19 22:15:48 -06001438 }
1439 port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev,
1440 devt, port, "vport%up%u",
Sjur Brændelanddc18f082013-02-12 16:24:59 +10301441 port->portdev->vdev->index, id);
Amit Shahc446f8f2010-05-19 22:15:48 -06001442 if (IS_ERR(port->dev)) {
1443 err = PTR_ERR(port->dev);
1444 dev_err(&port->portdev->vdev->dev,
1445 "Error %d creating device for port %u\n",
1446 err, id);
1447 goto free_cdev;
1448 }
1449
1450 spin_lock_init(&port->inbuf_lock);
Amit Shahcdfadfc2010-05-19 22:15:50 -06001451 spin_lock_init(&port->outvq_lock);
Amit Shahc446f8f2010-05-19 22:15:48 -06001452 init_waitqueue_head(&port->waitqueue);
1453
1454 /* Fill the in_vq with buffers so the host can send us data. */
1455 nr_added_bufs = fill_queue(port->in_vq, &port->inbuf_lock);
1456 if (!nr_added_bufs) {
1457 dev_err(port->dev, "Error allocating inbufs\n");
1458 err = -ENOMEM;
1459 goto free_device;
1460 }
1461
Sjur Brændeland1b637042012-12-14 14:40:51 +10301462 if (is_rproc_serial(port->portdev->vdev))
1463 /*
1464 * For rproc_serial assume remote processor is connected.
1465 * rproc_serial does not want the console port, only
1466 * the generic port implementation.
1467 */
Sjur Brændelandaabd6a82013-03-18 19:19:14 +10301468 port->host_connected = true;
Sjur Brændeland1b637042012-12-14 14:40:51 +10301469 else if (!use_multiport(port->portdev)) {
1470 /*
1471 * If we're not using multiport support,
1472 * this has to be a console port.
1473 */
Amit Shahc446f8f2010-05-19 22:15:48 -06001474 err = init_port_console(port);
1475 if (err)
1476 goto free_inbufs;
1477 }
1478
1479 spin_lock_irq(&portdev->ports_lock);
1480 list_add_tail(&port->list, &port->portdev->ports);
1481 spin_unlock_irq(&portdev->ports_lock);
1482
1483 /*
1484 * Tell the Host we're set so that it can send us various
1485 * configuration parameters for this port (eg, port name,
1486 * caching, whether this is a console port, etc.)
1487 */
1488 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1489
1490 if (pdrvdata.debugfs_dir) {
1491 /*
1492 * Finally, create the debugfs file that we can use to
1493 * inspect a port's state at any time
1494 */
Dan Carpenterdb170062015-05-08 12:16:25 +03001495 snprintf(debugfs_name, sizeof(debugfs_name), "vport%up%u",
1496 port->portdev->vdev->index, id);
Amit Shahc446f8f2010-05-19 22:15:48 -06001497 port->debugfs_file = debugfs_create_file(debugfs_name, 0444,
1498 pdrvdata.debugfs_dir,
1499 port,
1500 &port_debugfs_ops);
1501 }
1502 return 0;
1503
1504free_inbufs:
1505 while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301506 free_buf(buf, true);
Amit Shahc446f8f2010-05-19 22:15:48 -06001507free_device:
1508 device_destroy(pdrvdata.class, port->dev->devt);
1509free_cdev:
Amit Shahd22a6982010-09-02 18:20:59 +05301510 cdev_del(port->cdev);
Amit Shahc446f8f2010-05-19 22:15:48 -06001511free_port:
1512 kfree(port);
1513fail:
1514 /* The host might want to notify management sw about port add failure */
Julia Lawall0643e4c2010-05-15 11:45:53 +02001515 __send_control_msg(portdev, id, VIRTIO_CONSOLE_PORT_READY, 0);
Amit Shahc446f8f2010-05-19 22:15:48 -06001516 return err;
1517}
1518
Amit Shahb353a6b2010-09-02 18:38:29 +05301519/* No users remain, remove all port-specific data. */
1520static void remove_port(struct kref *kref)
1521{
1522 struct port *port;
1523
1524 port = container_of(kref, struct port, kref);
1525
Amit Shahb353a6b2010-09-02 18:38:29 +05301526 kfree(port);
1527}
1528
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301529static void remove_port_data(struct port *port)
1530{
1531 struct port_buffer *buf;
1532
Amit Shahc6017e72013-07-29 14:23:46 +09301533 spin_lock_irq(&port->inbuf_lock);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301534 /* Remove unused data this port might have received. */
1535 discard_port_data(port);
1536
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301537 /* Remove buffers we queued up for the Host to send us data in. */
1538 while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301539 free_buf(buf, true);
Amit Shahc6017e72013-07-29 14:23:46 +09301540 spin_unlock_irq(&port->inbuf_lock);
1541
1542 spin_lock_irq(&port->outvq_lock);
1543 reclaim_consumed_buffers(port);
sjur.brandeland@stericsson.comeb34f122012-11-16 11:20:19 +10301544
1545 /* Free pending buffers from the out-queue. */
1546 while ((buf = virtqueue_detach_unused_buf(port->out_vq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301547 free_buf(buf, true);
Amit Shahc6017e72013-07-29 14:23:46 +09301548 spin_unlock_irq(&port->outvq_lock);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301549}
1550
Amit Shahb353a6b2010-09-02 18:38:29 +05301551/*
1552 * Port got unplugged. Remove port from portdev's list and drop the
1553 * kref reference. If no userspace has this port opened, it will
1554 * result in immediate removal the port.
1555 */
1556static void unplug_port(struct port *port)
Amit Shah1f7aa422009-12-21 22:27:31 +05301557{
Amit Shahb353a6b2010-09-02 18:38:29 +05301558 spin_lock_irq(&port->portdev->ports_lock);
1559 list_del(&port->list);
1560 spin_unlock_irq(&port->portdev->ports_lock);
1561
Amit Shah5549fb22013-07-29 14:24:15 +09301562 spin_lock_irq(&port->inbuf_lock);
Amit Shah00476342010-05-27 13:24:39 +05301563 if (port->guest_connected) {
Amit Shaha461e112010-09-02 18:47:54 +05301564 /* Let the app know the port is going down. */
1565 send_sigio_to_port(port);
Amit Shah92d34532013-07-29 14:21:32 +09301566
1567 /* Do this after sigio is actually sent */
1568 port->guest_connected = false;
1569 port->host_connected = false;
1570
1571 wake_up_interruptible(&port->waitqueue);
Amit Shah00476342010-05-27 13:24:39 +05301572 }
Amit Shah5549fb22013-07-29 14:24:15 +09301573 spin_unlock_irq(&port->inbuf_lock);
Amit Shah00476342010-05-27 13:24:39 +05301574
Amit Shah1f7aa422009-12-21 22:27:31 +05301575 if (is_console_port(port)) {
1576 spin_lock_irq(&pdrvdata_lock);
1577 list_del(&port->cons.list);
1578 spin_unlock_irq(&pdrvdata_lock);
1579 hvc_remove(port->cons.hvc);
1580 }
Amit Shah1f7aa422009-12-21 22:27:31 +05301581
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301582 remove_port_data(port);
Amit Shaha9cdd482010-02-12 10:32:15 +05301583
Amit Shahb353a6b2010-09-02 18:38:29 +05301584 /*
1585 * We should just assume the device itself has gone off --
1586 * else a close on an open port later will try to send out a
1587 * control message.
1588 */
1589 port->portdev = NULL;
Amit Shah1f7aa422009-12-21 22:27:31 +05301590
Amit Shahea3768b2013-07-29 14:20:29 +09301591 sysfs_remove_group(&port->dev->kobj, &port_attribute_group);
1592 device_destroy(pdrvdata.class, port->dev->devt);
1593 cdev_del(port->cdev);
1594
Amit Shahea3768b2013-07-29 14:20:29 +09301595 debugfs_remove(port->debugfs_file);
Amit Shah3b868a42013-08-07 15:54:17 +09301596 kfree(port->name);
Amit Shahea3768b2013-07-29 14:20:29 +09301597
Amit Shahb353a6b2010-09-02 18:38:29 +05301598 /*
1599 * Locks around here are not necessary - a port can't be
1600 * opened after we removed the port struct from ports_list
1601 * above.
1602 */
1603 kref_put(&port->kref, remove_port);
Amit Shah1f7aa422009-12-21 22:27:31 +05301604}
1605
Amit Shah17634ba2009-12-21 21:03:25 +05301606/* Any private messages that the Host and Guest want to share */
Michael S. Tsirkin1f0f9102014-12-01 13:17:40 +02001607static void handle_control_message(struct virtio_device *vdev,
1608 struct ports_device *portdev,
Amit Shah17634ba2009-12-21 21:03:25 +05301609 struct port_buffer *buf)
1610{
1611 struct virtio_console_control *cpkt;
1612 struct port *port;
Amit Shah431edb82009-12-21 21:57:40 +05301613 size_t name_size;
1614 int err;
Amit Shah17634ba2009-12-21 21:03:25 +05301615
1616 cpkt = (struct virtio_console_control *)(buf->buf + buf->offset);
1617
Michael S. Tsirkin1f0f9102014-12-01 13:17:40 +02001618 port = find_port_by_id(portdev, virtio32_to_cpu(vdev, cpkt->id));
1619 if (!port &&
1620 cpkt->event != cpu_to_virtio16(vdev, VIRTIO_CONSOLE_PORT_ADD)) {
Amit Shah17634ba2009-12-21 21:03:25 +05301621 /* No valid header at start of buffer. Drop it. */
1622 dev_dbg(&portdev->vdev->dev,
1623 "Invalid index %u in control packet\n", cpkt->id);
1624 return;
1625 }
1626
Michael S. Tsirkin1f0f9102014-12-01 13:17:40 +02001627 switch (virtio16_to_cpu(vdev, cpkt->event)) {
Amit Shahf909f852010-05-19 22:15:48 -06001628 case VIRTIO_CONSOLE_PORT_ADD:
1629 if (port) {
Amit Shah1d051602010-05-19 22:15:49 -06001630 dev_dbg(&portdev->vdev->dev,
1631 "Port %u already added\n", port->id);
Amit Shahf909f852010-05-19 22:15:48 -06001632 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
1633 break;
1634 }
Michael S. Tsirkin1f0f9102014-12-01 13:17:40 +02001635 if (virtio32_to_cpu(vdev, cpkt->id) >=
1636 portdev->config.max_nr_ports) {
Amit Shahf909f852010-05-19 22:15:48 -06001637 dev_warn(&portdev->vdev->dev,
Michael S. Tsirkin1f0f9102014-12-01 13:17:40 +02001638 "Request for adding port with "
1639 "out-of-bound id %u, max. supported id: %u\n",
Amit Shahf909f852010-05-19 22:15:48 -06001640 cpkt->id, portdev->config.max_nr_ports - 1);
1641 break;
1642 }
Michael S. Tsirkin1f0f9102014-12-01 13:17:40 +02001643 add_port(portdev, virtio32_to_cpu(vdev, cpkt->id));
Amit Shahf909f852010-05-19 22:15:48 -06001644 break;
1645 case VIRTIO_CONSOLE_PORT_REMOVE:
Amit Shahb353a6b2010-09-02 18:38:29 +05301646 unplug_port(port);
Amit Shahf909f852010-05-19 22:15:48 -06001647 break;
Amit Shah17634ba2009-12-21 21:03:25 +05301648 case VIRTIO_CONSOLE_CONSOLE_PORT:
1649 if (!cpkt->value)
1650 break;
1651 if (is_console_port(port))
1652 break;
1653
1654 init_port_console(port);
Christian Borntraeger5e384832011-09-22 23:44:23 +05301655 complete(&early_console_added);
Amit Shah17634ba2009-12-21 21:03:25 +05301656 /*
1657 * Could remove the port here in case init fails - but
1658 * have to notify the host first.
1659 */
1660 break;
Amit Shah8345adb2010-05-06 02:05:09 +05301661 case VIRTIO_CONSOLE_RESIZE: {
1662 struct {
1663 __u16 rows;
1664 __u16 cols;
1665 } size;
1666
Amit Shah17634ba2009-12-21 21:03:25 +05301667 if (!is_console_port(port))
1668 break;
Amit Shah8345adb2010-05-06 02:05:09 +05301669
1670 memcpy(&size, buf->buf + buf->offset + sizeof(*cpkt),
1671 sizeof(size));
1672 set_console_size(port, size.rows, size.cols);
1673
Amit Shah17634ba2009-12-21 21:03:25 +05301674 port->cons.hvc->irq_requested = 1;
1675 resize_console(port);
1676 break;
Amit Shah8345adb2010-05-06 02:05:09 +05301677 }
Amit Shah2030fa42009-12-21 21:49:30 +05301678 case VIRTIO_CONSOLE_PORT_OPEN:
Michael S. Tsirkin1f0f9102014-12-01 13:17:40 +02001679 port->host_connected = virtio16_to_cpu(vdev, cpkt->value);
Amit Shah2030fa42009-12-21 21:49:30 +05301680 wake_up_interruptible(&port->waitqueue);
Amit Shahcdfadfc2010-05-19 22:15:50 -06001681 /*
1682 * If the host port got closed and the host had any
1683 * unconsumed buffers, we'll be able to reclaim them
1684 * now.
1685 */
1686 spin_lock_irq(&port->outvq_lock);
1687 reclaim_consumed_buffers(port);
1688 spin_unlock_irq(&port->outvq_lock);
Amit Shah3eae0ad2010-09-02 18:47:52 +05301689
1690 /*
1691 * If the guest is connected, it'll be interested in
1692 * knowing the host connection state changed.
1693 */
Amit Shah314081f2013-07-29 14:25:38 +09301694 spin_lock_irq(&port->inbuf_lock);
Amit Shah3eae0ad2010-09-02 18:47:52 +05301695 send_sigio_to_port(port);
Amit Shah314081f2013-07-29 14:25:38 +09301696 spin_unlock_irq(&port->inbuf_lock);
Amit Shah2030fa42009-12-21 21:49:30 +05301697 break;
Amit Shah431edb82009-12-21 21:57:40 +05301698 case VIRTIO_CONSOLE_PORT_NAME:
1699 /*
Amit Shah291024e2011-09-14 13:06:40 +05301700 * If we woke up after hibernation, we can get this
1701 * again. Skip it in that case.
1702 */
1703 if (port->name)
1704 break;
1705
1706 /*
Amit Shah431edb82009-12-21 21:57:40 +05301707 * Skip the size of the header and the cpkt to get the size
1708 * of the name that was sent
1709 */
1710 name_size = buf->len - buf->offset - sizeof(*cpkt) + 1;
1711
1712 port->name = kmalloc(name_size, GFP_KERNEL);
1713 if (!port->name) {
1714 dev_err(port->dev,
1715 "Not enough space to store port name\n");
1716 break;
1717 }
1718 strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt),
1719 name_size - 1);
1720 port->name[name_size - 1] = 0;
1721
1722 /*
1723 * Since we only have one sysfs attribute, 'name',
1724 * create it only if we have a name for the port.
1725 */
1726 err = sysfs_create_group(&port->dev->kobj,
1727 &port_attribute_group);
Amit Shahec642132010-03-19 17:36:43 +05301728 if (err) {
Amit Shah431edb82009-12-21 21:57:40 +05301729 dev_err(port->dev,
1730 "Error %d creating sysfs device attributes\n",
1731 err);
Amit Shahec642132010-03-19 17:36:43 +05301732 } else {
1733 /*
1734 * Generate a udev event so that appropriate
1735 * symlinks can be created based on udev
1736 * rules.
1737 */
1738 kobject_uevent(&port->dev->kobj, KOBJ_CHANGE);
1739 }
Amit Shah431edb82009-12-21 21:57:40 +05301740 break;
Amit Shah17634ba2009-12-21 21:03:25 +05301741 }
1742}
1743
1744static void control_work_handler(struct work_struct *work)
1745{
1746 struct ports_device *portdev;
1747 struct virtqueue *vq;
1748 struct port_buffer *buf;
1749 unsigned int len;
1750
1751 portdev = container_of(work, struct ports_device, control_work);
1752 vq = portdev->c_ivq;
1753
Amit Shah165b1b82013-03-29 16:30:07 +05301754 spin_lock(&portdev->c_ivq_lock);
Michael S. Tsirkin505b0452010-04-12 16:18:32 +03001755 while ((buf = virtqueue_get_buf(vq, &len))) {
Amit Shah165b1b82013-03-29 16:30:07 +05301756 spin_unlock(&portdev->c_ivq_lock);
Amit Shah17634ba2009-12-21 21:03:25 +05301757
1758 buf->len = len;
1759 buf->offset = 0;
1760
Michael S. Tsirkin1f0f9102014-12-01 13:17:40 +02001761 handle_control_message(vq->vdev, portdev, buf);
Amit Shah17634ba2009-12-21 21:03:25 +05301762
Amit Shah165b1b82013-03-29 16:30:07 +05301763 spin_lock(&portdev->c_ivq_lock);
Amit Shah17634ba2009-12-21 21:03:25 +05301764 if (add_inbuf(portdev->c_ivq, buf) < 0) {
1765 dev_warn(&portdev->vdev->dev,
1766 "Error adding buffer to queue\n");
Sjur Brændeland1b637042012-12-14 14:40:51 +10301767 free_buf(buf, false);
Amit Shah17634ba2009-12-21 21:03:25 +05301768 }
1769 }
Amit Shah165b1b82013-03-29 16:30:07 +05301770 spin_unlock(&portdev->c_ivq_lock);
Amit Shah17634ba2009-12-21 21:03:25 +05301771}
1772
Amit Shah2770c5e2011-01-31 13:06:36 +05301773static void out_intr(struct virtqueue *vq)
1774{
1775 struct port *port;
1776
1777 port = find_port_by_vq(vq->vdev->priv, vq);
1778 if (!port)
1779 return;
1780
1781 wake_up_interruptible(&port->waitqueue);
1782}
1783
Amit Shah17634ba2009-12-21 21:03:25 +05301784static void in_intr(struct virtqueue *vq)
1785{
1786 struct port *port;
1787 unsigned long flags;
1788
1789 port = find_port_by_vq(vq->vdev->priv, vq);
1790 if (!port)
1791 return;
1792
1793 spin_lock_irqsave(&port->inbuf_lock, flags);
Amit Shahd25a9dd2011-09-14 13:06:43 +05301794 port->inbuf = get_inbuf(port);
Amit Shah17634ba2009-12-21 21:03:25 +05301795
Amit Shah88f251a2009-12-21 22:15:30 +05301796 /*
Sjur Brændelandaabd6a82013-03-18 19:19:14 +10301797 * Normally the port should not accept data when the port is
1798 * closed. For generic serial ports, the host won't (shouldn't)
1799 * send data till the guest is connected. But this condition
Amit Shah88f251a2009-12-21 22:15:30 +05301800 * can be reached when a console port is not yet connected (no
Sjur Brændelandaabd6a82013-03-18 19:19:14 +10301801 * tty is spawned) and the other side sends out data over the
1802 * vring, or when a remote devices start sending data before
1803 * the ports are opened.
1804 *
1805 * A generic serial port will discard data if not connected,
1806 * while console ports and rproc-serial ports accepts data at
1807 * any time. rproc-serial is initiated with guest_connected to
1808 * false because port_fops_open expects this. Console ports are
1809 * hooked up with an HVC console and is initialized with
1810 * guest_connected to true.
Amit Shah88f251a2009-12-21 22:15:30 +05301811 */
Sjur Brændelandaabd6a82013-03-18 19:19:14 +10301812
1813 if (!port->guest_connected && !is_rproc_serial(port->portdev->vdev))
Amit Shah88f251a2009-12-21 22:15:30 +05301814 discard_port_data(port);
1815
Amit Shah314081f2013-07-29 14:25:38 +09301816 /* Send a SIGIO indicating new data in case the process asked for it */
1817 send_sigio_to_port(port);
1818
Amit Shah17634ba2009-12-21 21:03:25 +05301819 spin_unlock_irqrestore(&port->inbuf_lock, flags);
1820
Amit Shah2030fa42009-12-21 21:49:30 +05301821 wake_up_interruptible(&port->waitqueue);
1822
Amit Shah17634ba2009-12-21 21:03:25 +05301823 if (is_console_port(port) && hvc_poll(port->cons.hvc))
1824 hvc_kick();
1825}
1826
1827static void control_intr(struct virtqueue *vq)
1828{
1829 struct ports_device *portdev;
1830
1831 portdev = vq->vdev->priv;
1832 schedule_work(&portdev->control_work);
1833}
1834
Amit Shah7f5d8102009-12-21 22:22:08 +05301835static void config_intr(struct virtio_device *vdev)
1836{
1837 struct ports_device *portdev;
1838
1839 portdev = vdev->priv;
Amit Shah99f905f2010-05-19 22:15:48 -06001840
Michael S. Tsirkineeb8a7e2015-03-05 10:45:49 +10301841 if (!use_multiport(portdev))
1842 schedule_work(&portdev->config_work);
1843}
1844
1845static void config_work_handler(struct work_struct *work)
1846{
1847 struct ports_device *portdev;
1848
1849 portdev = container_of(work, struct ports_device, control_work);
Amit Shah4038f5b72010-05-06 02:05:07 +05301850 if (!use_multiport(portdev)) {
Michael S. Tsirkineeb8a7e2015-03-05 10:45:49 +10301851 struct virtio_device *vdev;
Amit Shah97788292010-05-06 02:05:08 +05301852 struct port *port;
1853 u16 rows, cols;
1854
Michael S. Tsirkineeb8a7e2015-03-05 10:45:49 +10301855 vdev = portdev->vdev;
Rusty Russell855e0c52013-10-14 18:11:51 +10301856 virtio_cread(vdev, struct virtio_console_config, cols, &cols);
1857 virtio_cread(vdev, struct virtio_console_config, rows, &rows);
Amit Shah97788292010-05-06 02:05:08 +05301858
1859 port = find_port_by_id(portdev, 0);
1860 set_console_size(port, rows, cols);
1861
Amit Shah4038f5b72010-05-06 02:05:07 +05301862 /*
1863 * We'll use this way of resizing only for legacy
1864 * support. For newer userspace
1865 * (VIRTIO_CONSOLE_F_MULTPORT+), use control messages
1866 * to indicate console size changes so that it can be
1867 * done per-port.
1868 */
Amit Shah97788292010-05-06 02:05:08 +05301869 resize_console(port);
Amit Shah4038f5b72010-05-06 02:05:07 +05301870 }
Amit Shah7f5d8102009-12-21 22:22:08 +05301871}
1872
Amit Shah2658a79a2010-01-18 19:15:11 +05301873static int init_vqs(struct ports_device *portdev)
1874{
1875 vq_callback_t **io_callbacks;
1876 char **io_names;
1877 struct virtqueue **vqs;
Amit Shah17634ba2009-12-21 21:03:25 +05301878 u32 i, j, nr_ports, nr_queues;
Amit Shah2658a79a2010-01-18 19:15:11 +05301879 int err;
1880
Amit Shah17634ba2009-12-21 21:03:25 +05301881 nr_ports = portdev->config.max_nr_ports;
1882 nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2;
Amit Shah2658a79a2010-01-18 19:15:11 +05301883
1884 vqs = kmalloc(nr_queues * sizeof(struct virtqueue *), GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301885 io_callbacks = kmalloc(nr_queues * sizeof(vq_callback_t *), GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301886 io_names = kmalloc(nr_queues * sizeof(char *), GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301887 portdev->in_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
1888 GFP_KERNEL);
Amit Shah2658a79a2010-01-18 19:15:11 +05301889 portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
1890 GFP_KERNEL);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001891 if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs ||
Amit Shah286f9a22011-09-14 13:06:39 +05301892 !portdev->out_vqs) {
Amit Shah2658a79a2010-01-18 19:15:11 +05301893 err = -ENOMEM;
Jiri Slaby22e132f2010-11-06 10:06:50 +01001894 goto free;
Amit Shah2658a79a2010-01-18 19:15:11 +05301895 }
1896
Amit Shah17634ba2009-12-21 21:03:25 +05301897 /*
1898 * For backward compat (newer host but older guest), the host
1899 * spawns a console port first and also inits the vqs for port
1900 * 0 before others.
1901 */
1902 j = 0;
1903 io_callbacks[j] = in_intr;
Amit Shah2770c5e2011-01-31 13:06:36 +05301904 io_callbacks[j + 1] = out_intr;
Amit Shah17634ba2009-12-21 21:03:25 +05301905 io_names[j] = "input";
1906 io_names[j + 1] = "output";
1907 j += 2;
Amit Shah2658a79a2010-01-18 19:15:11 +05301908
Amit Shah17634ba2009-12-21 21:03:25 +05301909 if (use_multiport(portdev)) {
1910 io_callbacks[j] = control_intr;
1911 io_callbacks[j + 1] = NULL;
1912 io_names[j] = "control-i";
1913 io_names[j + 1] = "control-o";
1914
1915 for (i = 1; i < nr_ports; i++) {
1916 j += 2;
1917 io_callbacks[j] = in_intr;
Amit Shah2770c5e2011-01-31 13:06:36 +05301918 io_callbacks[j + 1] = out_intr;
Amit Shah17634ba2009-12-21 21:03:25 +05301919 io_names[j] = "input";
1920 io_names[j + 1] = "output";
1921 }
1922 }
Amit Shah2658a79a2010-01-18 19:15:11 +05301923 /* Find the queues. */
1924 err = portdev->vdev->config->find_vqs(portdev->vdev, nr_queues, vqs,
1925 io_callbacks,
1926 (const char **)io_names);
1927 if (err)
Jiri Slaby22e132f2010-11-06 10:06:50 +01001928 goto free;
Amit Shah2658a79a2010-01-18 19:15:11 +05301929
Amit Shah17634ba2009-12-21 21:03:25 +05301930 j = 0;
Amit Shah2658a79a2010-01-18 19:15:11 +05301931 portdev->in_vqs[0] = vqs[0];
1932 portdev->out_vqs[0] = vqs[1];
Amit Shah17634ba2009-12-21 21:03:25 +05301933 j += 2;
1934 if (use_multiport(portdev)) {
1935 portdev->c_ivq = vqs[j];
1936 portdev->c_ovq = vqs[j + 1];
Amit Shah2658a79a2010-01-18 19:15:11 +05301937
Amit Shah17634ba2009-12-21 21:03:25 +05301938 for (i = 1; i < nr_ports; i++) {
1939 j += 2;
1940 portdev->in_vqs[i] = vqs[j];
1941 portdev->out_vqs[i] = vqs[j + 1];
1942 }
1943 }
Amit Shah2658a79a2010-01-18 19:15:11 +05301944 kfree(io_names);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001945 kfree(io_callbacks);
Amit Shah2658a79a2010-01-18 19:15:11 +05301946 kfree(vqs);
1947
1948 return 0;
1949
Jiri Slaby22e132f2010-11-06 10:06:50 +01001950free:
Amit Shah2658a79a2010-01-18 19:15:11 +05301951 kfree(portdev->out_vqs);
Amit Shah2658a79a2010-01-18 19:15:11 +05301952 kfree(portdev->in_vqs);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001953 kfree(io_names);
1954 kfree(io_callbacks);
Amit Shah2658a79a2010-01-18 19:15:11 +05301955 kfree(vqs);
Jiri Slaby22e132f2010-11-06 10:06:50 +01001956
Amit Shah2658a79a2010-01-18 19:15:11 +05301957 return err;
1958}
1959
Amit Shahfb08bd22009-12-21 21:36:04 +05301960static const struct file_operations portdev_fops = {
1961 .owner = THIS_MODULE,
1962};
1963
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301964static void remove_vqs(struct ports_device *portdev)
1965{
1966 portdev->vdev->config->del_vqs(portdev->vdev);
1967 kfree(portdev->in_vqs);
1968 kfree(portdev->out_vqs);
1969}
1970
1971static void remove_controlq_data(struct ports_device *portdev)
1972{
1973 struct port_buffer *buf;
1974 unsigned int len;
1975
1976 if (!use_multiport(portdev))
1977 return;
1978
1979 while ((buf = virtqueue_get_buf(portdev->c_ivq, &len)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301980 free_buf(buf, true);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301981
1982 while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq)))
Sjur Brændeland1b637042012-12-14 14:40:51 +10301983 free_buf(buf, true);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05301984}
1985
Amit Shah1c85bf32010-01-18 19:15:07 +05301986/*
1987 * Once we're further in boot, we get probed like any other virtio
1988 * device.
Amit Shah17634ba2009-12-21 21:03:25 +05301989 *
1990 * If the host also supports multiple console ports, we check the
1991 * config space to see how many ports the host has spawned. We
1992 * initialize each port found.
Amit Shah1c85bf32010-01-18 19:15:07 +05301993 */
Bill Pemberton2223cbe2012-11-19 13:22:51 -05001994static int virtcons_probe(struct virtio_device *vdev)
Amit Shah1c85bf32010-01-18 19:15:07 +05301995{
Amit Shah1c85bf32010-01-18 19:15:07 +05301996 struct ports_device *portdev;
1997 int err;
Amit Shah17634ba2009-12-21 21:03:25 +05301998 bool multiport;
Christian Borntraeger5e384832011-09-22 23:44:23 +05301999 bool early = early_put_chars != NULL;
2000
Rusty Russellbe8ff592015-02-11 15:01:14 +10302001 /* We only need a config space if features are offered */
2002 if (!vdev->config->get &&
2003 (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE)
2004 || virtio_has_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT))) {
Michael S. Tsirkin011f0e72015-01-12 16:23:37 +02002005 dev_err(&vdev->dev, "%s failure: config access disabled\n",
2006 __func__);
2007 return -EINVAL;
2008 }
2009
Christian Borntraeger5e384832011-09-22 23:44:23 +05302010 /* Ensure to read early_put_chars now */
2011 barrier();
Amit Shah1c85bf32010-01-18 19:15:07 +05302012
2013 portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
2014 if (!portdev) {
2015 err = -ENOMEM;
2016 goto fail;
2017 }
2018
2019 /* Attach this portdev to this virtio_device, and vice-versa. */
2020 portdev->vdev = vdev;
2021 vdev->priv = portdev;
2022
Amit Shahfb08bd22009-12-21 21:36:04 +05302023 portdev->chr_major = register_chrdev(0, "virtio-portsdev",
2024 &portdev_fops);
2025 if (portdev->chr_major < 0) {
2026 dev_err(&vdev->dev,
2027 "Error %d registering chrdev for device %u\n",
Sjur Brændelanddc18f082013-02-12 16:24:59 +10302028 portdev->chr_major, vdev->index);
Amit Shahfb08bd22009-12-21 21:36:04 +05302029 err = portdev->chr_major;
2030 goto free;
2031 }
2032
Amit Shah17634ba2009-12-21 21:03:25 +05302033 multiport = false;
Amit Shah17634ba2009-12-21 21:03:25 +05302034 portdev->config.max_nr_ports = 1;
Sjur Brændeland1b637042012-12-14 14:40:51 +10302035
2036 /* Don't test MULTIPORT at all if we're rproc: not a valid feature! */
2037 if (!is_rproc_serial(vdev) &&
Rusty Russell855e0c52013-10-14 18:11:51 +10302038 virtio_cread_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT,
2039 struct virtio_console_config, max_nr_ports,
2040 &portdev->config.max_nr_ports) == 0) {
Amit Shah17634ba2009-12-21 21:03:25 +05302041 multiport = true;
Sjur Brændeland1b637042012-12-14 14:40:51 +10302042 }
Amit Shah17634ba2009-12-21 21:03:25 +05302043
Amit Shah2658a79a2010-01-18 19:15:11 +05302044 err = init_vqs(portdev);
2045 if (err < 0) {
2046 dev_err(&vdev->dev, "Error %d initializing vqs\n", err);
Amit Shahfb08bd22009-12-21 21:36:04 +05302047 goto free_chrdev;
Amit Shah2658a79a2010-01-18 19:15:11 +05302048 }
Amit Shah1c85bf32010-01-18 19:15:07 +05302049
Amit Shah17634ba2009-12-21 21:03:25 +05302050 spin_lock_init(&portdev->ports_lock);
2051 INIT_LIST_HEAD(&portdev->ports);
2052
Cornelia Huck65eca3a2014-10-20 15:58:49 +02002053 virtio_device_ready(portdev->vdev);
2054
Michael S. Tsirkineeb8a7e2015-03-05 10:45:49 +10302055 INIT_WORK(&portdev->config_work, &config_work_handler);
Michael S. Tsirkin4f6e24e2015-03-05 10:45:30 +10302056 INIT_WORK(&portdev->control_work, &control_work_handler);
2057
Amit Shah17634ba2009-12-21 21:03:25 +05302058 if (multiport) {
Amit Shah335a64a5c2010-02-24 10:37:44 +05302059 unsigned int nr_added_bufs;
2060
Amit Shah165b1b82013-03-29 16:30:07 +05302061 spin_lock_init(&portdev->c_ivq_lock);
Amit Shah9ba5c802013-03-29 16:30:08 +05302062 spin_lock_init(&portdev->c_ovq_lock);
Amit Shah17634ba2009-12-21 21:03:25 +05302063
Amit Shah165b1b82013-03-29 16:30:07 +05302064 nr_added_bufs = fill_queue(portdev->c_ivq,
2065 &portdev->c_ivq_lock);
Amit Shah335a64a5c2010-02-24 10:37:44 +05302066 if (!nr_added_bufs) {
Amit Shah22a29ea2010-02-12 10:32:17 +05302067 dev_err(&vdev->dev,
2068 "Error allocating buffers for control queue\n");
2069 err = -ENOMEM;
2070 goto free_vqs;
2071 }
Amit Shah1d051602010-05-19 22:15:49 -06002072 } else {
2073 /*
2074 * For backward compatibility: Create a console port
2075 * if we're running on older host.
2076 */
2077 add_port(portdev, 0);
Amit Shah17634ba2009-12-21 21:03:25 +05302078 }
2079
Amit Shah6bdf2af2010-09-02 18:11:49 +05302080 spin_lock_irq(&pdrvdata_lock);
2081 list_add_tail(&portdev->list, &pdrvdata.portdevs);
2082 spin_unlock_irq(&pdrvdata_lock);
2083
Amit Shahf909f852010-05-19 22:15:48 -06002084 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2085 VIRTIO_CONSOLE_DEVICE_READY, 1);
Christian Borntraeger5e384832011-09-22 23:44:23 +05302086
2087 /*
2088 * If there was an early virtio console, assume that there are no
2089 * other consoles. We need to wait until the hvc_alloc matches the
2090 * hvc_instantiate, otherwise tty_open will complain, resulting in
2091 * a "Warning: unable to open an initial console" boot failure.
2092 * Without multiport this is done in add_port above. With multiport
2093 * this might take some host<->guest communication - thus we have to
2094 * wait.
2095 */
2096 if (multiport && early)
2097 wait_for_completion(&early_console_added);
2098
Rusty Russell31610432007-10-22 11:03:39 +10002099 return 0;
2100
Amit Shah22a29ea2010-02-12 10:32:17 +05302101free_vqs:
Julia Lawall0643e4c2010-05-15 11:45:53 +02002102 /* The host might want to notify mgmt sw about device add failure */
2103 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
2104 VIRTIO_CONSOLE_DEVICE_READY, 0);
Amit Shaha0e2dbf2011-12-22 16:58:27 +05302105 remove_vqs(portdev);
Amit Shahfb08bd22009-12-21 21:36:04 +05302106free_chrdev:
2107 unregister_chrdev(portdev->chr_major, "virtio-portsdev");
Rusty Russell31610432007-10-22 11:03:39 +10002108free:
Amit Shah1c85bf32010-01-18 19:15:07 +05302109 kfree(portdev);
Rusty Russell31610432007-10-22 11:03:39 +10002110fail:
2111 return err;
2112}
2113
Amit Shah71778762010-02-12 10:32:16 +05302114static void virtcons_remove(struct virtio_device *vdev)
2115{
2116 struct ports_device *portdev;
2117 struct port *port, *port2;
Amit Shah71778762010-02-12 10:32:16 +05302118
2119 portdev = vdev->priv;
2120
Amit Shah6bdf2af2010-09-02 18:11:49 +05302121 spin_lock_irq(&pdrvdata_lock);
2122 list_del(&portdev->list);
2123 spin_unlock_irq(&pdrvdata_lock);
2124
Amit Shah02238952010-09-02 18:11:40 +05302125 /* Disable interrupts for vqs */
2126 vdev->config->reset(vdev);
2127 /* Finish up work that's lined up */
Sjur Brændelandaded0242013-01-22 09:50:26 +10302128 if (use_multiport(portdev))
2129 cancel_work_sync(&portdev->control_work);
Michael S. Tsirkineeb8a7e2015-03-05 10:45:49 +10302130 else
2131 cancel_work_sync(&portdev->config_work);
Amit Shah71778762010-02-12 10:32:16 +05302132
2133 list_for_each_entry_safe(port, port2, &portdev->ports, list)
Amit Shahb353a6b2010-09-02 18:38:29 +05302134 unplug_port(port);
Amit Shah71778762010-02-12 10:32:16 +05302135
2136 unregister_chrdev(portdev->chr_major, "virtio-portsdev");
2137
Amit Shahe0620132010-09-02 18:38:30 +05302138 /*
2139 * When yanking out a device, we immediately lose the
2140 * (device-side) queues. So there's no point in keeping the
2141 * guest side around till we drop our final reference. This
2142 * also means that any ports which are in an open state will
2143 * have to just stop using the port, as the vqs are going
2144 * away.
2145 */
Amit Shaha0e2dbf2011-12-22 16:58:27 +05302146 remove_controlq_data(portdev);
2147 remove_vqs(portdev);
Amit Shah71778762010-02-12 10:32:16 +05302148 kfree(portdev);
2149}
2150
Rusty Russell31610432007-10-22 11:03:39 +10002151static struct virtio_device_id id_table[] = {
2152 { VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID },
2153 { 0 },
2154};
2155
Christian Borntraegerc2983452008-11-25 13:36:26 +01002156static unsigned int features[] = {
2157 VIRTIO_CONSOLE_F_SIZE,
Amit Shahb99fa812010-05-19 22:15:46 -06002158 VIRTIO_CONSOLE_F_MULTIPORT,
Christian Borntraegerc2983452008-11-25 13:36:26 +01002159};
2160
Sjur Brændeland1b637042012-12-14 14:40:51 +10302161static struct virtio_device_id rproc_serial_id_table[] = {
2162#if IS_ENABLED(CONFIG_REMOTEPROC)
2163 { VIRTIO_ID_RPROC_SERIAL, VIRTIO_DEV_ANY_ID },
2164#endif
2165 { 0 },
2166};
2167
2168static unsigned int rproc_serial_features[] = {
2169};
2170
Aaron Lu89107002013-09-17 09:25:23 +09302171#ifdef CONFIG_PM_SLEEP
Amit Shah2b8f41d2011-12-22 16:58:28 +05302172static int virtcons_freeze(struct virtio_device *vdev)
2173{
2174 struct ports_device *portdev;
2175 struct port *port;
2176
2177 portdev = vdev->priv;
2178
2179 vdev->config->reset(vdev);
2180
Amit Shahc743d092012-01-06 16:19:08 +05302181 virtqueue_disable_cb(portdev->c_ivq);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302182 cancel_work_sync(&portdev->control_work);
Michael S. Tsirkineeb8a7e2015-03-05 10:45:49 +10302183 cancel_work_sync(&portdev->config_work);
Amit Shahc743d092012-01-06 16:19:08 +05302184 /*
2185 * Once more: if control_work_handler() was running, it would
2186 * enable the cb as the last step.
2187 */
2188 virtqueue_disable_cb(portdev->c_ivq);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302189 remove_controlq_data(portdev);
2190
2191 list_for_each_entry(port, &portdev->ports, list) {
Amit Shahc743d092012-01-06 16:19:08 +05302192 virtqueue_disable_cb(port->in_vq);
2193 virtqueue_disable_cb(port->out_vq);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302194 /*
2195 * We'll ask the host later if the new invocation has
2196 * the port opened or closed.
2197 */
2198 port->host_connected = false;
2199 remove_port_data(port);
2200 }
2201 remove_vqs(portdev);
2202
2203 return 0;
2204}
2205
2206static int virtcons_restore(struct virtio_device *vdev)
2207{
2208 struct ports_device *portdev;
2209 struct port *port;
2210 int ret;
2211
2212 portdev = vdev->priv;
2213
2214 ret = init_vqs(portdev);
2215 if (ret)
2216 return ret;
2217
Michael S. Tsirkin401bbdc2014-10-15 10:22:32 +10302218 virtio_device_ready(portdev->vdev);
2219
Amit Shah2b8f41d2011-12-22 16:58:28 +05302220 if (use_multiport(portdev))
Amit Shah165b1b82013-03-29 16:30:07 +05302221 fill_queue(portdev->c_ivq, &portdev->c_ivq_lock);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302222
2223 list_for_each_entry(port, &portdev->ports, list) {
2224 port->in_vq = portdev->in_vqs[port->id];
2225 port->out_vq = portdev->out_vqs[port->id];
2226
2227 fill_queue(port->in_vq, &port->inbuf_lock);
2228
2229 /* Get port open/close status on the host */
2230 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
Amit Shahfa8b66c2012-04-25 14:40:39 +05302231
2232 /*
2233 * If a port was open at the time of suspending, we
2234 * have to let the host know that it's still open.
2235 */
2236 if (port->guest_connected)
2237 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
Amit Shah2b8f41d2011-12-22 16:58:28 +05302238 }
2239 return 0;
2240}
2241#endif
2242
Rusty Russell31610432007-10-22 11:03:39 +10002243static struct virtio_driver virtio_console = {
Christian Borntraegerc2983452008-11-25 13:36:26 +01002244 .feature_table = features,
2245 .feature_table_size = ARRAY_SIZE(features),
Rusty Russell31610432007-10-22 11:03:39 +10002246 .driver.name = KBUILD_MODNAME,
2247 .driver.owner = THIS_MODULE,
2248 .id_table = id_table,
2249 .probe = virtcons_probe,
Amit Shah71778762010-02-12 10:32:16 +05302250 .remove = virtcons_remove,
Amit Shah7f5d8102009-12-21 22:22:08 +05302251 .config_changed = config_intr,
Aaron Lu89107002013-09-17 09:25:23 +09302252#ifdef CONFIG_PM_SLEEP
Amit Shah2b8f41d2011-12-22 16:58:28 +05302253 .freeze = virtcons_freeze,
2254 .restore = virtcons_restore,
2255#endif
Rusty Russell31610432007-10-22 11:03:39 +10002256};
2257
Greg Kroah-Hartmanbcd29822012-12-21 15:12:08 -08002258static struct virtio_driver virtio_rproc_serial = {
Sjur Brændeland1b637042012-12-14 14:40:51 +10302259 .feature_table = rproc_serial_features,
2260 .feature_table_size = ARRAY_SIZE(rproc_serial_features),
2261 .driver.name = "virtio_rproc_serial",
2262 .driver.owner = THIS_MODULE,
2263 .id_table = rproc_serial_id_table,
2264 .probe = virtcons_probe,
2265 .remove = virtcons_remove,
2266};
2267
Rusty Russell31610432007-10-22 11:03:39 +10002268static int __init init(void)
2269{
Amit Shahfb08bd22009-12-21 21:36:04 +05302270 int err;
2271
2272 pdrvdata.class = class_create(THIS_MODULE, "virtio-ports");
2273 if (IS_ERR(pdrvdata.class)) {
2274 err = PTR_ERR(pdrvdata.class);
2275 pr_err("Error %d creating virtio-ports class\n", err);
2276 return err;
2277 }
Amit Shahd99393e2009-12-21 22:36:21 +05302278
2279 pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL);
Dan Carpenter3f0d0c92013-07-30 15:54:07 +09302280 if (!pdrvdata.debugfs_dir)
2281 pr_warning("Error creating debugfs dir for virtio-ports\n");
Amit Shah38edf582010-01-18 19:15:05 +05302282 INIT_LIST_HEAD(&pdrvdata.consoles);
Amit Shah6bdf2af2010-09-02 18:11:49 +05302283 INIT_LIST_HEAD(&pdrvdata.portdevs);
Amit Shah38edf582010-01-18 19:15:05 +05302284
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002285 err = register_virtio_driver(&virtio_console);
2286 if (err < 0) {
2287 pr_err("Error %d registering virtio driver\n", err);
2288 goto free;
2289 }
Sjur Brændeland1b637042012-12-14 14:40:51 +10302290 err = register_virtio_driver(&virtio_rproc_serial);
2291 if (err < 0) {
2292 pr_err("Error %d registering virtio rproc serial driver\n",
2293 err);
2294 goto unregister;
2295 }
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002296 return 0;
Sjur Brændeland1b637042012-12-14 14:40:51 +10302297unregister:
2298 unregister_virtio_driver(&virtio_console);
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002299free:
Fabian Frederick5885e482014-07-27 07:30:01 +09302300 debugfs_remove_recursive(pdrvdata.debugfs_dir);
Alexey Khoroshilov33e1afc2012-09-01 23:49:37 +04002301 class_destroy(pdrvdata.class);
2302 return err;
Rusty Russell31610432007-10-22 11:03:39 +10002303}
Amit Shah71778762010-02-12 10:32:16 +05302304
2305static void __exit fini(void)
2306{
Sjur Brændeland1b637042012-12-14 14:40:51 +10302307 reclaim_dma_bufs();
2308
Amit Shah71778762010-02-12 10:32:16 +05302309 unregister_virtio_driver(&virtio_console);
Sjur Brændeland1b637042012-12-14 14:40:51 +10302310 unregister_virtio_driver(&virtio_rproc_serial);
Amit Shah71778762010-02-12 10:32:16 +05302311
2312 class_destroy(pdrvdata.class);
Fabian Frederick5885e482014-07-27 07:30:01 +09302313 debugfs_remove_recursive(pdrvdata.debugfs_dir);
Amit Shah71778762010-02-12 10:32:16 +05302314}
Rusty Russell31610432007-10-22 11:03:39 +10002315module_init(init);
Amit Shah71778762010-02-12 10:32:16 +05302316module_exit(fini);
Rusty Russell31610432007-10-22 11:03:39 +10002317
2318MODULE_DEVICE_TABLE(virtio, id_table);
2319MODULE_DESCRIPTION("Virtio console driver");
2320MODULE_LICENSE("GPL");