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     console_type_t console_type;
 119     DisplayState *ds;
 120     /* Graphic console state.  */
 121     vga_hw_update_ptr hw_update;
 122     vga_hw_invalidate_ptr hw_invalidate;
 123     vga_hw_screen_dump_ptr hw_screen_dump;
 124     vga_hw_text_update_ptr hw_text_update;
 125     void *hw;
 126
 127     int g_width, g_height;
 128     int width;
 129     int height;
 130     int total_height;
 131     int backscroll_height;
 132     int x, y;
 133     int x_saved, y_saved;
 134     int y_displayed;
 135     int y_base;
 136     TextAttributes t_attrib_default; /* default text attributes */
 137     TextAttributes t_attrib; /* currently active text attributes */
 138     TextCell *cells;
 139     int text_x[2], text_y[2], cursor_invalidate;
 140
 141     enum TTYState state;
 142     int esc_params[MAX_ESC_PARAMS];
 143     int nb_esc_params;
 144
 145     CharDriverState *chr;
 146     /* fifo for key pressed */
 147     QEMUFIFO out_fifo;
 148     uint8_t out_fifo_buf[16];
 149     QEMUTimer *kbd_timer;
 150 };
 151
 152 static TextConsole *active_console;
 153 static TextConsole *consoles[MAX_CONSOLES];
 154 static int nb_consoles = 0;
 155
 156 void vga_hw_update(void)
 157 {
 158     if (active_console && active_console->hw_update)
 159         active_console->hw_update(active_console->hw);
 160 }
 161
 162 void vga_hw_invalidate(void)
 163 {
 164     if (active_console->hw_invalidate)
 165         active_console->hw_invalidate(active_console->hw);
 166 }
 167
 168 void vga_hw_screen_dump(const char *filename)
 169 {
 170     /* There is currently no was of specifying which screen we want to dump,
 171        so always dump the dirst one.  */
 172     if (consoles[0]->hw_screen_dump)
 173         consoles[0]->hw_screen_dump(consoles[0]->hw, filename);
 174 }
 175
 176 void vga_hw_text_update(console_ch_t *chardata)
 177 {
 178     if (active_console && active_console->hw_text_update)
 179         active_console->hw_text_update(active_console->hw, chardata);
 180 }
 181
 182 /* convert a RGBA color to a color index usable in graphic primitives */
 183 static unsigned int vga_get_color(DisplayState *ds, unsigned int rgba)
 184 {
 185     unsigned int r, g, b, color;
 186
 187     switch(ds->depth) {
 188 #if 0
 189     case 8:
 190         r = (rgba >> 16) & 0xff;
 191         g = (rgba >> 8) & 0xff;
 192         b = (rgba) & 0xff;
 193         color = (rgb_to_index[r] * 6 * 6) +
 194             (rgb_to_index[g] * 6) +
 195             (rgb_to_index[b]);
 196         break;
 197 #endif
 198     case 15:
 199         r = (rgba >> 16) & 0xff;
 200         g = (rgba >> 8) & 0xff;
 201         b = (rgba) & 0xff;
 202         color = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3);
 203         break;
 204     case 16:
 205         r = (rgba >> 16) & 0xff;
 206         g = (rgba >> 8) & 0xff;
 207         b = (rgba) & 0xff;
 208         color = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);
 209         break;
 210     case 32:
 211     default:
 212         color = rgba;
 213         break;
 214     }
 215     return color;
 216 }
 217
 218 static void vga_fill_rect (DisplayState *ds,
 219                            int posx, int posy, int width, int height, uint32_t color)
 220 {
 221     uint8_t *d, *d1;
 222     int x, y, bpp;
 223
 224     bpp = (ds->depth + 7) >> 3;
 225     d1 = ds->data +
 226         ds->linesize * posy + bpp * posx;
 227     for (y = 0; y < height; y++) {
 228         d = d1;
 229         switch(bpp) {
 230         case 1:
 231             for (x = 0; x < width; x++) {
 232                 *((uint8_t *)d) = color;
 233                 d++;
 234             }
 235             break;
 236         case 2:
 237             for (x = 0; x < width; x++) {
 238                 *((uint16_t *)d) = color;
 239                 d += 2;
 240             }
 241             break;
 242         case 4:
 243             for (x = 0; x < width; x++) {
 244                 *((uint32_t *)d) = color;
 245                 d += 4;
 246             }
 247             break;
 248         }
 249         d1 += ds->linesize;
 250     }
 251 }
 252
 253 /* copy from (xs, ys) to (xd, yd) a rectangle of size (w, h) */
 254 static void vga_bitblt(DisplayState *ds, int xs, int ys, int xd, int yd, int w, int h)
 255 {
 256     const uint8_t *s;
 257     uint8_t *d;
 258     int wb, y, bpp;
 259
 260     bpp = (ds->depth + 7) >> 3;
 261     wb = w * bpp;
 262     if (yd <= ys) {
 263         s = ds->data +
 264             ds->linesize * ys + bpp * xs;
 265         d = ds->data +
 266             ds->linesize * yd + bpp * xd;
 267         for (y = 0; y < h; y++) {
 268             memmove(d, s, wb);
 269             d += ds->linesize;
 270             s += ds->linesize;
 271         }
 272     } else {
 273         s = ds->data +
 274             ds->linesize * (ys + h - 1) + bpp * xs;
 275         d = ds->data +
 276             ds->linesize * (yd + h - 1) + bpp * xd;
 277        for (y = 0; y < h; y++) {
 278             memmove(d, s, wb);
 279             d -= ds->linesize;
 280             s -= ds->linesize;
 281         }
 282     }
 283 }
 284
 285 /***********************************************************/
 286 /* basic char display */
 287
 288 #define FONT_HEIGHT 16
 289 #define FONT_WIDTH 8
 290
 291 #include "vgafont.h"
 292
 293 #define cbswap_32(__x) \
 294 ((uint32_t)( \
 295                 (((uint32_t)(__x) & (uint32_t)0x000000ffUL) << 24) | \
 296                 (((uint32_t)(__x) & (uint32_t)0x0000ff00UL) <<  8) | \
 297                 (((uint32_t)(__x) & (uint32_t)0x00ff0000UL) >>  8) | \
 298                 (((uint32_t)(__x) & (uint32_t)0xff000000UL) >> 24) ))
 299
 300 #ifdef WORDS_BIGENDIAN
 301 #define PAT(x) x
 302 #else
 303 #define PAT(x) cbswap_32(x)
 304 #endif
 305
 306 static const uint32_t dmask16[16] = {
 307     PAT(0x00000000),
 308     PAT(0x000000ff),
 309     PAT(0x0000ff00),
 310     PAT(0x0000ffff),
 311     PAT(0x00ff0000),
 312     PAT(0x00ff00ff),
 313     PAT(0x00ffff00),
 314     PAT(0x00ffffff),
 315     PAT(0xff000000),
 316     PAT(0xff0000ff),
 317     PAT(0xff00ff00),
 318     PAT(0xff00ffff),
 319     PAT(0xffff0000),
 320     PAT(0xffff00ff),
 321     PAT(0xffffff00),
 322     PAT(0xffffffff),
 323 };
 324
 325 static const uint32_t dmask4[4] = {
 326     PAT(0x00000000),
 327     PAT(0x0000ffff),
 328     PAT(0xffff0000),
 329     PAT(0xffffffff),
 330 };
 331
 332 static uint32_t color_table[2][8];
 333
 334 enum color_names {
 335     COLOR_BLACK   = 0,
 336     COLOR_RED     = 1,
 337     COLOR_GREEN   = 2,
 338     COLOR_YELLOW  = 3,
 339     COLOR_BLUE    = 4,
 340     COLOR_MAGENTA = 5,
 341     COLOR_CYAN    = 6,
 342     COLOR_WHITE   = 7
 343 };
 344
 345 static const uint32_t color_table_rgb[2][8] = {
 346     {   /* dark */
 347         QEMU_RGB(0x00, 0x00, 0x00),  /* black */
 348         QEMU_RGB(0xaa, 0x00, 0x00),  /* red */
 349         QEMU_RGB(0x00, 0xaa, 0x00),  /* green */
 350         QEMU_RGB(0xaa, 0xaa, 0x00),  /* yellow */
 351         QEMU_RGB(0x00, 0x00, 0xaa),  /* blue */
 352         QEMU_RGB(0xaa, 0x00, 0xaa),  /* magenta */
 353         QEMU_RGB(0x00, 0xaa, 0xaa),  /* cyan */
 354         QEMU_RGB(0xaa, 0xaa, 0xaa),  /* white */
 355     },
 356     {   /* bright */
 357         QEMU_RGB(0x00, 0x00, 0x00),  /* black */
 358         QEMU_RGB(0xff, 0x00, 0x00),  /* red */
 359         QEMU_RGB(0x00, 0xff, 0x00),  /* green */
 360         QEMU_RGB(0xff, 0xff, 0x00),  /* yellow */
 361         QEMU_RGB(0x00, 0x00, 0xff),  /* blue */
 362         QEMU_RGB(0xff, 0x00, 0xff),  /* magenta */
 363         QEMU_RGB(0x00, 0xff, 0xff),  /* cyan */
 364         QEMU_RGB(0xff, 0xff, 0xff),  /* white */
 365     }
 366 };
 367
 368 static inline unsigned int col_expand(DisplayState *ds, unsigned int col)
 369 {
 370     switch(ds->depth) {
 371     case 8:
 372         col |= col << 8;
 373         col |= col << 16;
 374         break;
 375     case 15:
 376     case 16:
 377         col |= col << 16;
 378         break;
 379     default:
 380         break;
 381     }
 382
 383     return col;
 384 }
 385 #ifdef DEBUG_CONSOLE
 386 static void console_print_text_attributes(TextAttributes *t_attrib, char ch)
 387 {
 388     if (t_attrib->bold) {
 389         printf("b");
 390     } else {
 391         printf(" ");
 392     }
 393     if (t_attrib->uline) {
 394         printf("u");
 395     } else {
 396         printf(" ");
 397     }
 398     if (t_attrib->blink) {
 399         printf("l");
 400     } else {
 401         printf(" ");
 402     }
 403     if (t_attrib->invers) {
 404         printf("i");
 405     } else {
 406         printf(" ");
 407     }
 408     if (t_attrib->unvisible) {
 409         printf("n");
 410     } else {
 411         printf(" ");
 412     }
 413
 414     printf(" fg: %d bg: %d ch:'%2X' '%c'\n", t_attrib->fgcol, t_attrib->bgcol, ch, ch);
 415 }
 416 #endif
 417
 418 static void vga_putcharxy(DisplayState *ds, int x, int y, int ch,
 419                           TextAttributes *t_attrib)
 420 {
 421     uint8_t *d;
 422     const uint8_t *font_ptr;
 423     unsigned int font_data, linesize, xorcol, bpp;
 424     int i;
 425     unsigned int fgcol, bgcol;
 426
 427 #ifdef DEBUG_CONSOLE
 428     printf("x: %2i y: %2i", x, y);
 429     console_print_text_attributes(t_attrib, ch);
 430 #endif
 431
 432     if (t_attrib->invers) {
 433         bgcol = color_table[t_attrib->bold][t_attrib->fgcol];
 434         fgcol = color_table[t_attrib->bold][t_attrib->bgcol];
 435     } else {
 436         fgcol = color_table[t_attrib->bold][t_attrib->fgcol];
 437         bgcol = color_table[t_attrib->bold][t_attrib->bgcol];
 438     }
 439
 440     bpp = (ds->depth + 7) >> 3;
 441     d = ds->data +
 442         ds->linesize * y * FONT_HEIGHT + bpp * x * FONT_WIDTH;
 443     linesize = ds->linesize;
 444     font_ptr = vgafont16 + FONT_HEIGHT * ch;
 445     xorcol = bgcol ^ fgcol;
 446     switch(ds->depth) {
 447     case 8:
 448         for(i = 0; i < FONT_HEIGHT; i++) {
 449             font_data = *font_ptr++;
 450             if (t_attrib->uline
 451                 && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {
 452                 font_data = 0xFFFF;
 453             }
 454             ((uint32_t *)d)[0] = (dmask16[(font_data >> 4)] & xorcol) ^ bgcol;
 455             ((uint32_t *)d)[1] = (dmask16[(font_data >> 0) & 0xf] & xorcol) ^ bgcol;
 456             d += linesize;
 457         }
 458         break;
 459     case 16:
 460     case 15:
 461         for(i = 0; i < FONT_HEIGHT; i++) {
 462             font_data = *font_ptr++;
 463             if (t_attrib->uline
 464                 && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {
 465                 font_data = 0xFFFF;
 466             }
 467             ((uint32_t *)d)[0] = (dmask4[(font_data >> 6)] & xorcol) ^ bgcol;
 468             ((uint32_t *)d)[1] = (dmask4[(font_data >> 4) & 3] & xorcol) ^ bgcol;
 469             ((uint32_t *)d)[2] = (dmask4[(font_data >> 2) & 3] & xorcol) ^ bgcol;
 470             ((uint32_t *)d)[3] = (dmask4[(font_data >> 0) & 3] & xorcol) ^ bgcol;
 471             d += linesize;
 472         }
 473         break;
 474     case 32:
 475         for(i = 0; i < FONT_HEIGHT; i++) {
 476             font_data = *font_ptr++;
 477             if (t_attrib->uline && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {
 478                 font_data = 0xFFFF;
 479             }
 480             ((uint32_t *)d)[0] = (-((font_data >> 7)) & xorcol) ^ bgcol;
 481             ((uint32_t *)d)[1] = (-((font_data >> 6) & 1) & xorcol) ^ bgcol;
 482             ((uint32_t *)d)[2] = (-((font_data >> 5) & 1) & xorcol) ^ bgcol;
 483             ((uint32_t *)d)[3] = (-((font_data >> 4) & 1) & xorcol) ^ bgcol;
 484             ((uint32_t *)d)[4] = (-((font_data >> 3) & 1) & xorcol) ^ bgcol;
 485             ((uint32_t *)d)[5] = (-((font_data >> 2) & 1) & xorcol) ^ bgcol;
 486             ((uint32_t *)d)[6] = (-((font_data >> 1) & 1) & xorcol) ^ bgcol;
 487             ((uint32_t *)d)[7] = (-((font_data >> 0) & 1) & xorcol) ^ bgcol;
 488             d += linesize;
 489         }
 490         break;
 491     }
 492 }
 493
 494 static void text_console_resize(TextConsole *s)
 495 {
 496     TextCell *cells, *c, *c1;
 497     int w1, x, y, last_width;
 498
 499     last_width = s->width;
 500     s->width = s->g_width / FONT_WIDTH;
 501     s->height = s->g_height / FONT_HEIGHT;
 502
 503     w1 = last_width;
 504     if (s->width < w1)
 505         w1 = s->width;
 506
 507     cells = qemu_malloc(s->width * s->total_height * sizeof(TextCell));
 508     for(y = 0; y < s->total_height; y++) {
 509         c = &cells[y * s->width];
 510         if (w1 > 0) {
 511             c1 = &s->cells[y * last_width];
 512             for(x = 0; x < w1; x++) {
 513                 *c++ = *c1++;
 514             }
 515         }
 516         for(x = w1; x < s->width; x++) {
 517             c->ch = ' ';
 518             c->t_attrib = s->t_attrib_default;
 519             c++;
 520         }
 521     }
 522     qemu_free(s->cells);
 523     s->cells = cells;
 524 }
 525
 526 static inline void text_update_xy(TextConsole *s, int x, int y)
 527 {
 528     s->text_x[0] = MIN(s->text_x[0], x);
 529     s->text_x[1] = MAX(s->text_x[1], x);
 530     s->text_y[0] = MIN(s->text_y[0], y);
 531     s->text_y[1] = MAX(s->text_y[1], y);
 532 }
 533
 534 static void update_xy(TextConsole *s, int x, int y)
 535 {
 536     TextCell *c;
 537     int y1, y2;
 538
 539     if (s == active_console) {
 540         if (!s->ds->depth) {
 541             text_update_xy(s, x, y);
 542             return;
 543         }
 544
 545         y1 = (s->y_base + y) % s->total_height;
 546         y2 = y1 - s->y_displayed;
 547         if (y2 < 0)
 548             y2 += s->total_height;
 549         if (y2 < s->height) {
 550             c = &s->cells[y1 * s->width + x];
 551             vga_putcharxy(s->ds, x, y2, c->ch,
 552                           &(c->t_attrib));
 553             dpy_update(s->ds, x * FONT_WIDTH, y2 * FONT_HEIGHT,
 554                        FONT_WIDTH, FONT_HEIGHT);
 555         }
 556     }
 557 }
 558
 559 static void console_show_cursor(TextConsole *s, int show)
 560 {
 561     TextCell *c;
 562     int y, y1;
 563
 564     if (s == active_console) {
 565         int x = s->x;
 566
 567         if (!s->ds->depth) {
 568             s->cursor_invalidate = 1;
 569             return;
 570         }
 571
 572         if (x >= s->width) {
 573             x = s->width - 1;
 574         }
 575         y1 = (s->y_base + s->y) % s->total_height;
 576         y = y1 - s->y_displayed;
 577         if (y < 0)
 578             y += s->total_height;
 579         if (y < s->height) {
 580             c = &s->cells[y1 * s->width + x];
 581             if (show) {
 582                 TextAttributes t_attrib = s->t_attrib_default;
 583                 t_attrib.invers = !(t_attrib.invers); /* invert fg and bg */
 584                 vga_putcharxy(s->ds, x, y, c->ch, &t_attrib);
 585             } else {
 586                 vga_putcharxy(s->ds, x, y, c->ch, &(c->t_attrib));
 587             }
 588             dpy_update(s->ds, x * FONT_WIDTH, y * FONT_HEIGHT,
 589                        FONT_WIDTH, FONT_HEIGHT);
 590         }
 591     }
 592 }
 593
 594 static void console_refresh(TextConsole *s)
 595 {
 596     TextCell *c;
 597     int x, y, y1;
 598
 599     if (s != active_console)
 600         return;
 601     if (!s->ds->depth) {
 602         s->text_x[0] = 0;
 603         s->text_y[0] = 0;
 604         s->text_x[1] = s->width - 1;
 605         s->text_y[1] = s->height - 1;
 606         s->cursor_invalidate = 1;
 607         return;
 608     }
 609
 610     vga_fill_rect(s->ds, 0, 0, s->ds->width, s->ds->height,
 611                   color_table[0][COLOR_BLACK]);
 612     y1 = s->y_displayed;
 613     for(y = 0; y < s->height; y++) {
 614         c = s->cells + y1 * s->width;
 615         for(x = 0; x < s->width; x++) {
 616             vga_putcharxy(s->ds, x, y, c->ch,
 617                           &(c->t_attrib));
 618             c++;
 619         }
 620         if (++y1 == s->total_height)
 621             y1 = 0;
 622     }
 623     dpy_update(s->ds, 0, 0, s->ds->width, s->ds->height);
 624     console_show_cursor(s, 1);
 625 }
 626
 627 static void console_scroll(int ydelta)
 628 {
 629     TextConsole *s;
 630     int i, y1;
 631
 632     s = active_console;
 633     if (!s || (s->console_type == GRAPHIC_CONSOLE))
 634         return;
 635
 636     if (ydelta > 0) {
 637         for(i = 0; i < ydelta; i++) {
 638             if (s->y_displayed == s->y_base)
 639                 break;
 640             if (++s->y_displayed == s->total_height)
 641                 s->y_displayed = 0;
 642         }
 643     } else {
 644         ydelta = -ydelta;
 645         i = s->backscroll_height;
 646         if (i > s->total_height - s->height)
 647             i = s->total_height - s->height;
 648         y1 = s->y_base - i;
 649         if (y1 < 0)
 650             y1 += s->total_height;
 651         for(i = 0; i < ydelta; i++) {
 652             if (s->y_displayed == y1)
 653                 break;
 654             if (--s->y_displayed < 0)
 655                 s->y_displayed = s->total_height - 1;
 656         }
 657     }
 658     console_refresh(s);
 659 }
 660
 661 static void console_put_lf(TextConsole *s)
 662 {
 663     TextCell *c;
 664     int x, y1;
 665
 666     s->y++;
 667     if (s->y >= s->height) {
 668         s->y = s->height - 1;
 669
 670         if (s->y_displayed == s->y_base) {
 671             if (++s->y_displayed == s->total_height)
 672                 s->y_displayed = 0;
 673         }
 674         if (++s->y_base == s->total_height)
 675             s->y_base = 0;
 676         if (s->backscroll_height < s->total_height)
 677             s->backscroll_height++;
 678         y1 = (s->y_base + s->height - 1) % s->total_height;
 679         c = &s->cells[y1 * s->width];
 680         for(x = 0; x < s->width; x++) {
 681             c->ch = ' ';
 682             c->t_attrib = s->t_attrib_default;
 683             c++;
 684         }
 685         if (s == active_console && s->y_displayed == s->y_base) {
 686             if (!s->ds->depth) {
 687                 s->text_x[0] = 0;
 688                 s->text_y[0] = 0;
 689                 s->text_x[1] = s->width - 1;
 690                 s->text_y[1] = s->height - 1;
 691                 return;
 692             }
 693
 694             vga_bitblt(s->ds, 0, FONT_HEIGHT, 0, 0,
 695                        s->width * FONT_WIDTH,
 696                        (s->height - 1) * FONT_HEIGHT);
 697             vga_fill_rect(s->ds, 0, (s->height - 1) * FONT_HEIGHT,
 698                           s->width * FONT_WIDTH, FONT_HEIGHT,
 699                           color_table[0][s->t_attrib_default.bgcol]);
 700             dpy_update(s->ds, 0, 0,
 701                        s->width * FONT_WIDTH, s->height * FONT_HEIGHT);
 702         }
 703     }
 704 }
 705
 706 /* Set console attributes depending on the current escape codes.
 707  * NOTE: I know this code is not very efficient (checking every color for it
 708  * self) but it is more readable and better maintainable.
 709  */
 710 static void console_handle_escape(TextConsole *s)
 711 {
 712     int i;
 713
 714     for (i=0; i<s->nb_esc_params; i++) {
 715         switch (s->esc_params[i]) {
 716             case 0: /* reset all console attributes to default */
 717                 s->t_attrib = s->t_attrib_default;
 718                 break;
 719             case 1:
 720                 s->t_attrib.bold = 1;
 721                 break;
 722             case 4:
 723                 s->t_attrib.uline = 1;
 724                 break;
 725             case 5:
 726                 s->t_attrib.blink = 1;
 727                 break;
 728             case 7:
 729                 s->t_attrib.invers = 1;
 730                 break;
 731             case 8:
 732                 s->t_attrib.unvisible = 1;
 733                 break;
 734             case 22:
 735                 s->t_attrib.bold = 0;
 736                 break;
 737             case 24:
 738                 s->t_attrib.uline = 0;
 739                 break;
 740             case 25:
 741                 s->t_attrib.blink = 0;
 742                 break;
 743             case 27:
 744                 s->t_attrib.invers = 0;
 745                 break;
 746             case 28:
 747                 s->t_attrib.unvisible = 0;
 748                 break;
 749             /* set foreground color */
 750             case 30:
 751                 s->t_attrib.fgcol=COLOR_BLACK;
 752                 break;
 753             case 31:
 754                 s->t_attrib.fgcol=COLOR_RED;
 755                 break;
 756             case 32:
 757                 s->t_attrib.fgcol=COLOR_GREEN;
 758                 break;
 759             case 33:
 760                 s->t_attrib.fgcol=COLOR_YELLOW;
 761                 break;
 762             case 34:
 763                 s->t_attrib.fgcol=COLOR_BLUE;
 764                 break;
 765             case 35:
 766                 s->t_attrib.fgcol=COLOR_MAGENTA;
 767                 break;
 768             case 36:
 769                 s->t_attrib.fgcol=COLOR_CYAN;
 770                 break;
 771             case 37:
 772                 s->t_attrib.fgcol=COLOR_WHITE;
 773                 break;
 774             /* set background color */
 775             case 40:
 776                 s->t_attrib.bgcol=COLOR_BLACK;
 777                 break;
 778             case 41:
 779                 s->t_attrib.bgcol=COLOR_RED;
 780                 break;
 781             case 42:
 782                 s->t_attrib.bgcol=COLOR_GREEN;
 783                 break;
 784             case 43:
 785                 s->t_attrib.bgcol=COLOR_YELLOW;
 786                 break;
 787             case 44:
 788                 s->t_attrib.bgcol=COLOR_BLUE;
 789                 break;
 790             case 45:
 791                 s->t_attrib.bgcol=COLOR_MAGENTA;
 792                 break;
 793             case 46:
 794                 s->t_attrib.bgcol=COLOR_CYAN;
 795                 break;
 796             case 47:
 797                 s->t_attrib.bgcol=COLOR_WHITE;
 798                 break;
 799         }
 800     }
 801 }
 802
 803 static void console_clear_xy(TextConsole *s, int x, int y)
 804 {
 805     int y1 = (s->y_base + y) % s->total_height;
 806     TextCell *c = &s->cells[y1 * s->width + x];
 807     c->ch = ' ';
 808     c->t_attrib = s->t_attrib_default;
 809     c++;
 810     update_xy(s, x, y);
 811 }
 812
 813 static void console_putchar(TextConsole *s, int ch)
 814 {
 815     TextCell *c;
 816     int y1, i;
 817     int x, y;
 818
 819     switch(s->state) {
 820     case TTY_STATE_NORM:
 821         switch(ch) {
 822         case '\r':  /* carriage return */
 823             s->x = 0;
 824             break;
 825         case '\n':  /* newline */
 826             console_put_lf(s);
 827             break;
 828         case '\b':  /* backspace */
 829             if (s->x > 0)
 830                 s->x--;
 831             break;
 832         case '\t':  /* tabspace */
 833             if (s->x + (8 - (s->x % 8)) > s->width) {
 834                 s->x = 0;
 835                 console_put_lf(s);
 836             } else {
 837                 s->x = s->x + (8 - (s->x % 8));
 838             }
 839             break;
 840         case '\a':  /* alert aka. bell */
 841             /* TODO: has to be implemented */
 842             break;
 843         case 14:
 844             /* SI (shift in), character set 0 (ignored) */
 845             break;
 846         case 15:
 847             /* SO (shift out), character set 1 (ignored) */
 848             break;
 849         case 27:    /* esc (introducing an escape sequence) */
 850             s->state = TTY_STATE_ESC;
 851             break;
 852         default:
 853             if (s->x >= s->width) {
 854                 /* line wrap */
 855                 s->x = 0;
 856                 console_put_lf(s);
 857             }
 858             y1 = (s->y_base + s->y) % s->total_height;
 859             c = &s->cells[y1 * s->width + s->x];
 860             c->ch = ch;
 861             c->t_attrib = s->t_attrib;
 862             update_xy(s, s->x, s->y);
 863             s->x++;
 864             break;
 865         }
 866         break;
 867     case TTY_STATE_ESC: /* check if it is a terminal escape sequence */
 868         if (ch == '[') {
 869             for(i=0;i<MAX_ESC_PARAMS;i++)
 870                 s->esc_params[i] = 0;
 871             s->nb_esc_params = 0;
 872             s->state = TTY_STATE_CSI;
 873         } else {
 874             s->state = TTY_STATE_NORM;
 875         }
 876         break;
 877     case TTY_STATE_CSI: /* handle escape sequence parameters */
 878         if (ch >= '0' && ch <= '9') {
 879             if (s->nb_esc_params < MAX_ESC_PARAMS) {
 880                 s->esc_params[s->nb_esc_params] =
 881                     s->esc_params[s->nb_esc_params] * 10 + ch - '0';
 882             }
 883         } else {
 884             s->nb_esc_params++;
 885             if (ch == ';')
 886                 break;
 887 #ifdef DEBUG_CONSOLE
 888             fprintf(stderr, "escape sequence CSI%d;%d%c, %d parameters\n",
 889                     s->esc_params[0], s->esc_params[1], ch, s->nb_esc_params);
 890 #endif
 891             s->state = TTY_STATE_NORM;
 892             switch(ch) {
 893             case 'A':
 894                 /* move cursor up */
 895                 if (s->esc_params[0] == 0) {
 896                     s->esc_params[0] = 1;
 897                 }
 898                 s->y -= s->esc_params[0];
 899                 if (s->y < 0) {
 900                     s->y = 0;
 901                 }
 902                 break;
 903             case 'B':
 904                 /* move cursor down */
 905                 if (s->esc_params[0] == 0) {
 906                     s->esc_params[0] = 1;
 907                 }
 908                 s->y += s->esc_params[0];
 909                 if (s->y >= s->height) {
 910                     s->y = s->height - 1;
 911                 }
 912                 break;
 913             case 'C':
 914                 /* move cursor right */
 915                 if (s->esc_params[0] == 0) {
 916                     s->esc_params[0] = 1;
 917                 }
 918                 s->x += s->esc_params[0];
 919                 if (s->x >= s->width) {
 920                     s->x = s->width - 1;
 921                 }
 922                 break;
 923             case 'D':
 924                 /* move cursor left */
 925                 if (s->esc_params[0] == 0) {
 926                     s->esc_params[0] = 1;
 927                 }
 928                 s->x -= s->esc_params[0];
 929                 if (s->x < 0) {
 930                     s->x = 0;
 931                 }
 932                 break;
 933             case 'G':
 934                 /* move cursor to column */
 935                 s->x = s->esc_params[0] - 1;
 936                 if (s->x < 0) {
 937                     s->x = 0;
 938                 }
 939                 break;
 940             case 'f':
 941             case 'H':
 942                 /* move cursor to row, column */
 943                 s->x = s->esc_params[1] - 1;
 944                 if (s->x < 0) {
 945                     s->x = 0;
 946                 }
 947                 s->y = s->esc_params[0] - 1;
 948                 if (s->y < 0) {
 949                     s->y = 0;
 950                 }
 951                 break;
 952             case 'J':
 953                 switch (s->esc_params[0]) {
 954                 case 0:
 955                     /* clear to end of screen */
 956                     for (y = s->y; y < s->height; y++) {
 957                         for (x = 0; x < s->width; x++) {
 958                             if (y == s->y && x < s->x) {
 959                                 continue;
 960                             }
 961                             console_clear_xy(s, x, y);
 962                         }
 963                     }
 964                     break;
 965                 case 1:
 966                     /* clear from beginning of screen */
 967                     for (y = 0; y <= s->y; y++) {
 968                         for (x = 0; x < s->width; x++) {
 969                             if (y == s->y && x > s->x) {
 970                                 break;
 971                             }
 972                             console_clear_xy(s, x, y);
 973                         }
 974                     }
 975                     break;
 976                 case 2:
 977                     /* clear entire screen */
 978                     for (y = 0; y <= s->height; y++) {
 979                         for (x = 0; x < s->width; x++) {
 980                             console_clear_xy(s, x, y);
 981                         }
 982                     }
 983                 break;
 984                 }
 985             case 'K':
 986                 switch (s->esc_params[0]) {
 987                 case 0:
 988                 /* clear to eol */
 989                 for(x = s->x; x < s->width; x++) {
 990                         console_clear_xy(s, x, s->y);
 991                 }
 992                 break;
 993                 case 1:
 994                     /* clear from beginning of line */
 995                     for (x = 0; x <= s->x; x++) {
 996                         console_clear_xy(s, x, s->y);
 997                     }
 998                     break;
 999                 case 2:
1000                     /* clear entire line */
1001                     for(x = 0; x < s->width; x++) {
1002                         console_clear_xy(s, x, s->y);
1003                     }
1004                 break;
1005             }
1006                 break;
1007             case 'm':
1008             console_handle_escape(s);
1009             break;
1010             case 'n':
1011                 /* report cursor position */
1012                 /* TODO: send ESC[row;colR */
1013                 break;
1014             case 's':
1015                 /* save cursor position */
1016                 s->x_saved = s->x;
1017                 s->y_saved = s->y;
1018                 break;
1019             case 'u':
1020                 /* restore cursor position */
1021                 s->x = s->x_saved;
1022                 s->y = s->y_saved;
1023                 break;
1024             default:
1025 #ifdef DEBUG_CONSOLE
1026                 fprintf(stderr, "unhandled escape character '%c'\n", ch);
1027 #endif
1028                 break;
1029             }
1030             break;
1031         }
1032     }
1033 }
1034
1035 void console_select(unsigned int index)
1036 {
1037     TextConsole *s;
1038
1039     if (index >= MAX_CONSOLES)
1040         return;
1041     s = consoles[index];
1042     if (s) {
1043         active_console = s;
1044         vga_hw_invalidate();
1045     }
1046 }
1047
1048 static int console_puts(CharDriverState *chr, const uint8_t *buf, int len)
1049 {
1050     TextConsole *s = chr->opaque;
1051     int i;
1052
1053     console_show_cursor(s, 0);
1054     for(i = 0; i < len; i++) {
1055         console_putchar(s, buf[i]);
1056     }
1057     console_show_cursor(s, 1);
1058     return len;
1059 }
1060
1061 static void console_send_event(CharDriverState *chr, int event)
1062 {
1063     TextConsole *s = chr->opaque;
1064     int i;
1065
1066     if (event == CHR_EVENT_FOCUS) {
1067         for(i = 0; i < nb_consoles; i++) {
1068             if (consoles[i] == s) {
1069                 console_select(i);
1070                 break;
1071             }
1072         }
1073     }
1074 }
1075
1076 static void kbd_send_chars(void *opaque)
1077 {
1078     TextConsole *s = opaque;
1079     int len;
1080     uint8_t buf[16];
1081
1082     len = qemu_chr_can_read(s->chr);
1083     if (len > s->out_fifo.count)
1084         len = s->out_fifo.count;
1085     if (len > 0) {
1086         if (len > sizeof(buf))
1087             len = sizeof(buf);
1088         qemu_fifo_read(&s->out_fifo, buf, len);
1089         qemu_chr_read(s->chr, buf, len);
1090     }
1091     /* characters are pending: we send them a bit later (XXX:
1092        horrible, should change char device API) */
1093     if (s->out_fifo.count > 0) {
1094         qemu_mod_timer(s->kbd_timer, qemu_get_clock(rt_clock) + 1);
1095     }
1096 }
1097
1098 /* called when an ascii key is pressed */
1099 void kbd_put_keysym(int keysym)
1100 {
1101     TextConsole *s;
1102     uint8_t buf[16], *q;
1103     int c;
1104
1105     s = active_console;
1106     if (!s || (s->console_type == GRAPHIC_CONSOLE))
1107         return;
1108
1109     switch(keysym) {
1110     case QEMU_KEY_CTRL_UP:
1111         console_scroll(-1);
1112         break;
1113     case QEMU_KEY_CTRL_DOWN:
1114         console_scroll(1);
1115         break;
1116     case QEMU_KEY_CTRL_PAGEUP:
1117         console_scroll(-10);
1118         break;
1119     case QEMU_KEY_CTRL_PAGEDOWN:
1120         console_scroll(10);
1121         break;
1122     default:
1123         /* convert the QEMU keysym to VT100 key string */
1124         q = buf;
1125         if (keysym >= 0xe100 && keysym <= 0xe11f) {
1126             *q++ = '\033';
1127             *q++ = '[';
1128             c = keysym - 0xe100;
1129             if (c >= 10)
1130                 *q++ = '0' + (c / 10);
1131             *q++ = '0' + (c % 10);
1132             *q++ = '~';
1133         } else if (keysym >= 0xe120 && keysym <= 0xe17f) {
1134             *q++ = '\033';
1135             *q++ = '[';
1136             *q++ = keysym & 0xff;
1137         } else {
1138                 *q++ = keysym;
1139         }
1140         if (s->chr->chr_read) {
1141             qemu_fifo_write(&s->out_fifo, buf, q - buf);
1142             kbd_send_chars(s);
1143         }
1144         break;
1145     }
1146 }
1147
1148 static void text_console_invalidate(void *opaque)
1149 {
1150     TextConsole *s = (TextConsole *) opaque;
1151
1152     if (s->console_type != GRAPHIC_CONSOLE) {
1153         if (s->g_width != s->ds->width ||
1154             s->g_height != s->ds->height) {
1155             if (s->console_type == TEXT_CONSOLE_FIXED_SIZE)
1156                 dpy_resize(s->ds, s->g_width, s->g_height);
1157             else {
1158                 s->g_width = s->ds->width;
1159                 s->g_height = s->ds->height;
1160                 text_console_resize(s);
1161             }
1162         }
1163     }
1164     console_refresh(s);
1165 }
1166
1167 static void text_console_update(void *opaque, console_ch_t *chardata)
1168 {
1169     TextConsole *s = (TextConsole *) opaque;
1170     int i, j, src;
1171
1172     if (s->text_x[0] <= s->text_x[1]) {
1173         src = (s->y_base + s->text_y[0]) * s->width;
1174         chardata += s->text_y[0] * s->width;
1175         for (i = s->text_y[0]; i <= s->text_y[1]; i ++)
1176             for (j = 0; j < s->width; j ++, src ++)
1177                 console_write_ch(chardata ++, s->cells[src].ch |
1178                                 (s->cells[src].t_attrib.fgcol << 12) |
1179                                 (s->cells[src].t_attrib.bgcol << 8) |
1180                                 (s->cells[src].t_attrib.bold << 21));
1181         dpy_update(s->ds, s->text_x[0], s->text_y[0],
1182                    s->text_x[1] - s->text_x[0], i - s->text_y[0]);
1183         s->text_x[0] = s->width;
1184         s->text_y[0] = s->height;
1185         s->text_x[1] = 0;
1186         s->text_y[1] = 0;
1187     }
1188     if (s->cursor_invalidate) {
1189         dpy_cursor(s->ds, s->x, s->y);
1190         s->cursor_invalidate = 0;
1191     }
1192 }
1193
1194 static TextConsole *new_console(DisplayState *ds, console_type_t console_type)
1195 {
1196     TextConsole *s;
1197     int i;
1198
1199     if (nb_consoles >= MAX_CONSOLES)
1200         return NULL;
1201     s = qemu_mallocz(sizeof(TextConsole));
1202     if (!s) {
1203         return NULL;
1204     }
1205     if (!active_console || ((active_console->console_type != GRAPHIC_CONSOLE) &&
1206         (console_type == GRAPHIC_CONSOLE))) {
1207         active_console = s;
1208     }
1209     s->ds = ds;
1210     s->console_type = console_type;
1211     if (console_type != GRAPHIC_CONSOLE) {
1212         consoles[nb_consoles++] = s;
1213     } else {
1214         /* HACK: Put graphical consoles before text consoles.  */
1215         for (i = nb_consoles; i > 0; i--) {
1216             if (consoles[i - 1]->console_type == GRAPHIC_CONSOLE)
1217                 break;
1218             consoles[i] = consoles[i - 1];
1219         }
1220         consoles[i] = s;
1221     }
1222     return s;
1223 }
1224
1225 TextConsole *graphic_console_init(DisplayState *ds, vga_hw_update_ptr update,
1226                                   vga_hw_invalidate_ptr invalidate,
1227                                   vga_hw_screen_dump_ptr screen_dump,
1228                                   vga_hw_text_update_ptr text_update,
1229                                   void *opaque)
1230 {
1231     TextConsole *s;
1232
1233     s = new_console(ds, GRAPHIC_CONSOLE);
1234     if (!s)
1235       return NULL;
1236     s->hw_update = update;
1237     s->hw_invalidate = invalidate;
1238     s->hw_screen_dump = screen_dump;
1239     s->hw_text_update = text_update;
1240     s->hw = opaque;
1241     return s;
1242 }
1243
1244 int is_graphic_console(void)
1245 {
1246     return active_console && active_console->console_type == GRAPHIC_CONSOLE;
1247 }
1248
1249 void console_color_init(DisplayState *ds)
1250 {
1251     int i, j;
1252     for (j = 0; j < 2; j++) {
1253         for (i = 0; i < 8; i++) {
1254             color_table[j][i] = col_expand(ds,
1255                    vga_get_color(ds, color_table_rgb[j][i]));
1256         }
1257     }
1258 }
1259
1260 CharDriverState *text_console_init(DisplayState *ds, const char *p)
1261 {
1262     CharDriverState *chr;
1263     TextConsole *s;
1264     unsigned width;
1265     unsigned height;
1266     static int color_inited;
1267
1268     chr = qemu_mallocz(sizeof(CharDriverState));
1269     if (!chr)
1270         return NULL;
1271     s = new_console(ds, (p == 0) ? TEXT_CONSOLE : TEXT_CONSOLE_FIXED_SIZE);
1272     if (!s) {
1273         free(chr);
1274         return NULL;
1275     }
1276     chr->opaque = s;
1277     chr->chr_write = console_puts;
1278     chr->chr_send_event = console_send_event;
1279
1280     s->chr = chr;
1281     s->out_fifo.buf = s->out_fifo_buf;
1282     s->out_fifo.buf_size = sizeof(s->out_fifo_buf);
1283     s->kbd_timer = qemu_new_timer(rt_clock, kbd_send_chars, s);
1284
1285     if (!color_inited) {
1286         color_inited = 1;
1287         console_color_init(s->ds);
1288     }
1289     s->y_displayed = 0;
1290     s->y_base = 0;
1291     s->total_height = DEFAULT_BACKSCROLL;
1292     s->x = 0;
1293     s->y = 0;
1294     width = s->ds->width;
1295     height = s->ds->height;
1296     if (p != 0) {
1297         width = strtoul(p, (char **)&p, 10);
1298         if (*p == 'C') {
1299             p++;
1300             width *= FONT_WIDTH;
1301         }
1302         if (*p == 'x') {
1303             p++;
1304             height = strtoul(p, (char **)&p, 10);
1305             if (*p == 'C') {
1306                 p++;
1307                 height *= FONT_HEIGHT;
1308             }
1309         }
1310     }
1311     s->g_width = width;
1312     s->g_height = height;
1313
1314     s->hw_invalidate = text_console_invalidate;
1315     s->hw_text_update = text_console_update;
1316     s->hw = s;
1317
1318     /* Set text attribute defaults */
1319     s->t_attrib_default.bold = 0;
1320     s->t_attrib_default.uline = 0;
1321     s->t_attrib_default.blink = 0;
1322     s->t_attrib_default.invers = 0;
1323     s->t_attrib_default.unvisible = 0;
1324     s->t_attrib_default.fgcol = COLOR_WHITE;
1325     s->t_attrib_default.bgcol = COLOR_BLACK;
1326
1327     /* set current text attributes to default */
1328     s->t_attrib = s->t_attrib_default;
1329     text_console_resize(s);
1330
1331     qemu_chr_reset(chr);
1332
1333     return chr;
1334 }