?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tests/qtest: Add xscom tests for powernv10 machine
[qemu/ar7.git] / ui / console.c
blobc1544e0fb84de664997b3af02aee35f4c19a4e02
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 DisplayChangeListener *dcl;
1902 int width;
1903 int height;
1904
1905 if (!surface) {
1906 if (old_surface) {
1907 width = surface_width(old_surface);
1908 height = surface_height(old_surface);
1909 } else {
1910 width = 640;
1911 height = 480;
1912 }
1913
1914 surface = qemu_create_placeholder_surface(width, height, placeholder_msg);
1915 }
1916
1917 assert(old_surface != surface);
1918
1919 con->scanout.kind = SCANOUT_SURFACE;
1920 con->surface = surface;
1921 dpy_gfx_create_texture(con, surface);
1922 QLIST_FOREACH(dcl, &s->listeners, next) {
1923 if (con != (dcl->con ? dcl->con : active_console)) {
1924 continue;
1925 }
1926 displaychangelistener_gfx_switch(dcl, surface, FALSE);
1927 }
1928 dpy_gfx_destroy_texture(con, old_surface);
1929 qemu_free_displaysurface(old_surface);
1930 }
1931
1932 bool dpy_gfx_check_format(QemuConsole *con,
1933 pixman_format_code_t format)
1934 {
1935 DisplayChangeListener *dcl;
1936 DisplayState *s = con->ds;
1937
1938 QLIST_FOREACH(dcl, &s->listeners, next) {
1939 if (dcl->con && dcl->con != con) {
1940 /* dcl bound to another console -> skip */
1941 continue;
1942 }
1943 if (dcl->ops->dpy_gfx_check_format) {
1944 if (!dcl->ops->dpy_gfx_check_format(dcl, format)) {
1945 return false;
1946 }
1947 } else {
1948 /* default is to allow native 32 bpp only */
1949 if (format != qemu_default_pixman_format(32, true)) {
1950 return false;
1951 }
1952 }
1953 }
1954 return true;
1955 }
1956
1957 static void dpy_refresh(DisplayState *s)
1958 {
1959 DisplayChangeListener *dcl;
1960
1961 QLIST_FOREACH(dcl, &s->listeners, next) {
1962 if (dcl->ops->dpy_refresh) {
1963 dcl->ops->dpy_refresh(dcl);
1964 }
1965 }
1966 }
1967
1968 void dpy_text_cursor(QemuConsole *con, int x, int y)
1969 {
1970 DisplayState *s = con->ds;
1971 DisplayChangeListener *dcl;
1972
1973 if (!qemu_console_is_visible(con)) {
1974 return;
1975 }
1976 QLIST_FOREACH(dcl, &s->listeners, next) {
1977 if (con != (dcl->con ? dcl->con : active_console)) {
1978 continue;
1979 }
1980 if (dcl->ops->dpy_text_cursor) {
1981 dcl->ops->dpy_text_cursor(dcl, x, y);
1982 }
1983 }
1984 }
1985
1986 void dpy_text_update(QemuConsole *con, int x, int y, int w, int h)
1987 {
1988 DisplayState *s = con->ds;
1989 DisplayChangeListener *dcl;
1990
1991 if (!qemu_console_is_visible(con)) {
1992 return;
1993 }
1994 QLIST_FOREACH(dcl, &s->listeners, next) {
1995 if (con != (dcl->con ? dcl->con : active_console)) {
1996 continue;
1997 }
1998 if (dcl->ops->dpy_text_update) {
1999 dcl->ops->dpy_text_update(dcl, x, y, w, h);
2000 }
2001 }
2002 }
2003
2004 void dpy_text_resize(QemuConsole *con, int w, int h)
2005 {
2006 DisplayState *s = con->ds;
2007 DisplayChangeListener *dcl;
2008
2009 if (!qemu_console_is_visible(con)) {
2010 return;
2011 }
2012 QLIST_FOREACH(dcl, &s->listeners, next) {
2013 if (con != (dcl->con ? dcl->con : active_console)) {
2014 continue;
2015 }
2016 if (dcl->ops->dpy_text_resize) {
2017 dcl->ops->dpy_text_resize(dcl, w, h);
2018 }
2019 }
2020 }
2021
2022 void dpy_mouse_set(QemuConsole *con, int x, int y, int on)
2023 {
2024 DisplayState *s = con->ds;
2025 DisplayChangeListener *dcl;
2026
2027 con->cursor_x = x;
2028 con->cursor_y = y;
2029 con->cursor_on = on;
2030 if (!qemu_console_is_visible(con)) {
2031 return;
2032 }
2033 QLIST_FOREACH(dcl, &s->listeners, next) {
2034 if (con != (dcl->con ? dcl->con : active_console)) {
2035 continue;
2036 }
2037 if (dcl->ops->dpy_mouse_set) {
2038 dcl->ops->dpy_mouse_set(dcl, x, y, on);
2039 }
2040 }
2041 }
2042
2043 void dpy_cursor_define(QemuConsole *con, QEMUCursor *cursor)
2044 {
2045 DisplayState *s = con->ds;
2046 DisplayChangeListener *dcl;
2047
2048 cursor_unref(con->cursor);
2049 con->cursor = cursor_ref(cursor);
2050 if (!qemu_console_is_visible(con)) {
2051 return;
2052 }
2053 QLIST_FOREACH(dcl, &s->listeners, next) {
2054 if (con != (dcl->con ? dcl->con : active_console)) {
2055 continue;
2056 }
2057 if (dcl->ops->dpy_cursor_define) {
2058 dcl->ops->dpy_cursor_define(dcl, cursor);
2059 }
2060 }
2061 }
2062
2063 bool dpy_cursor_define_supported(QemuConsole *con)
2064 {
2065 DisplayState *s = con->ds;
2066 DisplayChangeListener *dcl;
2067
2068 QLIST_FOREACH(dcl, &s->listeners, next) {
2069 if (dcl->ops->dpy_cursor_define) {
2070 return true;
2071 }
2072 }
2073 return false;
2074 }
2075
2076 QEMUGLContext dpy_gl_ctx_create(QemuConsole *con,
2077 struct QEMUGLParams *qparams)
2078 {
2079 assert(con->gl);
2080 return con->gl->ops->dpy_gl_ctx_create(con->gl, qparams);
2081 }
2082
2083 void dpy_gl_ctx_destroy(QemuConsole *con, QEMUGLContext ctx)
2084 {
2085 assert(con->gl);
2086 con->gl->ops->dpy_gl_ctx_destroy(con->gl, ctx);
2087 }
2088
2089 int dpy_gl_ctx_make_current(QemuConsole *con, QEMUGLContext ctx)
2090 {
2091 assert(con->gl);
2092 return con->gl->ops->dpy_gl_ctx_make_current(con->gl, ctx);
2093 }
2094
2095 void dpy_gl_scanout_disable(QemuConsole *con)
2096 {
2097 DisplayState *s = con->ds;
2098 DisplayChangeListener *dcl;
2099
2100 if (con->scanout.kind != SCANOUT_SURFACE) {
2101 con->scanout.kind = SCANOUT_NONE;
2102 }
2103 QLIST_FOREACH(dcl, &s->listeners, next) {
2104 if (con != (dcl->con ? dcl->con : active_console)) {
2105 continue;
2106 }
2107 if (dcl->ops->dpy_gl_scanout_disable) {
2108 dcl->ops->dpy_gl_scanout_disable(dcl);
2109 }
2110 }
2111 }
2112
2113 void dpy_gl_scanout_texture(QemuConsole *con,
2114 uint32_t backing_id,
2115 bool backing_y_0_top,
2116 uint32_t backing_width,
2117 uint32_t backing_height,
2118 uint32_t x, uint32_t y,
2119 uint32_t width, uint32_t height,
2120 void *d3d_tex2d)
2121 {
2122 DisplayState *s = con->ds;
2123 DisplayChangeListener *dcl;
2124
2125 con->scanout.kind = SCANOUT_TEXTURE;
2126 con->scanout.texture = (ScanoutTexture) {
2127 backing_id, backing_y_0_top, backing_width, backing_height,
2128 x, y, width, height, d3d_tex2d,
2129 };
2130 QLIST_FOREACH(dcl, &s->listeners, next) {
2131 if (con != (dcl->con ? dcl->con : active_console)) {
2132 continue;
2133 }
2134 if (dcl->ops->dpy_gl_scanout_texture) {
2135 dcl->ops->dpy_gl_scanout_texture(dcl, backing_id,
2136 backing_y_0_top,
2137 backing_width, backing_height,
2138 x, y, width, height,
2139 d3d_tex2d);
2140 }
2141 }
2142 }
2143
2144 void dpy_gl_scanout_dmabuf(QemuConsole *con,
2145 QemuDmaBuf *dmabuf)
2146 {
2147 DisplayState *s = con->ds;
2148 DisplayChangeListener *dcl;
2149
2150 con->scanout.kind = SCANOUT_DMABUF;
2151 con->scanout.dmabuf = dmabuf;
2152 QLIST_FOREACH(dcl, &s->listeners, next) {
2153 if (con != (dcl->con ? dcl->con : active_console)) {
2154 continue;
2155 }
2156 if (dcl->ops->dpy_gl_scanout_dmabuf) {
2157 dcl->ops->dpy_gl_scanout_dmabuf(dcl, dmabuf);
2158 }
2159 }
2160 }
2161
2162 void dpy_gl_cursor_dmabuf(QemuConsole *con, QemuDmaBuf *dmabuf,
2163 bool have_hot, uint32_t hot_x, uint32_t hot_y)
2164 {
2165 DisplayState *s = con->ds;
2166 DisplayChangeListener *dcl;
2167
2168 QLIST_FOREACH(dcl, &s->listeners, next) {
2169 if (con != (dcl->con ? dcl->con : active_console)) {
2170 continue;
2171 }
2172 if (dcl->ops->dpy_gl_cursor_dmabuf) {
2173 dcl->ops->dpy_gl_cursor_dmabuf(dcl, dmabuf,
2174 have_hot, hot_x, hot_y);
2175 }
2176 }
2177 }
2178
2179 void dpy_gl_cursor_position(QemuConsole *con,
2180 uint32_t pos_x, uint32_t pos_y)
2181 {
2182 DisplayState *s = con->ds;
2183 DisplayChangeListener *dcl;
2184
2185 QLIST_FOREACH(dcl, &s->listeners, next) {
2186 if (con != (dcl->con ? dcl->con : active_console)) {
2187 continue;
2188 }
2189 if (dcl->ops->dpy_gl_cursor_position) {
2190 dcl->ops->dpy_gl_cursor_position(dcl, pos_x, pos_y);
2191 }
2192 }
2193 }
2194
2195 void dpy_gl_release_dmabuf(QemuConsole *con,
2196 QemuDmaBuf *dmabuf)
2197 {
2198 DisplayState *s = con->ds;
2199 DisplayChangeListener *dcl;
2200
2201 QLIST_FOREACH(dcl, &s->listeners, next) {
2202 if (con != (dcl->con ? dcl->con : active_console)) {
2203 continue;
2204 }
2205 if (dcl->ops->dpy_gl_release_dmabuf) {
2206 dcl->ops->dpy_gl_release_dmabuf(dcl, dmabuf);
2207 }
2208 }
2209 }
2210
2211 void dpy_gl_update(QemuConsole *con,
2212 uint32_t x, uint32_t y, uint32_t w, uint32_t h)
2213 {
2214 DisplayState *s = con->ds;
2215 DisplayChangeListener *dcl;
2216
2217 assert(con->gl);
2218
2219 graphic_hw_gl_block(con, true);
2220 QLIST_FOREACH(dcl, &s->listeners, next) {
2221 if (con != (dcl->con ? dcl->con : active_console)) {
2222 continue;
2223 }
2224 if (dcl->ops->dpy_gl_update) {
2225 dcl->ops->dpy_gl_update(dcl, x, y, w, h);
2226 }
2227 }
2228 graphic_hw_gl_block(con, false);
2229 }
2230
2231 /***********************************************************/
2232 /* register display */
2233
2234 /* console.c internal use only */
2235 static DisplayState *get_alloc_displaystate(void)
2236 {
2237 if (!display_state) {
2238 display_state = g_new0(DisplayState, 1);
2239 cursor_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
2240 text_console_update_cursor, NULL);
2241 }
2242 return display_state;
2243 }
2244
2245 /*
2246 * Called by main(), after creating QemuConsoles
2247 * and before initializing ui (sdl/vnc/...).
2248 */
2249 DisplayState *init_displaystate(void)
2250 {
2251 gchar *name;
2252 QemuConsole *con;
2253
2254 get_alloc_displaystate();
2255 QTAILQ_FOREACH(con, &consoles, next) {
2256 if (con->console_type != GRAPHIC_CONSOLE &&
2257 con->ds == NULL) {
2258 text_console_do_init(con->chr, display_state);
2259 }
2260
2261 /* Hook up into the qom tree here (not in new_console()), once
2262 * all QemuConsoles are created and the order / numbering
2263 * doesn't change any more */
2264 name = g_strdup_printf("console[%d]", con->index);
2265 object_property_add_child(container_get(object_get_root(), "/backend"),
2266 name, OBJECT(con));
2267 g_free(name);
2268 }
2269
2270 return display_state;
2271 }
2272
2273 void graphic_console_set_hwops(QemuConsole *con,
2274 const GraphicHwOps *hw_ops,
2275 void *opaque)
2276 {
2277 con->hw_ops = hw_ops;
2278 con->hw = opaque;
2279 }
2280
2281 QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head,
2282 const GraphicHwOps *hw_ops,
2283 void *opaque)
2284 {
2285 static const char noinit[] =
2286 "Guest has not initialized the display (yet).";
2287 int width = 640;
2288 int height = 480;
2289 QemuConsole *s;
2290 DisplayState *ds;
2291 DisplaySurface *surface;
2292
2293 ds = get_alloc_displaystate();
2294 s = qemu_console_lookup_unused();
2295 if (s) {
2296 trace_console_gfx_reuse(s->index);
2297 width = qemu_console_get_width(s, 0);
2298 height = qemu_console_get_height(s, 0);
2299 } else {
2300 trace_console_gfx_new();
2301 s = new_console(ds, GRAPHIC_CONSOLE, head);
2302 s->ui_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
2303 dpy_set_ui_info_timer, s);
2304 }
2305 graphic_console_set_hwops(s, hw_ops, opaque);
2306 if (dev) {
2307 object_property_set_link(OBJECT(s), "device", OBJECT(dev),
2308 &error_abort);
2309 }
2310
2311 surface = qemu_create_placeholder_surface(width, height, noinit);
2312 dpy_gfx_replace_surface(s, surface);
2313 s->gl_unblock_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
2314 graphic_hw_gl_unblock_timer, s);
2315 return s;
2316 }
2317
2318 static const GraphicHwOps unused_ops = {
2319 /* no callbacks */
2320 };
2321
2322 void graphic_console_close(QemuConsole *con)
2323 {
2324 static const char unplugged[] =
2325 "Guest display has been unplugged";
2326 DisplaySurface *surface;
2327 int width = qemu_console_get_width(con, 640);
2328 int height = qemu_console_get_height(con, 480);
2329
2330 trace_console_gfx_close(con->index);
2331 object_property_set_link(OBJECT(con), "device", NULL, &error_abort);
2332 graphic_console_set_hwops(con, &unused_ops, NULL);
2333
2334 if (con->gl) {
2335 dpy_gl_scanout_disable(con);
2336 }
2337 surface = qemu_create_placeholder_surface(width, height, unplugged);
2338 dpy_gfx_replace_surface(con, surface);
2339 }
2340
2341 QemuConsole *qemu_console_lookup_by_index(unsigned int index)
2342 {
2343 QemuConsole *con;
2344
2345 QTAILQ_FOREACH(con, &consoles, next) {
2346 if (con->index == index) {
2347 return con;
2348 }
2349 }
2350 return NULL;
2351 }
2352
2353 QemuConsole *qemu_console_lookup_by_device(DeviceState *dev, uint32_t head)
2354 {
2355 QemuConsole *con;
2356 Object *obj;
2357 uint32_t h;
2358
2359 QTAILQ_FOREACH(con, &consoles, next) {
2360 obj = object_property_get_link(OBJECT(con),
2361 "device", &error_abort);
2362 if (DEVICE(obj) != dev) {
2363 continue;
2364 }
2365 h = object_property_get_uint(OBJECT(con),
2366 "head", &error_abort);
2367 if (h != head) {
2368 continue;
2369 }
2370 return con;
2371 }
2372 return NULL;
2373 }
2374
2375 QemuConsole *qemu_console_lookup_by_device_name(const char *device_id,
2376 uint32_t head, Error **errp)
2377 {
2378 DeviceState *dev;
2379 QemuConsole *con;
2380
2381 dev = qdev_find_recursive(sysbus_get_default(), device_id);
2382 if (dev == NULL) {
2383 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
2384 "Device '%s' not found", device_id);
2385 return NULL;
2386 }
2387
2388 con = qemu_console_lookup_by_device(dev, head);
2389 if (con == NULL) {
2390 error_setg(errp, "Device %s (head %d) is not bound to a QemuConsole",
2391 device_id, head);
2392 return NULL;
2393 }
2394
2395 return con;
2396 }
2397
2398 QemuConsole *qemu_console_lookup_unused(void)
2399 {
2400 QemuConsole *con;
2401 Object *obj;
2402
2403 QTAILQ_FOREACH(con, &consoles, next) {
2404 if (con->hw_ops != &unused_ops) {
2405 continue;
2406 }
2407 obj = object_property_get_link(OBJECT(con),
2408 "device", &error_abort);
2409 if (obj != NULL) {
2410 continue;
2411 }
2412 return con;
2413 }
2414 return NULL;
2415 }
2416
2417 QEMUCursor *qemu_console_get_cursor(QemuConsole *con)
2418 {
2419 if (con == NULL) {
2420 con = active_console;
2421 }
2422 return con ? con->cursor : NULL;
2423 }
2424
2425 bool qemu_console_is_visible(QemuConsole *con)
2426 {
2427 return (con == active_console) || (con->dcls > 0);
2428 }
2429
2430 bool qemu_console_is_graphic(QemuConsole *con)
2431 {
2432 if (con == NULL) {
2433 con = active_console;
2434 }
2435 return con && (con->console_type == GRAPHIC_CONSOLE);
2436 }
2437
2438 bool qemu_console_is_fixedsize(QemuConsole *con)
2439 {
2440 if (con == NULL) {
2441 con = active_console;
2442 }
2443 return con && (con->console_type != TEXT_CONSOLE);
2444 }
2445
2446 bool qemu_console_is_gl_blocked(QemuConsole *con)
2447 {
2448 assert(con != NULL);
2449 return con->gl_block;
2450 }
2451
2452 bool qemu_console_is_multihead(DeviceState *dev)
2453 {
2454 QemuConsole *con;
2455 Object *obj;
2456 uint32_t f = 0xffffffff;
2457 uint32_t h;
2458
2459 QTAILQ_FOREACH(con, &consoles, next) {
2460 obj = object_property_get_link(OBJECT(con),
2461 "device", &error_abort);
2462 if (DEVICE(obj) != dev) {
2463 continue;
2464 }
2465
2466 h = object_property_get_uint(OBJECT(con),
2467 "head", &error_abort);
2468 if (f == 0xffffffff) {
2469 f = h;
2470 } else if (h != f) {
2471 return true;
2472 }
2473 }
2474 return false;
2475 }
2476
2477 char *qemu_console_get_label(QemuConsole *con)
2478 {
2479 if (con->console_type == GRAPHIC_CONSOLE) {
2480 if (con->device) {
2481 DeviceState *dev;
2482 bool multihead;
2483
2484 dev = DEVICE(con->device);
2485 multihead = qemu_console_is_multihead(dev);
2486 if (multihead) {
2487 return g_strdup_printf("%s.%d", dev->id ?
2488 dev->id :
2489 object_get_typename(con->device),
2490 con->head);
2491 } else {
2492 return g_strdup_printf("%s", dev->id ?
2493 dev->id :
2494 object_get_typename(con->device));
2495 }
2496 }
2497 return g_strdup("VGA");
2498 } else {
2499 if (con->chr && con->chr->label) {
2500 return g_strdup(con->chr->label);
2501 }
2502 return g_strdup_printf("vc%d", con->index);
2503 }
2504 }
2505
2506 int qemu_console_get_index(QemuConsole *con)
2507 {
2508 if (con == NULL) {
2509 con = active_console;
2510 }
2511 return con ? con->index : -1;
2512 }
2513
2514 uint32_t qemu_console_get_head(QemuConsole *con)
2515 {
2516 if (con == NULL) {
2517 con = active_console;
2518 }
2519 return con ? con->head : -1;
2520 }
2521
2522 int qemu_console_get_width(QemuConsole *con, int fallback)
2523 {
2524 if (con == NULL) {
2525 con = active_console;
2526 }
2527 if (con == NULL) {
2528 return fallback;
2529 }
2530 switch (con->scanout.kind) {
2531 case SCANOUT_DMABUF:
2532 return con->scanout.dmabuf->width;
2533 case SCANOUT_TEXTURE:
2534 return con->scanout.texture.width;
2535 case SCANOUT_SURFACE:
2536 return surface_width(con->surface);
2537 default:
2538 return fallback;
2539 }
2540 }
2541
2542 int qemu_console_get_height(QemuConsole *con, int fallback)
2543 {
2544 if (con == NULL) {
2545 con = active_console;
2546 }
2547 if (con == NULL) {
2548 return fallback;
2549 }
2550 switch (con->scanout.kind) {
2551 case SCANOUT_DMABUF:
2552 return con->scanout.dmabuf->height;
2553 case SCANOUT_TEXTURE:
2554 return con->scanout.texture.height;
2555 case SCANOUT_SURFACE:
2556 return surface_height(con->surface);
2557 default:
2558 return fallback;
2559 }
2560 }
2561
2562 static void vc_chr_accept_input(Chardev *chr)
2563 {
2564 VCChardev *drv = VC_CHARDEV(chr);
2565 QemuConsole *s = drv->console;
2566
2567 kbd_send_chars(s);
2568 }
2569
2570 static void vc_chr_set_echo(Chardev *chr, bool echo)
2571 {
2572 VCChardev *drv = VC_CHARDEV(chr);
2573 QemuConsole *s = drv->console;
2574
2575 s->echo = echo;
2576 }
2577
2578 static void text_console_update_cursor_timer(void)
2579 {
2580 timer_mod(cursor_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME)
2581 + CONSOLE_CURSOR_PERIOD / 2);
2582 }
2583
2584 static void text_console_update_cursor(void *opaque)
2585 {
2586 QemuConsole *s;
2587 int count = 0;
2588
2589 cursor_visible_phase = !cursor_visible_phase;
2590
2591 QTAILQ_FOREACH(s, &consoles, next) {
2592 if (qemu_console_is_graphic(s) ||
2593 !qemu_console_is_visible(s)) {
2594 continue;
2595 }
2596 count++;
2597 graphic_hw_invalidate(s);
2598 }
2599
2600 if (count) {
2601 text_console_update_cursor_timer();
2602 }
2603 }
2604
2605 static const GraphicHwOps text_console_ops = {
2606 .invalidate = text_console_invalidate,
2607 .text_update = text_console_update,
2608 };
2609
2610 static void text_console_do_init(Chardev *chr, DisplayState *ds)
2611 {
2612 VCChardev *drv = VC_CHARDEV(chr);
2613 QemuConsole *s = drv->console;
2614 int g_width = 80 * FONT_WIDTH;
2615 int g_height = 24 * FONT_HEIGHT;
2616
2617 fifo8_create(&s->out_fifo, 16);
2618 s->ds = ds;
2619
2620 s->y_displayed = 0;
2621 s->y_base = 0;
2622 s->total_height = DEFAULT_BACKSCROLL;
2623 s->x = 0;
2624 s->y = 0;
2625 if (s->scanout.kind != SCANOUT_SURFACE) {
2626 if (active_console && active_console->scanout.kind == SCANOUT_SURFACE) {
2627 g_width = qemu_console_get_width(active_console, g_width);
2628 g_height = qemu_console_get_height(active_console, g_height);
2629 }
2630 s->surface = qemu_create_displaysurface(g_width, g_height);
2631 s->scanout.kind = SCANOUT_SURFACE;
2632 }
2633
2634 s->hw_ops = &text_console_ops;
2635 s->hw = s;
2636
2637 /* Set text attribute defaults */
2638 s->t_attrib_default.bold = 0;
2639 s->t_attrib_default.uline = 0;
2640 s->t_attrib_default.blink = 0;
2641 s->t_attrib_default.invers = 0;
2642 s->t_attrib_default.unvisible = 0;
2643 s->t_attrib_default.fgcol = QEMU_COLOR_WHITE;
2644 s->t_attrib_default.bgcol = QEMU_COLOR_BLACK;
2645 /* set current text attributes to default */
2646 s->t_attrib = s->t_attrib_default;
2647 text_console_resize(s);
2648
2649 if (chr->label) {
2650 char *msg;
2651
2652 s->t_attrib.bgcol = QEMU_COLOR_BLUE;
2653 msg = g_strdup_printf("%s console\r\n", chr->label);
2654 vc_chr_write(chr, (uint8_t *)msg, strlen(msg));
2655 g_free(msg);
2656 s->t_attrib = s->t_attrib_default;
2657 }
2658
2659 qemu_chr_be_event(chr, CHR_EVENT_OPENED);
2660 }
2661
2662 static void vc_chr_open(Chardev *chr,
2663 ChardevBackend *backend,
2664 bool *be_opened,
2665 Error **errp)
2666 {
2667 ChardevVC *vc = backend->u.vc.data;
2668 VCChardev *drv = VC_CHARDEV(chr);
2669 QemuConsole *s;
2670 unsigned width = 0;
2671 unsigned height = 0;
2672
2673 if (vc->has_width) {
2674 width = vc->width;
2675 } else if (vc->has_cols) {
2676 width = vc->cols * FONT_WIDTH;
2677 }
2678
2679 if (vc->has_height) {
2680 height = vc->height;
2681 } else if (vc->has_rows) {
2682 height = vc->rows * FONT_HEIGHT;
2683 }
2684
2685 trace_console_txt_new(width, height);
2686 if (width == 0 || height == 0) {
2687 s = new_console(NULL, TEXT_CONSOLE, 0);
2688 } else {
2689 s = new_console(NULL, TEXT_CONSOLE_FIXED_SIZE, 0);
2690 s->scanout.kind = SCANOUT_SURFACE;
2691 s->surface = qemu_create_displaysurface(width, height);
2692 }
2693
2694 if (!s) {
2695 error_setg(errp, "cannot create text console");
2696 return;
2697 }
2698
2699 s->chr = chr;
2700 drv->console = s;
2701
2702 if (display_state) {
2703 text_console_do_init(chr, display_state);
2704 }
2705
2706 /* console/chardev init sometimes completes elsewhere in a 2nd
2707 * stage, so defer OPENED events until they are fully initialized
2708 */
2709 *be_opened = false;
2710 }
2711
2712 void qemu_console_resize(QemuConsole *s, int width, int height)
2713 {
2714 DisplaySurface *surface = qemu_console_surface(s);
2715
2716 assert(s->console_type == GRAPHIC_CONSOLE);
2717
2718 if ((s->scanout.kind != SCANOUT_SURFACE ||
2719 (surface && surface->flags & QEMU_ALLOCATED_FLAG)) &&
2720 qemu_console_get_width(s, -1) == width &&
2721 qemu_console_get_height(s, -1) == height) {
2722 return;
2723 }
2724
2725 surface = qemu_create_displaysurface(width, height);
2726 dpy_gfx_replace_surface(s, surface);
2727 }
2728
2729 DisplaySurface *qemu_console_surface(QemuConsole *console)
2730 {
2731 switch (console->scanout.kind) {
2732 case SCANOUT_SURFACE:
2733 return console->surface;
2734 default:
2735 return NULL;
2736 }
2737 }
2738
2739 PixelFormat qemu_default_pixelformat(int bpp)
2740 {
2741 pixman_format_code_t fmt = qemu_default_pixman_format(bpp, true);
2742 PixelFormat pf = qemu_pixelformat_from_pixman(fmt);
2743 return pf;
2744 }
2745
2746 static QemuDisplay *dpys[DISPLAY_TYPE__MAX];
2747
2748 void qemu_display_register(QemuDisplay *ui)
2749 {
2750 assert(ui->type < DISPLAY_TYPE__MAX);
2751 dpys[ui->type] = ui;
2752 }
2753
2754 bool qemu_display_find_default(DisplayOptions *opts)
2755 {
2756 static DisplayType prio[] = {
2757 #if defined(CONFIG_GTK)
2758 DISPLAY_TYPE_GTK,
2759 #endif
2760 #if defined(CONFIG_SDL)
2761 DISPLAY_TYPE_SDL,
2762 #endif
2763 #if defined(CONFIG_COCOA)
2764 DISPLAY_TYPE_COCOA
2765 #endif
2766 };
2767 int i;
2768
2769 for (i = 0; i < (int)ARRAY_SIZE(prio); i++) {
2770 if (dpys[prio[i]] == NULL) {
2771 Error *local_err = NULL;
2772 int rv = ui_module_load(DisplayType_str(prio[i]), &local_err);
2773 if (rv < 0) {
2774 error_report_err(local_err);
2775 }
2776 }
2777 if (dpys[prio[i]] == NULL) {
2778 continue;
2779 }
2780 opts->type = prio[i];
2781 return true;
2782 }
2783 return false;
2784 }
2785
2786 void qemu_display_early_init(DisplayOptions *opts)
2787 {
2788 assert(opts->type < DISPLAY_TYPE__MAX);
2789 if (opts->type == DISPLAY_TYPE_NONE) {
2790 return;
2791 }
2792 if (dpys[opts->type] == NULL) {
2793 Error *local_err = NULL;
2794 int rv = ui_module_load(DisplayType_str(opts->type), &local_err);
2795 if (rv < 0) {
2796 error_report_err(local_err);
2797 }
2798 }
2799 if (dpys[opts->type] == NULL) {
2800 error_report("Display '%s' is not available.",
2801 DisplayType_str(opts->type));
2802 exit(1);
2803 }
2804 if (dpys[opts->type]->early_init) {
2805 dpys[opts->type]->early_init(opts);
2806 }
2807 }
2808
2809 void qemu_display_init(DisplayState *ds, DisplayOptions *opts)
2810 {
2811 assert(opts->type < DISPLAY_TYPE__MAX);
2812 if (opts->type == DISPLAY_TYPE_NONE) {
2813 return;
2814 }
2815 assert(dpys[opts->type] != NULL);
2816 dpys[opts->type]->init(ds, opts);
2817 }
2818
2819 void qemu_display_help(void)
2820 {
2821 int idx;
2822
2823 printf("Available display backend types:\n");
2824 printf("none\n");
2825 for (idx = DISPLAY_TYPE_NONE; idx < DISPLAY_TYPE__MAX; idx++) {
2826 if (!dpys[idx]) {
2827 Error *local_err = NULL;
2828 int rv = ui_module_load(DisplayType_str(idx), &local_err);
2829 if (rv < 0) {
2830 error_report_err(local_err);
2831 }
2832 }
2833 if (dpys[idx]) {
2834 printf("%s\n", DisplayType_str(dpys[idx]->type));
2835 }
2836 }
2837 }
2838
2839 void qemu_chr_parse_vc(QemuOpts *opts, ChardevBackend *backend, Error **errp)
2840 {
2841 int val;
2842 ChardevVC *vc;
2843
2844 backend->type = CHARDEV_BACKEND_KIND_VC;
2845 vc = backend->u.vc.data = g_new0(ChardevVC, 1);
2846 qemu_chr_parse_common(opts, qapi_ChardevVC_base(vc));
2847
2848 val = qemu_opt_get_number(opts, "width", 0);
2849 if (val != 0) {
2850 vc->has_width = true;
2851 vc->width = val;
2852 }
2853
2854 val = qemu_opt_get_number(opts, "height", 0);
2855 if (val != 0) {
2856 vc->has_height = true;
2857 vc->height = val;
2858 }
2859
2860 val = qemu_opt_get_number(opts, "cols", 0);
2861 if (val != 0) {
2862 vc->has_cols = true;
2863 vc->cols = val;
2864 }
2865
2866 val = qemu_opt_get_number(opts, "rows", 0);
2867 if (val != 0) {
2868 vc->has_rows = true;
2869 vc->rows = val;
2870 }
2871 }
2872
2873 static const TypeInfo qemu_console_info = {
2874 .name = TYPE_QEMU_CONSOLE,
2875 .parent = TYPE_OBJECT,
2876 .instance_size = sizeof(QemuConsole),
2877 .class_size = sizeof(QemuConsoleClass),
2878 };
2879
2880 static void char_vc_class_init(ObjectClass *oc, void *data)
2881 {
2882 ChardevClass *cc = CHARDEV_CLASS(oc);
2883
2884 cc->parse = qemu_chr_parse_vc;
2885 cc->open = vc_chr_open;
2886 cc->chr_write = vc_chr_write;
2887 cc->chr_accept_input = vc_chr_accept_input;
2888 cc->chr_set_echo = vc_chr_set_echo;
2889 }
2890
2891 static const TypeInfo char_vc_type_info = {
2892 .name = TYPE_CHARDEV_VC,
2893 .parent = TYPE_CHARDEV,
2894 .instance_size = sizeof(VCChardev),
2895 .class_init = char_vc_class_init,
2896 };
2897
2898 void qemu_console_early_init(void)
2899 {
2900 /* set the default vc driver */
2901 if (!object_class_by_name(TYPE_CHARDEV_VC)) {
2902 type_register(&char_vc_type_info);
2903 }
2904 }
2905
2906 static void register_types(void)
2907 {
2908 type_register_static(&qemu_console_info);
2909 }
2910
2911 type_init(register_types);
AR7 emulation for QEMU