Commit | Line | Data |
---|---|---|
b536b4b9 JF |
1 | /* |
2 | * xen console driver interface to hvc_console.c | |
3 | * | |
4 | * (c) 2007 Gerd Hoffmann <kraxel@suse.de> | |
5 | * | |
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 | */ | |
20 | ||
21 | #include <linux/console.h> | |
22 | #include <linux/delay.h> | |
23 | #include <linux/err.h> | |
24 | #include <linux/init.h> | |
25 | #include <linux/types.h> | |
02e19f9c | 26 | #include <linux/list.h> |
b536b4b9 | 27 | |
eb5ef071 | 28 | #include <asm/io.h> |
b536b4b9 | 29 | #include <asm/xen/hypervisor.h> |
1ccbf534 JF |
30 | |
31 | #include <xen/xen.h> | |
eb5ef071 SS |
32 | #include <xen/interface/xen.h> |
33 | #include <xen/hvm.h> | |
02e19f9c | 34 | #include <xen/grant_table.h> |
b536b4b9 JF |
35 | #include <xen/page.h> |
36 | #include <xen/events.h> | |
37 | #include <xen/interface/io/console.h> | |
38 | #include <xen/hvc-console.h> | |
02e19f9c | 39 | #include <xen/xenbus.h> |
b536b4b9 JF |
40 | |
41 | #include "hvc_console.h" | |
42 | ||
43 | #define HVC_COOKIE 0x58656e /* "Xen" in hex */ | |
44 | ||
02e19f9c SS |
45 | struct xencons_info { |
46 | struct list_head list; | |
47 | struct xenbus_device *xbdev; | |
48 | struct xencons_interface *intf; | |
49 | unsigned int evtchn; | |
50 | struct hvc_struct *hvc; | |
51 | int irq; | |
52 | int vtermno; | |
53 | grant_ref_t gntref; | |
54 | }; | |
55 | ||
56 | static LIST_HEAD(xenconsoles); | |
57 | static DEFINE_SPINLOCK(xencons_lock); | |
b536b4b9 JF |
58 | |
59 | /* ------------------------------------------------------------------ */ | |
60 | ||
02e19f9c SS |
61 | static struct xencons_info *vtermno_to_xencons(int vtermno) |
62 | { | |
63 | struct xencons_info *entry, *n, *ret = NULL; | |
64 | ||
65 | if (list_empty(&xenconsoles)) | |
66 | return NULL; | |
67 | ||
68 | list_for_each_entry_safe(entry, n, &xenconsoles, list) { | |
69 | if (entry->vtermno == vtermno) { | |
70 | ret = entry; | |
71 | break; | |
72 | } | |
73 | } | |
6b9b732d | 74 | |
02e19f9c SS |
75 | return ret; |
76 | } | |
77 | ||
78 | static inline int xenbus_devid_to_vtermno(int devid) | |
b536b4b9 | 79 | { |
02e19f9c | 80 | return devid + HVC_COOKIE; |
b536b4b9 JF |
81 | } |
82 | ||
02e19f9c | 83 | static inline void notify_daemon(struct xencons_info *cons) |
b536b4b9 JF |
84 | { |
85 | /* Use evtchn: this is called early, before irq is set up. */ | |
02e19f9c | 86 | notify_remote_via_evtchn(cons->evtchn); |
b536b4b9 JF |
87 | } |
88 | ||
02e19f9c SS |
89 | static int __write_console(struct xencons_info *xencons, |
90 | const char *data, int len) | |
b536b4b9 | 91 | { |
b536b4b9 | 92 | XENCONS_RING_IDX cons, prod; |
02e19f9c | 93 | struct xencons_interface *intf = xencons->intf; |
b536b4b9 JF |
94 | int sent = 0; |
95 | ||
96 | cons = intf->out_cons; | |
97 | prod = intf->out_prod; | |
98 | mb(); /* update queue values before going on */ | |
99 | BUG_ON((prod - cons) > sizeof(intf->out)); | |
100 | ||
101 | while ((sent < len) && ((prod - cons) < sizeof(intf->out))) | |
102 | intf->out[MASK_XENCONS_IDX(prod++, intf->out)] = data[sent++]; | |
103 | ||
104 | wmb(); /* write ring before updating pointer */ | |
105 | intf->out_prod = prod; | |
106 | ||
403a85ff | 107 | if (sent) |
02e19f9c | 108 | notify_daemon(xencons); |
b536b4b9 JF |
109 | return sent; |
110 | } | |
111 | ||
4fe7d5a7 | 112 | static int domU_write_console(uint32_t vtermno, const char *data, int len) |
7825cf10 JF |
113 | { |
114 | int ret = len; | |
02e19f9c SS |
115 | struct xencons_info *cons = vtermno_to_xencons(vtermno); |
116 | if (cons == NULL) | |
117 | return -EINVAL; | |
7825cf10 JF |
118 | |
119 | /* | |
120 | * Make sure the whole buffer is emitted, polling if | |
121 | * necessary. We don't ever want to rely on the hvc daemon | |
122 | * because the most interesting console output is when the | |
123 | * kernel is crippled. | |
124 | */ | |
125 | while (len) { | |
02e19f9c | 126 | int sent = __write_console(cons, data, len); |
7825cf10 JF |
127 | |
128 | data += sent; | |
129 | len -= sent; | |
130 | ||
131 | if (unlikely(len)) | |
132 | HYPERVISOR_sched_op(SCHEDOP_yield, NULL); | |
133 | } | |
134 | ||
135 | return ret; | |
136 | } | |
137 | ||
4fe7d5a7 | 138 | static int domU_read_console(uint32_t vtermno, char *buf, int len) |
b536b4b9 | 139 | { |
02e19f9c | 140 | struct xencons_interface *intf; |
b536b4b9 JF |
141 | XENCONS_RING_IDX cons, prod; |
142 | int recv = 0; | |
02e19f9c SS |
143 | struct xencons_info *xencons = vtermno_to_xencons(vtermno); |
144 | if (xencons == NULL) | |
145 | return -EINVAL; | |
146 | intf = xencons->intf; | |
b536b4b9 JF |
147 | |
148 | cons = intf->in_cons; | |
149 | prod = intf->in_prod; | |
150 | mb(); /* get pointers before reading ring */ | |
151 | BUG_ON((prod - cons) > sizeof(intf->in)); | |
152 | ||
153 | while (cons != prod && recv < len) | |
154 | buf[recv++] = intf->in[MASK_XENCONS_IDX(cons++, intf->in)]; | |
155 | ||
156 | mb(); /* read ring before consuming */ | |
157 | intf->in_cons = cons; | |
158 | ||
02e19f9c | 159 | notify_daemon(xencons); |
b536b4b9 JF |
160 | return recv; |
161 | } | |
162 | ||
4fe7d5a7 JF |
163 | static struct hv_ops domU_hvc_ops = { |
164 | .get_chars = domU_read_console, | |
165 | .put_chars = domU_write_console, | |
611e097d CB |
166 | .notifier_add = notifier_add_irq, |
167 | .notifier_del = notifier_del_irq, | |
fc362e2e | 168 | .notifier_hangup = notifier_hangup_irq, |
b536b4b9 JF |
169 | }; |
170 | ||
4fe7d5a7 JF |
171 | static int dom0_read_console(uint32_t vtermno, char *buf, int len) |
172 | { | |
173 | return HYPERVISOR_console_io(CONSOLEIO_read, len, buf); | |
174 | } | |
175 | ||
176 | /* | |
177 | * Either for a dom0 to write to the system console, or a domU with a | |
178 | * debug version of Xen | |
179 | */ | |
180 | static int dom0_write_console(uint32_t vtermno, const char *str, int len) | |
181 | { | |
182 | int rc = HYPERVISOR_console_io(CONSOLEIO_write, len, (char *)str); | |
183 | if (rc < 0) | |
184 | return 0; | |
185 | ||
186 | return len; | |
187 | } | |
188 | ||
189 | static struct hv_ops dom0_hvc_ops = { | |
190 | .get_chars = dom0_read_console, | |
191 | .put_chars = dom0_write_console, | |
192 | .notifier_add = notifier_add_irq, | |
193 | .notifier_del = notifier_del_irq, | |
194 | .notifier_hangup = notifier_hangup_irq, | |
195 | }; | |
196 | ||
eb5ef071 SS |
197 | static int xen_hvm_console_init(void) |
198 | { | |
199 | int r; | |
200 | uint64_t v = 0; | |
201 | unsigned long mfn; | |
02e19f9c | 202 | struct xencons_info *info; |
eb5ef071 SS |
203 | |
204 | if (!xen_hvm_domain()) | |
205 | return -ENODEV; | |
206 | ||
02e19f9c SS |
207 | info = vtermno_to_xencons(HVC_COOKIE); |
208 | if (!info) { | |
209 | info = kzalloc(sizeof(struct xencons_info), GFP_KERNEL | __GFP_ZERO); | |
210 | if (!info) | |
211 | return -ENOMEM; | |
212 | } | |
213 | ||
214 | /* already configured */ | |
215 | if (info->intf != NULL) | |
216 | return 0; | |
5842f576 KRW |
217 | /* |
218 | * If the toolstack (or the hypervisor) hasn't set these values, the | |
219 | * default value is 0. Even though mfn = 0 and evtchn = 0 are | |
220 | * theoretically correct values, in practice they never are and they | |
221 | * mean that a legacy toolstack hasn't initialized the pv console correctly. | |
222 | */ | |
eb5ef071 | 223 | r = hvm_get_parameter(HVM_PARAM_CONSOLE_EVTCHN, &v); |
5842f576 | 224 | if (r < 0 || v == 0) |
2e5ad6b9 | 225 | goto err; |
02e19f9c | 226 | info->evtchn = v; |
a32c88b9 KRW |
227 | v = 0; |
228 | r = hvm_get_parameter(HVM_PARAM_CONSOLE_PFN, &v); | |
5842f576 | 229 | if (r < 0 || v == 0) |
2e5ad6b9 | 230 | goto err; |
eb5ef071 | 231 | mfn = v; |
02e19f9c | 232 | info->intf = ioremap(mfn << PAGE_SHIFT, PAGE_SIZE); |
2e5ad6b9 KRW |
233 | if (info->intf == NULL) |
234 | goto err; | |
02e19f9c SS |
235 | info->vtermno = HVC_COOKIE; |
236 | ||
237 | spin_lock(&xencons_lock); | |
238 | list_add_tail(&info->list, &xenconsoles); | |
239 | spin_unlock(&xencons_lock); | |
240 | ||
241 | return 0; | |
2e5ad6b9 KRW |
242 | err: |
243 | kfree(info); | |
244 | return -ENODEV; | |
02e19f9c SS |
245 | } |
246 | ||
247 | static int xen_pv_console_init(void) | |
248 | { | |
249 | struct xencons_info *info; | |
250 | ||
251 | if (!xen_pv_domain()) | |
252 | return -ENODEV; | |
253 | ||
254 | if (!xen_start_info->console.domU.evtchn) | |
255 | return -ENODEV; | |
256 | ||
257 | info = vtermno_to_xencons(HVC_COOKIE); | |
258 | if (!info) { | |
259 | info = kzalloc(sizeof(struct xencons_info), GFP_KERNEL | __GFP_ZERO); | |
260 | if (!info) | |
261 | return -ENOMEM; | |
262 | } | |
263 | ||
264 | /* already configured */ | |
265 | if (info->intf != NULL) | |
266 | return 0; | |
267 | ||
268 | info->evtchn = xen_start_info->console.domU.evtchn; | |
269 | info->intf = mfn_to_virt(xen_start_info->console.domU.mfn); | |
270 | info->vtermno = HVC_COOKIE; | |
271 | ||
272 | spin_lock(&xencons_lock); | |
273 | list_add_tail(&info->list, &xenconsoles); | |
274 | spin_unlock(&xencons_lock); | |
275 | ||
276 | return 0; | |
277 | } | |
278 | ||
279 | static int xen_initial_domain_console_init(void) | |
280 | { | |
281 | struct xencons_info *info; | |
282 | ||
283 | if (!xen_initial_domain()) | |
284 | return -ENODEV; | |
285 | ||
286 | info = vtermno_to_xencons(HVC_COOKIE); | |
287 | if (!info) { | |
288 | info = kzalloc(sizeof(struct xencons_info), GFP_KERNEL | __GFP_ZERO); | |
289 | if (!info) | |
290 | return -ENOMEM; | |
291 | } | |
292 | ||
293 | info->irq = bind_virq_to_irq(VIRQ_CONSOLE, 0); | |
294 | info->vtermno = HVC_COOKIE; | |
295 | ||
296 | spin_lock(&xencons_lock); | |
297 | list_add_tail(&info->list, &xenconsoles); | |
298 | spin_unlock(&xencons_lock); | |
eb5ef071 SS |
299 | |
300 | return 0; | |
301 | } | |
302 | ||
02e19f9c SS |
303 | void xen_console_resume(void) |
304 | { | |
305 | struct xencons_info *info = vtermno_to_xencons(HVC_COOKIE); | |
306 | if (info != NULL && info->irq) | |
307 | rebind_evtchn_irq(info->evtchn, info->irq); | |
308 | } | |
309 | ||
310 | static void xencons_disconnect_backend(struct xencons_info *info) | |
311 | { | |
312 | if (info->irq > 0) | |
313 | unbind_from_irqhandler(info->irq, NULL); | |
314 | info->irq = 0; | |
315 | if (info->evtchn > 0) | |
316 | xenbus_free_evtchn(info->xbdev, info->evtchn); | |
317 | info->evtchn = 0; | |
318 | if (info->gntref > 0) | |
319 | gnttab_free_grant_references(info->gntref); | |
320 | info->gntref = 0; | |
321 | if (info->hvc != NULL) | |
322 | hvc_remove(info->hvc); | |
323 | info->hvc = NULL; | |
324 | } | |
325 | ||
326 | static void xencons_free(struct xencons_info *info) | |
327 | { | |
328 | free_page((unsigned long)info->intf); | |
329 | info->intf = NULL; | |
330 | info->vtermno = 0; | |
331 | kfree(info); | |
332 | } | |
333 | ||
334 | static int xen_console_remove(struct xencons_info *info) | |
335 | { | |
336 | xencons_disconnect_backend(info); | |
337 | spin_lock(&xencons_lock); | |
338 | list_del(&info->list); | |
339 | spin_unlock(&xencons_lock); | |
340 | if (info->xbdev != NULL) | |
341 | xencons_free(info); | |
342 | else { | |
343 | if (xen_hvm_domain()) | |
344 | iounmap(info->intf); | |
345 | kfree(info); | |
4fe7d5a7 | 346 | } |
02e19f9c SS |
347 | return 0; |
348 | } | |
6b9b732d | 349 | |
cf8e019b SS |
350 | #ifdef CONFIG_HVC_XEN_FRONTEND |
351 | static struct xenbus_driver xencons_driver; | |
352 | ||
02e19f9c SS |
353 | static int xencons_remove(struct xenbus_device *dev) |
354 | { | |
355 | return xen_console_remove(dev_get_drvdata(&dev->dev)); | |
356 | } | |
b536b4b9 | 357 | |
02e19f9c SS |
358 | static int xencons_connect_backend(struct xenbus_device *dev, |
359 | struct xencons_info *info) | |
360 | { | |
361 | int ret, evtchn, devid, ref, irq; | |
362 | struct xenbus_transaction xbt; | |
363 | grant_ref_t gref_head; | |
364 | unsigned long mfn; | |
365 | ||
366 | ret = xenbus_alloc_evtchn(dev, &evtchn); | |
367 | if (ret) | |
368 | return ret; | |
369 | info->evtchn = evtchn; | |
370 | irq = bind_evtchn_to_irq(evtchn); | |
371 | if (irq < 0) | |
372 | return irq; | |
373 | info->irq = irq; | |
374 | devid = dev->nodename[strlen(dev->nodename) - 1] - '0'; | |
375 | info->hvc = hvc_alloc(xenbus_devid_to_vtermno(devid), | |
376 | irq, &domU_hvc_ops, 256); | |
377 | if (IS_ERR(info->hvc)) | |
378 | return PTR_ERR(info->hvc); | |
379 | if (xen_pv_domain()) | |
380 | mfn = virt_to_mfn(info->intf); | |
381 | else | |
382 | mfn = __pa(info->intf) >> PAGE_SHIFT; | |
383 | ret = gnttab_alloc_grant_references(1, &gref_head); | |
384 | if (ret < 0) | |
385 | return ret; | |
386 | info->gntref = gref_head; | |
387 | ref = gnttab_claim_grant_reference(&gref_head); | |
388 | if (ref < 0) | |
389 | return ref; | |
390 | gnttab_grant_foreign_access_ref(ref, info->xbdev->otherend_id, | |
391 | mfn, 0); | |
392 | ||
393 | again: | |
394 | ret = xenbus_transaction_start(&xbt); | |
395 | if (ret) { | |
396 | xenbus_dev_fatal(dev, ret, "starting transaction"); | |
397 | return ret; | |
398 | } | |
399 | ret = xenbus_printf(xbt, dev->nodename, "ring-ref", "%d", ref); | |
400 | if (ret) | |
401 | goto error_xenbus; | |
402 | ret = xenbus_printf(xbt, dev->nodename, "port", "%u", | |
403 | evtchn); | |
404 | if (ret) | |
405 | goto error_xenbus; | |
406 | ret = xenbus_printf(xbt, dev->nodename, "type", "ioemu"); | |
407 | if (ret) | |
408 | goto error_xenbus; | |
409 | ret = xenbus_transaction_end(xbt, 0); | |
410 | if (ret) { | |
411 | if (ret == -EAGAIN) | |
412 | goto again; | |
413 | xenbus_dev_fatal(dev, ret, "completing transaction"); | |
414 | return ret; | |
415 | } | |
6b9b732d | 416 | |
02e19f9c | 417 | xenbus_switch_state(dev, XenbusStateInitialised); |
b536b4b9 | 418 | return 0; |
02e19f9c SS |
419 | |
420 | error_xenbus: | |
421 | xenbus_transaction_end(xbt, 1); | |
422 | xenbus_dev_fatal(dev, ret, "writing xenstore"); | |
423 | return ret; | |
b536b4b9 JF |
424 | } |
425 | ||
02e19f9c SS |
426 | static int __devinit xencons_probe(struct xenbus_device *dev, |
427 | const struct xenbus_device_id *id) | |
6b9b732d | 428 | { |
02e19f9c SS |
429 | int ret, devid; |
430 | struct xencons_info *info; | |
431 | ||
432 | devid = dev->nodename[strlen(dev->nodename) - 1] - '0'; | |
433 | if (devid == 0) | |
434 | return -ENODEV; | |
435 | ||
201a52be | 436 | info = kzalloc(sizeof(struct xencons_info), GFP_KERNEL); |
02e19f9c | 437 | if (!info) |
201a52be | 438 | return -ENOMEM; |
02e19f9c SS |
439 | dev_set_drvdata(&dev->dev, info); |
440 | info->xbdev = dev; | |
441 | info->vtermno = xenbus_devid_to_vtermno(devid); | |
442 | info->intf = (void *)__get_free_page(GFP_KERNEL | __GFP_ZERO); | |
443 | if (!info->intf) | |
444 | goto error_nomem; | |
445 | ||
446 | ret = xencons_connect_backend(dev, info); | |
447 | if (ret < 0) | |
448 | goto error; | |
449 | spin_lock(&xencons_lock); | |
450 | list_add_tail(&info->list, &xenconsoles); | |
451 | spin_unlock(&xencons_lock); | |
452 | ||
453 | return 0; | |
454 | ||
455 | error_nomem: | |
456 | ret = -ENOMEM; | |
457 | xenbus_dev_fatal(dev, ret, "allocating device memory"); | |
458 | error: | |
459 | xencons_disconnect_backend(info); | |
460 | xencons_free(info); | |
461 | return ret; | |
462 | } | |
463 | ||
464 | static int xencons_resume(struct xenbus_device *dev) | |
465 | { | |
466 | struct xencons_info *info = dev_get_drvdata(&dev->dev); | |
467 | ||
468 | xencons_disconnect_backend(info); | |
469 | memset(info->intf, 0, PAGE_SIZE); | |
470 | return xencons_connect_backend(dev, info); | |
6b9b732d JF |
471 | } |
472 | ||
02e19f9c SS |
473 | static void xencons_backend_changed(struct xenbus_device *dev, |
474 | enum xenbus_state backend_state) | |
475 | { | |
476 | switch (backend_state) { | |
477 | case XenbusStateReconfiguring: | |
478 | case XenbusStateReconfigured: | |
479 | case XenbusStateInitialising: | |
480 | case XenbusStateInitialised: | |
481 | case XenbusStateUnknown: | |
482 | case XenbusStateClosed: | |
483 | break; | |
484 | ||
485 | case XenbusStateInitWait: | |
486 | break; | |
487 | ||
488 | case XenbusStateConnected: | |
489 | xenbus_switch_state(dev, XenbusStateConnected); | |
490 | break; | |
491 | ||
492 | case XenbusStateClosing: | |
493 | xenbus_frontend_closed(dev); | |
494 | break; | |
495 | } | |
496 | } | |
497 | ||
498 | static const struct xenbus_device_id xencons_ids[] = { | |
499 | { "console" }, | |
500 | { "" } | |
501 | }; | |
502 | ||
503 | ||
cf8e019b SS |
504 | static DEFINE_XENBUS_DRIVER(xencons, "xenconsole", |
505 | .probe = xencons_probe, | |
506 | .remove = xencons_remove, | |
507 | .resume = xencons_resume, | |
508 | .otherend_changed = xencons_backend_changed, | |
509 | ); | |
510 | #endif /* CONFIG_HVC_XEN_FRONTEND */ | |
511 | ||
512 | static int __init xen_hvc_init(void) | |
513 | { | |
514 | int r; | |
515 | struct xencons_info *info; | |
516 | const struct hv_ops *ops; | |
517 | ||
518 | if (!xen_domain()) | |
519 | return -ENODEV; | |
520 | ||
521 | if (xen_initial_domain()) { | |
522 | ops = &dom0_hvc_ops; | |
523 | r = xen_initial_domain_console_init(); | |
524 | if (r < 0) | |
525 | return r; | |
526 | info = vtermno_to_xencons(HVC_COOKIE); | |
527 | } else { | |
528 | ops = &domU_hvc_ops; | |
529 | if (xen_hvm_domain()) | |
530 | r = xen_hvm_console_init(); | |
531 | else | |
532 | r = xen_pv_console_init(); | |
533 | if (r < 0) | |
534 | return r; | |
535 | ||
536 | info = vtermno_to_xencons(HVC_COOKIE); | |
537 | info->irq = bind_evtchn_to_irq(info->evtchn); | |
538 | } | |
539 | if (info->irq < 0) | |
540 | info->irq = 0; /* NO_IRQ */ | |
541 | else | |
542 | irq_set_noprobe(info->irq); | |
543 | ||
544 | info->hvc = hvc_alloc(HVC_COOKIE, info->irq, ops, 256); | |
545 | if (IS_ERR(info->hvc)) { | |
546 | r = PTR_ERR(info->hvc); | |
547 | spin_lock(&xencons_lock); | |
548 | list_del(&info->list); | |
549 | spin_unlock(&xencons_lock); | |
550 | if (info->irq) | |
551 | unbind_from_irqhandler(info->irq, NULL); | |
552 | kfree(info); | |
553 | return r; | |
554 | } | |
555 | ||
556 | r = 0; | |
557 | #ifdef CONFIG_HVC_XEN_FRONTEND | |
558 | r = xenbus_register_frontend(&xencons_driver); | |
559 | #endif | |
560 | return r; | |
561 | } | |
562 | ||
4fe7d5a7 | 563 | static void __exit xen_hvc_fini(void) |
b536b4b9 | 564 | { |
02e19f9c SS |
565 | struct xencons_info *entry, *next; |
566 | ||
567 | if (list_empty(&xenconsoles)) | |
568 | return; | |
569 | ||
570 | list_for_each_entry_safe(entry, next, &xenconsoles, list) { | |
571 | xen_console_remove(entry); | |
572 | } | |
b536b4b9 JF |
573 | } |
574 | ||
575 | static int xen_cons_init(void) | |
576 | { | |
eb5ef071 | 577 | const struct hv_ops *ops; |
4fe7d5a7 | 578 | |
eb5ef071 | 579 | if (!xen_domain()) |
b536b4b9 JF |
580 | return 0; |
581 | ||
4fe7d5a7 JF |
582 | if (xen_initial_domain()) |
583 | ops = &dom0_hvc_ops; | |
eb5ef071 | 584 | else { |
02e19f9c | 585 | int r; |
4fe7d5a7 JF |
586 | ops = &domU_hvc_ops; |
587 | ||
02e19f9c SS |
588 | if (xen_hvm_domain()) |
589 | r = xen_hvm_console_init(); | |
eb5ef071 | 590 | else |
02e19f9c SS |
591 | r = xen_pv_console_init(); |
592 | if (r < 0) | |
593 | return r; | |
eb5ef071 SS |
594 | } |
595 | ||
4fe7d5a7 | 596 | hvc_instantiate(HVC_COOKIE, 0, ops); |
b536b4b9 JF |
597 | return 0; |
598 | } | |
599 | ||
02e19f9c | 600 | |
4fe7d5a7 JF |
601 | module_init(xen_hvc_init); |
602 | module_exit(xen_hvc_fini); | |
b536b4b9 JF |
603 | console_initcall(xen_cons_init); |
604 | ||
0922abdc | 605 | #ifdef CONFIG_EARLY_PRINTK |
b536b4b9 JF |
606 | static void xenboot_write_console(struct console *console, const char *string, |
607 | unsigned len) | |
608 | { | |
609 | unsigned int linelen, off = 0; | |
610 | const char *pos; | |
611 | ||
eb5ef071 SS |
612 | if (!xen_pv_domain()) |
613 | return; | |
614 | ||
4fe7d5a7 JF |
615 | dom0_write_console(0, string, len); |
616 | ||
617 | if (xen_initial_domain()) | |
618 | return; | |
0922abdc | 619 | |
4fe7d5a7 | 620 | domU_write_console(0, "(early) ", 8); |
b536b4b9 JF |
621 | while (off < len && NULL != (pos = strchr(string+off, '\n'))) { |
622 | linelen = pos-string+off; | |
623 | if (off + linelen > len) | |
624 | break; | |
4fe7d5a7 JF |
625 | domU_write_console(0, string+off, linelen); |
626 | domU_write_console(0, "\r\n", 2); | |
b536b4b9 JF |
627 | off += linelen + 1; |
628 | } | |
629 | if (off < len) | |
4fe7d5a7 | 630 | domU_write_console(0, string+off, len-off); |
b536b4b9 JF |
631 | } |
632 | ||
633 | struct console xenboot_console = { | |
634 | .name = "xenboot", | |
635 | .write = xenboot_write_console, | |
0922abdc | 636 | .flags = CON_PRINTBUFFER | CON_BOOT | CON_ANYTIME, |
b536b4b9 | 637 | }; |
0922abdc | 638 | #endif /* CONFIG_EARLY_PRINTK */ |
0acf10d8 JF |
639 | |
640 | void xen_raw_console_write(const char *str) | |
641 | { | |
4fe7d5a7 | 642 | dom0_write_console(0, str, strlen(str)); |
0acf10d8 JF |
643 | } |
644 | ||
645 | void xen_raw_printk(const char *fmt, ...) | |
646 | { | |
647 | static char buf[512]; | |
648 | va_list ap; | |
649 | ||
650 | va_start(ap, fmt); | |
651 | vsnprintf(buf, sizeof(buf), fmt, ap); | |
652 | va_end(ap); | |
653 | ||
654 | xen_raw_console_write(buf); | |
655 | } |