Statistics
| Branch: | Revision:

root / console.c @ 3bba22de

History | View | Annotate | Download (36.9 kB)

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
#define DEFAULT_MONITOR_SIZE "800x600"
32

    
33
#define QEMU_RGBA(r, g, b, a) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
34
#define QEMU_RGB(r, g, b) QEMU_RGBA(r, g, b, 0xff)
35

    
36
typedef struct TextAttributes {
37
    uint8_t fgcol:4;
38
    uint8_t bgcol:4;
39
    uint8_t bold:1;
40
    uint8_t uline:1;
41
    uint8_t blink:1;
42
    uint8_t invers:1;
43
    uint8_t unvisible:1;
44
} TextAttributes;
45

    
46
typedef struct TextCell {
47
    uint8_t ch;
48
    TextAttributes t_attrib;
49
} TextCell;
50

    
51
#define MAX_ESC_PARAMS 3
52

    
53
enum TTYState {
54
    TTY_STATE_NORM,
55
    TTY_STATE_ESC,
56
    TTY_STATE_CSI,
57
};
58

    
59
typedef struct QEMUFIFO {
60
    uint8_t *buf;
61
    int buf_size;
62
    int count, wptr, rptr;
63
} QEMUFIFO;
64

    
65
static int qemu_fifo_write(QEMUFIFO *f, const uint8_t *buf, int len1)
66
{
67
    int l, len;
68

    
69
    l = f->buf_size - f->count;
70
    if (len1 > l)
71
        len1 = l;
72
    len = len1;
73
    while (len > 0) {
74
        l = f->buf_size - f->wptr;
75
        if (l > len)
76
            l = len;
77
        memcpy(f->buf + f->wptr, buf, l);
78
        f->wptr += l;
79
        if (f->wptr >= f->buf_size)
80
            f->wptr = 0;
81
        buf += l;
82
        len -= l;
83
    }
84
    f->count += len1;
85
    return len1;
86
}
87

    
88
static int qemu_fifo_read(QEMUFIFO *f, uint8_t *buf, int len1)
89
{
90
    int l, len;
91

    
92
    if (len1 > f->count)
93
        len1 = f->count;
94
    len = len1;
95
    while (len > 0) {
96
        l = f->buf_size - f->rptr;
97
        if (l > len)
98
            l = len;
99
        memcpy(buf, f->buf + f->rptr, l);
100
        f->rptr += l;
101
        if (f->rptr >= f->buf_size)
102
            f->rptr = 0;
103
        buf += l;
104
        len -= l;
105
    }
106
    f->count -= len1;
107
    return len1;
108
}
109

    
110
typedef enum {
111
    GRAPHIC_CONSOLE,
112
    TEXT_CONSOLE
113
} 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
    TextConsole *previous_active_console;
171

    
172
    previous_active_console = active_console;
173
    active_console = consoles[0];
174
    /* There is currently no way of specifying which screen we want to dump,
175
       so always dump the dirst one.  */
176
    if (consoles[0]->hw_screen_dump)
177
        consoles[0]->hw_screen_dump(consoles[0]->hw, filename);
178
    active_console = previous_active_console;
179
}
180

    
181
void vga_hw_text_update(console_ch_t *chardata)
182
{
183
    if (active_console && active_console->hw_text_update)
184
        active_console->hw_text_update(active_console->hw, chardata);
185
}
186

    
187
/* convert a RGBA color to a color index usable in graphic primitives */
188
static unsigned int vga_get_color(DisplayState *ds, unsigned int rgba)
189
{
190
    unsigned int r, g, b, color;
191

    
192
    switch(ds->depth) {
193
#if 0
194
    case 8:
195
        r = (rgba >> 16) & 0xff;
196
        g = (rgba >> 8) & 0xff;
197
        b = (rgba) & 0xff;
198
        color = (rgb_to_index[r] * 6 * 6) +
199
            (rgb_to_index[g] * 6) +
200
            (rgb_to_index[b]);
201
        break;
202
#endif
203
    case 15:
204
        r = (rgba >> 16) & 0xff;
205
        g = (rgba >> 8) & 0xff;
206
        b = (rgba) & 0xff;
207
        color = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3);
208
        break;
209
    case 16:
210
        r = (rgba >> 16) & 0xff;
211
        g = (rgba >> 8) & 0xff;
212
        b = (rgba) & 0xff;
213
        color = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);
214
        break;
215
    case 32:
216
    default:
217
        color = rgba;
218
        break;
219
    }
220
    return color;
221
}
222

    
223
static void vga_fill_rect (DisplayState *ds,
224
                           int posx, int posy, int width, int height, uint32_t color)
