Archipelago » qemu

/*

 * QEMU graphical console

 *

 * Copyright (c) 2004 Fabrice Bellard

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include "qemu-common.h"

#include "ui/console.h"

#include "hw/qdev-core.h"

#include "qemu/timer.h"

#include "qmp-commands.h"

#include "sysemu/char.h"

#include "trace.h"

#define DEFAULT_BACKSCROLL 512

#define MAX_CONSOLES 12

#define CONSOLE_CURSOR_PERIOD 500

typedef struct TextAttributes {

    uint8_t fgcol:4;

    uint8_t bgcol:4;

    uint8_t bold:1;

    uint8_t uline:1;

    uint8_t blink:1;

    uint8_t invers:1;

    uint8_t unvisible:1;

} TextAttributes;

typedef struct TextCell {

    uint8_t ch;

    TextAttributes t_attrib;

} TextCell;

#define MAX_ESC_PARAMS 3

enum TTYState {

    TTY_STATE_NORM,

    TTY_STATE_ESC,

    TTY_STATE_CSI,

};

typedef struct QEMUFIFO {

    uint8_t *buf;

    int buf_size;

    int count, wptr, rptr;

} QEMUFIFO;

static int qemu_fifo_write(QEMUFIFO *f, const uint8_t *buf, int len1)

{

    int l, len;

    l = f->buf_size - f->count;

    if (len1 > l)

        len1 = l;

    len = len1;

    while (len > 0) {

        l = f->buf_size - f->wptr;

        if (l > len)

            l = len;

        memcpy(f->buf + f->wptr, buf, l);

        f->wptr += l;

        if (f->wptr >= f->buf_size)

            f->wptr = 0;

        buf += l;

        len -= l;

    }

    f->count += len1;

    return len1;

}

static int qemu_fifo_read(QEMUFIFO *f, uint8_t *buf, int len1)

{

    int l, len;

    if (len1 > f->count)

        len1 = f->count;

    len = len1;

    while (len > 0) {

        l = f->buf_size - f->rptr;

        if (l > len)

            l = len;

        memcpy(buf, f->buf + f->rptr, l);

        f->rptr += l;

        if (f->rptr >= f->buf_size)

            f->rptr = 0;

        buf += l;

        len -= l;

    }

    f->count -= len1;

    return len1;

}

typedef enum {

    GRAPHIC_CONSOLE,

    TEXT_CONSOLE,

    TEXT_CONSOLE_FIXED_SIZE

} console_type_t;

struct QemuConsole {

    Object parent;

    int index;

    console_type_t console_type;

    DisplayState *ds;

    DisplaySurface *surface;

    int dcls;

    /* Graphic console state.  */

    Object *device;

    const GraphicHwOps *hw_ops;

    void *hw;

    /* Text console state */

    int width;

    int height;

    int total_height;

    int backscroll_height;

    int x, y;

    int x_saved, y_saved;

    int y_displayed;

    int y_base;

    TextAttributes t_attrib_default; /* default text attributes */

    TextAttributes t_attrib; /* currently active text attributes */

    TextCell *cells;

    int text_x[2], text_y[2], cursor_invalidate;

    int echo;

    bool cursor_visible_phase;

    QEMUTimer *cursor_timer;

    int update_x0;

    int update_y0;

    int update_x1;

    int update_y1;

    enum TTYState state;

    int esc_params[MAX_ESC_PARAMS];

    int nb_esc_params;

    CharDriverState *chr;

    /* fifo for key pressed */

    QEMUFIFO out_fifo;

    uint8_t out_fifo_buf[16];

    QEMUTimer *kbd_timer;

};

struct DisplayState {

    QEMUTimer *gui_timer;

    uint64_t last_update;

    uint64_t update_interval;

    bool refreshing;

    bool have_gfx;

    bool have_text;

    QLIST_HEAD(, DisplayChangeListener) listeners;

};

static DisplayState *display_state;

static QemuConsole *active_console;

static QemuConsole *consoles[MAX_CONSOLES];

static int nb_consoles = 0;

static void text_console_do_init(CharDriverState *chr, DisplayState *ds);

static void dpy_refresh(DisplayState *s);

static DisplayState *get_alloc_displaystate(void);

static void gui_update(void *opaque)

