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