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