2 * The Guest console driver
4 * Writing console drivers is one of the few remaining Dark Arts in Linux.
5 * Fortunately for us, the path of virtual consoles has been well-trodden by
6 * the PowerPC folks, who wrote "hvc_console.c" to generically support any
7 * virtual console. We use that infrastructure which only requires us to write
8 * the basic put_chars and get_chars functions and call the right register
12 /*M:002 The console can be flooded: while the Guest is processing input the
13 * Host can send more. Buffering in the Host could alleviate this, but it is a
14 * difficult problem in general. :*/
15 /* Copyright (C) 2006, 2007 Rusty Russell, IBM Corporation
17 * This program is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation; either version 2 of the License, or
20 * (at your option) any later version.
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
31 #include <linux/err.h>
32 #include <linux/init.h>
33 #include <linux/virtio.h>
34 #include <linux/virtio_console.h>
35 #include "hvc_console.h"
37 /*D:340 These represent our input and output console queues, and the virtio
38 * operations for them. */
39 static struct virtqueue
*in_vq
, *out_vq
;
40 static struct virtio_device
*vdev
;
42 /* This is our input buffer, and how much data is left in it. */
43 static unsigned int in_len
;
44 static char *in
, *inbuf
;
46 /* The operations for our console. */
47 static struct hv_ops virtio_cons
;
50 static struct hvc_struct
*hvc
;
52 /*D:310 The put_chars() callback is pretty straightforward.
54 * We turn the characters into a scatter-gather list, add it to the output
55 * queue and then kick the Host. Then we sit here waiting for it to finish:
56 * inefficient in theory, but in practice implementations will do it
57 * immediately (lguest's Launcher does). */
58 static int put_chars(u32 vtermno
, const char *buf
, int count
)
60 struct scatterlist sg
[1];
63 /* This is a convenient routine to initialize a single-elem sg list */
64 sg_init_one(sg
, buf
, count
);
66 /* add_buf wants a token to identify this buffer: we hand it any
67 * non-NULL pointer, since there's only ever one buffer. */
68 if (out_vq
->vq_ops
->add_buf(out_vq
, sg
, 1, 0, (void *)1) == 0) {
69 /* Tell Host to go! */
70 out_vq
->vq_ops
->kick(out_vq
);
71 /* Chill out until it's done with the buffer. */
72 while (!out_vq
->vq_ops
->get_buf(out_vq
, &len
))
76 /* We're expected to return the amount of data we wrote: all of it. */
80 /* Create a scatter-gather list representing our input buffer and put it in the
82 static void add_inbuf(void)
84 struct scatterlist sg
[1];
85 sg_init_one(sg
, inbuf
, PAGE_SIZE
);
87 /* We should always be able to add one buffer to an empty queue. */
88 if (in_vq
->vq_ops
->add_buf(in_vq
, sg
, 0, 1, inbuf
) != 0)
90 in_vq
->vq_ops
->kick(in_vq
);
93 /*D:350 get_chars() is the callback from the hvc_console infrastructure when
94 * an interrupt is received.
96 * Most of the code deals with the fact that the hvc_console() infrastructure
97 * only asks us for 16 bytes at a time. We keep in_offset and in_used fields
98 * for partially-filled buffers. */
99 static int get_chars(u32 vtermno
, char *buf
, int count
)
101 /* If we don't have an input queue yet, we can't get input. */
104 /* No buffer? Try to get one. */
106 in
= in_vq
->vq_ops
->get_buf(in_vq
, &in_len
);
111 /* You want more than we have to give? Well, try wanting less! */
115 /* Copy across to their buffer and increment offset. */
116 memcpy(buf
, in
, count
);
120 /* Finished? Re-register buffer so Host will use it again. */
128 /*D:320 Console drivers are initialized very early so boot messages can go out,
129 * so we do things slightly differently from the generic virtio initialization
130 * of the net and block drivers.
132 * At this stage, the console is output-only. It's too early to set up a
133 * virtqueue, so we let the drivers do some boutique early-output thing. */
134 int __init
virtio_cons_early_init(int (*put_chars
)(u32
, const char *, int))
136 virtio_cons
.put_chars
= put_chars
;
137 return hvc_instantiate(0, 0, &virtio_cons
);
141 * virtio console configuration. This supports:
144 static void virtcons_apply_config(struct virtio_device
*dev
)
148 if (virtio_has_feature(dev
, VIRTIO_CONSOLE_F_SIZE
)) {
149 dev
->config
->get(dev
,
150 offsetof(struct virtio_console_config
, cols
),
151 &ws
.ws_col
, sizeof(u16
));
152 dev
->config
->get(dev
,
153 offsetof(struct virtio_console_config
, rows
),
154 &ws
.ws_row
, sizeof(u16
));
160 * we support only one console, the hvc struct is a global var
161 * We set the configuration at this point, since we now have a tty
163 static int notifier_add_vio(struct hvc_struct
*hp
, int data
)
165 hp
->irq_requested
= 1;
166 virtcons_apply_config(vdev
);
171 static void notifier_del_vio(struct hvc_struct
*hp
, int data
)
173 hp
->irq_requested
= 0;
176 static void hvc_handle_input(struct virtqueue
*vq
)
182 /*D:370 Once we're further in boot, we get probed like any other virtio device.
183 * At this stage we set up the output virtqueue.
185 * To set up and manage our virtual console, we call hvc_alloc(). Since we
186 * never remove the console device we never need this pointer again.
188 * Finally we put our input buffer in the input queue, ready to receive. */
189 static int __devinit
virtcons_probe(struct virtio_device
*dev
)
195 /* This is the scratch page we use to receive console input */
196 inbuf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
202 /* Find the input queue. */
203 /* FIXME: This is why we want to wean off hvc: we do nothing
204 * when input comes in. */
205 in_vq
= vdev
->config
->find_vq(vdev
, 0, hvc_handle_input
, "input");
207 err
= PTR_ERR(in_vq
);
211 out_vq
= vdev
->config
->find_vq(vdev
, 1, NULL
, "output");
212 if (IS_ERR(out_vq
)) {
213 err
= PTR_ERR(out_vq
);
217 /* Start using the new console output. */
218 virtio_cons
.get_chars
= get_chars
;
219 virtio_cons
.put_chars
= put_chars
;
220 virtio_cons
.notifier_add
= notifier_add_vio
;
221 virtio_cons
.notifier_del
= notifier_del_vio
;
222 virtio_cons
.notifier_hangup
= notifier_del_vio
;
224 /* The first argument of hvc_alloc() is the virtual console number, so
225 * we use zero. The second argument is the parameter for the
226 * notification mechanism (like irq number). We currently leave this
227 * as zero, virtqueues have implicit notifications.
229 * The third argument is a "struct hv_ops" containing the put_chars()
230 * get_chars(), notifier_add() and notifier_del() pointers.
231 * The final argument is the output buffer size: we can do any size,
232 * so we put PAGE_SIZE here. */
233 hvc
= hvc_alloc(0, 0, &virtio_cons
, PAGE_SIZE
);
239 /* Register the input buffer the first time. */
244 vdev
->config
->del_vq(out_vq
);
246 vdev
->config
->del_vq(in_vq
);
253 static struct virtio_device_id id_table
[] = {
254 { VIRTIO_ID_CONSOLE
, VIRTIO_DEV_ANY_ID
},
258 static unsigned int features
[] = {
259 VIRTIO_CONSOLE_F_SIZE
,
262 static struct virtio_driver virtio_console
= {
263 .feature_table
= features
,
264 .feature_table_size
= ARRAY_SIZE(features
),
265 .driver
.name
= KBUILD_MODNAME
,
266 .driver
.owner
= THIS_MODULE
,
267 .id_table
= id_table
,
268 .probe
= virtcons_probe
,
269 .config_changed
= virtcons_apply_config
,
272 static int __init
init(void)
274 return register_virtio_driver(&virtio_console
);
278 MODULE_DEVICE_TABLE(virtio
, id_table
);
279 MODULE_DESCRIPTION("Virtio console driver");
280 MODULE_LICENSE("GPL");