ui/console.c

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