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