Marc-André Lureau | 6f11081 | 2023-08-30 13:38:23 +0400 | [diff] [blame] | 1 | /* |
| 2 | * SPDX-License-Identifier: MIT |
| 3 | * QEMU VC |
| 4 | */ |
| 5 | #include "qemu/osdep.h" |
| 6 | |
| 7 | #include "chardev/char.h" |
| 8 | #include "qapi/error.h" |
| 9 | #include "qemu/fifo8.h" |
| 10 | #include "qemu/option.h" |
| 11 | #include "ui/console.h" |
| 12 | |
| 13 | #include "trace.h" |
| 14 | #include "console-priv.h" |
| 15 | |
| 16 | #define DEFAULT_BACKSCROLL 512 |
| 17 | #define CONSOLE_CURSOR_PERIOD 500 |
| 18 | |
| 19 | typedef struct TextAttributes { |
| 20 | uint8_t fgcol:4; |
| 21 | uint8_t bgcol:4; |
| 22 | uint8_t bold:1; |
| 23 | uint8_t uline:1; |
| 24 | uint8_t blink:1; |
| 25 | uint8_t invers:1; |
| 26 | uint8_t unvisible:1; |
| 27 | } TextAttributes; |
| 28 | |
| 29 | #define TEXT_ATTRIBUTES_DEFAULT ((TextAttributes) { \ |
| 30 | .fgcol = QEMU_COLOR_WHITE, \ |
| 31 | .bgcol = QEMU_COLOR_BLACK \ |
| 32 | }) |
| 33 | |
| 34 | typedef struct TextCell { |
| 35 | uint8_t ch; |
| 36 | TextAttributes t_attrib; |
| 37 | } TextCell; |
| 38 | |
| 39 | #define MAX_ESC_PARAMS 3 |
| 40 | |
| 41 | enum TTYState { |
| 42 | TTY_STATE_NORM, |
| 43 | TTY_STATE_ESC, |
| 44 | TTY_STATE_CSI, |
| 45 | }; |
| 46 | |
| 47 | typedef struct QemuTextConsole { |
| 48 | QemuConsole parent; |
| 49 | |
| 50 | int width; |
| 51 | int height; |
| 52 | int total_height; |
| 53 | int backscroll_height; |
| 54 | int x, y; |
| 55 | int y_displayed; |
| 56 | int y_base; |
| 57 | TextCell *cells; |
| 58 | int text_x[2], text_y[2], cursor_invalidate; |
| 59 | int echo; |
| 60 | |
| 61 | int update_x0; |
| 62 | int update_y0; |
| 63 | int update_x1; |
| 64 | int update_y1; |
| 65 | |
| 66 | Chardev *chr; |
| 67 | /* fifo for key pressed */ |
| 68 | Fifo8 out_fifo; |
| 69 | } QemuTextConsole; |
| 70 | |
| 71 | typedef QemuConsoleClass QemuTextConsoleClass; |
| 72 | |
| 73 | OBJECT_DEFINE_TYPE(QemuTextConsole, qemu_text_console, QEMU_TEXT_CONSOLE, QEMU_CONSOLE) |
| 74 | |
| 75 | typedef struct QemuFixedTextConsole { |
| 76 | QemuTextConsole parent; |
| 77 | } QemuFixedTextConsole; |
| 78 | |
| 79 | typedef QemuTextConsoleClass QemuFixedTextConsoleClass; |
| 80 | |
| 81 | OBJECT_DEFINE_TYPE(QemuFixedTextConsole, qemu_fixed_text_console, QEMU_FIXED_TEXT_CONSOLE, QEMU_TEXT_CONSOLE) |
| 82 | |
| 83 | struct VCChardev { |
| 84 | Chardev parent; |
| 85 | QemuTextConsole *console; |
| 86 | |
| 87 | enum TTYState state; |
| 88 | int esc_params[MAX_ESC_PARAMS]; |
| 89 | int nb_esc_params; |
| 90 | TextAttributes t_attrib; /* currently active text attributes */ |
| 91 | int x_saved, y_saved; |
| 92 | }; |
| 93 | typedef struct VCChardev VCChardev; |
| 94 | |
| 95 | static const pixman_color_t color_table_rgb[2][8] = { |
| 96 | { /* dark */ |
| 97 | [QEMU_COLOR_BLACK] = QEMU_PIXMAN_COLOR_BLACK, |
| 98 | [QEMU_COLOR_BLUE] = QEMU_PIXMAN_COLOR(0x00, 0x00, 0xaa), /* blue */ |
| 99 | [QEMU_COLOR_GREEN] = QEMU_PIXMAN_COLOR(0x00, 0xaa, 0x00), /* green */ |
| 100 | [QEMU_COLOR_CYAN] = QEMU_PIXMAN_COLOR(0x00, 0xaa, 0xaa), /* cyan */ |
| 101 | [QEMU_COLOR_RED] = QEMU_PIXMAN_COLOR(0xaa, 0x00, 0x00), /* red */ |
| 102 | [QEMU_COLOR_MAGENTA] = QEMU_PIXMAN_COLOR(0xaa, 0x00, 0xaa), /* magenta */ |
| 103 | [QEMU_COLOR_YELLOW] = QEMU_PIXMAN_COLOR(0xaa, 0xaa, 0x00), /* yellow */ |
| 104 | [QEMU_COLOR_WHITE] = QEMU_PIXMAN_COLOR_GRAY, |
| 105 | }, |
| 106 | { /* bright */ |
| 107 | [QEMU_COLOR_BLACK] = QEMU_PIXMAN_COLOR_BLACK, |
| 108 | [QEMU_COLOR_BLUE] = QEMU_PIXMAN_COLOR(0x00, 0x00, 0xff), /* blue */ |
| 109 | [QEMU_COLOR_GREEN] = QEMU_PIXMAN_COLOR(0x00, 0xff, 0x00), /* green */ |
| 110 | [QEMU_COLOR_CYAN] = QEMU_PIXMAN_COLOR(0x00, 0xff, 0xff), /* cyan */ |
| 111 | [QEMU_COLOR_RED] = QEMU_PIXMAN_COLOR(0xff, 0x00, 0x00), /* red */ |
| 112 | [QEMU_COLOR_MAGENTA] = QEMU_PIXMAN_COLOR(0xff, 0x00, 0xff), /* magenta */ |
| 113 | [QEMU_COLOR_YELLOW] = QEMU_PIXMAN_COLOR(0xff, 0xff, 0x00), /* yellow */ |
| 114 | [QEMU_COLOR_WHITE] = QEMU_PIXMAN_COLOR(0xff, 0xff, 0xff), /* white */ |
| 115 | } |
| 116 | }; |
| 117 | |
| 118 | static bool cursor_visible_phase; |
| 119 | static QEMUTimer *cursor_timer; |
| 120 | |
| 121 | const char * |
| 122 | qemu_text_console_get_label(QemuTextConsole *c) |
| 123 | { |
| 124 | return c->chr ? c->chr->label : NULL; |
| 125 | } |
| 126 | |
| 127 | static void qemu_console_fill_rect(QemuConsole *con, int posx, int posy, |
| 128 | int width, int height, pixman_color_t color) |
| 129 | { |
| 130 | DisplaySurface *surface = qemu_console_surface(con); |
| 131 | pixman_rectangle16_t rect = { |
| 132 | .x = posx, .y = posy, .width = width, .height = height |
| 133 | }; |
| 134 | |
| 135 | assert(surface); |
| 136 | pixman_image_fill_rectangles(PIXMAN_OP_SRC, surface->image, |
| 137 | &color, 1, &rect); |
| 138 | } |
| 139 | |
| 140 | /* copy from (xs, ys) to (xd, yd) a rectangle of size (w, h) */ |
| 141 | static void qemu_console_bitblt(QemuConsole *con, |
| 142 | int xs, int ys, int xd, int yd, int w, int h) |
| 143 | { |
| 144 | DisplaySurface *surface = qemu_console_surface(con); |
| 145 | |
| 146 | assert(surface); |
| 147 | pixman_image_composite(PIXMAN_OP_SRC, |
| 148 | surface->image, NULL, surface->image, |
| 149 | xs, ys, 0, 0, xd, yd, w, h); |
| 150 | } |
| 151 | |
| 152 | static void vga_putcharxy(QemuConsole *s, int x, int y, int ch, |
| 153 | TextAttributes *t_attrib) |
| 154 | { |
| 155 | static pixman_image_t *glyphs[256]; |
| 156 | DisplaySurface *surface = qemu_console_surface(s); |
| 157 | pixman_color_t fgcol, bgcol; |
| 158 | |
| 159 | assert(surface); |
| 160 | if (t_attrib->invers) { |
| 161 | bgcol = color_table_rgb[t_attrib->bold][t_attrib->fgcol]; |
| 162 | fgcol = color_table_rgb[t_attrib->bold][t_attrib->bgcol]; |
| 163 | } else { |
| 164 | fgcol = color_table_rgb[t_attrib->bold][t_attrib->fgcol]; |
| 165 | bgcol = color_table_rgb[t_attrib->bold][t_attrib->bgcol]; |
| 166 | } |
| 167 | |
| 168 | if (!glyphs[ch]) { |
| 169 | glyphs[ch] = qemu_pixman_glyph_from_vgafont(FONT_HEIGHT, vgafont16, ch); |
| 170 | } |
| 171 | qemu_pixman_glyph_render(glyphs[ch], surface->image, |
| 172 | &fgcol, &bgcol, x, y, FONT_WIDTH, FONT_HEIGHT); |
| 173 | } |
| 174 | |
| 175 | static void invalidate_xy(QemuTextConsole *s, int x, int y) |
| 176 | { |
| 177 | if (!qemu_console_is_visible(QEMU_CONSOLE(s))) { |
| 178 | return; |
| 179 | } |
| 180 | if (s->update_x0 > x * FONT_WIDTH) |
| 181 | s->update_x0 = x * FONT_WIDTH; |
| 182 | if (s->update_y0 > y * FONT_HEIGHT) |
| 183 | s->update_y0 = y * FONT_HEIGHT; |
| 184 | if (s->update_x1 < (x + 1) * FONT_WIDTH) |
| 185 | s->update_x1 = (x + 1) * FONT_WIDTH; |
| 186 | if (s->update_y1 < (y + 1) * FONT_HEIGHT) |
| 187 | s->update_y1 = (y + 1) * FONT_HEIGHT; |
| 188 | } |
| 189 | |
| 190 | static void console_show_cursor(QemuTextConsole *s, int show) |
| 191 | { |
| 192 | TextCell *c; |
| 193 | int y, y1; |
| 194 | int x = s->x; |
| 195 | |
| 196 | s->cursor_invalidate = 1; |
| 197 | |
| 198 | if (x >= s->width) { |
| 199 | x = s->width - 1; |
| 200 | } |
| 201 | y1 = (s->y_base + s->y) % s->total_height; |
| 202 | y = y1 - s->y_displayed; |
| 203 | if (y < 0) { |
| 204 | y += s->total_height; |
| 205 | } |
| 206 | if (y < s->height) { |
| 207 | c = &s->cells[y1 * s->width + x]; |
| 208 | if (show && cursor_visible_phase) { |
| 209 | TextAttributes t_attrib = TEXT_ATTRIBUTES_DEFAULT; |
| 210 | t_attrib.invers = !(t_attrib.invers); /* invert fg and bg */ |
| 211 | vga_putcharxy(QEMU_CONSOLE(s), x, y, c->ch, &t_attrib); |
| 212 | } else { |
| 213 | vga_putcharxy(QEMU_CONSOLE(s), x, y, c->ch, &(c->t_attrib)); |
| 214 | } |
| 215 | invalidate_xy(s, x, y); |
| 216 | } |
| 217 | } |
| 218 | |
| 219 | static void console_refresh(QemuTextConsole *s) |
| 220 | { |
| 221 | DisplaySurface *surface = qemu_console_surface(QEMU_CONSOLE(s)); |
| 222 | TextCell *c; |
| 223 | int x, y, y1; |
| 224 | |
| 225 | assert(surface); |
| 226 | s->text_x[0] = 0; |
| 227 | s->text_y[0] = 0; |
| 228 | s->text_x[1] = s->width - 1; |
| 229 | s->text_y[1] = s->height - 1; |
| 230 | s->cursor_invalidate = 1; |
| 231 | |
| 232 | qemu_console_fill_rect(QEMU_CONSOLE(s), 0, 0, surface_width(surface), surface_height(surface), |
| 233 | color_table_rgb[0][QEMU_COLOR_BLACK]); |
| 234 | y1 = s->y_displayed; |
| 235 | for (y = 0; y < s->height; y++) { |
| 236 | c = s->cells + y1 * s->width; |
| 237 | for (x = 0; x < s->width; x++) { |
| 238 | vga_putcharxy(QEMU_CONSOLE(s), x, y, c->ch, |
| 239 | &(c->t_attrib)); |
| 240 | c++; |
| 241 | } |
| 242 | if (++y1 == s->total_height) { |
| 243 | y1 = 0; |
| 244 | } |
| 245 | } |
| 246 | console_show_cursor(s, 1); |
| 247 | dpy_gfx_update(QEMU_CONSOLE(s), 0, 0, |
| 248 | surface_width(surface), surface_height(surface)); |
| 249 | } |
| 250 | |
| 251 | static void console_scroll(QemuTextConsole *s, int ydelta) |
| 252 | { |
| 253 | int i, y1; |
| 254 | |
| 255 | if (ydelta > 0) { |
| 256 | for(i = 0; i < ydelta; i++) { |
| 257 | if (s->y_displayed == s->y_base) |
| 258 | break; |
| 259 | if (++s->y_displayed == s->total_height) |
| 260 | s->y_displayed = 0; |
| 261 | } |
| 262 | } else { |
| 263 | ydelta = -ydelta; |
| 264 | i = s->backscroll_height; |
| 265 | if (i > s->total_height - s->height) |
| 266 | i = s->total_height - s->height; |
| 267 | y1 = s->y_base - i; |
| 268 | if (y1 < 0) |
| 269 | y1 += s->total_height; |
| 270 | for(i = 0; i < ydelta; i++) { |
| 271 | if (s->y_displayed == y1) |
| 272 | break; |
| 273 | if (--s->y_displayed < 0) |
| 274 | s->y_displayed = s->total_height - 1; |
| 275 | } |
| 276 | } |
| 277 | console_refresh(s); |
| 278 | } |
| 279 | |
| 280 | static void kbd_send_chars(QemuTextConsole *s) |
| 281 | { |
| 282 | uint32_t len, avail; |
| 283 | |
| 284 | len = qemu_chr_be_can_write(s->chr); |
| 285 | avail = fifo8_num_used(&s->out_fifo); |
| 286 | while (len > 0 && avail > 0) { |
| 287 | const uint8_t *buf; |
| 288 | uint32_t size; |
| 289 | |
Philippe Mathieu-Daudé | 06252bf | 2024-07-22 13:25:01 +0200 | [diff] [blame] | 290 | buf = fifo8_pop_bufptr(&s->out_fifo, MIN(len, avail), &size); |
Marc-André Lureau | 6f11081 | 2023-08-30 13:38:23 +0400 | [diff] [blame] | 291 | qemu_chr_be_write(s->chr, buf, size); |
| 292 | len = qemu_chr_be_can_write(s->chr); |
| 293 | avail -= size; |
| 294 | } |
| 295 | } |
| 296 | |
| 297 | /* called when an ascii key is pressed */ |
| 298 | void qemu_text_console_handle_keysym(QemuTextConsole *s, int keysym) |
| 299 | { |
| 300 | uint8_t buf[16], *q; |
| 301 | int c; |
| 302 | uint32_t num_free; |
| 303 | |
| 304 | switch(keysym) { |
| 305 | case QEMU_KEY_CTRL_UP: |
| 306 | console_scroll(s, -1); |
| 307 | break; |
| 308 | case QEMU_KEY_CTRL_DOWN: |
| 309 | console_scroll(s, 1); |
| 310 | break; |
| 311 | case QEMU_KEY_CTRL_PAGEUP: |
| 312 | console_scroll(s, -10); |
| 313 | break; |
| 314 | case QEMU_KEY_CTRL_PAGEDOWN: |
| 315 | console_scroll(s, 10); |
| 316 | break; |
| 317 | default: |
| 318 | /* convert the QEMU keysym to VT100 key string */ |
| 319 | q = buf; |
| 320 | if (keysym >= 0xe100 && keysym <= 0xe11f) { |
| 321 | *q++ = '\033'; |
| 322 | *q++ = '['; |
| 323 | c = keysym - 0xe100; |
| 324 | if (c >= 10) |
| 325 | *q++ = '0' + (c / 10); |
| 326 | *q++ = '0' + (c % 10); |
| 327 | *q++ = '~'; |
| 328 | } else if (keysym >= 0xe120 && keysym <= 0xe17f) { |
| 329 | *q++ = '\033'; |
| 330 | *q++ = '['; |
| 331 | *q++ = keysym & 0xff; |
| 332 | } else if (s->echo && (keysym == '\r' || keysym == '\n')) { |
| 333 | qemu_chr_write(s->chr, (uint8_t *)"\r", 1, true); |
| 334 | *q++ = '\n'; |
| 335 | } else { |
| 336 | *q++ = keysym; |
| 337 | } |
| 338 | if (s->echo) { |
| 339 | qemu_chr_write(s->chr, buf, q - buf, true); |
| 340 | } |
| 341 | num_free = fifo8_num_free(&s->out_fifo); |
| 342 | fifo8_push_all(&s->out_fifo, buf, MIN(num_free, q - buf)); |
| 343 | kbd_send_chars(s); |
| 344 | break; |
| 345 | } |
| 346 | } |
| 347 | |
| 348 | static void text_console_update(void *opaque, console_ch_t *chardata) |
| 349 | { |
| 350 | QemuTextConsole *s = QEMU_TEXT_CONSOLE(opaque); |
| 351 | int i, j, src; |
| 352 | |
| 353 | if (s->text_x[0] <= s->text_x[1]) { |
| 354 | src = (s->y_base + s->text_y[0]) * s->width; |
| 355 | chardata += s->text_y[0] * s->width; |
| 356 | for (i = s->text_y[0]; i <= s->text_y[1]; i ++) |
| 357 | for (j = 0; j < s->width; j++, src++) { |
| 358 | console_write_ch(chardata ++, |
| 359 | ATTR2CHTYPE(s->cells[src].ch, |
| 360 | s->cells[src].t_attrib.fgcol, |
| 361 | s->cells[src].t_attrib.bgcol, |
| 362 | s->cells[src].t_attrib.bold)); |
| 363 | } |
| 364 | dpy_text_update(QEMU_CONSOLE(s), s->text_x[0], s->text_y[0], |
| 365 | s->text_x[1] - s->text_x[0], i - s->text_y[0]); |
| 366 | s->text_x[0] = s->width; |
| 367 | s->text_y[0] = s->height; |
| 368 | s->text_x[1] = 0; |
| 369 | s->text_y[1] = 0; |
| 370 | } |
| 371 | if (s->cursor_invalidate) { |
| 372 | dpy_text_cursor(QEMU_CONSOLE(s), s->x, s->y); |
| 373 | s->cursor_invalidate = 0; |
| 374 | } |
| 375 | } |
| 376 | |
| 377 | static void text_console_resize(QemuTextConsole *t) |
| 378 | { |
| 379 | QemuConsole *s = QEMU_CONSOLE(t); |
| 380 | TextCell *cells, *c, *c1; |
| 381 | int w1, x, y, last_width, w, h; |
| 382 | |
| 383 | assert(s->scanout.kind == SCANOUT_SURFACE); |
| 384 | |
| 385 | w = surface_width(s->surface) / FONT_WIDTH; |
| 386 | h = surface_height(s->surface) / FONT_HEIGHT; |
| 387 | if (w == t->width && h == t->height) { |
| 388 | return; |
| 389 | } |
| 390 | |
| 391 | last_width = t->width; |
| 392 | t->width = w; |
| 393 | t->height = h; |
| 394 | |
| 395 | w1 = MIN(t->width, last_width); |
| 396 | |
| 397 | cells = g_new(TextCell, t->width * t->total_height + 1); |
| 398 | for (y = 0; y < t->total_height; y++) { |
| 399 | c = &cells[y * t->width]; |
| 400 | if (w1 > 0) { |
| 401 | c1 = &t->cells[y * last_width]; |
| 402 | for (x = 0; x < w1; x++) { |
| 403 | *c++ = *c1++; |
| 404 | } |
| 405 | } |
| 406 | for (x = w1; x < t->width; x++) { |
| 407 | c->ch = ' '; |
| 408 | c->t_attrib = TEXT_ATTRIBUTES_DEFAULT; |
| 409 | c++; |
| 410 | } |
| 411 | } |
| 412 | g_free(t->cells); |
| 413 | t->cells = cells; |
| 414 | } |
| 415 | |
| 416 | static void vc_put_lf(VCChardev *vc) |
| 417 | { |
| 418 | QemuTextConsole *s = vc->console; |
| 419 | TextCell *c; |
| 420 | int x, y1; |
| 421 | |
| 422 | s->y++; |
| 423 | if (s->y >= s->height) { |
| 424 | s->y = s->height - 1; |
| 425 | |
| 426 | if (s->y_displayed == s->y_base) { |
| 427 | if (++s->y_displayed == s->total_height) |
| 428 | s->y_displayed = 0; |
| 429 | } |
| 430 | if (++s->y_base == s->total_height) |
| 431 | s->y_base = 0; |
| 432 | if (s->backscroll_height < s->total_height) |
| 433 | s->backscroll_height++; |
| 434 | y1 = (s->y_base + s->height - 1) % s->total_height; |
| 435 | c = &s->cells[y1 * s->width]; |
| 436 | for(x = 0; x < s->width; x++) { |
| 437 | c->ch = ' '; |
| 438 | c->t_attrib = TEXT_ATTRIBUTES_DEFAULT; |
| 439 | c++; |
| 440 | } |
| 441 | if (s->y_displayed == s->y_base) { |
| 442 | s->text_x[0] = 0; |
| 443 | s->text_y[0] = 0; |
| 444 | s->text_x[1] = s->width - 1; |
| 445 | s->text_y[1] = s->height - 1; |
| 446 | |
| 447 | qemu_console_bitblt(QEMU_CONSOLE(s), 0, FONT_HEIGHT, 0, 0, |
| 448 | s->width * FONT_WIDTH, |
| 449 | (s->height - 1) * FONT_HEIGHT); |
| 450 | qemu_console_fill_rect(QEMU_CONSOLE(s), 0, (s->height - 1) * FONT_HEIGHT, |
| 451 | s->width * FONT_WIDTH, FONT_HEIGHT, |
| 452 | color_table_rgb[0][TEXT_ATTRIBUTES_DEFAULT.bgcol]); |
| 453 | s->update_x0 = 0; |
| 454 | s->update_y0 = 0; |
| 455 | s->update_x1 = s->width * FONT_WIDTH; |
| 456 | s->update_y1 = s->height * FONT_HEIGHT; |
| 457 | } |
| 458 | } |
| 459 | } |
| 460 | |
| 461 | /* Set console attributes depending on the current escape codes. |
| 462 | * NOTE: I know this code is not very efficient (checking every color for it |
| 463 | * self) but it is more readable and better maintainable. |
| 464 | */ |
| 465 | static void vc_handle_escape(VCChardev *vc) |
| 466 | { |
| 467 | int i; |
| 468 | |
| 469 | for (i = 0; i < vc->nb_esc_params; i++) { |
| 470 | switch (vc->esc_params[i]) { |
| 471 | case 0: /* reset all console attributes to default */ |
| 472 | vc->t_attrib = TEXT_ATTRIBUTES_DEFAULT; |
| 473 | break; |
| 474 | case 1: |
| 475 | vc->t_attrib.bold = 1; |
| 476 | break; |
| 477 | case 4: |
| 478 | vc->t_attrib.uline = 1; |
| 479 | break; |
| 480 | case 5: |
| 481 | vc->t_attrib.blink = 1; |
| 482 | break; |
| 483 | case 7: |
| 484 | vc->t_attrib.invers = 1; |
| 485 | break; |
| 486 | case 8: |
| 487 | vc->t_attrib.unvisible = 1; |
| 488 | break; |
| 489 | case 22: |
| 490 | vc->t_attrib.bold = 0; |
| 491 | break; |
| 492 | case 24: |
| 493 | vc->t_attrib.uline = 0; |
| 494 | break; |
| 495 | case 25: |
| 496 | vc->t_attrib.blink = 0; |
| 497 | break; |
| 498 | case 27: |
| 499 | vc->t_attrib.invers = 0; |
| 500 | break; |
| 501 | case 28: |
| 502 | vc->t_attrib.unvisible = 0; |
| 503 | break; |
| 504 | /* set foreground color */ |
| 505 | case 30: |
| 506 | vc->t_attrib.fgcol = QEMU_COLOR_BLACK; |
| 507 | break; |
| 508 | case 31: |
| 509 | vc->t_attrib.fgcol = QEMU_COLOR_RED; |
| 510 | break; |
| 511 | case 32: |
| 512 | vc->t_attrib.fgcol = QEMU_COLOR_GREEN; |
| 513 | break; |
| 514 | case 33: |
| 515 | vc->t_attrib.fgcol = QEMU_COLOR_YELLOW; |
| 516 | break; |
| 517 | case 34: |
| 518 | vc->t_attrib.fgcol = QEMU_COLOR_BLUE; |
| 519 | break; |
| 520 | case 35: |
| 521 | vc->t_attrib.fgcol = QEMU_COLOR_MAGENTA; |
| 522 | break; |
| 523 | case 36: |
| 524 | vc->t_attrib.fgcol = QEMU_COLOR_CYAN; |
| 525 | break; |
| 526 | case 37: |
| 527 | vc->t_attrib.fgcol = QEMU_COLOR_WHITE; |
| 528 | break; |
| 529 | /* set background color */ |
| 530 | case 40: |
| 531 | vc->t_attrib.bgcol = QEMU_COLOR_BLACK; |
| 532 | break; |
| 533 | case 41: |
| 534 | vc->t_attrib.bgcol = QEMU_COLOR_RED; |
| 535 | break; |
| 536 | case 42: |
| 537 | vc->t_attrib.bgcol = QEMU_COLOR_GREEN; |
| 538 | break; |
| 539 | case 43: |
| 540 | vc->t_attrib.bgcol = QEMU_COLOR_YELLOW; |
| 541 | break; |
| 542 | case 44: |
| 543 | vc->t_attrib.bgcol = QEMU_COLOR_BLUE; |
| 544 | break; |
| 545 | case 45: |
| 546 | vc->t_attrib.bgcol = QEMU_COLOR_MAGENTA; |
| 547 | break; |
| 548 | case 46: |
| 549 | vc->t_attrib.bgcol = QEMU_COLOR_CYAN; |
| 550 | break; |
| 551 | case 47: |
| 552 | vc->t_attrib.bgcol = QEMU_COLOR_WHITE; |
| 553 | break; |
| 554 | } |
| 555 | } |
| 556 | } |
| 557 | |
| 558 | static void vc_update_xy(VCChardev *vc, int x, int y) |
| 559 | { |
| 560 | QemuTextConsole *s = vc->console; |
| 561 | TextCell *c; |
| 562 | int y1, y2; |
| 563 | |
| 564 | s->text_x[0] = MIN(s->text_x[0], x); |
| 565 | s->text_x[1] = MAX(s->text_x[1], x); |
| 566 | s->text_y[0] = MIN(s->text_y[0], y); |
| 567 | s->text_y[1] = MAX(s->text_y[1], y); |
| 568 | |
| 569 | y1 = (s->y_base + y) % s->total_height; |
| 570 | y2 = y1 - s->y_displayed; |
| 571 | if (y2 < 0) { |
| 572 | y2 += s->total_height; |
| 573 | } |
| 574 | if (y2 < s->height) { |
| 575 | if (x >= s->width) { |
| 576 | x = s->width - 1; |
| 577 | } |
| 578 | c = &s->cells[y1 * s->width + x]; |
| 579 | vga_putcharxy(QEMU_CONSOLE(s), x, y2, c->ch, |
| 580 | &(c->t_attrib)); |
| 581 | invalidate_xy(s, x, y2); |
| 582 | } |
| 583 | } |
| 584 | |
| 585 | static void vc_clear_xy(VCChardev *vc, int x, int y) |
| 586 | { |
| 587 | QemuTextConsole *s = vc->console; |
| 588 | int y1 = (s->y_base + y) % s->total_height; |
| 589 | if (x >= s->width) { |
| 590 | x = s->width - 1; |
| 591 | } |
| 592 | TextCell *c = &s->cells[y1 * s->width + x]; |
| 593 | c->ch = ' '; |
| 594 | c->t_attrib = TEXT_ATTRIBUTES_DEFAULT; |
| 595 | vc_update_xy(vc, x, y); |
| 596 | } |
| 597 | |
| 598 | static void vc_put_one(VCChardev *vc, int ch) |
| 599 | { |
| 600 | QemuTextConsole *s = vc->console; |
| 601 | TextCell *c; |
| 602 | int y1; |
| 603 | if (s->x >= s->width) { |
| 604 | /* line wrap */ |
| 605 | s->x = 0; |
| 606 | vc_put_lf(vc); |
| 607 | } |
| 608 | y1 = (s->y_base + s->y) % s->total_height; |
| 609 | c = &s->cells[y1 * s->width + s->x]; |
| 610 | c->ch = ch; |
| 611 | c->t_attrib = vc->t_attrib; |
| 612 | vc_update_xy(vc, s->x, s->y); |
| 613 | s->x++; |
| 614 | } |
| 615 | |
| 616 | static void vc_respond_str(VCChardev *vc, const char *buf) |
| 617 | { |
| 618 | while (*buf) { |
| 619 | vc_put_one(vc, *buf); |
| 620 | buf++; |
| 621 | } |
| 622 | } |
| 623 | |
| 624 | /* set cursor, checking bounds */ |
| 625 | static void vc_set_cursor(VCChardev *vc, int x, int y) |
| 626 | { |
| 627 | QemuTextConsole *s = vc->console; |
| 628 | |
| 629 | if (x < 0) { |
| 630 | x = 0; |
| 631 | } |
| 632 | if (y < 0) { |
| 633 | y = 0; |
| 634 | } |
| 635 | if (y >= s->height) { |
| 636 | y = s->height - 1; |
| 637 | } |
| 638 | if (x >= s->width) { |
| 639 | x = s->width - 1; |
| 640 | } |
| 641 | |
| 642 | s->x = x; |
| 643 | s->y = y; |
| 644 | } |
| 645 | |
| 646 | static void vc_putchar(VCChardev *vc, int ch) |
| 647 | { |
| 648 | QemuTextConsole *s = vc->console; |
| 649 | int i; |
| 650 | int x, y; |
| 651 | char response[40]; |
| 652 | |
| 653 | switch(vc->state) { |
| 654 | case TTY_STATE_NORM: |
| 655 | switch(ch) { |
| 656 | case '\r': /* carriage return */ |
| 657 | s->x = 0; |
| 658 | break; |
| 659 | case '\n': /* newline */ |
| 660 | vc_put_lf(vc); |
| 661 | break; |
| 662 | case '\b': /* backspace */ |
| 663 | if (s->x > 0) |
| 664 | s->x--; |
| 665 | break; |
| 666 | case '\t': /* tabspace */ |
| 667 | if (s->x + (8 - (s->x % 8)) > s->width) { |
| 668 | s->x = 0; |
| 669 | vc_put_lf(vc); |
| 670 | } else { |
| 671 | s->x = s->x + (8 - (s->x % 8)); |
| 672 | } |
| 673 | break; |
| 674 | case '\a': /* alert aka. bell */ |
| 675 | /* TODO: has to be implemented */ |
| 676 | break; |
| 677 | case 14: |
| 678 | /* SI (shift in), character set 0 (ignored) */ |
| 679 | break; |
| 680 | case 15: |
| 681 | /* SO (shift out), character set 1 (ignored) */ |
| 682 | break; |
| 683 | case 27: /* esc (introducing an escape sequence) */ |
| 684 | vc->state = TTY_STATE_ESC; |
| 685 | break; |
| 686 | default: |
| 687 | vc_put_one(vc, ch); |
| 688 | break; |
| 689 | } |
| 690 | break; |
| 691 | case TTY_STATE_ESC: /* check if it is a terminal escape sequence */ |
| 692 | if (ch == '[') { |
| 693 | for(i=0;i<MAX_ESC_PARAMS;i++) |
| 694 | vc->esc_params[i] = 0; |
| 695 | vc->nb_esc_params = 0; |
| 696 | vc->state = TTY_STATE_CSI; |
| 697 | } else { |
| 698 | vc->state = TTY_STATE_NORM; |
| 699 | } |
| 700 | break; |
| 701 | case TTY_STATE_CSI: /* handle escape sequence parameters */ |
| 702 | if (ch >= '0' && ch <= '9') { |
| 703 | if (vc->nb_esc_params < MAX_ESC_PARAMS) { |
| 704 | int *param = &vc->esc_params[vc->nb_esc_params]; |
| 705 | int digit = (ch - '0'); |
| 706 | |
| 707 | *param = (*param <= (INT_MAX - digit) / 10) ? |
| 708 | *param * 10 + digit : INT_MAX; |
| 709 | } |
| 710 | } else { |
| 711 | if (vc->nb_esc_params < MAX_ESC_PARAMS) |
| 712 | vc->nb_esc_params++; |
| 713 | if (ch == ';' || ch == '?') { |
| 714 | break; |
| 715 | } |
| 716 | trace_console_putchar_csi(vc->esc_params[0], vc->esc_params[1], |
| 717 | ch, vc->nb_esc_params); |
| 718 | vc->state = TTY_STATE_NORM; |
| 719 | switch(ch) { |
| 720 | case 'A': |
| 721 | /* move cursor up */ |
| 722 | if (vc->esc_params[0] == 0) { |
| 723 | vc->esc_params[0] = 1; |
| 724 | } |
| 725 | vc_set_cursor(vc, s->x, s->y - vc->esc_params[0]); |
| 726 | break; |
| 727 | case 'B': |
| 728 | /* move cursor down */ |
| 729 | if (vc->esc_params[0] == 0) { |
| 730 | vc->esc_params[0] = 1; |
| 731 | } |
| 732 | vc_set_cursor(vc, s->x, s->y + vc->esc_params[0]); |
| 733 | break; |
| 734 | case 'C': |
| 735 | /* move cursor right */ |
| 736 | if (vc->esc_params[0] == 0) { |
| 737 | vc->esc_params[0] = 1; |
| 738 | } |
| 739 | vc_set_cursor(vc, s->x + vc->esc_params[0], s->y); |
| 740 | break; |
| 741 | case 'D': |
| 742 | /* move cursor left */ |
| 743 | if (vc->esc_params[0] == 0) { |
| 744 | vc->esc_params[0] = 1; |
| 745 | } |
| 746 | vc_set_cursor(vc, s->x - vc->esc_params[0], s->y); |
| 747 | break; |
| 748 | case 'G': |
| 749 | /* move cursor to column */ |
| 750 | vc_set_cursor(vc, vc->esc_params[0] - 1, s->y); |
| 751 | break; |
| 752 | case 'f': |
| 753 | case 'H': |
| 754 | /* move cursor to row, column */ |
| 755 | vc_set_cursor(vc, vc->esc_params[1] - 1, vc->esc_params[0] - 1); |
| 756 | break; |
| 757 | case 'J': |
| 758 | switch (vc->esc_params[0]) { |
| 759 | case 0: |
| 760 | /* clear to end of screen */ |
| 761 | for (y = s->y; y < s->height; y++) { |
| 762 | for (x = 0; x < s->width; x++) { |
| 763 | if (y == s->y && x < s->x) { |
| 764 | continue; |
| 765 | } |
| 766 | vc_clear_xy(vc, x, y); |
| 767 | } |
| 768 | } |
| 769 | break; |
| 770 | case 1: |
| 771 | /* clear from beginning of screen */ |
| 772 | for (y = 0; y <= s->y; y++) { |
| 773 | for (x = 0; x < s->width; x++) { |
| 774 | if (y == s->y && x > s->x) { |
| 775 | break; |
| 776 | } |
| 777 | vc_clear_xy(vc, x, y); |
| 778 | } |
| 779 | } |
| 780 | break; |
| 781 | case 2: |
| 782 | /* clear entire screen */ |
| 783 | for (y = 0; y <= s->height; y++) { |
| 784 | for (x = 0; x < s->width; x++) { |
| 785 | vc_clear_xy(vc, x, y); |
| 786 | } |
| 787 | } |
| 788 | break; |
| 789 | } |
| 790 | break; |
| 791 | case 'K': |
| 792 | switch (vc->esc_params[0]) { |
| 793 | case 0: |
| 794 | /* clear to eol */ |
| 795 | for(x = s->x; x < s->width; x++) { |
| 796 | vc_clear_xy(vc, x, s->y); |
| 797 | } |
| 798 | break; |
| 799 | case 1: |
| 800 | /* clear from beginning of line */ |
| 801 | for (x = 0; x <= s->x && x < s->width; x++) { |
| 802 | vc_clear_xy(vc, x, s->y); |
| 803 | } |
| 804 | break; |
| 805 | case 2: |
| 806 | /* clear entire line */ |
| 807 | for(x = 0; x < s->width; x++) { |
| 808 | vc_clear_xy(vc, x, s->y); |
| 809 | } |
| 810 | break; |
| 811 | } |
| 812 | break; |
| 813 | case 'm': |
| 814 | vc_handle_escape(vc); |
| 815 | break; |
| 816 | case 'n': |
| 817 | switch (vc->esc_params[0]) { |
| 818 | case 5: |
| 819 | /* report console status (always succeed)*/ |
| 820 | vc_respond_str(vc, "\033[0n"); |
| 821 | break; |
| 822 | case 6: |
| 823 | /* report cursor position */ |
| 824 | sprintf(response, "\033[%d;%dR", |
| 825 | (s->y_base + s->y) % s->total_height + 1, |
| 826 | s->x + 1); |
| 827 | vc_respond_str(vc, response); |
| 828 | break; |
| 829 | } |
| 830 | break; |
| 831 | case 's': |
| 832 | /* save cursor position */ |
| 833 | vc->x_saved = s->x; |
| 834 | vc->y_saved = s->y; |
| 835 | break; |
| 836 | case 'u': |
| 837 | /* restore cursor position */ |
| 838 | s->x = vc->x_saved; |
| 839 | s->y = vc->y_saved; |
| 840 | break; |
| 841 | default: |
| 842 | trace_console_putchar_unhandled(ch); |
| 843 | break; |
| 844 | } |
| 845 | break; |
| 846 | } |
| 847 | } |
| 848 | } |
| 849 | |
| 850 | #define TYPE_CHARDEV_VC "chardev-vc" |
| 851 | DECLARE_INSTANCE_CHECKER(VCChardev, VC_CHARDEV, |
| 852 | TYPE_CHARDEV_VC) |
| 853 | |
| 854 | static int vc_chr_write(Chardev *chr, const uint8_t *buf, int len) |
| 855 | { |
| 856 | VCChardev *drv = VC_CHARDEV(chr); |
| 857 | QemuTextConsole *s = drv->console; |
| 858 | int i; |
| 859 | |
| 860 | s->update_x0 = s->width * FONT_WIDTH; |
| 861 | s->update_y0 = s->height * FONT_HEIGHT; |
| 862 | s->update_x1 = 0; |
| 863 | s->update_y1 = 0; |
| 864 | console_show_cursor(s, 0); |
| 865 | for(i = 0; i < len; i++) { |
| 866 | vc_putchar(drv, buf[i]); |
| 867 | } |
| 868 | console_show_cursor(s, 1); |
| 869 | if (s->update_x0 < s->update_x1) { |
| 870 | dpy_gfx_update(QEMU_CONSOLE(s), s->update_x0, s->update_y0, |
| 871 | s->update_x1 - s->update_x0, |
| 872 | s->update_y1 - s->update_y0); |
| 873 | } |
| 874 | return len; |
| 875 | } |
| 876 | |
| 877 | void qemu_text_console_update_cursor(void) |
| 878 | { |
| 879 | cursor_visible_phase = !cursor_visible_phase; |
| 880 | |
| 881 | if (qemu_invalidate_text_consoles()) { |
| 882 | timer_mod(cursor_timer, |
| 883 | qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + CONSOLE_CURSOR_PERIOD / 2); |
| 884 | } |
| 885 | } |
| 886 | |
| 887 | static void |
| 888 | cursor_timer_cb(void *opaque) |
| 889 | { |
| 890 | qemu_text_console_update_cursor(); |
| 891 | } |
| 892 | |
| 893 | static void text_console_invalidate(void *opaque) |
| 894 | { |
| 895 | QemuTextConsole *s = QEMU_TEXT_CONSOLE(opaque); |
| 896 | |
| 897 | if (!QEMU_IS_FIXED_TEXT_CONSOLE(s)) { |
| 898 | text_console_resize(QEMU_TEXT_CONSOLE(s)); |
| 899 | } |
| 900 | console_refresh(s); |
| 901 | } |
| 902 | |
| 903 | static void |
| 904 | qemu_text_console_finalize(Object *obj) |
| 905 | { |
| 906 | } |
| 907 | |
| 908 | static void |
| 909 | qemu_text_console_class_init(ObjectClass *oc, void *data) |
| 910 | { |
| 911 | if (!cursor_timer) { |
| 912 | cursor_timer = timer_new_ms(QEMU_CLOCK_REALTIME, cursor_timer_cb, NULL); |
| 913 | } |
| 914 | } |
| 915 | |
| 916 | static const GraphicHwOps text_console_ops = { |
| 917 | .invalidate = text_console_invalidate, |
| 918 | .text_update = text_console_update, |
| 919 | }; |
| 920 | |
| 921 | static void |
| 922 | qemu_text_console_init(Object *obj) |
| 923 | { |
| 924 | QemuTextConsole *c = QEMU_TEXT_CONSOLE(obj); |
| 925 | |
| 926 | fifo8_create(&c->out_fifo, 16); |
| 927 | c->total_height = DEFAULT_BACKSCROLL; |
| 928 | QEMU_CONSOLE(c)->hw_ops = &text_console_ops; |
| 929 | QEMU_CONSOLE(c)->hw = c; |
| 930 | } |
| 931 | |
| 932 | static void |
| 933 | qemu_fixed_text_console_finalize(Object *obj) |
| 934 | { |
| 935 | } |
| 936 | |
| 937 | static void |
| 938 | qemu_fixed_text_console_class_init(ObjectClass *oc, void *data) |
| 939 | { |
| 940 | } |
| 941 | |
| 942 | static void |
| 943 | qemu_fixed_text_console_init(Object *obj) |
| 944 | { |
| 945 | } |
| 946 | |
| 947 | static void vc_chr_accept_input(Chardev *chr) |
| 948 | { |
| 949 | VCChardev *drv = VC_CHARDEV(chr); |
| 950 | |
| 951 | kbd_send_chars(drv->console); |
| 952 | } |
| 953 | |
| 954 | static void vc_chr_set_echo(Chardev *chr, bool echo) |
| 955 | { |
| 956 | VCChardev *drv = VC_CHARDEV(chr); |
| 957 | |
| 958 | drv->console->echo = echo; |
| 959 | } |
| 960 | |
Akihiko Odaki | e99441a | 2024-03-19 12:08:42 +0900 | [diff] [blame] | 961 | void qemu_text_console_update_size(QemuTextConsole *c) |
Marc-André Lureau | 6f11081 | 2023-08-30 13:38:23 +0400 | [diff] [blame] | 962 | { |
| 963 | dpy_text_resize(QEMU_CONSOLE(c), c->width, c->height); |
Marc-André Lureau | 6f11081 | 2023-08-30 13:38:23 +0400 | [diff] [blame] | 964 | } |
| 965 | |
| 966 | static void vc_chr_open(Chardev *chr, |
| 967 | ChardevBackend *backend, |
| 968 | bool *be_opened, |
| 969 | Error **errp) |
| 970 | { |
| 971 | ChardevVC *vc = backend->u.vc.data; |
| 972 | VCChardev *drv = VC_CHARDEV(chr); |
| 973 | QemuTextConsole *s; |
| 974 | unsigned width = 0; |
| 975 | unsigned height = 0; |
| 976 | |
| 977 | if (vc->has_width) { |
| 978 | width = vc->width; |
| 979 | } else if (vc->has_cols) { |
| 980 | width = vc->cols * FONT_WIDTH; |
| 981 | } |
| 982 | |
| 983 | if (vc->has_height) { |
| 984 | height = vc->height; |
| 985 | } else if (vc->has_rows) { |
| 986 | height = vc->rows * FONT_HEIGHT; |
| 987 | } |
| 988 | |
| 989 | trace_console_txt_new(width, height); |
| 990 | if (width == 0 || height == 0) { |
| 991 | s = QEMU_TEXT_CONSOLE(object_new(TYPE_QEMU_TEXT_CONSOLE)); |
Akihiko Odaki | 271a197 | 2024-03-19 12:08:39 +0900 | [diff] [blame] | 992 | width = 80 * FONT_WIDTH; |
| 993 | height = 24 * FONT_HEIGHT; |
Marc-André Lureau | 6f11081 | 2023-08-30 13:38:23 +0400 | [diff] [blame] | 994 | } else { |
| 995 | s = QEMU_TEXT_CONSOLE(object_new(TYPE_QEMU_FIXED_TEXT_CONSOLE)); |
| 996 | } |
| 997 | |
| 998 | dpy_gfx_replace_surface(QEMU_CONSOLE(s), qemu_create_displaysurface(width, height)); |
| 999 | |
| 1000 | s->chr = chr; |
| 1001 | drv->console = s; |
| 1002 | |
| 1003 | /* set current text attributes to default */ |
| 1004 | drv->t_attrib = TEXT_ATTRIBUTES_DEFAULT; |
| 1005 | text_console_resize(s); |
| 1006 | |
| 1007 | if (chr->label) { |
| 1008 | char *msg; |
| 1009 | |
| 1010 | drv->t_attrib.bgcol = QEMU_COLOR_BLUE; |
| 1011 | msg = g_strdup_printf("%s console\r\n", chr->label); |
| 1012 | qemu_chr_write(chr, (uint8_t *)msg, strlen(msg), true); |
| 1013 | g_free(msg); |
| 1014 | drv->t_attrib = TEXT_ATTRIBUTES_DEFAULT; |
| 1015 | } |
| 1016 | |
| 1017 | *be_opened = true; |
| 1018 | } |
| 1019 | |
| 1020 | static void vc_chr_parse(QemuOpts *opts, ChardevBackend *backend, Error **errp) |
| 1021 | { |
| 1022 | int val; |
| 1023 | ChardevVC *vc; |
| 1024 | |
| 1025 | backend->type = CHARDEV_BACKEND_KIND_VC; |
| 1026 | vc = backend->u.vc.data = g_new0(ChardevVC, 1); |
| 1027 | qemu_chr_parse_common(opts, qapi_ChardevVC_base(vc)); |
| 1028 | |
| 1029 | val = qemu_opt_get_number(opts, "width", 0); |
| 1030 | if (val != 0) { |
| 1031 | vc->has_width = true; |
| 1032 | vc->width = val; |
| 1033 | } |
| 1034 | |
| 1035 | val = qemu_opt_get_number(opts, "height", 0); |
| 1036 | if (val != 0) { |
| 1037 | vc->has_height = true; |
| 1038 | vc->height = val; |
| 1039 | } |
| 1040 | |
| 1041 | val = qemu_opt_get_number(opts, "cols", 0); |
| 1042 | if (val != 0) { |
| 1043 | vc->has_cols = true; |
| 1044 | vc->cols = val; |
| 1045 | } |
| 1046 | |
| 1047 | val = qemu_opt_get_number(opts, "rows", 0); |
| 1048 | if (val != 0) { |
| 1049 | vc->has_rows = true; |
| 1050 | vc->rows = val; |
| 1051 | } |
| 1052 | } |
| 1053 | |
| 1054 | static void char_vc_class_init(ObjectClass *oc, void *data) |
| 1055 | { |
| 1056 | ChardevClass *cc = CHARDEV_CLASS(oc); |
| 1057 | |
| 1058 | cc->parse = vc_chr_parse; |
| 1059 | cc->open = vc_chr_open; |
| 1060 | cc->chr_write = vc_chr_write; |
| 1061 | cc->chr_accept_input = vc_chr_accept_input; |
| 1062 | cc->chr_set_echo = vc_chr_set_echo; |
| 1063 | } |
| 1064 | |
| 1065 | static const TypeInfo char_vc_type_info = { |
| 1066 | .name = TYPE_CHARDEV_VC, |
| 1067 | .parent = TYPE_CHARDEV, |
| 1068 | .instance_size = sizeof(VCChardev), |
| 1069 | .class_init = char_vc_class_init, |
| 1070 | }; |
| 1071 | |
| 1072 | void qemu_console_early_init(void) |
| 1073 | { |
| 1074 | /* set the default vc driver */ |
| 1075 | if (!object_class_by_name(TYPE_CHARDEV_VC)) { |
| 1076 | type_register(&char_vc_type_info); |
| 1077 | } |
| 1078 | } |