225
{
226
    uint8_t *d, *d1;
227
    int x, y, bpp;
228

    
229
    bpp = (ds->depth + 7) >> 3;
230
    d1 = ds->data +
231
        ds->linesize * posy + bpp * posx;
232
    for (y = 0; y < height; y++) {
233
        d = d1;
234
        switch(bpp) {
235
        case 1:
236
            for (x = 0; x < width; x++) {
237
                *((uint8_t *)d) = color;
238
                d++;
239
            }
240
            break;
241
        case 2:
242
            for (x = 0; x < width; x++) {
243
                *((uint16_t *)d) = color;
244
                d += 2;
245
            }
246
            break;
247
        case 4:
248
            for (x = 0; x < width; x++) {
249
                *((uint32_t *)d) = color;
250
                d += 4;
251
            }
252
            break;
253
        }
254
        d1 += ds->linesize;
255
    }
256
}
257

    
258
/* copy from (xs, ys) to (xd, yd) a rectangle of size (w, h) */
259
static void vga_bitblt(DisplayState *ds, int xs, int ys, int xd, int yd, int w, int h)
260
{
261
    const uint8_t *s;
262
    uint8_t *d;
263
    int wb, y, bpp;
264

    
265
    bpp = (ds->depth + 7) >> 3;
266
    wb = w * bpp;
267
    if (yd <= ys) {
268
        s = ds->data +
269
            ds->linesize * ys + bpp * xs;
270
        d = ds->data +
271
            ds->linesize * yd + bpp * xd;
272
        for (y = 0; y < h; y++) {
273
            memmove(d, s, wb);
274
            d += ds->linesize;
275
            s += ds->linesize;
276
        }
277
    } else {
278
        s = ds->data +
279
            ds->linesize * (ys + h - 1) + bpp * xs;
280
        d = ds->data +
281
            ds->linesize * (yd + h - 1) + bpp * xd;
282
       for (y = 0; y < h; y++) {
283
            memmove(d, s, wb);
284
            d -= ds->linesize;
285
            s -= ds->linesize;
286
        }
287
    }
288
}
289

    
290
/***********************************************************/
291
/* basic char display */
292

    
293
#define FONT_HEIGHT 16
294
#define FONT_WIDTH 8
295

    
296
#include "vgafont.h"
297

    
298
#define cbswap_32(__x) \
299
((uint32_t)( \
300
                (((uint32_t)(__x) & (uint32_t)0x000000ffUL) << 24) | \
301
                (((uint32_t)(__x) & (uint32_t)0x0000ff00UL) <<  8) | \
302
                (((uint32_t)(__x) & (uint32_t)0x00ff0000UL) >>  8) | \
303
                (((uint32_t)(__x) & (uint32_t)0xff000000UL) >> 24) ))
304

    
305
#ifdef WORDS_BIGENDIAN
306
#define PAT(x) x
307
#else
308
#define PAT(x) cbswap_32(x)
309
#endif
310

    
311
static const uint32_t dmask16[16] = {
312
    PAT(0x00000000),
313
    PAT(0x000000ff),
314
    PAT(0x0000ff00),
315
    PAT(0x0000ffff),
316
    PAT(0x00ff0000),
317
    PAT(0x00ff00ff),
318
    PAT(0x00ffff00),
319
    PAT(0x00ffffff),
320
    PAT(0xff000000),
321
    PAT(0xff0000ff),
322
    PAT(0xff00ff00),
323
    PAT(0xff00ffff),
324
    PAT(0xffff0000),
325
    PAT(0xffff00ff),
326
    PAT(0xffffff00),
327
    PAT(0xffffffff),
328
};
329

    
330
static const uint32_t dmask4[4] = {
331
    PAT(0x00000000),
332
    PAT(0x0000ffff),
333
    PAT(0xffff0000),
334
    PAT(0xffffffff),
335
};
336

    
337
static uint32_t color_table[2][8];
338

    
339
enum color_names {
340
    COLOR_BLACK   = 0,
341
    COLOR_RED     = 1,
342
    COLOR_GREEN   = 2,
343
    COLOR_YELLOW  = 3,
344
    COLOR_BLUE    = 4,
345
    COLOR_MAGENTA = 5,
346
    COLOR_CYAN    = 6,
347
    COLOR_WHITE   = 7
348
};
349

    
350
static const uint32_t color_table_rgb[2][8] = {
351
    {   /* dark */
352
        QEMU_RGB(0x00, 0x00, 0x00),  /* black */
353
        QEMU_RGB(0xaa, 0x00, 0x00),  /* red */
354
        QEMU_RGB(0x00, 0xaa, 0x00),  /* green */
355
        QEMU_RGB(0xaa, 0xaa, 0x00),  /* yellow */
356
        QEMU_RGB(0x00, 0x00, 0xaa),  /* blue */
357
        QEMU_RGB(0xaa, 0x00, 0xaa),  /* magenta */
358
        QEMU_RGB(0x00, 0xaa, 0xaa),  /* cyan */
359
        QEMU_RGB(0xaa, 0xaa, 0xaa),  /* white */
360
    },
361
    {   /* bright */
362
        QEMU_RGB(0x00, 0x00, 0x00),  /* black */
363
        QEMU_RGB(0xff, 0x00, 0x00),  /* red */
364
        QEMU_RGB(0x00, 0xff, 0x00),  /* green */
365
        QEMU_RGB(0xff, 0xff, 0x00),  /* yellow */
366
        QEMU_RGB(0x00, 0x00, 0xff),  /* blue */
367
        QEMU_RGB(0xff, 0x00, 0xff),  /* magenta */
368
        QEMU_RGB(0x00, 0xff, 0xff),  /* cyan */
369
        QEMU_RGB(0xff, 0xff, 0xff),  /* white */
370
    }
371
};
372

    
373
static inline unsigned int col_expand(DisplayState *ds, unsigned int col)
374
{
375
    switch(ds->depth) {
376
    case 8:
377
        col |= col << 8;
378
        col |= col << 16;
379
        break;
380
    case 15:
381
    case 16:
382
        col |= col << 16;
383
        break;
384
    default:
385
        break;
386
    }
387

    
388
    return col;
389
}
390
#ifdef DEBUG_CONSOLE
391
static void console_print_text_attributes(TextAttributes *t_attrib, char ch)
392
{
393
    if (t_attrib->bold) {
394
        printf("b");
395
    } else {
396
        printf(" ");
397
    }
398
    if (t_attrib->uline) {
399
        printf("u");
400
    } else {
401
        printf(" ");
402
    }
403
    if (t_attrib->blink) {
404
        printf("l");
405
    } else {
406
        printf(" ");
407
    }
408
    if (t_attrib->invers) {
409
        printf("i");
410
    } else {
411
        printf(" ");
412
    }
413
    if (t_attrib->unvisible) {
414
        printf("n");
415
    } else {
416
        printf(" ");
417
    }
418

    
419
    printf(" fg: %d bg: %d ch:'%2X' '%c'\n", t_attrib->fgcol, t_attrib->bgcol, ch, ch);
420
}
421
#endif
422

    
423
static void vga_putcharxy(DisplayState *ds, int x, int y, int ch,
424
                          TextAttributes *t_attrib)
