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