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 #ifdef WIN32 1517 void qemu_displaysurface_win32_set_handle(DisplaySurface *surface, 1518 HANDLE h, uint32_t offset) 1519 { 1520 assert(!surface->handle); 1521 1522 surface->handle = h; 1523 surface->handle_offset = offset; 1524 } 1525 1526 static void 1527 win32_pixman_image_destroy(pixman_image_t *image, void *data) 1528 { 1529 DisplaySurface *surface = data; 1530 1531 if (!surface->handle) { 1532 return; 1533 } 1534 1535 assert(surface->handle_offset == 0); 1536 1537 qemu_win32_map_free( 1538 pixman_image_get_data(surface->image), 1539 surface->handle, 1540 &error_warn 1541 ); 1542 } 1543 #endif 1544 1545 DisplaySurface *qemu_create_displaysurface(int width, int height) 1546 { 1547 DisplaySurface *surface; 1548 void *bits = NULL; 1549 #ifdef WIN32 1550 HANDLE handle = NULL; 1551 #endif 1552 1553 trace_displaysurface_create(width, height); 1554 1555 #ifdef WIN32 1556 bits = qemu_win32_map_alloc(width * height * 4, &handle, &error_abort); 1557 #endif 1558 1559 surface = qemu_create_displaysurface_from( 1560 width, height, 1561 PIXMAN_x8r8g8b8, 1562 width * 4, bits 1563 ); 1564 surface->flags = QEMU_ALLOCATED_FLAG; 1565 1566 #ifdef WIN32 1567 qemu_displaysurface_win32_set_handle(surface, handle, 0); 1568 #endif 1569 return surface; 1570 } 1571 1572 DisplaySurface *qemu_create_displaysurface_from(int width, int height, 1573 pixman_format_code_t format, 1574 int linesize, uint8_t *data) 1575 { 1576 DisplaySurface *surface = g_new0(DisplaySurface, 1); 1577 1578 trace_displaysurface_create_from(surface, width, height, format); 1579 surface->format = format; 1580 surface->image = pixman_image_create_bits(surface->format, 1581 width, height, 1582 (void *)data, linesize); 1583 assert(surface->image != NULL); 1584 #ifdef WIN32 1585 pixman_image_set_destroy_function(surface->image, 1586 win32_pixman_image_destroy, surface); 1587 #endif 1588 1589 return surface; 1590 } 1591 1592 DisplaySurface *qemu_create_displaysurface_pixman(pixman_image_t *image) 1593 { 1594 DisplaySurface *surface = g_new0(DisplaySurface, 1); 1595 1596 trace_displaysurface_create_pixman(surface); 1597 surface->format = pixman_image_get_format(image); 1598 surface->image = pixman_image_ref(image); 1599 1600 return surface; 1601 } 1602 1603 DisplaySurface *qemu_create_placeholder_surface(int w, int h, 1604 const char *msg) 1605 { 1606 DisplaySurface *surface = qemu_create_displaysurface(w, h); 1607 pixman_color_t bg = color_table_rgb[0][QEMU_COLOR_BLACK]; 1608 pixman_color_t fg = color_table_rgb[0][QEMU_COLOR_WHITE]; 1609 pixman_image_t *glyph; 1610 int len, x, y, i; 1611 1612 len = strlen(msg); 1613 x = (w / FONT_WIDTH - len) / 2; 1614 y = (h / FONT_HEIGHT - 1) / 2; 1615 for (i = 0; i < len; i++) { 1616 glyph = qemu_pixman_glyph_from_vgafont(FONT_HEIGHT, vgafont16, msg[i]); 1617 qemu_pixman_glyph_render(glyph, surface->image, &fg, &bg, 1618 x+i, y, FONT_WIDTH, FONT_HEIGHT); 1619 qemu_pixman_image_unref(glyph); 1620 } 1621 surface->flags |= QEMU_PLACEHOLDER_FLAG; 1622 return surface; 1623 } 1624 1625 void qemu_free_displaysurface(DisplaySurface *surface) 1626 { 1627 if (surface == NULL) { 1628 return; 1629 } 1630 trace_displaysurface_free(surface); 1631 qemu_pixman_image_unref(surface->image); 1632 g_free(surface); 1633 } 1634 1635 bool console_has_gl(QemuConsole *con) 1636 { 1637 return con->gl != NULL; 1638 } 1639 1640 static bool displaychangelistener_has_dmabuf(DisplayChangeListener *dcl) 1641 { 1642 if (dcl->ops->dpy_has_dmabuf) { 1643 return dcl->ops->dpy_has_dmabuf(dcl); 1644 } 1645 1646 if (dcl->ops->dpy_gl_scanout_dmabuf) { 1647 return true; 1648 } 1649 1650 return false; 1651 } 1652 1653 static bool console_compatible_with(QemuConsole *con, 1654 DisplayChangeListener *dcl, Error **errp) 1655 { 1656 int flags; 1657 1658 flags = con->hw_ops->get_flags ? con->hw_ops->get_flags(con->hw) : 0; 1659 1660 if (console_has_gl(con) && 1661 !con->gl->ops->dpy_gl_ctx_is_compatible_dcl(con->gl, dcl)) { 1662 error_setg(errp, "Display %s is incompatible with the GL context", 1663 dcl->ops->dpy_name); 1664 return false; 1665 } 1666 1667 if (flags & GRAPHIC_FLAGS_GL && 1668 !console_has_gl(con)) { 1669 error_setg(errp, "The console requires a GL context."); 1670 return false; 1671 1672 } 1673 1674 if (flags & GRAPHIC_FLAGS_DMABUF && 1675 !displaychangelistener_has_dmabuf(dcl)) { 1676 error_setg(errp, "The console requires display DMABUF support."); 1677 return false; 1678 } 1679 1680 return true; 1681 } 1682 1683 void console_handle_touch_event(QemuConsole *con, 1684 struct touch_slot touch_slots[INPUT_EVENT_SLOTS_MAX], 1685 uint64_t num_slot, 1686 int width, int height, 1687 double x, double y, 1688 InputMultiTouchType type, 1689 Error **errp) 1690 { 1691 struct touch_slot *slot; 1692 bool needs_sync = false; 1693 int update; 1694 int i; 1695 1696 if (num_slot >= INPUT_EVENT_SLOTS_MAX) { 1697 error_setg(errp, 1698 "Unexpected touch slot number: % " PRId64" >= %d", 1699 num_slot, INPUT_EVENT_SLOTS_MAX); 1700 return; 1701 } 1702 1703 slot = &touch_slots[num_slot]; 1704 slot->x = x; 1705 slot->y = y; 1706 1707 if (type == INPUT_MULTI_TOUCH_TYPE_BEGIN) { 1708 slot->tracking_id = num_slot; 1709 } 1710 1711 for (i = 0; i < INPUT_EVENT_SLOTS_MAX; ++i) { 1712 if (i == num_slot) { 1713 update = type; 1714 } else { 1715 update = INPUT_MULTI_TOUCH_TYPE_UPDATE; 1716 } 1717 1718 slot = &touch_slots[i]; 1719 1720 if (slot->tracking_id == -1) { 1721 continue; 1722 } 1723 1724 if (update == INPUT_MULTI_TOUCH_TYPE_END) { 1725 slot->tracking_id = -1; 1726 qemu_input_queue_mtt(con, update, i, slot->tracking_id); 1727 needs_sync = true; 1728 } else { 1729 qemu_input_queue_mtt(con, update, i, slot->tracking_id); 1730 qemu_input_queue_btn(con, INPUT_BUTTON_TOUCH, true); 1731 qemu_input_queue_mtt_abs(con, 1732 INPUT_AXIS_X, (int) slot->x, 1733 0, width, 1734 i, slot->tracking_id); 1735 qemu_input_queue_mtt_abs(con, 1736 INPUT_AXIS_Y, (int) slot->y, 1737 0, height, 1738 i, slot->tracking_id); 1739 needs_sync = true; 1740 } 1741 } 1742 1743 if (needs_sync) { 1744 qemu_input_event_sync(); 1745 } 1746 } 1747 1748 void qemu_console_set_display_gl_ctx(QemuConsole *con, DisplayGLCtx *gl) 1749 { 1750 /* display has opengl support */ 1751 assert(con); 1752 if (con->gl) { 1753 error_report("The console already has an OpenGL context."); 1754 exit(1); 1755 } 1756 con->gl = gl; 1757 } 1758 1759 void register_displaychangelistener(DisplayChangeListener *dcl) 1760 { 1761 QemuConsole *con; 1762 1763 assert(!dcl->ds); 1764 1765 trace_displaychangelistener_register(dcl, dcl->ops->dpy_name); 1766 dcl->ds = get_alloc_displaystate(); 1767 QLIST_INSERT_HEAD(&dcl->ds->listeners, dcl, next); 1768 gui_setup_refresh(dcl->ds); 1769 if (dcl->con) { 1770 dcl->con->dcls++; 1771 con = dcl->con; 1772 } else { 1773 con = active_console; 1774 } 1775 displaychangelistener_display_console(dcl, con, dcl->con ? &error_fatal : NULL); 1776 if (con && con->cursor && dcl->ops->dpy_cursor_define) { 1777 dcl->ops->dpy_cursor_define(dcl, con->cursor); 1778 } 1779 if (con && dcl->ops->dpy_mouse_set) { 1780 dcl->ops->dpy_mouse_set(dcl, con->cursor_x, con->cursor_y, con->cursor_on); 1781 } 1782 text_console_update_cursor(NULL); 1783 } 1784 1785 void update_displaychangelistener(DisplayChangeListener *dcl, 1786 uint64_t interval) 1787 { 1788 DisplayState *ds = dcl->ds; 1789 1790 dcl->update_interval = interval; 1791 if (!ds->refreshing && ds->update_interval > interval) { 1792 timer_mod(ds->gui_timer, ds->last_update + interval); 1793 } 1794 } 1795 1796 void unregister_displaychangelistener(DisplayChangeListener *dcl) 1797 { 1798 DisplayState *ds = dcl->ds; 1799 trace_displaychangelistener_unregister(dcl, dcl->ops->dpy_name); 1800 if (dcl->con) { 1801 dcl->con->dcls--; 1802 } 1803 QLIST_REMOVE(dcl, next); 1804 dcl->ds = NULL; 1805 gui_setup_refresh(ds); 1806 } 1807 1808 static void dpy_set_ui_info_timer(void *opaque) 1809 { 1810 QemuConsole *con = opaque; 1811 1812 con->hw_ops->ui_info(con->hw, con->head, &con->ui_info); 1813 } 1814 1815 bool dpy_ui_info_supported(QemuConsole *con) 1816 { 1817 if (con == NULL) { 1818 con = active_console; 1819 } 1820 1821 return con->hw_ops->ui_info != NULL; 1822 } 1823 1824 const QemuUIInfo *dpy_get_ui_info(const QemuConsole *con) 1825 { 1826 if (con == NULL) { 1827 con = active_console; 1828 } 1829 1830 return &con->ui_info; 1831 } 1832 1833 int dpy_set_ui_info(QemuConsole *con, QemuUIInfo *info, bool delay) 1834 { 1835 if (con == NULL) { 1836 con = active_console; 1837 } 1838 1839 if (!dpy_ui_info_supported(con)) { 1840 return -1; 1841 } 1842 if (memcmp(&con->ui_info, info, sizeof(con->ui_info)) == 0) { 1843 /* nothing changed -- ignore */ 1844 return 0; 1845 } 1846 1847 /* 1848 * Typically we get a flood of these as the user resizes the window. 1849 * Wait until the dust has settled (one second without updates), then 1850 * go notify the guest. 1851 */ 1852 con->ui_info = *info; 1853 timer_mod(con->ui_timer, 1854 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + (delay ? 1000 : 0)); 1855 return 0; 1856 } 1857 1858 void dpy_gfx_update(QemuConsole *con, int x, int y, int w, int h) 1859 { 1860 DisplayState *s = con->ds; 1861 DisplayChangeListener *dcl; 1862 int width = qemu_console_get_width(con, x + w); 1863 int height = qemu_console_get_height(con, y + h); 1864 1865 x = MAX(x, 0); 1866 y = MAX(y, 0); 1867 x = MIN(x, width); 1868 y = MIN(y, height); 1869 w = MIN(w, width - x); 1870 h = MIN(h, height - y); 1871 1872 if (!qemu_console_is_visible(con)) { 1873 return; 1874 } 1875 dpy_gfx_update_texture(con, con->surface, x, y, w, h); 1876 QLIST_FOREACH(dcl, &s->listeners, next) { 1877 if (con != (dcl->con ? dcl->con : active_console)) { 1878 continue; 1879 } 1880 if (dcl->ops->dpy_gfx_update) { 1881 dcl->ops->dpy_gfx_update(dcl, x, y, w, h); 1882 } 1883 } 1884 } 1885 1886 void dpy_gfx_update_full(QemuConsole *con) 1887 { 1888 int w = qemu_console_get_width(con, 0); 1889 int h = qemu_console_get_height(con, 0); 1890 1891 dpy_gfx_update(con, 0, 0, w, h); 1892 } 1893 1894 void dpy_gfx_replace_surface(QemuConsole *con, 1895 DisplaySurface *surface) 1896 { 1897 static const char placeholder_msg[] = "Display output is not active."; 1898 DisplayState *s = con->ds; 1899 DisplaySurface *old_surface = con->surface; 1900 DisplayChangeListener *dcl; 1901 int width; 1902 int height; 1903 1904 if (!surface) { 1905 if (old_surface) { 1906 width = surface_width(old_surface); 1907 height = surface_height(old_surface); 1908 } else { 1909 width = 640; 1910 height = 480; 1911 } 1912 1913 surface = qemu_create_placeholder_surface(width, height, placeholder_msg); 1914 } 1915 1916 assert(old_surface != surface); 1917 1918 con->scanout.kind = SCANOUT_SURFACE; 1919 con->surface = surface; 1920 dpy_gfx_create_texture(con, surface); 1921 QLIST_FOREACH(dcl, &s->listeners, next) { 1922 if (con != (dcl->con ? dcl->con : active_console)) { 1923 continue; 1924 } 1925 displaychangelistener_gfx_switch(dcl, surface, FALSE); 1926 } 1927 dpy_gfx_destroy_texture(con, old_surface); 1928 qemu_free_displaysurface(old_surface); 1929 } 1930 1931 bool dpy_gfx_check_format(QemuConsole *con, 1932 pixman_format_code_t format) 1933 { 1934 DisplayChangeListener *dcl; 1935 DisplayState *s = con->ds; 1936 1937 QLIST_FOREACH(dcl, &s->listeners, next) { 1938 if (dcl->con && dcl->con != con) { 1939 /* dcl bound to another console -> skip */ 1940 continue; 1941 } 1942 if (dcl->ops->dpy_gfx_check_format) { 1943 if (!dcl->ops->dpy_gfx_check_format(dcl, format)) { 1944 return false; 1945 } 1946 } else { 1947 /* default is to allow native 32 bpp only */ 1948 if (format != qemu_default_pixman_format(32, true)) { 1949 return false; 1950 } 1951 } 1952 } 1953 return true; 1954 } 1955 1956 static void dpy_refresh(DisplayState *s) 1957 { 1958 DisplayChangeListener *dcl; 1959 1960 QLIST_FOREACH(dcl, &s->listeners, next) { 1961 if (dcl->ops->dpy_refresh) { 1962 dcl->ops->dpy_refresh(dcl); 1963 } 1964 } 1965 } 1966 1967 void dpy_text_cursor(QemuConsole *con, int x, int y) 1968 { 1969 DisplayState *s = con->ds; 1970 DisplayChangeListener *dcl; 1971 1972 if (!qemu_console_is_visible(con)) { 1973 return; 1974 } 1975 QLIST_FOREACH(dcl, &s->listeners, next) { 1976 if (con != (dcl->con ? dcl->con : active_console)) { 1977 continue; 1978 } 1979 if (dcl->ops->dpy_text_cursor) { 1980 dcl->ops->dpy_text_cursor(dcl, x, y); 1981 } 1982 } 1983 } 1984 1985 void dpy_text_update(QemuConsole *con, int x, int y, int w, int h) 1986 { 1987 DisplayState *s = con->ds; 1988 DisplayChangeListener *dcl; 1989 1990 if (!qemu_console_is_visible(con)) { 1991 return; 1992 } 1993 QLIST_FOREACH(dcl, &s->listeners, next) { 1994 if (con != (dcl->con ? dcl->con : active_console)) { 1995 continue; 1996 } 1997 if (dcl->ops->dpy_text_update) { 1998 dcl->ops->dpy_text_update(dcl, x, y, w, h); 1999 } 2000 } 2001 } 2002 2003 void dpy_text_resize(QemuConsole *con, int w, int h) 2004 { 2005 DisplayState *s = con->ds; 2006 DisplayChangeListener *dcl; 2007 2008 if (!qemu_console_is_visible(con)) { 2009 return; 2010 } 2011 QLIST_FOREACH(dcl, &s->listeners, next) { 2012 if (con != (dcl->con ? dcl->con : active_console)) { 2013 continue; 2014 } 2015 if (dcl->ops->dpy_text_resize) { 2016 dcl->ops->dpy_text_resize(dcl, w, h); 2017 } 2018 } 2019 } 2020 2021 void dpy_mouse_set(QemuConsole *con, int x, int y, int on) 2022 { 2023 DisplayState *s = con->ds; 2024 DisplayChangeListener *dcl; 2025 2026 con->cursor_x = x; 2027 con->cursor_y = y; 2028 con->cursor_on = on; 2029 if (!qemu_console_is_visible(con)) { 2030 return; 2031 } 2032 QLIST_FOREACH(dcl, &s->listeners, next) { 2033 if (con != (dcl->con ? dcl->con : active_console)) { 2034 continue; 2035 } 2036 if (dcl->ops->dpy_mouse_set) { 2037 dcl->ops->dpy_mouse_set(dcl, x, y, on); 2038 } 2039 } 2040 } 2041 2042 void dpy_cursor_define(QemuConsole *con, QEMUCursor *cursor) 2043 { 2044 DisplayState *s = con->ds; 2045 DisplayChangeListener *dcl; 2046 2047 cursor_unref(con->cursor); 2048 con->cursor = cursor_ref(cursor); 2049 if (!qemu_console_is_visible(con)) { 2050 return; 2051 } 2052 QLIST_FOREACH(dcl, &s->listeners, next) { 2053 if (con != (dcl->con ? dcl->con : active_console)) { 2054 continue; 2055 } 2056 if (dcl->ops->dpy_cursor_define) { 2057 dcl->ops->dpy_cursor_define(dcl, cursor); 2058 } 2059 } 2060 } 2061 2062 bool dpy_cursor_define_supported(QemuConsole *con) 2063 { 2064 DisplayState *s = con->ds; 2065 DisplayChangeListener *dcl; 2066 2067 QLIST_FOREACH(dcl, &s->listeners, next) { 2068 if (dcl->ops->dpy_cursor_define) { 2069 return true; 2070 } 2071 } 2072 return false; 2073 } 2074 2075 QEMUGLContext dpy_gl_ctx_create(QemuConsole *con, 2076 struct QEMUGLParams *qparams) 2077 { 2078 assert(con->gl); 2079 return con->gl->ops->dpy_gl_ctx_create(con->gl, qparams); 2080 } 2081 2082 void dpy_gl_ctx_destroy(QemuConsole *con, QEMUGLContext ctx) 2083 { 2084 assert(con->gl); 2085 con->gl->ops->dpy_gl_ctx_destroy(con->gl, ctx); 2086 } 2087 2088 int dpy_gl_ctx_make_current(QemuConsole *con, QEMUGLContext ctx) 2089 { 2090 assert(con->gl); 2091 return con->gl->ops->dpy_gl_ctx_make_current(con->gl, ctx); 2092 } 2093 2094 void dpy_gl_scanout_disable(QemuConsole *con) 2095 { 2096 DisplayState *s = con->ds; 2097 DisplayChangeListener *dcl; 2098 2099 if (con->scanout.kind != SCANOUT_SURFACE) { 2100 con->scanout.kind = SCANOUT_NONE; 2101 } 2102 QLIST_FOREACH(dcl, &s->listeners, next) { 2103 if (con != (dcl->con ? dcl->con : active_console)) { 2104 continue; 2105 } 2106 if (dcl->ops->dpy_gl_scanout_disable) { 2107 dcl->ops->dpy_gl_scanout_disable(dcl); 2108 } 2109 } 2110 } 2111 2112 void dpy_gl_scanout_texture(QemuConsole *con, 2113 uint32_t backing_id, 2114 bool backing_y_0_top, 2115 uint32_t backing_width, 2116 uint32_t backing_height, 2117 uint32_t x, uint32_t y, 2118 uint32_t width, uint32_t height) 2119 { 2120 DisplayState *s = con->ds; 2121 DisplayChangeListener *dcl; 2122 2123 con->scanout.kind = SCANOUT_TEXTURE; 2124 con->scanout.texture = (ScanoutTexture) { 2125 backing_id, backing_y_0_top, backing_width, backing_height, 2126 x, y, width, height 2127 }; 2128 QLIST_FOREACH(dcl, &s->listeners, next) { 2129 if (con != (dcl->con ? dcl->con : active_console)) { 2130 continue; 2131 } 2132 if (dcl->ops->dpy_gl_scanout_texture) { 2133 dcl->ops->dpy_gl_scanout_texture(dcl, backing_id, 2134 backing_y_0_top, 2135 backing_width, backing_height, 2136 x, y, width, height); 2137 } 2138 } 2139 } 2140 2141 void dpy_gl_scanout_dmabuf(QemuConsole *con, 2142 QemuDmaBuf *dmabuf) 2143 { 2144 DisplayState *s = con->ds; 2145 DisplayChangeListener *dcl; 2146 2147 con->scanout.kind = SCANOUT_DMABUF; 2148 con->scanout.dmabuf = dmabuf; 2149 QLIST_FOREACH(dcl, &s->listeners, next) { 2150 if (con != (dcl->con ? dcl->con : active_console)) { 2151 continue; 2152 } 2153 if (dcl->ops->dpy_gl_scanout_dmabuf) { 2154 dcl->ops->dpy_gl_scanout_dmabuf(dcl, dmabuf); 2155 } 2156 } 2157 } 2158 2159 void dpy_gl_cursor_dmabuf(QemuConsole *con, QemuDmaBuf *dmabuf, 2160 bool have_hot, uint32_t hot_x, uint32_t hot_y) 2161 { 2162 DisplayState *s = con->ds; 2163 DisplayChangeListener *dcl; 2164 2165 QLIST_FOREACH(dcl, &s->listeners, next) { 2166 if (con != (dcl->con ? dcl->con : active_console)) { 2167 continue; 2168 } 2169 if (dcl->ops->dpy_gl_cursor_dmabuf) { 2170 dcl->ops->dpy_gl_cursor_dmabuf(dcl, dmabuf, 2171 have_hot, hot_x, hot_y); 2172 } 2173 } 2174 } 2175 2176 void dpy_gl_cursor_position(QemuConsole *con, 2177 uint32_t pos_x, uint32_t pos_y) 2178 { 2179 DisplayState *s = con->ds; 2180 DisplayChangeListener *dcl; 2181 2182 QLIST_FOREACH(dcl, &s->listeners, next) { 2183 if (con != (dcl->con ? dcl->con : active_console)) { 2184 continue; 2185 } 2186 if (dcl->ops->dpy_gl_cursor_position) { 2187 dcl->ops->dpy_gl_cursor_position(dcl, pos_x, pos_y); 2188 } 2189 } 2190 } 2191 2192 void dpy_gl_release_dmabuf(QemuConsole *con, 2193 QemuDmaBuf *dmabuf) 2194 { 2195 DisplayState *s = con->ds; 2196 DisplayChangeListener *dcl; 2197 2198 QLIST_FOREACH(dcl, &s->listeners, next) { 2199 if (con != (dcl->con ? dcl->con : active_console)) { 2200 continue; 2201 } 2202 if (dcl->ops->dpy_gl_release_dmabuf) { 2203 dcl->ops->dpy_gl_release_dmabuf(dcl, dmabuf); 2204 } 2205 } 2206 } 2207 2208 void dpy_gl_update(QemuConsole *con, 2209 uint32_t x, uint32_t y, uint32_t w, uint32_t h) 2210 { 2211 DisplayState *s = con->ds; 2212 DisplayChangeListener *dcl; 2213 2214 assert(con->gl); 2215 2216 graphic_hw_gl_block(con, true); 2217 QLIST_FOREACH(dcl, &s->listeners, next) { 2218 if (con != (dcl->con ? dcl->con : active_console)) { 2219 continue; 2220 } 2221 if (dcl->ops->dpy_gl_update) { 2222 dcl->ops->dpy_gl_update(dcl, x, y, w, h); 2223 } 2224 } 2225 graphic_hw_gl_block(con, false); 2226 } 2227 2228 /***********************************************************/ 2229 /* register display */ 2230 2231 /* console.c internal use only */ 2232 static DisplayState *get_alloc_displaystate(void) 2233 { 2234 if (!display_state) { 2235 display_state = g_new0(DisplayState, 1); 2236 cursor_timer = timer_new_ms(QEMU_CLOCK_REALTIME, 2237 text_console_update_cursor, NULL); 2238 } 2239 return display_state; 2240 } 2241 2242 /* 2243 * Called by main(), after creating QemuConsoles 2244 * and before initializing ui (sdl/vnc/...). 2245 */ 2246 DisplayState *init_displaystate(void) 2247 { 2248 gchar *name; 2249 QemuConsole *con; 2250 2251 get_alloc_displaystate(); 2252 QTAILQ_FOREACH(con, &consoles, next) { 2253 if (con->console_type != GRAPHIC_CONSOLE && 2254 con->ds == NULL) { 2255 text_console_do_init(con->chr, display_state); 2256 } 2257 2258 /* Hook up into the qom tree here (not in new_console()), once 2259 * all QemuConsoles are created and the order / numbering 2260 * doesn't change any more */ 2261 name = g_strdup_printf("console[%d]", con->index); 2262 object_property_add_child(container_get(object_get_root(), "/backend"), 2263 name, OBJECT(con)); 2264 g_free(name); 2265 } 2266 2267 return display_state; 2268 } 2269 2270 void graphic_console_set_hwops(QemuConsole *con, 2271 const GraphicHwOps *hw_ops, 2272 void *opaque) 2273 { 2274 con->hw_ops = hw_ops; 2275 con->hw = opaque; 2276 } 2277 2278 QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head, 2279 const GraphicHwOps *hw_ops, 2280 void *opaque) 2281 { 2282 static const char noinit[] = 2283 "Guest has not initialized the display (yet)."; 2284 int width = 640; 2285 int height = 480; 2286 QemuConsole *s; 2287 DisplayState *ds; 2288 DisplaySurface *surface; 2289 2290 ds = get_alloc_displaystate(); 2291 s = qemu_console_lookup_unused(); 2292 if (s) { 2293 trace_console_gfx_reuse(s->index); 2294 width = qemu_console_get_width(s, 0); 2295 height = qemu_console_get_height(s, 0); 2296 } else { 2297 trace_console_gfx_new(); 2298 s = new_console(ds, GRAPHIC_CONSOLE, head); 2299 s->ui_timer = timer_new_ms(QEMU_CLOCK_REALTIME, 2300 dpy_set_ui_info_timer, s); 2301 } 2302 graphic_console_set_hwops(s, hw_ops, opaque); 2303 if (dev) { 2304 object_property_set_link(OBJECT(s), "device", OBJECT(dev), 2305 &error_abort); 2306 } 2307 2308 surface = qemu_create_placeholder_surface(width, height, noinit); 2309 dpy_gfx_replace_surface(s, surface); 2310 s->gl_unblock_timer = timer_new_ms(QEMU_CLOCK_REALTIME, 2311 graphic_hw_gl_unblock_timer, s); 2312 return s; 2313 } 2314 2315 static const GraphicHwOps unused_ops = { 2316 /* no callbacks */ 2317 }; 2318 2319 void graphic_console_close(QemuConsole *con) 2320 { 2321 static const char unplugged[] = 2322 "Guest display has been unplugged"; 2323 DisplaySurface *surface; 2324 int width = qemu_console_get_width(con, 640); 2325 int height = qemu_console_get_height(con, 480); 2326 2327 trace_console_gfx_close(con->index); 2328 object_property_set_link(OBJECT(con), "device", NULL, &error_abort); 2329 graphic_console_set_hwops(con, &unused_ops, NULL); 2330 2331 if (con->gl) { 2332 dpy_gl_scanout_disable(con); 2333 } 2334 surface = qemu_create_placeholder_surface(width, height, unplugged); 2335 dpy_gfx_replace_surface(con, surface); 2336 } 2337 2338 QemuConsole *qemu_console_lookup_by_index(unsigned int index) 2339 { 2340 QemuConsole *con; 2341 2342 QTAILQ_FOREACH(con, &consoles, next) { 2343 if (con->index == index) { 2344 return con; 2345 } 2346 } 2347 return NULL; 2348 } 2349 2350 QemuConsole *qemu_console_lookup_by_device(DeviceState *dev, uint32_t head) 2351 { 2352 QemuConsole *con; 2353 Object *obj; 2354 uint32_t h; 2355 2356 QTAILQ_FOREACH(con, &consoles, next) { 2357 obj = object_property_get_link(OBJECT(con), 2358 "device", &error_abort); 2359 if (DEVICE(obj) != dev) { 2360 continue; 2361 } 2362 h = object_property_get_uint(OBJECT(con), 2363 "head", &error_abort); 2364 if (h != head) { 2365 continue; 2366 } 2367 return con; 2368 } 2369 return NULL; 2370 } 2371 2372 QemuConsole *qemu_console_lookup_by_device_name(const char *device_id, 2373 uint32_t head, Error **errp) 2374 { 2375 DeviceState *dev; 2376 QemuConsole *con; 2377 2378 dev = qdev_find_recursive(sysbus_get_default(), device_id); 2379 if (dev == NULL) { 2380 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, 2381 "Device '%s' not found", device_id); 2382 return NULL; 2383 } 2384 2385 con = qemu_console_lookup_by_device(dev, head); 2386 if (con == NULL) { 2387 error_setg(errp, "Device %s (head %d) is not bound to a QemuConsole", 2388 device_id, head); 2389 return NULL; 2390 } 2391 2392 return con; 2393 } 2394 2395 QemuConsole *qemu_console_lookup_unused(void) 2396 { 2397 QemuConsole *con; 2398 Object *obj; 2399 2400 QTAILQ_FOREACH(con, &consoles, next) { 2401 if (con->hw_ops != &unused_ops) { 2402 continue; 2403 } 2404 obj = object_property_get_link(OBJECT(con), 2405 "device", &error_abort); 2406 if (obj != NULL) { 2407 continue; 2408 } 2409 return con; 2410 } 2411 return NULL; 2412 } 2413 2414 QEMUCursor *qemu_console_get_cursor(QemuConsole *con) 2415 { 2416 if (con == NULL) { 2417 con = active_console; 2418 } 2419 return con ? con->cursor : NULL; 2420 } 2421 2422 bool qemu_console_is_visible(QemuConsole *con) 2423 { 2424 return (con == active_console) || (con->dcls > 0); 2425 } 2426 2427 bool qemu_console_is_graphic(QemuConsole *con) 2428 { 2429 if (con == NULL) { 2430 con = active_console; 2431 } 2432 return con && (con->console_type == GRAPHIC_CONSOLE); 2433 } 2434 2435 bool qemu_console_is_fixedsize(QemuConsole *con) 2436 { 2437 if (con == NULL) { 2438 con = active_console; 2439 } 2440 return con && (con->console_type != TEXT_CONSOLE); 2441 } 2442 2443 bool qemu_console_is_gl_blocked(QemuConsole *con) 2444 { 2445 assert(con != NULL); 2446 return con->gl_block; 2447 } 2448 2449 bool qemu_console_is_multihead(DeviceState *dev) 2450 { 2451 QemuConsole *con; 2452 Object *obj; 2453 uint32_t f = 0xffffffff; 2454 uint32_t h; 2455 2456 QTAILQ_FOREACH(con, &consoles, next) { 2457 obj = object_property_get_link(OBJECT(con), 2458 "device", &error_abort); 2459 if (DEVICE(obj) != dev) { 2460 continue; 2461 } 2462 2463 h = object_property_get_uint(OBJECT(con), 2464 "head", &error_abort); 2465 if (f == 0xffffffff) { 2466 f = h; 2467 } else if (h != f) { 2468 return true; 2469 } 2470 } 2471 return false; 2472 } 2473 2474 char *qemu_console_get_label(QemuConsole *con) 2475 { 2476 if (con->console_type == GRAPHIC_CONSOLE) { 2477 if (con->device) { 2478 DeviceState *dev; 2479 bool multihead; 2480 2481 dev = DEVICE(con->device); 2482 multihead = qemu_console_is_multihead(dev); 2483 if (multihead) { 2484 return g_strdup_printf("%s.%d", dev->id ? 2485 dev->id : 2486 object_get_typename(con->device), 2487 con->head); 2488 } else { 2489 return g_strdup_printf("%s", dev->id ? 2490 dev->id : 2491 object_get_typename(con->device)); 2492 } 2493 } 2494 return g_strdup("VGA"); 2495 } else { 2496 if (con->chr && con->chr->label) { 2497 return g_strdup(con->chr->label); 2498 } 2499 return g_strdup_printf("vc%d", con->index); 2500 } 2501 } 2502 2503 int qemu_console_get_index(QemuConsole *con) 2504 { 2505 if (con == NULL) { 2506 con = active_console; 2507 } 2508 return con ? con->index : -1; 2509 } 2510 2511 uint32_t qemu_console_get_head(QemuConsole *con) 2512 { 2513 if (con == NULL) { 2514 con = active_console; 2515 } 2516 return con ? con->head : -1; 2517 } 2518 2519 int qemu_console_get_width(QemuConsole *con, int fallback) 2520 { 2521 if (con == NULL) { 2522 con = active_console; 2523 } 2524 if (con == NULL) { 2525 return fallback; 2526 } 2527 switch (con->scanout.kind) { 2528 case SCANOUT_DMABUF: 2529 return con->scanout.dmabuf->width; 2530 case SCANOUT_TEXTURE: 2531 return con->scanout.texture.width; 2532 case SCANOUT_SURFACE: 2533 return surface_width(con->surface); 2534 default: 2535 return fallback; 2536 } 2537 } 2538 2539 int qemu_console_get_height(QemuConsole *con, int fallback) 2540 { 2541 if (con == NULL) { 2542 con = active_console; 2543 } 2544 if (con == NULL) { 2545 return fallback; 2546 } 2547 switch (con->scanout.kind) { 2548 case SCANOUT_DMABUF: 2549 return con->scanout.dmabuf->height; 2550 case SCANOUT_TEXTURE: 2551 return con->scanout.texture.height; 2552 case SCANOUT_SURFACE: 2553 return surface_height(con->surface); 2554 default: 2555 return fallback; 2556 } 2557 } 2558 2559 static void vc_chr_accept_input(Chardev *chr) 2560 { 2561 VCChardev *drv = VC_CHARDEV(chr); 2562 QemuConsole *s = drv->console; 2563 2564 kbd_send_chars(s); 2565 } 2566 2567 static void vc_chr_set_echo(Chardev *chr, bool echo) 2568 { 2569 VCChardev *drv = VC_CHARDEV(chr); 2570 QemuConsole *s = drv->console; 2571 2572 s->echo = echo; 2573 } 2574 2575 static void text_console_update_cursor_timer(void) 2576 { 2577 timer_mod(cursor_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) 2578 + CONSOLE_CURSOR_PERIOD / 2); 2579 } 2580 2581 static void text_console_update_cursor(void *opaque) 2582 { 2583 QemuConsole *s; 2584 int count = 0; 2585 2586 cursor_visible_phase = !cursor_visible_phase; 2587 2588 QTAILQ_FOREACH(s, &consoles, next) { 2589 if (qemu_console_is_graphic(s) || 2590 !qemu_console_is_visible(s)) { 2591 continue; 2592 } 2593 count++; 2594 graphic_hw_invalidate(s); 2595 } 2596 2597 if (count) { 2598 text_console_update_cursor_timer(); 2599 } 2600 } 2601 2602 static const GraphicHwOps text_console_ops = { 2603 .invalidate = text_console_invalidate, 2604 .text_update = text_console_update, 2605 }; 2606 2607 static void text_console_do_init(Chardev *chr, DisplayState *ds) 2608 { 2609 VCChardev *drv = VC_CHARDEV(chr); 2610 QemuConsole *s = drv->console; 2611 int g_width = 80 * FONT_WIDTH; 2612 int g_height = 24 * FONT_HEIGHT; 2613 2614 fifo8_create(&s->out_fifo, 16); 2615 s->ds = ds; 2616 2617 s->y_displayed = 0; 2618 s->y_base = 0; 2619 s->total_height = DEFAULT_BACKSCROLL; 2620 s->x = 0; 2621 s->y = 0; 2622 if (s->scanout.kind != SCANOUT_SURFACE) { 2623 if (active_console && active_console->scanout.kind == SCANOUT_SURFACE) { 2624 g_width = qemu_console_get_width(active_console, g_width); 2625 g_height = qemu_console_get_height(active_console, g_height); 2626 } 2627 s->surface = qemu_create_displaysurface(g_width, g_height); 2628 s->scanout.kind = SCANOUT_SURFACE; 2629 } 2630 2631 s->hw_ops = &text_console_ops; 2632 s->hw = s; 2633 2634 /* Set text attribute defaults */ 2635 s->t_attrib_default.bold = 0; 2636 s->t_attrib_default.uline = 0; 2637 s->t_attrib_default.blink = 0; 2638 s->t_attrib_default.invers = 0; 2639 s->t_attrib_default.unvisible = 0; 2640 s->t_attrib_default.fgcol = QEMU_COLOR_WHITE; 2641 s->t_attrib_default.bgcol = QEMU_COLOR_BLACK; 2642 /* set current text attributes to default */ 2643 s->t_attrib = s->t_attrib_default; 2644 text_console_resize(s); 2645 2646 if (chr->label) { 2647 char *msg; 2648 2649 s->t_attrib.bgcol = QEMU_COLOR_BLUE; 2650 msg = g_strdup_printf("%s console\r\n", chr->label); 2651 vc_chr_write(chr, (uint8_t *)msg, strlen(msg)); 2652 g_free(msg); 2653 s->t_attrib = s->t_attrib_default; 2654 } 2655 2656 qemu_chr_be_event(chr, CHR_EVENT_OPENED); 2657 } 2658 2659 static void vc_chr_open(Chardev *chr, 2660 ChardevBackend *backend, 2661 bool *be_opened, 2662 Error **errp) 2663 { 2664 ChardevVC *vc = backend->u.vc.data; 2665 VCChardev *drv = VC_CHARDEV(chr); 2666 QemuConsole *s; 2667 unsigned width = 0; 2668 unsigned height = 0; 2669 2670 if (vc->has_width) { 2671 width = vc->width; 2672 } else if (vc->has_cols) { 2673 width = vc->cols * FONT_WIDTH; 2674 } 2675 2676 if (vc->has_height) { 2677 height = vc->height; 2678 } else if (vc->has_rows) { 2679 height = vc->rows * FONT_HEIGHT; 2680 } 2681 2682 trace_console_txt_new(width, height); 2683 if (width == 0 || height == 0) { 2684 s = new_console(NULL, TEXT_CONSOLE, 0); 2685 } else { 2686 s = new_console(NULL, TEXT_CONSOLE_FIXED_SIZE, 0); 2687 s->scanout.kind = SCANOUT_SURFACE; 2688 s->surface = qemu_create_displaysurface(width, height); 2689 } 2690 2691 if (!s) { 2692 error_setg(errp, "cannot create text console"); 2693 return; 2694 } 2695 2696 s->chr = chr; 2697 drv->console = s; 2698 2699 if (display_state) { 2700 text_console_do_init(chr, display_state); 2701 } 2702 2703 /* console/chardev init sometimes completes elsewhere in a 2nd 2704 * stage, so defer OPENED events until they are fully initialized 2705 */ 2706 *be_opened = false; 2707 } 2708 2709 void qemu_console_resize(QemuConsole *s, int width, int height) 2710 { 2711 DisplaySurface *surface = qemu_console_surface(s); 2712 2713 assert(s->console_type == GRAPHIC_CONSOLE); 2714 2715 if ((s->scanout.kind != SCANOUT_SURFACE || 2716 (surface && surface->flags & QEMU_ALLOCATED_FLAG)) && 2717 qemu_console_get_width(s, -1) == width && 2718 qemu_console_get_height(s, -1) == height) { 2719 return; 2720 } 2721 2722 surface = qemu_create_displaysurface(width, height); 2723 dpy_gfx_replace_surface(s, surface); 2724 } 2725 2726 DisplaySurface *qemu_console_surface(QemuConsole *console) 2727 { 2728 switch (console->scanout.kind) { 2729 case SCANOUT_SURFACE: 2730 return console->surface; 2731 default: 2732 return NULL; 2733 } 2734 } 2735 2736 PixelFormat qemu_default_pixelformat(int bpp) 2737 { 2738 pixman_format_code_t fmt = qemu_default_pixman_format(bpp, true); 2739 PixelFormat pf = qemu_pixelformat_from_pixman(fmt); 2740 return pf; 2741 } 2742 2743 static QemuDisplay *dpys[DISPLAY_TYPE__MAX]; 2744 2745 void qemu_display_register(QemuDisplay *ui) 2746 { 2747 assert(ui->type < DISPLAY_TYPE__MAX); 2748 dpys[ui->type] = ui; 2749 } 2750 2751 bool qemu_display_find_default(DisplayOptions *opts) 2752 { 2753 static DisplayType prio[] = { 2754 #if defined(CONFIG_GTK) 2755 DISPLAY_TYPE_GTK, 2756 #endif 2757 #if defined(CONFIG_SDL) 2758 DISPLAY_TYPE_SDL, 2759 #endif 2760 #if defined(CONFIG_COCOA) 2761 DISPLAY_TYPE_COCOA 2762 #endif 2763 }; 2764 int i; 2765 2766 for (i = 0; i < (int)ARRAY_SIZE(prio); i++) { 2767 if (dpys[prio[i]] == NULL) { 2768 Error *local_err = NULL; 2769 int rv = ui_module_load(DisplayType_str(prio[i]), &local_err); 2770 if (rv < 0) { 2771 error_report_err(local_err); 2772 } 2773 } 2774 if (dpys[prio[i]] == NULL) { 2775 continue; 2776 } 2777 opts->type = prio[i]; 2778 return true; 2779 } 2780 return false; 2781 } 2782 2783 void qemu_display_early_init(DisplayOptions *opts) 2784 { 2785 assert(opts->type < DISPLAY_TYPE__MAX); 2786 if (opts->type == DISPLAY_TYPE_NONE) { 2787 return; 2788 } 2789 if (dpys[opts->type] == NULL) { 2790 Error *local_err = NULL; 2791 int rv = ui_module_load(DisplayType_str(opts->type), &local_err); 2792 if (rv < 0) { 2793 error_report_err(local_err); 2794 } 2795 } 2796 if (dpys[opts->type] == NULL) { 2797 error_report("Display '%s' is not available.", 2798 DisplayType_str(opts->type)); 2799 exit(1); 2800 } 2801 if (dpys[opts->type]->early_init) { 2802 dpys[opts->type]->early_init(opts); 2803 } 2804 } 2805 2806 void qemu_display_init(DisplayState *ds, DisplayOptions *opts) 2807 { 2808 assert(opts->type < DISPLAY_TYPE__MAX); 2809 if (opts->type == DISPLAY_TYPE_NONE) { 2810 return; 2811 } 2812 assert(dpys[opts->type] != NULL); 2813 dpys[opts->type]->init(ds, opts); 2814 } 2815 2816 void qemu_display_help(void) 2817 { 2818 int idx; 2819 2820 printf("Available display backend types:\n"); 2821 printf("none\n"); 2822 for (idx = DISPLAY_TYPE_NONE; idx < DISPLAY_TYPE__MAX; idx++) { 2823 if (!dpys[idx]) { 2824 Error *local_err = NULL; 2825 int rv = ui_module_load(DisplayType_str(idx), &local_err); 2826 if (rv < 0) { 2827 error_report_err(local_err); 2828 } 2829 } 2830 if (dpys[idx]) { 2831 printf("%s\n", DisplayType_str(dpys[idx]->type)); 2832 } 2833 } 2834 } 2835 2836 void qemu_chr_parse_vc(QemuOpts *opts, ChardevBackend *backend, Error **errp) 2837 { 2838 int val; 2839 ChardevVC *vc; 2840 2841 backend->type = CHARDEV_BACKEND_KIND_VC; 2842 vc = backend->u.vc.data = g_new0(ChardevVC, 1); 2843 qemu_chr_parse_common(opts, qapi_ChardevVC_base(vc)); 2844 2845 val = qemu_opt_get_number(opts, "width", 0); 2846 if (val != 0) { 2847 vc->has_width = true; 2848 vc->width = val; 2849 } 2850 2851 val = qemu_opt_get_number(opts, "height", 0); 2852 if (val != 0) { 2853 vc->has_height = true; 2854 vc->height = val; 2855 } 2856 2857 val = qemu_opt_get_number(opts, "cols", 0); 2858 if (val != 0) { 2859 vc->has_cols = true; 2860 vc->cols = val; 2861 } 2862 2863 val = qemu_opt_get_number(opts, "rows", 0); 2864 if (val != 0) { 2865 vc->has_rows = true; 2866 vc->rows = val; 2867 } 2868 } 2869 2870 static const TypeInfo qemu_console_info = { 2871 .name = TYPE_QEMU_CONSOLE, 2872 .parent = TYPE_OBJECT, 2873 .instance_size = sizeof(QemuConsole), 2874 .class_size = sizeof(QemuConsoleClass), 2875 }; 2876 2877 static void char_vc_class_init(ObjectClass *oc, void *data) 2878 { 2879 ChardevClass *cc = CHARDEV_CLASS(oc); 2880 2881 cc->parse = qemu_chr_parse_vc; 2882 cc->open = vc_chr_open; 2883 cc->chr_write = vc_chr_write; 2884 cc->chr_accept_input = vc_chr_accept_input; 2885 cc->chr_set_echo = vc_chr_set_echo; 2886 } 2887 2888 static const TypeInfo char_vc_type_info = { 2889 .name = TYPE_CHARDEV_VC, 2890 .parent = TYPE_CHARDEV, 2891 .instance_size = sizeof(VCChardev), 2892 .class_init = char_vc_class_init, 2893 }; 2894 2895 void qemu_console_early_init(void) 2896 { 2897 /* set the default vc driver */ 2898 if (!object_class_by_name(TYPE_CHARDEV_VC)) { 2899 type_register(&char_vc_type_info); 2900 } 2901 } 2902 2903 static void register_types(void) 2904 { 2905 type_register_static(&qemu_console_info); 2906 } 2907 2908 type_init(register_types); 2909