}    ssp.speed = speed;    ssp.parity = parity;    ssp.data_bits = data_bits;    ssp.stop_bits = stop_bits;    SER_DPRINTF("channel %c: speed=%d parity=%c data=%d stop=%d\n", CHN_C(s),                speed, parity, data_bits, stop_bits);    qemu_chr_ioctl(s->chr, CHR_IOCTL_SERIAL_SET_PARAMS, &ssp);}static void slavio_serial_mem_writeb(void *opaque, target_phys_addr_t addr,                                     uint32_t val){    SerialState *serial = opaque;    ChannelState *s;    uint32_t saddr;    int newreg, channel;    val &= 0xff;    saddr = (addr & 3) >> 1;    channel = (addr & SERIAL_MAXADDR) >> 2;    s = &serial->chn[channel];    switch (saddr) {    case SERIAL_CTRL:        SER_DPRINTF("Write channel %c, reg[%d] = %2.2x\n", CHN_C(s), s->reg,                    val & 0xff);        newreg = 0;        switch (s->reg) {        case W_CMD:            newreg = val & CMD_PTR_MASK;            val &= CMD_CMD_MASK;            switch (val) {            case CMD_HI:                newreg |= CMD_HI;                break;            case CMD_CLR_TXINT:                clr_txint(s);                break;            case CMD_CLR_IUS:                if (s->rxint_under_svc)                    clr_rxint(s);                else if (s->txint_under_svc)                    clr_txint(s);                break;            default:                break;            }            break;        case W_INTR ... W_RXCTRL:        case W_SYNC1 ... W_TXBUF:        case W_MISC1 ... W_CLOCK:        case W_MISC2 ... W_EXTINT:            s->wregs[s->reg] = val;            break;        case W_TXCTRL1:        case W_TXCTRL2:        case W_BRGLO:        case W_BRGHI:            s->wregs[s->reg] = val;            slavio_serial_update_parameters(s);            break;        case W_MINTR:            switch (val & MINTR_RST_MASK) {            case 0:            default:                break;            case MINTR_RST_B:                slavio_serial_reset_chn(&serial->chn[1]);                return;            case MINTR_RST_A:                slavio_serial_reset_chn(&serial->chn[0]);                return;            case MINTR_RST_ALL:                slavio_serial_reset(serial);                return;            }            break;        default:            break;        }        if (s->reg == 0)            s->reg = newreg;        else            s->reg = 0;        break;    case SERIAL_DATA:        SER_DPRINTF("Write channel %c, ch %d\n", CHN_C(s), val);        s->tx = val;        if (s->wregs[W_TXCTRL2] & TXCTRL2_TXEN) { // tx enabled            if (s->chr)                qemu_chr_write(s->chr, &s->tx, 1);            else if (s->type == kbd && !s->disabled) {                handle_kbd_command(s, val);            }        }        s->rregs[R_STATUS] |= STATUS_TXEMPTY; // Tx buffer empty        s->rregs[R_SPEC] |= SPEC_ALLSENT; // All sent        set_txint(s);        break;    default:        break;    }}static uint32_t slavio_serial_mem_readb(void *opaque, target_phys_addr_t addr){    SerialState *serial = opaque;    ChannelState *s;    uint32_t saddr;    uint32_t ret;    int channel;    saddr = (addr & 3) >> 1;    channel = (addr & SERIAL_MAXADDR) >> 2;    s = &serial->chn[channel];    switch (saddr) {    case SERIAL_CTRL:        SER_DPRINTF("Read channel %c, reg[%d] = %2.2x\n", CHN_C(s), s->reg,                    s->rregs[s->reg]);        ret = s->rregs[s->reg];        s->reg = 0;        return ret;    case SERIAL_DATA:        s->rregs[R_STATUS] &= ~STATUS_RXAV;        clr_rxint(s);        if (s->type == kbd || s->type == mouse)            ret = get_queue(s);        else            ret = s->rx;        SER_DPRINTF("Read channel %c, ch %d\n", CHN_C(s), ret);        if (s->chr)            qemu_chr_accept_input(s->chr);        return ret;    default:        break;    }    return 0;}static int serial_can_receive(void *opaque){    ChannelState *s = opaque;    int ret;    if (((s->wregs[W_RXCTRL] & RXCTRL_RXEN) == 0) // Rx not enabled        || ((s->rregs[R_STATUS] & STATUS_RXAV) == STATUS_RXAV))        // char already available        ret = 0;    else        ret = 1;    return ret;}static void serial_receive_byte(ChannelState *s, int ch){    SER_DPRINTF("channel %c put ch %d\n", CHN_C(s), ch);    s->rregs[R_STATUS] |= STATUS_RXAV;    s->rx = ch;    set_rxint(s);}static void serial_receive_break(ChannelState *s){    s->rregs[R_STATUS] |= STATUS_BRK;    slavio_serial_update_irq(s);}static void serial_receive1(void *opaque, const uint8_t *buf, int size){    ChannelState *s = opaque;    serial_receive_byte(s, buf[0]);}static void serial_event(void *opaque, int event){    ChannelState *s = opaque;    if (event == CHR_EVENT_BREAK)        serial_receive_break(s);}static CPUReadMemoryFunc *slavio_serial_mem_read[3] = {    slavio_serial_mem_readb,    NULL,    NULL,};static CPUWriteMemoryFunc *slavio_serial_mem_write[3] = {    slavio_serial_mem_writeb,    NULL,    NULL,};static void slavio_serial_save_chn(QEMUFile *f, ChannelState *s){    int tmp;    tmp = 0;    qemu_put_be32s(f, &tmp); /* unused, was IRQ.  */    qemu_put_be32s(f, &s->reg);    qemu_put_be32s(f, &s->rxint);    qemu_put_be32s(f, &s->txint);    qemu_put_be32s(f, &s->rxint_under_svc);    qemu_put_be32s(f, &s->txint_under_svc);    qemu_put_8s(f, &s->rx);    qemu_put_8s(f, &s->tx);    qemu_put_buffer(f, s->wregs, SERIAL_REGS);    qemu_put_buffer(f, s->rregs, SERIAL_REGS);}static void slavio_serial_save(QEMUFile *f, void *opaque){    SerialState *s = opaque;    slavio_serial_save_chn(f, &s->chn[0]);    slavio_serial_save_chn(f, &s->chn[1]);}static int slavio_serial_load_chn(QEMUFile *f, ChannelState *s, int version_id){    int tmp;    if (version_id > 2)        return -EINVAL;    qemu_get_be32s(f, &tmp); /* unused */    qemu_get_be32s(f, &s->reg);    qemu_get_be32s(f, &s->rxint);    qemu_get_be32s(f, &s->txint);    if (version_id >= 2) {        qemu_get_be32s(f, &s->rxint_under_svc);        qemu_get_be32s(f, &s->txint_under_svc);    }    qemu_get_8s(f, &s->rx);    qemu_get_8s(f, &s->tx);    qemu_get_buffer(f, s->wregs, SERIAL_REGS);    qemu_get_buffer(f, s->rregs, SERIAL_REGS);    return 0;}static int slavio_serial_load(QEMUFile *f, void *opaque, int version_id){    SerialState *s = opaque;    int ret;    ret = slavio_serial_load_chn(f, &s->chn[0], version_id);    if (ret != 0)        return ret;    ret = slavio_serial_load_chn(f, &s->chn[1], version_id);    return ret;}SerialState *slavio_serial_init(target_phys_addr_t base, qemu_irq irq,                                CharDriverState *chr1, CharDriverState *chr2){    int slavio_serial_io_memory, i;    SerialState *s;    s = qemu_mallocz(sizeof(SerialState));    if (!s)        return NULL;    slavio_serial_io_memory = cpu_register_io_memory(0, slavio_serial_mem_read,                                                     slavio_serial_mem_write,                                                     s);    cpu_register_physical_memory(base, SERIAL_SIZE, slavio_serial_io_memory);    s->chn[0].chr = chr1;    s->chn[1].chr = chr2;    s->chn[0].disabled = 0;    s->chn[1].disabled = 0;    for (i = 0; i < 2; i++) {        s->chn[i].irq = irq;        s->chn[i].chn = 1 - i;        s->chn[i].type = ser;        if (s->chn[i].chr) {            qemu_chr_add_handlers(s->chn[i].chr, serial_can_receive,                                  serial_receive1, serial_event, &s->chn[i]);        }    }    s->chn[0].otherchn = &s->chn[1];    s->chn[1].otherchn = &s->chn[0];    register_savevm("slavio_serial", base, 2, slavio_serial_save,                    slavio_serial_load, s);    qemu_register_reset(slavio_serial_reset, s);    slavio_serial_reset(s);    return s;}static const uint8_t keycodes[128] = {    127, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 43, 53,    54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 89, 76, 77, 78,    79, 80, 81, 82, 83, 84, 85, 86, 87, 42, 99, 88, 100, 101, 102, 103,    104, 105, 106, 107, 108, 109, 110, 47, 19, 121, 119, 5, 6, 8, 10, 12,    14, 16, 17, 18, 7, 98, 23, 68, 69, 70, 71, 91, 92, 93, 125, 112,    113, 114, 94, 50, 0, 0, 124, 9, 11, 0, 0, 0, 0, 0, 0, 0,    90, 0, 46, 22, 13, 111, 52, 20, 96, 24, 28, 74, 27, 123, 44, 66,    0, 45, 2, 4, 48, 0, 0, 21, 0, 0, 0, 0, 0, 120, 122, 67,};static const uint8_t e0_keycodes[128] = {    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 90, 76, 0, 0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    0, 0, 0, 0, 0, 109, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0,    0, 0, 0, 0, 0, 0, 0, 68, 69, 70, 0, 91, 0, 93, 0, 112,    113, 114, 94, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,};static void sunkbd_event(void *opaque, int ch){    ChannelState *s = opaque;    int release = ch & 0x80;    KBD_DPRINTF("Untranslated keycode %2.2x (%s)\n", ch, release? "release" :                "press");    switch (ch) {    case 58: // Caps lock press        s->caps_lock_mode ^= 1;        if (s->caps_lock_mode == 2)            return; // Drop second press        break;    case 69: // Num lock press        s->num_lock_mode ^= 1;        if (s->num_lock_mode == 2)            return; // Drop second press        break;    case 186: // Caps lock release        s->caps_lock_mode ^= 2;        if (s->caps_lock_mode == 3)            return; // Drop first release        break;    case 197: // Num lock release        s->num_lock_mode ^= 2;        if (s->num_lock_mode == 3)            return; // Drop first release        break;    case 0xe0:        s->e0_mode = 1;        return;    default:        break;    }    if (s->e0_mode) {        s->e0_mode = 0;        ch = e0_keycodes[ch & 0x7f];    } else {        ch = keycodes[ch & 0x7f];    }    KBD_DPRINTF("Translated keycode %2.2x\n", ch);    put_queue(s, ch | release);}static void handle_kbd_command(ChannelState *s, int val){    KBD_DPRINTF("Command %d\n", val);    if (s->led_mode) { // Ignore led byte        s->led_mode = 0;        return;    }    switch (val) {    case 1: // Reset, return type code        clear_queue(s);        put_queue(s, 0xff);        put_queue(s, 4); // Type 4        put_queue(s, 0x7f);        break;    case 0xe: // Set leds        s->led_mode = 1;        break;    case 7: // Query layout    case 0xf:        clear_queue(s);        put_queue(s, 0xfe);        put_queue(s, 0); // XXX, layout?        break;    default:        break;    }}static void sunmouse_event(void *opaque,                               int dx, int dy, int dz, int buttons_state){    ChannelState *s = opaque;    int ch;    MS_DPRINTF("dx=%d dy=%d buttons=%01x\n", dx, dy, buttons_state);    ch = 0x80 | 0x7; /* protocol start byte, no buttons pressed */    if (buttons_state & MOUSE_EVENT_LBUTTON)        ch ^= 0x4;    if (buttons_state & MOUSE_EVENT_MBUTTON)        ch ^= 0x2;    if (buttons_state & MOUSE_EVENT_RBUTTON)        ch ^= 0x1;    put_queue(s, ch);    ch = dx;    if (ch > 127)        ch=127;    else if (ch < -127)        ch=-127;    put_queue(s, ch & 0xff);    ch = -dy;    if (ch > 127)        ch=127;    else if (ch < -127)        ch=-127;    put_queue(s, ch & 0xff);    // MSC protocol specify two extra motion bytes    put_queue(s, 0);    put_queue(s, 0);}void slavio_serial_ms_kbd_init(target_phys_addr_t base, qemu_irq irq,                               int disabled){    int slavio_serial_io_memory, i;    SerialState *s;    s = qemu_mallocz(sizeof(SerialState));    if (!s)        return;    for (i = 0; i < 2; i++) {        s->chn[i].irq = irq;        s->chn[i].chn = 1 - i;        s->chn[i].chr = NULL;    }    s->chn[0].otherchn = &s->chn[1];    s->chn[1].otherchn = &s->chn[0];    s->chn[0].type = mouse;    s->chn[1].type = kbd;    s->chn[0].disabled = disabled;    s->chn[1].disabled = disabled;    slavio_serial_io_memory = cpu_register_io_memory(0, slavio_serial_mem_read,                                                     slavio_serial_mem_write,                                                     s);    cpu_register_physical_memory(base, SERIAL_SIZE, slavio_serial_io_memory);    qemu_add_mouse_event_handler(sunmouse_event, &s->chn[0], 0,                                 "QEMU Sun Mouse");    qemu_add_kbd_event_handler(sunkbd_event, &s->chn[1]);    register_savevm("slavio_serial_mouse", base, 2, slavio_serial_save,                    slavio_serial_load, s);    qemu_register_reset(slavio_serial_reset, s);    slavio_serial_reset(s);}