{

    uint64_t interval = GUI_REFRESH_INTERVAL_IDLE;

    uint64_t dcl_interval;

    DisplayState *ds = opaque;

    DisplayChangeListener *dcl;

    int i;

    ds->refreshing = true;

    dpy_refresh(ds);

    ds->refreshing = false;

    QLIST_FOREACH(dcl, &ds->listeners, next) {

        dcl_interval = dcl->update_interval ?

            dcl->update_interval : GUI_REFRESH_INTERVAL_DEFAULT;

        if (interval > dcl_interval) {

            interval = dcl_interval;

        }

    }

    if (ds->update_interval != interval) {

        ds->update_interval = interval;

        for (i = 0; i < nb_consoles; i++) {

            if (consoles[i]->hw_ops->update_interval) {

                consoles[i]->hw_ops->update_interval(consoles[i]->hw, interval);

            }

        }

        trace_console_refresh(interval);

    }

    ds->last_update = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);

    timer_mod(ds->gui_timer, ds->last_update + interval);

}

static void gui_setup_refresh(DisplayState *ds)

{

    DisplayChangeListener *dcl;

    bool need_timer = false;

    bool have_gfx = false;

    bool have_text = false;

    QLIST_FOREACH(dcl, &ds->listeners, next) {

        if (dcl->ops->dpy_refresh != NULL) {

            need_timer = true;

        }

        if (dcl->ops->dpy_gfx_update != NULL) {

            have_gfx = true;

        }

        if (dcl->ops->dpy_text_update != NULL) {

            have_text = true;

        }

    }

    if (need_timer && ds->gui_timer == NULL) {

        ds->gui_timer = timer_new_ms(QEMU_CLOCK_REALTIME, gui_update, ds);

        timer_mod(ds->gui_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME));

    }

    if (!need_timer && ds->gui_timer != NULL) {

        timer_del(ds->gui_timer);

        timer_free(ds->gui_timer);

        ds->gui_timer = NULL;

    }

    ds->have_gfx = have_gfx;

    ds->have_text = have_text;

}

void graphic_hw_update(QemuConsole *con)

{

    if (!con) {

        con = active_console;

    }

    if (con && con->hw_ops->gfx_update) {

        con->hw_ops->gfx_update(con->hw);

    }

}

void graphic_hw_invalidate(QemuConsole *con)

{

    if (!con) {

        con = active_console;

    }

    if (con && con->hw_ops->invalidate) {

        con->hw_ops->invalidate(con->hw);

    }

}

static void ppm_save(const char *filename, struct DisplaySurface *ds,

                     Error **errp)

{

    int width = pixman_image_get_width(ds->image);

    int height = pixman_image_get_height(ds->image);

    int fd;

    FILE *f;

    int y;

    int ret;

    pixman_image_t *linebuf;

    trace_ppm_save(filename, ds);

    fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);

    if (fd == -1) {

        error_setg(errp, "failed to open file '%s': %s", filename,

                   strerror(errno));

        return;

    }

    f = fdopen(fd, "wb");

    ret = fprintf(f, "P6\n%d %d\n%d\n", width, height, 255);

    if (ret < 0) {

        linebuf = NULL;

        goto write_err;

    }

    linebuf = qemu_pixman_linebuf_create(PIXMAN_BE_r8g8b8, width);

    for (y = 0; y < height; y++) {

        qemu_pixman_linebuf_fill(linebuf, ds->image, width, 0, y);

        clearerr(f);

        ret = fwrite(pixman_image_get_data(linebuf), 1,

                     pixman_image_get_stride(linebuf), f);

        (void)ret;

        if (ferror(f)) {

            goto write_err;

        }

    }

out:

    qemu_pixman_image_unref(linebuf);

    fclose(f);

    return;

write_err:

    error_setg(errp, "failed to write to file '%s': %s", filename,

               strerror(errno));

    unlink(filename);

    goto out;

}

void qmp_screendump(const char *filename, Error **errp)

{

    QemuConsole *con = qemu_console_lookup_by_index(0);

    DisplaySurface *surface;

    if (con == NULL) {

        error_setg(errp, "There is no QemuConsole I can screendump from.");

        return;

    }

    graphic_hw_update(con);

    surface = qemu_console_surface(con);

    ppm_save(filename, surface, errp);

}

void graphic_hw_text_update(QemuConsole *con, console_ch_t *chardata)

{

    if (!con) {

        con = active_console;

    }

    if (con && con->hw_ops->text_update) {

        con->hw_ops->text_update(con->hw, chardata);

    }

}

static void vga_fill_rect(QemuConsole *con,

                          int posx, int posy, int width, int height,

                          pixman_color_t color)

