?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Special Mask Mode for i8259 PIC (Sebastian Reichelt).
[qemu/mini2440/sniper_sniper_test.git] / console.c
bloba1bc769c82ca9e1eeb5698c0b71840cfab3738e6
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 /* 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 if (s->g_width && s->g_height
1045 && (s->g_width != s->ds->width || s->g_height != s->ds->height))
1046 dpy_resize(s->ds, s->g_width, s->g_height);
1047 vga_hw_invalidate();
1048 }
1049 }
1050
1051 static int console_puts(CharDriverState *chr, const uint8_t *buf, int len)
1052 {
1053 TextConsole *s = chr->opaque;
1054 int i;
1055
1056 console_show_cursor(s, 0);
1057 for(i = 0; i < len; i++) {
1058 console_putchar(s, buf[i]);
1059 }
1060 console_show_cursor(s, 1);
1061 return len;
1062 }
1063
1064 static void console_send_event(CharDriverState *chr, int event)
1065 {
1066 TextConsole *s = chr->opaque;
1067 int i;
1068
1069 if (event == CHR_EVENT_FOCUS) {
1070 for(i = 0; i < nb_consoles; i++) {
1071 if (consoles[i] == s) {
1072 console_select(i);
1073 break;
1074 }
1075 }
1076 }
1077 }
1078
1079 static void kbd_send_chars(void *opaque)
1080 {
1081 TextConsole *s = opaque;
1082 int len;
1083 uint8_t buf[16];
1084
1085 len = qemu_chr_can_read(s->chr);
1086 if (len > s->out_fifo.count)
1087 len = s->out_fifo.count;
1088 if (len > 0) {
1089 if (len > sizeof(buf))
1090 len = sizeof(buf);
1091 qemu_fifo_read(&s->out_fifo, buf, len);
1092 qemu_chr_read(s->chr, buf, len);
1093 }
1094 /* characters are pending: we send them a bit later (XXX:
1095 horrible, should change char device API) */
1096 if (s->out_fifo.count > 0) {
1097 qemu_mod_timer(s->kbd_timer, qemu_get_clock(rt_clock) + 1);
1098 }
1099 }
1100
1101 /* called when an ascii key is pressed */
1102 void kbd_put_keysym(int keysym)
1103 {
1104 TextConsole *s;
1105 uint8_t buf[16], *q;
1106 int c;
1107
1108 s = active_console;
1109 if (!s || (s->console_type == GRAPHIC_CONSOLE))
1110 return;
1111
1112 switch(keysym) {
1113 case QEMU_KEY_CTRL_UP:
1114 console_scroll(-1);
1115 break;
1116 case QEMU_KEY_CTRL_DOWN:
1117 console_scroll(1);
1118 break;
1119 case QEMU_KEY_CTRL_PAGEUP:
1120 console_scroll(-10);
1121 break;
1122 case QEMU_KEY_CTRL_PAGEDOWN:
1123 console_scroll(10);
1124 break;
1125 default:
1126 /* convert the QEMU keysym to VT100 key string */
1127 q = buf;
1128 if (keysym >= 0xe100 && keysym <= 0xe11f) {
1129 *q++ = '\033';
1130 *q++ = '[';
1131 c = keysym - 0xe100;
1132 if (c >= 10)
1133 *q++ = '0' + (c / 10);
1134 *q++ = '0' + (c % 10);
1135 *q++ = '~';
1136 } else if (keysym >= 0xe120 && keysym <= 0xe17f) {
1137 *q++ = '\033';
1138 *q++ = '[';
1139 *q++ = keysym & 0xff;
1140 } else {
1141 *q++ = keysym;
1142 }
1143 if (s->chr->chr_read) {
1144 qemu_fifo_write(&s->out_fifo, buf, q - buf);
1145 kbd_send_chars(s);
1146 }
1147 break;
1148 }
1149 }
1150
1151 static void text_console_invalidate(void *opaque)
1152 {
1153 TextConsole *s = (TextConsole *) opaque;
1154
1155 console_refresh(s);
1156 }
1157
1158 static void text_console_update(void *opaque, console_ch_t *chardata)
1159 {
1160 TextConsole *s = (TextConsole *) opaque;
1161 int i, j, src;
1162
1163 if (s->text_x[0] <= s->text_x[1]) {
1164 src = (s->y_base + s->text_y[0]) * s->width;
1165 chardata += s->text_y[0] * s->width;
1166 for (i = s->text_y[0]; i <= s->text_y[1]; i ++)
1167 for (j = 0; j < s->width; j ++, src ++)
1168 console_write_ch(chardata ++, s->cells[src].ch |
1169 (s->cells[src].t_attrib.fgcol << 12) |
1170 (s->cells[src].t_attrib.bgcol << 8) |
1171 (s->cells[src].t_attrib.bold << 21));
1172 dpy_update(s->ds, s->text_x[0], s->text_y[0],
1173 s->text_x[1] - s->text_x[0], i - s->text_y[0]);
1174 s->text_x[0] = s->width;
1175 s->text_y[0] = s->height;
1176 s->text_x[1] = 0;
1177 s->text_y[1] = 0;
1178 }
1179 if (s->cursor_invalidate) {
1180 dpy_cursor(s->ds, s->x, s->y);
1181 s->cursor_invalidate = 0;
1182 }
1183 }
1184
1185 static TextConsole *new_console(DisplayState *ds, console_type_t console_type)
1186 {
1187 TextConsole *s;
1188 int i;
1189
1190 if (nb_consoles >= MAX_CONSOLES)
1191 return NULL;
1192 s = qemu_mallocz(sizeof(TextConsole));
1193 if (!s) {
1194 return NULL;
1195 }
1196 if (!active_console || ((active_console->console_type != GRAPHIC_CONSOLE) &&
1197 (console_type == GRAPHIC_CONSOLE))) {
1198 active_console = s;
1199 }
1200 s->ds = ds;
1201 s->console_type = console_type;
1202 if (console_type != GRAPHIC_CONSOLE) {
1203 consoles[nb_consoles++] = s;
1204 } else {
1205 /* HACK: Put graphical consoles before text consoles. */
1206 for (i = nb_consoles; i > 0; i--) {
1207 if (consoles[i - 1]->console_type == GRAPHIC_CONSOLE)
1208 break;
1209 consoles[i] = consoles[i - 1];
1210 }
1211 consoles[i] = s;
1212 }
1213 return s;
1214 }
1215
1216 TextConsole *graphic_console_init(DisplayState *ds, vga_hw_update_ptr update,
1217 vga_hw_invalidate_ptr invalidate,
1218 vga_hw_screen_dump_ptr screen_dump,
1219 vga_hw_text_update_ptr text_update,
1220 void *opaque)
1221 {
1222 TextConsole *s;
1223
1224 s = new_console(ds, GRAPHIC_CONSOLE);
1225 if (!s)
1226 return NULL;
1227 s->hw_update = update;
1228 s->hw_invalidate = invalidate;
1229 s->hw_screen_dump = screen_dump;
1230 s->hw_text_update = text_update;
1231 s->hw = opaque;
1232 return s;
1233 }
1234
1235 int is_graphic_console(void)
1236 {
1237 return active_console && active_console->console_type == GRAPHIC_CONSOLE;
1238 }
1239
1240 void console_color_init(DisplayState *ds)
1241 {
1242 int i, j;
1243 for (j = 0; j < 2; j++) {
1244 for (i = 0; i < 8; i++) {
1245 color_table[j][i] = col_expand(ds,
1246 vga_get_color(ds, color_table_rgb[j][i]));
1247 }
1248 }
1249 }
1250
1251 CharDriverState *text_console_init(DisplayState *ds, const char *p)
1252 {
1253 CharDriverState *chr;
1254 TextConsole *s;
1255 unsigned width;
1256 unsigned height;
1257 static int color_inited;
1258
1259 chr = qemu_mallocz(sizeof(CharDriverState));
1260 if (!chr)
1261 return NULL;
1262 s = new_console(ds, TEXT_CONSOLE);
1263 if (!s) {
1264 free(chr);
1265 return NULL;
1266 }
1267 if (!p)
1268 p = DEFAULT_MONITOR_SIZE;
1269
1270 chr->opaque = s;
1271 chr->chr_write = console_puts;
1272 chr->chr_send_event = console_send_event;
1273
1274 s->chr = chr;
1275 s->out_fifo.buf = s->out_fifo_buf;
1276 s->out_fifo.buf_size = sizeof(s->out_fifo_buf);
1277 s->kbd_timer = qemu_new_timer(rt_clock, kbd_send_chars, s);
1278
1279 if (!color_inited) {
1280 color_inited = 1;
1281 console_color_init(s->ds);
1282 }
1283 s->y_displayed = 0;
1284 s->y_base = 0;
1285 s->total_height = DEFAULT_BACKSCROLL;
1286 s->x = 0;
1287 s->y = 0;
1288 width = s->ds->width;
1289 height = s->ds->height;
1290 if (p != 0) {
1291 width = strtoul(p, (char **)&p, 10);
1292 if (*p == 'C') {
1293 p++;
1294 width *= FONT_WIDTH;
1295 }
1296 if (*p == 'x') {
1297 p++;
1298 height = strtoul(p, (char **)&p, 10);
1299 if (*p == 'C') {
1300 p++;
1301 height *= FONT_HEIGHT;
1302 }
1303 }
1304 }
1305 s->g_width = width;
1306 s->g_height = height;
1307
1308 s->hw_invalidate = text_console_invalidate;
1309 s->hw_text_update = text_console_update;
1310 s->hw = s;
1311
1312 /* Set text attribute defaults */
1313 s->t_attrib_default.bold = 0;
1314 s->t_attrib_default.uline = 0;
1315 s->t_attrib_default.blink = 0;
1316 s->t_attrib_default.invers = 0;
1317 s->t_attrib_default.unvisible = 0;
1318 s->t_attrib_default.fgcol = COLOR_WHITE;
1319 s->t_attrib_default.bgcol = COLOR_BLACK;
1320
1321 /* set current text attributes to default */
1322 s->t_attrib = s->t_attrib_default;
1323 text_console_resize(s);
1324
1325 qemu_chr_reset(chr);
1326
1327 return chr;
1328 }
1329
1330 void qemu_console_resize(QEMUConsole *console, int width, int height)
1331 {
1332 if (console->g_width != width || console->g_height != height) {
1333 console->g_width = width;
1334 console->g_height = height;
1335 if (active_console == console) {
1336 dpy_resize(console->ds, width, height);
1337 }
1338 }
1339 }