2 * QEMU Sparc SLAVIO serial port emulation
4 * Copyright (c) 2003-2005 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
26 //#define DEBUG_SERIAL
35 * This is the serial port, mouse and keyboard part of chip STP2001
36 * (Slave I/O), also produced as NCR89C105. See
37 * http://www.ibiblio.org/pub/historic-linux/early-ports/Sparc/NCR/NCR89C105.txt
39 * The serial ports implement full AMD AM8530 or Zilog Z8530 chips,
40 * mouse and keyboard ports don't implement all functions and they are
41 * only asynchronous. There is no DMA.
47 * 2006-Aug-10 Igor Kovalenko : Renamed KBDQueue to SERIOQueue, implemented
49 * Implemented serial mouse protocol.
53 #define SER_DPRINTF(fmt, args...) \
54 do { printf("SER: " fmt , ##args); } while (0)
55 #define pic_set_irq(irq, level) \
56 do { printf("SER: set_irq(%d): %d\n", (irq), (level)); pic_set_irq((irq),(level));} while (0)
58 #define SER_DPRINTF(fmt, args...)
61 #define KBD_DPRINTF(fmt, args...) \
62 do { printf("KBD: " fmt , ##args); } while (0)
64 #define KBD_DPRINTF(fmt, args...)
67 #define MS_DPRINTF(fmt, args...) \
68 do { printf("MSC: " fmt , ##args); } while (0)
70 #define MS_DPRINTF(fmt, args...)
81 #define SERIO_QUEUE_SIZE 256
84 uint8_t data[SERIO_QUEUE_SIZE];
85 int rptr, wptr, count;
88 typedef struct ChannelState {
91 int rxint, txint, rxint_under_svc, txint_under_svc;
92 chn_id_t chn; // this channel, A (base+4) or B (base+0)
94 struct ChannelState *otherchn;
95 uint8_t rx, tx, wregs[16], rregs[16];
101 struct ChannelState chn[2];
104 #define SERIAL_MAXADDR 7
106 static void handle_kbd_command(ChannelState *s, int val);
107 static int serial_can_receive(void *opaque);
108 static void serial_receive_byte(ChannelState *s, int ch);
109 static inline void set_txint(ChannelState *s);
111 static void put_queue(void *opaque, int b)
113 ChannelState *s = opaque;
114 SERIOQueue *q = &s->queue;
116 SER_DPRINTF("put: 0x%02x\n", b);
117 if (q->count >= SERIO_QUEUE_SIZE)
119 q->data[q->wptr] = b;
120 if (++q->wptr == SERIO_QUEUE_SIZE)
123 serial_receive_byte(s, 0);
126 static uint32_t get_queue(void *opaque)
128 ChannelState *s = opaque;
129 SERIOQueue *q = &s->queue;
135 val = q->data[q->rptr];
136 if (++q->rptr == SERIO_QUEUE_SIZE)
140 KBD_DPRINTF("get 0x%02x\n", val);
142 serial_receive_byte(s, 0);
146 static int slavio_serial_update_irq_chn(ChannelState *s)
148 if ((s->wregs[1] & 1) && // interrupts enabled
149 (((s->wregs[1] & 2) && s->txint == 1) || // tx ints enabled, pending
150 ((((s->wregs[1] & 0x18) == 8) || ((s->wregs[1] & 0x18) == 0x10)) &&
151 s->rxint == 1) || // rx ints enabled, pending
152 ((s->wregs[15] & 0x80) && (s->rregs[0] & 0x80)))) { // break int e&p
158 static void slavio_serial_update_irq(ChannelState *s)
162 irq = slavio_serial_update_irq_chn(s);
163 irq |= slavio_serial_update_irq_chn(s->otherchn);
165 pic_set_irq(s->irq, irq);
168 static void slavio_serial_reset_chn(ChannelState *s)
173 for (i = 0; i < SERIAL_MAXADDR; i++) {
186 s->rxint = s->txint = 0;
187 s->rxint_under_svc = s->txint_under_svc = 0;
190 static void slavio_serial_reset(void *opaque)
192 SerialState *s = opaque;
193 slavio_serial_reset_chn(&s->chn[0]);
194 slavio_serial_reset_chn(&s->chn[1]);
197 static inline void clr_rxint(ChannelState *s)
200 s->rxint_under_svc = 0;
202 s->rregs[3] &= ~0x20;
204 s->otherchn->rregs[3] &= ~4;
210 slavio_serial_update_irq(s);
213 static inline void set_rxint(ChannelState *s)
216 if (!s->txint_under_svc) {
217 s->rxint_under_svc = 1;
221 s->otherchn->rregs[3] |= 4;
224 slavio_serial_update_irq(s);
228 static inline void clr_txint(ChannelState *s)
231 s->txint_under_svc = 0;
233 s->rregs[3] &= ~0x10;
235 s->otherchn->rregs[3] &= ~2;
241 slavio_serial_update_irq(s);
244 static inline void set_txint(ChannelState *s)
247 if (!s->rxint_under_svc) {
248 s->txint_under_svc = 1;
252 s->otherchn->rregs[3] |= 2;
255 slavio_serial_update_irq(s);
259 static void slavio_serial_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
261 SerialState *ser = opaque;
267 saddr = (addr & 3) >> 1;
268 channel = (addr & SERIAL_MAXADDR) >> 2;
269 s = &ser->chn[channel];
272 SER_DPRINTF("Write channel %c, reg[%d] = %2.2x\n", channel? 'b' : 'a', s->reg, val & 0xff);
286 if (s->rxint_under_svc)
288 else if (s->txint_under_svc)
297 s->wregs[s->reg] = val;
300 switch (val & 0xc0) {
305 slavio_serial_reset_chn(&ser->chn[1]);
308 slavio_serial_reset_chn(&ser->chn[0]);
311 slavio_serial_reset(ser);
324 SER_DPRINTF("Write channel %c, ch %d\n", channel? 'b' : 'a', val);
325 if (s->wregs[5] & 8) { // tx enabled
328 qemu_chr_write(s->chr, &s->tx, 1);
329 else if (s->type == kbd) {
330 handle_kbd_command(s, val);
332 s->rregs[0] |= 4; // Tx buffer empty
333 s->rregs[1] |= 1; // All sent
342 static uint32_t slavio_serial_mem_readb(void *opaque, target_phys_addr_t addr)
344 SerialState *ser = opaque;
350 saddr = (addr & 3) >> 1;
351 channel = (addr & SERIAL_MAXADDR) >> 2;
352 s = &ser->chn[channel];
355 SER_DPRINTF("Read channel %c, reg[%d] = %2.2x\n", channel? 'b' : 'a', s->reg, s->rregs[s->reg]);
356 ret = s->rregs[s->reg];
362 if (s->type == kbd || s->type == mouse)
366 SER_DPRINTF("Read channel %c, ch %d\n", channel? 'b' : 'a', ret);
374 static int serial_can_receive(void *opaque)
376 ChannelState *s = opaque;
379 if (((s->wregs[3] & 1) == 0) // Rx not enabled
380 || ((s->rregs[0] & 1) == 1)) // char already available
384 SER_DPRINTF("can receive %d\n", ret);
388 static void serial_receive_byte(ChannelState *s, int ch)
390 SER_DPRINTF("put ch %d\n", ch);
396 static void serial_receive_break(ChannelState *s)
399 slavio_serial_update_irq(s);
402 static void serial_receive1(void *opaque, const uint8_t *buf, int size)
404 ChannelState *s = opaque;
405 serial_receive_byte(s, buf[0]);
408 static void serial_event(void *opaque, int event)
410 ChannelState *s = opaque;
411 if (event == CHR_EVENT_BREAK)
412 serial_receive_break(s);
415 static CPUReadMemoryFunc *slavio_serial_mem_read[3] = {
416 slavio_serial_mem_readb,
417 slavio_serial_mem_readb,
418 slavio_serial_mem_readb,
421 static CPUWriteMemoryFunc *slavio_serial_mem_write[3] = {
422 slavio_serial_mem_writeb,
423 slavio_serial_mem_writeb,
424 slavio_serial_mem_writeb,
427 static void slavio_serial_save_chn(QEMUFile *f, ChannelState *s)
429 qemu_put_be32s(f, &s->irq);
430 qemu_put_be32s(f, &s->reg);
431 qemu_put_be32s(f, &s->rxint);
432 qemu_put_be32s(f, &s->txint);
433 qemu_put_be32s(f, &s->rxint_under_svc);
434 qemu_put_be32s(f, &s->txint_under_svc);
435 qemu_put_8s(f, &s->rx);
436 qemu_put_8s(f, &s->tx);
437 qemu_put_buffer(f, s->wregs, 16);
438 qemu_put_buffer(f, s->rregs, 16);
441 static void slavio_serial_save(QEMUFile *f, void *opaque)
443 SerialState *s = opaque;
445 slavio_serial_save_chn(f, &s->chn[0]);
446 slavio_serial_save_chn(f, &s->chn[1]);
449 static int slavio_serial_load_chn(QEMUFile *f, ChannelState *s, int version_id)
454 qemu_get_be32s(f, &s->irq);
455 qemu_get_be32s(f, &s->reg);
456 qemu_get_be32s(f, &s->rxint);
457 qemu_get_be32s(f, &s->txint);
458 if (version_id >= 2) {
459 qemu_get_be32s(f, &s->rxint_under_svc);
460 qemu_get_be32s(f, &s->txint_under_svc);
462 qemu_get_8s(f, &s->rx);
463 qemu_get_8s(f, &s->tx);
464 qemu_get_buffer(f, s->wregs, 16);
465 qemu_get_buffer(f, s->rregs, 16);
469 static int slavio_serial_load(QEMUFile *f, void *opaque, int version_id)
471 SerialState *s = opaque;
474 ret = slavio_serial_load_chn(f, &s->chn[0], version_id);
477 ret = slavio_serial_load_chn(f, &s->chn[1], version_id);
482 SerialState *slavio_serial_init(int base, int irq, CharDriverState *chr1, CharDriverState *chr2)
484 int slavio_serial_io_memory, i;
487 s = qemu_mallocz(sizeof(SerialState));
491 slavio_serial_io_memory = cpu_register_io_memory(0, slavio_serial_mem_read, slavio_serial_mem_write, s);
492 cpu_register_physical_memory(base, SERIAL_MAXADDR, slavio_serial_io_memory);
494 s->chn[0].chr = chr1;
495 s->chn[1].chr = chr2;
497 for (i = 0; i < 2; i++) {
499 s->chn[i].chn = 1 - i;
500 s->chn[i].type = ser;
502 qemu_chr_add_read_handler(s->chn[i].chr, serial_can_receive, serial_receive1, &s->chn[i]);
503 qemu_chr_add_event_handler(s->chn[i].chr, serial_event);
506 s->chn[0].otherchn = &s->chn[1];
507 s->chn[1].otherchn = &s->chn[0];
508 register_savevm("slavio_serial", base, 2, slavio_serial_save, slavio_serial_load, s);
509 qemu_register_reset(slavio_serial_reset, s);
510 slavio_serial_reset(s);
514 static const uint8_t keycodes[128] = {
515 127, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 43, 53,
516 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 89, 76, 77, 78,
517 79, 80, 81, 82, 83, 84, 85, 86, 87, 42, 99, 88, 100, 101, 102, 103,
518 104, 105, 106, 107, 108, 109, 110, 47, 19, 121, 119, 5, 6, 8, 10, 12,
519 14, 16, 17, 18, 7, 98, 23, 68, 69, 70, 71, 91, 92, 93, 125, 112,
520 113, 114, 94, 50, 0, 0, 124, 9, 11, 0, 0, 0, 0, 0, 0, 0,
521 90, 0, 46, 22, 13, 111, 52, 20, 96, 24, 28, 74, 27, 123, 44, 66,
522 0, 45, 2, 4, 48, 0, 0, 21, 0, 0, 0, 0, 0, 120, 122, 67,
525 static void sunkbd_event(void *opaque, int ch)
527 ChannelState *s = opaque;
528 int release = ch & 0x80;
530 ch = keycodes[ch & 0x7f];
531 KBD_DPRINTF("Keycode %d (%s)\n", ch, release? "release" : "press");
532 put_queue(s, ch | release);
535 static void handle_kbd_command(ChannelState *s, int val)
537 KBD_DPRINTF("Command %d\n", val);
539 case 1: // Reset, return type code
541 put_queue(s, 5); // Type 5
543 case 7: // Query layout
545 put_queue(s, 0x20); // XXX, layout?
552 static void sunmouse_event(void *opaque,
553 int dx, int dy, int dz, int buttons_state)
555 ChannelState *s = opaque;
558 /* XXX: SDL sometimes generates nul events: we delete them */
559 if (dx == 0 && dy == 0 && dz == 0 && buttons_state == 0)
561 MS_DPRINTF("dx=%d dy=%d buttons=%01x\n", dx, dy, buttons_state);
563 ch = 0x80 | 0x7; /* protocol start byte, no buttons pressed */
565 if (buttons_state & MOUSE_EVENT_LBUTTON)
567 if (buttons_state & MOUSE_EVENT_MBUTTON)
569 if (buttons_state & MOUSE_EVENT_RBUTTON)
581 put_queue(s, ch & 0xff);
590 put_queue(s, ch & 0xff);
592 // MSC protocol specify two extra motion bytes
598 void slavio_serial_ms_kbd_init(int base, int irq)
600 int slavio_serial_io_memory, i;
603 s = qemu_mallocz(sizeof(SerialState));
606 for (i = 0; i < 2; i++) {
608 s->chn[i].chn = 1 - i;
609 s->chn[i].chr = NULL;
611 s->chn[0].otherchn = &s->chn[1];
612 s->chn[1].otherchn = &s->chn[0];
613 s->chn[0].type = mouse;
614 s->chn[1].type = kbd;
616 slavio_serial_io_memory = cpu_register_io_memory(0, slavio_serial_mem_read, slavio_serial_mem_write, s);
617 cpu_register_physical_memory(base, SERIAL_MAXADDR, slavio_serial_io_memory);
619 qemu_add_mouse_event_handler(sunmouse_event, &s->chn[0], 0);
620 qemu_add_kbd_event_handler(sunkbd_event, &s->chn[1]);
621 qemu_register_reset(slavio_serial_reset, s);
622 slavio_serial_reset(s);