{

    DisplaySurface *surface = qemu_console_surface(con);

    pixman_rectangle16_t rect = {

        .x = posx, .y = posy, .width = width, .height = height

    };

    pixman_image_fill_rectangles(PIXMAN_OP_SRC, surface->image,

                                 &color, 1, &rect);

}

/* copy from (xs, ys) to (xd, yd) a rectangle of size (w, h) */

static void vga_bitblt(QemuConsole *con,

                       int xs, int ys, int xd, int yd, int w, int h)

{

    DisplaySurface *surface = qemu_console_surface(con);

    pixman_image_composite(PIXMAN_OP_SRC,

                           surface->image, NULL, surface->image,

                           xs, ys, 0, 0, xd, yd, w, h);

}

/***********************************************************/

/* basic char display */

#define FONT_HEIGHT 16

#define FONT_WIDTH 8

#include "vgafont.h"

#ifndef CONFIG_CURSES

enum color_names {

    COLOR_BLACK   = 0,

    COLOR_RED     = 1,

    COLOR_GREEN   = 2,

    COLOR_YELLOW  = 3,

    COLOR_BLUE    = 4,

    COLOR_MAGENTA = 5,

    COLOR_CYAN    = 6,

    COLOR_WHITE   = 7

};

#endif

#define QEMU_RGB(r, g, b)                                               \

    { .red = r << 8, .green = g << 8, .blue = b << 8, .alpha = 0xffff }

static const pixman_color_t color_table_rgb[2][8] = {

    {   /* dark */

        QEMU_RGB(0x00, 0x00, 0x00),  /* black */

        QEMU_RGB(0xaa, 0x00, 0x00),  /* red */

        QEMU_RGB(0x00, 0xaa, 0x00),  /* green */

        QEMU_RGB(0xaa, 0xaa, 0x00),  /* yellow */

        QEMU_RGB(0x00, 0x00, 0xaa),  /* blue */

        QEMU_RGB(0xaa, 0x00, 0xaa),  /* magenta */

        QEMU_RGB(0x00, 0xaa, 0xaa),  /* cyan */

        QEMU_RGB(0xaa, 0xaa, 0xaa),  /* white */

    },

    {   /* bright */

        QEMU_RGB(0x00, 0x00, 0x00),  /* black */

        QEMU_RGB(0xff, 0x00, 0x00),  /* red */

        QEMU_RGB(0x00, 0xff, 0x00),  /* green */

        QEMU_RGB(0xff, 0xff, 0x00),  /* yellow */

        QEMU_RGB(0x00, 0x00, 0xff),  /* blue */

        QEMU_RGB(0xff, 0x00, 0xff),  /* magenta */

        QEMU_RGB(0x00, 0xff, 0xff),  /* cyan */

        QEMU_RGB(0xff, 0xff, 0xff),  /* white */

    }

};

static void vga_putcharxy(QemuConsole *s, int x, int y, int ch,

                          TextAttributes *t_attrib)

{

    static pixman_image_t *glyphs[256];

    DisplaySurface *surface = qemu_console_surface(s);

    pixman_color_t fgcol, bgcol;

    if (t_attrib->invers) {

        bgcol = color_table_rgb[t_attrib->bold][t_attrib->fgcol];

        fgcol = color_table_rgb[t_attrib->bold][t_attrib->bgcol];

    } else {

        fgcol = color_table_rgb[t_attrib->bold][t_attrib->fgcol];

        bgcol = color_table_rgb[t_attrib->bold][t_attrib->bgcol];

    }

    if (!glyphs[ch]) {

        glyphs[ch] = qemu_pixman_glyph_from_vgafont(FONT_HEIGHT, vgafont16, ch);

    }

    qemu_pixman_glyph_render(glyphs[ch], surface->image,

                             &fgcol, &bgcol, x, y, FONT_WIDTH, FONT_HEIGHT);

}

static void text_console_resize(QemuConsole *s)

{

    TextCell *cells, *c, *c1;

    int w1, x, y, last_width;

    last_width = s->width;

    s->width = surface_width(s->surface) / FONT_WIDTH;

    s->height = surface_height(s->surface) / FONT_HEIGHT;

    w1 = last_width;

    if (s->width < w1)

        w1 = s->width;

    cells = g_malloc(s->width * s->total_height * sizeof(TextCell));

    for(y = 0; y < s->total_height; y++) {

        c = &cells[y * s->width];

        if (w1 > 0) {

            c1 = &s->cells[y * last_width];

            for(x = 0; x < w1; x++) {

                *c++ = *c1++;

            }

        }

        for(x = w1; x < s->width; x++) {

            c->ch = ' ';

            c->t_attrib = s->t_attrib_default;

            c++;

        }

    }

    g_free(s->cells);

    s->cells = cells;

}

