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 #include "qemu-common.h" 25 #include "ui/console.h" 26 #include "hw/qdev-core.h" 27 #include "qemu/timer.h" 28 #include "qmp-commands.h" 29 #include "sysemu/char.h" 30 #include "trace.h" 31 32 #define DEFAULT_BACKSCROLL 512 33 #define MAX_CONSOLES 12 34 #define CONSOLE_CURSOR_PERIOD 500 35 36 typedef struct TextAttributes { 37 uint8_t fgcol:4; 38 uint8_t bgcol:4; 39 uint8_t bold:1; 40 uint8_t uline:1; 41 uint8_t blink:1; 42 uint8_t invers:1; 43 uint8_t unvisible:1; 44 } TextAttributes; 45 46 typedef struct TextCell { 47 uint8_t ch; 48 TextAttributes t_attrib; 49 } TextCell; 50 51 #define MAX_ESC_PARAMS 3 52 53 enum TTYState { 54 TTY_STATE_NORM, 55 TTY_STATE_ESC, 56 TTY_STATE_CSI, 57 }; 58 59 typedef struct QEMUFIFO { 60 uint8_t *buf; 61 int buf_size; 62 int count, wptr, rptr; 63 } QEMUFIFO; 64 65 static int qemu_fifo_write(QEMUFIFO *f, const uint8_t *buf, int len1) 66 { 67 int l, len; 68 69 l = f->buf_size - f->count; 70 if (len1 > l) 71 len1 = l; 72 len = len1; 73 while (len > 0) { 74 l = f->buf_size - f->wptr; 75 if (l > len) 76 l = len; 77 memcpy(f->buf + f->wptr, buf, l); 78 f->wptr += l; 79 if (f->wptr >= f->buf_size) 80 f->wptr = 0; 81 buf += l; 82 len -= l; 83 } 84 f->count += len1; 85 return len1; 86 } 87 88 static int qemu_fifo_read(QEMUFIFO *f, uint8_t *buf, int len1) 89 { 90 int l, len; 91 92 if (len1 > f->count) 93 len1 = f->count; 94 len = len1; 95 while (len > 0) { 96 l = f->buf_size - f->rptr; 97 if (l > len) 98 l = len; 99 memcpy(buf, f->buf + f->rptr, l); 100 f->rptr += l; 101 if (f->rptr >= f->buf_size) 102 f->rptr = 0; 103 buf += l; 104 len -= l; 105 } 106 f->count -= len1; 107 return len1; 108 } 109 110 typedef enum { 111 GRAPHIC_CONSOLE, 112 TEXT_CONSOLE, 113 TEXT_CONSOLE_FIXED_SIZE 114 } console_type_t; 115 116 struct QemuConsole { 117 Object parent; 118 119 int index; 120 console_type_t console_type; 121 DisplayState *ds; 122 DisplaySurface *surface; 123 int dcls; 124 125 /* Graphic console state. */ 126 Object *device; 127 const GraphicHwOps *hw_ops; 128 void *hw; 129 130 /* Text console state */ 131 int width; 132 int height; 133 int total_height; 134 int backscroll_height; 135 int x, y; 136 int x_saved, y_saved; 137 int y_displayed; 138 int y_base; 139 TextAttributes t_attrib_default; /* default text attributes */ 140 TextAttributes t_attrib; /* currently active text attributes */ 141 TextCell *cells; 142 int text_x[2], text_y[2], cursor_invalidate; 143 int echo; 144 bool cursor_visible_phase; 145 QEMUTimer *cursor_timer; 146 147 int update_x0; 148 int update_y0; 149 int update_x1; 150 int update_y1; 151 152 enum TTYState state; 153 int esc_params[MAX_ESC_PARAMS]; 154 int nb_esc_params; 155 156 CharDriverState *chr; 157 /* fifo for key pressed */ 158 QEMUFIFO out_fifo; 159 uint8_t out_fifo_buf[16]; 160 QEMUTimer *kbd_timer; 161 }; 162 163 struct DisplayState { 164 QEMUTimer *gui_timer; 165 uint64_t last_update; 166 uint64_t update_interval; 167 bool refreshing; 168 bool have_gfx; 169 bool have_text; 170 171 QLIST_HEAD(, DisplayChangeListener) listeners; 172 }; 173 174 static DisplayState *display_state; 175 static QemuConsole *active_console; 176 static QemuConsole *consoles[MAX_CONSOLES]; 177 static int nb_consoles = 0; 178 179 static void text_console_do_init(CharDriverState *chr, DisplayState *ds); 180 static void dpy_refresh(DisplayState *s); 181 static DisplayState *get_alloc_displaystate(void); 182 183 static void gui_update(void *opaque) 184 { 185 uint64_t interval = GUI_REFRESH_INTERVAL_IDLE; 186 uint64_t dcl_interval; 187 DisplayState *ds = opaque; 188 DisplayChangeListener *dcl; 189 int i; 190 191 ds->refreshing = true; 192 dpy_refresh(ds); 193 ds->refreshing = false; 194 195 QLIST_FOREACH(dcl, &ds->listeners, next) { 196 dcl_interval = dcl->update_interval ? 197 dcl->update_interval : GUI_REFRESH_INTERVAL_DEFAULT; 198 if (interval > dcl_interval) { 199 interval = dcl_interval; 200 } 201 } 202 if (ds->update_interval != interval) { 203 ds->update_interval = interval; 204 for (i = 0; i < nb_consoles; i++) { 205 if (consoles[i]->hw_ops->update_interval) { 206 consoles[i]->hw_ops->update_interval(consoles[i]->hw, interval); 207 } 208 } 209 trace_console_refresh(interval); 210 } 211 ds->last_update = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); 212 timer_mod(ds->gui_timer, ds->last_update + interval); 213 } 214 215 static void gui_setup_refresh(DisplayState *ds) 216 { 217 DisplayChangeListener *dcl; 218 bool need_timer = false; 219 bool have_gfx = false; 220 bool have_text = false; 221 222 QLIST_FOREACH(dcl, &ds->listeners, next) { 223 if (dcl->ops->dpy_refresh != NULL) { 224 need_timer = true; 225 } 226 if (dcl->ops->dpy_gfx_update != NULL) { 227 have_gfx = true; 228 } 229 if (dcl->ops->dpy_text_update != NULL) { 230 have_text = true; 231 } 232 } 233 234 if (need_timer && ds->gui_timer == NULL) { 235 ds->gui_timer = timer_new_ms(QEMU_CLOCK_REALTIME, gui_update, ds); 236 timer_mod(ds->gui_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME)); 237 } 238 if (!need_timer && ds->gui_timer != NULL) { 239 timer_del(ds->gui_timer); 240 timer_free(ds->gui_timer); 241 ds->gui_timer = NULL; 242 } 243 244 ds->have_gfx = have_gfx; 245 ds->have_text = have_text; 246 } 247 248 void graphic_hw_update(QemuConsole *con) 249 { 250 if (!con) { 251 con = active_console; 252 } 253 if (con && con->hw_ops->gfx_update) { 254 con->hw_ops->gfx_update(con->hw); 255 } 256 } 257 258 void graphic_hw_invalidate(QemuConsole *con) 259 { 260 if (!con) { 261 con = active_console; 262 } 263 if (con && con->hw_ops->invalidate) { 264 con->hw_ops->invalidate(con->hw); 265 } 266 } 267 268 static void ppm_save(const char *filename, struct DisplaySurface *ds, 269 Error **errp) 270 { 271 int width = pixman_image_get_width(ds->image); 272 int height = pixman_image_get_height(ds->image); 273 int fd; 274 FILE *f; 275 int y; 276 int ret; 277 pixman_image_t *linebuf; 278 279 trace_ppm_save(filename, ds); 280 fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666); 281 if (fd == -1) { 282 error_setg(errp, "failed to open file '%s': %s", filename, 283 strerror(errno)); 284 return; 285 } 286 f = fdopen(fd, "wb"); 287 ret = fprintf(f, "P6\n%d %d\n%d\n", width, height, 255); 288 if (ret < 0) { 289 linebuf = NULL; 290 goto write_err; 291 } 292 linebuf = qemu_pixman_linebuf_create(PIXMAN_BE_r8g8b8, width); 293 for (y = 0; y < height; y++) { 294 qemu_pixman_linebuf_fill(linebuf, ds->image, width, 0, y); 295 clearerr(f); 296 ret = fwrite(pixman_image_get_data(linebuf), 1, 297 pixman_image_get_stride(linebuf), f); 298 (void)ret; 299 if (ferror(f)) { 300 goto write_err; 301 } 302 } 303 304 out: 305 qemu_pixman_image_unref(linebuf); 306 fclose(f); 307 return; 308 309 write_err: 310 error_setg(errp, "failed to write to file '%s': %s", filename, 311 strerror(errno)); 312 unlink(filename); 313 goto out; 314 } 315 316 void qmp_screendump(const char *filename, Error **errp) 317 { 318 QemuConsole *con = qemu_console_lookup_by_index(0); 319 DisplaySurface *surface; 320 321 if (con == NULL) { 322 error_setg(errp, "There is no QemuConsole I can screendump from."); 323 return; 324 } 325 326 graphic_hw_update(con); 327 surface = qemu_console_surface(con); 328 ppm_save(filename, surface, errp); 329 } 330 331 void graphic_hw_text_update(QemuConsole *con, console_ch_t *chardata) 332 { 333 if (!con) { 334 con = active_console; 335 } 336 if (con && con->hw_ops->text_update) { 337 con->hw_ops->text_update(con->hw, chardata); 338 } 339 } 340 341 static void vga_fill_rect(QemuConsole *con, 342 int posx, int posy, int width, int height, 343 pixman_color_t color) 344 { 345 DisplaySurface *surface = qemu_console_surface(con); 346 pixman_rectangle16_t rect = { 347 .x = posx, .y = posy, .width = width, .height = height 348 }; 349 350 pixman_image_fill_rectangles(PIXMAN_OP_SRC, surface->image, 351 &color, 1, &rect); 352 } 353 354 /* copy from (xs, ys) to (xd, yd) a rectangle of size (w, h) */ 355 static void vga_bitblt(QemuConsole *con, 356 int xs, int ys, int xd, int yd, int w, int h) 357 { 358 DisplaySurface *surface = qemu_console_surface(con); 359 360 pixman_image_composite(PIXMAN_OP_SRC, 361 surface->image, NULL, surface->image, 362 xs, ys, 0, 0, xd, yd, w, h); 363 } 364 365 /***********************************************************/ 366 /* basic char display */ 367 368 #define FONT_HEIGHT 16 369 #define FONT_WIDTH 8 370 371 #include "vgafont.h" 372 373 #ifndef CONFIG_CURSES 374 enum color_names { 375 COLOR_BLACK = 0, 376 COLOR_RED = 1, 377 COLOR_GREEN = 2, 378 COLOR_YELLOW = 3, 379 COLOR_BLUE = 4, 380 COLOR_MAGENTA = 5, 381 COLOR_CYAN = 6, 382 COLOR_WHITE = 7 383 }; 384 #endif 385 386 #define QEMU_RGB(r, g, b) \ 387 { .red = r << 8, .green = g << 8, .blue = b << 8, .alpha = 0xffff } 388 389 static const pixman_color_t color_table_rgb[2][8] = { 390 { /* dark */ 391 QEMU_RGB(0x00, 0x00, 0x00), /* black */ 392 QEMU_RGB(0xaa, 0x00, 0x00), /* red */ 393 QEMU_RGB(0x00, 0xaa, 0x00), /* green */ 394 QEMU_RGB(0xaa, 0xaa, 0x00), /* yellow */ 395 QEMU_RGB(0x00, 0x00, 0xaa), /* blue */ 396 QEMU_RGB(0xaa, 0x00, 0xaa), /* magenta */ 397 QEMU_RGB(0x00, 0xaa, 0xaa), /* cyan */ 398 QEMU_RGB(0xaa, 0xaa, 0xaa), /* white */ 399 }, 400 { /* bright */ 401 QEMU_RGB(0x00, 0x00, 0x00), /* black */ 402 QEMU_RGB(0xff, 0x00, 0x00), /* red */ 403 QEMU_RGB(0x00, 0xff, 0x00), /* green */ 404 QEMU_RGB(0xff, 0xff, 0x00), /* yellow */ 405 QEMU_RGB(0x00, 0x00, 0xff), /* blue */ 406 QEMU_RGB(0xff, 0x00, 0xff), /* magenta */ 407 QEMU_RGB(0x00, 0xff, 0xff), /* cyan */ 408 QEMU_RGB(0xff, 0xff, 0xff), /* white */ 409 } 410 }; 411 412 static void vga_putcharxy(QemuConsole *s, int x, int y, int ch, 413 TextAttributes *t_attrib) 414 { 415 static pixman_image_t *glyphs[256]; 416 DisplaySurface *surface = qemu_console_surface(s); 417 pixman_color_t fgcol, bgcol; 418 419 if (t_attrib->invers) { 420 bgcol = color_table_rgb[t_attrib->bold][t_attrib->fgcol]; 421 fgcol = color_table_rgb[t_attrib->bold][t_attrib->bgcol]; 422 } else { 423 fgcol = color_table_rgb[t_attrib->bold][t_attrib->fgcol]; 424 bgcol = color_table_rgb[t_attrib->bold][t_attrib->bgcol]; 425 } 426 427 if (!glyphs[ch]) { 428 glyphs[ch] = qemu_pixman_glyph_from_vgafont(FONT_HEIGHT, vgafont16, ch); 429 } 430 qemu_pixman_glyph_render(glyphs[ch], surface->image, 431 &fgcol, &bgcol, x, y, FONT_WIDTH, FONT_HEIGHT); 432 } 433 434 static void text_console_resize(QemuConsole *s) 435 { 436 TextCell *cells, *c, *c1; 437 int w1, x, y, last_width; 438 439 last_width = s->width; 440 s->width = surface_width(s->surface) / FONT_WIDTH; 441 s->height = surface_height(s->surface) / FONT_HEIGHT; 442 443 w1 = last_width; 444 if (s->width < w1) 445 w1 = s->width; 446 447 cells = g_malloc(s->width * s->total_height * sizeof(TextCell)); 448 for(y = 0; y < s->total_height; y++) { 449 c = &cells[y * s->width]; 450 if (w1 > 0) { 451 c1 = &s->cells[y * last_width]; 452 for(x = 0; x < w1; x++) { 453 *c++ = *c1++; 454 } 455 } 456 for(x = w1; x < s->width; x++) { 457 c->ch = ' '; 458 c->t_attrib = s->t_attrib_default; 459 c++; 460 } 461 } 462 g_free(s->cells); 463 s->cells = cells; 464 } 465 466 static inline void text_update_xy(QemuConsole *s, int x, int y) 467 { 468 s->text_x[0] = MIN(s->text_x[0], x); 469 s->text_x[1] = MAX(s->text_x[1], x); 470 s->text_y[0] = MIN(s->text_y[0], y); 471 s->text_y[1] = MAX(s->text_y[1], y); 472 } 473 474 static void invalidate_xy(QemuConsole *s, int x, int y) 475 { 476 if (s->update_x0 > x * FONT_WIDTH) 477 s->update_x0 = x * FONT_WIDTH; 478 if (s->update_y0 > y * FONT_HEIGHT) 479 s->update_y0 = y * FONT_HEIGHT; 480 if (s->update_x1 < (x + 1) * FONT_WIDTH) 481 s->update_x1 = (x + 1) * FONT_WIDTH; 482 if (s->update_y1 < (y + 1) * FONT_HEIGHT) 483 s->update_y1 = (y + 1) * FONT_HEIGHT; 484 } 485 486 static void update_xy(QemuConsole *s, int x, int y) 487 { 488 TextCell *c; 489 int y1, y2; 490 491 if (!qemu_console_is_visible(s)) { 492 return; 493 } 494 495 if (s->ds->have_text) { 496 text_update_xy(s, x, y); 497 } 498 499 if (s->ds->have_gfx) { 500 y1 = (s->y_base + y) % s->total_height; 501 y2 = y1 - s->y_displayed; 502 if (y2 < 0) 503 y2 += s->total_height; 504 if (y2 < s->height) { 505 c = &s->cells[y1 * s->width + x]; 506 vga_putcharxy(s, x, y2, c->ch, 507 &(c->t_attrib)); 508 invalidate_xy(s, x, y2); 509 } 510 } 511 } 512 513 static void console_show_cursor(QemuConsole *s, int show) 514 { 515 TextCell *c; 516 int y, y1; 517 int x = s->x; 518 519 if (!qemu_console_is_visible(s)) { 520 return; 521 } 522 523 if (s->ds->have_text) { 524 s->cursor_invalidate = 1; 525 } 526 527 if (s->ds->have_gfx) { 528 if (x >= s->width) { 529 x = s->width - 1; 530 } 531 y1 = (s->y_base + s->y) % s->total_height; 532 y = y1 - s->y_displayed; 533 if (y < 0) 534 y += s->total_height; 535 if (y < s->height) { 536 c = &s->cells[y1 * s->width + x]; 537 if (show && s->cursor_visible_phase) { 538 TextAttributes t_attrib = s->t_attrib_default; 539 t_attrib.invers = !(t_attrib.invers); /* invert fg and bg */ 540 vga_putcharxy(s, x, y, c->ch, &t_attrib); 541 } else { 542 vga_putcharxy(s, x, y, c->ch, &(c->t_attrib)); 543 } 544 invalidate_xy(s, x, y); 545 } 546 } 547 } 548 549 static void console_refresh(QemuConsole *s) 550 { 551 DisplaySurface *surface = qemu_console_surface(s); 552 TextCell *c; 553 int x, y, y1; 554 555 if (!qemu_console_is_visible(s)) { 556 return; 557 } 558 559 if (s->ds->have_text) { 560 s->text_x[0] = 0; 561 s->text_y[0] = 0; 562 s->text_x[1] = s->width - 1; 563 s->text_y[1] = s->height - 1; 564 s->cursor_invalidate = 1; 565 } 566 567 if (s->ds->have_gfx) { 568 vga_fill_rect(s, 0, 0, surface_width(surface), surface_height(surface), 569 color_table_rgb[0][COLOR_BLACK]); 570 y1 = s->y_displayed; 571 for (y = 0; y < s->height; y++) { 572 c = s->cells + y1 * s->width; 573 for (x = 0; x < s->width; x++) { 574 vga_putcharxy(s, x, y, c->ch, 575 &(c->t_attrib)); 576 c++; 577 } 578 if (++y1 == s->total_height) { 579 y1 = 0; 580 } 581 } 582 console_show_cursor(s, 1); 583 dpy_gfx_update(s, 0, 0, 584 surface_width(surface), surface_height(surface)); 585 } 586 } 587 588 static void console_scroll(QemuConsole *s, int ydelta) 589 { 590 int i, y1; 591 592 if (ydelta > 0) { 593 for(i = 0; i < ydelta; i++) { 594 if (s->y_displayed == s->y_base) 595 break; 596 if (++s->y_displayed == s->total_height) 597 s->y_displayed = 0; 598 } 599 } else { 600 ydelta = -ydelta; 601 i = s->backscroll_height; 602 if (i > s->total_height - s->height) 603 i = s->total_height - s->height; 604 y1 = s->y_base - i; 605 if (y1 < 0) 606 y1 += s->total_height; 607 for(i = 0; i < ydelta; i++) { 608 if (s->y_displayed == y1) 609 break; 610 if (--s->y_displayed < 0) 611 s->y_displayed = s->total_height - 1; 612 } 613 } 614 console_refresh(s); 615 } 616 617 static void console_put_lf(QemuConsole *s) 618 { 619 TextCell *c; 620 int x, y1; 621 622 s->y++; 623 if (s->y >= s->height) { 624 s->y = s->height - 1; 625 626 if (s->y_displayed == s->y_base) { 627 if (++s->y_displayed == s->total_height) 628 s->y_displayed = 0; 629 } 630 if (++s->y_base == s->total_height) 631 s->y_base = 0; 632 if (s->backscroll_height < s->total_height) 633 s->backscroll_height++; 634 y1 = (s->y_base + s->height - 1) % s->total_height; 635 c = &s->cells[y1 * s->width]; 636 for(x = 0; x < s->width; x++) { 637 c->ch = ' '; 638 c->t_attrib = s->t_attrib_default; 639 c++; 640 } 641 if (qemu_console_is_visible(s) && s->y_displayed == s->y_base) { 642 if (s->ds->have_text) { 643 s->text_x[0] = 0; 644 s->text_y[0] = 0; 645 s->text_x[1] = s->width - 1; 646 s->text_y[1] = s->height - 1; 647 } 648 649 if (s->ds->have_gfx) { 650 vga_bitblt(s, 0, FONT_HEIGHT, 0, 0, 651 s->width * FONT_WIDTH, 652 (s->height - 1) * FONT_HEIGHT); 653 vga_fill_rect(s, 0, (s->height - 1) * FONT_HEIGHT, 654 s->width * FONT_WIDTH, FONT_HEIGHT, 655 color_table_rgb[0][s->t_attrib_default.bgcol]); 656 s->update_x0 = 0; 657 s->update_y0 = 0; 658 s->update_x1 = s->width * FONT_WIDTH; 659 s->update_y1 = s->height * FONT_HEIGHT; 660 } 661 } 662 } 663 } 664 665 /* Set console attributes depending on the current escape codes. 666 * NOTE: I know this code is not very efficient (checking every color for it 667 * self) but it is more readable and better maintainable. 668 */ 669 static void console_handle_escape(QemuConsole *s) 670 { 671 int i; 672 673 for (i=0; i<s->nb_esc_params; i++) { 674 switch (s->esc_params[i]) { 675 case 0: /* reset all console attributes to default */ 676 s->t_attrib = s->t_attrib_default; 677 break; 678 case 1: 679 s->t_attrib.bold = 1; 680 break; 681 case 4: 682 s->t_attrib.uline = 1; 683 break; 684 case 5: 685 s->t_attrib.blink = 1; 686 break; 687 case 7: 688 s->t_attrib.invers = 1; 689 break; 690 case 8: 691 s->t_attrib.unvisible = 1; 692 break; 693 case 22: 694 s->t_attrib.bold = 0; 695 break; 696 case 24: 697 s->t_attrib.uline = 0; 698 break; 699 case 25: 700 s->t_attrib.blink = 0; 701 break; 702 case 27: 703 s->t_attrib.invers = 0; 704 break; 705 case 28: 706 s->t_attrib.unvisible = 0; 707 break; 708 /* set foreground color */ 709 case 30: 710 s->t_attrib.fgcol=COLOR_BLACK; 711 break; 712 case 31: 713 s->t_attrib.fgcol=COLOR_RED; 714 break; 715 case 32: 716 s->t_attrib.fgcol=COLOR_GREEN; 717 break; 718 case 33: 719 s->t_attrib.fgcol=COLOR_YELLOW; 720 break; 721 case 34: 722 s->t_attrib.fgcol=COLOR_BLUE; 723 break; 724 case 35: 725 s->t_attrib.fgcol=COLOR_MAGENTA; 726 break; 727 case 36: 728 s->t_attrib.fgcol=COLOR_CYAN; 729 break; 730 case 37: 731 s->t_attrib.fgcol=COLOR_WHITE; 732 break; 733 /* set background color */ 734 case 40: 735 s->t_attrib.bgcol=COLOR_BLACK; 736 break; 737 case 41: 738 s->t_attrib.bgcol=COLOR_RED; 739 break; 740 case 42: 741 s->t_attrib.bgcol=COLOR_GREEN; 742 break; 743 case 43: 744 s->t_attrib.bgcol=COLOR_YELLOW; 745 break; 746 case 44: 747 s->t_attrib.bgcol=COLOR_BLUE; 748 break; 749 case 45: 750 s->t_attrib.bgcol=COLOR_MAGENTA; 751 break; 752 case 46: 753 s->t_attrib.bgcol=COLOR_CYAN; 754 break; 755 case 47: 756 s->t_attrib.bgcol=COLOR_WHITE; 757 break; 758 } 759 } 760 } 761 762 static void console_clear_xy(QemuConsole *s, int x, int y) 763 { 764 int y1 = (s->y_base + y) % s->total_height; 765 TextCell *c = &s->cells[y1 * s->width + x]; 766 c->ch = ' '; 767 c->t_attrib = s->t_attrib_default; 768 update_xy(s, x, y); 769 } 770 771 /* set cursor, checking bounds */ 772 static void set_cursor(QemuConsole *s, int x, int y) 773 { 774 if (x < 0) { 775 x = 0; 776 } 777 if (y < 0) { 778 y = 0; 779 } 780 if (y >= s->height) { 781 y = s->height - 1; 782 } 783 if (x >= s->width) { 784 x = s->width - 1; 785 } 786 787 s->x = x; 788 s->y = y; 789 } 790 791 static void console_putchar(QemuConsole *s, int ch) 792 { 793 TextCell *c; 794 int y1, i; 795 int x, y; 796 797 switch(s->state) { 798 case TTY_STATE_NORM: 799 switch(ch) { 800 case '\r': /* carriage return */ 801 s->x = 0; 802 break; 803 case '\n': /* newline */ 804 console_put_lf(s); 805 break; 806 case '\b': /* backspace */ 807 if (s->x > 0) 808 s->x--; 809 break; 810 case '\t': /* tabspace */ 811 if (s->x + (8 - (s->x % 8)) > s->width) { 812 s->x = 0; 813 console_put_lf(s); 814 } else { 815 s->x = s->x + (8 - (s->x % 8)); 816 } 817 break; 818 case '\a': /* alert aka. bell */ 819 /* TODO: has to be implemented */ 820 break; 821 case 14: 822 /* SI (shift in), character set 0 (ignored) */ 823 break; 824 case 15: 825 /* SO (shift out), character set 1 (ignored) */ 826 break; 827 case 27: /* esc (introducing an escape sequence) */ 828 s->state = TTY_STATE_ESC; 829 break; 830 default: 831 if (s->x >= s->width) { 832 /* line wrap */ 833 s->x = 0; 834 console_put_lf(s); 835 } 836 y1 = (s->y_base + s->y) % s->total_height; 837 c = &s->cells[y1 * s->width + s->x]; 838 c->ch = ch; 839 c->t_attrib = s->t_attrib; 840 update_xy(s, s->x, s->y); 841 s->x++; 842 break; 843 } 844 break; 845 case TTY_STATE_ESC: /* check if it is a terminal escape sequence */ 846 if (ch == '[') { 847 for(i=0;i<MAX_ESC_PARAMS;i++) 848 s->esc_params[i] = 0; 849 s->nb_esc_params = 0; 850 s->state = TTY_STATE_CSI; 851 } else { 852 s->state = TTY_STATE_NORM; 853 } 854 break; 855 case TTY_STATE_CSI: /* handle escape sequence parameters */ 856 if (ch >= '0' && ch <= '9') { 857 if (s->nb_esc_params < MAX_ESC_PARAMS) { 858 int *param = &s->esc_params[s->nb_esc_params]; 859 int digit = (ch - '0'); 860 861 *param = (*param <= (INT_MAX - digit) / 10) ? 862 *param * 10 + digit : INT_MAX; 863 } 864 } else { 865 if (s->nb_esc_params < MAX_ESC_PARAMS) 866 s->nb_esc_params++; 867 if (ch == ';') 868 break; 869 trace_console_putchar_csi(s->esc_params[0], s->esc_params[1], 870 ch, s->nb_esc_params); 871 s->state = TTY_STATE_NORM; 872 switch(ch) { 873 case 'A': 874 /* move cursor up */ 875 if (s->esc_params[0] == 0) { 876 s->esc_params[0] = 1; 877 } 878 set_cursor(s, s->x, s->y - s->esc_params[0]); 879 break; 880 case 'B': 881 /* move cursor down */ 882 if (s->esc_params[0] == 0) { 883 s->esc_params[0] = 1; 884 } 885 set_cursor(s, s->x, s->y + s->esc_params[0]); 886 break; 887 case 'C': 888 /* move cursor right */ 889 if (s->esc_params[0] == 0) { 890 s->esc_params[0] = 1; 891 } 892 set_cursor(s, s->x + s->esc_params[0], s->y); 893 break; 894 case 'D': 895 /* move cursor left */ 896 if (s->esc_params[0] == 0) { 897 s->esc_params[0] = 1; 898 } 899 set_cursor(s, s->x - s->esc_params[0], s->y); 900 break; 901 case 'G': 902 /* move cursor to column */ 903 set_cursor(s, s->esc_params[0] - 1, s->y); 904 break; 905 case 'f': 906 case 'H': 907 /* move cursor to row, column */ 908 set_cursor(s, s->esc_params[1] - 1, s->esc_params[0] - 1); 909 break; 910 case 'J': 911 switch (s->esc_params[0]) { 912 case 0: 913 /* clear to end of screen */ 914 for (y = s->y; y < s->height; y++) { 915 for (x = 0; x < s->width; x++) { 916 if (y == s->y && x < s->x) { 917 continue; 918 } 919 console_clear_xy(s, x, y); 920 } 921 } 922 break; 923 case 1: 924 /* clear from beginning of screen */ 925 for (y = 0; y <= s->y; y++) { 926 for (x = 0; x < s->width; x++) { 927 if (y == s->y && x > s->x) { 928 break; 929 } 930 console_clear_xy(s, x, y); 931 } 932 } 933 break; 934 case 2: 935 /* clear entire screen */ 936 for (y = 0; y <= s->height; y++) { 937 for (x = 0; x < s->width; x++) { 938 console_clear_xy(s, x, y); 939 } 940 } 941 break; 942 } 943 break; 944 case 'K': 945 switch (s->esc_params[0]) { 946 case 0: 947 /* clear to eol */ 948 for(x = s->x; x < s->width; x++) { 949 console_clear_xy(s, x, s->y); 950 } 951 break; 952 case 1: 953 /* clear from beginning of line */ 954 for (x = 0; x <= s->x; x++) { 955 console_clear_xy(s, x, s->y); 956 } 957 break; 958 case 2: 959 /* clear entire line */ 960 for(x = 0; x < s->width; x++) { 961 console_clear_xy(s, x, s->y); 962 } 963 break; 964 } 965 break; 966 case 'm': 967 console_handle_escape(s); 968 break; 969 case 'n': 970 /* report cursor position */ 971 /* TODO: send ESC[row;colR */ 972 break; 973 case 's': 974 /* save cursor position */ 975 s->x_saved = s->x; 976 s->y_saved = s->y; 977 break; 978 case 'u': 979 /* restore cursor position */ 980 s->x = s->x_saved; 981 s->y = s->y_saved; 982 break; 983 default: 984 trace_console_putchar_unhandled(ch); 985 break; 986 } 987 break; 988 } 989 } 990 } 991 992 void console_select(unsigned int index) 993 { 994 DisplayChangeListener *dcl; 995 QemuConsole *s; 996 997 if (index >= MAX_CONSOLES) 998 return; 999 1000 trace_console_select(index); 1001 s = qemu_console_lookup_by_index(index); 1002 if (s) { 1003 DisplayState *ds = s->ds; 1004 1005 if (active_console && active_console->cursor_timer) { 1006 timer_del(active_console->cursor_timer); 1007 } 1008 active_console = s; 1009 if (ds->have_gfx) { 1010 QLIST_FOREACH(dcl, &ds->listeners, next) { 1011 if (dcl->con != NULL) { 1012 continue; 1013 } 1014 if (dcl->ops->dpy_gfx_switch) { 1015 dcl->ops->dpy_gfx_switch(dcl, s->surface); 1016 } 1017 } 1018 dpy_gfx_update(s, 0, 0, surface_width(s->surface), 1019 surface_height(s->surface)); 1020 } 1021 if (ds->have_text) { 1022 dpy_text_resize(s, s->width, s->height); 1023 } 1024 if (s->cursor_timer) { 1025 timer_mod(s->cursor_timer, 1026 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + CONSOLE_CURSOR_PERIOD / 2); 1027 } 1028 } 1029 } 1030 1031 static int console_puts(CharDriverState *chr, const uint8_t *buf, int len) 1032 { 1033 QemuConsole *s = chr->opaque; 1034 int i; 1035 1036 s->update_x0 = s->width * FONT_WIDTH; 1037 s->update_y0 = s->height * FONT_HEIGHT; 1038 s->update_x1 = 0; 1039 s->update_y1 = 0; 1040 console_show_cursor(s, 0); 1041 for(i = 0; i < len; i++) { 1042 console_putchar(s, buf[i]); 1043 } 1044 console_show_cursor(s, 1); 1045 if (s->ds->have_gfx && s->update_x0 < s->update_x1) { 1046 dpy_gfx_update(s, s->update_x0, s->update_y0, 1047 s->update_x1 - s->update_x0, 1048 s->update_y1 - s->update_y0); 1049 } 1050 return len; 1051 } 1052 1053 static void kbd_send_chars(void *opaque) 1054 { 1055 QemuConsole *s = opaque; 1056 int len; 1057 uint8_t buf[16]; 1058 1059 len = qemu_chr_be_can_write(s->chr); 1060 if (len > s->out_fifo.count) 1061 len = s->out_fifo.count; 1062 if (len > 0) { 1063 if (len > sizeof(buf)) 1064 len = sizeof(buf); 1065 qemu_fifo_read(&s->out_fifo, buf, len); 1066 qemu_chr_be_write(s->chr, buf, len); 1067 } 1068 /* characters are pending: we send them a bit later (XXX: 1069 horrible, should change char device API) */ 1070 if (s->out_fifo.count > 0) { 1071 timer_mod(s->kbd_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1); 1072 } 1073 } 1074 1075 /* called when an ascii key is pressed */ 1076 void kbd_put_keysym(int keysym) 1077 { 1078 QemuConsole *s; 1079 uint8_t buf[16], *q; 1080 int c; 1081 1082 s = active_console; 1083 if (!s || (s->console_type == GRAPHIC_CONSOLE)) 1084 return; 1085 1086 switch(keysym) { 1087 case QEMU_KEY_CTRL_UP: 1088 console_scroll(s, -1); 1089 break; 1090 case QEMU_KEY_CTRL_DOWN: 1091 console_scroll(s, 1); 1092 break; 1093 case QEMU_KEY_CTRL_PAGEUP: 1094 console_scroll(s, -10); 1095 break; 1096 case QEMU_KEY_CTRL_PAGEDOWN: 1097 console_scroll(s, 10); 1098 break; 1099 default: 1100 /* convert the QEMU keysym to VT100 key string */ 1101 q = buf; 1102 if (keysym >= 0xe100 && keysym <= 0xe11f) { 1103 *q++ = '\033'; 1104 *q++ = '['; 1105 c = keysym - 0xe100; 1106 if (c >= 10) 1107 *q++ = '0' + (c / 10); 1108 *q++ = '0' + (c % 10); 1109 *q++ = '~'; 1110 } else if (keysym >= 0xe120 && keysym <= 0xe17f) { 1111 *q++ = '\033'; 1112 *q++ = '['; 1113 *q++ = keysym & 0xff; 1114 } else if (s->echo && (keysym == '\r' || keysym == '\n')) { 1115 console_puts(s->chr, (const uint8_t *) "\r", 1); 1116 *q++ = '\n'; 1117 } else { 1118 *q++ = keysym; 1119 } 1120 if (s->echo) { 1121 console_puts(s->chr, buf, q - buf); 1122 } 1123 if (s->chr->chr_read) { 1124 qemu_fifo_write(&s->out_fifo, buf, q - buf); 1125 kbd_send_chars(s); 1126 } 1127 break; 1128 } 1129 } 1130 1131 static void text_console_invalidate(void *opaque) 1132 { 1133 QemuConsole *s = (QemuConsole *) opaque; 1134 1135 if (s->ds->have_text && s->console_type == TEXT_CONSOLE) { 1136 text_console_resize(s); 1137 } 1138 console_refresh(s); 1139 } 1140 1141 static void text_console_update(void *opaque, console_ch_t *chardata) 1142 { 1143 QemuConsole *s = (QemuConsole *) opaque; 1144 int i, j, src; 1145 1146 if (s->text_x[0] <= s->text_x[1]) { 1147 src = (s->y_base + s->text_y[0]) * s->width; 1148 chardata += s->text_y[0] * s->width; 1149 for (i = s->text_y[0]; i <= s->text_y[1]; i ++) 1150 for (j = 0; j < s->width; j ++, src ++) 1151 console_write_ch(chardata ++, s->cells[src].ch | 1152 (s->cells[src].t_attrib.fgcol << 12) | 1153 (s->cells[src].t_attrib.bgcol << 8) | 1154 (s->cells[src].t_attrib.bold << 21)); 1155 dpy_text_update(s, s->text_x[0], s->text_y[0], 1156 s->text_x[1] - s->text_x[0], i - s->text_y[0]); 1157 s->text_x[0] = s->width; 1158 s->text_y[0] = s->height; 1159 s->text_x[1] = 0; 1160 s->text_y[1] = 0; 1161 } 1162 if (s->cursor_invalidate) { 1163 dpy_text_cursor(s, s->x, s->y); 1164 s->cursor_invalidate = 0; 1165 } 1166 } 1167 1168 static QemuConsole *new_console(DisplayState *ds, console_type_t console_type) 1169 { 1170 Error *local_err = NULL; 1171 Object *obj; 1172 QemuConsole *s; 1173 int i; 1174 1175 if (nb_consoles >= MAX_CONSOLES) 1176 return NULL; 1177 1178 obj = object_new(TYPE_QEMU_CONSOLE); 1179 s = QEMU_CONSOLE(obj); 1180 object_property_add_link(obj, "device", TYPE_DEVICE, 1181 (Object **)&s->device, &local_err); 1182 1183 if (!active_console || ((active_console->console_type != GRAPHIC_CONSOLE) && 1184 (console_type == GRAPHIC_CONSOLE))) { 1185 active_console = s; 1186 } 1187 s->ds = ds; 1188 s->console_type = console_type; 1189 if (console_type != GRAPHIC_CONSOLE) { 1190 s->index = nb_consoles; 1191 consoles[nb_consoles++] = s; 1192 } else { 1193 /* HACK: Put graphical consoles before text consoles. */ 1194 for (i = nb_consoles; i > 0; i--) { 1195 if (consoles[i - 1]->console_type == GRAPHIC_CONSOLE) 1196 break; 1197 consoles[i] = consoles[i - 1]; 1198 consoles[i]->index = i; 1199 } 1200 s->index = i; 1201 consoles[i] = s; 1202 nb_consoles++; 1203 } 1204 return s; 1205 } 1206 1207 static void qemu_alloc_display(DisplaySurface *surface, int width, int height, 1208 int linesize, PixelFormat pf, int newflags) 1209 { 1210 surface->pf = pf; 1211 1212 qemu_pixman_image_unref(surface->image); 1213 surface->image = NULL; 1214 1215 surface->format = qemu_pixman_get_format(&pf); 1216 assert(surface->format != 0); 1217 surface->image = pixman_image_create_bits(surface->format, 1218 width, height, 1219 NULL, linesize); 1220 assert(surface->image != NULL); 1221 1222 surface->flags = newflags | QEMU_ALLOCATED_FLAG; 1223 #ifdef HOST_WORDS_BIGENDIAN 1224 surface->flags |= QEMU_BIG_ENDIAN_FLAG; 1225 #endif 1226 } 1227 1228 DisplaySurface *qemu_create_displaysurface(int width, int height) 1229 { 1230 DisplaySurface *surface = g_new0(DisplaySurface, 1); 1231 int linesize = width * 4; 1232 1233 trace_displaysurface_create(surface, width, height); 1234 qemu_alloc_display(surface, width, height, linesize, 1235 qemu_default_pixelformat(32), 0); 1236 return surface; 1237 } 1238 1239 DisplaySurface *qemu_create_displaysurface_from(int width, int height, int bpp, 1240 int linesize, uint8_t *data, 1241 bool byteswap) 1242 { 1243 DisplaySurface *surface = g_new0(DisplaySurface, 1); 1244 1245 trace_displaysurface_create_from(surface, width, height, bpp, byteswap); 1246 if (byteswap) { 1247 surface->pf = qemu_different_endianness_pixelformat(bpp); 1248 } else { 1249 surface->pf = qemu_default_pixelformat(bpp); 1250 } 1251 1252 surface->format = qemu_pixman_get_format(&surface->pf); 1253 assert(surface->format != 0); 1254 surface->image = pixman_image_create_bits(surface->format, 1255 width, height, 1256 (void *)data, linesize); 1257 assert(surface->image != NULL); 1258 1259 #ifdef HOST_WORDS_BIGENDIAN 1260 surface->flags = QEMU_BIG_ENDIAN_FLAG; 1261 #endif 1262 1263 return surface; 1264 } 1265 1266 static DisplaySurface *qemu_create_dummy_surface(void) 1267 { 1268 static const char msg[] = 1269 "This VM has no graphic display device."; 1270 DisplaySurface *surface = qemu_create_displaysurface(640, 480); 1271 pixman_color_t bg = color_table_rgb[0][COLOR_BLACK]; 1272 pixman_color_t fg = color_table_rgb[0][COLOR_WHITE]; 1273 pixman_image_t *glyph; 1274 int len, x, y, i; 1275 1276 len = strlen(msg); 1277 x = (640/FONT_WIDTH - len) / 2; 1278 y = (480/FONT_HEIGHT - 1) / 2; 1279 for (i = 0; i < len; i++) { 1280 glyph = qemu_pixman_glyph_from_vgafont(FONT_HEIGHT, vgafont16, msg[i]); 1281 qemu_pixman_glyph_render(glyph, surface->image, &fg, &bg, 1282 x+i, y, FONT_WIDTH, FONT_HEIGHT); 1283 qemu_pixman_image_unref(glyph); 1284 } 1285 return surface; 1286 } 1287 1288 void qemu_free_displaysurface(DisplaySurface *surface) 1289 { 1290 if (surface == NULL) { 1291 return; 1292 } 1293 trace_displaysurface_free(surface); 1294 qemu_pixman_image_unref(surface->image); 1295 g_free(surface); 1296 } 1297 1298 void register_displaychangelistener(DisplayChangeListener *dcl) 1299 { 1300 static DisplaySurface *dummy; 1301 QemuConsole *con; 1302 1303 trace_displaychangelistener_register(dcl, dcl->ops->dpy_name); 1304 dcl->ds = get_alloc_displaystate(); 1305 QLIST_INSERT_HEAD(&dcl->ds->listeners, dcl, next); 1306 gui_setup_refresh(dcl->ds); 1307 if (dcl->con) { 1308 dcl->con->dcls++; 1309 con = dcl->con; 1310 } else { 1311 con = active_console; 1312 } 1313 if (dcl->ops->dpy_gfx_switch) { 1314 if (con) { 1315 dcl->ops->dpy_gfx_switch(dcl, con->surface); 1316 } else { 1317 if (!dummy) { 1318 dummy = qemu_create_dummy_surface(); 1319 } 1320 dcl->ops->dpy_gfx_switch(dcl, dummy); 1321 } 1322 } 1323 } 1324 1325 void update_displaychangelistener(DisplayChangeListener *dcl, 1326 uint64_t interval) 1327 { 1328 DisplayState *ds = dcl->ds; 1329 1330 dcl->update_interval = interval; 1331 if (!ds->refreshing && ds->update_interval > interval) { 1332 timer_mod(ds->gui_timer, ds->last_update + interval); 1333 } 1334 } 1335 1336 void unregister_displaychangelistener(DisplayChangeListener *dcl) 1337 { 1338 DisplayState *ds = dcl->ds; 1339 trace_displaychangelistener_unregister(dcl, dcl->ops->dpy_name); 1340 if (dcl->con) { 1341 dcl->con->dcls--; 1342 } 1343 QLIST_REMOVE(dcl, next); 1344 gui_setup_refresh(ds); 1345 } 1346 1347 void dpy_gfx_update(QemuConsole *con, int x, int y, int w, int h) 1348 { 1349 DisplayState *s = con->ds; 1350 DisplayChangeListener *dcl; 1351 int width = surface_width(con->surface); 1352 int height = surface_height(con->surface); 1353 1354 x = MAX(x, 0); 1355 y = MAX(y, 0); 1356 x = MIN(x, width); 1357 y = MIN(y, height); 1358 w = MIN(w, width - x); 1359 h = MIN(h, height - y); 1360 1361 if (!qemu_console_is_visible(con)) { 1362 return; 1363 } 1364 QLIST_FOREACH(dcl, &s->listeners, next) { 1365 if (con != (dcl->con ? dcl->con : active_console)) { 1366 continue; 1367 } 1368 if (dcl->ops->dpy_gfx_update) { 1369 dcl->ops->dpy_gfx_update(dcl, x, y, w, h); 1370 } 1371 } 1372 } 1373 1374 void dpy_gfx_replace_surface(QemuConsole *con, 1375 DisplaySurface *surface) 1376 { 1377 DisplayState *s = con->ds; 1378 DisplaySurface *old_surface = con->surface; 1379 DisplayChangeListener *dcl; 1380 1381 con->surface = surface; 1382 QLIST_FOREACH(dcl, &s->listeners, next) { 1383 if (con != (dcl->con ? dcl->con : active_console)) { 1384 continue; 1385 } 1386 if (dcl->ops->dpy_gfx_switch) { 1387 dcl->ops->dpy_gfx_switch(dcl, surface); 1388 } 1389 } 1390 qemu_free_displaysurface(old_surface); 1391 } 1392 1393 void dpy_refresh(DisplayState *s) 1394 { 1395 DisplayChangeListener *dcl; 1396 1397 QLIST_FOREACH(dcl, &s->listeners, next) { 1398 if (dcl->ops->dpy_refresh) { 1399 dcl->ops->dpy_refresh(dcl); 1400 } 1401 } 1402 } 1403 1404 void dpy_gfx_copy(QemuConsole *con, int src_x, int src_y, 1405 int dst_x, int dst_y, int w, int h) 1406 { 1407 DisplayState *s = con->ds; 1408 DisplayChangeListener *dcl; 1409 1410 if (!qemu_console_is_visible(con)) { 1411 return; 1412 } 1413 QLIST_FOREACH(dcl, &s->listeners, next) { 1414 if (con != (dcl->con ? dcl->con : active_console)) { 1415 continue; 1416 } 1417 if (dcl->ops->dpy_gfx_copy) { 1418 dcl->ops->dpy_gfx_copy(dcl, src_x, src_y, dst_x, dst_y, w, h); 1419 } else { /* TODO */ 1420 dcl->ops->dpy_gfx_update(dcl, dst_x, dst_y, w, h); 1421 } 1422 } 1423 } 1424 1425 void dpy_text_cursor(QemuConsole *con, int x, int y) 1426 { 1427 DisplayState *s = con->ds; 1428 DisplayChangeListener *dcl; 1429 1430 if (!qemu_console_is_visible(con)) { 1431 return; 1432 } 1433 QLIST_FOREACH(dcl, &s->listeners, next) { 1434 if (con != (dcl->con ? dcl->con : active_console)) { 1435 continue; 1436 } 1437 if (dcl->ops->dpy_text_cursor) { 1438 dcl->ops->dpy_text_cursor(dcl, x, y); 1439 } 1440 } 1441 } 1442 1443 void dpy_text_update(QemuConsole *con, int x, int y, int w, int h) 1444 { 1445 DisplayState *s = con->ds; 1446 DisplayChangeListener *dcl; 1447 1448 if (!qemu_console_is_visible(con)) { 1449 return; 1450 } 1451 QLIST_FOREACH(dcl, &s->listeners, next) { 1452 if (con != (dcl->con ? dcl->con : active_console)) { 1453 continue; 1454 } 1455 if (dcl->ops->dpy_text_update) { 1456 dcl->ops->dpy_text_update(dcl, x, y, w, h); 1457 } 1458 } 1459 } 1460 1461 void dpy_text_resize(QemuConsole *con, int w, int h) 1462 { 1463 DisplayState *s = con->ds; 1464 struct DisplayChangeListener *dcl; 1465 1466 if (!qemu_console_is_visible(con)) { 1467 return; 1468 } 1469 QLIST_FOREACH(dcl, &s->listeners, next) { 1470 if (con != (dcl->con ? dcl->con : active_console)) { 1471 continue; 1472 } 1473 if (dcl->ops->dpy_text_resize) { 1474 dcl->ops->dpy_text_resize(dcl, w, h); 1475 } 1476 } 1477 } 1478 1479 void dpy_mouse_set(QemuConsole *con, int x, int y, int on) 1480 { 1481 DisplayState *s = con->ds; 1482 DisplayChangeListener *dcl; 1483 1484 if (!qemu_console_is_visible(con)) { 1485 return; 1486 } 1487 QLIST_FOREACH(dcl, &s->listeners, next) { 1488 if (con != (dcl->con ? dcl->con : active_console)) { 1489 continue; 1490 } 1491 if (dcl->ops->dpy_mouse_set) { 1492 dcl->ops->dpy_mouse_set(dcl, x, y, on); 1493 } 1494 } 1495 } 1496 1497 void dpy_cursor_define(QemuConsole *con, QEMUCursor *cursor) 1498 { 1499 DisplayState *s = con->ds; 1500 DisplayChangeListener *dcl; 1501 1502 if (!qemu_console_is_visible(con)) { 1503 return; 1504 } 1505 QLIST_FOREACH(dcl, &s->listeners, next) { 1506 if (con != (dcl->con ? dcl->con : active_console)) { 1507 continue; 1508 } 1509 if (dcl->ops->dpy_cursor_define) { 1510 dcl->ops->dpy_cursor_define(dcl, cursor); 1511 } 1512 } 1513 } 1514 1515 bool dpy_cursor_define_supported(QemuConsole *con) 1516 { 1517 DisplayState *s = con->ds; 1518 DisplayChangeListener *dcl; 1519 1520 QLIST_FOREACH(dcl, &s->listeners, next) { 1521 if (dcl->ops->dpy_cursor_define) { 1522 return true; 1523 } 1524 } 1525 return false; 1526 } 1527 1528 /***********************************************************/ 1529 /* register display */ 1530 1531 /* console.c internal use only */ 1532 static DisplayState *get_alloc_displaystate(void) 1533 { 1534 if (!display_state) { 1535 display_state = g_new0(DisplayState, 1); 1536 } 1537 return display_state; 1538 } 1539 1540 /* 1541 * Called by main(), after creating QemuConsoles 1542 * and before initializing ui (sdl/vnc/...). 1543 */ 1544 DisplayState *init_displaystate(void) 1545 { 1546 Error *local_err = NULL; 1547 gchar *name; 1548 int i; 1549 1550 if (!display_state) { 1551 display_state = g_new0(DisplayState, 1); 1552 } 1553 1554 for (i = 0; i < nb_consoles; i++) { 1555 if (consoles[i]->console_type != GRAPHIC_CONSOLE && 1556 consoles[i]->ds == NULL) { 1557 text_console_do_init(consoles[i]->chr, display_state); 1558 } 1559 1560 /* Hook up into the qom tree here (not in new_console()), once 1561 * all QemuConsoles are created and the order / numbering 1562 * doesn't change any more */ 1563 name = g_strdup_printf("console[%d]", i); 1564 object_property_add_child(container_get(object_get_root(), "/backend"), 1565 name, OBJECT(consoles[i]), &local_err); 1566 g_free(name); 1567 } 1568 1569 return display_state; 1570 } 1571 1572 QemuConsole *graphic_console_init(DeviceState *dev, 1573 const GraphicHwOps *hw_ops, 1574 void *opaque) 1575 { 1576 Error *local_err = NULL; 1577 int width = 640; 1578 int height = 480; 1579 QemuConsole *s; 1580 DisplayState *ds; 1581 1582 ds = get_alloc_displaystate(); 1583 trace_console_gfx_new(); 1584 s = new_console(ds, GRAPHIC_CONSOLE); 1585 s->hw_ops = hw_ops; 1586 s->hw = opaque; 1587 if (dev) { 1588 object_property_set_link(OBJECT(s), OBJECT(dev), 1589 "device", &local_err); 1590 } 1591 1592 s->surface = qemu_create_displaysurface(width, height); 1593 return s; 1594 } 1595 1596 QemuConsole *qemu_console_lookup_by_index(unsigned int index) 1597 { 1598 if (index >= MAX_CONSOLES) { 1599 return NULL; 1600 } 1601 return consoles[index]; 1602 } 1603 1604 QemuConsole *qemu_console_lookup_by_device(DeviceState *dev) 1605 { 1606 Error *local_err = NULL; 1607 Object *obj; 1608 int i; 1609 1610 for (i = 0; i < nb_consoles; i++) { 1611 if (!consoles[i]) { 1612 continue; 1613 } 1614 obj = object_property_get_link(OBJECT(consoles[i]), 1615 "device", &local_err); 1616 if (DEVICE(obj) == dev) { 1617 return consoles[i]; 1618 } 1619 } 1620 return NULL; 1621 } 1622 1623 bool qemu_console_is_visible(QemuConsole *con) 1624 { 1625 return (con == active_console) || (con->dcls > 0); 1626 } 1627 1628 bool qemu_console_is_graphic(QemuConsole *con) 1629 { 1630 if (con == NULL) { 1631 con = active_console; 1632 } 1633 return con && (con->console_type == GRAPHIC_CONSOLE); 1634 } 1635 1636 bool qemu_console_is_fixedsize(QemuConsole *con) 1637 { 1638 if (con == NULL) { 1639 con = active_console; 1640 } 1641 return con && (con->console_type != TEXT_CONSOLE); 1642 } 1643 1644 static void text_console_set_echo(CharDriverState *chr, bool echo) 1645 { 1646 QemuConsole *s = chr->opaque; 1647 1648 s->echo = echo; 1649 } 1650 1651 static void text_console_update_cursor(void *opaque) 1652 { 1653 QemuConsole *s = opaque; 1654 1655 s->cursor_visible_phase = !s->cursor_visible_phase; 1656 graphic_hw_invalidate(s); 1657 timer_mod(s->cursor_timer, 1658 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + CONSOLE_CURSOR_PERIOD / 2); 1659 } 1660 1661 static const GraphicHwOps text_console_ops = { 1662 .invalidate = text_console_invalidate, 1663 .text_update = text_console_update, 1664 }; 1665 1666 static void text_console_do_init(CharDriverState *chr, DisplayState *ds) 1667 { 1668 QemuConsole *s; 1669 int g_width = 80 * FONT_WIDTH; 1670 int g_height = 24 * FONT_HEIGHT; 1671 1672 s = chr->opaque; 1673 1674 chr->chr_write = console_puts; 1675 1676 s->out_fifo.buf = s->out_fifo_buf; 1677 s->out_fifo.buf_size = sizeof(s->out_fifo_buf); 1678 s->kbd_timer = timer_new_ms(QEMU_CLOCK_REALTIME, kbd_send_chars, s); 1679 s->ds = ds; 1680 1681 s->y_displayed = 0; 1682 s->y_base = 0; 1683 s->total_height = DEFAULT_BACKSCROLL; 1684 s->x = 0; 1685 s->y = 0; 1686 if (!s->surface) { 1687 if (active_console && active_console->surface) { 1688 g_width = surface_width(active_console->surface); 1689 g_height = surface_height(active_console->surface); 1690 } 1691 s->surface = qemu_create_displaysurface(g_width, g_height); 1692 } 1693 1694 s->cursor_timer = 1695 timer_new_ms(QEMU_CLOCK_REALTIME, text_console_update_cursor, s); 1696 1697 s->hw_ops = &text_console_ops; 1698 s->hw = s; 1699 1700 /* Set text attribute defaults */ 1701 s->t_attrib_default.bold = 0; 1702 s->t_attrib_default.uline = 0; 1703 s->t_attrib_default.blink = 0; 1704 s->t_attrib_default.invers = 0; 1705 s->t_attrib_default.unvisible = 0; 1706 s->t_attrib_default.fgcol = COLOR_WHITE; 1707 s->t_attrib_default.bgcol = COLOR_BLACK; 1708 /* set current text attributes to default */ 1709 s->t_attrib = s->t_attrib_default; 1710 text_console_resize(s); 1711 1712 if (chr->label) { 1713 char msg[128]; 1714 int len; 1715 1716 s->t_attrib.bgcol = COLOR_BLUE; 1717 len = snprintf(msg, sizeof(msg), "%s console\r\n", chr->label); 1718 console_puts(chr, (uint8_t*)msg, len); 1719 s->t_attrib = s->t_attrib_default; 1720 } 1721 1722 qemu_chr_be_generic_open(chr); 1723 if (chr->init) 1724 chr->init(chr); 1725 } 1726 1727 static CharDriverState *text_console_init(ChardevVC *vc) 1728 { 1729 CharDriverState *chr; 1730 QemuConsole *s; 1731 unsigned width = 0; 1732 unsigned height = 0; 1733 1734 chr = g_malloc0(sizeof(CharDriverState)); 1735 1736 if (vc->has_width) { 1737 width = vc->width; 1738 } else if (vc->has_cols) { 1739 width = vc->cols * FONT_WIDTH; 1740 } 1741 1742 if (vc->has_height) { 1743 height = vc->height; 1744 } else if (vc->has_rows) { 1745 height = vc->rows * FONT_HEIGHT; 1746 } 1747 1748 trace_console_txt_new(width, height); 1749 if (width == 0 || height == 0) { 1750 s = new_console(NULL, TEXT_CONSOLE); 1751 } else { 1752 s = new_console(NULL, TEXT_CONSOLE_FIXED_SIZE); 1753 s->surface = qemu_create_displaysurface(width, height); 1754 } 1755 1756 if (!s) { 1757 g_free(chr); 1758 return NULL; 1759 } 1760 1761 s->chr = chr; 1762 chr->opaque = s; 1763 chr->chr_set_echo = text_console_set_echo; 1764 /* console/chardev init sometimes completes elsewhere in a 2nd 1765 * stage, so defer OPENED events until they are fully initialized 1766 */ 1767 chr->explicit_be_open = true; 1768 1769 if (display_state) { 1770 text_console_do_init(chr, display_state); 1771 } 1772 return chr; 1773 } 1774 1775 static VcHandler *vc_handler = text_console_init; 1776 1777 CharDriverState *vc_init(ChardevVC *vc) 1778 { 1779 return vc_handler(vc); 1780 } 1781 1782 void register_vc_handler(VcHandler *handler) 1783 { 1784 vc_handler = handler; 1785 } 1786 1787 void qemu_console_resize(QemuConsole *s, int width, int height) 1788 { 1789 DisplaySurface *surface; 1790 1791 assert(s->console_type == GRAPHIC_CONSOLE); 1792 surface = qemu_create_displaysurface(width, height); 1793 dpy_gfx_replace_surface(s, surface); 1794 } 1795 1796 void qemu_console_copy(QemuConsole *con, int src_x, int src_y, 1797 int dst_x, int dst_y, int w, int h) 1798 { 1799 assert(con->console_type == GRAPHIC_CONSOLE); 1800 dpy_gfx_copy(con, src_x, src_y, dst_x, dst_y, w, h); 1801 } 1802 1803 DisplaySurface *qemu_console_surface(QemuConsole *console) 1804 { 1805 return console->surface; 1806 } 1807 1808 DisplayState *qemu_console_displaystate(QemuConsole *console) 1809 { 1810 return console->ds; 1811 } 1812 1813 PixelFormat qemu_different_endianness_pixelformat(int bpp) 1814 { 1815 PixelFormat pf; 1816 1817 memset(&pf, 0x00, sizeof(PixelFormat)); 1818 1819 pf.bits_per_pixel = bpp; 1820 pf.bytes_per_pixel = DIV_ROUND_UP(bpp, 8); 1821 pf.depth = bpp == 32 ? 24 : bpp; 1822 1823 switch (bpp) { 1824 case 24: 1825 pf.rmask = 0x000000FF; 1826 pf.gmask = 0x0000FF00; 1827 pf.bmask = 0x00FF0000; 1828 pf.rmax = 255; 1829 pf.gmax = 255; 1830 pf.bmax = 255; 1831 pf.rshift = 0; 1832 pf.gshift = 8; 1833 pf.bshift = 16; 1834 pf.rbits = 8; 1835 pf.gbits = 8; 1836 pf.bbits = 8; 1837 break; 1838 case 32: 1839 pf.rmask = 0x0000FF00; 1840 pf.gmask = 0x00FF0000; 1841 pf.bmask = 0xFF000000; 1842 pf.amask = 0x00000000; 1843 pf.amax = 255; 1844 pf.rmax = 255; 1845 pf.gmax = 255; 1846 pf.bmax = 255; 1847 pf.ashift = 0; 1848 pf.rshift = 8; 1849 pf.gshift = 16; 1850 pf.bshift = 24; 1851 pf.rbits = 8; 1852 pf.gbits = 8; 1853 pf.bbits = 8; 1854 pf.abits = 8; 1855 break; 1856 default: 1857 break; 1858 } 1859 return pf; 1860 } 1861 1862 PixelFormat qemu_default_pixelformat(int bpp) 1863 { 1864 PixelFormat pf; 1865 1866 memset(&pf, 0x00, sizeof(PixelFormat)); 1867 1868 pf.bits_per_pixel = bpp; 1869 pf.bytes_per_pixel = DIV_ROUND_UP(bpp, 8); 1870 pf.depth = bpp == 32 ? 24 : bpp; 1871 1872 switch (bpp) { 1873 case 15: 1874 pf.bits_per_pixel = 16; 1875 pf.rmask = 0x00007c00; 1876 pf.gmask = 0x000003E0; 1877 pf.bmask = 0x0000001F; 1878 pf.rmax = 31; 1879 pf.gmax = 31; 1880 pf.bmax = 31; 1881 pf.rshift = 10; 1882 pf.gshift = 5; 1883 pf.bshift = 0; 1884 pf.rbits = 5; 1885 pf.gbits = 5; 1886 pf.bbits = 5; 1887 break; 1888 case 16: 1889 pf.rmask = 0x0000F800; 1890 pf.gmask = 0x000007E0; 1891 pf.bmask = 0x0000001F; 1892 pf.rmax = 31; 1893 pf.gmax = 63; 1894 pf.bmax = 31; 1895 pf.rshift = 11; 1896 pf.gshift = 5; 1897 pf.bshift = 0; 1898 pf.rbits = 5; 1899 pf.gbits = 6; 1900 pf.bbits = 5; 1901 break; 1902 case 24: 1903 pf.rmask = 0x00FF0000; 1904 pf.gmask = 0x0000FF00; 1905 pf.bmask = 0x000000FF; 1906 pf.rmax = 255; 1907 pf.gmax = 255; 1908 pf.bmax = 255; 1909 pf.rshift = 16; 1910 pf.gshift = 8; 1911 pf.bshift = 0; 1912 pf.rbits = 8; 1913 pf.gbits = 8; 1914 pf.bbits = 8; 1915 break; 1916 case 32: 1917 pf.rmask = 0x00FF0000; 1918 pf.gmask = 0x0000FF00; 1919 pf.bmask = 0x000000FF; 1920 pf.rmax = 255; 1921 pf.gmax = 255; 1922 pf.bmax = 255; 1923 pf.rshift = 16; 1924 pf.gshift = 8; 1925 pf.bshift = 0; 1926 pf.rbits = 8; 1927 pf.gbits = 8; 1928 pf.bbits = 8; 1929 break; 1930 default: 1931 break; 1932 } 1933 return pf; 1934 } 1935 1936 static void qemu_chr_parse_vc(QemuOpts *opts, ChardevBackend *backend, 1937 Error **errp) 1938 { 1939 int val; 1940 1941 backend->vc = g_new0(ChardevVC, 1); 1942 1943 val = qemu_opt_get_number(opts, "width", 0); 1944 if (val != 0) { 1945 backend->vc->has_width = true; 1946 backend->vc->width = val; 1947 } 1948 1949 val = qemu_opt_get_number(opts, "height", 0); 1950 if (val != 0) { 1951 backend->vc->has_height = true; 1952 backend->vc->height = val; 1953 } 1954 1955 val = qemu_opt_get_number(opts, "cols", 0); 1956 if (val != 0) { 1957 backend->vc->has_cols = true; 1958 backend->vc->cols = val; 1959 } 1960 1961 val = qemu_opt_get_number(opts, "rows", 0); 1962 if (val != 0) { 1963 backend->vc->has_rows = true; 1964 backend->vc->rows = val; 1965 } 1966 } 1967 1968 static const TypeInfo qemu_console_info = { 1969 .name = TYPE_QEMU_CONSOLE, 1970 .parent = TYPE_OBJECT, 1971 .instance_size = sizeof(QemuConsole), 1972 .class_size = sizeof(QemuConsoleClass), 1973 }; 1974 1975 1976 static void register_types(void) 1977 { 1978 type_register_static(&qemu_console_info); 1979 register_char_driver_qapi("vc", CHARDEV_BACKEND_KIND_VC, 1980 qemu_chr_parse_vc); 1981 } 1982 1983 type_init(register_types); 1984