?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
target/arm: Allow users to set the number of VFP registers
[qemu/kevin.git] / ui / console.c
blobe173731e2056a0edf1bedc6b1934e322da7fbe42
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 }
1228 }
1229
1230 void console_select(unsigned int index)
1231 {
1232 DisplayChangeListener *dcl;
1233 QemuConsole *s;
1234
1235 trace_console_select(index);
1236 s = qemu_console_lookup_by_index(index);
1237 if (s) {
1238 DisplayState *ds = s->ds;
1239
1240 active_console = s;
1241 if (ds->have_gfx) {
1242 QLIST_FOREACH(dcl, &ds->listeners, next) {
1243 if (dcl->con != NULL) {
1244 continue;
1245 }
1246 displaychangelistener_display_console(dcl, s, NULL);
1247 }
1248 }
1249 if (ds->have_text) {
1250 dpy_text_resize(s, s->width, s->height);
1251 }
1252 text_console_update_cursor(NULL);
1253 }
1254 }
1255
1256 struct VCChardev {
1257 Chardev parent;
1258 QemuConsole *console;
1259 };
1260 typedef struct VCChardev VCChardev;
1261
1262 #define TYPE_CHARDEV_VC "chardev-vc"
1263 DECLARE_INSTANCE_CHECKER(VCChardev, VC_CHARDEV,
1264 TYPE_CHARDEV_VC)
1265
1266 static int vc_chr_write(Chardev *chr, const uint8_t *buf, int len)
1267 {
1268 VCChardev *drv = VC_CHARDEV(chr);
1269 QemuConsole *s = drv->console;
1270 int i;
1271
1272 if (!s->ds) {
1273 return 0;
1274 }
1275
1276 s->update_x0 = s->width * FONT_WIDTH;
1277 s->update_y0 = s->height * FONT_HEIGHT;
1278 s->update_x1 = 0;
1279 s->update_y1 = 0;
1280 console_show_cursor(s, 0);
1281 for(i = 0; i < len; i++) {
1282 console_putchar(s, buf[i]);
1283 }
1284 console_show_cursor(s, 1);
1285 if (s->ds->have_gfx && s->update_x0 < s->update_x1) {
1286 dpy_gfx_update(s, s->update_x0, s->update_y0,
1287 s->update_x1 - s->update_x0,
1288 s->update_y1 - s->update_y0);
1289 }
1290 return len;
1291 }
1292
1293 static void kbd_send_chars(QemuConsole *s)
1294 {
1295 uint32_t len, avail;
1296
1297 len = qemu_chr_be_can_write(s->chr);
1298 avail = fifo8_num_used(&s->out_fifo);
1299 while (len > 0 && avail > 0) {
1300 const uint8_t *buf;
1301 uint32_t size;
1302
1303 buf = fifo8_pop_buf(&s->out_fifo, MIN(len, avail), &size);
1304 qemu_chr_be_write(s->chr, buf, size);
1305 len = qemu_chr_be_can_write(s->chr);
1306 avail -= size;
1307 }
1308 }
1309
1310 /* called when an ascii key is pressed */
1311 void kbd_put_keysym_console(QemuConsole *s, int keysym)
1312 {
1313 uint8_t buf[16], *q;
1314 int c;
1315 uint32_t num_free;
1316
1317 if (!s || (s->console_type == GRAPHIC_CONSOLE))
1318 return;
1319
1320 switch(keysym) {
1321 case QEMU_KEY_CTRL_UP:
1322 console_scroll(s, -1);
1323 break;
1324 case QEMU_KEY_CTRL_DOWN:
1325 console_scroll(s, 1);
1326 break;
1327 case QEMU_KEY_CTRL_PAGEUP:
1328 console_scroll(s, -10);
1329 break;
1330 case QEMU_KEY_CTRL_PAGEDOWN:
1331 console_scroll(s, 10);
1332 break;
1333 default:
1334 /* convert the QEMU keysym to VT100 key string */
1335 q = buf;
1336 if (keysym >= 0xe100 && keysym <= 0xe11f) {
1337 *q++ = '\033';
1338 *q++ = '[';
1339 c = keysym - 0xe100;
1340 if (c >= 10)
1341 *q++ = '0' + (c / 10);
1342 *q++ = '0' + (c % 10);
1343 *q++ = '~';
1344 } else if (keysym >= 0xe120 && keysym <= 0xe17f) {
1345 *q++ = '\033';
1346 *q++ = '[';
1347 *q++ = keysym & 0xff;
1348 } else if (s->echo && (keysym == '\r' || keysym == '\n')) {
1349 vc_chr_write(s->chr, (const uint8_t *) "\r", 1);
1350 *q++ = '\n';
1351 } else {
1352 *q++ = keysym;
1353 }
1354 if (s->echo) {
1355 vc_chr_write(s->chr, buf, q - buf);
1356 }
1357 num_free = fifo8_num_free(&s->out_fifo);
1358 fifo8_push_all(&s->out_fifo, buf, MIN(num_free, q - buf));
1359 kbd_send_chars(s);
1360 break;
1361 }
1362 }
1363
1364 static const int qcode_to_keysym[Q_KEY_CODE__MAX] = {
1365 [Q_KEY_CODE_UP] = QEMU_KEY_UP,
1366 [Q_KEY_CODE_DOWN] = QEMU_KEY_DOWN,
1367 [Q_KEY_CODE_RIGHT] = QEMU_KEY_RIGHT,
1368 [Q_KEY_CODE_LEFT] = QEMU_KEY_LEFT,
1369 [Q_KEY_CODE_HOME] = QEMU_KEY_HOME,
1370 [Q_KEY_CODE_END] = QEMU_KEY_END,
1371 [Q_KEY_CODE_PGUP] = QEMU_KEY_PAGEUP,
1372 [Q_KEY_CODE_PGDN] = QEMU_KEY_PAGEDOWN,
1373 [Q_KEY_CODE_DELETE] = QEMU_KEY_DELETE,
1374 [Q_KEY_CODE_TAB] = QEMU_KEY_TAB,
1375 [Q_KEY_CODE_BACKSPACE] = QEMU_KEY_BACKSPACE,
1376 };
1377
1378 static const int ctrl_qcode_to_keysym[Q_KEY_CODE__MAX] = {
1379 [Q_KEY_CODE_UP] = QEMU_KEY_CTRL_UP,
1380 [Q_KEY_CODE_DOWN] = QEMU_KEY_CTRL_DOWN,
1381 [Q_KEY_CODE_RIGHT] = QEMU_KEY_CTRL_RIGHT,
1382 [Q_KEY_CODE_LEFT] = QEMU_KEY_CTRL_LEFT,
1383 [Q_KEY_CODE_HOME] = QEMU_KEY_CTRL_HOME,
1384 [Q_KEY_CODE_END] = QEMU_KEY_CTRL_END,
1385 [Q_KEY_CODE_PGUP] = QEMU_KEY_CTRL_PAGEUP,
1386 [Q_KEY_CODE_PGDN] = QEMU_KEY_CTRL_PAGEDOWN,
1387 };
1388
1389 bool kbd_put_qcode_console(QemuConsole *s, int qcode, bool ctrl)
1390 {
1391 int keysym;
1392
1393 keysym = ctrl ? ctrl_qcode_to_keysym[qcode] : qcode_to_keysym[qcode];
1394 if (keysym == 0) {
1395 return false;
1396 }
1397 kbd_put_keysym_console(s, keysym);
1398 return true;
1399 }
1400
1401 void kbd_put_string_console(QemuConsole *s, const char *str, int len)
1402 {
1403 int i;
1404
1405 for (i = 0; i < len && str[i]; i++) {
1406 kbd_put_keysym_console(s, str[i]);
1407 }
1408 }
1409
1410 void kbd_put_keysym(int keysym)
1411 {
1412 kbd_put_keysym_console(active_console, keysym);
1413 }
1414
1415 static void text_console_invalidate(void *opaque)
1416 {
1417 QemuConsole *s = (QemuConsole *) opaque;
1418
1419 if (s->ds->have_text && s->console_type == TEXT_CONSOLE) {
1420 text_console_resize(s);
1421 }
1422 console_refresh(s);
1423 }
1424
1425 static void text_console_update(void *opaque, console_ch_t *chardata)
1426 {
1427 QemuConsole *s = (QemuConsole *) opaque;
1428 int i, j, src;
1429
1430 if (s->text_x[0] <= s->text_x[1]) {
1431 src = (s->y_base + s->text_y[0]) * s->width;
1432 chardata += s->text_y[0] * s->width;
1433 for (i = s->text_y[0]; i <= s->text_y[1]; i ++)
1434 for (j = 0; j < s->width; j++, src++) {
1435 console_write_ch(chardata ++,
1436 ATTR2CHTYPE(s->cells[src].ch,
1437 s->cells[src].t_attrib.fgcol,
1438 s->cells[src].t_attrib.bgcol,
1439 s->cells[src].t_attrib.bold));
1440 }
1441 dpy_text_update(s, s->text_x[0], s->text_y[0],
1442 s->text_x[1] - s->text_x[0], i - s->text_y[0]);
1443 s->text_x[0] = s->width;
1444 s->text_y[0] = s->height;
1445 s->text_x[1] = 0;
1446 s->text_y[1] = 0;
1447 }
1448 if (s->cursor_invalidate) {
1449 dpy_text_cursor(s, s->x, s->y);
1450 s->cursor_invalidate = 0;
1451 }
1452 }
1453
1454 static QemuConsole *new_console(DisplayState *ds, console_type_t console_type,
1455 uint32_t head)
1456 {
1457 Object *obj;
1458 QemuConsole *s;
1459 int i;
1460
1461 obj = object_new(TYPE_QEMU_CONSOLE);
1462 s = QEMU_CONSOLE(obj);
1463 qemu_co_queue_init(&s->dump_queue);
1464 s->head = head;
1465 object_property_add_link(obj, "device", TYPE_DEVICE,
1466 (Object **)&s->device,
1467 object_property_allow_set_link,
1468 OBJ_PROP_LINK_STRONG);
1469 object_property_add_uint32_ptr(obj, "head", &s->head,
1470 OBJ_PROP_FLAG_READ);
1471
1472 if (!active_console || ((active_console->console_type != GRAPHIC_CONSOLE) &&
1473 (console_type == GRAPHIC_CONSOLE))) {
1474 active_console = s;
1475 }
1476 s->ds = ds;
1477 s->console_type = console_type;
1478 s->window_id = -1;
1479
1480 if (QTAILQ_EMPTY(&consoles)) {
1481 s->index = 0;
1482 QTAILQ_INSERT_TAIL(&consoles, s, next);
1483 } else if (console_type != GRAPHIC_CONSOLE || phase_check(PHASE_MACHINE_READY)) {
1484 QemuConsole *last = QTAILQ_LAST(&consoles);
1485 s->index = last->index + 1;
1486 QTAILQ_INSERT_TAIL(&consoles, s, next);
1487 } else {
1488 /*
1489 * HACK: Put graphical consoles before text consoles.
1490 *
1491 * Only do that for coldplugged devices. After initial device
1492 * initialization we will not renumber the consoles any more.
1493 */
1494 QemuConsole *c = QTAILQ_FIRST(&consoles);
1495
1496 while (QTAILQ_NEXT(c, next) != NULL &&
1497 c->console_type == GRAPHIC_CONSOLE) {
1498 c = QTAILQ_NEXT(c, next);
1499 }
1500 if (c->console_type == GRAPHIC_CONSOLE) {
1501 /* have no text consoles */
1502 s->index = c->index + 1;
1503 QTAILQ_INSERT_AFTER(&consoles, c, s, next);
1504 } else {
1505 s->index = c->index;
1506 QTAILQ_INSERT_BEFORE(c, s, next);
1507 /* renumber text consoles */
1508 for (i = s->index + 1; c != NULL; c = QTAILQ_NEXT(c, next), i++) {
1509 c->index = i;
1510 }
1511 }
1512 }
1513 return s;
1514 }
1515
1516 DisplaySurface *qemu_create_displaysurface(int width, int height)
1517 {
1518 DisplaySurface *surface = g_new0(DisplaySurface, 1);
1519
1520 trace_displaysurface_create(surface, width, height);
1521 surface->format = PIXMAN_x8r8g8b8;
1522 surface->image = pixman_image_create_bits(surface->format,
1523 width, height,
1524 NULL, width * 4);
1525 assert(surface->image != NULL);
1526 surface->flags = QEMU_ALLOCATED_FLAG;
1527
1528 return surface;
1529 }
1530
1531 DisplaySurface *qemu_create_displaysurface_from(int width, int height,
1532 pixman_format_code_t format,
1533 int linesize, uint8_t *data)
1534 {
1535 DisplaySurface *surface = g_new0(DisplaySurface, 1);
1536
1537 trace_displaysurface_create_from(surface, width, height, format);
1538 surface->format = format;
1539 surface->image = pixman_image_create_bits(surface->format,
1540 width, height,
1541 (void *)data, linesize);
1542 assert(surface->image != NULL);
1543
1544 return surface;
1545 }
1546
1547 DisplaySurface *qemu_create_displaysurface_pixman(pixman_image_t *image)
1548 {
1549 DisplaySurface *surface = g_new0(DisplaySurface, 1);
1550
1551 trace_displaysurface_create_pixman(surface);
1552 surface->format = pixman_image_get_format(image);
1553 surface->image = pixman_image_ref(image);
1554
1555 return surface;
1556 }
1557
1558 DisplaySurface *qemu_create_placeholder_surface(int w, int h,
1559 const char *msg)
1560 {
1561 DisplaySurface *surface = qemu_create_displaysurface(w, h);
1562 pixman_color_t bg = color_table_rgb[0][QEMU_COLOR_BLACK];
1563 pixman_color_t fg = color_table_rgb[0][QEMU_COLOR_WHITE];
1564 pixman_image_t *glyph;
1565 int len, x, y, i;
1566
1567 len = strlen(msg);
1568 x = (w / FONT_WIDTH - len) / 2;
1569 y = (h / FONT_HEIGHT - 1) / 2;
1570 for (i = 0; i < len; i++) {
1571 glyph = qemu_pixman_glyph_from_vgafont(FONT_HEIGHT, vgafont16, msg[i]);
1572 qemu_pixman_glyph_render(glyph, surface->image, &fg, &bg,
1573 x+i, y, FONT_WIDTH, FONT_HEIGHT);
1574 qemu_pixman_image_unref(glyph);
1575 }
1576 surface->flags |= QEMU_PLACEHOLDER_FLAG;
1577 return surface;
1578 }
1579
1580 void qemu_free_displaysurface(DisplaySurface *surface)
1581 {
1582 if (surface == NULL) {
1583 return;
1584 }
1585 trace_displaysurface_free(surface);
1586 qemu_pixman_image_unref(surface->image);
1587 g_free(surface);
1588 }
1589
1590 bool console_has_gl(QemuConsole *con)
1591 {
1592 return con->gl != NULL;
1593 }
1594
1595 static bool displaychangelistener_has_dmabuf(DisplayChangeListener *dcl)
1596 {
1597 if (dcl->ops->dpy_has_dmabuf) {
1598 return dcl->ops->dpy_has_dmabuf(dcl);
1599 }
1600
1601 if (dcl->ops->dpy_gl_scanout_dmabuf) {
1602 return true;
1603 }
1604
1605 return false;
1606 }
1607
1608 static bool console_compatible_with(QemuConsole *con,
1609 DisplayChangeListener *dcl, Error **errp)
1610 {
1611 int flags;
1612
1613 flags = con->hw_ops->get_flags ? con->hw_ops->get_flags(con->hw) : 0;
1614
1615 if (console_has_gl(con) &&
1616 !con->gl->ops->dpy_gl_ctx_is_compatible_dcl(con->gl, dcl)) {
1617 error_setg(errp, "Display %s is incompatible with the GL context",
1618 dcl->ops->dpy_name);
1619 return false;
1620 }
1621
1622 if (flags & GRAPHIC_FLAGS_GL &&
1623 !console_has_gl(con)) {
1624 error_setg(errp, "The console requires a GL context.");
1625 return false;
1626
1627 }
1628
1629 if (flags & GRAPHIC_FLAGS_DMABUF &&
1630 !displaychangelistener_has_dmabuf(dcl)) {
1631 error_setg(errp, "The console requires display DMABUF support.");
1632 return false;
1633 }
1634
1635 return true;
1636 }
1637
1638 void qemu_console_set_display_gl_ctx(QemuConsole *con, DisplayGLCtx *gl)
1639 {
1640 /* display has opengl support */
1641 assert(con);
1642 if (con->gl) {
1643 error_report("The console already has an OpenGL context.");
1644 exit(1);
1645 }
1646 con->gl = gl;
1647 }
1648
1649 void register_displaychangelistener(DisplayChangeListener *dcl)
1650 {
1651 QemuConsole *con;
1652
1653 assert(!dcl->ds);
1654
1655 trace_displaychangelistener_register(dcl, dcl->ops->dpy_name);
1656 dcl->ds = get_alloc_displaystate();
1657 QLIST_INSERT_HEAD(&dcl->ds->listeners, dcl, next);
1658 gui_setup_refresh(dcl->ds);
1659 if (dcl->con) {
1660 dcl->con->dcls++;
1661 con = dcl->con;
1662 } else {
1663 con = active_console;
1664 }
1665 displaychangelistener_display_console(dcl, con, dcl->con ? &error_fatal : NULL);
1666 if (con && con->cursor && dcl->ops->dpy_cursor_define) {
1667 dcl->ops->dpy_cursor_define(dcl, con->cursor);
1668 }
1669 if (con && dcl->ops->dpy_mouse_set) {
1670 dcl->ops->dpy_mouse_set(dcl, con->cursor_x, con->cursor_y, con->cursor_on);
1671 }
1672 text_console_update_cursor(NULL);
1673 }
1674
1675 void update_displaychangelistener(DisplayChangeListener *dcl,
1676 uint64_t interval)
1677 {
1678 DisplayState *ds = dcl->ds;
1679
1680 dcl->update_interval = interval;
1681 if (!ds->refreshing && ds->update_interval > interval) {
1682 timer_mod(ds->gui_timer, ds->last_update + interval);
1683 }
1684 }
1685
1686 void unregister_displaychangelistener(DisplayChangeListener *dcl)
1687 {
1688 DisplayState *ds = dcl->ds;
1689 trace_displaychangelistener_unregister(dcl, dcl->ops->dpy_name);
1690 if (dcl->con) {
1691 dcl->con->dcls--;
1692 }
1693 QLIST_REMOVE(dcl, next);
1694 dcl->ds = NULL;
1695 gui_setup_refresh(ds);
1696 }
1697
1698 static void dpy_set_ui_info_timer(void *opaque)
1699 {
1700 QemuConsole *con = opaque;
1701
1702 con->hw_ops->ui_info(con->hw, con->head, &con->ui_info);
1703 }
1704
1705 bool dpy_ui_info_supported(QemuConsole *con)
1706 {
1707 if (con == NULL) {
1708 con = active_console;
1709 }
1710
1711 return con->hw_ops->ui_info != NULL;
1712 }
1713
1714 const QemuUIInfo *dpy_get_ui_info(const QemuConsole *con)
1715 {
1716 if (con == NULL) {
1717 con = active_console;
1718 }
1719
1720 return &con->ui_info;
1721 }
1722
1723 int dpy_set_ui_info(QemuConsole *con, QemuUIInfo *info, bool delay)
1724 {
1725 if (con == NULL) {
1726 con = active_console;
1727 }
1728
1729 if (!dpy_ui_info_supported(con)) {
1730 return -1;
1731 }
1732 if (memcmp(&con->ui_info, info, sizeof(con->ui_info)) == 0) {
1733 /* nothing changed -- ignore */
1734 return 0;
1735 }
1736
1737 /*
1738 * Typically we get a flood of these as the user resizes the window.
1739 * Wait until the dust has settled (one second without updates), then
1740 * go notify the guest.
1741 */
1742 con->ui_info = *info;
1743 timer_mod(con->ui_timer,
1744 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + (delay ? 1000 : 0));
1745 return 0;
1746 }
1747
1748 void dpy_gfx_update(QemuConsole *con, int x, int y, int w, int h)
1749 {
1750 DisplayState *s = con->ds;
1751 DisplayChangeListener *dcl;
1752 int width = qemu_console_get_width(con, x + w);
1753 int height = qemu_console_get_height(con, y + h);
1754
1755 x = MAX(x, 0);
1756 y = MAX(y, 0);
1757 x = MIN(x, width);
1758 y = MIN(y, height);
1759 w = MIN(w, width - x);
1760 h = MIN(h, height - y);
1761
1762 if (!qemu_console_is_visible(con)) {
1763 return;
1764 }
1765 dpy_gfx_update_texture(con, con->surface, x, y, w, h);
1766 QLIST_FOREACH(dcl, &s->listeners, next) {
1767 if (con != (dcl->con ? dcl->con : active_console)) {
1768 continue;
1769 }
1770 if (dcl->ops->dpy_gfx_update) {
1771 dcl->ops->dpy_gfx_update(dcl, x, y, w, h);
1772 }
1773 }
1774 }
1775
1776 void dpy_gfx_update_full(QemuConsole *con)
1777 {
1778 int w = qemu_console_get_width(con, 0);
1779 int h = qemu_console_get_height(con, 0);
1780
1781 dpy_gfx_update(con, 0, 0, w, h);
1782 }
1783
1784 void dpy_gfx_replace_surface(QemuConsole *con,
1785 DisplaySurface *surface)
1786 {
1787 static const char placeholder_msg[] = "Display output is not active.";
1788 DisplayState *s = con->ds;
1789 DisplaySurface *old_surface = con->surface;
1790 DisplayChangeListener *dcl;
1791 int width;
1792 int height;
1793
1794 if (!surface) {
1795 if (old_surface) {
1796 width = surface_width(old_surface);
1797 height = surface_height(old_surface);
1798 } else {
1799 width = 640;
1800 height = 480;
1801 }
1802
1803 surface = qemu_create_placeholder_surface(width, height, placeholder_msg);
1804 }
1805
1806 assert(old_surface != surface);
1807
1808 con->scanout.kind = SCANOUT_SURFACE;
1809 con->surface = surface;
1810 dpy_gfx_create_texture(con, surface);
1811 QLIST_FOREACH(dcl, &s->listeners, next) {
1812 if (con != (dcl->con ? dcl->con : active_console)) {
1813 continue;
1814 }
1815 displaychangelistener_gfx_switch(dcl, surface, FALSE);
1816 }
1817 dpy_gfx_destroy_texture(con, old_surface);
1818 qemu_free_displaysurface(old_surface);
1819 }
1820
1821 bool dpy_gfx_check_format(QemuConsole *con,
1822 pixman_format_code_t format)
1823 {
1824 DisplayChangeListener *dcl;
1825 DisplayState *s = con->ds;
1826
1827 QLIST_FOREACH(dcl, &s->listeners, next) {
1828 if (dcl->con && dcl->con != con) {
1829 /* dcl bound to another console -> skip */
1830 continue;
1831 }
1832 if (dcl->ops->dpy_gfx_check_format) {
1833 if (!dcl->ops->dpy_gfx_check_format(dcl, format)) {
1834 return false;
1835 }
1836 } else {
1837 /* default is to allow native 32 bpp only */
1838 if (format != qemu_default_pixman_format(32, true)) {
1839 return false;
1840 }
1841 }
1842 }
1843 return true;
1844 }
1845
1846 static void dpy_refresh(DisplayState *s)
1847 {
1848 DisplayChangeListener *dcl;
1849
1850 QLIST_FOREACH(dcl, &s->listeners, next) {
1851 if (dcl->ops->dpy_refresh) {
1852 dcl->ops->dpy_refresh(dcl);
1853 }
1854 }
1855 }
1856
1857 void dpy_text_cursor(QemuConsole *con, int x, int y)
1858 {
1859 DisplayState *s = con->ds;
1860 DisplayChangeListener *dcl;
1861
1862 if (!qemu_console_is_visible(con)) {
1863 return;
1864 }
1865 QLIST_FOREACH(dcl, &s->listeners, next) {
1866 if (con != (dcl->con ? dcl->con : active_console)) {
1867 continue;
1868 }
1869 if (dcl->ops->dpy_text_cursor) {
1870 dcl->ops->dpy_text_cursor(dcl, x, y);
1871 }
1872 }
1873 }
1874
1875 void dpy_text_update(QemuConsole *con, int x, int y, int w, int h)
1876 {
1877 DisplayState *s = con->ds;
1878 DisplayChangeListener *dcl;
1879
1880 if (!qemu_console_is_visible(con)) {
1881 return;
1882 }
1883 QLIST_FOREACH(dcl, &s->listeners, next) {
1884 if (con != (dcl->con ? dcl->con : active_console)) {
1885 continue;
1886 }
1887 if (dcl->ops->dpy_text_update) {
1888 dcl->ops->dpy_text_update(dcl, x, y, w, h);
1889 }
1890 }
1891 }
1892
1893 void dpy_text_resize(QemuConsole *con, int w, int h)
1894 {
1895 DisplayState *s = con->ds;
1896 DisplayChangeListener *dcl;
1897
1898 if (!qemu_console_is_visible(con)) {
1899 return;
1900 }
1901 QLIST_FOREACH(dcl, &s->listeners, next) {
1902 if (con != (dcl->con ? dcl->con : active_console)) {
1903 continue;
1904 }
1905 if (dcl->ops->dpy_text_resize) {
1906 dcl->ops->dpy_text_resize(dcl, w, h);
1907 }
1908 }
1909 }
1910
1911 void dpy_mouse_set(QemuConsole *con, int x, int y, int on)
1912 {
1913 DisplayState *s = con->ds;
1914 DisplayChangeListener *dcl;
1915
1916 con->cursor_x = x;
1917 con->cursor_y = y;
1918 con->cursor_on = on;
1919 if (!qemu_console_is_visible(con)) {
1920 return;
1921 }
1922 QLIST_FOREACH(dcl, &s->listeners, next) {
1923 if (con != (dcl->con ? dcl->con : active_console)) {
1924 continue;
1925 }
1926 if (dcl->ops->dpy_mouse_set) {
1927 dcl->ops->dpy_mouse_set(dcl, x, y, on);
1928 }
1929 }
1930 }
1931
1932 void dpy_cursor_define(QemuConsole *con, QEMUCursor *cursor)
1933 {
1934 DisplayState *s = con->ds;
1935 DisplayChangeListener *dcl;
1936
1937 cursor_unref(con->cursor);
1938 con->cursor = cursor_ref(cursor);
1939 if (!qemu_console_is_visible(con)) {
1940 return;
1941 }
1942 QLIST_FOREACH(dcl, &s->listeners, next) {
1943 if (con != (dcl->con ? dcl->con : active_console)) {
1944 continue;
1945 }
1946 if (dcl->ops->dpy_cursor_define) {
1947 dcl->ops->dpy_cursor_define(dcl, cursor);
1948 }
1949 }
1950 }
1951
1952 bool dpy_cursor_define_supported(QemuConsole *con)
1953 {
1954 DisplayState *s = con->ds;
1955 DisplayChangeListener *dcl;
1956
1957 QLIST_FOREACH(dcl, &s->listeners, next) {
1958 if (dcl->ops->dpy_cursor_define) {
1959 return true;
1960 }
1961 }
1962 return false;
1963 }
1964
1965 QEMUGLContext dpy_gl_ctx_create(QemuConsole *con,
1966 struct QEMUGLParams *qparams)
1967 {
1968 assert(con->gl);
1969 return con->gl->ops->dpy_gl_ctx_create(con->gl, qparams);
1970 }
1971
1972 void dpy_gl_ctx_destroy(QemuConsole *con, QEMUGLContext ctx)
1973 {
1974 assert(con->gl);
1975 con->gl->ops->dpy_gl_ctx_destroy(con->gl, ctx);
1976 }
1977
1978 int dpy_gl_ctx_make_current(QemuConsole *con, QEMUGLContext ctx)
1979 {
1980 assert(con->gl);
1981 return con->gl->ops->dpy_gl_ctx_make_current(con->gl, ctx);
1982 }
1983
1984 void dpy_gl_scanout_disable(QemuConsole *con)
1985 {
1986 DisplayState *s = con->ds;
1987 DisplayChangeListener *dcl;
1988
1989 if (con->scanout.kind != SCANOUT_SURFACE) {
1990 con->scanout.kind = SCANOUT_NONE;
1991 }
1992 QLIST_FOREACH(dcl, &s->listeners, next) {
1993 if (con != (dcl->con ? dcl->con : active_console)) {
1994 continue;
1995 }
1996 if (dcl->ops->dpy_gl_scanout_disable) {
1997 dcl->ops->dpy_gl_scanout_disable(dcl);
1998 }
1999 }
2000 }
2001
2002 void dpy_gl_scanout_texture(QemuConsole *con,
2003 uint32_t backing_id,
2004 bool backing_y_0_top,
2005 uint32_t backing_width,
2006 uint32_t backing_height,
2007 uint32_t x, uint32_t y,
2008 uint32_t width, uint32_t height)
2009 {
2010 DisplayState *s = con->ds;
2011 DisplayChangeListener *dcl;
2012
2013 con->scanout.kind = SCANOUT_TEXTURE;
2014 con->scanout.texture = (ScanoutTexture) {
2015 backing_id, backing_y_0_top, backing_width, backing_height,
2016 x, y, width, height
2017 };
2018 QLIST_FOREACH(dcl, &s->listeners, next) {
2019 if (con != (dcl->con ? dcl->con : active_console)) {
2020 continue;
2021 }
2022 if (dcl->ops->dpy_gl_scanout_texture) {
2023 dcl->ops->dpy_gl_scanout_texture(dcl, backing_id,
2024 backing_y_0_top,
2025 backing_width, backing_height,
2026 x, y, width, height);
2027 }
2028 }
2029 }
2030
2031 void dpy_gl_scanout_dmabuf(QemuConsole *con,
2032 QemuDmaBuf *dmabuf)
2033 {
2034 DisplayState *s = con->ds;
2035 DisplayChangeListener *dcl;
2036
2037 con->scanout.kind = SCANOUT_DMABUF;
2038 con->scanout.dmabuf = dmabuf;
2039 QLIST_FOREACH(dcl, &s->listeners, next) {
2040 if (con != (dcl->con ? dcl->con : active_console)) {
2041 continue;
2042 }
2043 if (dcl->ops->dpy_gl_scanout_dmabuf) {
2044 dcl->ops->dpy_gl_scanout_dmabuf(dcl, dmabuf);
2045 }
2046 }
2047 }
2048
2049 void dpy_gl_cursor_dmabuf(QemuConsole *con, QemuDmaBuf *dmabuf,
2050 bool have_hot, uint32_t hot_x, uint32_t hot_y)
2051 {
2052 DisplayState *s = con->ds;
2053 DisplayChangeListener *dcl;
2054
2055 QLIST_FOREACH(dcl, &s->listeners, next) {
2056 if (con != (dcl->con ? dcl->con : active_console)) {
2057 continue;
2058 }
2059 if (dcl->ops->dpy_gl_cursor_dmabuf) {
2060 dcl->ops->dpy_gl_cursor_dmabuf(dcl, dmabuf,
2061 have_hot, hot_x, hot_y);
2062 }
2063 }
2064 }
2065
2066 void dpy_gl_cursor_position(QemuConsole *con,
2067 uint32_t pos_x, uint32_t pos_y)
2068 {
2069 DisplayState *s = con->ds;
2070 DisplayChangeListener *dcl;
2071
2072 QLIST_FOREACH(dcl, &s->listeners, next) {
2073 if (con != (dcl->con ? dcl->con : active_console)) {
2074 continue;
2075 }
2076 if (dcl->ops->dpy_gl_cursor_position) {
2077 dcl->ops->dpy_gl_cursor_position(dcl, pos_x, pos_y);
2078 }
2079 }
2080 }
2081
2082 void dpy_gl_release_dmabuf(QemuConsole *con,
2083 QemuDmaBuf *dmabuf)
2084 {
2085 DisplayState *s = con->ds;
2086 DisplayChangeListener *dcl;
2087
2088 QLIST_FOREACH(dcl, &s->listeners, next) {
2089 if (con != (dcl->con ? dcl->con : active_console)) {
2090 continue;
2091 }
2092 if (dcl->ops->dpy_gl_release_dmabuf) {
2093 dcl->ops->dpy_gl_release_dmabuf(dcl, dmabuf);
2094 }
2095 }
2096 }
2097
2098 void dpy_gl_update(QemuConsole *con,
2099 uint32_t x, uint32_t y, uint32_t w, uint32_t h)
2100 {
2101 DisplayState *s = con->ds;
2102 DisplayChangeListener *dcl;
2103
2104 assert(con->gl);
2105
2106 graphic_hw_gl_block(con, true);
2107 QLIST_FOREACH(dcl, &s->listeners, next) {
2108 if (con != (dcl->con ? dcl->con : active_console)) {
2109 continue;
2110 }
2111 if (dcl->ops->dpy_gl_update) {
2112 dcl->ops->dpy_gl_update(dcl, x, y, w, h);
2113 }
2114 }
2115 graphic_hw_gl_block(con, false);
2116 }
2117
2118 /***********************************************************/
2119 /* register display */
2120
2121 /* console.c internal use only */
2122 static DisplayState *get_alloc_displaystate(void)
2123 {
2124 if (!display_state) {
2125 display_state = g_new0(DisplayState, 1);
2126 cursor_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
2127 text_console_update_cursor, NULL);
2128 }
2129 return display_state;
2130 }
2131
2132 /*
2133 * Called by main(), after creating QemuConsoles
2134 * and before initializing ui (sdl/vnc/...).
2135 */
2136 DisplayState *init_displaystate(void)
2137 {
2138 gchar *name;
2139 QemuConsole *con;
2140
2141 get_alloc_displaystate();
2142 QTAILQ_FOREACH(con, &consoles, next) {
2143 if (con->console_type != GRAPHIC_CONSOLE &&
2144 con->ds == NULL) {
2145 text_console_do_init(con->chr, display_state);
2146 }
2147
2148 /* Hook up into the qom tree here (not in new_console()), once
2149 * all QemuConsoles are created and the order / numbering
2150 * doesn't change any more */
2151 name = g_strdup_printf("console[%d]", con->index);
2152 object_property_add_child(container_get(object_get_root(), "/backend"),
2153 name, OBJECT(con));
2154 g_free(name);
2155 }
2156
2157 return display_state;
2158 }
2159
2160 void graphic_console_set_hwops(QemuConsole *con,
2161 const GraphicHwOps *hw_ops,
2162 void *opaque)
2163 {
2164 con->hw_ops = hw_ops;
2165 con->hw = opaque;
2166 }
2167
2168 QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head,
2169 const GraphicHwOps *hw_ops,
2170 void *opaque)
2171 {
2172 static const char noinit[] =
2173 "Guest has not initialized the display (yet).";
2174 int width = 640;
2175 int height = 480;
2176 QemuConsole *s;
2177 DisplayState *ds;
2178 DisplaySurface *surface;
2179
2180 ds = get_alloc_displaystate();
2181 s = qemu_console_lookup_unused();
2182 if (s) {
2183 trace_console_gfx_reuse(s->index);
2184 width = qemu_console_get_width(s, 0);
2185 height = qemu_console_get_height(s, 0);
2186 } else {
2187 trace_console_gfx_new();
2188 s = new_console(ds, GRAPHIC_CONSOLE, head);
2189 s->ui_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
2190 dpy_set_ui_info_timer, s);
2191 }
2192 graphic_console_set_hwops(s, hw_ops, opaque);
2193 if (dev) {
2194 object_property_set_link(OBJECT(s), "device", OBJECT(dev),
2195 &error_abort);
2196 }
2197
2198 surface = qemu_create_placeholder_surface(width, height, noinit);
2199 dpy_gfx_replace_surface(s, surface);
2200 s->gl_unblock_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
2201 graphic_hw_gl_unblock_timer, s);
2202 return s;
2203 }
2204
2205 static const GraphicHwOps unused_ops = {
2206 /* no callbacks */
2207 };
2208
2209 void graphic_console_close(QemuConsole *con)
2210 {
2211 static const char unplugged[] =
2212 "Guest display has been unplugged";
2213 DisplaySurface *surface;
2214 int width = qemu_console_get_width(con, 640);
2215 int height = qemu_console_get_height(con, 480);
2216
2217 trace_console_gfx_close(con->index);
2218 object_property_set_link(OBJECT(con), "device", NULL, &error_abort);
2219 graphic_console_set_hwops(con, &unused_ops, NULL);
2220
2221 if (con->gl) {
2222 dpy_gl_scanout_disable(con);
2223 }
2224 surface = qemu_create_placeholder_surface(width, height, unplugged);
2225 dpy_gfx_replace_surface(con, surface);
2226 }
2227
2228 QemuConsole *qemu_console_lookup_by_index(unsigned int index)
2229 {
2230 QemuConsole *con;
2231
2232 QTAILQ_FOREACH(con, &consoles, next) {
2233 if (con->index == index) {
2234 return con;
2235 }
2236 }
2237 return NULL;
2238 }
2239
2240 QemuConsole *qemu_console_lookup_by_device(DeviceState *dev, uint32_t head)
2241 {
2242 QemuConsole *con;
2243 Object *obj;
2244 uint32_t h;
2245
2246 QTAILQ_FOREACH(con, &consoles, next) {
2247 obj = object_property_get_link(OBJECT(con),
2248 "device", &error_abort);
2249 if (DEVICE(obj) != dev) {
2250 continue;
2251 }
2252 h = object_property_get_uint(OBJECT(con),
2253 "head", &error_abort);
2254 if (h != head) {
2255 continue;
2256 }
2257 return con;
2258 }
2259 return NULL;
2260 }
2261
2262 QemuConsole *qemu_console_lookup_by_device_name(const char *device_id,
2263 uint32_t head, Error **errp)
2264 {
2265 DeviceState *dev;
2266 QemuConsole *con;
2267
2268 dev = qdev_find_recursive(sysbus_get_default(), device_id);
2269 if (dev == NULL) {
2270 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
2271 "Device '%s' not found", device_id);
2272 return NULL;
2273 }
2274
2275 con = qemu_console_lookup_by_device(dev, head);
2276 if (con == NULL) {
2277 error_setg(errp, "Device %s (head %d) is not bound to a QemuConsole",
2278 device_id, head);
2279 return NULL;
2280 }
2281
2282 return con;
2283 }
2284
2285 QemuConsole *qemu_console_lookup_unused(void)
2286 {
2287 QemuConsole *con;
2288 Object *obj;
2289
2290 QTAILQ_FOREACH(con, &consoles, next) {
2291 if (con->hw_ops != &unused_ops) {
2292 continue;
2293 }
2294 obj = object_property_get_link(OBJECT(con),
2295 "device", &error_abort);
2296 if (obj != NULL) {
2297 continue;
2298 }
2299 return con;
2300 }
2301 return NULL;
2302 }
2303
2304 QEMUCursor *qemu_console_get_cursor(QemuConsole *con)
2305 {
2306 if (con == NULL) {
2307 con = active_console;
2308 }
2309 return con->cursor;
2310 }
2311
2312 bool qemu_console_is_visible(QemuConsole *con)
2313 {
2314 return (con == active_console) || (con->dcls > 0);
2315 }
2316
2317 bool qemu_console_is_graphic(QemuConsole *con)
2318 {
2319 if (con == NULL) {
2320 con = active_console;
2321 }
2322 return con && (con->console_type == GRAPHIC_CONSOLE);
2323 }
2324
2325 bool qemu_console_is_fixedsize(QemuConsole *con)
2326 {
2327 if (con == NULL) {
2328 con = active_console;
2329 }
2330 return con && (con->console_type != TEXT_CONSOLE);
2331 }
2332
2333 bool qemu_console_is_gl_blocked(QemuConsole *con)
2334 {
2335 assert(con != NULL);
2336 return con->gl_block;
2337 }
2338
2339 bool qemu_console_is_multihead(DeviceState *dev)
2340 {
2341 QemuConsole *con;
2342 Object *obj;
2343 uint32_t f = 0xffffffff;
2344 uint32_t h;
2345
2346 QTAILQ_FOREACH(con, &consoles, next) {
2347 obj = object_property_get_link(OBJECT(con),
2348 "device", &error_abort);
2349 if (DEVICE(obj) != dev) {
2350 continue;
2351 }
2352
2353 h = object_property_get_uint(OBJECT(con),
2354 "head", &error_abort);
2355 if (f == 0xffffffff) {
2356 f = h;
2357 } else if (h != f) {
2358 return true;
2359 }
2360 }
2361 return false;
2362 }
2363
2364 char *qemu_console_get_label(QemuConsole *con)
2365 {
2366 if (con->console_type == GRAPHIC_CONSOLE) {
2367 if (con->device) {
2368 DeviceState *dev;
2369 bool multihead;
2370
2371 dev = DEVICE(con->device);
2372 multihead = qemu_console_is_multihead(dev);
2373 if (multihead) {
2374 return g_strdup_printf("%s.%d", dev->id ?
2375 dev->id :
2376 object_get_typename(con->device),
2377 con->head);
2378 } else {
2379 return g_strdup_printf("%s", dev->id ?
2380 dev->id :
2381 object_get_typename(con->device));
2382 }
2383 }
2384 return g_strdup("VGA");
2385 } else {
2386 if (con->chr && con->chr->label) {
2387 return g_strdup(con->chr->label);
2388 }
2389 return g_strdup_printf("vc%d", con->index);
2390 }
2391 }
2392
2393 int qemu_console_get_index(QemuConsole *con)
2394 {
2395 if (con == NULL) {
2396 con = active_console;
2397 }
2398 return con ? con->index : -1;
2399 }
2400
2401 uint32_t qemu_console_get_head(QemuConsole *con)
2402 {
2403 if (con == NULL) {
2404 con = active_console;
2405 }
2406 return con ? con->head : -1;
2407 }
2408
2409 int qemu_console_get_width(QemuConsole *con, int fallback)
2410 {
2411 if (con == NULL) {
2412 con = active_console;
2413 }
2414 if (con == NULL) {
2415 return fallback;
2416 }
2417 switch (con->scanout.kind) {
2418 case SCANOUT_DMABUF:
2419 return con->scanout.dmabuf->width;
2420 case SCANOUT_TEXTURE:
2421 return con->scanout.texture.width;
2422 case SCANOUT_SURFACE:
2423 return surface_width(con->surface);
2424 default:
2425 return fallback;
2426 }
2427 }
2428
2429 int qemu_console_get_height(QemuConsole *con, int fallback)
2430 {
2431 if (con == NULL) {
2432 con = active_console;
2433 }
2434 if (con == NULL) {
2435 return fallback;
2436 }
2437 switch (con->scanout.kind) {
2438 case SCANOUT_DMABUF:
2439 return con->scanout.dmabuf->height;
2440 case SCANOUT_TEXTURE:
2441 return con->scanout.texture.height;
2442 case SCANOUT_SURFACE:
2443 return surface_height(con->surface);
2444 default:
2445 return fallback;
2446 }
2447 }
2448
2449 static void vc_chr_accept_input(Chardev *chr)
2450 {
2451 VCChardev *drv = VC_CHARDEV(chr);
2452 QemuConsole *s = drv->console;
2453
2454 kbd_send_chars(s);
2455 }
2456
2457 static void vc_chr_set_echo(Chardev *chr, bool echo)
2458 {
2459 VCChardev *drv = VC_CHARDEV(chr);
2460 QemuConsole *s = drv->console;
2461
2462 s->echo = echo;
2463 }
2464
2465 static void text_console_update_cursor_timer(void)
2466 {
2467 timer_mod(cursor_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME)
2468 + CONSOLE_CURSOR_PERIOD / 2);
2469 }
2470
2471 static void text_console_update_cursor(void *opaque)
2472 {
2473 QemuConsole *s;
2474 int count = 0;
2475
2476 cursor_visible_phase = !cursor_visible_phase;
2477
2478 QTAILQ_FOREACH(s, &consoles, next) {
2479 if (qemu_console_is_graphic(s) ||
2480 !qemu_console_is_visible(s)) {
2481 continue;
2482 }
2483 count++;
2484 graphic_hw_invalidate(s);
2485 }
2486
2487 if (count) {
2488 text_console_update_cursor_timer();
2489 }
2490 }
2491
2492 static const GraphicHwOps text_console_ops = {
2493 .invalidate = text_console_invalidate,
2494 .text_update = text_console_update,
2495 };
2496
2497 static void text_console_do_init(Chardev *chr, DisplayState *ds)
2498 {
2499 VCChardev *drv = VC_CHARDEV(chr);
2500 QemuConsole *s = drv->console;
2501 int g_width = 80 * FONT_WIDTH;
2502 int g_height = 24 * FONT_HEIGHT;
2503
2504 fifo8_create(&s->out_fifo, 16);
2505 s->ds = ds;
2506
2507 s->y_displayed = 0;
2508 s->y_base = 0;
2509 s->total_height = DEFAULT_BACKSCROLL;
2510 s->x = 0;
2511 s->y = 0;
2512 if (s->scanout.kind != SCANOUT_SURFACE) {
2513 if (active_console && active_console->scanout.kind == SCANOUT_SURFACE) {
2514 g_width = qemu_console_get_width(active_console, g_width);
2515 g_height = qemu_console_get_height(active_console, g_height);
2516 }
2517 s->surface = qemu_create_displaysurface(g_width, g_height);
2518 s->scanout.kind = SCANOUT_SURFACE;
2519 }
2520
2521 s->hw_ops = &text_console_ops;
2522 s->hw = s;
2523
2524 /* Set text attribute defaults */
2525 s->t_attrib_default.bold = 0;
2526 s->t_attrib_default.uline = 0;
2527 s->t_attrib_default.blink = 0;
2528 s->t_attrib_default.invers = 0;
2529 s->t_attrib_default.unvisible = 0;
2530 s->t_attrib_default.fgcol = QEMU_COLOR_WHITE;
2531 s->t_attrib_default.bgcol = QEMU_COLOR_BLACK;
2532 /* set current text attributes to default */
2533 s->t_attrib = s->t_attrib_default;
2534 text_console_resize(s);
2535
2536 if (chr->label) {
2537 char *msg;
2538
2539 s->t_attrib.bgcol = QEMU_COLOR_BLUE;
2540 msg = g_strdup_printf("%s console\r\n", chr->label);
2541 vc_chr_write(chr, (uint8_t *)msg, strlen(msg));
2542 g_free(msg);
2543 s->t_attrib = s->t_attrib_default;
2544 }
2545
2546 qemu_chr_be_event(chr, CHR_EVENT_OPENED);
2547 }
2548
2549 static void vc_chr_open(Chardev *chr,
2550 ChardevBackend *backend,
2551 bool *be_opened,
2552 Error **errp)
2553 {
2554 ChardevVC *vc = backend->u.vc.data;
2555 VCChardev *drv = VC_CHARDEV(chr);
2556 QemuConsole *s;
2557 unsigned width = 0;
2558 unsigned height = 0;
2559
2560 if (vc->has_width) {
2561 width = vc->width;
2562 } else if (vc->has_cols) {
2563 width = vc->cols * FONT_WIDTH;
2564 }
2565
2566 if (vc->has_height) {
2567 height = vc->height;
2568 } else if (vc->has_rows) {
2569 height = vc->rows * FONT_HEIGHT;
2570 }
2571
2572 trace_console_txt_new(width, height);
2573 if (width == 0 || height == 0) {
2574 s = new_console(NULL, TEXT_CONSOLE, 0);
2575 } else {
2576 s = new_console(NULL, TEXT_CONSOLE_FIXED_SIZE, 0);
2577 s->scanout.kind = SCANOUT_SURFACE;
2578 s->surface = qemu_create_displaysurface(width, height);
2579 }
2580
2581 if (!s) {
2582 error_setg(errp, "cannot create text console");
2583 return;
2584 }
2585
2586 s->chr = chr;
2587 drv->console = s;
2588
2589 if (display_state) {
2590 text_console_do_init(chr, display_state);
2591 }
2592
2593 /* console/chardev init sometimes completes elsewhere in a 2nd
2594 * stage, so defer OPENED events until they are fully initialized
2595 */
2596 *be_opened = false;
2597 }
2598
2599 void qemu_console_resize(QemuConsole *s, int width, int height)
2600 {
2601 DisplaySurface *surface = qemu_console_surface(s);
2602
2603 assert(s->console_type == GRAPHIC_CONSOLE);
2604
2605 if ((s->scanout.kind != SCANOUT_SURFACE ||
2606 (surface && surface->flags & QEMU_ALLOCATED_FLAG)) &&
2607 qemu_console_get_width(s, -1) == width &&
2608 qemu_console_get_height(s, -1) == height) {
2609 return;
2610 }
2611
2612 surface = qemu_create_displaysurface(width, height);
2613 dpy_gfx_replace_surface(s, surface);
2614 }
2615
2616 DisplaySurface *qemu_console_surface(QemuConsole *console)
2617 {
2618 switch (console->scanout.kind) {
2619 case SCANOUT_SURFACE:
2620 return console->surface;
2621 default:
2622 return NULL;
2623 }
2624 }
2625
2626 PixelFormat qemu_default_pixelformat(int bpp)
2627 {
2628 pixman_format_code_t fmt = qemu_default_pixman_format(bpp, true);
2629 PixelFormat pf = qemu_pixelformat_from_pixman(fmt);
2630 return pf;
2631 }
2632
2633 static QemuDisplay *dpys[DISPLAY_TYPE__MAX];
2634
2635 void qemu_display_register(QemuDisplay *ui)
2636 {
2637 assert(ui->type < DISPLAY_TYPE__MAX);
2638 dpys[ui->type] = ui;
2639 }
2640
2641 bool qemu_display_find_default(DisplayOptions *opts)
2642 {
2643 static DisplayType prio[] = {
2644 #if defined(CONFIG_GTK)
2645 DISPLAY_TYPE_GTK,
2646 #endif
2647 #if defined(CONFIG_SDL)
2648 DISPLAY_TYPE_SDL,
2649 #endif
2650 #if defined(CONFIG_COCOA)
2651 DISPLAY_TYPE_COCOA
2652 #endif
2653 };
2654 int i;
2655
2656 for (i = 0; i < (int)ARRAY_SIZE(prio); i++) {
2657 if (dpys[prio[i]] == NULL) {
2658 Error *local_err = NULL;
2659 int rv = ui_module_load(DisplayType_str(prio[i]), &local_err);
2660 if (rv < 0) {
2661 error_report_err(local_err);
2662 }
2663 }
2664 if (dpys[prio[i]] == NULL) {
2665 continue;
2666 }
2667 opts->type = prio[i];
2668 return true;
2669 }
2670 return false;
2671 }
2672
2673 void qemu_display_early_init(DisplayOptions *opts)
2674 {
2675 assert(opts->type < DISPLAY_TYPE__MAX);
2676 if (opts->type == DISPLAY_TYPE_NONE) {
2677 return;
2678 }
2679 if (dpys[opts->type] == NULL) {
2680 Error *local_err = NULL;
2681 int rv = ui_module_load(DisplayType_str(opts->type), &local_err);
2682 if (rv < 0) {
2683 error_report_err(local_err);
2684 }
2685 }
2686 if (dpys[opts->type] == NULL) {
2687 error_report("Display '%s' is not available.",
2688 DisplayType_str(opts->type));
2689 exit(1);
2690 }
2691 if (dpys[opts->type]->early_init) {
2692 dpys[opts->type]->early_init(opts);
2693 }
2694 }
2695
2696 void qemu_display_init(DisplayState *ds, DisplayOptions *opts)
2697 {
2698 assert(opts->type < DISPLAY_TYPE__MAX);
2699 if (opts->type == DISPLAY_TYPE_NONE) {
2700 return;
2701 }
2702 assert(dpys[opts->type] != NULL);
2703 dpys[opts->type]->init(ds, opts);
2704 }
2705
2706 void qemu_display_help(void)
2707 {
2708 int idx;
2709
2710 printf("Available display backend types:\n");
2711 printf("none\n");
2712 for (idx = DISPLAY_TYPE_NONE; idx < DISPLAY_TYPE__MAX; idx++) {
2713 if (!dpys[idx]) {
2714 Error *local_err = NULL;
2715 int rv = ui_module_load(DisplayType_str(idx), &local_err);
2716 if (rv < 0) {
2717 error_report_err(local_err);
2718 }
2719 }
2720 if (dpys[idx]) {
2721 printf("%s\n", DisplayType_str(dpys[idx]->type));
2722 }
2723 }
2724 }
2725
2726 void qemu_chr_parse_vc(QemuOpts *opts, ChardevBackend *backend, Error **errp)
2727 {
2728 int val;
2729 ChardevVC *vc;
2730
2731 backend->type = CHARDEV_BACKEND_KIND_VC;
2732 vc = backend->u.vc.data = g_new0(ChardevVC, 1);
2733 qemu_chr_parse_common(opts, qapi_ChardevVC_base(vc));
2734
2735 val = qemu_opt_get_number(opts, "width", 0);
2736 if (val != 0) {
2737 vc->has_width = true;
2738 vc->width = val;
2739 }
2740
2741 val = qemu_opt_get_number(opts, "height", 0);
2742 if (val != 0) {
2743 vc->has_height = true;
2744 vc->height = val;
2745 }
2746
2747 val = qemu_opt_get_number(opts, "cols", 0);
2748 if (val != 0) {
2749 vc->has_cols = true;
2750 vc->cols = val;
2751 }
2752
2753 val = qemu_opt_get_number(opts, "rows", 0);
2754 if (val != 0) {
2755 vc->has_rows = true;
2756 vc->rows = val;
2757 }
2758 }
2759
2760 static const TypeInfo qemu_console_info = {
2761 .name = TYPE_QEMU_CONSOLE,
2762 .parent = TYPE_OBJECT,
2763 .instance_size = sizeof(QemuConsole),
2764 .class_size = sizeof(QemuConsoleClass),
2765 };
2766
2767 static void char_vc_class_init(ObjectClass *oc, void *data)
2768 {
2769 ChardevClass *cc = CHARDEV_CLASS(oc);
2770
2771 cc->parse = qemu_chr_parse_vc;
2772 cc->open = vc_chr_open;
2773 cc->chr_write = vc_chr_write;
2774 cc->chr_accept_input = vc_chr_accept_input;
2775 cc->chr_set_echo = vc_chr_set_echo;
2776 }
2777
2778 static const TypeInfo char_vc_type_info = {
2779 .name = TYPE_CHARDEV_VC,
2780 .parent = TYPE_CHARDEV,
2781 .instance_size = sizeof(VCChardev),
2782 .class_init = char_vc_class_init,
2783 };
2784
2785 void qemu_console_early_init(void)
2786 {
2787 /* set the default vc driver */
2788 if (!object_class_by_name(TYPE_CHARDEV_VC)) {
2789 type_register(&char_vc_type_info);
2790 }
2791 }
2792
2793 static void register_types(void)
2794 {
2795 type_register_static(&qemu_console_info);
2796 }
2797
2798 type_init(register_types);
Random patches