]> git.proxmox.com Git - mirror_qemu.git/blob - ui/console.c
projects / mirror_qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'pull-target-arm-20230717' of https://git.linaro.org/people/pmaydell/qemu...
[mirror_qemu.git] / ui / console.c
1 /*
2 * QEMU graphical console
3 *
4 * Copyright (c) 2004 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 #include "qemu/osdep.h"
26 #include "ui/console.h"
27 #include "hw/qdev-core.h"
28 #include "qapi/error.h"
29 #include "qapi/qapi-commands-ui.h"
30 #include "qemu/coroutine.h"
31 #include "qemu/error-report.h"
32 #include "qemu/fifo8.h"
33 #include "qemu/main-loop.h"
34 #include "qemu/module.h"
35 #include "qemu/option.h"
36 #include "qemu/timer.h"
37 #include "chardev/char.h"
38 #include "trace.h"
39 #include "exec/memory.h"
40 #include "io/channel-file.h"
41 #include "qom/object.h"
42 #ifdef CONFIG_PNG
43 #include <png.h>
44 #endif
45
46 #define DEFAULT_BACKSCROLL 512
47 #define CONSOLE_CURSOR_PERIOD 500
48
49 typedef struct TextAttributes {
50 uint8_t fgcol:4;
51 uint8_t bgcol:4;
52 uint8_t bold:1;
53 uint8_t uline:1;
54 uint8_t blink:1;
55 uint8_t invers:1;
56 uint8_t unvisible:1;
57 } TextAttributes;
58
59 typedef struct TextCell {
60 uint8_t ch;
61 TextAttributes t_attrib;
62 } TextCell;
63
64 #define MAX_ESC_PARAMS 3
65
66 enum TTYState {
67 TTY_STATE_NORM,
68 TTY_STATE_ESC,
69 TTY_STATE_CSI,
70 };
71
72 typedef enum {
73 GRAPHIC_CONSOLE,
74 TEXT_CONSOLE,
75 TEXT_CONSOLE_FIXED_SIZE
76 } console_type_t;
77
78 struct QemuConsole {
79 Object parent;
80
81 int index;
82 console_type_t console_type;
83 DisplayState *ds;
84 DisplaySurface *surface;
85 DisplayScanout scanout;
86 int dcls;
87 DisplayGLCtx *gl;
88 int gl_block;
89 QEMUTimer *gl_unblock_timer;
90 int window_id;
91
92 /* Graphic console state. */
93 Object *device;
94 uint32_t head;
95 QemuUIInfo ui_info;
96 QEMUTimer *ui_timer;
97 QEMUCursor *cursor;
98 int cursor_x, cursor_y, cursor_on;
99 const GraphicHwOps *hw_ops;
100 void *hw;
101
102 /* Text console state */
103 int width;
104 int height;
105 int total_height;
106 int backscroll_height;
107 int x, y;
108 int x_saved, y_saved;
109 int y_displayed;
110 int y_base;
111 TextAttributes t_attrib_default; /* default text attributes */
112 TextAttributes t_attrib; /* currently active text attributes */
113 TextCell *cells;
114 int text_x[2], text_y[2], cursor_invalidate;
115 int echo;
116
117 int update_x0;
118 int update_y0;
119 int update_x1;
120 int update_y1;
121
122 enum TTYState state;
123 int esc_params[MAX_ESC_PARAMS];
124 int nb_esc_params;
125
126 Chardev *chr;
127 /* fifo for key pressed */
128 Fifo8 out_fifo;
129 CoQueue dump_queue;
130
131 QTAILQ_ENTRY(QemuConsole) next;
132 };
133
134 struct DisplayState {
135 QEMUTimer *gui_timer;
136 uint64_t last_update;
137 uint64_t update_interval;
138 bool refreshing;
139 bool have_gfx;
140 bool have_text;
141
142 QLIST_HEAD(, DisplayChangeListener) listeners;
143 };
144
145 static DisplayState *display_state;
146 static QemuConsole *active_console;
147 static QTAILQ_HEAD(, QemuConsole) consoles =
148 QTAILQ_HEAD_INITIALIZER(consoles);
149 static bool cursor_visible_phase;
150 static QEMUTimer *cursor_timer;
151
152 static void text_console_do_init(Chardev *chr, DisplayState *ds);
153 static void dpy_refresh(DisplayState *s);
154 static DisplayState *get_alloc_displaystate(void);
155 static void text_console_update_cursor_timer(void);
156 static void text_console_update_cursor(void *opaque);
157 static bool displaychangelistener_has_dmabuf(DisplayChangeListener *dcl);
158 static bool console_compatible_with(QemuConsole *con,
159 DisplayChangeListener *dcl, Error **errp);
160
161 static void gui_update(void *opaque)
162 {
163 uint64_t interval = GUI_REFRESH_INTERVAL_IDLE;
164 uint64_t dcl_interval;
165 DisplayState *ds = opaque;
166 DisplayChangeListener *dcl;
167
168 ds->refreshing = true;
169 dpy_refresh(ds);
170 ds->refreshing = false;
171
172 QLIST_FOREACH(dcl, &ds->listeners, next) {
173 dcl_interval = dcl->update_interval ?
174 dcl->update_interval : GUI_REFRESH_INTERVAL_DEFAULT;
175 if (interval > dcl_interval) {
176 interval = dcl_interval;
177 }
178 }
179 if (ds->update_interval != interval) {
180 ds->update_interval = interval;
181 trace_console_refresh(interval);
182 }
183 ds->last_update = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
184 timer_mod(ds->gui_timer, ds->last_update + interval);
185 }
186
187 static void gui_setup_refresh(DisplayState *ds)
188 {
189 DisplayChangeListener *dcl;
190 bool need_timer = false;
191 bool have_gfx = false;
192 bool have_text = false;
193
194 QLIST_FOREACH(dcl, &ds->listeners, next) {
195 if (dcl->ops->dpy_refresh != NULL) {
196 need_timer = true;
197 }
198 if (dcl->ops->dpy_gfx_update != NULL) {
199 have_gfx = true;
200 }
201 if (dcl->ops->dpy_text_update != NULL) {
202 have_text = true;
203 }
204 }
205
206 if (need_timer && ds->gui_timer == NULL) {
207 ds->gui_timer = timer_new_ms(QEMU_CLOCK_REALTIME, gui_update, ds);
208 timer_mod(ds->gui_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME));
209 }
210 if (!need_timer && ds->gui_timer != NULL) {
211 timer_free(ds->gui_timer);
212 ds->gui_timer = NULL;
213 }
214
215 ds->have_gfx = have_gfx;
216 ds->have_text = have_text;
217 }
218
219 void graphic_hw_update_done(QemuConsole *con)
220 {
221 if (con) {
222 qemu_co_enter_all(&con->dump_queue, NULL);
223 }
224 }
225
226 void graphic_hw_update(QemuConsole *con)
227 {
228 bool async = false;
229 con = con ? con : active_console;
230 if (!con) {
231 return;
232 }
233 if (con->hw_ops->gfx_update) {
234 con->hw_ops->gfx_update(con->hw);
235 async = con->hw_ops->gfx_update_async;
236 }
237 if (!async) {
238 graphic_hw_update_done(con);
239 }
240 }
241
242 static void graphic_hw_gl_unblock_timer(void *opaque)
243 {
244 warn_report("console: no gl-unblock within one second");
245 }
246
247 void graphic_hw_gl_block(QemuConsole *con, bool block)
248 {
249 uint64_t timeout;
250 assert(con != NULL);
251
252 if (block) {
253 con->gl_block++;
254 } else {
255 con->gl_block--;
256 }
257 assert(con->gl_block >= 0);
258 if (!con->hw_ops->gl_block) {
259 return;
260 }
261 if ((block && con->gl_block != 1) || (!block && con->gl_block != 0)) {
262 return;
263 }
264 con->hw_ops->gl_block(con->hw, block);
265
266 if (block) {
267 timeout = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
268 timeout += 1000; /* one sec */
269 timer_mod(con->gl_unblock_timer, timeout);
270 } else {
271 timer_del(con->gl_unblock_timer);
272 }
273 }
274
275 int qemu_console_get_window_id(QemuConsole *con)
276 {
277 return con->window_id;
278 }
279
280 void qemu_console_set_window_id(QemuConsole *con, int window_id)
281 {
282 con->window_id = window_id;
283 }
284
285 void graphic_hw_invalidate(QemuConsole *con)
286 {
287 if (!con) {
288 con = active_console;
289 }
290 if (con && con->hw_ops->invalidate) {
291 con->hw_ops->invalidate(con->hw);
292 }
293 }
294
295 #ifdef CONFIG_PNG
296 /**
297 * png_save: Take a screenshot as PNG
298 *
299 * Saves screendump as a PNG file
300 *
301 * Returns true for success or false for error.
302 *
303 * @fd: File descriptor for PNG file.
304 * @image: Image data in pixman format.
305 * @errp: Pointer to an error.
306 */
307 static bool png_save(int fd, pixman_image_t *image, Error **errp)
308 {
309 int width = pixman_image_get_width(image);
310 int height = pixman_image_get_height(image);
311 png_struct *png_ptr;
312 png_info *info_ptr;
313 g_autoptr(pixman_image_t) linebuf =
314 qemu_pixman_linebuf_create(PIXMAN_BE_r8g8b8, width);
315 uint8_t *buf = (uint8_t *)pixman_image_get_data(linebuf);
316 FILE *f = fdopen(fd, "wb");
317 int y;
318 if (!f) {
319 error_setg_errno(errp, errno,
320 "Failed to create file from file descriptor");
321 return false;
322 }
323
324 png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL,
325 NULL, NULL);
326 if (!png_ptr) {
327 error_setg(errp, "PNG creation failed. Unable to write struct");
328 fclose(f);
329 return false;
330 }
331
332 info_ptr = png_create_info_struct(png_ptr);
333
334 if (!info_ptr) {
335 error_setg(errp, "PNG creation failed. Unable to write info");
336 fclose(f);
337 png_destroy_write_struct(&png_ptr, &info_ptr);
338 return false;
339 }
340
341 png_init_io(png_ptr, f);
342
343 png_set_IHDR(png_ptr, info_ptr, width, height, 8,
344 PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
345 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
346
347 png_write_info(png_ptr, info_ptr);
348
349 for (y = 0; y < height; ++y) {
350 qemu_pixman_linebuf_fill(linebuf, image, width, 0, y);
351 png_write_row(png_ptr, buf);
352 }
353
354 png_write_end(png_ptr, NULL);
355
356 png_destroy_write_struct(&png_ptr, &info_ptr);
357
358 if (fclose(f) != 0) {
359 error_setg_errno(errp, errno,
360 "PNG creation failed. Unable to close file");
361 return false;
362 }
363
364 return true;
365 }
366
367 #else /* no png support */
368
369 static bool png_save(int fd, pixman_image_t *image, Error **errp)
370 {
371 error_setg(errp, "Enable PNG support with libpng for screendump");
372 return false;
373 }
374
375 #endif /* CONFIG_PNG */
376
377 static bool ppm_save(int fd, pixman_image_t *image, Error **errp)
378 {
379 int width = pixman_image_get_width(image);
380 int height = pixman_image_get_height(image);
381 g_autoptr(Object) ioc = OBJECT(qio_channel_file_new_fd(fd));
382 g_autofree char *header = NULL;
383 g_autoptr(pixman_image_t) linebuf = NULL;
384 int y;
385
386 trace_ppm_save(fd, image);
387
388 header = g_strdup_printf("P6\n%d %d\n%d\n", width, height, 255);
389 if (qio_channel_write_all(QIO_CHANNEL(ioc),
390 header, strlen(header), errp) < 0) {
391 return false;
392 }
393
394 linebuf = qemu_pixman_linebuf_create(PIXMAN_BE_r8g8b8, width);
395 for (y = 0; y < height; y++) {
396 qemu_pixman_linebuf_fill(linebuf, image, width, 0, y);
397 if (qio_channel_write_all(QIO_CHANNEL(ioc),
398 (char *)pixman_image_get_data(linebuf),
399 pixman_image_get_stride(linebuf), errp) < 0) {
400 return false;
401 }
402 }
403
404 return true;
405 }
406
407 static void graphic_hw_update_bh(void *con)
408 {
409 graphic_hw_update(con);
410 }
411
412 /* Safety: coroutine-only, concurrent-coroutine safe, main thread only */
413 void coroutine_fn
414 qmp_screendump(const char *filename, const char *device,
415 bool has_head, int64_t head,
416 bool has_format, ImageFormat format, Error **errp)
417 {
418 g_autoptr(pixman_image_t) image = NULL;
419 QemuConsole *con;
420 DisplaySurface *surface;
421 int fd;
422
423 if (device) {
424 con = qemu_console_lookup_by_device_name(device, has_head ? head : 0,
425 errp);
426 if (!con) {
427 return;
428 }
429 } else {
430 if (has_head) {
431 error_setg(errp, "'head' must be specified together with 'device'");
432 return;
433 }
434 con = qemu_console_lookup_by_index(0);
435 if (!con) {
436 error_setg(errp, "There is no console to take a screendump from");
437 return;
438 }
439 }
440
441 if (qemu_co_queue_empty(&con->dump_queue)) {
442 /* Defer the update, it will restart the pending coroutines */
443 aio_bh_schedule_oneshot(qemu_get_aio_context(),
444 graphic_hw_update_bh, con);
445 }
446 qemu_co_queue_wait(&con->dump_queue, NULL);
447
448 /*
449 * All pending coroutines are woken up, while the BQL is held. No
450 * further graphic update are possible until it is released. Take
451 * an image ref before that.
452 */
453 surface = qemu_console_surface(con);
454 if (!surface) {
455 error_setg(errp, "no surface");
456 return;
457 }
458 image = pixman_image_ref(surface->image);
459
460 fd = qemu_open_old(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
461 if (fd == -1) {
462 error_setg(errp, "failed to open file '%s': %s", filename,
463 strerror(errno));
464 return;
465 }
466
467 /*
468 * The image content could potentially be updated as the coroutine
469 * yields and releases the BQL. It could produce corrupted dump, but
470 * it should be otherwise safe.
471 */
472 if (has_format && format == IMAGE_FORMAT_PNG) {
473 /* PNG format specified for screendump */
474 if (!png_save(fd, image, errp)) {
475 qemu_unlink(filename);
476 }
477 } else {
478 /* PPM format specified/default for screendump */
479 if (!ppm_save(fd, image, errp)) {
480 qemu_unlink(filename);
481 }
482 }
483 }
484
485 void graphic_hw_text_update(QemuConsole *con, console_ch_t *chardata)
486 {
487 if (!con) {
488 con = active_console;
489 }
490 if (con && con->hw_ops->text_update) {
491 con->hw_ops->text_update(con->hw, chardata);
492 }
493 }
494
495 static void vga_fill_rect(QemuConsole *con,
496 int posx, int posy, int width, int height,
497 pixman_color_t color)
498 {
499 DisplaySurface *surface = qemu_console_surface(con);
500 pixman_rectangle16_t rect = {
501 .x = posx, .y = posy, .width = width, .height = height
502 };
503
504 pixman_image_fill_rectangles(PIXMAN_OP_SRC, surface->image,
505 &color, 1, &rect);
506 }
507
508 /* copy from (xs, ys) to (xd, yd) a rectangle of size (w, h) */
509 static void vga_bitblt(QemuConsole *con,
510 int xs, int ys, int xd, int yd, int w, int h)
511 {
512 DisplaySurface *surface = qemu_console_surface(con);
513
514 pixman_image_composite(PIXMAN_OP_SRC,
515 surface->image, NULL, surface->image,
516 xs, ys, 0, 0, xd, yd, w, h);
517 }
518
519 /***********************************************************/
520 /* basic char display */
521
522 #define FONT_HEIGHT 16
523 #define FONT_WIDTH 8
524
525 #include "vgafont.h"
526
527 #define QEMU_RGB(r, g, b) \
528 { .red = r << 8, .green = g << 8, .blue = b << 8, .alpha = 0xffff }
529
530 static const pixman_color_t color_table_rgb[2][8] = {
531 { /* dark */
532 [QEMU_COLOR_BLACK] = QEMU_RGB(0x00, 0x00, 0x00), /* black */
533 [QEMU_COLOR_BLUE] = QEMU_RGB(0x00, 0x00, 0xaa), /* blue */
534 [QEMU_COLOR_GREEN] = QEMU_RGB(0x00, 0xaa, 0x00), /* green */
535 [QEMU_COLOR_CYAN] = QEMU_RGB(0x00, 0xaa, 0xaa), /* cyan */
536 [QEMU_COLOR_RED] = QEMU_RGB(0xaa, 0x00, 0x00), /* red */
537 [QEMU_COLOR_MAGENTA] = QEMU_RGB(0xaa, 0x00, 0xaa), /* magenta */
538 [QEMU_COLOR_YELLOW] = QEMU_RGB(0xaa, 0xaa, 0x00), /* yellow */
539 [QEMU_COLOR_WHITE] = QEMU_RGB(0xaa, 0xaa, 0xaa), /* white */
540 },
541 { /* bright */
542 [QEMU_COLOR_BLACK] = QEMU_RGB(0x00, 0x00, 0x00), /* black */
543 [QEMU_COLOR_BLUE] = QEMU_RGB(0x00, 0x00, 0xff), /* blue */
544 [QEMU_COLOR_GREEN] = QEMU_RGB(0x00, 0xff, 0x00), /* green */
545 [QEMU_COLOR_CYAN] = QEMU_RGB(0x00, 0xff, 0xff), /* cyan */
546 [QEMU_COLOR_RED] = QEMU_RGB(0xff, 0x00, 0x00), /* red */
547 [QEMU_COLOR_MAGENTA] = QEMU_RGB(0xff, 0x00, 0xff), /* magenta */
548 [QEMU_COLOR_YELLOW] = QEMU_RGB(0xff, 0xff, 0x00), /* yellow */
549 [QEMU_COLOR_WHITE] = QEMU_RGB(0xff, 0xff, 0xff), /* white */
550 }
551 };
552
553 static void vga_putcharxy(QemuConsole *s, int x, int y, int ch,
554 TextAttributes *t_attrib)
555 {
556 static pixman_image_t *glyphs[256];
557 DisplaySurface *surface = qemu_console_surface(s);
558 pixman_color_t fgcol, bgcol;
559
560 if (t_attrib->invers) {
561 bgcol = color_table_rgb[t_attrib->bold][t_attrib->fgcol];
562 fgcol = color_table_rgb[t_attrib->bold][t_attrib->bgcol];
563 } else {
564 fgcol = color_table_rgb[t_attrib->bold][t_attrib->fgcol];
565 bgcol = color_table_rgb[t_attrib->bold][t_attrib->bgcol];
566 }
567
568 if (!glyphs[ch]) {
569 glyphs[ch] = qemu_pixman_glyph_from_vgafont(FONT_HEIGHT, vgafont16, ch);
570 }
571 qemu_pixman_glyph_render(glyphs[ch], surface->image,
572 &fgcol, &bgcol, x, y, FONT_WIDTH, FONT_HEIGHT);
573 }
574
575 static void text_console_resize(QemuConsole *s)
576 {
577 TextCell *cells, *c, *c1;
578 int w1, x, y, last_width;
579
580 assert(s->scanout.kind == SCANOUT_SURFACE);
581
582 last_width = s->width;
583 s->width = surface_width(s->surface) / FONT_WIDTH;
584 s->height = surface_height(s->surface) / FONT_HEIGHT;
585
586 w1 = last_width;
587 if (s->width < w1)
588 w1 = s->width;
589
590 cells = g_new(TextCell, s->width * s->total_height + 1);
591 for(y = 0; y < s->total_height; y++) {
592 c = &cells[y * s->width];
593 if (w1 > 0) {
594 c1 = &s->cells[y * last_width];
595 for(x = 0; x < w1; x++) {
596 *c++ = *c1++;
597 }
598 }
599 for(x = w1; x < s->width; x++) {
600 c->ch = ' ';
601 c->t_attrib = s->t_attrib_default;
602 c++;
603 }
604 }
605 g_free(s->cells);
606 s->cells = cells;
607 }
608
609 static inline void text_update_xy(QemuConsole *s, int x, int y)
610 {
611 s->text_x[0] = MIN(s->text_x[0], x);
612 s->text_x[1] = MAX(s->text_x[1], x);
613 s->text_y[0] = MIN(s->text_y[0], y);
614 s->text_y[1] = MAX(s->text_y[1], y);
615 }
616
617 static void invalidate_xy(QemuConsole *s, int x, int y)
618 {
619 if (!qemu_console_is_visible(s)) {
620 return;
621 }
622 if (s->update_x0 > x * FONT_WIDTH)
623 s->update_x0 = x * FONT_WIDTH;
624 if (s->update_y0 > y * FONT_HEIGHT)
625 s->update_y0 = y * FONT_HEIGHT;
626 if (s->update_x1 < (x + 1) * FONT_WIDTH)
627 s->update_x1 = (x + 1) * FONT_WIDTH;
628 if (s->update_y1 < (y + 1) * FONT_HEIGHT)
629 s->update_y1 = (y + 1) * FONT_HEIGHT;
630 }
631
632 static void update_xy(QemuConsole *s, int x, int y)
633 {
634 TextCell *c;
635 int y1, y2;
636
637 if (s->ds->have_text) {
638 text_update_xy(s, x, y);
639 }
640
641 y1 = (s->y_base + y) % s->total_height;
642 y2 = y1 - s->y_displayed;
643 if (y2 < 0) {
644 y2 += s->total_height;
645 }
646 if (y2 < s->height) {
647 if (x >= s->width) {
648 x = s->width - 1;
649 }
650 c = &s->cells[y1 * s->width + x];
651 vga_putcharxy(s, x, y2, c->ch,
652 &(c->t_attrib));
653 invalidate_xy(s, x, y2);
654 }
655 }
656
657 static void console_show_cursor(QemuConsole *s, int show)
658 {
659 TextCell *c;
660 int y, y1;
661 int x = s->x;
662
663 if (s->ds->have_text) {
664 s->cursor_invalidate = 1;
665 }
666
667 if (x >= s->width) {
668 x = s->width - 1;
669 }
670 y1 = (s->y_base + s->y) % s->total_height;
671 y = y1 - s->y_displayed;
672 if (y < 0) {
673 y += s->total_height;
674 }
675 if (y < s->height) {
676 c = &s->cells[y1 * s->width + x];
677 if (show && cursor_visible_phase) {
678 TextAttributes t_attrib = s->t_attrib_default;
679 t_attrib.invers = !(t_attrib.invers); /* invert fg and bg */
680 vga_putcharxy(s, x, y, c->ch, &t_attrib);
681 } else {
682 vga_putcharxy(s, x, y, c->ch, &(c->t_attrib));
683 }
684 invalidate_xy(s, x, y);
685 }
686 }
687
688 static void console_refresh(QemuConsole *s)
689 {
690 DisplaySurface *surface = qemu_console_surface(s);
691 TextCell *c;
692 int x, y, y1;
693
694 if (s->ds->have_text) {
695 s->text_x[0] = 0;
696 s->text_y[0] = 0;
697 s->text_x[1] = s->width - 1;
698 s->text_y[1] = s->height - 1;
699 s->cursor_invalidate = 1;
700 }
701
702 vga_fill_rect(s, 0, 0, surface_width(surface), surface_height(surface),
703 color_table_rgb[0][QEMU_COLOR_BLACK]);
704 y1 = s->y_displayed;
705 for (y = 0; y < s->height; y++) {
706 c = s->cells + y1 * s->width;
707 for (x = 0; x < s->width; x++) {
708 vga_putcharxy(s, x, y, c->ch,
709 &(c->t_attrib));
710 c++;
711 }
712 if (++y1 == s->total_height) {
713 y1 = 0;
714 }
715 }
716 console_show_cursor(s, 1);
717 dpy_gfx_update(s, 0, 0,
718 surface_width(surface), surface_height(surface));
719 }
720
721 static void console_scroll(QemuConsole *s, int ydelta)
722 {
723 int i, y1;
724
725 if (ydelta > 0) {
726 for(i = 0; i < ydelta; i++) {
727 if (s->y_displayed == s->y_base)
728 break;
729 if (++s->y_displayed == s->total_height)
730 s->y_displayed = 0;
731 }
732 } else {
733 ydelta = -ydelta;
734 i = s->backscroll_height;
735 if (i > s->total_height - s->height)
736 i = s->total_height - s->height;
737 y1 = s->y_base - i;
738 if (y1 < 0)
739 y1 += s->total_height;
740 for(i = 0; i < ydelta; i++) {
741 if (s->y_displayed == y1)
742 break;
743 if (--s->y_displayed < 0)
744 s->y_displayed = s->total_height - 1;
745 }
746 }
747 console_refresh(s);
748 }
749
750 static void console_put_lf(QemuConsole *s)
751 {
752 TextCell *c;
753 int x, y1;
754
755 s->y++;
756 if (s->y >= s->height) {
757 s->y = s->height - 1;
758
759 if (s->y_displayed == s->y_base) {
760 if (++s->y_displayed == s->total_height)
761 s->y_displayed = 0;
762 }
763 if (++s->y_base == s->total_height)
764 s->y_base = 0;
765 if (s->backscroll_height < s->total_height)
766 s->backscroll_height++;
767 y1 = (s->y_base + s->height - 1) % s->total_height;
768 c = &s->cells[y1 * s->width];
769 for(x = 0; x < s->width; x++) {
770 c->ch = ' ';
771 c->t_attrib = s->t_attrib_default;
772 c++;
773 }
774 if (s->y_displayed == s->y_base) {
775 if (s->ds->have_text) {
776 s->text_x[0] = 0;
777 s->text_y[0] = 0;
778 s->text_x[1] = s->width - 1;
779 s->text_y[1] = s->height - 1;
780 }
781
782 vga_bitblt(s, 0, FONT_HEIGHT, 0, 0,
783 s->width * FONT_WIDTH,
784 (s->height - 1) * FONT_HEIGHT);
785 vga_fill_rect(s, 0, (s->height - 1) * FONT_HEIGHT,
786 s->width * FONT_WIDTH, FONT_HEIGHT,
787 color_table_rgb[0][s->t_attrib_default.bgcol]);
788 s->update_x0 = 0;
789 s->update_y0 = 0;
790 s->update_x1 = s->width * FONT_WIDTH;
791 s->update_y1 = s->height * FONT_HEIGHT;
792 }
793 }
794 }
795
796 /* Set console attributes depending on the current escape codes.
797 * NOTE: I know this code is not very efficient (checking every color for it
798 * self) but it is more readable and better maintainable.
799 */
800 static void console_handle_escape(QemuConsole *s)
801 {
802 int i;
803
804 for (i=0; i<s->nb_esc_params; i++) {
805 switch (s->esc_params[i]) {
806 case 0: /* reset all console attributes to default */
807 s->t_attrib = s->t_attrib_default;
808 break;
809 case 1:
810 s->t_attrib.bold = 1;
811 break;
812 case 4:
813 s->t_attrib.uline = 1;
814 break;
815 case 5:
816 s->t_attrib.blink = 1;
817 break;
818 case 7:
819 s->t_attrib.invers = 1;
820 break;
821 case 8:
822 s->t_attrib.unvisible = 1;
823 break;
824 case 22:
825 s->t_attrib.bold = 0;
826 break;
827 case 24:
828 s->t_attrib.uline = 0;
829 break;
830 case 25:
831 s->t_attrib.blink = 0;
832 break;
833 case 27:
834 s->t_attrib.invers = 0;
835 break;
836 case 28:
837 s->t_attrib.unvisible = 0;
838 break;
839 /* set foreground color */
840 case 30:
841 s->t_attrib.fgcol = QEMU_COLOR_BLACK;
842 break;
843 case 31:
844 s->t_attrib.fgcol = QEMU_COLOR_RED;
845 break;
846 case 32:
847 s->t_attrib.fgcol = QEMU_COLOR_GREEN;
848 break;
849 case 33:
850 s->t_attrib.fgcol = QEMU_COLOR_YELLOW;
851 break;
852 case 34:
853 s->t_attrib.fgcol = QEMU_COLOR_BLUE;
854 break;
855 case 35:
856 s->t_attrib.fgcol = QEMU_COLOR_MAGENTA;
857 break;
858 case 36:
859 s->t_attrib.fgcol = QEMU_COLOR_CYAN;
860 break;
861 case 37:
862 s->t_attrib.fgcol = QEMU_COLOR_WHITE;
863 break;
864 /* set background color */
865 case 40:
866 s->t_attrib.bgcol = QEMU_COLOR_BLACK;
867 break;
868 case 41:
869 s->t_attrib.bgcol = QEMU_COLOR_RED;
870 break;
871 case 42:
872 s->t_attrib.bgcol = QEMU_COLOR_GREEN;
873 break;
874 case 43:
875 s->t_attrib.bgcol = QEMU_COLOR_YELLOW;
876 break;
877 case 44:
878 s->t_attrib.bgcol = QEMU_COLOR_BLUE;
879 break;
880 case 45:
881 s->t_attrib.bgcol = QEMU_COLOR_MAGENTA;
882 break;
883 case 46:
884 s->t_attrib.bgcol = QEMU_COLOR_CYAN;
885 break;
886 case 47:
887 s->t_attrib.bgcol = QEMU_COLOR_WHITE;
888 break;
889 }
890 }
891 }
892
893 static void console_clear_xy(QemuConsole *s, int x, int y)
894 {
895 int y1 = (s->y_base + y) % s->total_height;
896 if (x >= s->width) {
897 x = s->width - 1;
898 }
899 TextCell *c = &s->cells[y1 * s->width + x];
900 c->ch = ' ';
901 c->t_attrib = s->t_attrib_default;
902 update_xy(s, x, y);
903 }
904
905 static void console_put_one(QemuConsole *s, int ch)
906 {
907 TextCell *c;
908 int y1;
909 if (s->x >= s->width) {
910 /* line wrap */
911 s->x = 0;
912 console_put_lf(s);
913 }
914 y1 = (s->y_base + s->y) % s->total_height;
915 c = &s->cells[y1 * s->width + s->x];
916 c->ch = ch;
917 c->t_attrib = s->t_attrib;
918 update_xy(s, s->x, s->y);
919 s->x++;
920 }
921
922 static void console_respond_str(QemuConsole *s, const char *buf)
923 {
924 while (*buf) {
925 console_put_one(s, *buf);
926 buf++;
927 }
928 }
929
930 /* set cursor, checking bounds */
931 static void set_cursor(QemuConsole *s, int x, int y)
932 {
933 if (x < 0) {
934 x = 0;
935 }
936 if (y < 0) {
937 y = 0;
938 }
939 if (y >= s->height) {
940 y = s->height - 1;
941 }
942 if (x >= s->width) {
943 x = s->width - 1;
944 }
945
946 s->x = x;
947 s->y = y;
948 }
949
950 static void console_putchar(QemuConsole *s, int ch)
951 {
952 int i;
953 int x, y;
954 char response[40];
955
956 switch(s->state) {
957 case TTY_STATE_NORM:
958 switch(ch) {
959 case '\r': /* carriage return */
960 s->x = 0;
961 break;
962 case '\n': /* newline */
963 console_put_lf(s);
964 break;
965 case '\b': /* backspace */
966 if (s->x > 0)
967 s->x--;
968 break;
969 case '\t': /* tabspace */
970 if (s->x + (8 - (s->x % 8)) > s->width) {
971 s->x = 0;
972 console_put_lf(s);
973 } else {
974 s->x = s->x + (8 - (s->x % 8));
975 }
976 break;
977 case '\a': /* alert aka. bell */
978 /* TODO: has to be implemented */
979 break;
980 case 14:
981 /* SI (shift in), character set 0 (ignored) */
982 break;
983 case 15:
984 /* SO (shift out), character set 1 (ignored) */
985 break;
986 case 27: /* esc (introducing an escape sequence) */
987 s->state = TTY_STATE_ESC;
988 break;
989 default:
990 console_put_one(s, ch);
991 break;
992 }
993 break;
994 case TTY_STATE_ESC: /* check if it is a terminal escape sequence */
995 if (ch == '[') {
996 for(i=0;i<MAX_ESC_PARAMS;i++)
997 s->esc_params[i] = 0;
998 s->nb_esc_params = 0;
999 s->state = TTY_STATE_CSI;
1000 } else {
1001 s->state = TTY_STATE_NORM;
1002 }
1003 break;
1004 case TTY_STATE_CSI: /* handle escape sequence parameters */
1005 if (ch >= '0' && ch <= '9') {
1006 if (s->nb_esc_params < MAX_ESC_PARAMS) {
1007 int *param = &s->esc_params[s->nb_esc_params];
1008 int digit = (ch - '0');
1009
1010 *param = (*param <= (INT_MAX - digit) / 10) ?
1011 *param * 10 + digit : INT_MAX;
1012 }
1013 } else {
1014 if (s->nb_esc_params < MAX_ESC_PARAMS)
1015 s->nb_esc_params++;
1016 if (ch == ';' || ch == '?') {
1017 break;
1018 }
1019 trace_console_putchar_csi(s->esc_params[0], s->esc_params[1],
1020 ch, s->nb_esc_params);
1021 s->state = TTY_STATE_NORM;
1022 switch(ch) {
1023 case 'A':
1024 /* move cursor up */
1025 if (s->esc_params[0] == 0) {
1026 s->esc_params[0] = 1;
1027 }
1028 set_cursor(s, s->x, s->y - s->esc_params[0]);
1029 break;
1030 case 'B':
1031 /* move cursor down */
1032 if (s->esc_params[0] == 0) {
1033 s->esc_params[0] = 1;
1034 }
1035 set_cursor(s, s->x, s->y + s->esc_params[0]);
1036 break;
1037 case 'C':
1038 /* move cursor right */
1039 if (s->esc_params[0] == 0) {
1040 s->esc_params[0] = 1;
1041 }
1042 set_cursor(s, s->x + s->esc_params[0], s->y);
1043 break;
1044 case 'D':
1045 /* move cursor left */
1046 if (s->esc_params[0] == 0) {
1047 s->esc_params[0] = 1;
1048 }
1049 set_cursor(s, s->x - s->esc_params[0], s->y);
1050 break;
1051 case 'G':
1052 /* move cursor to column */
1053 set_cursor(s, s->esc_params[0] - 1, s->y);
1054 break;
1055 case 'f':
1056 case 'H':
1057 /* move cursor to row, column */
1058 set_cursor(s, s->esc_params[1] - 1, s->esc_params[0] - 1);
1059 break;
1060 case 'J':
1061 switch (s->esc_params[0]) {
1062 case 0:
1063 /* clear to end of screen */
1064 for (y = s->y; y < s->height; y++) {
1065 for (x = 0; x < s->width; x++) {
1066 if (y == s->y && x < s->x) {
1067 continue;
1068 }
1069 console_clear_xy(s, x, y);
1070 }
1071 }
1072 break;
1073 case 1:
1074 /* clear from beginning of screen */
1075 for (y = 0; y <= s->y; y++) {
1076 for (x = 0; x < s->width; x++) {
1077 if (y == s->y && x > s->x) {
1078 break;
1079 }
1080 console_clear_xy(s, x, y);
1081 }
1082 }
1083 break;
1084 case 2:
1085 /* clear entire screen */
1086 for (y = 0; y <= s->height; y++) {
1087 for (x = 0; x < s->width; x++) {
1088 console_clear_xy(s, x, y);
1089 }
1090 }
1091 break;
1092 }
1093 break;
1094 case 'K':
1095 switch (s->esc_params[0]) {
1096 case 0:
1097 /* clear to eol */
1098 for(x = s->x; x < s->width; x++) {
1099 console_clear_xy(s, x, s->y);
1100 }
1101 break;
1102 case 1:
1103 /* clear from beginning of line */
1104 for (x = 0; x <= s->x && x < s->width; x++) {
1105 console_clear_xy(s, x, s->y);
1106 }
1107 break;
1108 case 2:
1109 /* clear entire line */
1110 for(x = 0; x < s->width; x++) {
1111 console_clear_xy(s, x, s->y);
1112 }
1113 break;
1114 }
1115 break;
1116 case 'm':
1117 console_handle_escape(s);
1118 break;
1119 case 'n':
1120 switch (s->esc_params[0]) {
1121 case 5:
1122 /* report console status (always succeed)*/
1123 console_respond_str(s, "\033[0n");
1124 break;
1125 case 6:
1126 /* report cursor position */
1127 sprintf(response, "\033[%d;%dR",
1128 (s->y_base + s->y) % s->total_height + 1,
1129 s->x + 1);
1130 console_respond_str(s, response);
1131 break;
1132 }
1133 break;
1134 case 's':
1135 /* save cursor position */
1136 s->x_saved = s->x;
1137 s->y_saved = s->y;
1138 break;
1139 case 'u':
1140 /* restore cursor position */
1141 s->x = s->x_saved;
1142 s->y = s->y_saved;
1143 break;
1144 default:
1145 trace_console_putchar_unhandled(ch);
1146 break;
1147 }
1148 break;
1149 }
1150 }
1151 }
1152
1153 static void displaychangelistener_gfx_switch(DisplayChangeListener *dcl,
1154 struct DisplaySurface *new_surface,
1155 bool update)
1156 {
1157 if (dcl->ops->dpy_gfx_switch) {
1158 dcl->ops->dpy_gfx_switch(dcl, new_surface);
1159 }
1160
1161 if (update && dcl->ops->dpy_gfx_update) {
1162 dcl->ops->dpy_gfx_update(dcl, 0, 0,
1163 surface_width(new_surface),
1164 surface_height(new_surface));
1165 }
1166 }
1167
1168 static void dpy_gfx_create_texture(QemuConsole *con, DisplaySurface *surface)
1169 {
1170 if (con->gl && con->gl->ops->dpy_gl_ctx_create_texture) {
1171 con->gl->ops->dpy_gl_ctx_create_texture(con->gl, surface);
1172 }
1173 }
1174
1175 static void dpy_gfx_destroy_texture(QemuConsole *con, DisplaySurface *surface)
1176 {
1177 if (con->gl && con->gl->ops->dpy_gl_ctx_destroy_texture) {
1178 con->gl->ops->dpy_gl_ctx_destroy_texture(con->gl, surface);
1179 }
1180 }
1181
1182 static void dpy_gfx_update_texture(QemuConsole *con, DisplaySurface *surface,
1183 int x, int y, int w, int h)
1184 {
1185 if (con->gl && con->gl->ops->dpy_gl_ctx_update_texture) {
1186 con->gl->ops->dpy_gl_ctx_update_texture(con->gl, surface, x, y, w, h);
1187 }
1188 }
1189
1190 static void displaychangelistener_display_console(DisplayChangeListener *dcl,
1191 QemuConsole *con,
1192 Error **errp)
1193 {
1194 static const char nodev[] =
1195 "This VM has no graphic display device.";
1196 static DisplaySurface *dummy;
1197
1198 if (!con || !console_compatible_with(con, dcl, errp)) {
1199 if (!dummy) {
1200 dummy = qemu_create_placeholder_surface(640, 480, nodev);
1201 }
1202 if (con) {
1203 dpy_gfx_create_texture(con, dummy);
1204 }
1205 displaychangelistener_gfx_switch(dcl, dummy, TRUE);
1206 return;
1207 }
1208
1209 dpy_gfx_create_texture(con, con->surface);
1210 displaychangelistener_gfx_switch(dcl, con->surface,
1211 con->scanout.kind == SCANOUT_SURFACE);
1212
1213 if (con->scanout.kind == SCANOUT_DMABUF &&
1214 displaychangelistener_has_dmabuf(dcl)) {
1215 dcl->ops->dpy_gl_scanout_dmabuf(dcl, con->scanout.dmabuf);
1216 } else if (con->scanout.kind == SCANOUT_TEXTURE &&
1217 dcl->ops->dpy_gl_scanout_texture) {
1218 dcl->ops->dpy_gl_scanout_texture(dcl,
1219 con->scanout.texture.backing_id,
1220 con->scanout.texture.backing_y_0_top,
1221 con->scanout.texture.backing_width,
1222 con->scanout.texture.backing_height,
1223 con->scanout.texture.x,
1224 con->scanout.texture.y,
1225 con->scanout.texture.width,
1226 con->scanout.texture.height,
1227 con->scanout.texture.d3d_tex2d);
1228 }
1229 }
1230
1231 void console_select(unsigned int index)
1232 {
1233 DisplayChangeListener *dcl;
1234 QemuConsole *s;
1235
1236 trace_console_select(index);
1237 s = qemu_console_lookup_by_index(index);
1238 if (s) {
1239 DisplayState *ds = s->ds;
1240
1241 active_console = s;
1242 if (ds->have_gfx) {
1243 QLIST_FOREACH(dcl, &ds->listeners, next) {
1244 if (dcl->con != NULL) {
1245 continue;
1246 }
1247 displaychangelistener_display_console(dcl, s, NULL);
1248 }
1249 }
1250 if (ds->have_text) {
1251 dpy_text_resize(s, s->width, s->height);
1252 }
1253 text_console_update_cursor(NULL);
1254 }
1255 }
1256
1257 struct VCChardev {
1258 Chardev parent;
1259 QemuConsole *console;
1260 };
1261 typedef struct VCChardev VCChardev;
1262
1263 #define TYPE_CHARDEV_VC "chardev-vc"
1264 DECLARE_INSTANCE_CHECKER(VCChardev, VC_CHARDEV,
1265 TYPE_CHARDEV_VC)
1266
1267 static int vc_chr_write(Chardev *chr, const uint8_t *buf, int len)
1268 {
1269 VCChardev *drv = VC_CHARDEV(chr);
1270 QemuConsole *s = drv->console;
1271 int i;
1272
1273 if (!s->ds) {
1274 return 0;
1275 }
1276
1277 s->update_x0 = s->width * FONT_WIDTH;
1278 s->update_y0 = s->height * FONT_HEIGHT;
1279 s->update_x1 = 0;
1280 s->update_y1 = 0;
1281 console_show_cursor(s, 0);
1282 for(i = 0; i < len; i++) {
1283 console_putchar(s, buf[i]);
1284 }
1285 console_show_cursor(s, 1);
1286 if (s->ds->have_gfx && s->update_x0 < s->update_x1) {
1287 dpy_gfx_update(s, s->update_x0, s->update_y0,
1288 s->update_x1 - s->update_x0,
1289 s->update_y1 - s->update_y0);
1290 }
1291 return len;
1292 }
1293
1294 static void kbd_send_chars(QemuConsole *s)
1295 {
1296 uint32_t len, avail;
1297
1298 len = qemu_chr_be_can_write(s->chr);
1299 avail = fifo8_num_used(&s->out_fifo);
1300 while (len > 0 && avail > 0) {
1301 const uint8_t *buf;
1302 uint32_t size;
1303
1304 buf = fifo8_pop_buf(&s->out_fifo, MIN(len, avail), &size);
1305 qemu_chr_be_write(s->chr, buf, size);
1306 len = qemu_chr_be_can_write(s->chr);
1307 avail -= size;
1308 }
1309 }
1310
1311 /* called when an ascii key is pressed */
1312 void kbd_put_keysym_console(QemuConsole *s, int keysym)
1313 {
1314 uint8_t buf[16], *q;
1315 int c;
1316 uint32_t num_free;
1317
1318 if (!s || (s->console_type == GRAPHIC_CONSOLE))
1319 return;
1320
1321 switch(keysym) {
1322 case QEMU_KEY_CTRL_UP:
1323 console_scroll(s, -1);
1324 break;
1325 case QEMU_KEY_CTRL_DOWN:
1326 console_scroll(s, 1);
1327 break;
1328 case QEMU_KEY_CTRL_PAGEUP:
1329 console_scroll(s, -10);
1330 break;
1331 case QEMU_KEY_CTRL_PAGEDOWN:
1332 console_scroll(s, 10);
1333 break;
1334 default:
1335 /* convert the QEMU keysym to VT100 key string */
1336 q = buf;
1337 if (keysym >= 0xe100 && keysym <= 0xe11f) {
1338 *q++ = '\033';
1339 *q++ = '[';
1340 c = keysym - 0xe100;
1341 if (c >= 10)
1342 *q++ = '0' + (c / 10);
1343 *q++ = '0' + (c % 10);
1344 *q++ = '~';
1345 } else if (keysym >= 0xe120 && keysym <= 0xe17f) {
1346 *q++ = '\033';
1347 *q++ = '[';
1348 *q++ = keysym & 0xff;
1349 } else if (s->echo && (keysym == '\r' || keysym == '\n')) {
1350 vc_chr_write(s->chr, (const uint8_t *) "\r", 1);
1351 *q++ = '\n';
1352 } else {
1353 *q++ = keysym;
1354 }
1355 if (s->echo) {
1356 vc_chr_write(s->chr, buf, q - buf);
1357 }
1358 num_free = fifo8_num_free(&s->out_fifo);
1359 fifo8_push_all(&s->out_fifo, buf, MIN(num_free, q - buf));
1360 kbd_send_chars(s);
1361 break;
1362 }
1363 }
1364
1365 static const int qcode_to_keysym[Q_KEY_CODE__MAX] = {
1366 [Q_KEY_CODE_UP] = QEMU_KEY_UP,
1367 [Q_KEY_CODE_DOWN] = QEMU_KEY_DOWN,
1368 [Q_KEY_CODE_RIGHT] = QEMU_KEY_RIGHT,
1369 [Q_KEY_CODE_LEFT] = QEMU_KEY_LEFT,
1370 [Q_KEY_CODE_HOME] = QEMU_KEY_HOME,
1371 [Q_KEY_CODE_END] = QEMU_KEY_END,
1372 [Q_KEY_CODE_PGUP] = QEMU_KEY_PAGEUP,
1373 [Q_KEY_CODE_PGDN] = QEMU_KEY_PAGEDOWN,
1374 [Q_KEY_CODE_DELETE] = QEMU_KEY_DELETE,
1375 [Q_KEY_CODE_TAB] = QEMU_KEY_TAB,
1376 [Q_KEY_CODE_BACKSPACE] = QEMU_KEY_BACKSPACE,
1377 };
1378
1379 static const int ctrl_qcode_to_keysym[Q_KEY_CODE__MAX] = {
1380 [Q_KEY_CODE_UP] = QEMU_KEY_CTRL_UP,
1381 [Q_KEY_CODE_DOWN] = QEMU_KEY_CTRL_DOWN,
1382 [Q_KEY_CODE_RIGHT] = QEMU_KEY_CTRL_RIGHT,
1383 [Q_KEY_CODE_LEFT] = QEMU_KEY_CTRL_LEFT,
1384 [Q_KEY_CODE_HOME] = QEMU_KEY_CTRL_HOME,
1385 [Q_KEY_CODE_END] = QEMU_KEY_CTRL_END,
1386 [Q_KEY_CODE_PGUP] = QEMU_KEY_CTRL_PAGEUP,
1387 [Q_KEY_CODE_PGDN] = QEMU_KEY_CTRL_PAGEDOWN,
1388 };
1389
1390 bool kbd_put_qcode_console(QemuConsole *s, int qcode, bool ctrl)
1391 {
1392 int keysym;
1393
1394 keysym = ctrl ? ctrl_qcode_to_keysym[qcode] : qcode_to_keysym[qcode];
1395 if (keysym == 0) {
1396 return false;
1397 }
1398 kbd_put_keysym_console(s, keysym);
1399 return true;
1400 }
1401
1402 void kbd_put_string_console(QemuConsole *s, const char *str, int len)
1403 {
1404 int i;
1405
1406 for (i = 0; i < len && str[i]; i++) {
1407 kbd_put_keysym_console(s, str[i]);
1408 }
1409 }
1410
1411 void kbd_put_keysym(int keysym)
1412 {
1413 kbd_put_keysym_console(active_console, keysym);
1414 }
1415
1416 static void text_console_invalidate(void *opaque)
1417 {
1418 QemuConsole *s = (QemuConsole *) opaque;
1419
1420 if (s->ds->have_text && s->console_type == TEXT_CONSOLE) {
1421 text_console_resize(s);
1422 }
1423 console_refresh(s);
1424 }
1425
1426 static void text_console_update(void *opaque, console_ch_t *chardata)
1427 {
1428 QemuConsole *s = (QemuConsole *) opaque;
1429 int i, j, src;
1430
1431 if (s->text_x[0] <= s->text_x[1]) {
1432 src = (s->y_base + s->text_y[0]) * s->width;
1433 chardata += s->text_y[0] * s->width;
1434 for (i = s->text_y[0]; i <= s->text_y[1]; i ++)
1435 for (j = 0; j < s->width; j++, src++) {
1436 console_write_ch(chardata ++,
1437 ATTR2CHTYPE(s->cells[src].ch,
1438 s->cells[src].t_attrib.fgcol,
1439 s->cells[src].t_attrib.bgcol,
1440 s->cells[src].t_attrib.bold));
1441 }
1442 dpy_text_update(s, s->text_x[0], s->text_y[0],
1443 s->text_x[1] - s->text_x[0], i - s->text_y[0]);
1444 s->text_x[0] = s->width;
1445 s->text_y[0] = s->height;
1446 s->text_x[1] = 0;
1447 s->text_y[1] = 0;
1448 }
1449 if (s->cursor_invalidate) {
1450 dpy_text_cursor(s, s->x, s->y);
1451 s->cursor_invalidate = 0;
1452 }
1453 }
1454
1455 static QemuConsole *new_console(DisplayState *ds, console_type_t console_type,
1456 uint32_t head)
1457 {
1458 Object *obj;
1459 QemuConsole *s;
1460 int i;
1461
1462 obj = object_new(TYPE_QEMU_CONSOLE);
1463 s = QEMU_CONSOLE(obj);
1464 qemu_co_queue_init(&s->dump_queue);
1465 s->head = head;
1466 object_property_add_link(obj, "device", TYPE_DEVICE,
1467 (Object **)&s->device,
1468 object_property_allow_set_link,
1469 OBJ_PROP_LINK_STRONG);
1470 object_property_add_uint32_ptr(obj, "head", &s->head,
1471 OBJ_PROP_FLAG_READ);
1472
1473 if (!active_console || ((active_console->console_type != GRAPHIC_CONSOLE) &&
1474 (console_type == GRAPHIC_CONSOLE))) {
1475 active_console = s;
1476 }
1477 s->ds = ds;
1478 s->console_type = console_type;
1479 s->window_id = -1;
1480
1481 if (QTAILQ_EMPTY(&consoles)) {
1482 s->index = 0;
1483 QTAILQ_INSERT_TAIL(&consoles, s, next);
1484 } else if (console_type != GRAPHIC_CONSOLE || phase_check(PHASE_MACHINE_READY)) {
1485 QemuConsole *last = QTAILQ_LAST(&consoles);
1486 s->index = last->index + 1;
1487 QTAILQ_INSERT_TAIL(&consoles, s, next);
1488 } else {
1489 /*
1490 * HACK: Put graphical consoles before text consoles.
1491 *
1492 * Only do that for coldplugged devices. After initial device
1493 * initialization we will not renumber the consoles any more.
1494 */
1495 QemuConsole *c = QTAILQ_FIRST(&consoles);
1496
1497 while (QTAILQ_NEXT(c, next) != NULL &&
1498 c->console_type == GRAPHIC_CONSOLE) {
1499 c = QTAILQ_NEXT(c, next);
1500 }
1501 if (c->console_type == GRAPHIC_CONSOLE) {
1502 /* have no text consoles */
1503 s->index = c->index + 1;
1504 QTAILQ_INSERT_AFTER(&consoles, c, s, next);
1505 } else {
1506 s->index = c->index;
1507 QTAILQ_INSERT_BEFORE(c, s, next);
1508 /* renumber text consoles */
1509 for (i = s->index + 1; c != NULL; c = QTAILQ_NEXT(c, next), i++) {
1510 c->index = i;
1511 }
1512 }
1513 }
1514 return s;
1515 }
1516
1517 #ifdef WIN32
1518 void qemu_displaysurface_win32_set_handle(DisplaySurface *surface,
1519 HANDLE h, uint32_t offset)
1520 {
1521 assert(!surface->handle);
1522
1523 surface->handle = h;
1524 surface->handle_offset = offset;
1525 }
1526
1527 static void
1528 win32_pixman_image_destroy(pixman_image_t *image, void *data)
1529 {
1530 DisplaySurface *surface = data;
1531
1532 if (!surface->handle) {
1533 return;
1534 }
1535
1536 assert(surface->handle_offset == 0);
1537
1538 qemu_win32_map_free(
1539 pixman_image_get_data(surface->image),
1540 surface->handle,
1541 &error_warn
1542 );
1543 }
1544 #endif
1545
1546 DisplaySurface *qemu_create_displaysurface(int width, int height)
1547 {
1548 DisplaySurface *surface;
1549 void *bits = NULL;
1550 #ifdef WIN32
1551 HANDLE handle = NULL;
1552 #endif
1553
1554 trace_displaysurface_create(width, height);
1555
1556 #ifdef WIN32
1557 bits = qemu_win32_map_alloc(width * height * 4, &handle, &error_abort);
1558 #endif
1559
1560 surface = qemu_create_displaysurface_from(
1561 width, height,
1562 PIXMAN_x8r8g8b8,
1563 width * 4, bits
1564 );
1565 surface->flags = QEMU_ALLOCATED_FLAG;
1566
1567 #ifdef WIN32
1568 qemu_displaysurface_win32_set_handle(surface, handle, 0);
1569 #endif
1570 return surface;
1571 }
1572
1573 DisplaySurface *qemu_create_displaysurface_from(int width, int height,
1574 pixman_format_code_t format,
1575 int linesize, uint8_t *data)
1576 {
1577 DisplaySurface *surface = g_new0(DisplaySurface, 1);
1578
1579 trace_displaysurface_create_from(surface, width, height, format);
1580 surface->format = format;
1581 surface->image = pixman_image_create_bits(surface->format,
1582 width, height,
1583 (void *)data, linesize);
1584 assert(surface->image != NULL);
1585 #ifdef WIN32
1586 pixman_image_set_destroy_function(surface->image,
1587 win32_pixman_image_destroy, surface);
1588 #endif
1589
1590 return surface;
1591 }
1592
1593 DisplaySurface *qemu_create_displaysurface_pixman(pixman_image_t *image)
1594 {
1595 DisplaySurface *surface = g_new0(DisplaySurface, 1);
1596
1597 trace_displaysurface_create_pixman(surface);
1598 surface->format = pixman_image_get_format(image);
1599 surface->image = pixman_image_ref(image);
1600
1601 return surface;
1602 }
1603
1604 DisplaySurface *qemu_create_placeholder_surface(int w, int h,
1605 const char *msg)
1606 {
1607 DisplaySurface *surface = qemu_create_displaysurface(w, h);
1608 pixman_color_t bg = color_table_rgb[0][QEMU_COLOR_BLACK];
1609 pixman_color_t fg = color_table_rgb[0][QEMU_COLOR_WHITE];
1610 pixman_image_t *glyph;
1611 int len, x, y, i;
1612
1613 len = strlen(msg);
1614 x = (w / FONT_WIDTH - len) / 2;
1615 y = (h / FONT_HEIGHT - 1) / 2;
1616 for (i = 0; i < len; i++) {
1617 glyph = qemu_pixman_glyph_from_vgafont(FONT_HEIGHT, vgafont16, msg[i]);
1618 qemu_pixman_glyph_render(glyph, surface->image, &fg, &bg,
1619 x+i, y, FONT_WIDTH, FONT_HEIGHT);
1620 qemu_pixman_image_unref(glyph);
1621 }
1622 surface->flags |= QEMU_PLACEHOLDER_FLAG;
1623 return surface;
1624 }
1625
1626 void qemu_free_displaysurface(DisplaySurface *surface)
1627 {
1628 if (surface == NULL) {
1629 return;
1630 }
1631 trace_displaysurface_free(surface);
1632 qemu_pixman_image_unref(surface->image);
1633 g_free(surface);
1634 }
1635
1636 bool console_has_gl(QemuConsole *con)
1637 {
1638 return con->gl != NULL;
1639 }
1640
1641 static bool displaychangelistener_has_dmabuf(DisplayChangeListener *dcl)
1642 {
1643 if (dcl->ops->dpy_has_dmabuf) {
1644 return dcl->ops->dpy_has_dmabuf(dcl);
1645 }
1646
1647 if (dcl->ops->dpy_gl_scanout_dmabuf) {
1648 return true;
1649 }
1650
1651 return false;
1652 }
1653
1654 static bool console_compatible_with(QemuConsole *con,
1655 DisplayChangeListener *dcl, Error **errp)
1656 {
1657 int flags;
1658
1659 flags = con->hw_ops->get_flags ? con->hw_ops->get_flags(con->hw) : 0;
1660
1661 if (console_has_gl(con) &&
1662 !con->gl->ops->dpy_gl_ctx_is_compatible_dcl(con->gl, dcl)) {
1663 error_setg(errp, "Display %s is incompatible with the GL context",
1664 dcl->ops->dpy_name);
1665 return false;
1666 }
1667
1668 if (flags & GRAPHIC_FLAGS_GL &&
1669 !console_has_gl(con)) {
1670 error_setg(errp, "The console requires a GL context.");
1671 return false;
1672
1673 }
1674
1675 if (flags & GRAPHIC_FLAGS_DMABUF &&
1676 !displaychangelistener_has_dmabuf(dcl)) {
1677 error_setg(errp, "The console requires display DMABUF support.");
1678 return false;
1679 }
1680
1681 return true;
1682 }
1683
1684 void console_handle_touch_event(QemuConsole *con,
1685 struct touch_slot touch_slots[INPUT_EVENT_SLOTS_MAX],
1686 uint64_t num_slot,
1687 int width, int height,
1688 double x, double y,
1689 InputMultiTouchType type,
1690 Error **errp)
1691 {
1692 struct touch_slot *slot;
1693 bool needs_sync = false;
1694 int update;
1695 int i;
1696
1697 if (num_slot >= INPUT_EVENT_SLOTS_MAX) {
1698 error_setg(errp,
1699 "Unexpected touch slot number: % " PRId64" >= %d",
1700 num_slot, INPUT_EVENT_SLOTS_MAX);
1701 return;
1702 }
1703
1704 slot = &touch_slots[num_slot];
1705 slot->x = x;
1706 slot->y = y;
1707
1708 if (type == INPUT_MULTI_TOUCH_TYPE_BEGIN) {
1709 slot->tracking_id = num_slot;
1710 }
1711
1712 for (i = 0; i < INPUT_EVENT_SLOTS_MAX; ++i) {
1713 if (i == num_slot) {
1714 update = type;
1715 } else {
1716 update = INPUT_MULTI_TOUCH_TYPE_UPDATE;
1717 }
1718
1719 slot = &touch_slots[i];
1720
1721 if (slot->tracking_id == -1) {
1722 continue;
1723 }
1724
1725 if (update == INPUT_MULTI_TOUCH_TYPE_END) {
1726 slot->tracking_id = -1;
1727 qemu_input_queue_mtt(con, update, i, slot->tracking_id);
1728 needs_sync = true;
1729 } else {
1730 qemu_input_queue_mtt(con, update, i, slot->tracking_id);
1731 qemu_input_queue_btn(con, INPUT_BUTTON_TOUCH, true);
1732 qemu_input_queue_mtt_abs(con,
1733 INPUT_AXIS_X, (int) slot->x,
1734 0, width,
1735 i, slot->tracking_id);
1736 qemu_input_queue_mtt_abs(con,
1737 INPUT_AXIS_Y, (int) slot->y,
1738 0, height,
1739 i, slot->tracking_id);
1740 needs_sync = true;
1741 }
1742 }
1743
1744 if (needs_sync) {
1745 qemu_input_event_sync();
1746 }
1747 }
1748
1749 void qemu_console_set_display_gl_ctx(QemuConsole *con, DisplayGLCtx *gl)
1750 {
1751 /* display has opengl support */
1752 assert(con);
1753 if (con->gl) {
1754 error_report("The console already has an OpenGL context.");
1755 exit(1);
1756 }
1757 con->gl = gl;
1758 }
1759
1760 void register_displaychangelistener(DisplayChangeListener *dcl)
1761 {
1762 QemuConsole *con;
1763
1764 assert(!dcl->ds);
1765
1766 trace_displaychangelistener_register(dcl, dcl->ops->dpy_name);
1767 dcl->ds = get_alloc_displaystate();
1768 QLIST_INSERT_HEAD(&dcl->ds->listeners, dcl, next);
1769 gui_setup_refresh(dcl->ds);
1770 if (dcl->con) {
1771 dcl->con->dcls++;
1772 con = dcl->con;
1773 } else {
1774 con = active_console;
1775 }
1776 displaychangelistener_display_console(dcl, con, dcl->con ? &error_fatal : NULL);
1777 if (con && con->cursor && dcl->ops->dpy_cursor_define) {
1778 dcl->ops->dpy_cursor_define(dcl, con->cursor);
1779 }
1780 if (con && dcl->ops->dpy_mouse_set) {
1781 dcl->ops->dpy_mouse_set(dcl, con->cursor_x, con->cursor_y, con->cursor_on);
1782 }
1783 text_console_update_cursor(NULL);
1784 }
1785
1786 void update_displaychangelistener(DisplayChangeListener *dcl,
1787 uint64_t interval)
1788 {
1789 DisplayState *ds = dcl->ds;
1790
1791 dcl->update_interval = interval;
1792 if (!ds->refreshing && ds->update_interval > interval) {
1793 timer_mod(ds->gui_timer, ds->last_update + interval);
1794 }
1795 }
1796
1797 void unregister_displaychangelistener(DisplayChangeListener *dcl)
1798 {
1799 DisplayState *ds = dcl->ds;
1800 trace_displaychangelistener_unregister(dcl, dcl->ops->dpy_name);
1801 if (dcl->con) {
1802 dcl->con->dcls--;
1803 }
1804 QLIST_REMOVE(dcl, next);
1805 dcl->ds = NULL;
1806 gui_setup_refresh(ds);
1807 }
1808
1809 static void dpy_set_ui_info_timer(void *opaque)
1810 {
1811 QemuConsole *con = opaque;
1812
1813 con->hw_ops->ui_info(con->hw, con->head, &con->ui_info);
1814 }
1815
1816 bool dpy_ui_info_supported(QemuConsole *con)
1817 {
1818 if (con == NULL) {
1819 con = active_console;
1820 }
1821
1822 return con->hw_ops->ui_info != NULL;
1823 }
1824
1825 const QemuUIInfo *dpy_get_ui_info(const QemuConsole *con)
1826 {
1827 if (con == NULL) {
1828 con = active_console;
1829 }
1830
1831 return &con->ui_info;
1832 }
1833
1834 int dpy_set_ui_info(QemuConsole *con, QemuUIInfo *info, bool delay)
1835 {
1836 if (con == NULL) {
1837 con = active_console;
1838 }
1839
1840 if (!dpy_ui_info_supported(con)) {
1841 return -1;
1842 }
1843 if (memcmp(&con->ui_info, info, sizeof(con->ui_info)) == 0) {
1844 /* nothing changed -- ignore */
1845 return 0;
1846 }
1847
1848 /*
1849 * Typically we get a flood of these as the user resizes the window.
1850 * Wait until the dust has settled (one second without updates), then
1851 * go notify the guest.
1852 */
1853 con->ui_info = *info;
1854 timer_mod(con->ui_timer,
1855 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + (delay ? 1000 : 0));
1856 return 0;
1857 }
1858
1859 void dpy_gfx_update(QemuConsole *con, int x, int y, int w, int h)
1860 {
1861 DisplayState *s = con->ds;
1862 DisplayChangeListener *dcl;
1863 int width = qemu_console_get_width(con, x + w);
1864 int height = qemu_console_get_height(con, y + h);
1865
1866 x = MAX(x, 0);
1867 y = MAX(y, 0);
1868 x = MIN(x, width);
1869 y = MIN(y, height);
1870 w = MIN(w, width - x);
1871 h = MIN(h, height - y);
1872
1873 if (!qemu_console_is_visible(con)) {
1874 return;
1875 }
1876 dpy_gfx_update_texture(con, con->surface, x, y, w, h);
1877 QLIST_FOREACH(dcl, &s->listeners, next) {
1878 if (con != (dcl->con ? dcl->con : active_console)) {
1879 continue;
1880 }
1881 if (dcl->ops->dpy_gfx_update) {
1882 dcl->ops->dpy_gfx_update(dcl, x, y, w, h);
1883 }
1884 }
1885 }
1886
1887 void dpy_gfx_update_full(QemuConsole *con)
1888 {
1889 int w = qemu_console_get_width(con, 0);
1890 int h = qemu_console_get_height(con, 0);
1891
1892 dpy_gfx_update(con, 0, 0, w, h);
1893 }
1894
1895 void dpy_gfx_replace_surface(QemuConsole *con,
1896 DisplaySurface *surface)
1897 {
1898 static const char placeholder_msg[] = "Display output is not active.";
1899 DisplayState *s = con->ds;
1900 DisplaySurface *old_surface = con->surface;
1901 DisplaySurface *new_surface = surface;
1902 DisplayChangeListener *dcl;
1903 int width;
1904 int height;
1905
1906 if (!surface) {
1907 if (old_surface) {
1908 width = surface_width(old_surface);
1909 height = surface_height(old_surface);
1910 } else {
1911 width = 640;
1912 height = 480;
1913 }
1914
1915 new_surface = qemu_create_placeholder_surface(width, height, placeholder_msg);
1916 }
1917
1918 assert(old_surface != new_surface);
1919
1920 con->scanout.kind = SCANOUT_SURFACE;
1921 con->surface = new_surface;
1922 dpy_gfx_create_texture(con, new_surface);
1923 QLIST_FOREACH(dcl, &s->listeners, next) {
1924 if (con != (dcl->con ? dcl->con : active_console)) {
1925 continue;
1926 }
1927 displaychangelistener_gfx_switch(dcl, new_surface, surface ? FALSE : TRUE);
1928 }
1929 dpy_gfx_destroy_texture(con, old_surface);
1930 qemu_free_displaysurface(old_surface);
1931 }
1932
1933 bool dpy_gfx_check_format(QemuConsole *con,
1934 pixman_format_code_t format)
1935 {
1936 DisplayChangeListener *dcl;
1937 DisplayState *s = con->ds;
1938
1939 QLIST_FOREACH(dcl, &s->listeners, next) {
1940 if (dcl->con && dcl->con != con) {
1941 /* dcl bound to another console -> skip */
1942 continue;
1943 }
1944 if (dcl->ops->dpy_gfx_check_format) {
1945 if (!dcl->ops->dpy_gfx_check_format(dcl, format)) {
1946 return false;
1947 }
1948 } else {
1949 /* default is to allow native 32 bpp only */
1950 if (format != qemu_default_pixman_format(32, true)) {
1951 return false;
1952 }
1953 }
1954 }
1955 return true;
1956 }
1957
1958 static void dpy_refresh(DisplayState *s)
1959 {
1960 DisplayChangeListener *dcl;
1961
1962 QLIST_FOREACH(dcl, &s->listeners, next) {
1963 if (dcl->ops->dpy_refresh) {
1964 dcl->ops->dpy_refresh(dcl);
1965 }
1966 }
1967 }
1968
1969 void dpy_text_cursor(QemuConsole *con, int x, int y)
1970 {
1971 DisplayState *s = con->ds;
1972 DisplayChangeListener *dcl;
1973
1974 if (!qemu_console_is_visible(con)) {
1975 return;
1976 }
1977 QLIST_FOREACH(dcl, &s->listeners, next) {
1978 if (con != (dcl->con ? dcl->con : active_console)) {
1979 continue;
1980 }
1981 if (dcl->ops->dpy_text_cursor) {
1982 dcl->ops->dpy_text_cursor(dcl, x, y);
1983 }
1984 }
1985 }
1986
1987 void dpy_text_update(QemuConsole *con, int x, int y, int w, int h)
1988 {
1989 DisplayState *s = con->ds;
1990 DisplayChangeListener *dcl;
1991
1992 if (!qemu_console_is_visible(con)) {
1993 return;
1994 }
1995 QLIST_FOREACH(dcl, &s->listeners, next) {
1996 if (con != (dcl->con ? dcl->con : active_console)) {
1997 continue;
1998 }
1999 if (dcl->ops->dpy_text_update) {
2000 dcl->ops->dpy_text_update(dcl, x, y, w, h);
2001 }
2002 }
2003 }
2004
2005 void dpy_text_resize(QemuConsole *con, int w, int h)
2006 {
2007 DisplayState *s = con->ds;
2008 DisplayChangeListener *dcl;
2009
2010 if (!qemu_console_is_visible(con)) {
2011 return;
2012 }
2013 QLIST_FOREACH(dcl, &s->listeners, next) {
2014 if (con != (dcl->con ? dcl->con : active_console)) {
2015 continue;
2016 }
2017 if (dcl->ops->dpy_text_resize) {
2018 dcl->ops->dpy_text_resize(dcl, w, h);
2019 }
2020 }
2021 }
2022
2023 void dpy_mouse_set(QemuConsole *con, int x, int y, int on)
2024 {
2025 DisplayState *s = con->ds;
2026 DisplayChangeListener *dcl;
2027
2028 con->cursor_x = x;
2029 con->cursor_y = y;
2030 con->cursor_on = on;
2031 if (!qemu_console_is_visible(con)) {
2032 return;
2033 }
2034 QLIST_FOREACH(dcl, &s->listeners, next) {
2035 if (con != (dcl->con ? dcl->con : active_console)) {
2036 continue;
2037 }
2038 if (dcl->ops->dpy_mouse_set) {
2039 dcl->ops->dpy_mouse_set(dcl, x, y, on);
2040 }
2041 }
2042 }
2043
2044 void dpy_cursor_define(QemuConsole *con, QEMUCursor *cursor)
2045 {
2046 DisplayState *s = con->ds;
2047 DisplayChangeListener *dcl;
2048
2049 cursor_unref(con->cursor);
2050 con->cursor = cursor_ref(cursor);
2051 if (!qemu_console_is_visible(con)) {
2052 return;
2053 }
2054 QLIST_FOREACH(dcl, &s->listeners, next) {
2055 if (con != (dcl->con ? dcl->con : active_console)) {
2056 continue;
2057 }
2058 if (dcl->ops->dpy_cursor_define) {
2059 dcl->ops->dpy_cursor_define(dcl, cursor);
2060 }
2061 }
2062 }
2063
2064 bool dpy_cursor_define_supported(QemuConsole *con)
2065 {
2066 DisplayState *s = con->ds;
2067 DisplayChangeListener *dcl;
2068
2069 QLIST_FOREACH(dcl, &s->listeners, next) {
2070 if (dcl->ops->dpy_cursor_define) {
2071 return true;
2072 }
2073 }
2074 return false;
2075 }
2076
2077 QEMUGLContext dpy_gl_ctx_create(QemuConsole *con,
2078 struct QEMUGLParams *qparams)
2079 {
2080 assert(con->gl);
2081 return con->gl->ops->dpy_gl_ctx_create(con->gl, qparams);
2082 }
2083
2084 void dpy_gl_ctx_destroy(QemuConsole *con, QEMUGLContext ctx)
2085 {
2086 assert(con->gl);
2087 con->gl->ops->dpy_gl_ctx_destroy(con->gl, ctx);
2088 }
2089
2090 int dpy_gl_ctx_make_current(QemuConsole *con, QEMUGLContext ctx)
2091 {
2092 assert(con->gl);
2093 return con->gl->ops->dpy_gl_ctx_make_current(con->gl, ctx);
2094 }
2095
2096 void dpy_gl_scanout_disable(QemuConsole *con)
2097 {
2098 DisplayState *s = con->ds;
2099 DisplayChangeListener *dcl;
2100
2101 if (con->scanout.kind != SCANOUT_SURFACE) {
2102 con->scanout.kind = SCANOUT_NONE;
2103 }
2104 QLIST_FOREACH(dcl, &s->listeners, next) {
2105 if (con != (dcl->con ? dcl->con : active_console)) {
2106 continue;
2107 }
2108 if (dcl->ops->dpy_gl_scanout_disable) {
2109 dcl->ops->dpy_gl_scanout_disable(dcl);
2110 }
2111 }
2112 }
2113
2114 void dpy_gl_scanout_texture(QemuConsole *con,
2115 uint32_t backing_id,
2116 bool backing_y_0_top,
2117 uint32_t backing_width,
2118 uint32_t backing_height,
2119 uint32_t x, uint32_t y,
2120 uint32_t width, uint32_t height,
2121 void *d3d_tex2d)
2122 {
2123 DisplayState *s = con->ds;
2124 DisplayChangeListener *dcl;
2125
2126 con->scanout.kind = SCANOUT_TEXTURE;
2127 con->scanout.texture = (ScanoutTexture) {
2128 backing_id, backing_y_0_top, backing_width, backing_height,
2129 x, y, width, height, d3d_tex2d,
2130 };
2131 QLIST_FOREACH(dcl, &s->listeners, next) {
2132 if (con != (dcl->con ? dcl->con : active_console)) {
2133 continue;
2134 }
2135 if (dcl->ops->dpy_gl_scanout_texture) {
2136 dcl->ops->dpy_gl_scanout_texture(dcl, backing_id,
2137 backing_y_0_top,
2138 backing_width, backing_height,
2139 x, y, width, height,
2140 d3d_tex2d);
2141 }
2142 }
2143 }
2144
2145 void dpy_gl_scanout_dmabuf(QemuConsole *con,
2146 QemuDmaBuf *dmabuf)
2147 {
2148 DisplayState *s = con->ds;
2149 DisplayChangeListener *dcl;
2150
2151 con->scanout.kind = SCANOUT_DMABUF;
2152 con->scanout.dmabuf = dmabuf;
2153 QLIST_FOREACH(dcl, &s->listeners, next) {
2154 if (con != (dcl->con ? dcl->con : active_console)) {
2155 continue;
2156 }
2157 if (dcl->ops->dpy_gl_scanout_dmabuf) {
2158 dcl->ops->dpy_gl_scanout_dmabuf(dcl, dmabuf);
2159 }
2160 }
2161 }
2162
2163 void dpy_gl_cursor_dmabuf(QemuConsole *con, QemuDmaBuf *dmabuf,
2164 bool have_hot, uint32_t hot_x, uint32_t hot_y)
2165 {
2166 DisplayState *s = con->ds;
2167 DisplayChangeListener *dcl;
2168
2169 QLIST_FOREACH(dcl, &s->listeners, next) {
2170 if (con != (dcl->con ? dcl->con : active_console)) {
2171 continue;
2172 }
2173 if (dcl->ops->dpy_gl_cursor_dmabuf) {
2174 dcl->ops->dpy_gl_cursor_dmabuf(dcl, dmabuf,
2175 have_hot, hot_x, hot_y);
2176 }
2177 }
2178 }
2179
2180 void dpy_gl_cursor_position(QemuConsole *con,
2181 uint32_t pos_x, uint32_t pos_y)
2182 {
2183 DisplayState *s = con->ds;
2184 DisplayChangeListener *dcl;
2185
2186 QLIST_FOREACH(dcl, &s->listeners, next) {
2187 if (con != (dcl->con ? dcl->con : active_console)) {
2188 continue;
2189 }
2190 if (dcl->ops->dpy_gl_cursor_position) {
2191 dcl->ops->dpy_gl_cursor_position(dcl, pos_x, pos_y);
2192 }
2193 }
2194 }
2195
2196 void dpy_gl_release_dmabuf(QemuConsole *con,
2197 QemuDmaBuf *dmabuf)
2198 {
2199 DisplayState *s = con->ds;
2200 DisplayChangeListener *dcl;
2201
2202 QLIST_FOREACH(dcl, &s->listeners, next) {
2203 if (con != (dcl->con ? dcl->con : active_console)) {
2204 continue;
2205 }
2206 if (dcl->ops->dpy_gl_release_dmabuf) {
2207 dcl->ops->dpy_gl_release_dmabuf(dcl, dmabuf);
2208 }
2209 }
2210 }
2211
2212 void dpy_gl_update(QemuConsole *con,
2213 uint32_t x, uint32_t y, uint32_t w, uint32_t h)
2214 {
2215 DisplayState *s = con->ds;
2216 DisplayChangeListener *dcl;
2217
2218 assert(con->gl);
2219
2220 graphic_hw_gl_block(con, true);
2221 QLIST_FOREACH(dcl, &s->listeners, next) {
2222 if (con != (dcl->con ? dcl->con : active_console)) {
2223 continue;
2224 }
2225 if (dcl->ops->dpy_gl_update) {
2226 dcl->ops->dpy_gl_update(dcl, x, y, w, h);
2227 }
2228 }
2229 graphic_hw_gl_block(con, false);
2230 }
2231
2232 /***********************************************************/
2233 /* register display */
2234
2235 /* console.c internal use only */
2236 static DisplayState *get_alloc_displaystate(void)
2237 {
2238 if (!display_state) {
2239 display_state = g_new0(DisplayState, 1);
2240 cursor_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
2241 text_console_update_cursor, NULL);
2242 }
2243 return display_state;
2244 }
2245
2246 /*
2247 * Called by main(), after creating QemuConsoles
2248 * and before initializing ui (sdl/vnc/...).
2249 */
2250 DisplayState *init_displaystate(void)
2251 {
2252 gchar *name;
2253 QemuConsole *con;
2254
2255 get_alloc_displaystate();
2256 QTAILQ_FOREACH(con, &consoles, next) {
2257 if (con->console_type != GRAPHIC_CONSOLE &&
2258 con->ds == NULL) {
2259 text_console_do_init(con->chr, display_state);
2260 }
2261
2262 /* Hook up into the qom tree here (not in new_console()), once
2263 * all QemuConsoles are created and the order / numbering
2264 * doesn't change any more */
2265 name = g_strdup_printf("console[%d]", con->index);
2266 object_property_add_child(container_get(object_get_root(), "/backend"),
2267 name, OBJECT(con));
2268 g_free(name);
2269 }
2270
2271 return display_state;
2272 }
2273
2274 void graphic_console_set_hwops(QemuConsole *con,
2275 const GraphicHwOps *hw_ops,
2276 void *opaque)
2277 {
2278 con->hw_ops = hw_ops;
2279 con->hw = opaque;
2280 }
2281
2282 QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head,
2283 const GraphicHwOps *hw_ops,
2284 void *opaque)
2285 {
2286 static const char noinit[] =
2287 "Guest has not initialized the display (yet).";
2288 int width = 640;
2289 int height = 480;
2290 QemuConsole *s;
2291 DisplayState *ds;
2292 DisplaySurface *surface;
2293
2294 ds = get_alloc_displaystate();
2295 s = qemu_console_lookup_unused();
2296 if (s) {
2297 trace_console_gfx_reuse(s->index);
2298 width = qemu_console_get_width(s, 0);
2299 height = qemu_console_get_height(s, 0);
2300 } else {
2301 trace_console_gfx_new();
2302 s = new_console(ds, GRAPHIC_CONSOLE, head);
2303 s->ui_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
2304 dpy_set_ui_info_timer, s);
2305 }
2306 graphic_console_set_hwops(s, hw_ops, opaque);
2307 if (dev) {
2308 object_property_set_link(OBJECT(s), "device", OBJECT(dev),
2309 &error_abort);
2310 }
2311
2312 surface = qemu_create_placeholder_surface(width, height, noinit);
2313 dpy_gfx_replace_surface(s, surface);
2314 s->gl_unblock_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
2315 graphic_hw_gl_unblock_timer, s);
2316 return s;
2317 }
2318
2319 static const GraphicHwOps unused_ops = {
2320 /* no callbacks */
2321 };
2322
2323 void graphic_console_close(QemuConsole *con)
2324 {
2325 static const char unplugged[] =
2326 "Guest display has been unplugged";
2327 DisplaySurface *surface;
2328 int width = qemu_console_get_width(con, 640);
2329 int height = qemu_console_get_height(con, 480);
2330
2331 trace_console_gfx_close(con->index);
2332 object_property_set_link(OBJECT(con), "device", NULL, &error_abort);
2333 graphic_console_set_hwops(con, &unused_ops, NULL);
2334
2335 if (con->gl) {
2336 dpy_gl_scanout_disable(con);
2337 }
2338 surface = qemu_create_placeholder_surface(width, height, unplugged);
2339 dpy_gfx_replace_surface(con, surface);
2340 }
2341
2342 QemuConsole *qemu_console_lookup_by_index(unsigned int index)
2343 {
2344 QemuConsole *con;
2345
2346 QTAILQ_FOREACH(con, &consoles, next) {
2347 if (con->index == index) {
2348 return con;
2349 }
2350 }
2351 return NULL;
2352 }
2353
2354 QemuConsole *qemu_console_lookup_by_device(DeviceState *dev, uint32_t head)
2355 {
2356 QemuConsole *con;
2357 Object *obj;
2358 uint32_t h;
2359
2360 QTAILQ_FOREACH(con, &consoles, next) {
2361 obj = object_property_get_link(OBJECT(con),
2362 "device", &error_abort);
2363 if (DEVICE(obj) != dev) {
2364 continue;
2365 }
2366 h = object_property_get_uint(OBJECT(con),
2367 "head", &error_abort);
2368 if (h != head) {
2369 continue;
2370 }
2371 return con;
2372 }
2373 return NULL;
2374 }
2375
2376 QemuConsole *qemu_console_lookup_by_device_name(const char *device_id,
2377 uint32_t head, Error **errp)
2378 {
2379 DeviceState *dev;
2380 QemuConsole *con;
2381
2382 dev = qdev_find_recursive(sysbus_get_default(), device_id);
2383 if (dev == NULL) {
2384 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
2385 "Device '%s' not found", device_id);
2386 return NULL;
2387 }
2388
2389 con = qemu_console_lookup_by_device(dev, head);
2390 if (con == NULL) {
2391 error_setg(errp, "Device %s (head %d) is not bound to a QemuConsole",
2392 device_id, head);
2393 return NULL;
2394 }
2395
2396 return con;
2397 }
2398
2399 QemuConsole *qemu_console_lookup_unused(void)
2400 {
2401 QemuConsole *con;
2402 Object *obj;
2403
2404 QTAILQ_FOREACH(con, &consoles, next) {
2405 if (con->hw_ops != &unused_ops) {
2406 continue;
2407 }
2408 obj = object_property_get_link(OBJECT(con),
2409 "device", &error_abort);
2410 if (obj != NULL) {
2411 continue;
2412 }
2413 return con;
2414 }
2415 return NULL;
2416 }
2417
2418 QEMUCursor *qemu_console_get_cursor(QemuConsole *con)
2419 {
2420 if (con == NULL) {
2421 con = active_console;
2422 }
2423 return con ? con->cursor : NULL;
2424 }
2425
2426 bool qemu_console_is_visible(QemuConsole *con)
2427 {
2428 return (con == active_console) || (con->dcls > 0);
2429 }
2430
2431 bool qemu_console_is_graphic(QemuConsole *con)
2432 {
2433 if (con == NULL) {
2434 con = active_console;
2435 }
2436 return con && (con->console_type == GRAPHIC_CONSOLE);
2437 }
2438
2439 bool qemu_console_is_fixedsize(QemuConsole *con)
2440 {
2441 if (con == NULL) {
2442 con = active_console;
2443 }
2444 return con && (con->console_type != TEXT_CONSOLE);
2445 }
2446
2447 bool qemu_console_is_gl_blocked(QemuConsole *con)
2448 {
2449 assert(con != NULL);
2450 return con->gl_block;
2451 }
2452
2453 bool qemu_console_is_multihead(DeviceState *dev)
2454 {
2455 QemuConsole *con;
2456 Object *obj;
2457 uint32_t f = 0xffffffff;
2458 uint32_t h;
2459
2460 QTAILQ_FOREACH(con, &consoles, next) {
2461 obj = object_property_get_link(OBJECT(con),
2462 "device", &error_abort);
2463 if (DEVICE(obj) != dev) {
2464 continue;
2465 }
2466
2467 h = object_property_get_uint(OBJECT(con),
2468 "head", &error_abort);
2469 if (f == 0xffffffff) {
2470 f = h;
2471 } else if (h != f) {
2472 return true;
2473 }
2474 }
2475 return false;
2476 }
2477
2478 char *qemu_console_get_label(QemuConsole *con)
2479 {
2480 if (con->console_type == GRAPHIC_CONSOLE) {
2481 if (con->device) {
2482 DeviceState *dev;
2483 bool multihead;
2484
2485 dev = DEVICE(con->device);
2486 multihead = qemu_console_is_multihead(dev);
2487 if (multihead) {
2488 return g_strdup_printf("%s.%d", dev->id ?
2489 dev->id :
2490 object_get_typename(con->device),
2491 con->head);
2492 } else {
2493 return g_strdup_printf("%s", dev->id ?
2494 dev->id :
2495 object_get_typename(con->device));
2496 }
2497 }
2498 return g_strdup("VGA");
2499 } else {
2500 if (con->chr && con->chr->label) {
2501 return g_strdup(con->chr->label);
2502 }
2503 return g_strdup_printf("vc%d", con->index);
2504 }
2505 }
2506
2507 int qemu_console_get_index(QemuConsole *con)
2508 {
2509 if (con == NULL) {
2510 con = active_console;
2511 }
2512 return con ? con->index : -1;
2513 }
2514
2515 uint32_t qemu_console_get_head(QemuConsole *con)
2516 {
2517 if (con == NULL) {
2518 con = active_console;
2519 }
2520 return con ? con->head : -1;
2521 }
2522
2523 int qemu_console_get_width(QemuConsole *con, int fallback)
2524 {
2525 if (con == NULL) {
2526 con = active_console;
2527 }
2528 if (con == NULL) {
2529 return fallback;
2530 }
2531 switch (con->scanout.kind) {
2532 case SCANOUT_DMABUF:
2533 return con->scanout.dmabuf->width;
2534 case SCANOUT_TEXTURE:
2535 return con->scanout.texture.width;
2536 case SCANOUT_SURFACE:
2537 return surface_width(con->surface);
2538 default:
2539 return fallback;
2540 }
2541 }
2542
2543 int qemu_console_get_height(QemuConsole *con, int fallback)
2544 {
2545 if (con == NULL) {
2546 con = active_console;
2547 }
2548 if (con == NULL) {
2549 return fallback;
2550 }
2551 switch (con->scanout.kind) {
2552 case SCANOUT_DMABUF:
2553 return con->scanout.dmabuf->height;
2554 case SCANOUT_TEXTURE:
2555 return con->scanout.texture.height;
2556 case SCANOUT_SURFACE:
2557 return surface_height(con->surface);
2558 default:
2559 return fallback;
2560 }
2561 }
2562
2563 static void vc_chr_accept_input(Chardev *chr)
2564 {
2565 VCChardev *drv = VC_CHARDEV(chr);
2566 QemuConsole *s = drv->console;
2567
2568 kbd_send_chars(s);
2569 }
2570
2571 static void vc_chr_set_echo(Chardev *chr, bool echo)
2572 {
2573 VCChardev *drv = VC_CHARDEV(chr);
2574 QemuConsole *s = drv->console;
2575
2576 s->echo = echo;
2577 }
2578
2579 static void text_console_update_cursor_timer(void)
2580 {
2581 timer_mod(cursor_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME)
2582 + CONSOLE_CURSOR_PERIOD / 2);
2583 }
2584
2585 static void text_console_update_cursor(void *opaque)
2586 {
2587 QemuConsole *s;
2588 int count = 0;
2589
2590 cursor_visible_phase = !cursor_visible_phase;
2591
2592 QTAILQ_FOREACH(s, &consoles, next) {
2593 if (qemu_console_is_graphic(s) ||
2594 !qemu_console_is_visible(s)) {
2595 continue;
2596 }
2597 count++;
2598 graphic_hw_invalidate(s);
2599 }
2600
2601 if (count) {
2602 text_console_update_cursor_timer();
2603 }
2604 }
2605
2606 static const GraphicHwOps text_console_ops = {
2607 .invalidate = text_console_invalidate,
2608 .text_update = text_console_update,
2609 };
2610
2611 static void text_console_do_init(Chardev *chr, DisplayState *ds)
2612 {
2613 VCChardev *drv = VC_CHARDEV(chr);
2614 QemuConsole *s = drv->console;
2615 int g_width = 80 * FONT_WIDTH;
2616 int g_height = 24 * FONT_HEIGHT;
2617
2618 fifo8_create(&s->out_fifo, 16);
2619 s->ds = ds;
2620
2621 s->y_displayed = 0;
2622 s->y_base = 0;
2623 s->total_height = DEFAULT_BACKSCROLL;
2624 s->x = 0;
2625 s->y = 0;
2626 if (s->scanout.kind != SCANOUT_SURFACE) {
2627 if (active_console && active_console->scanout.kind == SCANOUT_SURFACE) {
2628 g_width = qemu_console_get_width(active_console, g_width);
2629 g_height = qemu_console_get_height(active_console, g_height);
2630 }
2631 s->surface = qemu_create_displaysurface(g_width, g_height);
2632 s->scanout.kind = SCANOUT_SURFACE;
2633 }
2634
2635 s->hw_ops = &text_console_ops;
2636 s->hw = s;
2637
2638 /* Set text attribute defaults */
2639 s->t_attrib_default.bold = 0;
2640 s->t_attrib_default.uline = 0;
2641 s->t_attrib_default.blink = 0;
2642 s->t_attrib_default.invers = 0;
2643 s->t_attrib_default.unvisible = 0;
2644 s->t_attrib_default.fgcol = QEMU_COLOR_WHITE;
2645 s->t_attrib_default.bgcol = QEMU_COLOR_BLACK;
2646 /* set current text attributes to default */
2647 s->t_attrib = s->t_attrib_default;
2648 text_console_resize(s);
2649
2650 if (chr->label) {
2651 char *msg;
2652
2653 s->t_attrib.bgcol = QEMU_COLOR_BLUE;
2654 msg = g_strdup_printf("%s console\r\n", chr->label);
2655 vc_chr_write(chr, (uint8_t *)msg, strlen(msg));
2656 g_free(msg);
2657 s->t_attrib = s->t_attrib_default;
2658 }
2659
2660 qemu_chr_be_event(chr, CHR_EVENT_OPENED);
2661 }
2662
2663 static void vc_chr_open(Chardev *chr,
2664 ChardevBackend *backend,
2665 bool *be_opened,
2666 Error **errp)
2667 {
2668 ChardevVC *vc = backend->u.vc.data;
2669 VCChardev *drv = VC_CHARDEV(chr);
2670 QemuConsole *s;
2671 unsigned width = 0;
2672 unsigned height = 0;
2673
2674 if (vc->has_width) {
2675 width = vc->width;
2676 } else if (vc->has_cols) {
2677 width = vc->cols * FONT_WIDTH;
2678 }
2679
2680 if (vc->has_height) {
2681 height = vc->height;
2682 } else if (vc->has_rows) {
2683 height = vc->rows * FONT_HEIGHT;
2684 }
2685
2686 trace_console_txt_new(width, height);
2687 if (width == 0 || height == 0) {
2688 s = new_console(NULL, TEXT_CONSOLE, 0);
2689 } else {
2690 s = new_console(NULL, TEXT_CONSOLE_FIXED_SIZE, 0);
2691 s->scanout.kind = SCANOUT_SURFACE;
2692 s->surface = qemu_create_displaysurface(width, height);
2693 }
2694
2695 if (!s) {
2696 error_setg(errp, "cannot create text console");
2697 return;
2698 }
2699
2700 s->chr = chr;
2701 drv->console = s;
2702
2703 if (display_state) {
2704 text_console_do_init(chr, display_state);
2705 }
2706
2707 /* console/chardev init sometimes completes elsewhere in a 2nd
2708 * stage, so defer OPENED events until they are fully initialized
2709 */
2710 *be_opened = false;
2711 }
2712
2713 void qemu_console_resize(QemuConsole *s, int width, int height)
2714 {
2715 DisplaySurface *surface = qemu_console_surface(s);
2716
2717 assert(s->console_type == GRAPHIC_CONSOLE);
2718
2719 if ((s->scanout.kind != SCANOUT_SURFACE ||
2720 (surface && surface->flags & QEMU_ALLOCATED_FLAG)) &&
2721 qemu_console_get_width(s, -1) == width &&
2722 qemu_console_get_height(s, -1) == height) {
2723 return;
2724 }
2725
2726 surface = qemu_create_displaysurface(width, height);
2727 dpy_gfx_replace_surface(s, surface);
2728 }
2729
2730 DisplaySurface *qemu_console_surface(QemuConsole *console)
2731 {
2732 switch (console->scanout.kind) {
2733 case SCANOUT_SURFACE:
2734 return console->surface;
2735 default:
2736 return NULL;
2737 }
2738 }
2739
2740 PixelFormat qemu_default_pixelformat(int bpp)
2741 {
2742 pixman_format_code_t fmt = qemu_default_pixman_format(bpp, true);
2743 PixelFormat pf = qemu_pixelformat_from_pixman(fmt);
2744 return pf;
2745 }
2746
2747 static QemuDisplay *dpys[DISPLAY_TYPE__MAX];
2748
2749 void qemu_display_register(QemuDisplay *ui)
2750 {
2751 assert(ui->type < DISPLAY_TYPE__MAX);
2752 dpys[ui->type] = ui;
2753 }
2754
2755 bool qemu_display_find_default(DisplayOptions *opts)
2756 {
2757 static DisplayType prio[] = {
2758 #if defined(CONFIG_GTK)
2759 DISPLAY_TYPE_GTK,
2760 #endif
2761 #if defined(CONFIG_SDL)
2762 DISPLAY_TYPE_SDL,
2763 #endif
2764 #if defined(CONFIG_COCOA)
2765 DISPLAY_TYPE_COCOA
2766 #endif
2767 };
2768 int i;
2769
2770 for (i = 0; i < (int)ARRAY_SIZE(prio); i++) {
2771 if (dpys[prio[i]] == NULL) {
2772 Error *local_err = NULL;
2773 int rv = ui_module_load(DisplayType_str(prio[i]), &local_err);
2774 if (rv < 0) {
2775 error_report_err(local_err);
2776 }
2777 }
2778 if (dpys[prio[i]] == NULL) {
2779 continue;
2780 }
2781 opts->type = prio[i];
2782 return true;
2783 }
2784 return false;
2785 }
2786
2787 void qemu_display_early_init(DisplayOptions *opts)
2788 {
2789 assert(opts->type < DISPLAY_TYPE__MAX);
2790 if (opts->type == DISPLAY_TYPE_NONE) {
2791 return;
2792 }
2793 if (dpys[opts->type] == NULL) {
2794 Error *local_err = NULL;
2795 int rv = ui_module_load(DisplayType_str(opts->type), &local_err);
2796 if (rv < 0) {
2797 error_report_err(local_err);
2798 }
2799 }
2800 if (dpys[opts->type] == NULL) {
2801 error_report("Display '%s' is not available.",
2802 DisplayType_str(opts->type));
2803 exit(1);
2804 }
2805 if (dpys[opts->type]->early_init) {
2806 dpys[opts->type]->early_init(opts);
2807 }
2808 }
2809
2810 void qemu_display_init(DisplayState *ds, DisplayOptions *opts)
2811 {
2812 assert(opts->type < DISPLAY_TYPE__MAX);
2813 if (opts->type == DISPLAY_TYPE_NONE) {
2814 return;
2815 }
2816 assert(dpys[opts->type] != NULL);
2817 dpys[opts->type]->init(ds, opts);
2818 }
2819
2820 void qemu_display_help(void)
2821 {
2822 int idx;
2823
2824 printf("Available display backend types:\n");
2825 printf("none\n");
2826 for (idx = DISPLAY_TYPE_NONE; idx < DISPLAY_TYPE__MAX; idx++) {
2827 if (!dpys[idx]) {
2828 Error *local_err = NULL;
2829 int rv = ui_module_load(DisplayType_str(idx), &local_err);
2830 if (rv < 0) {
2831 error_report_err(local_err);
2832 }
2833 }
2834 if (dpys[idx]) {
2835 printf("%s\n", DisplayType_str(dpys[idx]->type));
2836 }
2837 }
2838 }
2839
2840 void qemu_chr_parse_vc(QemuOpts *opts, ChardevBackend *backend, Error **errp)
2841 {
2842 int val;
2843 ChardevVC *vc;
2844
2845 backend->type = CHARDEV_BACKEND_KIND_VC;
2846 vc = backend->u.vc.data = g_new0(ChardevVC, 1);
2847 qemu_chr_parse_common(opts, qapi_ChardevVC_base(vc));
2848
2849 val = qemu_opt_get_number(opts, "width", 0);
2850 if (val != 0) {
2851 vc->has_width = true;
2852 vc->width = val;
2853 }
2854
2855 val = qemu_opt_get_number(opts, "height", 0);
2856 if (val != 0) {
2857 vc->has_height = true;
2858 vc->height = val;
2859 }
2860
2861 val = qemu_opt_get_number(opts, "cols", 0);
2862 if (val != 0) {
2863 vc->has_cols = true;
2864 vc->cols = val;
2865 }
2866
2867 val = qemu_opt_get_number(opts, "rows", 0);
2868 if (val != 0) {
2869 vc->has_rows = true;
2870 vc->rows = val;
2871 }
2872 }
2873
2874 static const TypeInfo qemu_console_info = {
2875 .name = TYPE_QEMU_CONSOLE,
2876 .parent = TYPE_OBJECT,
2877 .instance_size = sizeof(QemuConsole),
2878 .class_size = sizeof(QemuConsoleClass),
2879 };
2880
2881 static void char_vc_class_init(ObjectClass *oc, void *data)
2882 {
2883 ChardevClass *cc = CHARDEV_CLASS(oc);
2884
2885 cc->parse = qemu_chr_parse_vc;
2886 cc->open = vc_chr_open;
2887 cc->chr_write = vc_chr_write;
2888 cc->chr_accept_input = vc_chr_accept_input;
2889 cc->chr_set_echo = vc_chr_set_echo;
2890 }
2891
2892 static const TypeInfo char_vc_type_info = {
2893 .name = TYPE_CHARDEV_VC,
2894 .parent = TYPE_CHARDEV,
2895 .instance_size = sizeof(VCChardev),
2896 .class_init = char_vc_class_init,
2897 };
2898
2899 void qemu_console_early_init(void)
2900 {
2901 /* set the default vc driver */
2902 if (!object_class_by_name(TYPE_CHARDEV_VC)) {
2903 type_register(&char_vc_type_info);
2904 }
2905 }
2906
2907 static void register_types(void)
2908 {
2909 type_register_static(&qemu_console_info);
2910 }
2911
2912 type_init(register_types);
QEMU mirror