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