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 #include "qemu-char.h"
30 //#define DEBUG_SERIAL
39 * This is the serial port, mouse and keyboard part of chip STP2001
40 * (Slave I/O), also produced as NCR89C105. See
41 * http://www.ibiblio.org/pub/historic-linux/early-ports/Sparc/NCR/NCR89C105.txt
43 * The serial ports implement full AMD AM8530 or Zilog Z8530 chips,
44 * mouse and keyboard ports don't implement all functions and they are
45 * only asynchronous. There is no DMA.
51 * 2006-Aug-10 Igor Kovalenko : Renamed KBDQueue to SERIOQueue, implemented
53 * Implemented serial mouse protocol.
57 #define SER_DPRINTF(fmt, args...) \
58 do { printf("SER: " fmt , ##args); } while (0)
60 #define SER_DPRINTF(fmt, args...)
63 #define KBD_DPRINTF(fmt, args...) \
64 do { printf("KBD: " fmt , ##args); } while (0)
66 #define KBD_DPRINTF(fmt, args...)
69 #define MS_DPRINTF(fmt, args...) \
70 do { printf("MSC: " fmt , ##args); } while (0)
72 #define MS_DPRINTF(fmt, args...)
79 #define CHN_C(s) ((s)->chn == chn_b? 'b' : 'a')
85 #define SERIO_QUEUE_SIZE 256
88 uint8_t data
[SERIO_QUEUE_SIZE
];
89 int rptr
, wptr
, count
;
92 typedef struct ChannelState
{
95 int rxint
, txint
, rxint_under_svc
, txint_under_svc
;
96 chn_id_t chn
; // this channel, A (base+4) or B (base+0)
98 struct ChannelState
*otherchn
;
99 uint8_t rx
, tx
, wregs
[16], rregs
[16];
101 CharDriverState
*chr
;
102 int e0_mode
, led_mode
, caps_lock_mode
, num_lock_mode
;
106 struct ChannelState chn
[2];
109 #define SERIAL_MAXADDR 7
110 #define SERIAL_SIZE (SERIAL_MAXADDR + 1)
112 static void handle_kbd_command(ChannelState
*s
, int val
);
113 static int serial_can_receive(void *opaque
);
114 static void serial_receive_byte(ChannelState
*s
, int ch
);
115 static inline void set_txint(ChannelState
*s
);
117 static void clear_queue(void *opaque
)
119 ChannelState
*s
= opaque
;
120 SERIOQueue
*q
= &s
->queue
;
121 q
->rptr
= q
->wptr
= q
->count
= 0;
124 static void put_queue(void *opaque
, int b
)
126 ChannelState
*s
= opaque
;
127 SERIOQueue
*q
= &s
->queue
;
129 SER_DPRINTF("channel %c put: 0x%02x\n", CHN_C(s
), b
);
130 if (q
->count
>= SERIO_QUEUE_SIZE
)
132 q
->data
[q
->wptr
] = b
;
133 if (++q
->wptr
== SERIO_QUEUE_SIZE
)
136 serial_receive_byte(s
, 0);
139 static uint32_t get_queue(void *opaque
)
141 ChannelState
*s
= opaque
;
142 SERIOQueue
*q
= &s
->queue
;
148 val
= q
->data
[q
->rptr
];
149 if (++q
->rptr
== SERIO_QUEUE_SIZE
)
153 SER_DPRINTF("channel %c get 0x%02x\n", CHN_C(s
), val
);
155 serial_receive_byte(s
, 0);
159 static int slavio_serial_update_irq_chn(ChannelState
*s
)
161 if ((s
->wregs
[1] & 1) && // interrupts enabled
162 (((s
->wregs
[1] & 2) && s
->txint
== 1) || // tx ints enabled, pending
163 ((((s
->wregs
[1] & 0x18) == 8) || ((s
->wregs
[1] & 0x18) == 0x10)) &&
164 s
->rxint
== 1) || // rx ints enabled, pending
165 ((s
->wregs
[15] & 0x80) && (s
->rregs
[0] & 0x80)))) { // break int e&p
171 static void slavio_serial_update_irq(ChannelState
*s
)
175 irq
= slavio_serial_update_irq_chn(s
);
176 irq
|= slavio_serial_update_irq_chn(s
->otherchn
);
178 SER_DPRINTF("IRQ = %d\n", irq
);
179 qemu_set_irq(s
->irq
, irq
);
182 static void slavio_serial_reset_chn(ChannelState
*s
)
187 for (i
= 0; i
< SERIAL_SIZE
; i
++) {
200 s
->rxint
= s
->txint
= 0;
201 s
->rxint_under_svc
= s
->txint_under_svc
= 0;
202 s
->e0_mode
= s
->led_mode
= s
->caps_lock_mode
= s
->num_lock_mode
= 0;
206 static void slavio_serial_reset(void *opaque
)
208 SerialState
*s
= opaque
;
209 slavio_serial_reset_chn(&s
->chn
[0]);
210 slavio_serial_reset_chn(&s
->chn
[1]);
213 static inline void clr_rxint(ChannelState
*s
)
216 s
->rxint_under_svc
= 0;
217 if (s
->chn
== chn_a
) {
218 if (s
->wregs
[9] & 0x10)
219 s
->otherchn
->rregs
[2] = 0x60;
221 s
->otherchn
->rregs
[2] = 0x06;
222 s
->rregs
[3] &= ~0x20;
224 if (s
->wregs
[9] & 0x10)
228 s
->otherchn
->rregs
[3] &= ~4;
232 slavio_serial_update_irq(s
);
235 static inline void set_rxint(ChannelState
*s
)
238 if (!s
->txint_under_svc
) {
239 s
->rxint_under_svc
= 1;
240 if (s
->chn
== chn_a
) {
241 if (s
->wregs
[9] & 0x10)
242 s
->otherchn
->rregs
[2] = 0x30;
244 s
->otherchn
->rregs
[2] = 0x0c;
246 if (s
->wregs
[9] & 0x10)
255 s
->otherchn
->rregs
[3] |= 4;
256 slavio_serial_update_irq(s
);
259 static inline void clr_txint(ChannelState
*s
)
262 s
->txint_under_svc
= 0;
263 if (s
->chn
== chn_a
) {
264 if (s
->wregs
[9] & 0x10)
265 s
->otherchn
->rregs
[2] = 0x60;
267 s
->otherchn
->rregs
[2] = 0x06;
268 s
->rregs
[3] &= ~0x10;
270 if (s
->wregs
[9] & 0x10)
274 s
->otherchn
->rregs
[3] &= ~2;
278 slavio_serial_update_irq(s
);
281 static inline void set_txint(ChannelState
*s
)
284 if (!s
->rxint_under_svc
) {
285 s
->txint_under_svc
= 1;
286 if (s
->chn
== chn_a
) {
287 if (s
->wregs
[9] & 0x10)
288 s
->otherchn
->rregs
[2] = 0x10;
290 s
->otherchn
->rregs
[2] = 0x08;
298 s
->otherchn
->rregs
[3] |= 2;
299 slavio_serial_update_irq(s
);
302 static void slavio_serial_update_parameters(ChannelState
*s
)
304 int speed
, parity
, data_bits
, stop_bits
;
305 QEMUSerialSetParams ssp
;
307 if (!s
->chr
|| s
->type
!= ser
)
310 if (s
->wregs
[4] & 1) {
318 if ((s
->wregs
[4] & 0x0c) == 0x0c)
322 switch (s
->wregs
[5] & 0x60) {
337 speed
= 2457600 / ((s
->wregs
[12] | (s
->wregs
[13] << 8)) + 2);
338 switch (s
->wregs
[4] & 0xc0) {
354 ssp
.data_bits
= data_bits
;
355 ssp
.stop_bits
= stop_bits
;
356 SER_DPRINTF("channel %c: speed=%d parity=%c data=%d stop=%d\n", CHN_C(s
),
357 speed
, parity
, data_bits
, stop_bits
);
358 qemu_chr_ioctl(s
->chr
, CHR_IOCTL_SERIAL_SET_PARAMS
, &ssp
);
361 static void slavio_serial_mem_writeb(void *opaque
, target_phys_addr_t addr
, uint32_t val
)
363 SerialState
*serial
= opaque
;
369 saddr
= (addr
& 3) >> 1;
370 channel
= (addr
& SERIAL_MAXADDR
) >> 2;
371 s
= &serial
->chn
[channel
];
374 SER_DPRINTF("Write channel %c, reg[%d] = %2.2x\n", CHN_C(s
), s
->reg
, val
& 0xff);
388 if (s
->rxint_under_svc
)
390 else if (s
->txint_under_svc
)
401 s
->wregs
[s
->reg
] = val
;
407 s
->wregs
[s
->reg
] = val
;
408 slavio_serial_update_parameters(s
);
411 switch (val
& 0xc0) {
416 slavio_serial_reset_chn(&serial
->chn
[1]);
419 slavio_serial_reset_chn(&serial
->chn
[0]);
422 slavio_serial_reset(serial
);
435 SER_DPRINTF("Write channel %c, ch %d\n", CHN_C(s
), val
);
437 if (s
->wregs
[5] & 8) { // tx enabled
439 qemu_chr_write(s
->chr
, &s
->tx
, 1);
440 else if (s
->type
== kbd
) {
441 handle_kbd_command(s
, val
);
444 s
->rregs
[0] |= 4; // Tx buffer empty
445 s
->rregs
[1] |= 1; // All sent
453 static uint32_t slavio_serial_mem_readb(void *opaque
, target_phys_addr_t addr
)
455 SerialState
*serial
= opaque
;
461 saddr
= (addr
& 3) >> 1;
462 channel
= (addr
& SERIAL_MAXADDR
) >> 2;
463 s
= &serial
->chn
[channel
];
466 SER_DPRINTF("Read channel %c, reg[%d] = %2.2x\n", CHN_C(s
), s
->reg
, s
->rregs
[s
->reg
]);
467 ret
= s
->rregs
[s
->reg
];
473 if (s
->type
== kbd
|| s
->type
== mouse
)
477 SER_DPRINTF("Read channel %c, ch %d\n", CHN_C(s
), ret
);
478 qemu_chr_accept_input(s
->chr
);
486 static int serial_can_receive(void *opaque
)
488 ChannelState
*s
= opaque
;
491 if (((s
->wregs
[3] & 1) == 0) // Rx not enabled
492 || ((s
->rregs
[0] & 1) == 1)) // char already available
496 //SER_DPRINTF("channel %c can receive %d\n", CHN_C(s), ret);
500 static void serial_receive_byte(ChannelState
*s
, int ch
)
502 SER_DPRINTF("channel %c put ch %d\n", CHN_C(s
), ch
);
508 static void serial_receive_break(ChannelState
*s
)
511 slavio_serial_update_irq(s
);
514 static void serial_receive1(void *opaque
, const uint8_t *buf
, int size
)
516 ChannelState
*s
= opaque
;
517 serial_receive_byte(s
, buf
[0]);
520 static void serial_event(void *opaque
, int event
)
522 ChannelState
*s
= opaque
;
523 if (event
== CHR_EVENT_BREAK
)
524 serial_receive_break(s
);
527 static CPUReadMemoryFunc
*slavio_serial_mem_read
[3] = {
528 slavio_serial_mem_readb
,
529 slavio_serial_mem_readb
,
530 slavio_serial_mem_readb
,
533 static CPUWriteMemoryFunc
*slavio_serial_mem_write
[3] = {
534 slavio_serial_mem_writeb
,
535 slavio_serial_mem_writeb
,
536 slavio_serial_mem_writeb
,
539 static void slavio_serial_save_chn(QEMUFile
*f
, ChannelState
*s
)
543 qemu_put_be32s(f
, &tmp
); /* unused, was IRQ. */
544 qemu_put_be32s(f
, &s
->reg
);
545 qemu_put_be32s(f
, &s
->rxint
);
546 qemu_put_be32s(f
, &s
->txint
);
547 qemu_put_be32s(f
, &s
->rxint_under_svc
);
548 qemu_put_be32s(f
, &s
->txint_under_svc
);
549 qemu_put_8s(f
, &s
->rx
);
550 qemu_put_8s(f
, &s
->tx
);
551 qemu_put_buffer(f
, s
->wregs
, 16);
552 qemu_put_buffer(f
, s
->rregs
, 16);
555 static void slavio_serial_save(QEMUFile
*f
, void *opaque
)
557 SerialState
*s
= opaque
;
559 slavio_serial_save_chn(f
, &s
->chn
[0]);
560 slavio_serial_save_chn(f
, &s
->chn
[1]);
563 static int slavio_serial_load_chn(QEMUFile
*f
, ChannelState
*s
, int version_id
)
570 qemu_get_be32s(f
, &tmp
); /* unused */
571 qemu_get_be32s(f
, &s
->reg
);
572 qemu_get_be32s(f
, &s
->rxint
);
573 qemu_get_be32s(f
, &s
->txint
);
574 if (version_id
>= 2) {
575 qemu_get_be32s(f
, &s
->rxint_under_svc
);
576 qemu_get_be32s(f
, &s
->txint_under_svc
);
578 qemu_get_8s(f
, &s
->rx
);
579 qemu_get_8s(f
, &s
->tx
);
580 qemu_get_buffer(f
, s
->wregs
, 16);
581 qemu_get_buffer(f
, s
->rregs
, 16);
585 static int slavio_serial_load(QEMUFile
*f
, void *opaque
, int version_id
)
587 SerialState
*s
= opaque
;
590 ret
= slavio_serial_load_chn(f
, &s
->chn
[0], version_id
);
593 ret
= slavio_serial_load_chn(f
, &s
->chn
[1], version_id
);
598 SerialState
*slavio_serial_init(target_phys_addr_t base
, qemu_irq irq
,
599 CharDriverState
*chr1
, CharDriverState
*chr2
)
601 int slavio_serial_io_memory
, i
;
604 s
= qemu_mallocz(sizeof(SerialState
));
608 slavio_serial_io_memory
= cpu_register_io_memory(0, slavio_serial_mem_read
, slavio_serial_mem_write
, s
);
609 cpu_register_physical_memory(base
, SERIAL_SIZE
, slavio_serial_io_memory
);
611 s
->chn
[0].chr
= chr1
;
612 s
->chn
[1].chr
= chr2
;
614 for (i
= 0; i
< 2; i
++) {
616 s
->chn
[i
].chn
= 1 - i
;
617 s
->chn
[i
].type
= ser
;
619 qemu_chr_add_handlers(s
->chn
[i
].chr
, serial_can_receive
,
620 serial_receive1
, serial_event
, &s
->chn
[i
]);
623 s
->chn
[0].otherchn
= &s
->chn
[1];
624 s
->chn
[1].otherchn
= &s
->chn
[0];
625 register_savevm("slavio_serial", base
, 2, slavio_serial_save
, slavio_serial_load
, s
);
626 qemu_register_reset(slavio_serial_reset
, s
);
627 slavio_serial_reset(s
);
631 static const uint8_t keycodes
[128] = {
632 127, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 43, 53,
633 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 89, 76, 77, 78,
634 79, 80, 81, 82, 83, 84, 85, 86, 87, 42, 99, 88, 100, 101, 102, 103,
635 104, 105, 106, 107, 108, 109, 110, 47, 19, 121, 119, 5, 6, 8, 10, 12,
636 14, 16, 17, 18, 7, 98, 23, 68, 69, 70, 71, 91, 92, 93, 125, 112,
637 113, 114, 94, 50, 0, 0, 124, 9, 11, 0, 0, 0, 0, 0, 0, 0,
638 90, 0, 46, 22, 13, 111, 52, 20, 96, 24, 28, 74, 27, 123, 44, 66,
639 0, 45, 2, 4, 48, 0, 0, 21, 0, 0, 0, 0, 0, 120, 122, 67,
642 static const uint8_t e0_keycodes
[128] = {
643 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
644 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 90, 76, 0, 0,
645 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
646 0, 0, 0, 0, 0, 109, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0,
647 0, 0, 0, 0, 0, 0, 0, 68, 69, 70, 0, 91, 0, 93, 0, 112,
648 113, 114, 94, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
649 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
650 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
653 static void sunkbd_event(void *opaque
, int ch
)
655 ChannelState
*s
= opaque
;
656 int release
= ch
& 0x80;
658 KBD_DPRINTF("Untranslated keycode %2.2x (%s)\n", ch
, release
? "release" : "press");
660 case 58: // Caps lock press
661 s
->caps_lock_mode
^= 1;
662 if (s
->caps_lock_mode
== 2)
663 return; // Drop second press
665 case 69: // Num lock press
666 s
->num_lock_mode
^= 1;
667 if (s
->num_lock_mode
== 2)
668 return; // Drop second press
670 case 186: // Caps lock release
671 s
->caps_lock_mode
^= 2;
672 if (s
->caps_lock_mode
== 3)
673 return; // Drop first release
675 case 197: // Num lock release
676 s
->num_lock_mode
^= 2;
677 if (s
->num_lock_mode
== 3)
678 return; // Drop first release
688 ch
= e0_keycodes
[ch
& 0x7f];
690 ch
= keycodes
[ch
& 0x7f];
692 KBD_DPRINTF("Translated keycode %2.2x\n", ch
);
693 put_queue(s
, ch
| release
);
696 static void handle_kbd_command(ChannelState
*s
, int val
)
698 KBD_DPRINTF("Command %d\n", val
);
699 if (s
->led_mode
) { // Ignore led byte
704 case 1: // Reset, return type code
707 put_queue(s
, 4); // Type 4
710 case 0xe: // Set leds
713 case 7: // Query layout
717 put_queue(s
, 0); // XXX, layout?
724 static void sunmouse_event(void *opaque
,
725 int dx
, int dy
, int dz
, int buttons_state
)
727 ChannelState
*s
= opaque
;
730 MS_DPRINTF("dx=%d dy=%d buttons=%01x\n", dx
, dy
, buttons_state
);
732 ch
= 0x80 | 0x7; /* protocol start byte, no buttons pressed */
734 if (buttons_state
& MOUSE_EVENT_LBUTTON
)
736 if (buttons_state
& MOUSE_EVENT_MBUTTON
)
738 if (buttons_state
& MOUSE_EVENT_RBUTTON
)
750 put_queue(s
, ch
& 0xff);
759 put_queue(s
, ch
& 0xff);
761 // MSC protocol specify two extra motion bytes
767 void slavio_serial_ms_kbd_init(target_phys_addr_t base
, qemu_irq irq
)
769 int slavio_serial_io_memory
, i
;
772 s
= qemu_mallocz(sizeof(SerialState
));
775 for (i
= 0; i
< 2; i
++) {
777 s
->chn
[i
].chn
= 1 - i
;
778 s
->chn
[i
].chr
= NULL
;
780 s
->chn
[0].otherchn
= &s
->chn
[1];
781 s
->chn
[1].otherchn
= &s
->chn
[0];
782 s
->chn
[0].type
= mouse
;
783 s
->chn
[1].type
= kbd
;
785 slavio_serial_io_memory
= cpu_register_io_memory(0, slavio_serial_mem_read
, slavio_serial_mem_write
, s
);
786 cpu_register_physical_memory(base
, SERIAL_SIZE
, slavio_serial_io_memory
);
788 qemu_add_mouse_event_handler(sunmouse_event
, &s
->chn
[0], 0, "QEMU Sun Mouse");
789 qemu_add_kbd_event_handler(sunkbd_event
, &s
->chn
[1]);
790 register_savevm("slavio_serial_mouse", base
, 2, slavio_serial_save
, slavio_serial_load
, s
);
791 qemu_register_reset(slavio_serial_reset
, s
);
792 slavio_serial_reset(s
);