425
{
426
    uint8_t *d;
427
    const uint8_t *font_ptr;
428
    unsigned int font_data, linesize, xorcol, bpp;
429
    int i;
430
    unsigned int fgcol, bgcol;
431

    
432
#ifdef DEBUG_CONSOLE
433
    printf("x: %2i y: %2i", x, y);
434
    console_print_text_attributes(t_attrib, ch);
435
#endif
436

    
437
    if (t_attrib->invers) {
438
        bgcol = color_table[t_attrib->bold][t_attrib->fgcol];
439
        fgcol = color_table[t_attrib->bold][t_attrib->bgcol];
440
    } else {
441
        fgcol = color_table[t_attrib->bold][t_attrib->fgcol];
442
        bgcol = color_table[t_attrib->bold][t_attrib->bgcol];
443
    }
444

    
445
    bpp = (ds->depth + 7) >> 3;
446
    d = ds->data +
447
        ds->linesize * y * FONT_HEIGHT + bpp * x * FONT_WIDTH;
448
    linesize = ds->linesize;
449
    font_ptr = vgafont16 + FONT_HEIGHT * ch;
450
    xorcol = bgcol ^ fgcol;
451
    switch(ds->depth) {
452
    case 8:
453
        for(i = 0; i < FONT_HEIGHT; i++) {
454
            font_data = *font_ptr++;
455
            if (t_attrib->uline
456
                && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {
457
                font_data = 0xFFFF;
458
            }
459
            ((uint32_t *)d)[0] = (dmask16[(font_data >> 4)] & xorcol) ^ bgcol;
460
            ((uint32_t *)d)[1] = (dmask16[(font_data >> 0) & 0xf] & xorcol) ^ bgcol;
461
            d += linesize;
462
        }
463
        break;
464
    case 16:
465
    case 15:
466
        for(i = 0; i < FONT_HEIGHT; i++) {
467
            font_data = *font_ptr++;
468
            if (t_attrib->uline
469
                && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {
470
                font_data = 0xFFFF;
471
            }
472
            ((uint32_t *)d)[0] = (dmask4[(font_data >> 6)] & xorcol) ^ bgcol;
473
            ((uint32_t *)d)[1] = (dmask4[(font_data >> 4) & 3] & xorcol) ^ bgcol;
474
            ((uint32_t *)d)[2] = (dmask4[(font_data >> 2) & 3] & xorcol) ^ bgcol;
475
            ((uint32_t *)d)[3] = (dmask4[(font_data >> 0) & 3] & xorcol) ^ bgcol;
476
            d += linesize;
477
        }
478
        break;
479
    case 32:
480
        for(i = 0; i < FONT_HEIGHT; i++) {
481
            font_data = *font_ptr++;
482
            if (t_attrib->uline && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {
483
                font_data = 0xFFFF;
484
            }
485
            ((uint32_t *)d)[0] = (-((font_data >> 7)) & xorcol) ^ bgcol;
486
            ((uint32_t *)d)[1] = (-((font_data >> 6) & 1) & xorcol) ^ bgcol;
487
            ((uint32_t *)d)[2] = (-((font_data >> 5) & 1) & xorcol) ^ bgcol;
488
            ((uint32_t *)d)[3] = (-((font_data >> 4) & 1) & xorcol) ^ bgcol;
489
            ((uint32_t *)d)[4] = (-((font_data >> 3) & 1) & xorcol) ^ bgcol;
490
            ((uint32_t *)d)[5] = (-((font_data >> 2) & 1) & xorcol) ^ bgcol;
491
            ((uint32_t *)d)[6] = (-((font_data >> 1) & 1) & xorcol) ^ bgcol;
492
            ((uint32_t *)d)[7] = (-((font_data >> 0) & 1) & xorcol) ^ bgcol;
493
            d += linesize;
494
        }
495
        break;
496
    }
497
}
498

    
499
static void text_console_resize(TextConsole *s)
500
{
501
    TextCell *cells, *c, *c1;
502
    int w1, x, y, last_width;
503

    
504
    last_width = s->width;
505
    s->width = s->g_width / FONT_WIDTH;
506
    s->height = s->g_height / FONT_HEIGHT;
507

    
508
    w1 = last_width;
509
    if (s->width < w1)
510
        w1 = s->width;
511

    
512
    cells = qemu_malloc(s->width * s->total_height * sizeof(TextCell));
513
    for(y = 0; y < s->total_height; y++) {
514
        c = &cells[y * s->width];
515
        if (w1 > 0) {
516
            c1 = &s->cells[y * last_width];
517
            for(x = 0; x < w1; x++) {
518
                *c++ = *c1++;
519
            }
520
        }
521
        for(x = w1; x < s->width; x++) {
522
            c->ch = ' ';
523
            c->t_attrib = s->t_attrib_default;
524
            c++;
525
        }
526
    }
527
    qemu_free(s->cells);
528
    s->cells = cells;
529
}
530

    
531
static inline void text_update_xy(TextConsole *s, int x, int y)
532
{
533
    s->text_x[0] = MIN(s->text_x[0], x);
534
    s->text_x[1] = MAX(s->text_x[1], x);
535
    s->text_y[0] = MIN(s->text_y[0], y);
536
    s->text_y[1] = MAX(s->text_y[1], y);
537
}
538

    
539
static void update_xy(TextConsole *s, int x, int y)
540
{
541
    TextCell *c;
542
    int y1, y2;
543

    
544
    if (s == active_console) {
545
        if (!s->ds->depth) {
546
            text_update_xy(s, x, y);
547
            return;
548
        }
549

    
550
        y1 = (s->y_base + y) % s->total_height;
551
        y2 = y1 - s->y_displayed;
552
        if (y2 < 0)
553
            y2 += s->total_height;
554
        if (y2 < s->height) {
555
            c = &s->cells[y1 * s->width + x];
556
            vga_putcharxy(s->ds, x, y2, c->ch,
557
                          &(c->t_attrib));
558
            dpy_update(s->ds, x * FONT_WIDTH, y2 * FONT_HEIGHT,
559
                       FONT_WIDTH, FONT_HEIGHT);
560
        }
561
    }
562
}
563

    
564
static void console_show_cursor(TextConsole *s, int show)
565
{
566
    TextCell *c;
567
    int y, y1;
568

    
569
    if (s == active_console) {
570
        int x = s->x;
571

    
572
        if (!s->ds->depth) {
573
            s->cursor_invalidate = 1;
574
            return;
575
        }
576

    
577
        if (x >= s->width) {
578
            x = s->width - 1;
579
        }
580
        y1 = (s->y_base + s->y) % s->total_height;
581
        y = y1 - s->y_displayed;
582
        if (y < 0)
583
            y += s->total_height;
584
        if (y < s->height) {
585
            c = &s->cells[y1 * s->width + x];
586
            if (show) {
587
                TextAttributes t_attrib = s->t_attrib_default;
588
                t_attrib.invers = !(t_attrib.invers); /* invert fg and bg */
589
                vga_putcharxy(s->ds, x, y, c->ch, &t_attrib);
590
            } else {
591
                vga_putcharxy(s->ds, x, y, c->ch, &(c->t_attrib));
592
            }
593
            dpy_update(s->ds, x * FONT_WIDTH, y * FONT_HEIGHT,
594
                       FONT_WIDTH, FONT_HEIGHT);
595
        }
596
    }
597
}
598

    
599
static void console_refresh(TextConsole *s)
600
{
601
    TextCell *c;
602
    int x, y, y1;
603

    
604
    if (s != active_console)
605
        return;
606
    if (!s->ds->depth) {
607
        s->text_x[0] = 0;
608
        s->text_y[0] = 0;
609
        s->text_x[1] = s->width - 1;
610
        s->text_y[1] = s->height - 1;
611
        s->cursor_invalidate = 1;
612
        return;
613
    }
614

    
615
    vga_fill_rect(s->ds, 0, 0, s->ds->width, s->ds->height,
616
                  color_table[0][COLOR_BLACK]);
617
    y1 = s->y_displayed;
618
    for(y = 0; y < s->height; y++) {
619
        c = s->cells + y1 * s->width;
620
        for(x = 0; x < s->width; x++) {
621
            vga_putcharxy(s->ds, x, y, c->ch,
622
                          &(c->t_attrib));
623
            c++;
624
        }
625
        if (++y1 == s->total_height)
626
            y1 = 0;
627
    }
628
    dpy_update(s->ds, 0, 0, s->ds->width, s->ds->height);
629
    console_show_cursor(s, 1);
630
}
631

    
632
static void console_scroll(int ydelta)
633
{
634
    TextConsole *s;
635
    int i, y1;
636

    
637
    s = active_console;
638
    if (!s || (s->console_type == GRAPHIC_CONSOLE))
639
        return;
640

    
641
    if (ydelta > 0) {
642
        for(i = 0; i < ydelta; i++) {
643
            if (s->y_displayed == s->y_base)
644
                break;
645
            if (++s->y_displayed == s->total_height)
646
                s->y_displayed = 0;
647
        }
648
    } else {
649
        ydelta = -ydelta;
650
        i = s->backscroll_height;
651
        if (i > s->total_height - s->height)
652
            i = s->total_height - s->height;
653
        y1 = s->y_base - i;
654
        if (y1 < 0)
655
            y1 += s->total_height;
656
        for(i = 0; i < ydelta; i++) {
657
            if (s->y_displayed == y1)
658
                break;
659
            if (--s->y_displayed < 0)
660
                s->y_displayed = s->total_height - 1;
661
        }
662
    }
663
    console_refresh(s);
664
}
665

    
666
static void console_put_lf(TextConsole *s)
667
{
668
    TextCell *c;
669
    int x, y1;
670

    
671
    s->y++;
672
    if (s->y >= s->height) {
673
        s->y = s->height - 1;
674

    
675
        if (s->y_displayed == s->y_base) {
676
            if (++s->y_displayed == s->total_height)
677
                s->y_displayed = 0;
678
        }
679
        if (++s->y_base == s->total_height)
680
            s->y_base = 0;
681
        if (s->backscroll_height < s->total_height)
682
            s->backscroll_height++;
683
        y1 = (s->y_base + s->height - 1) % s->total_height;
684
        c = &s->cells[y1 * s->width];
685
        for(x = 0; x < s->width; x++) {
686
            c->ch = ' ';
687
            c->t_attrib = s->t_attrib_default;
688
            c++;
689
        }
690
        if (s == active_console && s->y_displayed == s->y_base) {
691
            if (!s->ds->depth) {
692
                s->text_x[0] = 0;
693
                s->text_y[0] = 0;
694
                s->text_x[1] = s->width - 1;
695
                s->text_y[1] = s->height - 1;
696
                return;
697
            }
698

    
699
            vga_bitblt(s->ds, 0, FONT_HEIGHT, 0, 0,
700
                       s->width * FONT_WIDTH,
701
                       (s->height - 1) * FONT_HEIGHT);
702
            vga_fill_rect(s->ds, 0, (s->height - 1) * FONT_HEIGHT,
703
                          s->width * FONT_WIDTH, FONT_HEIGHT,
704
                          color_table[0][s->t_attrib_default.bgcol]);
705
            dpy_update(s->ds, 0, 0,
706
                       s->width * FONT_WIDTH, s->height * FONT_HEIGHT);
707
        }
708
    }
709
}
710

    
711
/* Set console attributes depending on the current escape codes.
712
 * NOTE: I know this code is not very efficient (checking every color for it
713
 * self) but it is more readable and better maintainable.
714
 */
715
static void console_handle_escape(TextConsole *s)
716
{
717
    int i;
718

    
719
    for (i=0; i<s->nb_esc_params; i++) {
720
        switch (s->esc_params[i]) {
721
            case 0: /* reset all console attributes to default */
722
                s->t_attrib = s->t_attrib_default;
723
                break;
724
            case 1:
725
                s->t_attrib.bold = 1;
726
                break;
727
            case 4:
728
                s->t_attrib.uline = 1;
729
                break;
730
            case 5:
731
                s->t_attrib.blink = 1;
732
                break;
733
            case 7:
734
                s->t_attrib.invers = 1;
735
                break;
736
            case 8:
737
                s->t_attrib.unvisible = 1;
738
                break;
739
            case 22:
740
                s->t_attrib.bold = 0;
741
                break;
742
            case 24:
743
                s->t_attrib.uline = 0;
744
                break;
745
            case 25:
746
                s->t_attrib.blink = 0;
747
                break;
748
            case 27:
749
                s->t_attrib.invers = 0;
750
                break;
751
            case 28:
752
                s->t_attrib.unvisible = 0;
753
                break;
754
            /* set foreground color */
755
            case 30:
756
                s->t_attrib.fgcol=COLOR_BLACK;
757
                break;
758
            case 31:
759
                s->t_attrib.fgcol=COLOR_RED;
760
                break;
761
            case 32:
762
                s->t_attrib.fgcol=COLOR_GREEN;
763
                break;
764
            case 33:
765
                s->t_attrib.fgcol=COLOR_YELLOW;
766
                break;
767
            case 34:
768
                s->t_attrib.fgcol=COLOR_BLUE;
769
                break;
770
            case 35:
771
                s->t_attrib.fgcol=COLOR_MAGENTA;
772
                break;
773
            case 36:
774
                s->t_attrib.fgcol=COLOR_CYAN;
775
                break;
776
            case 37:
777
                s->t_attrib.fgcol=COLOR_WHITE;
778
                break;
779
            /* set background color */
780
            case 40:
781
                s->t_attrib.bgcol=COLOR_BLACK;
782
                break;
783
            case 41:
784
                s->t_attrib.bgcol=COLOR_RED;
785
                break;
786
            case 42:
787
                s->t_attrib.bgcol=COLOR_GREEN;
788
                break;
789
            case 43:
790
                s->t_attrib.bgcol=COLOR_YELLOW;
791
                break;
792
            case 44:
793
                s->t_attrib.bgcol=COLOR_BLUE;
794
                break;
795
            case 45:
796
                s->t_attrib.bgcol=COLOR_MAGENTA;
797
                break;
798
            case 46:
799
                s->t_attrib.bgcol=COLOR_CYAN;
800
                break;
801
            case 47:
802
                s->t_attrib.bgcol=COLOR_WHITE;
803
                break;
804
        }
805
    }
806
}
807

    
808
static void console_clear_xy(TextConsole *s, int x, int y)
809
{
810
    int y1 = (s->y_base + y) % s->total_height;
811
    TextCell *c = &s->cells[y1 * s->width + x];
812
    c->ch = ' ';
813
    c->t_attrib = s->t_attrib_default;
814
    c++;
815
    update_xy(s, x, y);
816
}
817

    
818
static void console_putchar(TextConsole *s, int ch)
819
{
820
    TextCell *c;
821
    int y1, i;
822
    int x, y;
823

    
824
    switch(s->state) {
825
    case TTY_STATE_NORM:
826
        switch(ch) {
827
        case '\r':  /* carriage return */
828
            s->x = 0;
829
            break;
830
        case '\n':  /* newline */
831
            console_put_lf(s);
832
            break;
833
        case '\b':  /* backspace */
834
            if (s->x > 0)
835
                s->x--;
836
            break;
837
        case '\t':  /* tabspace */
838
            if (s->x + (8 - (s->x % 8)) > s->width) {
839
                s->x = 0;
840
                console_put_lf(s);
841
            } else {
842
                s->x = s->x + (8 - (s->x % 8));
843
            }
844
            break;
845
        case '\a':  /* alert aka. bell */
846
            /* TODO: has to be implemented */
847
            break;
848
        case 14:
849
            /* SI (shift in), character set 0 (ignored) */
850
            break;
851
        case 15:
852
            /* SO (shift out), character set 1 (ignored) */
853
            break;
854
        case 27:    /* esc (introducing an escape sequence) */
855
            s->state = TTY_STATE_ESC;
856
            break;
857
        default:
858
            if (s->x >= s->width) {
859
                /* line wrap */
860
                s->x = 0;
861
                console_put_lf(s);
862
            }
863
            y1 = (s->y_base + s->y) % s->total_height;
864
            c = &s->cells[y1 * s->width + s->x];
865
            c->ch = ch;
866
            c->t_attrib = s->t_attrib;
867
            update_xy(s, s->x, s->y);
868
            s->x++;
869
            break;
870
        }
871
        break;
872
    case TTY_STATE_ESC: /* check if it is a terminal escape sequence */
873
        if (ch == '[') {
874
            for(i=0;i<MAX_ESC_PARAMS;i++)
875
                s->esc_params[i] = 0;
876
            s->nb_esc_params = 0;
877
            s->state = TTY_STATE_CSI;
878
        } else {
879
            s->state = TTY_STATE_NORM;
880
        }
881
        break;
882
    case TTY_STATE_CSI: /* handle escape sequence parameters */
883
        if (ch >= '0' && ch <= '9') {
884
            if (s->nb_esc_params < MAX_ESC_PARAMS) {
885
                s->esc_params[s->nb_esc_params] =
886
                    s->esc_params[s->nb_esc_params] * 10 + ch - '0';
887
            }
888
        } else {
889
            s->nb_esc_params++;
890
            if (ch == ';')
891
                break;
892
#ifdef DEBUG_CONSOLE
893
            fprintf(stderr, "escape sequence CSI%d;%d%c, %d parameters\n",
894
                    s->esc_params[0], s->esc_params[1], ch, s->nb_esc_params);
895
#endif
896
            s->state = TTY_STATE_NORM;
897
            switch(ch) {
898
            case 'A':
899
                /* move cursor up */
900
                if (s->esc_params[0] == 0) {
901
                    s->esc_params[0] = 1;
902
                }
903
                s->y -= s->esc_params[0];
904
                if (s->y < 0) {
905
                    s->y = 0;
906
                }
907
                break;
908
            case 'B':
909
                /* move cursor down */
910
                if (s->esc_params[0] == 0) {
911
                    s->esc_params[0] = 1;
912
                }
913
                s->y += s->esc_params[0];
914
                if (s->y >= s->height) {
915
                    s->y = s->height - 1;
916
                }
917
                break;
918
            case 'C':
919
                /* move cursor right */
920
                if (s->esc_params[0] == 0) {
921
                    s->esc_params[0] = 1;
922
                }
923
                s->x += s->esc_params[0];
924
                if (s->x >= s->width) {
925
                    s->x = s->width - 1;
926
                }
927
                break;
928
            case 'D':
929
                /* move cursor left */
930
                if (s->esc_params[0] == 0) {
931
                    s->esc_params[0] = 1;
932
                }
933
                s->x -= s->esc_params[0];
934
                if (s->x < 0) {
935
                    s->x = 0;
936
                }
937
                break;
938
            case 'G':
939
                /* move cursor to column */
940
                s->x = s->esc_params[0] - 1;
941
                if (s->x < 0) {
942
                    s->x = 0;
943
                }
944
                break;
945
            case 'f':
946
            case 'H':
947
                /* move cursor to row, column */
948
                s->x = s->esc_params[1] - 1;
949
                if (s->x < 0) {
950
                    s->x = 0;
951
                }
952
                s->y = s->esc_params[0] - 1;
953
                if (s->y < 0) {
954
                    s->y = 0;
955
                }
956
                break;
957
            case 'J':
958
                switch (s->esc_params[0]) {
959
                case 0:
960
                    /* clear to end of screen */
961
                    for (y = s->y; y < s->height; y++) {
962
                        for (x = 0; x < s->width; x++) {
963
                            if (y == s->y && x < s->x) {
964
                                continue;
965
                            }
966
                            console_clear_xy(s, x, y);
967
                        }
968
                    }
969
                    break;
970
                case 1:
971
                    /* clear from beginning of screen */
972
                    for (y = 0; y <= s->y; y++) {
973
                        for (x = 0; x < s->width; x++) {
974
                            if (y == s->y && x > s->x) {
975
                                break;
976
                            }
977
                            console_clear_xy(s, x, y);
978
                        }
979
                    }
980
                    break;
981
                case 2:
982
                    /* clear entire screen */
983
                    for (y = 0; y <= s->height; y++) {
984
                        for (x = 0; x < s->width; x++) {
985
                            console_clear_xy(s, x, y);
986
                        }
987
                    }
988
                break;
989
                }
990
            case 'K':
991
                switch (s->esc_params[0]) {
992
                case 0:
993
                /* clear to eol */
994
                for(x = s->x; x < s->width; x++) {
995
                        console_clear_xy(s, x, s->y);
996
                }
997
                break;
998
                case 1:
999
                    /* clear from beginning of line */
1000
                    for (x = 0; x <= s->x; x++) {
1001
                        console_clear_xy(s, x, s->y);
1002
                    }
1003
                    break;
1004
                case 2:
1005
                    /* clear entire line */
1006
                    for(x = 0; x < s->width; x++) {
1007
                        console_clear_xy(s, x, s->y);
1008
                    }
1009
                break;
1010
            }
1011
                break;
1012
            case 'm':
1013
            console_handle_escape(s);
1014
            break;
1015
            case 'n':
1016
                /* report cursor position */
1017
                /* TODO: send ESC[row;colR */
1018
                break;
1019
            case 's':
1020
                /* save cursor position */
1021
                s->x_saved = s->x;
1022
                s->y_saved = s->y;
1023
                break;
1024
            case 'u':
1025
                /* restore cursor position */
1026
                s->x = s->x_saved;
1027
                s->y = s->y_saved;
1028
                break;
1029
            default:
1030
#ifdef DEBUG_CONSOLE
1031
                fprintf(stderr, "unhandled escape character '%c'\n", ch);
1032
#endif
1033
                break;
1034
            }
1035
            break;
1036
        }
1037
    }
1038
}
1039

    
1040
void console_select(unsigned int index)
1041
{
1042
    TextConsole *s;
1043

    
1044
    if (index >= MAX_CONSOLES)
1045
        return;
1046
    s = consoles[index];
1047
    if (s) {
1048
        active_console = s;
1049
        if (s->g_width && s->g_height
1050
            && (s->g_width != s->ds->width || s->g_height != s->ds->height))
1051
            dpy_resize(s->ds, s->g_width, s->g_height);
1052
        vga_hw_invalidate();
1053
    }
1054
}
1055

    
1056
static int console_puts(CharDriverState *chr, const uint8_t *buf, int len)
1057
{
1058
    TextConsole *s = chr->opaque;
1059
    int i;
1060

    
1061
    console_show_cursor(s, 0);
1062
    for(i = 0; i < len; i++) {
1063
        console_putchar(s, buf[i]);
1064
    }
1065
    console_show_cursor(s, 1);
1066
    return len;
1067
}
1068

    
1069
static void console_send_event(CharDriverState *chr, int event)
1070
{
1071
    TextConsole *s = chr->opaque;
1072
    int i;
1073

    
1074
    if (event == CHR_EVENT_FOCUS) {
1075
        for(i = 0; i < nb_consoles; i++) {
1076
            if (consoles[i] == s) {
1077
                console_select(i);
1078
                break;
1079
            }
1080
        }
1081
    }
1082
}
1083

    
1084
static void kbd_send_chars(void *opaque)
1085
{
1086
    TextConsole *s = opaque;
1087
    int len;
1088
    uint8_t buf[16];
1089

    
1090
    len = qemu_chr_can_read(s->chr);
1091
    if (len > s->out_fifo.count)
1092
        len = s->out_fifo.count;
1093
    if (len > 0) {
1094
        if (len > sizeof(buf))
1095
            len = sizeof(buf);
1096
        qemu_fifo_read(&s->out_fifo, buf, len);
1097
        qemu_chr_read(s->chr, buf, len);
1098
    }
1099
    /* characters are pending: we send them a bit later (XXX:
1100
       horrible, should change char device API) */
1101
    if (s->out_fifo.count > 0) {
1102
        qemu_mod_timer(s->kbd_timer, qemu_get_clock(rt_clock) + 1);
1103
    }
1104
}
1105

    
1106
/* called when an ascii key is pressed */
1107
void kbd_put_keysym(int keysym)
1108
{
1109
    TextConsole *s;
1110
    uint8_t buf[16], *q;
1111
    int c;
1112

    
1113
    s = active_console;
1114
    if (!s || (s->console_type == GRAPHIC_CONSOLE))
1115
        return;
1116

    
1117
    switch(keysym) {
1118
    case QEMU_KEY_CTRL_UP:
1119
        console_scroll(-1);
1120
        break;
1121
    case QEMU_KEY_CTRL_DOWN:
1122
        console_scroll(1);
1123
        break;
1124
    case QEMU_KEY_CTRL_PAGEUP:
1125
        console_scroll(-10);
1126
        break;
1127
    case QEMU_KEY_CTRL_PAGEDOWN:
1128
        console_scroll(10);
1129
        break;
1130
    default:
1131
        /* convert the QEMU keysym to VT100 key string */
1132
        q = buf;
1133
        if (keysym >= 0xe100 && keysym <= 0xe11f) {
1134
            *q++ = '\033';
1135
            *q++ = '[';
1136
            c = keysym - 0xe100;
1137
            if (c >= 10)
1138
                *q++ = '0' + (c / 10);
1139
            *q++ = '0' + (c % 10);
1140
            *q++ = '~';
1141
        } else if (keysym >= 0xe120 && keysym <= 0xe17f) {
1142
            *q++ = '\033';
1143
            *q++ = '[';
1144
            *q++ = keysym & 0xff;
1145
        } else {
1146
                *q++ = keysym;
1147
        }
1148
        if (s->chr->chr_read) {
1149
            qemu_fifo_write(&s->out_fifo, buf, q - buf);
1150
            kbd_send_chars(s);
1151
        }
1152
        break;
1153
    }
1154
}
1155

    
1156
static void text_console_invalidate(void *opaque)
1157
{
1158
    TextConsole *s = (TextConsole *) opaque;
1159

    
1160
    console_refresh(s);
1161
}
1162

    
1163
static void text_console_update(void *opaque, console_ch_t *chardata)
1164
{
1165
    TextConsole *s = (TextConsole *) opaque;
1166
    int i, j, src;
1167

    
1168
    if (s->text_x[0] <= s->text_x[1]) {
1169
        src = (s->y_base + s->text_y[0]) * s->width;
1170
        chardata += s->text_y[0] * s->width;
1171
        for (i = s->text_y[0]; i <= s->text_y[1]; i ++)
1172
            for (j = 0; j < s->width; j ++, src ++)
1173
                console_write_ch(chardata ++, s->cells[src].ch |
1174
                                (s->cells[src].t_attrib.fgcol << 12) |
1175
                                (s->cells[src].t_attrib.bgcol << 8) |
1176
                                (s->cells[src].t_attrib.bold << 21));
1177
        dpy_update(s->ds, s->text_x[0], s->text_y[0],
1178
                   s->text_x[1] - s->text_x[0], i - s->text_y[0]);
1179
        s->text_x[0] = s->width;
1180
        s->text_y[0] = s->height;
1181
        s->text_x[1] = 0;
1182
        s->text_y[1] = 0;
1183
    }
1184
    if (s->cursor_invalidate) {
1185
        dpy_cursor(s->ds, s->x, s->y);
1186
        s->cursor_invalidate = 0;
1187
    }
1188
}
1189

    
1190
static TextConsole *new_console(DisplayState *ds, console_type_t console_type)
1191
{
1192
    TextConsole *s;
1193
    int i;
1194

    
1195
    if (nb_consoles >= MAX_CONSOLES)
1196
        return NULL;
1197
    s = qemu_mallocz(sizeof(TextConsole));
1198
    if (!s) {
1199
        return NULL;
1200
    }
1201
    if (!active_console || ((active_console->console_type != GRAPHIC_CONSOLE) &&
1202
        (console_type == GRAPHIC_CONSOLE))) {
1203
        active_console = s;
1204
    }
1205
    s->ds = ds;
1206
    s->console_type = console_type;
1207
    if (console_type != GRAPHIC_CONSOLE) {
1208
        consoles[nb_consoles++] = s;
1209
    } else {
1210
        /* HACK: Put graphical consoles before text consoles.  */
1211
        for (i = nb_consoles; i > 0; i--) {
1212
            if (consoles[i - 1]->console_type == GRAPHIC_CONSOLE)
1213
                break;
1214
            consoles[i] = consoles[i - 1];
1215
        }
1216
        consoles[i] = s;
1217
    }
1218
    return s;
1219
}
1220

    
1221
TextConsole *graphic_console_init(DisplayState *ds, vga_hw_update_ptr update,
1222
                                  vga_hw_invalidate_ptr invalidate,
1223
                                  vga_hw_screen_dump_ptr screen_dump,
1224
                                  vga_hw_text_update_ptr text_update,
1225
                                  void *opaque)
1226
{
1227
    TextConsole *s;
1228

    
1229
    s = new_console(ds, GRAPHIC_CONSOLE);
1230
    if (!s)
1231
      return NULL;
1232
    s->hw_update = update;
1233
    s->hw_invalidate = invalidate;
1234
    s->hw_screen_dump = screen_dump;
1235
    s->hw_text_update = text_update;
1236
    s->hw = opaque;
1237
    return s;
1238
}
1239

    
1240
int is_graphic_console(void)
1241
{
1242
    return active_console && active_console->console_type == GRAPHIC_CONSOLE;
1243
}
1244

    
1245
void console_color_init(DisplayState *ds)
1246
{
1247
    int i, j;
1248
    for (j = 0; j < 2; j++) {
1249
        for (i = 0; i < 8; i++) {
1250
            color_table[j][i] = col_expand(ds, 
1251
                   vga_get_color(ds, color_table_rgb[j][i]));
1252
        }
1253
    }
1254
}
1255

    
1256
CharDriverState *text_console_init(DisplayState *ds, const char *p)
1257
{
1258
    CharDriverState *chr;
1259
    TextConsole *s;
1260
    unsigned width;
1261
    unsigned height;
1262
    static int color_inited;
1263

    
1264
    chr = qemu_mallocz(sizeof(CharDriverState));
1265
    if (!chr)
1266
        return NULL;
1267
    s = new_console(ds, TEXT_CONSOLE);
1268
    if (!s) {
1269
        free(chr);
1270
        return NULL;
1271
    }
1272
    if (!p)
1273
        p = DEFAULT_MONITOR_SIZE;
1274

    
1275
    chr->opaque = s;
1276
    chr->chr_write = console_puts;
1277
    chr->chr_send_event = console_send_event;
1278

    
1279
    s->chr = chr;
1280
    s->out_fifo.buf = s->out_fifo_buf;
1281
    s->out_fifo.buf_size = sizeof(s->out_fifo_buf);
1282
    s->kbd_timer = qemu_new_timer(rt_clock, kbd_send_chars, s);
1283

    
1284
    if (!color_inited) {
1285
        color_inited = 1;
1286
        console_color_init(s->ds);
1287
    }
1288
    s->y_displayed = 0;
1289
    s->y_base = 0;
1290
    s->total_height = DEFAULT_BACKSCROLL;
1291
    s->x = 0;
1292
    s->y = 0;
1293
    width = s->ds->width;
1294
    height = s->ds->height;
1295
    if (p != 0) {
1296
        width = strtoul(p, (char **)&p, 10);
1297
        if (*p == 'C') {
1298
            p++;
1299
            width *= FONT_WIDTH;
1300
        }
1301
        if (*p == 'x') {
1302
            p++;
1303
            height = strtoul(p, (char **)&p, 10);
1304
            if (*p == 'C') {
1305
                p++;
1306
                height *= FONT_HEIGHT;
1307
            }
1308
        }
1309
    }
1310
    s->g_width = width;
1311
    s->g_height = height;
1312

    
1313
    s->hw_invalidate = text_console_invalidate;
1314
    s->hw_text_update = text_console_update;
1315
    s->hw = s;
1316

    
1317
    /* Set text attribute defaults */
1318
    s->t_attrib_default.bold = 0;
1319
    s->t_attrib_default.uline = 0;
1320
    s->t_attrib_default.blink = 0;
1321
    s->t_attrib_default.invers = 0;
1322
    s->t_attrib_default.unvisible = 0;
1323
    s->t_attrib_default.fgcol = COLOR_WHITE;
1324
    s->t_attrib_default.bgcol = COLOR_BLACK;
1325

    
1326
    /* set current text attributes to default */
1327
    s->t_attrib = s->t_attrib_default;
1328
    text_console_resize(s);
1329

    
1330
    qemu_chr_reset(chr);
1331

    
1332
    return chr;
1333
}
1334

    
1335
void qemu_console_resize(QEMUConsole *console, int width, int height)
1336
{
1337
    if (console->g_width != width || console->g_height != height
1338
        || !console->ds->data) {
1339
        console->g_width = width;
1340
        console->g_height = height;
1341
        if (active_console == console) {
1342
            dpy_resize(console->ds, width, height);
1343
        }
1344
    }
1345
}