?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
linux-user/syscall.c: Don't skip stracing for fcntl64 failure case
[qemu.git] / console.c
blob223f8fd9a4563606c348c79c44887914a952e2c9
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 = 0xFF;
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 = 0xFF;
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 = 0xFF;
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 break;
1015 case 'K':
1016 switch (s->esc_params[0]) {
1017 case 0:
1018 /* clear to eol */
1019 for(x = s->x; x < s->width; x++) {
1020 console_clear_xy(s, x, s->y);
1021 }
1022 break;
1023 case 1:
1024 /* clear from beginning of line */
1025 for (x = 0; x <= s->x; x++) {
1026 console_clear_xy(s, x, s->y);
1027 }
1028 break;
1029 case 2:
1030 /* clear entire line */
1031 for(x = 0; x < s->width; x++) {
1032 console_clear_xy(s, x, s->y);
1033 }
1034 break;
1035 }
1036 break;
1037 case 'm':
1038 console_handle_escape(s);
1039 break;
1040 case 'n':
1041 /* report cursor position */
1042 /* TODO: send ESC[row;colR */
1043 break;
1044 case 's':
1045 /* save cursor position */
1046 s->x_saved = s->x;
1047 s->y_saved = s->y;
1048 break;
1049 case 'u':
1050 /* restore cursor position */
1051 s->x = s->x_saved;
1052 s->y = s->y_saved;
1053 break;
1054 default:
1055 #ifdef DEBUG_CONSOLE
1056 fprintf(stderr, "unhandled escape character '%c'\n", ch);
1057 #endif
1058 break;
1059 }
1060 break;
1061 }
1062 }
1063 }
1064
1065 void console_select(unsigned int index)
1066 {
1067 TextConsole *s;
1068
1069 if (index >= MAX_CONSOLES)
1070 return;
1071 if (active_console) {
1072 active_console->g_width = ds_get_width(active_console->ds);
1073 active_console->g_height = ds_get_height(active_console->ds);
1074 }
1075 s = consoles[index];
1076 if (s) {
1077 DisplayState *ds = s->ds;
1078 active_console = s;
1079 if (ds_get_bits_per_pixel(s->ds)) {
1080 ds->surface = qemu_resize_displaysurface(ds, s->g_width, s->g_height);
1081 } else {
1082 s->ds->surface->width = s->width;
1083 s->ds->surface->height = s->height;
1084 }
1085 dpy_resize(s->ds);
1086 vga_hw_invalidate();
1087 }
1088 }
1089
1090 static int console_puts(CharDriverState *chr, const uint8_t *buf, int len)
1091 {
1092 TextConsole *s = chr->opaque;
1093 int i;
1094
1095 s->update_x0 = s->width * FONT_WIDTH;
1096 s->update_y0 = s->height * FONT_HEIGHT;
1097 s->update_x1 = 0;
1098 s->update_y1 = 0;
1099 console_show_cursor(s, 0);
1100 for(i = 0; i < len; i++) {
1101 console_putchar(s, buf[i]);
1102 }
1103 console_show_cursor(s, 1);
1104 if (ds_get_bits_per_pixel(s->ds) && s->update_x0 < s->update_x1) {
1105 dpy_update(s->ds, s->update_x0, s->update_y0,
1106 s->update_x1 - s->update_x0,
1107 s->update_y1 - s->update_y0);
1108 }
1109 return len;
1110 }
1111
1112 static void kbd_send_chars(void *opaque)
1113 {
1114 TextConsole *s = opaque;
1115 int len;
1116 uint8_t buf[16];
1117
1118 len = qemu_chr_be_can_write(s->chr);
1119 if (len > s->out_fifo.count)
1120 len = s->out_fifo.count;
1121 if (len > 0) {
1122 if (len > sizeof(buf))
1123 len = sizeof(buf);
1124 qemu_fifo_read(&s->out_fifo, buf, len);
1125 qemu_chr_be_write(s->chr, buf, len);
1126 }
1127 /* characters are pending: we send them a bit later (XXX:
1128 horrible, should change char device API) */
1129 if (s->out_fifo.count > 0) {
1130 qemu_mod_timer(s->kbd_timer, qemu_get_clock_ms(rt_clock) + 1);
1131 }
1132 }
1133
1134 /* called when an ascii key is pressed */
1135 void kbd_put_keysym(int keysym)
1136 {
1137 TextConsole *s;
1138 uint8_t buf[16], *q;
1139 int c;
1140
1141 s = active_console;
1142 if (!s || (s->console_type == GRAPHIC_CONSOLE))
1143 return;
1144
1145 switch(keysym) {
1146 case QEMU_KEY_CTRL_UP:
1147 console_scroll(-1);
1148 break;
1149 case QEMU_KEY_CTRL_DOWN:
1150 console_scroll(1);
1151 break;
1152 case QEMU_KEY_CTRL_PAGEUP:
1153 console_scroll(-10);
1154 break;
1155 case QEMU_KEY_CTRL_PAGEDOWN:
1156 console_scroll(10);
1157 break;
1158 default:
1159 /* convert the QEMU keysym to VT100 key string */
1160 q = buf;
1161 if (keysym >= 0xe100 && keysym <= 0xe11f) {
1162 *q++ = '\033';
1163 *q++ = '[';
1164 c = keysym - 0xe100;
1165 if (c >= 10)
1166 *q++ = '0' + (c / 10);
1167 *q++ = '0' + (c % 10);
1168 *q++ = '~';
1169 } else if (keysym >= 0xe120 && keysym <= 0xe17f) {
1170 *q++ = '\033';
1171 *q++ = '[';
1172 *q++ = keysym & 0xff;
1173 } else if (s->echo && (keysym == '\r' || keysym == '\n')) {
1174 console_puts(s->chr, (const uint8_t *) "\r", 1);
1175 *q++ = '\n';
1176 } else {
1177 *q++ = keysym;
1178 }
1179 if (s->echo) {
1180 console_puts(s->chr, buf, q - buf);
1181 }
1182 if (s->chr->chr_read) {
1183 qemu_fifo_write(&s->out_fifo, buf, q - buf);
1184 kbd_send_chars(s);
1185 }
1186 break;
1187 }
1188 }
1189
1190 static void text_console_invalidate(void *opaque)
1191 {
1192 TextConsole *s = (TextConsole *) opaque;
1193 if (!ds_get_bits_per_pixel(s->ds) && s->console_type == TEXT_CONSOLE) {
1194 s->g_width = ds_get_width(s->ds);
1195 s->g_height = ds_get_height(s->ds);
1196 text_console_resize(s);
1197 }
1198 console_refresh(s);
1199 }
1200
1201 static void text_console_update(void *opaque, console_ch_t *chardata)
1202 {
1203 TextConsole *s = (TextConsole *) opaque;
1204 int i, j, src;
1205
1206 if (s->text_x[0] <= s->text_x[1]) {
1207 src = (s->y_base + s->text_y[0]) * s->width;
1208 chardata += s->text_y[0] * s->width;
1209 for (i = s->text_y[0]; i <= s->text_y[1]; i ++)
1210 for (j = 0; j < s->width; j ++, src ++)
1211 console_write_ch(chardata ++, s->cells[src].ch |
1212 (s->cells[src].t_attrib.fgcol << 12) |
1213 (s->cells[src].t_attrib.bgcol << 8) |
1214 (s->cells[src].t_attrib.bold << 21));
1215 dpy_update(s->ds, s->text_x[0], s->text_y[0],
1216 s->text_x[1] - s->text_x[0], i - s->text_y[0]);
1217 s->text_x[0] = s->width;
1218 s->text_y[0] = s->height;
1219 s->text_x[1] = 0;
1220 s->text_y[1] = 0;
1221 }
1222 if (s->cursor_invalidate) {
1223 dpy_cursor(s->ds, s->x, s->y);
1224 s->cursor_invalidate = 0;
1225 }
1226 }
1227
1228 static TextConsole *get_graphic_console(DisplayState *ds)
1229 {
1230 int i;
1231 TextConsole *s;
1232 for (i = 0; i < nb_consoles; i++) {
1233 s = consoles[i];
1234 if (s->console_type == GRAPHIC_CONSOLE && s->ds == ds)
1235 return s;
1236 }
1237 return NULL;
1238 }
1239
1240 static TextConsole *new_console(DisplayState *ds, console_type_t console_type)
1241 {
1242 TextConsole *s;
1243 int i;
1244
1245 if (nb_consoles >= MAX_CONSOLES)
1246 return NULL;
1247 s = g_malloc0(sizeof(TextConsole));
1248 if (!active_console || ((active_console->console_type != GRAPHIC_CONSOLE) &&
1249 (console_type == GRAPHIC_CONSOLE))) {
1250 active_console = s;
1251 }
1252 s->ds = ds;
1253 s->console_type = console_type;
1254 if (console_type != GRAPHIC_CONSOLE) {
1255 s->index = nb_consoles;
1256 consoles[nb_consoles++] = s;
1257 } else {
1258 /* HACK: Put graphical consoles before text consoles. */
1259 for (i = nb_consoles; i > 0; i--) {
1260 if (consoles[i - 1]->console_type == GRAPHIC_CONSOLE)
1261 break;
1262 consoles[i] = consoles[i - 1];
1263 consoles[i]->index = i;
1264 }
1265 s->index = i;
1266 consoles[i] = s;
1267 nb_consoles++;
1268 }
1269 return s;
1270 }
1271
1272 static DisplaySurface* defaultallocator_create_displaysurface(int width, int height)
1273 {
1274 DisplaySurface *surface = (DisplaySurface*) g_malloc0(sizeof(DisplaySurface));
1275
1276 int linesize = width * 4;
1277 qemu_alloc_display(surface, width, height, linesize,
1278 qemu_default_pixelformat(32), 0);
1279 return surface;
1280 }
1281
1282 static DisplaySurface* defaultallocator_resize_displaysurface(DisplaySurface *surface,
1283 int width, int height)
1284 {
1285 int linesize = width * 4;
1286 qemu_alloc_display(surface, width, height, linesize,
1287 qemu_default_pixelformat(32), 0);
1288 return surface;
1289 }
1290
1291 void qemu_alloc_display(DisplaySurface *surface, int width, int height,
1292 int linesize, PixelFormat pf, int newflags)
1293 {
1294 void *data;
1295 surface->width = width;
1296 surface->height = height;
1297 surface->linesize = linesize;
1298 surface->pf = pf;
1299 if (surface->flags & QEMU_ALLOCATED_FLAG) {
1300 data = g_realloc(surface->data,
1301 surface->linesize * surface->height);
1302 } else {
1303 data = g_malloc(surface->linesize * surface->height);
1304 }
1305 surface->data = (uint8_t *)data;
1306 surface->flags = newflags | QEMU_ALLOCATED_FLAG;
1307 #ifdef HOST_WORDS_BIGENDIAN
1308 surface->flags |= QEMU_BIG_ENDIAN_FLAG;
1309 #endif
1310 }
1311
1312 DisplaySurface* qemu_create_displaysurface_from(int width, int height, int bpp,
1313 int linesize, uint8_t *data)
1314 {
1315 DisplaySurface *surface = (DisplaySurface*) g_malloc0(sizeof(DisplaySurface));
1316
1317 surface->width = width;
1318 surface->height = height;
1319 surface->linesize = linesize;
1320 surface->pf = qemu_default_pixelformat(bpp);
1321 #ifdef HOST_WORDS_BIGENDIAN
1322 surface->flags = QEMU_BIG_ENDIAN_FLAG;
1323 #endif
1324 surface->data = data;
1325
1326 return surface;
1327 }
1328
1329 static void defaultallocator_free_displaysurface(DisplaySurface *surface)
1330 {
1331 if (surface == NULL)
1332 return;
1333 if (surface->flags & QEMU_ALLOCATED_FLAG)
1334 g_free(surface->data);
1335 g_free(surface);
1336 }
1337
1338 static struct DisplayAllocator default_allocator = {
1339 defaultallocator_create_displaysurface,
1340 defaultallocator_resize_displaysurface,
1341 defaultallocator_free_displaysurface
1342 };
1343
1344 static void dumb_display_init(void)
1345 {
1346 DisplayState *ds = g_malloc0(sizeof(DisplayState));
1347 int width = 640;
1348 int height = 480;
1349
1350 ds->allocator = &default_allocator;
1351 if (is_fixedsize_console()) {
1352 width = active_console->g_width;
1353 height = active_console->g_height;
1354 }
1355 ds->surface = qemu_create_displaysurface(ds, width, height);
1356 register_displaystate(ds);
1357 }
1358
1359 /***********************************************************/
1360 /* register display */
1361
1362 void register_displaystate(DisplayState *ds)
1363 {
1364 DisplayState **s;
1365 s = &display_state;
1366 while (*s != NULL)
1367 s = &(*s)->next;
1368 ds->next = NULL;
1369 *s = ds;
1370 }
1371
1372 DisplayState *get_displaystate(void)
1373 {
1374 if (!display_state) {
1375 dumb_display_init ();
1376 }
1377 return display_state;
1378 }
1379
1380 DisplayAllocator *register_displayallocator(DisplayState *ds, DisplayAllocator *da)
1381 {
1382 if(ds->allocator == &default_allocator) {
1383 DisplaySurface *surf;
1384 surf = da->create_displaysurface(ds_get_width(ds), ds_get_height(ds));
1385 defaultallocator_free_displaysurface(ds->surface);
1386 ds->surface = surf;
1387 ds->allocator = da;
1388 }
1389 return ds->allocator;
1390 }
1391
1392 DisplayState *graphic_console_init(vga_hw_update_ptr update,
1393 vga_hw_invalidate_ptr invalidate,
1394 vga_hw_screen_dump_ptr screen_dump,
1395 vga_hw_text_update_ptr text_update,
1396 void *opaque)
1397 {
1398 TextConsole *s;
1399 DisplayState *ds;
1400
1401 ds = (DisplayState *) g_malloc0(sizeof(DisplayState));
1402 ds->allocator = &default_allocator;
1403 ds->surface = qemu_create_displaysurface(ds, 640, 480);
1404
1405 s = new_console(ds, GRAPHIC_CONSOLE);
1406 if (s == NULL) {
1407 qemu_free_displaysurface(ds);
1408 g_free(ds);
1409 return NULL;
1410 }
1411 s->hw_update = update;
1412 s->hw_invalidate = invalidate;
1413 s->hw_screen_dump = screen_dump;
1414 s->hw_text_update = text_update;
1415 s->hw = opaque;
1416
1417 register_displaystate(ds);
1418 return ds;
1419 }
1420
1421 int is_graphic_console(void)
1422 {
1423 return active_console && active_console->console_type == GRAPHIC_CONSOLE;
1424 }
1425
1426 int is_fixedsize_console(void)
1427 {
1428 return active_console && active_console->console_type != TEXT_CONSOLE;
1429 }
1430
1431 void console_color_init(DisplayState *ds)
1432 {
1433 int i, j;
1434 for (j = 0; j < 2; j++) {
1435 for (i = 0; i < 8; i++) {
1436 color_table[j][i] = col_expand(ds,
1437 vga_get_color(ds, color_table_rgb[j][i]));
1438 }
1439 }
1440 }
1441
1442 static int n_text_consoles;
1443 static CharDriverState *text_consoles[128];
1444
1445 static void text_console_set_echo(CharDriverState *chr, bool echo)
1446 {
1447 TextConsole *s = chr->opaque;
1448
1449 s->echo = echo;
1450 }
1451
1452 static void text_console_do_init(CharDriverState *chr, DisplayState *ds)
1453 {
1454 TextConsole *s;
1455 static int color_inited;
1456
1457 s = chr->opaque;
1458
1459 chr->chr_write = console_puts;
1460
1461 s->out_fifo.buf = s->out_fifo_buf;
1462 s->out_fifo.buf_size = sizeof(s->out_fifo_buf);
1463 s->kbd_timer = qemu_new_timer_ms(rt_clock, kbd_send_chars, s);
1464 s->ds = ds;
1465
1466 if (!color_inited) {
1467 color_inited = 1;
1468 console_color_init(s->ds);
1469 }
1470 s->y_displayed = 0;
1471 s->y_base = 0;
1472 s->total_height = DEFAULT_BACKSCROLL;
1473 s->x = 0;
1474 s->y = 0;
1475 if (s->console_type == TEXT_CONSOLE) {
1476 s->g_width = ds_get_width(s->ds);
1477 s->g_height = ds_get_height(s->ds);
1478 }
1479
1480 s->hw_invalidate = text_console_invalidate;
1481 s->hw_text_update = text_console_update;
1482 s->hw = s;
1483
1484 /* Set text attribute defaults */
1485 s->t_attrib_default.bold = 0;
1486 s->t_attrib_default.uline = 0;
1487 s->t_attrib_default.blink = 0;
1488 s->t_attrib_default.invers = 0;
1489 s->t_attrib_default.unvisible = 0;
1490 s->t_attrib_default.fgcol = COLOR_WHITE;
1491 s->t_attrib_default.bgcol = COLOR_BLACK;
1492 /* set current text attributes to default */
1493 s->t_attrib = s->t_attrib_default;
1494 text_console_resize(s);
1495
1496 if (chr->label) {
1497 char msg[128];
1498 int len;
1499
1500 s->t_attrib.bgcol = COLOR_BLUE;
1501 len = snprintf(msg, sizeof(msg), "%s console\r\n", chr->label);
1502 console_puts(chr, (uint8_t*)msg, len);
1503 s->t_attrib = s->t_attrib_default;
1504 }
1505
1506 qemu_chr_generic_open(chr);
1507 if (chr->init)
1508 chr->init(chr);
1509 }
1510
1511 int text_console_init(QemuOpts *opts, CharDriverState **_chr)
1512 {
1513 CharDriverState *chr;
1514 TextConsole *s;
1515 unsigned width;
1516 unsigned height;
1517
1518 chr = g_malloc0(sizeof(CharDriverState));
1519
1520 if (n_text_consoles == 128) {
1521 fprintf(stderr, "Too many text consoles\n");
1522 exit(1);
1523 }
1524 text_consoles[n_text_consoles] = chr;
1525 n_text_consoles++;
1526
1527 width = qemu_opt_get_number(opts, "width", 0);
1528 if (width == 0)
1529 width = qemu_opt_get_number(opts, "cols", 0) * FONT_WIDTH;
1530
1531 height = qemu_opt_get_number(opts, "height", 0);
1532 if (height == 0)
1533 height = qemu_opt_get_number(opts, "rows", 0) * FONT_HEIGHT;
1534
1535 if (width == 0 || height == 0) {
1536 s = new_console(NULL, TEXT_CONSOLE);
1537 } else {
1538 s = new_console(NULL, TEXT_CONSOLE_FIXED_SIZE);
1539 }
1540
1541 if (!s) {
1542 g_free(chr);
1543 return -EBUSY;
1544 }
1545
1546 s->chr = chr;
1547 s->g_width = width;
1548 s->g_height = height;
1549 chr->opaque = s;
1550 chr->chr_set_echo = text_console_set_echo;
1551
1552 *_chr = chr;
1553 return 0;
1554 }
1555
1556 void text_consoles_set_display(DisplayState *ds)
1557 {
1558 int i;
1559
1560 for (i = 0; i < n_text_consoles; i++) {
1561 text_console_do_init(text_consoles[i], ds);
1562 }
1563
1564 n_text_consoles = 0;
1565 }
1566
1567 void qemu_console_resize(DisplayState *ds, int width, int height)
1568 {
1569 TextConsole *s = get_graphic_console(ds);
1570 if (!s) return;
1571
1572 s->g_width = width;
1573 s->g_height = height;
1574 if (is_graphic_console()) {
1575 ds->surface = qemu_resize_displaysurface(ds, width, height);
1576 dpy_resize(ds);
1577 }
1578 }
1579
1580 void qemu_console_copy(DisplayState *ds, int src_x, int src_y,
1581 int dst_x, int dst_y, int w, int h)
1582 {
1583 if (is_graphic_console()) {
1584 dpy_copy(ds, src_x, src_y, dst_x, dst_y, w, h);
1585 }
1586 }
1587
1588 PixelFormat qemu_different_endianness_pixelformat(int bpp)
1589 {
1590 PixelFormat pf;
1591
1592 memset(&pf, 0x00, sizeof(PixelFormat));
1593
1594 pf.bits_per_pixel = bpp;
1595 pf.bytes_per_pixel = bpp / 8;
1596 pf.depth = bpp == 32 ? 24 : bpp;
1597
1598 switch (bpp) {
1599 case 24:
1600 pf.rmask = 0x000000FF;
1601 pf.gmask = 0x0000FF00;
1602 pf.bmask = 0x00FF0000;
1603 pf.rmax = 255;
1604 pf.gmax = 255;
1605 pf.bmax = 255;
1606 pf.rshift = 0;
1607 pf.gshift = 8;
1608 pf.bshift = 16;
1609 pf.rbits = 8;
1610 pf.gbits = 8;
1611 pf.bbits = 8;
1612 break;
1613 case 32:
1614 pf.rmask = 0x0000FF00;
1615 pf.gmask = 0x00FF0000;
1616 pf.bmask = 0xFF000000;
1617 pf.amask = 0x00000000;
1618 pf.amax = 255;
1619 pf.rmax = 255;
1620 pf.gmax = 255;
1621 pf.bmax = 255;
1622 pf.ashift = 0;
1623 pf.rshift = 8;
1624 pf.gshift = 16;
1625 pf.bshift = 24;
1626 pf.rbits = 8;
1627 pf.gbits = 8;
1628 pf.bbits = 8;
1629 pf.abits = 8;
1630 break;
1631 default:
1632 break;
1633 }
1634 return pf;
1635 }
1636
1637 PixelFormat qemu_default_pixelformat(int bpp)
1638 {
1639 PixelFormat pf;
1640
1641 memset(&pf, 0x00, sizeof(PixelFormat));
1642
1643 pf.bits_per_pixel = bpp;
1644 pf.bytes_per_pixel = bpp / 8;
1645 pf.depth = bpp == 32 ? 24 : bpp;
1646
1647 switch (bpp) {
1648 case 15:
1649 pf.bits_per_pixel = 16;
1650 pf.bytes_per_pixel = 2;
1651 pf.rmask = 0x00007c00;
1652 pf.gmask = 0x000003E0;
1653 pf.bmask = 0x0000001F;
1654 pf.rmax = 31;
1655 pf.gmax = 31;
1656 pf.bmax = 31;
1657 pf.rshift = 10;
1658 pf.gshift = 5;
1659 pf.bshift = 0;
1660 pf.rbits = 5;
1661 pf.gbits = 5;
1662 pf.bbits = 5;
1663 break;
1664 case 16:
1665 pf.rmask = 0x0000F800;
1666 pf.gmask = 0x000007E0;
1667 pf.bmask = 0x0000001F;
1668 pf.rmax = 31;
1669 pf.gmax = 63;
1670 pf.bmax = 31;
1671 pf.rshift = 11;
1672 pf.gshift = 5;
1673 pf.bshift = 0;
1674 pf.rbits = 5;
1675 pf.gbits = 6;
1676 pf.bbits = 5;
1677 break;
1678 case 24:
1679 pf.rmask = 0x00FF0000;
1680 pf.gmask = 0x0000FF00;
1681 pf.bmask = 0x000000FF;
1682 pf.rmax = 255;
1683 pf.gmax = 255;
1684 pf.bmax = 255;
1685 pf.rshift = 16;
1686 pf.gshift = 8;
1687 pf.bshift = 0;
1688 pf.rbits = 8;
1689 pf.gbits = 8;
1690 pf.bbits = 8;
1691 break;
1692 case 32:
1693 pf.rmask = 0x00FF0000;
1694 pf.gmask = 0x0000FF00;
1695 pf.bmask = 0x000000FF;
1696 pf.amax = 255;
1697 pf.rmax = 255;
1698 pf.gmax = 255;
1699 pf.bmax = 255;
1700 pf.ashift = 24;
1701 pf.rshift = 16;
1702 pf.gshift = 8;
1703 pf.bshift = 0;
1704 pf.rbits = 8;
1705 pf.gbits = 8;
1706 pf.bbits = 8;
1707 pf.abits = 8;
1708 break;
1709 default:
1710 break;
1711 }
1712 return pf;
1713 }
QEmu