static inline void text_update_xy(QemuConsole *s, int x, int y)

{

    s->text_x[0] = MIN(s->text_x[0], x);

    s->text_x[1] = MAX(s->text_x[1], x);

    s->text_y[0] = MIN(s->text_y[0], y);

    s->text_y[1] = MAX(s->text_y[1], y);

}

static void invalidate_xy(QemuConsole *s, int x, int y)

{

    if (s->update_x0 > x * FONT_WIDTH)

        s->update_x0 = x * FONT_WIDTH;

    if (s->update_y0 > y * FONT_HEIGHT)

        s->update_y0 = y * FONT_HEIGHT;

    if (s->update_x1 < (x + 1) * FONT_WIDTH)

        s->update_x1 = (x + 1) * FONT_WIDTH;

    if (s->update_y1 < (y + 1) * FONT_HEIGHT)

        s->update_y1 = (y + 1) * FONT_HEIGHT;

}

static void update_xy(QemuConsole *s, int x, int y)

{

    TextCell *c;

    int y1, y2;

    if (!qemu_console_is_visible(s)) {

        return;

    }

    if (s->ds->have_text) {

        text_update_xy(s, x, y);

    }

    if (s->ds->have_gfx) {

        y1 = (s->y_base + y) % s->total_height;

        y2 = y1 - s->y_displayed;

        if (y2 < 0)

            y2 += s->total_height;

        if (y2 < s->height) {

            c = &s->cells[y1 * s->width + x];

            vga_putcharxy(s, x, y2, c->ch,

                          &(c->t_attrib));

            invalidate_xy(s, x, y2);

        }

    }

}

static void console_show_cursor(QemuConsole *s, int show)

{

    TextCell *c;

    int y, y1;

    int x = s->x;

    if (!qemu_console_is_visible(s)) {

        return;

    }

    if (s->ds->have_text) {

        s->cursor_invalidate = 1;

    }

    if (s->ds->have_gfx) {

        if (x >= s->width) {

            x = s->width - 1;

        }

        y1 = (s->y_base + s->y) % s->total_height;

        y = y1 - s->y_displayed;

        if (y < 0)

            y += s->total_height;

        if (y < s->height) {

            c = &s->cells[y1 * s->width + x];

            if (show && s->cursor_visible_phase) {

                TextAttributes t_attrib = s->t_attrib_default;

                t_attrib.invers = !(t_attrib.invers); /* invert fg and bg */

                vga_putcharxy(s, x, y, c->ch, &t_attrib);

            } else {

                vga_putcharxy(s, x, y, c->ch, &(c->t_attrib));

            }

            invalidate_xy(s, x, y);

        }

    }

}

static void console_refresh(QemuConsole *s)

{

    DisplaySurface *surface = qemu_console_surface(s);

    TextCell *c;

    int x, y, y1;

    if (!qemu_console_is_visible(s)) {

        return;

    }

    if (s->ds->have_text) {

        s->text_x[0] = 0;

        s->text_y[0] = 0;

        s->text_x[1] = s->width - 1;

        s->text_y[1] = s->height - 1;

        s->cursor_invalidate = 1;

    }

    if (s->ds->have_gfx) {

        vga_fill_rect(s, 0, 0, surface_width(surface), surface_height(surface),

                      color_table_rgb[0][COLOR_BLACK]);

        y1 = s->y_displayed;

        for (y = 0; y < s->height; y++) {

            c = s->cells + y1 * s->width;

            for (x = 0; x < s->width; x++) {

                vga_putcharxy(s, x, y, c->ch,

                              &(c->t_attrib));

                c++;

            }

            if (++y1 == s->total_height) {

                y1 = 0;

            }

        }

        console_show_cursor(s, 1);

        dpy_gfx_update(s, 0, 0,

                       surface_width(surface), surface_height(surface));

    }

}

static void console_scroll(QemuConsole *s, int ydelta)

