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 "console.h"
  26 #include "qemu-timer.h"
  27
  28 //#define DEBUG_CONSOLE
  29 #define DEFAULT_BACKSCROLL 512
  30 #define MAX_CONSOLES 12
  31
  32 #define QEMU_RGBA(r, g, b, a) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
  33 #define QEMU_RGB(r, g, b) QEMU_RGBA(r, g, b, 0xff)
  34
  35 typedef struct TextAttributes {
  36     uint8_t fgcol:4;
  37     uint8_t bgcol:4;
  38     uint8_t bold:1;
  39     uint8_t uline:1;
  40     uint8_t blink:1;
  41     uint8_t invers:1;
  42     uint8_t unvisible:1;
  43 } TextAttributes;
  44
  45 typedef struct TextCell {
  46     uint8_t ch;
  47     TextAttributes t_attrib;
  48 } TextCell;
  49
  50 #define MAX_ESC_PARAMS 3
  51
  52 enum TTYState {
  53     TTY_STATE_NORM,
  54     TTY_STATE_ESC,
  55     TTY_STATE_CSI,
  56 };
  57
  58 typedef struct QEMUFIFO {
  59     uint8_t *buf;
  60     int buf_size;
  61     int count, wptr, rptr;
  62 } QEMUFIFO;
  63
  64 static int qemu_fifo_write(QEMUFIFO *f, const uint8_t *buf, int len1)
  65 {
  66     int l, len;
  67
  68     l = f->buf_size - f->count;
  69     if (len1 > l)
  70         len1 = l;
  71     len = len1;
  72     while (len > 0) {
  73         l = f->buf_size - f->wptr;
  74         if (l > len)
  75             l = len;
  76         memcpy(f->buf + f->wptr, buf, l);
  77         f->wptr += l;
  78         if (f->wptr >= f->buf_size)
  79             f->wptr = 0;
  80         buf += l;
  81         len -= l;
  82     }
  83     f->count += len1;
  84     return len1;
  85 }
  86
  87 static int qemu_fifo_read(QEMUFIFO *f, uint8_t *buf, int len1)
  88 {
  89     int l, len;
  90
  91     if (len1 > f->count)
  92         len1 = f->count;
  93     len = len1;
  94     while (len > 0) {
  95         l = f->buf_size - f->rptr;
  96         if (l > len)
  97             l = len;
  98         memcpy(buf, f->buf + f->rptr, l);
  99         f->rptr += l;
 100         if (f->rptr >= f->buf_size)
 101             f->rptr = 0;
 102         buf += l;
 103         len -= l;
 104     }
 105     f->count -= len1;
 106     return len1;
 107 }
 108
 109 typedef enum {
 110     GRAPHIC_CONSOLE,
 111     TEXT_CONSOLE,
 112     TEXT_CONSOLE_FIXED_SIZE
 113 } console_type_t;
 114
 115 /* ??? This is mis-named.
 116    It is used for both text and graphical consoles.  */
 117 struct TextConsole {
 118     int index;
 119     console_type_t console_type;
 120     DisplayState *ds;
 121     /* Graphic console state.  */
 122     vga_hw_update_ptr hw_update;
 123     vga_hw_invalidate_ptr hw_invalidate;
 124     vga_hw_screen_dump_ptr hw_screen_dump;
 125     vga_hw_text_update_ptr hw_text_update;
 126     void *hw;
 127
 128     int g_width, g_height;
 129     int width;
 130     int height;
 131     int total_height;
 132     int backscroll_height;
 133     int x, y;
 134     int x_saved, y_saved;
 135     int y_displayed;
 136     int y_base;
 137     TextAttributes t_attrib_default; /* default text attributes */
 138     TextAttributes t_attrib; /* currently active text attributes */
 139     TextCell *cells;
 140     int text_x[2], text_y[2], cursor_invalidate;
 141     int echo;
 142
 143     int update_x0;
 144     int update_y0;
 145     int update_x1;
 146     int update_y1;
 147
 148     enum TTYState state;
 149     int esc_params[MAX_ESC_PARAMS];
 150     int nb_esc_params;
 151
 152     CharDriverState *chr;
 153     /* fifo for key pressed */
 154     QEMUFIFO out_fifo;
 155     uint8_t out_fifo_buf[16];
 156     QEMUTimer *kbd_timer;
 157 };
 158
 159 static DisplayState *display_state;
 160 static TextConsole *active_console;
 161 static TextConsole *consoles[MAX_CONSOLES];
 162 static int nb_consoles = 0;
 163
 164 void vga_hw_update(void)
 165 {
 166     if (active_console && active_console->hw_update)
 167         active_console->hw_update(active_console->hw);
 168 }
 169
 170 void vga_hw_invalidate(void)
 171 {
 172     if (active_console && active_console->hw_invalidate)
 173         active_console->hw_invalidate(active_console->hw);
 174 }
 175
 176 void vga_hw_screen_dump(const char *filename)
 177 {
 178     TextConsole *previous_active_console;
 179
 180     previous_active_console = active_console;
 181
 182     /* There is currently no way of specifying which screen we want to dump,
 183        so always dump the first one.  */
 184     console_select(0);
 185     if (consoles[0] && consoles[0]->hw_screen_dump) {
 186         consoles[0]->hw_screen_dump(consoles[0]->hw, filename);
 187     }
 188
 189     if (previous_active_console) {
 190         console_select(previous_active_console->index);
 191     }
 192 }
 193
 194 void vga_hw_text_update(console_ch_t *chardata)
 195 {
 196     if (active_console && active_console->hw_text_update)
 197         active_console->hw_text_update(active_console->hw, chardata);
 198 }
 199
 200 /* convert a RGBA color to a color index usable in graphic primitives */
 201 static unsigned int vga_get_color(DisplayState *ds, unsigned int rgba)
 202 {
 203     unsigned int r, g, b, color;
 204
 205     switch(ds_get_bits_per_pixel(ds)) {
 206 #if 0
 207     case 8:
 208         r = (rgba >> 16) & 0xff;
 209         g = (rgba >> 8) & 0xff;
 210         b = (rgba) & 0xff;
 211         color = (rgb_to_index[r] * 6 * 6) +
 212             (rgb_to_index[g] * 6) +
 213             (rgb_to_index[b]);
 214         break;
 215 #endif
 216     case 15:
 217         r = (rgba >> 16) & 0xff;
 218         g = (rgba >> 8) & 0xff;
 219         b = (rgba) & 0xff;
 220         color = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3);
 221         break;
 222     case 16:
 223         r = (rgba >> 16) & 0xff;
 224         g = (rgba >> 8) & 0xff;
 225         b = (rgba) & 0xff;
 226         color = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);
 227         break;
 228     case 32:
 229     default:
 230         color = rgba;
 231         break;
 232     }
 233     return color;
 234 }
 235
 236 static void vga_fill_rect (DisplayState *ds,
 237                            int posx, int posy, int width, int height, uint32_t color)
 238 {
 239     uint8_t *d, *d1;
 240     int x, y, bpp;
 241
 242     bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
 243     d1 = ds_get_data(ds) +
 244         ds_get_linesize(ds) * posy + bpp * posx;
 245     for (y = 0; y < height; y++) {
 246         d = d1;
 247         switch(bpp) {
 248         case 1:
 249             for (x = 0; x < width; x++) {
 250                 *((uint8_t *)d) = color;
 251                 d++;
 252             }
 253             break;
 254         case 2:
 255             for (x = 0; x < width; x++) {
 256                 *((uint16_t *)d) = color;
 257                 d += 2;
 258             }
 259             break;
 260         case 4:
 261             for (x = 0; x < width; x++) {
 262                 *((uint32_t *)d) = color;
 263                 d += 4;
 264             }
 265             break;
 266         }
 267         d1 += ds_get_linesize(ds);
 268     }
 269 }
 270
 271 /* copy from (xs, ys) to (xd, yd) a rectangle of size (w, h) */
 272 static void vga_bitblt(DisplayState *ds, int xs, int ys, int xd, int yd, int w, int h)
 273 {
 274     const uint8_t *s;
 275     uint8_t *d;
 276     int wb, y, bpp;
 277
 278     bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
 279     wb = w * bpp;
 280     if (yd <= ys) {
 281         s = ds_get_data(ds) +
 282             ds_get_linesize(ds) * ys + bpp * xs;
 283         d = ds_get_data(ds) +
 284             ds_get_linesize(ds) * yd + bpp * xd;
 285         for (y = 0; y < h; y++) {
 286             memmove(d, s, wb);
 287             d += ds_get_linesize(ds);
 288             s += ds_get_linesize(ds);
 289         }
 290     } else {
 291         s = ds_get_data(ds) +
 292             ds_get_linesize(ds) * (ys + h - 1) + bpp * xs;
 293         d = ds_get_data(ds) +
 294             ds_get_linesize(ds) * (yd + h - 1) + bpp * xd;
 295        for (y = 0; y < h; y++) {
 296             memmove(d, s, wb);
 297             d -= ds_get_linesize(ds);
 298             s -= ds_get_linesize(ds);
 299         }
 300     }
 301 }
 302
 303 /***********************************************************/
 304 /* basic char display */
 305
 306 #define FONT_HEIGHT 16
 307 #define FONT_WIDTH 8
 308
 309 #include "vgafont.h"
 310
 311 #define cbswap_32(__x) \
 312 ((uint32_t)( \
 313                 (((uint32_t)(__x) & (uint32_t)0x000000ffUL) << 24) | \
 314                 (((uint32_t)(__x) & (uint32_t)0x0000ff00UL) <<  8) | \
 315                 (((uint32_t)(__x) & (uint32_t)0x00ff0000UL) >>  8) | \
 316                 (((uint32_t)(__x) & (uint32_t)0xff000000UL) >> 24) ))
 317
 318 #ifdef HOST_WORDS_BIGENDIAN
 319 #define PAT(x) x
 320 #else
 321 #define PAT(x) cbswap_32(x)
 322 #endif
 323
 324 static const uint32_t dmask16[16] = {
 325     PAT(0x00000000),
 326     PAT(0x000000ff),
 327     PAT(0x0000ff00),
 328     PAT(0x0000ffff),
 329     PAT(0x00ff0000),
 330     PAT(0x00ff00ff),
 331     PAT(0x00ffff00),
 332     PAT(0x00ffffff),
 333     PAT(0xff000000),
 334     PAT(0xff0000ff),
 335     PAT(0xff00ff00),
 336     PAT(0xff00ffff),
 337     PAT(0xffff0000),
 338     PAT(0xffff00ff),
 339     PAT(0xffffff00),
 340     PAT(0xffffffff),
 341 };
 342
 343 static const uint32_t dmask4[4] = {
 344     PAT(0x00000000),
 345     PAT(0x0000ffff),
 346     PAT(0xffff0000),
 347     PAT(0xffffffff),
 348 };
 349
 350 static uint32_t color_table[2][8];
 351
 352 #ifndef CONFIG_CURSES
 353 enum color_names {
 354     COLOR_BLACK   = 0,
 355     COLOR_RED     = 1,
 356     COLOR_GREEN   = 2,
 357     COLOR_YELLOW  = 3,
 358     COLOR_BLUE    = 4,
 359     COLOR_MAGENTA = 5,
 360     COLOR_CYAN    = 6,
 361     COLOR_WHITE   = 7
 362 };
 363 #endif
 364
 365 static const uint32_t color_table_rgb[2][8] = {
 366     {   /* dark */
 367         QEMU_RGB(0x00, 0x00, 0x00),  /* black */
 368         QEMU_RGB(0xaa, 0x00, 0x00),  /* red */
 369         QEMU_RGB(0x00, 0xaa, 0x00),  /* green */
 370         QEMU_RGB(0xaa, 0xaa, 0x00),  /* yellow */
 371         QEMU_RGB(0x00, 0x00, 0xaa),  /* blue */
 372         QEMU_RGB(0xaa, 0x00, 0xaa),  /* magenta */
 373         QEMU_RGB(0x00, 0xaa, 0xaa),  /* cyan */
 374         QEMU_RGB(0xaa, 0xaa, 0xaa),  /* white */
 375     },
 376     {   /* bright */
 377         QEMU_RGB(0x00, 0x00, 0x00),  /* black */
 378         QEMU_RGB(0xff, 0x00, 0x00),  /* red */
 379         QEMU_RGB(0x00, 0xff, 0x00),  /* green */
 380         QEMU_RGB(0xff, 0xff, 0x00),  /* yellow */
 381         QEMU_RGB(0x00, 0x00, 0xff),  /* blue */
 382         QEMU_RGB(0xff, 0x00, 0xff),  /* magenta */
 383         QEMU_RGB(0x00, 0xff, 0xff),  /* cyan */
 384         QEMU_RGB(0xff, 0xff, 0xff),  /* white */
 385     }
 386 };
 387
 388 static inline unsigned int col_expand(DisplayState *ds, unsigned int col)
 389 {
 390     switch(ds_get_bits_per_pixel(ds)) {
 391     case 8:
 392         col |= col << 8;
 393         col |= col << 16;
 394         break;
 395     case 15:
 396     case 16:
 397         col |= col << 16;
 398         break;
 399     default:
 400         break;
 401     }
 402
 403     return col;
 404 }
 405 #ifdef DEBUG_CONSOLE
 406 static void console_print_text_attributes(TextAttributes *t_attrib, char ch)
 407 {
 408     if (t_attrib->bold) {
 409         printf("b");
 410     } else {
 411         printf(" ");
 412     }
 413     if (t_attrib->uline) {
 414         printf("u");
 415     } else {
 416         printf(" ");
 417     }
 418     if (t_attrib->blink) {
 419         printf("l");
 420     } else {
 421         printf(" ");
 422     }
 423     if (t_attrib->invers) {
 424         printf("i");
 425     } else {
 426         printf(" ");
 427     }
 428     if (t_attrib->unvisible) {
 429         printf("n");
 430     } else {
 431         printf(" ");
 432     }
 433
 434     printf(" fg: %d bg: %d ch:'%2X' '%c'\n", t_attrib->fgcol, t_attrib->bgcol, ch, ch);
 435 }
 436 #endif
 437
 438 static void vga_putcharxy(DisplayState *ds, int x, int y, int ch,
 439                           TextAttributes *t_attrib)
 440 {
 441     uint8_t *d;
 442     const uint8_t *font_ptr;
 443     unsigned int font_data, linesize, xorcol, bpp;
 444     int i;
 445     unsigned int fgcol, bgcol;
 446
 447 #ifdef DEBUG_CONSOLE
 448     printf("x: %2i y: %2i", x, y);
 449     console_print_text_attributes(t_attrib, ch);
 450 #endif
 451
 452     if (t_attrib->invers) {
 453         bgcol = color_table[t_attrib->bold][t_attrib->fgcol];
 454         fgcol = color_table[t_attrib->bold][t_attrib->bgcol];
 455     } else {
 456         fgcol = color_table[t_attrib->bold][t_attrib->fgcol];
 457         bgcol = color_table[t_attrib->bold][t_attrib->bgcol];
 458     }
 459
 460     bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
 461     d = ds_get_data(ds) +
 462         ds_get_linesize(ds) * y * FONT_HEIGHT + bpp * x * FONT_WIDTH;
 463     linesize = ds_get_linesize(ds);
 464     font_ptr = vgafont16 + FONT_HEIGHT * ch;
 465     xorcol = bgcol ^ fgcol;
 466     switch(ds_get_bits_per_pixel(ds)) {
 467     case 8:
 468         for(i = 0; i < FONT_HEIGHT; i++) {
 469             font_data = *font_ptr++;
 470             if (t_attrib->uline
 471                 && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {
 472                 font_data = 0xFF;
 473             }
 474             ((uint32_t *)d)[0] = (dmask16[(font_data >> 4)] & xorcol) ^ bgcol;
 475             ((uint32_t *)d)[1] = (dmask16[(font_data >> 0) & 0xf] & xorcol) ^ bgcol;
 476             d += linesize;
 477         }
 478         break;
 479     case 16:
 480     case 15:
 481         for(i = 0; i < FONT_HEIGHT; i++) {
 482             font_data = *font_ptr++;
 483             if (t_attrib->uline
 484                 && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {
 485                 font_data = 0xFF;
 486             }
 487             ((uint32_t *)d)[0] = (dmask4[(font_data >> 6)] & xorcol) ^ bgcol;
 488             ((uint32_t *)d)[1] = (dmask4[(font_data >> 4) & 3] & xorcol) ^ bgcol;
 489             ((uint32_t *)d)[2] = (dmask4[(font_data >> 2) & 3] & xorcol) ^ bgcol;
 490             ((uint32_t *)d)[3] = (dmask4[(font_data >> 0) & 3] & xorcol) ^ bgcol;
 491             d += linesize;
 492         }
 493         break;
 494     case 32:
 495         for(i = 0; i < FONT_HEIGHT; i++) {
 496             font_data = *font_ptr++;
 497             if (t_attrib->uline && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {
 498                 font_data = 0xFF;
 499             }
 500             ((uint32_t *)d)[0] = (-((font_data >> 7)) & xorcol) ^ bgcol;
 501             ((uint32_t *)d)[1] = (-((font_data >> 6) & 1) & xorcol) ^ bgcol;
 502             ((uint32_t *)d)[2] = (-((font_data >> 5) & 1) & xorcol) ^ bgcol;
 503             ((uint32_t *)d)[3] = (-((font_data >> 4) & 1) & xorcol) ^ bgcol;
 504             ((uint32_t *)d)[4] = (-((font_data >> 3) & 1) & xorcol) ^ bgcol;
 505             ((uint32_t *)d)[5] = (-((font_data >> 2) & 1) & xorcol) ^ bgcol;
 506             ((uint32_t *)d)[6] = (-((font_data >> 1) & 1) & xorcol) ^ bgcol;
 507             ((uint32_t *)d)[7] = (-((font_data >> 0) & 1) & xorcol) ^ bgcol;
 508             d += linesize;
 509         }
 510         break;
 511     }
 512 }
 513
 514 static void text_console_resize(TextConsole *s)
 515 {
 516     TextCell *cells, *c, *c1;
 517     int w1, x, y, last_width;
 518
 519     last_width = s->width;
 520     s->width = s->g_width / FONT_WIDTH;
 521     s->height = s->g_height / FONT_HEIGHT;
 522
 523     w1 = last_width;
 524     if (s->width < w1)
 525         w1 = s->width;
 526
 527     cells = g_malloc(s->width * s->total_height * sizeof(TextCell));
 528     for(y = 0; y < s->total_height; y++) {
 529         c = &cells[y * s->width];
 530         if (w1 > 0) {
 531             c1 = &s->cells[y * last_width];
 532             for(x = 0; x < w1; x++) {
 533                 *c++ = *c1++;
 534             }
 535         }
 536         for(x = w1; x < s->width; x++) {
 537             c->ch = ' ';
 538             c->t_attrib = s->t_attrib_default;
 539             c++;
 540         }
 541     }
 542     g_free(s->cells);
 543     s->cells = cells;
 544 }
 545
 546 static inline void text_update_xy(TextConsole *s, int x, int y)
 547 {
 548     s->text_x[0] = MIN(s->text_x[0], x);
 549     s->text_x[1] = MAX(s->text_x[1], x);
 550     s->text_y[0] = MIN(s->text_y[0], y);
 551     s->text_y[1] = MAX(s->text_y[1], y);
 552 }
 553
 554 static void invalidate_xy(TextConsole *s, int x, int y)
 555 {
 556     if (s->update_x0 > x * FONT_WIDTH)
 557         s->update_x0 = x * FONT_WIDTH;
 558     if (s->update_y0 > y * FONT_HEIGHT)
 559         s->update_y0 = y * FONT_HEIGHT;
 560     if (s->update_x1 < (x + 1) * FONT_WIDTH)
 561         s->update_x1 = (x + 1) * FONT_WIDTH;
 562     if (s->update_y1 < (y + 1) * FONT_HEIGHT)
 563         s->update_y1 = (y + 1) * FONT_HEIGHT;
 564 }
 565
 566 static void update_xy(TextConsole *s, int x, int y)
 567 {
 568     TextCell *c;
 569     int y1, y2;
 570
 571     if (s == active_console) {
 572         if (!ds_get_bits_per_pixel(s->ds)) {
 573             text_update_xy(s, x, y);
 574             return;
 575         }
 576
 577         y1 = (s->y_base + y) % s->total_height;
 578         y2 = y1 - s->y_displayed;
 579         if (y2 < 0)
 580             y2 += s->total_height;
 581         if (y2 < s->height) {
 582             c = &s->cells[y1 * s->width + x];
 583             vga_putcharxy(s->ds, x, y2, c->ch,
 584                           &(c->t_attrib));
 585             invalidate_xy(s, x, y2);
 586         }
 587     }
 588 }
 589
 590 static void console_show_cursor(TextConsole *s, int show)
 591 {
 592     TextCell *c;
 593     int y, y1;
 594
 595     if (s == active_console) {
 596         int x = s->x;
 597
 598         if (!ds_get_bits_per_pixel(s->ds)) {
 599             s->cursor_invalidate = 1;
 600             return;
 601         }
 602
 603         if (x >= s->width) {
 604             x = s->width - 1;
 605         }
 606         y1 = (s->y_base + s->y) % s->total_height;
 607         y = y1 - s->y_displayed;
 608         if (y < 0)
 609             y += s->total_height;
 610         if (y < s->height) {
 611             c = &s->cells[y1 * s->width + x];
 612             if (show) {
 613                 TextAttributes t_attrib = s->t_attrib_default;
 614                 t_attrib.invers = !(t_attrib.invers); /* invert fg and bg */
 615                 vga_putcharxy(s->ds, x, y, c->ch, &t_attrib);
 616             } else {
 617                 vga_putcharxy(s->ds, x, y, c->ch, &(c->t_attrib));
 618             }
 619             invalidate_xy(s, x, y);
 620         }
 621     }
 622 }
 623
 624 static void console_refresh(TextConsole *s)
 625 {
 626     TextCell *c;
 627     int x, y, y1;
 628
 629     if (s != active_console)
 630         return;
 631     if (!ds_get_bits_per_pixel(s->ds)) {
 632         s->text_x[0] = 0;
 633         s->text_y[0] = 0;
 634         s->text_x[1] = s->width - 1;
 635         s->text_y[1] = s->height - 1;
 636         s->cursor_invalidate = 1;
 637         return;
 638     }
 639
 640     vga_fill_rect(s->ds, 0, 0, ds_get_width(s->ds), ds_get_height(s->ds),
 641                   color_table[0][COLOR_BLACK]);
 642     y1 = s->y_displayed;
 643     for(y = 0; y < s->height; y++) {
 644         c = s->cells + y1 * s->width;
 645         for(x = 0; x < s->width; x++) {
 646             vga_putcharxy(s->ds, x, y, c->ch,
 647                           &(c->t_attrib));
 648             c++;
 649         }
 650         if (++y1 == s->total_height)
 651             y1 = 0;
 652     }
 653     console_show_cursor(s, 1);
 654     dpy_update(s->ds, 0, 0, ds_get_width(s->ds), ds_get_height(s->ds));
 655 }
 656
 657 static void console_scroll(int ydelta)
 658 {
 659     TextConsole *s;
 660     int i, y1;
 661
 662     s = active_console;
 663     if (!s || (s->console_type == GRAPHIC_CONSOLE))
 664         return;
 665
 666     if (ydelta > 0) {
 667         for(i = 0; i < ydelta; i++) {
 668             if (s->y_displayed == s->y_base)
 669                 break;
 670             if (++s->y_displayed == s->total_height)
 671                 s->y_displayed = 0;
 672         }
 673     } else {
 674         ydelta = -ydelta;
 675         i = s->backscroll_height;
 676         if (i > s->total_height - s->height)
 677             i = s->total_height - s->height;
 678         y1 = s->y_base - i;
 679         if (y1 < 0)
 680             y1 += s->total_height;
 681         for(i = 0; i < ydelta; i++) {
 682             if (s->y_displayed == y1)
 683                 break;
 684             if (--s->y_displayed < 0)
 685                 s->y_displayed = s->total_height - 1;
 686         }
 687     }
 688     console_refresh(s);
 689 }
 690
 691 static void console_put_lf(TextConsole *s)
 692 {
 693     TextCell *c;
 694     int x, y1;
 695
 696     s->y++;
 697     if (s->y >= s->height) {
 698         s->y = s->height - 1;
 699
 700         if (s->y_displayed == s->y_base) {
 701             if (++s->y_displayed == s->total_height)
 702                 s->y_displayed = 0;
 703         }
 704         if (++s->y_base == s->total_height)
 705             s->y_base = 0;
 706         if (s->backscroll_height < s->total_height)
 707             s->backscroll_height++;
 708         y1 = (s->y_base + s->height - 1) % s->total_height;
 709         c = &s->cells[y1 * s->width];
 710         for(x = 0; x < s->width; x++) {
 711             c->ch = ' ';
 712             c->t_attrib = s->t_attrib_default;
 713             c++;
 714         }
 715         if (s == active_console && s->y_displayed == s->y_base) {
 716             if (!ds_get_bits_per_pixel(s->ds)) {
 717                 s->text_x[0] = 0;
 718                 s->text_y[0] = 0;
 719                 s->text_x[1] = s->width - 1;
 720                 s->text_y[1] = s->height - 1;
 721                 return;
 722             }
 723
 724             vga_bitblt(s->ds, 0, FONT_HEIGHT, 0, 0,
 725                        s->width * FONT_WIDTH,
 726                        (s->height - 1) * FONT_HEIGHT);
 727             vga_fill_rect(s->ds, 0, (s->height - 1) * FONT_HEIGHT,
 728                           s->width * FONT_WIDTH, FONT_HEIGHT,
 729                           color_table[0][s->t_attrib_default.bgcol]);
 730             s->update_x0 = 0;
 731             s->update_y0 = 0;
 732             s->update_x1 = s->width * FONT_WIDTH;
 733             s->update_y1 = s->height * FONT_HEIGHT;
 734         }
 735     }
 736 }
 737
 738 /* Set console attributes depending on the current escape codes.
 739  * NOTE: I know this code is not very efficient (checking every color for it
 740  * self) but it is more readable and better maintainable.
 741  */
 742 static void console_handle_escape(TextConsole *s)
 743 {
 744     int i;
 745
 746     for (i=0; i<s->nb_esc_params; i++) {
 747         switch (s->esc_params[i]) {
 748             case 0: /* reset all console attributes to default */
 749                 s->t_attrib = s->t_attrib_default;
 750                 break;
 751             case 1:
 752                 s->t_attrib.bold = 1;
 753                 break;
 754             case 4:
 755                 s->t_attrib.uline = 1;
 756                 break;
 757             case 5:
 758                 s->t_attrib.blink = 1;
 759                 break;
 760             case 7:
 761                 s->t_attrib.invers = 1;
 762                 break;
 763             case 8:
 764                 s->t_attrib.unvisible = 1;
 765                 break;
 766             case 22:
 767                 s->t_attrib.bold = 0;
 768                 break;
 769             case 24:
 770                 s->t_attrib.uline = 0;
 771                 break;
 772             case 25:
 773                 s->t_attrib.blink = 0;
 774                 break;
 775             case 27:
 776                 s->t_attrib.invers = 0;
 777                 break;
 778             case 28:
 779                 s->t_attrib.unvisible = 0;
 780                 break;
 781             /* set foreground color */
 782             case 30:
 783                 s->t_attrib.fgcol=COLOR_BLACK;
 784                 break;
 785             case 31:
 786                 s->t_attrib.fgcol=COLOR_RED;
 787                 break;
 788             case 32:
 789                 s->t_attrib.fgcol=COLOR_GREEN;
 790                 break;
 791             case 33:
 792                 s->t_attrib.fgcol=COLOR_YELLOW;
 793                 break;
 794             case 34:
 795                 s->t_attrib.fgcol=COLOR_BLUE;
 796                 break;
 797             case 35:
 798                 s->t_attrib.fgcol=COLOR_MAGENTA;
 799                 break;
 800             case 36:
 801                 s->t_attrib.fgcol=COLOR_CYAN;
 802                 break;
 803             case 37:
 804                 s->t_attrib.fgcol=COLOR_WHITE;
 805                 break;
 806             /* set background color */
 807             case 40:
 808                 s->t_attrib.bgcol=COLOR_BLACK;
 809                 break;
 810             case 41:
 811                 s->t_attrib.bgcol=COLOR_RED;
 812                 break;
 813             case 42:
 814                 s->t_attrib.bgcol=COLOR_GREEN;
 815                 break;
 816             case 43:
 817                 s->t_attrib.bgcol=COLOR_YELLOW;
 818                 break;
 819             case 44:
 820                 s->t_attrib.bgcol=COLOR_BLUE;
 821                 break;
 822             case 45:
 823                 s->t_attrib.bgcol=COLOR_MAGENTA;
 824                 break;
 825             case 46:
 826                 s->t_attrib.bgcol=COLOR_CYAN;
 827                 break;
 828             case 47:
 829                 s->t_attrib.bgcol=COLOR_WHITE;
 830                 break;
 831         }
 832     }
 833 }
 834
 835 static void console_clear_xy(TextConsole *s, int x, int y)
 836 {
 837     int y1 = (s->y_base + y) % s->total_height;
 838     TextCell *c = &s->cells[y1 * s->width + x];
 839     c->ch = ' ';
 840     c->t_attrib = s->t_attrib_default;
 841     update_xy(s, x, y);
 842 }
 843
 844 static void console_putchar(TextConsole *s, int ch)
 845 {
 846     TextCell *c;
 847     int y1, i;
 848     int x, y;
 849
 850     switch(s->state) {
 851     case TTY_STATE_NORM:
 852         switch(ch) {
 853         case '\r':  /* carriage return */
 854             s->x = 0;
 855             break;
 856         case '\n':  /* newline */
 857             console_put_lf(s);
 858             break;
 859         case '\b':  /* backspace */
 860             if (s->x > 0)
 861                 s->x--;
 862             break;
 863         case '\t':  /* tabspace */
 864             if (s->x + (8 - (s->x % 8)) > s->width) {
 865                 s->x = 0;
 866                 console_put_lf(s);
 867             } else {
 868                 s->x = s->x + (8 - (s->x % 8));
 869             }
 870             break;
 871         case '\a':  /* alert aka. bell */
 872             /* TODO: has to be implemented */
 873             break;
 874         case 14:
 875             /* SI (shift in), character set 0 (ignored) */
 876             break;
 877         case 15:
 878             /* SO (shift out), character set 1 (ignored) */
 879             break;
 880         case 27:    /* esc (introducing an escape sequence) */
 881             s->state = TTY_STATE_ESC;
 882             break;
 883         default:
 884             if (s->x >= s->width) {
 885                 /* line wrap */
 886                 s->x = 0;
 887                 console_put_lf(s);
 888             }
 889             y1 = (s->y_base + s->y) % s->total_height;
 890             c = &s->cells[y1 * s->width + s->x];
 891             c->ch = ch;
 892             c->t_attrib = s->t_attrib;
 893             update_xy(s, s->x, s->y);
 894             s->x++;
 895             break;
 896         }
 897         break;
 898     case TTY_STATE_ESC: /* check if it is a terminal escape sequence */
 899         if (ch == '[') {
 900             for(i=0;i<MAX_ESC_PARAMS;i++)
 901                 s->esc_params[i] = 0;
 902             s->nb_esc_params = 0;
 903             s->state = TTY_STATE_CSI;
 904         } else {
 905             s->state = TTY_STATE_NORM;
 906         }
 907         break;
 908     case TTY_STATE_CSI: /* handle escape sequence parameters */
 909         if (ch >= '0' && ch <= '9') {
 910             if (s->nb_esc_params < MAX_ESC_PARAMS) {
 911                 s->esc_params[s->nb_esc_params] =
 912                     s->esc_params[s->nb_esc_params] * 10 + ch - '0';
 913             }
 914         } else {
 915             s->nb_esc_params++;
 916             if (ch == ';')
 917                 break;
 918 #ifdef DEBUG_CONSOLE
 919             fprintf(stderr, "escape sequence CSI%d;%d%c, %d parameters\n",
 920                     s->esc_params[0], s->esc_params[1], ch, s->nb_esc_params);
 921 #endif
 922             s->state = TTY_STATE_NORM;
 923             switch(ch) {
 924             case 'A':
 925                 /* move cursor up */
 926                 if (s->esc_params[0] == 0) {
 927                     s->esc_params[0] = 1;
 928                 }
 929                 s->y -= s->esc_params[0];
 930                 if (s->y < 0) {
 931                     s->y = 0;
 932                 }
 933                 break;
 934             case 'B':
 935                 /* move cursor down */
 936                 if (s->esc_params[0] == 0) {
 937                     s->esc_params[0] = 1;
 938                 }
 939                 s->y += s->esc_params[0];
 940                 if (s->y >= s->height) {
 941                     s->y = s->height - 1;
 942                 }
 943                 break;
 944             case 'C':
 945                 /* move cursor right */
 946                 if (s->esc_params[0] == 0) {
 947                     s->esc_params[0] = 1;
 948                 }
 949                 s->x += s->esc_params[0];
 950                 if (s->x >= s->width) {
 951                     s->x = s->width - 1;
 952                 }
 953                 break;
 954             case 'D':
 955                 /* move cursor left */
 956                 if (s->esc_params[0] == 0) {
 957                     s->esc_params[0] = 1;
 958                 }
 959                 s->x -= s->esc_params[0];
 960                 if (s->x < 0) {
 961                     s->x = 0;
 962                 }
 963                 break;
 964             case 'G':
 965                 /* move cursor to column */
 966                 s->x = s->esc_params[0] - 1;
 967                 if (s->x < 0) {
 968                     s->x = 0;
 969                 }
 970                 break;
 971             case 'f':
 972             case 'H':
 973                 /* move cursor to row, column */
 974                 s->x = s->esc_params[1] - 1;
 975                 if (s->x < 0) {
 976                     s->x = 0;
 977                 }
 978                 s->y = s->esc_params[0] - 1;
 979                 if (s->y < 0) {
 980                     s->y = 0;
 981                 }
 982                 break;
 983             case 'J':
 984                 switch (s->esc_params[0]) {
 985                 case 0:
 986                     /* clear to end of screen */
 987                     for (y = s->y; y < s->height; y++) {
 988                         for (x = 0; x < s->width; x++) {
 989                             if (y == s->y && x < s->x) {
 990                                 continue;
 991                             }
 992                             console_clear_xy(s, x, y);
 993                         }
 994                     }
 995                     break;
 996                 case 1:
 997                     /* clear from beginning of screen */
 998                     for (y = 0; y <= s->y; y++) {
 999                         for (x = 0; x < s->width; x++) {
1000                             if (y == s->y && x > s->x) {
1001                                 break;
1002                             }
1003                             console_clear_xy(s, x, y);
1004                         }
1005                     }
1006                     break;
1007                 case 2:
1008                     /* clear entire screen */
1009                     for (y = 0; y <= s->height; y++) {
1010                         for (x = 0; x < s->width; x++) {
1011                             console_clear_xy(s, x, y);
1012                         }
1013                     }
1014                     break;
1015                 }
1016                 break;
1017             case 'K':
1018                 switch (s->esc_params[0]) {
1019                 case 0:
1020                     /* clear to eol */
1021                     for(x = s->x; x < s->width; x++) {
1022                         console_clear_xy(s, x, s->y);
1023                     }
1024                     break;
1025                 case 1:
1026                     /* clear from beginning of line */
1027                     for (x = 0; x <= s->x; x++) {
1028                         console_clear_xy(s, x, s->y);
1029                     }
1030                     break;
1031                 case 2:
1032                     /* clear entire line */
1033                     for(x = 0; x < s->width; x++) {
1034                         console_clear_xy(s, x, s->y);
1035                     }
1036                     break;
1037                 }
1038                 break;
1039             case 'm':
1040                 console_handle_escape(s);
1041                 break;
1042             case 'n':
1043                 /* report cursor position */
1044                 /* TODO: send ESC[row;colR */
1045                 break;
1046             case 's':
1047                 /* save cursor position */
1048                 s->x_saved = s->x;
1049                 s->y_saved = s->y;
1050                 break;
1051             case 'u':
1052                 /* restore cursor position */
1053                 s->x = s->x_saved;
1054                 s->y = s->y_saved;
1055                 break;
1056             default:
1057 #ifdef DEBUG_CONSOLE
1058                 fprintf(stderr, "unhandled escape character '%c'\n", ch);
1059 #endif
1060                 break;
1061             }
1062             break;
1063         }
1064     }
1065 }
1066
1067 void console_select(unsigned int index)
1068 {
1069     TextConsole *s;
1070
1071     if (index >= MAX_CONSOLES)
1072         return;
1073     if (active_console) {
1074         active_console->g_width = ds_get_width(active_console->ds);
1075         active_console->g_height = ds_get_height(active_console->ds);
1076     }
1077     s = consoles[index];
1078     if (s) {
1079         DisplayState *ds = s->ds;
1080         active_console = s;
1081         if (ds_get_bits_per_pixel(s->ds)) {
1082             ds->surface = qemu_resize_displaysurface(ds, s->g_width, s->g_height);
1083         } else {
1084             s->ds->surface->width = s->width;
1085             s->ds->surface->height = s->height;
1086         }
1087         dpy_resize(s->ds);
1088         vga_hw_invalidate();
1089     }
1090 }
1091
1092 static int console_puts(CharDriverState *chr, const uint8_t *buf, int len)
1093 {
1094     TextConsole *s = chr->opaque;
1095     int i;
1096
1097     s->update_x0 = s->width * FONT_WIDTH;
1098     s->update_y0 = s->height * FONT_HEIGHT;
1099     s->update_x1 = 0;
1100     s->update_y1 = 0;
1101     console_show_cursor(s, 0);
1102     for(i = 0; i < len; i++) {
1103         console_putchar(s, buf[i]);
1104     }
1105     console_show_cursor(s, 1);
1106     if (ds_get_bits_per_pixel(s->ds) && s->update_x0 < s->update_x1) {
1107         dpy_update(s->ds, s->update_x0, s->update_y0,
1108                    s->update_x1 - s->update_x0,
1109                    s->update_y1 - s->update_y0);
1110     }
1111     return len;
1112 }
1113
1114 static void kbd_send_chars(void *opaque)
1115 {
1116     TextConsole *s = opaque;
1117     int len;
1118     uint8_t buf[16];
1119
1120     len = qemu_chr_be_can_write(s->chr);
1121     if (len > s->out_fifo.count)
1122         len = s->out_fifo.count;
1123     if (len > 0) {
1124         if (len > sizeof(buf))
1125             len = sizeof(buf);
1126         qemu_fifo_read(&s->out_fifo, buf, len);
1127         qemu_chr_be_write(s->chr, buf, len);
1128     }
1129     /* characters are pending: we send them a bit later (XXX:
1130        horrible, should change char device API) */
1131     if (s->out_fifo.count > 0) {
1132         qemu_mod_timer(s->kbd_timer, qemu_get_clock_ms(rt_clock) + 1);
1133     }
1134 }
1135
1136 /* called when an ascii key is pressed */
1137 void kbd_put_keysym(int keysym)
1138 {
1139     TextConsole *s;
1140     uint8_t buf[16], *q;
1141     int c;
1142
1143     s = active_console;
1144     if (!s || (s->console_type == GRAPHIC_CONSOLE))
1145         return;
1146
1147     switch(keysym) {
1148     case QEMU_KEY_CTRL_UP:
1149         console_scroll(-1);
1150         break;
1151     case QEMU_KEY_CTRL_DOWN:
1152         console_scroll(1);
1153         break;
1154     case QEMU_KEY_CTRL_PAGEUP:
1155         console_scroll(-10);
1156         break;
1157     case QEMU_KEY_CTRL_PAGEDOWN:
1158         console_scroll(10);
1159         break;
1160     default:
1161         /* convert the QEMU keysym to VT100 key string */
1162         q = buf;
1163         if (keysym >= 0xe100 && keysym <= 0xe11f) {
1164             *q++ = '\033';
1165             *q++ = '[';
1166             c = keysym - 0xe100;
1167             if (c >= 10)
1168                 *q++ = '0' + (c / 10);
1169             *q++ = '0' + (c % 10);
1170             *q++ = '~';
1171         } else if (keysym >= 0xe120 && keysym <= 0xe17f) {
1172             *q++ = '\033';
1173             *q++ = '[';
1174             *q++ = keysym & 0xff;
1175         } else if (s->echo && (keysym == '\r' || keysym == '\n')) {
1176             console_puts(s->chr, (const uint8_t *) "\r", 1);
1177             *q++ = '\n';
1178         } else {
1179             *q++ = keysym;
1180         }
1181         if (s->echo) {
1182             console_puts(s->chr, buf, q - buf);
1183         }
1184         if (s->chr->chr_read) {
1185             qemu_fifo_write(&s->out_fifo, buf, q - buf);
1186             kbd_send_chars(s);
1187         }
1188         break;
1189     }
1190 }
1191
1192 static void text_console_invalidate(void *opaque)
1193 {
1194     TextConsole *s = (TextConsole *) opaque;
1195     if (!ds_get_bits_per_pixel(s->ds) && s->console_type == TEXT_CONSOLE) {
1196         s->g_width = ds_get_width(s->ds);
1197         s->g_height = ds_get_height(s->ds);
1198         text_console_resize(s);
1199     }
1200     console_refresh(s);
1201 }
1202
1203 static void text_console_update(void *opaque, console_ch_t *chardata)
1204 {
1205     TextConsole *s = (TextConsole *) opaque;
1206     int i, j, src;
1207
1208     if (s->text_x[0] <= s->text_x[1]) {
1209         src = (s->y_base + s->text_y[0]) * s->width;
1210         chardata += s->text_y[0] * s->width;
1211         for (i = s->text_y[0]; i <= s->text_y[1]; i ++)
1212             for (j = 0; j < s->width; j ++, src ++)
1213                 console_write_ch(chardata ++, s->cells[src].ch |
1214                                 (s->cells[src].t_attrib.fgcol << 12) |
1215                                 (s->cells[src].t_attrib.bgcol << 8) |
1216                                 (s->cells[src].t_attrib.bold << 21));
1217         dpy_update(s->ds, s->text_x[0], s->text_y[0],
1218                    s->text_x[1] - s->text_x[0], i - s->text_y[0]);
1219         s->text_x[0] = s->width;
1220         s->text_y[0] = s->height;
1221         s->text_x[1] = 0;
1222         s->text_y[1] = 0;
1223     }
1224     if (s->cursor_invalidate) {
1225         dpy_cursor(s->ds, s->x, s->y);
1226         s->cursor_invalidate = 0;
1227     }
1228 }
1229
1230 static TextConsole *get_graphic_console(DisplayState *ds)
1231 {
1232     int i;
1233     TextConsole *s;
1234     for (i = 0; i < nb_consoles; i++) {
1235         s = consoles[i];
1236         if (s->console_type == GRAPHIC_CONSOLE && s->ds == ds)
1237             return s;
1238     }
1239     return NULL;
1240 }
1241
1242 static TextConsole *new_console(DisplayState *ds, console_type_t console_type)
1243 {
1244     TextConsole *s;
1245     int i;
1246
1247     if (nb_consoles >= MAX_CONSOLES)
1248         return NULL;
1249     s = g_malloc0(sizeof(TextConsole));
1250     if (!active_console || ((active_console->console_type != GRAPHIC_CONSOLE) &&
1251         (console_type == GRAPHIC_CONSOLE))) {
1252         active_console = s;
1253     }
1254     s->ds = ds;
1255     s->console_type = console_type;
1256     if (console_type != GRAPHIC_CONSOLE) {
1257         s->index = nb_consoles;
1258         consoles[nb_consoles++] = s;
1259     } else {
1260         /* HACK: Put graphical consoles before text consoles.  */
1261         for (i = nb_consoles; i > 0; i--) {
1262             if (consoles[i - 1]->console_type == GRAPHIC_CONSOLE)
1263                 break;
1264             consoles[i] = consoles[i - 1];
1265             consoles[i]->index = i;
1266         }
1267         s->index = i;
1268         consoles[i] = s;
1269         nb_consoles++;
1270     }
1271     return s;
1272 }
1273
1274 static DisplaySurface* defaultallocator_create_displaysurface(int width, int height)
1275 {
1276     DisplaySurface *surface = (DisplaySurface*) g_malloc0(sizeof(DisplaySurface));
1277
1278     int linesize = width * 4;
1279     qemu_alloc_display(surface, width, height, linesize,
1280                        qemu_default_pixelformat(32), 0);
1281     return surface;
1282 }
1283
1284 static DisplaySurface* defaultallocator_resize_displaysurface(DisplaySurface *surface,
1285                                           int width, int height)
1286 {
1287     int linesize = width * 4;
1288     qemu_alloc_display(surface, width, height, linesize,
1289                        qemu_default_pixelformat(32), 0);
1290     return surface;
1291 }
1292
1293 void qemu_alloc_display(DisplaySurface *surface, int width, int height,
1294                         int linesize, PixelFormat pf, int newflags)
1295 {
1296     void *data;
1297     surface->width = width;
1298     surface->height = height;
1299     surface->linesize = linesize;
1300     surface->pf = pf;
1301     if (surface->flags & QEMU_ALLOCATED_FLAG) {
1302         data = g_realloc(surface->data,
1303                             surface->linesize * surface->height);
1304     } else {
1305         data = g_malloc(surface->linesize * surface->height);
1306     }
1307     surface->data = (uint8_t *)data;
1308     surface->flags = newflags | QEMU_ALLOCATED_FLAG;
1309 #ifdef HOST_WORDS_BIGENDIAN
1310     surface->flags |= QEMU_BIG_ENDIAN_FLAG;
1311 #endif
1312 }
1313
1314 DisplaySurface* qemu_create_displaysurface_from(int width, int height, int bpp,
1315                                               int linesize, uint8_t *data)
1316 {
1317     DisplaySurface *surface = (DisplaySurface*) g_malloc0(sizeof(DisplaySurface));
1318
1319     surface->width = width;
1320     surface->height = height;
1321     surface->linesize = linesize;
1322     surface->pf = qemu_default_pixelformat(bpp);
1323 #ifdef HOST_WORDS_BIGENDIAN
1324     surface->flags = QEMU_BIG_ENDIAN_FLAG;
1325 #endif
1326     surface->data = data;
1327
1328     return surface;
1329 }
1330
1331 static void defaultallocator_free_displaysurface(DisplaySurface *surface)
1332 {
1333     if (surface == NULL)
1334         return;
1335     if (surface->flags & QEMU_ALLOCATED_FLAG)
1336         g_free(surface->data);
1337     g_free(surface);
1338 }
1339
1340 static struct DisplayAllocator default_allocator = {
1341     defaultallocator_create_displaysurface,
1342     defaultallocator_resize_displaysurface,
1343     defaultallocator_free_displaysurface
1344 };
1345
1346 static void dumb_display_init(void)
1347 {
1348     DisplayState *ds = g_malloc0(sizeof(DisplayState));
1349     int width = 640;
1350     int height = 480;
1351
1352     ds->allocator = &default_allocator;
1353     if (is_fixedsize_console()) {
1354         width = active_console->g_width;
1355         height = active_console->g_height;
1356     }
1357     ds->surface = qemu_create_displaysurface(ds, width, height);
1358     register_displaystate(ds);
1359 }
1360
1361 /***********************************************************/
1362 /* register display */
1363
1364 void register_displaystate(DisplayState *ds)
1365 {
1366     DisplayState **s;
1367     s = &display_state;
1368     while (*s != NULL)
1369         s = &(*s)->next;
1370     ds->next = NULL;
1371     *s = ds;
1372 }
1373
1374 DisplayState *get_displaystate(void)
1375 {
1376     if (!display_state) {
1377         dumb_display_init ();
1378     }
1379     return display_state;
1380 }
1381
1382 DisplayAllocator *register_displayallocator(DisplayState *ds, DisplayAllocator *da)
1383 {
1384     if(ds->allocator ==  &default_allocator) {
1385         DisplaySurface *surf;
1386         surf = da->create_displaysurface(ds_get_width(ds), ds_get_height(ds));
1387         defaultallocator_free_displaysurface(ds->surface);
1388         ds->surface = surf;
1389         ds->allocator = da;
1390     }
1391     return ds->allocator;
1392 }
1393
1394 DisplayState *graphic_console_init(vga_hw_update_ptr update,
1395                                    vga_hw_invalidate_ptr invalidate,
1396                                    vga_hw_screen_dump_ptr screen_dump,
1397                                    vga_hw_text_update_ptr text_update,
1398                                    void *opaque)
1399 {
1400     TextConsole *s;
1401     DisplayState *ds;
1402
1403     ds = (DisplayState *) g_malloc0(sizeof(DisplayState));
1404     ds->allocator = &default_allocator;
1405     ds->surface = qemu_create_displaysurface(ds, 640, 480);
1406
1407     s = new_console(ds, GRAPHIC_CONSOLE);
1408     if (s == NULL) {
1409         qemu_free_displaysurface(ds);
1410         g_free(ds);
1411         return NULL;
1412     }
1413     s->hw_update = update;
1414     s->hw_invalidate = invalidate;
1415     s->hw_screen_dump = screen_dump;
1416     s->hw_text_update = text_update;
1417     s->hw = opaque;
1418
1419     register_displaystate(ds);
1420     return ds;
1421 }
1422
1423 int is_graphic_console(void)
1424 {
1425     return active_console && active_console->console_type == GRAPHIC_CONSOLE;
1426 }
1427
1428 int is_fixedsize_console(void)
1429 {
1430     return active_console && active_console->console_type != TEXT_CONSOLE;
1431 }
1432
1433 void console_color_init(DisplayState *ds)
1434 {
1435     int i, j;
1436     for (j = 0; j < 2; j++) {
1437         for (i = 0; i < 8; i++) {
1438             color_table[j][i] = col_expand(ds,
1439                    vga_get_color(ds, color_table_rgb[j][i]));
1440         }
1441     }
1442 }
1443
1444 static int n_text_consoles;
1445 static CharDriverState *text_consoles[128];
1446
1447 static void text_console_set_echo(CharDriverState *chr, bool echo)
1448 {
1449     TextConsole *s = chr->opaque;
1450
1451     s->echo = echo;
1452 }
1453
1454 static void text_console_do_init(CharDriverState *chr, DisplayState *ds)
1455 {
1456     TextConsole *s;
1457     static int color_inited;
1458
1459     s = chr->opaque;
1460
1461     chr->chr_write = console_puts;
1462
1463     s->out_fifo.buf = s->out_fifo_buf;
1464     s->out_fifo.buf_size = sizeof(s->out_fifo_buf);
1465     s->kbd_timer = qemu_new_timer_ms(rt_clock, kbd_send_chars, s);
1466     s->ds = ds;
1467
1468     if (!color_inited) {
1469         color_inited = 1;
1470         console_color_init(s->ds);
1471     }
1472     s->y_displayed = 0;
1473     s->y_base = 0;
1474     s->total_height = DEFAULT_BACKSCROLL;
1475     s->x = 0;
1476     s->y = 0;
1477     if (s->console_type == TEXT_CONSOLE) {
1478         s->g_width = ds_get_width(s->ds);
1479         s->g_height = ds_get_height(s->ds);
1480     }
1481
1482     s->hw_invalidate = text_console_invalidate;
1483     s->hw_text_update = text_console_update;
1484     s->hw = s;
1485
1486     /* Set text attribute defaults */
1487     s->t_attrib_default.bold = 0;
1488     s->t_attrib_default.uline = 0;
1489     s->t_attrib_default.blink = 0;
1490     s->t_attrib_default.invers = 0;
1491     s->t_attrib_default.unvisible = 0;
1492     s->t_attrib_default.fgcol = COLOR_WHITE;
1493     s->t_attrib_default.bgcol = COLOR_BLACK;
1494     /* set current text attributes to default */
1495     s->t_attrib = s->t_attrib_default;
1496     text_console_resize(s);
1497
1498     if (chr->label) {
1499         char msg[128];
1500         int len;
1501
1502         s->t_attrib.bgcol = COLOR_BLUE;
1503         len = snprintf(msg, sizeof(msg), "%s console\r\n", chr->label);
1504         console_puts(chr, (uint8_t*)msg, len);
1505         s->t_attrib = s->t_attrib_default;
1506     }
1507
1508     qemu_chr_generic_open(chr);
1509     if (chr->init)
1510         chr->init(chr);
1511 }
1512
1513 int text_console_init(QemuOpts *opts, CharDriverState **_chr)
1514 {
1515     CharDriverState *chr;
1516     TextConsole *s;
1517     unsigned width;
1518     unsigned height;
1519
1520     chr = g_malloc0(sizeof(CharDriverState));
1521
1522     if (n_text_consoles == 128) {
1523         fprintf(stderr, "Too many text consoles\n");
1524         exit(1);
1525     }
1526     text_consoles[n_text_consoles] = chr;
1527     n_text_consoles++;
1528
1529     width = qemu_opt_get_number(opts, "width", 0);
1530     if (width == 0)
1531         width = qemu_opt_get_number(opts, "cols", 0) * FONT_WIDTH;
1532
1533     height = qemu_opt_get_number(opts, "height", 0);
1534     if (height == 0)
1535         height = qemu_opt_get_number(opts, "rows", 0) * FONT_HEIGHT;
1536
1537     if (width == 0 || height == 0) {
1538         s = new_console(NULL, TEXT_CONSOLE);
1539     } else {
1540         s = new_console(NULL, TEXT_CONSOLE_FIXED_SIZE);
1541     }
1542
1543     if (!s) {
1544         g_free(chr);
1545         return -EBUSY;
1546     }
1547
1548     s->chr = chr;
1549     s->g_width = width;
1550     s->g_height = height;
1551     chr->opaque = s;
1552     chr->chr_set_echo = text_console_set_echo;
1553
1554     *_chr = chr;
1555     return 0;
1556 }
1557
1558 void text_consoles_set_display(DisplayState *ds)
1559 {
1560     int i;
1561
1562     for (i = 0; i < n_text_consoles; i++) {
1563         text_console_do_init(text_consoles[i], ds);
1564     }
1565
1566     n_text_consoles = 0;
1567 }
1568
1569 void qemu_console_resize(DisplayState *ds, int width, int height)
1570 {
1571     TextConsole *s = get_graphic_console(ds);
1572     if (!s) return;
1573
1574     s->g_width = width;
1575     s->g_height = height;
1576     if (is_graphic_console()) {
1577         ds->surface = qemu_resize_displaysurface(ds, width, height);
1578         dpy_resize(ds);
1579     }
1580 }
1581
1582 void qemu_console_copy(DisplayState *ds, int src_x, int src_y,
1583                        int dst_x, int dst_y, int w, int h)
1584 {
1585     if (is_graphic_console()) {
1586         dpy_copy(ds, src_x, src_y, dst_x, dst_y, w, h);
1587     }
1588 }
1589
1590 PixelFormat qemu_different_endianness_pixelformat(int bpp)
1591 {
1592     PixelFormat pf;
1593
1594     memset(&pf, 0x00, sizeof(PixelFormat));
1595
1596     pf.bits_per_pixel = bpp;
1597     pf.bytes_per_pixel = bpp / 8;
1598     pf.depth = bpp == 32 ? 24 : bpp;
1599
1600     switch (bpp) {
1601         case 24:
1602             pf.rmask = 0x000000FF;
1603             pf.gmask = 0x0000FF00;
1604             pf.bmask = 0x00FF0000;
1605             pf.rmax = 255;
1606             pf.gmax = 255;
1607             pf.bmax = 255;
1608             pf.rshift = 0;
1609             pf.gshift = 8;
1610             pf.bshift = 16;
1611             pf.rbits = 8;
1612             pf.gbits = 8;
1613             pf.bbits = 8;
1614             break;
1615         case 32:
1616             pf.rmask = 0x0000FF00;
1617             pf.gmask = 0x00FF0000;
1618             pf.bmask = 0xFF000000;
1619             pf.amask = 0x00000000;
1620             pf.amax = 255;
1621             pf.rmax = 255;
1622             pf.gmax = 255;
1623             pf.bmax = 255;
1624             pf.ashift = 0;
1625             pf.rshift = 8;
1626             pf.gshift = 16;
1627             pf.bshift = 24;
1628             pf.rbits = 8;
1629             pf.gbits = 8;
1630             pf.bbits = 8;
1631             pf.abits = 8;
1632             break;
1633         default:
1634             break;
1635     }
1636     return pf;
1637 }
1638
1639 PixelFormat qemu_default_pixelformat(int bpp)
1640 {
1641     PixelFormat pf;
1642
1643     memset(&pf, 0x00, sizeof(PixelFormat));
1644
1645     pf.bits_per_pixel = bpp;
1646     pf.bytes_per_pixel = bpp / 8;
1647     pf.depth = bpp == 32 ? 24 : bpp;
1648
1649     switch (bpp) {
1650         case 15:
1651             pf.bits_per_pixel = 16;
1652             pf.bytes_per_pixel = 2;
1653             pf.rmask = 0x00007c00;
1654             pf.gmask = 0x000003E0;
1655             pf.bmask = 0x0000001F;
1656             pf.rmax = 31;
1657             pf.gmax = 31;
1658             pf.bmax = 31;
1659             pf.rshift = 10;
1660             pf.gshift = 5;
1661             pf.bshift = 0;
1662             pf.rbits = 5;
1663             pf.gbits = 5;
1664             pf.bbits = 5;
1665             break;
1666         case 16:
1667             pf.rmask = 0x0000F800;
1668             pf.gmask = 0x000007E0;
1669             pf.bmask = 0x0000001F;
1670             pf.rmax = 31;
1671             pf.gmax = 63;
1672             pf.bmax = 31;
1673             pf.rshift = 11;
1674             pf.gshift = 5;
1675             pf.bshift = 0;
1676             pf.rbits = 5;
1677             pf.gbits = 6;
1678             pf.bbits = 5;
1679             break;
1680         case 24:
1681             pf.rmask = 0x00FF0000;
1682             pf.gmask = 0x0000FF00;
1683             pf.bmask = 0x000000FF;
1684             pf.rmax = 255;
1685             pf.gmax = 255;
1686             pf.bmax = 255;
1687             pf.rshift = 16;
1688             pf.gshift = 8;
1689             pf.bshift = 0;
1690             pf.rbits = 8;
1691             pf.gbits = 8;
1692             pf.bbits = 8;
1693             break;
1694         case 32:
1695             pf.rmask = 0x00FF0000;
1696             pf.gmask = 0x0000FF00;
1697             pf.bmask = 0x000000FF;
1698             pf.amax = 255;
1699             pf.rmax = 255;
1700             pf.gmax = 255;
1701             pf.bmax = 255;
1702             pf.ashift = 24;
1703             pf.rshift = 16;
1704             pf.gshift = 8;
1705             pf.bshift = 0;
1706             pf.rbits = 8;
1707             pf.gbits = 8;
1708             pf.bbits = 8;
1709             pf.abits = 8;
1710             break;
1711         default:
1712             break;
1713     }
1714     return pf;
1715 }