GNU Linux-libre 6.7.9-gnu
[releases.git] / drivers / tty / hvc / hvc_xen.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * xen console driver interface to hvc_console.c
4  *
5  * (c) 2007 Gerd Hoffmann <kraxel@suse.de>
6  */
7
8 #include <linux/console.h>
9 #include <linux/delay.h>
10 #include <linux/err.h>
11 #include <linux/irq.h>
12 #include <linux/init.h>
13 #include <linux/types.h>
14 #include <linux/list.h>
15 #include <linux/serial_core.h>
16
17 #include <asm/io.h>
18 #include <asm/xen/hypervisor.h>
19
20 #include <xen/xen.h>
21 #include <xen/interface/xen.h>
22 #include <xen/hvm.h>
23 #include <xen/grant_table.h>
24 #include <xen/page.h>
25 #include <xen/events.h>
26 #include <xen/interface/io/console.h>
27 #include <xen/interface/sched.h>
28 #include <xen/hvc-console.h>
29 #include <xen/xenbus.h>
30
31 #include "hvc_console.h"
32
33 #define HVC_COOKIE   0x58656e /* "Xen" in hex */
34
35 struct xencons_info {
36         struct list_head list;
37         struct xenbus_device *xbdev;
38         struct xencons_interface *intf;
39         unsigned int evtchn;
40         XENCONS_RING_IDX out_cons;
41         unsigned int out_cons_same;
42         struct hvc_struct *hvc;
43         int irq;
44         int vtermno;
45         grant_ref_t gntref;
46         spinlock_t ring_lock;
47 };
48
49 static LIST_HEAD(xenconsoles);
50 static DEFINE_SPINLOCK(xencons_lock);
51
52 /* ------------------------------------------------------------------ */
53
54 static struct xencons_info *vtermno_to_xencons(int vtermno)
55 {
56         struct xencons_info *entry, *ret = NULL;
57         unsigned long flags;
58
59         spin_lock_irqsave(&xencons_lock, flags);
60         if (list_empty(&xenconsoles)) {
61                 spin_unlock_irqrestore(&xencons_lock, flags);
62                 return NULL;
63         }
64
65         list_for_each_entry(entry, &xenconsoles, list) {
66                 if (entry->vtermno == vtermno) {
67                         ret  = entry;
68                         break;
69                 }
70         }
71         spin_unlock_irqrestore(&xencons_lock, flags);
72
73         return ret;
74 }
75
76 static inline int xenbus_devid_to_vtermno(int devid)
77 {
78         return devid + HVC_COOKIE;
79 }
80
81 static inline void notify_daemon(struct xencons_info *cons)
82 {
83         /* Use evtchn: this is called early, before irq is set up. */
84         notify_remote_via_evtchn(cons->evtchn);
85 }
86
87 static int __write_console(struct xencons_info *xencons,
88                 const char *data, int len)
89 {
90         XENCONS_RING_IDX cons, prod;
91         struct xencons_interface *intf = xencons->intf;
92         int sent = 0;
93         unsigned long flags;
94
95         spin_lock_irqsave(&xencons->ring_lock, flags);
96         cons = intf->out_cons;
97         prod = intf->out_prod;
98         mb();                   /* update queue values before going on */
99
100         if ((prod - cons) > sizeof(intf->out)) {
101                 spin_unlock_irqrestore(&xencons->ring_lock, flags);
102                 pr_err_once("xencons: Illegal ring page indices");
103                 return -EINVAL;
104         }
105
106         while ((sent < len) && ((prod - cons) < sizeof(intf->out)))
107                 intf->out[MASK_XENCONS_IDX(prod++, intf->out)] = data[sent++];
108
109         wmb();                  /* write ring before updating pointer */
110         intf->out_prod = prod;
111         spin_unlock_irqrestore(&xencons->ring_lock, flags);
112
113         if (sent)
114                 notify_daemon(xencons);
115         return sent;
116 }
117
118 static int domU_write_console(uint32_t vtermno, const char *data, int len)
119 {
120         int ret = len;
121         struct xencons_info *cons = vtermno_to_xencons(vtermno);
122         if (cons == NULL)
123                 return -EINVAL;
124
125         /*
126          * Make sure the whole buffer is emitted, polling if
127          * necessary.  We don't ever want to rely on the hvc daemon
128          * because the most interesting console output is when the
129          * kernel is crippled.
130          */
131         while (len) {
132                 int sent = __write_console(cons, data, len);
133
134                 if (sent < 0)
135                         return sent;
136
137                 data += sent;
138                 len -= sent;
139
140                 if (unlikely(len))
141                         HYPERVISOR_sched_op(SCHEDOP_yield, NULL);
142         }
143
144         return ret;
145 }
146
147 static int domU_read_console(uint32_t vtermno, char *buf, int len)
148 {
149         struct xencons_interface *intf;
150         XENCONS_RING_IDX cons, prod;
151         int recv = 0;
152         struct xencons_info *xencons = vtermno_to_xencons(vtermno);
153         unsigned int eoiflag = 0;
154         unsigned long flags;
155
156         if (xencons == NULL)
157                 return -EINVAL;
158         intf = xencons->intf;
159
160         spin_lock_irqsave(&xencons->ring_lock, flags);
161         cons = intf->in_cons;
162         prod = intf->in_prod;
163         mb();                   /* get pointers before reading ring */
164
165         if ((prod - cons) > sizeof(intf->in)) {
166                 spin_unlock_irqrestore(&xencons->ring_lock, flags);
167                 pr_err_once("xencons: Illegal ring page indices");
168                 return -EINVAL;
169         }
170
171         while (cons != prod && recv < len)
172                 buf[recv++] = intf->in[MASK_XENCONS_IDX(cons++, intf->in)];
173
174         mb();                   /* read ring before consuming */
175         intf->in_cons = cons;
176
177         /*
178          * When to mark interrupt having been spurious:
179          * - there was no new data to be read, and
180          * - the backend did not consume some output bytes, and
181          * - the previous round with no read data didn't see consumed bytes
182          *   (we might have a race with an interrupt being in flight while
183          *   updating xencons->out_cons, so account for that by allowing one
184          *   round without any visible reason)
185          */
186         if (intf->out_cons != xencons->out_cons) {
187                 xencons->out_cons = intf->out_cons;
188                 xencons->out_cons_same = 0;
189         }
190         if (!recv && xencons->out_cons_same++ > 1) {
191                 eoiflag = XEN_EOI_FLAG_SPURIOUS;
192         }
193         spin_unlock_irqrestore(&xencons->ring_lock, flags);
194
195         if (recv) {
196                 notify_daemon(xencons);
197         }
198
199         xen_irq_lateeoi(xencons->irq, eoiflag);
200
201         return recv;
202 }
203
204 static const struct hv_ops domU_hvc_ops = {
205         .get_chars = domU_read_console,
206         .put_chars = domU_write_console,
207         .notifier_add = notifier_add_irq,
208         .notifier_del = notifier_del_irq,
209         .notifier_hangup = notifier_hangup_irq,
210 };
211
212 static int dom0_read_console(uint32_t vtermno, char *buf, int len)
213 {
214         return HYPERVISOR_console_io(CONSOLEIO_read, len, buf);
215 }
216
217 /*
218  * Either for a dom0 to write to the system console, or a domU with a
219  * debug version of Xen
220  */
221 static int dom0_write_console(uint32_t vtermno, const char *str, int len)
222 {
223         int rc = HYPERVISOR_console_io(CONSOLEIO_write, len, (char *)str);
224         if (rc < 0)
225                 return rc;
226
227         return len;
228 }
229
230 static const struct hv_ops dom0_hvc_ops = {
231         .get_chars = dom0_read_console,
232         .put_chars = dom0_write_console,
233         .notifier_add = notifier_add_irq,
234         .notifier_del = notifier_del_irq,
235         .notifier_hangup = notifier_hangup_irq,
236 };
237
238 static int xen_hvm_console_init(void)
239 {
240         int r;
241         uint64_t v = 0;
242         unsigned long gfn, flags;
243         struct xencons_info *info;
244
245         if (!xen_hvm_domain())
246                 return -ENODEV;
247
248         info = vtermno_to_xencons(HVC_COOKIE);
249         if (!info) {
250                 info = kzalloc(sizeof(struct xencons_info), GFP_KERNEL);
251                 if (!info)
252                         return -ENOMEM;
253                 spin_lock_init(&info->ring_lock);
254         } else if (info->intf != NULL) {
255                 /* already configured */
256                 return 0;
257         }
258         /*
259          * If the toolstack (or the hypervisor) hasn't set these values, the
260          * default value is 0. Even though gfn = 0 and evtchn = 0 are
261          * theoretically correct values, in practice they never are and they
262          * mean that a legacy toolstack hasn't initialized the pv console correctly.
263          */
264         r = hvm_get_parameter(HVM_PARAM_CONSOLE_EVTCHN, &v);
265         if (r < 0 || v == 0)
266                 goto err;
267         info->evtchn = v;
268         v = 0;
269         r = hvm_get_parameter(HVM_PARAM_CONSOLE_PFN, &v);
270         if (r < 0 || v == 0)
271                 goto err;
272         gfn = v;
273         info->intf = memremap(gfn << XEN_PAGE_SHIFT, XEN_PAGE_SIZE, MEMREMAP_WB);
274         if (info->intf == NULL)
275                 goto err;
276         info->vtermno = HVC_COOKIE;
277
278         spin_lock_irqsave(&xencons_lock, flags);
279         list_add_tail(&info->list, &xenconsoles);
280         spin_unlock_irqrestore(&xencons_lock, flags);
281
282         return 0;
283 err:
284         kfree(info);
285         return -ENODEV;
286 }
287
288 static int xencons_info_pv_init(struct xencons_info *info, int vtermno)
289 {
290         spin_lock_init(&info->ring_lock);
291         info->evtchn = xen_start_info->console.domU.evtchn;
292         /* GFN == MFN for PV guest */
293         info->intf = gfn_to_virt(xen_start_info->console.domU.mfn);
294         info->vtermno = vtermno;
295
296         list_add_tail(&info->list, &xenconsoles);
297
298         return 0;
299 }
300
301 static int xen_pv_console_init(void)
302 {
303         struct xencons_info *info;
304         unsigned long flags;
305
306         if (!xen_pv_domain())
307                 return -ENODEV;
308
309         if (!xen_start_info->console.domU.evtchn)
310                 return -ENODEV;
311
312         info = vtermno_to_xencons(HVC_COOKIE);
313         if (!info) {
314                 info = kzalloc(sizeof(struct xencons_info), GFP_KERNEL);
315                 if (!info)
316                         return -ENOMEM;
317         } else if (info->intf != NULL) {
318                 /* already configured */
319                 return 0;
320         }
321         spin_lock_irqsave(&xencons_lock, flags);
322         xencons_info_pv_init(info, HVC_COOKIE);
323         spin_unlock_irqrestore(&xencons_lock, flags);
324
325         return 0;
326 }
327
328 static int xen_initial_domain_console_init(void)
329 {
330         struct xencons_info *info;
331         unsigned long flags;
332
333         if (!xen_initial_domain())
334                 return -ENODEV;
335
336         info = vtermno_to_xencons(HVC_COOKIE);
337         if (!info) {
338                 info = kzalloc(sizeof(struct xencons_info), GFP_KERNEL);
339                 if (!info)
340                         return -ENOMEM;
341                 spin_lock_init(&info->ring_lock);
342         }
343
344         info->irq = bind_virq_to_irq(VIRQ_CONSOLE, 0, false);
345         info->vtermno = HVC_COOKIE;
346
347         spin_lock_irqsave(&xencons_lock, flags);
348         list_add_tail(&info->list, &xenconsoles);
349         spin_unlock_irqrestore(&xencons_lock, flags);
350
351         return 0;
352 }
353
354 static void xen_console_update_evtchn(struct xencons_info *info)
355 {
356         if (xen_hvm_domain()) {
357                 uint64_t v = 0;
358                 int err;
359
360                 err = hvm_get_parameter(HVM_PARAM_CONSOLE_EVTCHN, &v);
361                 if (!err && v)
362                         info->evtchn = v;
363         } else
364                 info->evtchn = xen_start_info->console.domU.evtchn;
365 }
366
367 void xen_console_resume(void)
368 {
369         struct xencons_info *info = vtermno_to_xencons(HVC_COOKIE);
370         if (info != NULL && info->irq) {
371                 if (!xen_initial_domain())
372                         xen_console_update_evtchn(info);
373                 rebind_evtchn_irq(info->evtchn, info->irq);
374         }
375 }
376
377 #ifdef CONFIG_HVC_XEN_FRONTEND
378 static void xencons_disconnect_backend(struct xencons_info *info)
379 {
380         if (info->hvc != NULL)
381                 hvc_remove(info->hvc);
382         info->hvc = NULL;
383         if (info->irq > 0) {
384                 evtchn_put(info->evtchn);
385                 info->irq = 0;
386                 info->evtchn = 0;
387         }
388         /* evtchn_put() will also close it so this is only an error path */
389         if (info->evtchn > 0)
390                 xenbus_free_evtchn(info->xbdev, info->evtchn);
391         info->evtchn = 0;
392         if (info->gntref > 0)
393                 gnttab_free_grant_references(info->gntref);
394         info->gntref = 0;
395 }
396
397 static void xencons_free(struct xencons_info *info)
398 {
399         free_page((unsigned long)info->intf);
400         info->intf = NULL;
401         info->vtermno = 0;
402         kfree(info);
403 }
404
405 static int xen_console_remove(struct xencons_info *info)
406 {
407         unsigned long flags;
408
409         xencons_disconnect_backend(info);
410         spin_lock_irqsave(&xencons_lock, flags);
411         list_del(&info->list);
412         spin_unlock_irqrestore(&xencons_lock, flags);
413         if (info->xbdev != NULL)
414                 xencons_free(info);
415         else {
416                 if (xen_hvm_domain())
417                         iounmap(info->intf);
418                 kfree(info);
419         }
420         return 0;
421 }
422
423 static void xencons_remove(struct xenbus_device *dev)
424 {
425         xen_console_remove(dev_get_drvdata(&dev->dev));
426 }
427
428 static int xencons_connect_backend(struct xenbus_device *dev,
429                                   struct xencons_info *info)
430 {
431         int ret, evtchn, devid, ref, irq;
432         struct xenbus_transaction xbt;
433         grant_ref_t gref_head;
434
435         ret = xenbus_alloc_evtchn(dev, &evtchn);
436         if (ret)
437                 return ret;
438         info->evtchn = evtchn;
439         irq = bind_evtchn_to_irq_lateeoi(evtchn);
440         if (irq < 0)
441                 return irq;
442         info->irq = irq;
443         devid = dev->nodename[strlen(dev->nodename) - 1] - '0';
444         info->hvc = hvc_alloc(xenbus_devid_to_vtermno(devid),
445                         irq, &domU_hvc_ops, 256);
446         if (IS_ERR(info->hvc))
447                 return PTR_ERR(info->hvc);
448         ret = gnttab_alloc_grant_references(1, &gref_head);
449         if (ret < 0)
450                 return ret;
451         info->gntref = gref_head;
452         ref = gnttab_claim_grant_reference(&gref_head);
453         if (ref < 0)
454                 return ref;
455         gnttab_grant_foreign_access_ref(ref, info->xbdev->otherend_id,
456                                         virt_to_gfn(info->intf), 0);
457
458  again:
459         ret = xenbus_transaction_start(&xbt);
460         if (ret) {
461                 xenbus_dev_fatal(dev, ret, "starting transaction");
462                 return ret;
463         }
464         ret = xenbus_printf(xbt, dev->nodename, "ring-ref", "%d", ref);
465         if (ret)
466                 goto error_xenbus;
467         ret = xenbus_printf(xbt, dev->nodename, "port", "%u",
468                             evtchn);
469         if (ret)
470                 goto error_xenbus;
471         ret = xenbus_transaction_end(xbt, 0);
472         if (ret) {
473                 if (ret == -EAGAIN)
474                         goto again;
475                 xenbus_dev_fatal(dev, ret, "completing transaction");
476                 return ret;
477         }
478
479         xenbus_switch_state(dev, XenbusStateInitialised);
480         return 0;
481
482  error_xenbus:
483         xenbus_transaction_end(xbt, 1);
484         xenbus_dev_fatal(dev, ret, "writing xenstore");
485         return ret;
486 }
487
488 static int xencons_probe(struct xenbus_device *dev,
489                                   const struct xenbus_device_id *id)
490 {
491         int ret, devid;
492         struct xencons_info *info;
493         unsigned long flags;
494
495         devid = dev->nodename[strlen(dev->nodename) - 1] - '0';
496         if (devid == 0)
497                 return -ENODEV;
498
499         info = kzalloc(sizeof(struct xencons_info), GFP_KERNEL);
500         if (!info)
501                 return -ENOMEM;
502         spin_lock_init(&info->ring_lock);
503         dev_set_drvdata(&dev->dev, info);
504         info->xbdev = dev;
505         info->vtermno = xenbus_devid_to_vtermno(devid);
506         info->intf = (void *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
507         if (!info->intf)
508                 goto error_nomem;
509
510         ret = xencons_connect_backend(dev, info);
511         if (ret < 0)
512                 goto error;
513         spin_lock_irqsave(&xencons_lock, flags);
514         list_add_tail(&info->list, &xenconsoles);
515         spin_unlock_irqrestore(&xencons_lock, flags);
516
517         return 0;
518
519  error_nomem:
520         ret = -ENOMEM;
521         xenbus_dev_fatal(dev, ret, "allocating device memory");
522  error:
523         xencons_disconnect_backend(info);
524         xencons_free(info);
525         return ret;
526 }
527
528 static int xencons_resume(struct xenbus_device *dev)
529 {
530         struct xencons_info *info = dev_get_drvdata(&dev->dev);
531
532         xencons_disconnect_backend(info);
533         memset(info->intf, 0, XEN_PAGE_SIZE);
534         return xencons_connect_backend(dev, info);
535 }
536
537 static void xencons_backend_changed(struct xenbus_device *dev,
538                                    enum xenbus_state backend_state)
539 {
540         switch (backend_state) {
541         case XenbusStateReconfiguring:
542         case XenbusStateReconfigured:
543         case XenbusStateInitialising:
544         case XenbusStateInitialised:
545         case XenbusStateUnknown:
546                 break;
547
548         case XenbusStateInitWait:
549                 break;
550
551         case XenbusStateConnected:
552                 xenbus_switch_state(dev, XenbusStateConnected);
553                 break;
554
555         case XenbusStateClosed:
556                 if (dev->state == XenbusStateClosed)
557                         break;
558                 fallthrough;    /* Missed the backend's CLOSING state */
559         case XenbusStateClosing: {
560                 struct xencons_info *info = dev_get_drvdata(&dev->dev);;
561
562                 /*
563                  * Don't tear down the evtchn and grant ref before the other
564                  * end has disconnected, but do stop userspace from trying
565                  * to use the device before we allow the backend to close.
566                  */
567                 if (info->hvc) {
568                         hvc_remove(info->hvc);
569                         info->hvc = NULL;
570                 }
571
572                 xenbus_frontend_closed(dev);
573                 break;
574         }
575         }
576 }
577
578 static const struct xenbus_device_id xencons_ids[] = {
579         { "console" },
580         { "" }
581 };
582
583 static struct xenbus_driver xencons_driver = {
584         .name = "xenconsole",
585         .ids = xencons_ids,
586         .probe = xencons_probe,
587         .remove = xencons_remove,
588         .resume = xencons_resume,
589         .otherend_changed = xencons_backend_changed,
590         .not_essential = true,
591 };
592 #endif /* CONFIG_HVC_XEN_FRONTEND */
593
594 static int __init xen_hvc_init(void)
595 {
596         int r;
597         struct xencons_info *info;
598         const struct hv_ops *ops;
599
600         if (!xen_domain())
601                 return -ENODEV;
602
603         if (xen_initial_domain()) {
604                 ops = &dom0_hvc_ops;
605                 r = xen_initial_domain_console_init();
606                 if (r < 0)
607                         goto register_fe;
608                 info = vtermno_to_xencons(HVC_COOKIE);
609         } else {
610                 ops = &domU_hvc_ops;
611                 if (xen_hvm_domain())
612                         r = xen_hvm_console_init();
613                 else
614                         r = xen_pv_console_init();
615                 if (r < 0)
616                         goto register_fe;
617
618                 info = vtermno_to_xencons(HVC_COOKIE);
619                 info->irq = bind_evtchn_to_irq_lateeoi(info->evtchn);
620         }
621         if (info->irq < 0)
622                 info->irq = 0; /* NO_IRQ */
623         else
624                 irq_set_noprobe(info->irq);
625
626         info->hvc = hvc_alloc(HVC_COOKIE, info->irq, ops, 256);
627         if (IS_ERR(info->hvc)) {
628                 unsigned long flags;
629
630                 r = PTR_ERR(info->hvc);
631                 spin_lock_irqsave(&xencons_lock, flags);
632                 list_del(&info->list);
633                 spin_unlock_irqrestore(&xencons_lock, flags);
634                 if (info->irq)
635                         evtchn_put(info->evtchn);
636                 kfree(info);
637                 return r;
638         }
639
640         r = 0;
641  register_fe:
642 #ifdef CONFIG_HVC_XEN_FRONTEND
643         r = xenbus_register_frontend(&xencons_driver);
644 #endif
645         return r;
646 }
647 device_initcall(xen_hvc_init);
648
649 static int xen_cons_init(void)
650 {
651         const struct hv_ops *ops;
652
653         if (!xen_domain())
654                 return 0;
655
656         if (xen_initial_domain())
657                 ops = &dom0_hvc_ops;
658         else {
659                 int r;
660                 ops = &domU_hvc_ops;
661
662                 if (xen_hvm_domain())
663                         r = xen_hvm_console_init();
664                 else
665                         r = xen_pv_console_init();
666                 if (r < 0)
667                         return r;
668         }
669
670         hvc_instantiate(HVC_COOKIE, 0, ops);
671         return 0;
672 }
673 console_initcall(xen_cons_init);
674
675 #ifdef CONFIG_X86
676 static void xen_hvm_early_write(uint32_t vtermno, const char *str, int len)
677 {
678         if (xen_cpuid_base())
679                 outsb(0xe9, str, len);
680 }
681 #else
682 static void xen_hvm_early_write(uint32_t vtermno, const char *str, int len) { }
683 #endif
684
685 #ifdef CONFIG_EARLY_PRINTK
686 static int __init xenboot_console_setup(struct console *console, char *string)
687 {
688         static struct xencons_info xenboot;
689
690         if (xen_initial_domain() || !xen_pv_domain())
691                 return 0;
692
693         return xencons_info_pv_init(&xenboot, 0);
694 }
695
696 static void xenboot_write_console(struct console *console, const char *string,
697                                   unsigned len)
698 {
699         unsigned int linelen, off = 0;
700         const char *pos;
701
702         if (dom0_write_console(0, string, len) >= 0)
703                 return;
704
705         if (!xen_pv_domain()) {
706                 xen_hvm_early_write(0, string, len);
707                 return;
708         }
709
710         if (domU_write_console(0, "(early) ", 8) < 0)
711                 return;
712         while (off < len && NULL != (pos = strchr(string+off, '\n'))) {
713                 linelen = pos-string+off;
714                 if (off + linelen > len)
715                         break;
716                 domU_write_console(0, string+off, linelen);
717                 domU_write_console(0, "\r\n", 2);
718                 off += linelen + 1;
719         }
720         if (off < len)
721                 domU_write_console(0, string+off, len-off);
722 }
723
724 struct console xenboot_console = {
725         .name           = "xenboot",
726         .write          = xenboot_write_console,
727         .setup          = xenboot_console_setup,
728         .flags          = CON_PRINTBUFFER | CON_BOOT | CON_ANYTIME,
729         .index          = -1,
730 };
731 #endif  /* CONFIG_EARLY_PRINTK */
732
733 void xen_raw_console_write(const char *str)
734 {
735         ssize_t len = strlen(str);
736         int rc = 0;
737
738         if (xen_domain()) {
739                 rc = dom0_write_console(0, str, len);
740                 if (rc != -ENOSYS || !xen_hvm_domain())
741                         return;
742         }
743         xen_hvm_early_write(0, str, len);
744 }
745
746 void xen_raw_printk(const char *fmt, ...)
747 {
748         static char buf[512];
749         va_list ap;
750
751         va_start(ap, fmt);
752         vsnprintf(buf, sizeof(buf), fmt, ap);
753         va_end(ap);
754
755         xen_raw_console_write(buf);
756 }
757
758 static void xenboot_earlycon_write(struct console *console,
759                                   const char *string,
760                                   unsigned len)
761 {
762         dom0_write_console(0, string, len);
763 }
764
765 static int __init xenboot_earlycon_setup(struct earlycon_device *device,
766                                             const char *opt)
767 {
768         device->con->write = xenboot_earlycon_write;
769         return 0;
770 }
771 EARLYCON_DECLARE(xenboot, xenboot_earlycon_setup);