{

    int i, y1;

    if (ydelta > 0) {

        for(i = 0; i < ydelta; i++) {

            if (s->y_displayed == s->y_base)

                break;

            if (++s->y_displayed == s->total_height)

                s->y_displayed = 0;

        }

    } else {

        ydelta = -ydelta;

        i = s->backscroll_height;

        if (i > s->total_height - s->height)

            i = s->total_height - s->height;

        y1 = s->y_base - i;

        if (y1 < 0)

            y1 += s->total_height;

        for(i = 0; i < ydelta; i++) {

            if (s->y_displayed == y1)

                break;

            if (--s->y_displayed < 0)

                s->y_displayed = s->total_height - 1;

        }

    }

    console_refresh(s);

}

static void console_put_lf(QemuConsole *s)

{

    TextCell *c;

    int x, y1;

    s->y++;

    if (s->y >= s->height) {

        s->y = s->height - 1;

        if (s->y_displayed == s->y_base) {

            if (++s->y_displayed == s->total_height)

                s->y_displayed = 0;

        }

        if (++s->y_base == s->total_height)

            s->y_base = 0;

        if (s->backscroll_height < s->total_height)

            s->backscroll_height++;

        y1 = (s->y_base + s->height - 1) % s->total_height;

        c = &s->cells[y1 * s->width];

        for(x = 0; x < s->width; x++) {

            c->ch = ' ';

            c->t_attrib = s->t_attrib_default;

            c++;

        }

        if (qemu_console_is_visible(s) && s->y_displayed == s->y_base) {

            if (s->ds->have_text) {

                s->text_x[0] = 0;

                s->text_y[0] = 0;

                s->text_x[1] = s->width - 1;

                s->text_y[1] = s->height - 1;

            }

            if (s->ds->have_gfx) {

                vga_bitblt(s, 0, FONT_HEIGHT, 0, 0,

                           s->width * FONT_WIDTH,

                           (s->height - 1) * FONT_HEIGHT);

                vga_fill_rect(s, 0, (s->height - 1) * FONT_HEIGHT,

                              s->width * FONT_WIDTH, FONT_HEIGHT,

                              color_table_rgb[0][s->t_attrib_default.bgcol]);

                s->update_x0 = 0;

                s->update_y0 = 0;

                s->update_x1 = s->width * FONT_WIDTH;

                s->update_y1 = s->height * FONT_HEIGHT;

            }

        }

    }

}

/* Set console attributes depending on the current escape codes.

 * NOTE: I know this code is not very efficient (checking every color for it

 * self) but it is more readable and better maintainable.

 */

static void console_handle_escape(QemuConsole *s)

{

    int i;

    for (i=0; i<s->nb_esc_params; i++) {

        switch (s->esc_params[i]) {

            case 0: /* reset all console attributes to default */

                s->t_attrib = s->t_attrib_default;

                break;

            case 1:

                s->t_attrib.bold = 1;

                break;

            case 4:

                s->t_attrib.uline = 1;

                break;

            case 5:

                s->t_attrib.blink = 1;

                break;

            case 7:

                s->t_attrib.invers = 1;

                break;

            case 8:

                s->t_attrib.unvisible = 1;

                break;

            case 22:

                s->t_attrib.bold = 0;

                break;

            case 24:

                s->t_attrib.uline = 0;

                break;

            case 25:

                s->t_attrib.blink = 0;

                break;

            case 27:

                s->t_attrib.invers = 0;

                break;

            case 28:

                s->t_attrib.unvisible = 0;

                break;

            /* set foreground color */

            case 30:

                s->t_attrib.fgcol=COLOR_BLACK;

                break;

            case 31:

                s->t_attrib.fgcol=COLOR_RED;

                break;

            case 32:

                s->t_attrib.fgcol=COLOR_GREEN;

                break;

            case 33:

                s->t_attrib.fgcol=COLOR_YELLOW;

                break;

            case 34:

                s->t_attrib.fgcol=COLOR_BLUE;

                break;

            case 35:

                s->t_attrib.fgcol=COLOR_MAGENTA;

                break;

            case 36:

                s->t_attrib.fgcol=COLOR_CYAN;

                break;

            case 37:

                s->t_attrib.fgcol=COLOR_WHITE;

                break;

            /* set background color */

            case 40:

                s->t_attrib.bgcol=COLOR_BLACK;

                break;

            case 41:

                s->t_attrib.bgcol=COLOR_RED;

                break;

            case 42:

                s->t_attrib.bgcol=COLOR_GREEN;

                break;

            case 43:

                s->t_attrib.bgcol=COLOR_YELLOW;

                break;

            case 44:

                s->t_attrib.bgcol=COLOR_BLUE;

                break;

            case 45:

                s->t_attrib.bgcol=COLOR_MAGENTA;

                break;

            case 46:

                s->t_attrib.bgcol=COLOR_CYAN;

                break;

            case 47:

                s->t_attrib.bgcol=COLOR_WHITE;

                break;

        }

    }

}

