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