static void console_clear_xy(QemuConsole *s, int x, int y)

{

    int y1 = (s->y_base + y) % s->total_height;

    TextCell *c = &s->cells[y1 * s->width + x];

    c->ch = ' ';

    c->t_attrib = s->t_attrib_default;

    update_xy(s, x, y);

}

/* set cursor, checking bounds */

static void set_cursor(QemuConsole *s, int x, int y)

{

    if (x < 0) {

        x = 0;

    }

    if (y < 0) {

        y = 0;

    }

    if (y >= s->height) {

        y = s->height - 1;

    }

    if (x >= s->width) {

        x = s->width - 1;

    }

    s->x = x;

    s->y = y;

}

static void console_putchar(QemuConsole *s, int ch)

{

    TextCell *c;

    int y1, i;

    int x, y;

    switch(s->state) {

    case TTY_STATE_NORM:

        switch(ch) {

        case '\r':  /* carriage return */

            s->x = 0;

            break;

        case '\n':  /* newline */

            console_put_lf(s);

            break;

        case '\b':  /* backspace */

            if (s->x > 0)

                s->x--;

            break;

        case '\t':  /* tabspace */

            if (s->x + (8 - (s->x % 8)) > s->width) {

                s->x = 0;

                console_put_lf(s);

            } else {

                s->x = s->x + (8 - (s->x % 8));

            }

            break;

        case '\a':  /* alert aka. bell */

            /* TODO: has to be implemented */

            break;

        case 14:

            /* SI (shift in), character set 0 (ignored) */

            break;

        case 15:

            /* SO (shift out), character set 1 (ignored) */

            break;

        case 27:    /* esc (introducing an escape sequence) */

            s->state = TTY_STATE_ESC;

            break;

        default:

            if (s->x >= s->width) {

                /* line wrap */

                s->x = 0;

                console_put_lf(s);

            }

            y1 = (s->y_base + s->y) % s->total_height;

            c = &s->cells[y1 * s->width + s->x];

            c->ch = ch;

            c->t_attrib = s->t_attrib;

            update_xy(s, s->x, s->y);

            s->x++;

            break;

        }

        break;

    case TTY_STATE_ESC: /* check if it is a terminal escape sequence */

        if (ch == '[') {

            for(i=0;i<MAX_ESC_PARAMS;i++)

                s->esc_params[i] = 0;

            s->nb_esc_params = 0;

            s->state = TTY_STATE_CSI;

        } else {

            s->state = TTY_STATE_NORM;

        }

        break;

    case TTY_STATE_CSI: /* handle escape sequence parameters */

        if (ch >= '0' && ch <= '9') {

            if (s->nb_esc_params < MAX_ESC_PARAMS) {

                int *param = &s->esc_params[s->nb_esc_params];

                int digit = (ch - '0');

                *param = (*param <= (INT_MAX - digit) / 10) ?

                         *param * 10 + digit : INT_MAX;

            }

        } else {

            if (s->nb_esc_params < MAX_ESC_PARAMS)

                s->nb_esc_params++;

            if (ch == ';')

                break;

            trace_console_putchar_csi(s->esc_params[0], s->esc_params[1],

                                      ch, s->nb_esc_params);

            s->state = TTY_STATE_NORM;

            switch(ch) {

            case 'A':

                /* move cursor up */

                if (s->esc_params[0] == 0) {

                    s->esc_params[0] = 1;

                }

                set_cursor(s, s->x, s->y - s->esc_params[0]);

                break;

            case 'B':

                /* move cursor down */

                if (s->esc_params[0] == 0) {

                    s->esc_params[0] = 1;

                }

                set_cursor(s, s->x, s->y + s->esc_params[0]);

                break;

            case 'C':

                /* move cursor right */

                if (s->esc_params[0] == 0) {

                    s->esc_params[0] = 1;

                }

                set_cursor(s, s->x + s->esc_params[0], s->y);

                break;

            case 'D':

                /* move cursor left */

                if (s->esc_params[0] == 0) {