1 /*

     2  * QEMU Sparc SLAVIO serial port emulation

     3  *

     4  * Copyright (c) 2003-2005 Fabrice Bellard

     5  *

     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:

    12  *

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

    14  * all copies or substantial portions of the Software.

    15  *

    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

    22  * THE SOFTWARE.

    23  */

    24 #include "hw.h"

    25 #include "sun4m.h"

    26 #include "qemu-char.h"

    27 #include "console.h"

    28 

    29 /* debug serial */

    30 //#define DEBUG_SERIAL

    31 

    32 /* debug keyboard */

    33 //#define DEBUG_KBD

    34 

    35 /* debug mouse */

    36 //#define DEBUG_MOUSE

    37 

    38 /*

    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

    42  *

    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.

    46  *

    47  */

    48 

    49 /*

    50  * Modifications:

    51  *  2006-Aug-10  Igor Kovalenko :   Renamed KBDQueue to SERIOQueue, implemented

    52  *                                  serial mouse queue.

    53  *                                  Implemented serial mouse protocol.

    54  */

    55 

    56 #ifdef DEBUG_SERIAL

    57 #define SER_DPRINTF(fmt, args...) \

    58 do { printf("SER: " fmt , ##args); } while (0)

    59 #else

    60 #define SER_DPRINTF(fmt, args...)

    61 #endif

    62 #ifdef DEBUG_KBD

    63 #define KBD_DPRINTF(fmt, args...) \

    64 do { printf("KBD: " fmt , ##args); } while (0)

    65 #else

    66 #define KBD_DPRINTF(fmt, args...)

    67 #endif

    68 #ifdef DEBUG_MOUSE

    69 #define MS_DPRINTF(fmt, args...) \

    70 do { printf("MSC: " fmt , ##args); } while (0)

    71 #else

    72 #define MS_DPRINTF(fmt, args...)

    73 #endif

    74 

    75 typedef enum {

    76     chn_a, chn_b,

    77 } chn_id_t;

    78 

    79 #define CHN_C(s) ((s)->chn == chn_b? 'b' : 'a')

    80 

    81 typedef enum {

    82     ser, kbd, mouse,

    83 } chn_type_t;

    84 

    85 #define SERIO_QUEUE_SIZE 256

    86 

    87 typedef struct {

    88     uint8_t data[SERIO_QUEUE_SIZE];

    89     int rptr, wptr, count;

    90 } SERIOQueue;

    91 

    92 #define SERIAL_REGS 16

    93 typedef struct ChannelState {

    94     qemu_irq irq;

    95     uint32_t reg;

    96     uint32_t rxint, txint, rxint_under_svc, txint_under_svc;

    97     chn_id_t chn; // this channel, A (base+4) or B (base+0)

    98     chn_type_t type;

    99     struct ChannelState *otherchn;

   100     uint8_t rx, tx, wregs[SERIAL_REGS], rregs[SERIAL_REGS];

   101     SERIOQueue queue;

   102     CharDriverState *chr;

   103     int e0_mode, led_mode, caps_lock_mode, num_lock_mode;

   104     int disabled;

   105 } ChannelState;

   106 

   107 struct SerialState {

   108     struct ChannelState chn[2];

   109 };

   110 

   111 #define SERIAL_SIZE 8

   112 #define SERIAL_CTRL 0

   113 #define SERIAL_DATA 1

   114 

   115 #define W_CMD     0

   116 #define CMD_PTR_MASK   0x07

   117 #define CMD_CMD_MASK   0x38

   118 #define CMD_HI         0x08

   119 #define CMD_CLR_TXINT  0x28

   120 #define CMD_CLR_IUS    0x38

   121 #define W_INTR    1

   122 #define INTR_INTALL    0x01

   123 #define INTR_TXINT     0x02

   124 #define INTR_RXMODEMSK 0x18

   125 #define INTR_RXINT1ST  0x08

   126 #define INTR_RXINTALL  0x10

   127 #define W_IVEC    2

   128 #define W_RXCTRL  3

   129 #define RXCTRL_RXEN    0x01

   130 #define W_TXCTRL1 4

   131 #define TXCTRL1_PAREN  0x01

   132 #define TXCTRL1_PAREV  0x02

   133 #define TXCTRL1_1STOP  0x04

   134 #define TXCTRL1_1HSTOP 0x08

   135 #define TXCTRL1_2STOP  0x0c

   136 #define TXCTRL1_STPMSK 0x0c

   137 #define TXCTRL1_CLK1X  0x00

   138 #define TXCTRL1_CLK16X 0x40

   139 #define TXCTRL1_CLK32X 0x80

   140 #define TXCTRL1_CLK64X 0xc0

   141 #define TXCTRL1_CLKMSK 0xc0

   142 #define W_TXCTRL2 5

   143 #define TXCTRL2_TXEN   0x08

   144 #define TXCTRL2_BITMSK 0x60

   145 #define TXCTRL2_5BITS  0x00

   146 #define TXCTRL2_7BITS  0x20

   147 #define TXCTRL2_6BITS  0x40

   148 #define TXCTRL2_8BITS  0x60

   149 #define W_SYNC1   6

   150 #define W_SYNC2   7

   151 #define W_TXBUF   8

   152 #define W_MINTR   9

   153 #define MINTR_STATUSHI 0x10

   154 #define MINTR_RST_MASK 0xc0

   155 #define MINTR_RST_B    0x40

   156 #define MINTR_RST_A    0x80

   157 #define MINTR_RST_ALL  0xc0

   158 #define W_MISC1  10

   159 #define W_CLOCK  11

   160 #define CLOCK_TRXC     0x08

   161 #define W_BRGLO  12

   162 #define W_BRGHI  13

   163 #define W_MISC2  14

   164 #define MISC2_PLLDIS   0x30

   165 #define W_EXTINT 15

   166 #define EXTINT_DCD     0x08

   167 #define EXTINT_SYNCINT 0x10

   168 #define EXTINT_CTSINT  0x20

   169 #define EXTINT_TXUNDRN 0x40

   170 #define EXTINT_BRKINT  0x80

   171 

   172 #define R_STATUS  0

   173 #define STATUS_RXAV    0x01

   174 #define STATUS_ZERO    0x02

   175 #define STATUS_TXEMPTY 0x04

   176 #define STATUS_DCD     0x08

   177 #define STATUS_SYNC    0x10

   178 #define STATUS_CTS     0x20

   179 #define STATUS_TXUNDRN 0x40

   180 #define STATUS_BRK     0x80

   181 #define R_SPEC    1

   182 #define SPEC_ALLSENT   0x01

   183 #define SPEC_BITS8     0x06

   184 #define R_IVEC    2

   185 #define IVEC_TXINTB    0x00

   186 #define IVEC_LONOINT   0x06

   187 #define IVEC_LORXINTA  0x0c

   188 #define IVEC_LORXINTB  0x04

   189 #define IVEC_LOTXINTA  0x08

   190 #define IVEC_HINOINT   0x60

   191 #define IVEC_HIRXINTA  0x30

   192 #define IVEC_HIRXINTB  0x20

   193 #define IVEC_HITXINTA  0x10

   194 #define R_INTR    3

   195 #define INTR_EXTINTB   0x01

   196 #define INTR_TXINTB    0x02

   197 #define INTR_RXINTB    0x04

   198 #define INTR_EXTINTA   0x08

   199 #define INTR_TXINTA    0x10

   200 #define INTR_RXINTA    0x20

   201 #define R_IPEN    4

   202 #define R_TXCTRL1 5

   203 #define R_TXCTRL2 6

   204 #define R_BC      7

   205 #define R_RXBUF   8

   206 #define R_RXCTRL  9

   207 #define R_MISC   10

   208 #define R_MISC1  11

   209 #define R_BRGLO  12

   210 #define R_BRGHI  13

   211 #define R_MISC1I 14

   212 #define R_EXTINT 15

   213 

   214 static void handle_kbd_command(ChannelState *s, int val);

   215 static int serial_can_receive(void *opaque);

   216 static void serial_receive_byte(ChannelState *s, int ch);

   217 

   218 static void clear_queue(void *opaque)

   219 {

   220     ChannelState *s = opaque;

   221     SERIOQueue *q = &s->queue;

   222     q->rptr = q->wptr = q->count = 0;

   223 }

   224 

   225 static void put_queue(void *opaque, int b)

   226 {

   227     ChannelState *s = opaque;

   228     SERIOQueue *q = &s->queue;

   229 

   230     SER_DPRINTF("channel %c put: 0x%02x\n", CHN_C(s), b);

   231     if (q->count >= SERIO_QUEUE_SIZE)

   232         return;

   233     q->data[q->wptr] = b;

   234     if (++q->wptr == SERIO_QUEUE_SIZE)

   235         q->wptr = 0;

   236     q->count++;

   237     serial_receive_byte(s, 0);

   238 }

   239 

   240 static uint32_t get_queue(void *opaque)

   241 {

   242     ChannelState *s = opaque;

   243     SERIOQueue *q = &s->queue;

   244     int val;

   245 

   246     if (q->count == 0) {

   247         return 0;

   248     } else {

   249         val = q->data[q->rptr];

   250         if (++q->rptr == SERIO_QUEUE_SIZE)

   251             q->rptr = 0;

   252         q->count--;

   253     }

   254     SER_DPRINTF("channel %c get 0x%02x\n", CHN_C(s), val);

   255     if (q->count > 0)

   256         serial_receive_byte(s, 0);

   257     return val;

   258 }

   259 

   260 static int slavio_serial_update_irq_chn(ChannelState *s)

   261 {

   262     if ((((s->wregs[W_INTR] & INTR_TXINT) && s->txint == 1) ||

   263          // tx ints enabled, pending

   264          ((((s->wregs[W_INTR] & INTR_RXMODEMSK) == INTR_RXINT1ST) ||

   265            ((s->wregs[W_INTR] & INTR_RXMODEMSK) == INTR_RXINTALL)) &&

   266           s->rxint == 1) || // rx ints enabled, pending

   267          ((s->wregs[W_EXTINT] & EXTINT_BRKINT) &&

   268           (s->rregs[R_STATUS] & STATUS_BRK)))) { // break int e&p

   269         return 1;

   270     }

   271     return 0;

   272 }

   273 

   274 static void slavio_serial_update_irq(ChannelState *s)

   275 {

   276     int irq;

   277 

   278     irq = slavio_serial_update_irq_chn(s);

   279     irq |= slavio_serial_update_irq_chn(s->otherchn);

   280 

   281     SER_DPRINTF("IRQ = %d\n", irq);

   282     qemu_set_irq(s->irq, irq);

   283 }

   284 

   285 static void slavio_serial_reset_chn(ChannelState *s)

   286 {

   287     int i;

   288 

   289     s->reg = 0;

   290     for (i = 0; i < SERIAL_SIZE; i++) {

   291         s->rregs[i] = 0;

   292         s->wregs[i] = 0;

   293     }

   294     s->wregs[W_TXCTRL1] = TXCTRL1_1STOP; // 1X divisor, 1 stop bit, no parity

   295     s->wregs[W_MINTR] = MINTR_RST_ALL;

   296     s->wregs[W_CLOCK] = CLOCK_TRXC; // Synch mode tx clock = TRxC

   297     s->wregs[W_MISC2] = MISC2_PLLDIS; // PLL disabled

   298     s->wregs[W_EXTINT] = EXTINT_DCD | EXTINT_SYNCINT | EXTINT_CTSINT |

   299         EXTINT_TXUNDRN | EXTINT_BRKINT; // Enable most interrupts

   300     if (s->disabled)

   301         s->rregs[R_STATUS] = STATUS_TXEMPTY | STATUS_DCD | STATUS_SYNC |

   302             STATUS_CTS | STATUS_TXUNDRN;

   303     else

   304         s->rregs[R_STATUS] = STATUS_TXEMPTY | STATUS_TXUNDRN;

   305     s->rregs[R_SPEC] = SPEC_BITS8 | SPEC_ALLSENT;

   306 

   307     s->rx = s->tx = 0;

   308     s->rxint = s->txint = 0;

   309     s->rxint_under_svc = s->txint_under_svc = 0;

   310     s->e0_mode = s->led_mode = s->caps_lock_mode = s->num_lock_mode = 0;

   311     clear_queue(s);

   312 }

   313 

   314 static void slavio_serial_reset(void *opaque)

   315 {

   316     SerialState *s = opaque;

   317     slavio_serial_reset_chn(&s->chn[0]);

   318     slavio_serial_reset_chn(&s->chn[1]);

   319 }

   320 

   321 static inline void set_rxint(ChannelState *s)

   322 {

   323     s->rxint = 1;

   324     if (!s->txint_under_svc) {

   325         s->rxint_under_svc = 1;

   326         if (s->chn == chn_a) {

   327             if (s->wregs[W_MINTR] & MINTR_STATUSHI)

   328                 s->otherchn->rregs[R_IVEC] = IVEC_HIRXINTA;

   329             else

   330                 s->otherchn->rregs[R_IVEC] = IVEC_LORXINTA;

   331         } else {

   332             if (s->wregs[W_MINTR] & MINTR_STATUSHI)

   333                 s->rregs[R_IVEC] = IVEC_HIRXINTB;

   334             else

   335                 s->rregs[R_IVEC] = IVEC_LORXINTB;

   336         }

   337     }

   338     if (s->chn == chn_a)

   339         s->rregs[R_INTR] |= INTR_RXINTA;

   340     else

   341         s->otherchn->rregs[R_INTR] |= INTR_RXINTB;

   342     slavio_serial_update_irq(s);

   343 }

   344 

   345 static inline void set_txint(ChannelState *s)

   346 {

   347     s->txint = 1;

   348     if (!s->rxint_under_svc) {

   349         s->txint_under_svc = 1;

   350         if (s->chn == chn_a) {

   351             if (s->wregs[W_MINTR] & MINTR_STATUSHI)

   352                 s->otherchn->rregs[R_IVEC] = IVEC_HITXINTA;

   353             else

   354                 s->otherchn->rregs[R_IVEC] = IVEC_LOTXINTA;

   355         } else {

   356             s->rregs[R_IVEC] = IVEC_TXINTB;

   357         }

   358     }

   359     if (s->chn == chn_a)

   360         s->rregs[R_INTR] |= INTR_TXINTA;

   361     else

   362         s->otherchn->rregs[R_INTR] |= INTR_TXINTB;

   363     slavio_serial_update_irq(s);

   364 }

   365 

   366 static inline void clr_rxint(ChannelState *s)

   367 {

   368     s->rxint = 0;

   369     s->rxint_under_svc = 0;

   370     if (s->chn == chn_a) {

   371         if (s->wregs[W_MINTR] & MINTR_STATUSHI)

   372             s->otherchn->rregs[R_IVEC] = IVEC_HINOINT;

   373         else

   374             s->otherchn->rregs[R_IVEC] = IVEC_LONOINT;

   375         s->rregs[R_INTR] &= ~INTR_RXINTA;

   376     } else {

   377         if (s->wregs[W_MINTR] & MINTR_STATUSHI)

   378             s->rregs[R_IVEC] = IVEC_HINOINT;

   379         else

   380             s->rregs[R_IVEC] = IVEC_LONOINT;

   381         s->otherchn->rregs[R_INTR] &= ~INTR_RXINTB;

   382     }

   383     if (s->txint)

   384         set_txint(s);

   385     slavio_serial_update_irq(s);

   386 }

   387 

   388 static inline void clr_txint(ChannelState *s)

   389 {

   390     s->txint = 0;

   391     s->txint_under_svc = 0;

   392     if (s->chn == chn_a) {

   393         if (s->wregs[W_MINTR] & MINTR_STATUSHI)

   394             s->otherchn->rregs[R_IVEC] = IVEC_HINOINT;

   395         else

   396             s->otherchn->rregs[R_IVEC] = IVEC_LONOINT;

   397         s->rregs[R_INTR] &= ~INTR_TXINTA;

   398     } else {

   399         if (s->wregs[W_MINTR] & MINTR_STATUSHI)

   400             s->rregs[R_IVEC] = IVEC_HINOINT;

   401         else

   402             s->rregs[R_IVEC] = IVEC_LONOINT;

   403         s->otherchn->rregs[R_INTR] &= ~INTR_TXINTB;

   404     }

   405     if (s->rxint)

   406         set_rxint(s);

   407     slavio_serial_update_irq(s);

   408 }

   409 

   410 static void slavio_serial_update_parameters(ChannelState *s)

   411 {

   412     int speed, parity, data_bits, stop_bits;

   413     QEMUSerialSetParams ssp;

   414 

   415     if (!s->chr || s->type != ser)

   416         return;

   417 

   418     if (s->wregs[W_TXCTRL1] & TXCTRL1_PAREN) {

   419         if (s->wregs[W_TXCTRL1] & TXCTRL1_PAREV)

   420             parity = 'E';

   421         else

   422             parity = 'O';

   423     } else {

   424         parity = 'N';

   425     }

   426     if ((s->wregs[W_TXCTRL1] & TXCTRL1_STPMSK) == TXCTRL1_2STOP)

   427         stop_bits = 2;

   428     else

   429         stop_bits = 1;

   430     switch (s->wregs[W_TXCTRL2] & TXCTRL2_BITMSK) {

   431     case TXCTRL2_5BITS:

   432         data_bits = 5;

   433         break;

   434     case TXCTRL2_7BITS:

   435         data_bits = 7;

   436         break;

   437     case TXCTRL2_6BITS:

   438         data_bits = 6;

   439         break;

   440     default:

   441     case TXCTRL2_8BITS:

   442         data_bits = 8;

   443         break;

   444     }

   445     speed = 2457600 / ((s->wregs[W_BRGLO] | (s->wregs[W_BRGHI] << 8)) + 2);

   446     switch (s->wregs[W_TXCTRL1] & TXCTRL1_CLKMSK) {

   447     case TXCTRL1_CLK1X:

   448         break;

   449     case TXCTRL1_CLK16X:

   450         speed /= 16;

   451         break;

   452     case TXCTRL1_CLK32X:

   453         speed /= 32;

   454         break;

   455     default:

   456     case TXCTRL1_CLK64X:

   457         speed /= 64;

   458         break;

   459     }

   460     ssp.speed = speed;

   461     ssp.parity = parity;

   462     ssp.data_bits = data_bits;

   463     ssp.stop_bits = stop_bits;

   464     SER_DPRINTF("channel %c: speed=%d parity=%c data=%d stop=%d\n", CHN_C(s),

   465                 speed, parity, data_bits, stop_bits);

   466     qemu_chr_ioctl(s->chr, CHR_IOCTL_SERIAL_SET_PARAMS, &ssp);

   467 }

   468 

   469 static void slavio_serial_mem_writeb(void *opaque, target_phys_addr_t addr,

   470                                      uint32_t val)

   471 {

   472     SerialState *serial = opaque;

   473     ChannelState *s;

   474     uint32_t saddr;

   475     int newreg, channel;

   476 

   477     val &= 0xff;

   478     saddr = (addr & 3) >> 1;

   479     channel = addr >> 2;

   480     s = &serial->chn[channel];

   481     switch (saddr) {

   482     case SERIAL_CTRL:

   483         SER_DPRINTF("Write channel %c, reg[%d] = %2.2x\n", CHN_C(s), s->reg,

   484                     val & 0xff);

   485         newreg = 0;

   486         switch (s->reg) {

   487         case W_CMD:

   488             newreg = val & CMD_PTR_MASK;

   489             val &= CMD_CMD_MASK;

   490             switch (val) {

   491             case CMD_HI:

   492                 newreg |= CMD_HI;

   493                 break;

   494             case CMD_CLR_TXINT:

   495                 clr_txint(s);

   496                 break;

   497             case CMD_CLR_IUS:

   498                 if (s->rxint_under_svc)

   499                     clr_rxint(s);

   500                 else if (s->txint_under_svc)

   501                     clr_txint(s);

   502                 break;

   503             default:

   504                 break;

   505             }

   506             break;

   507         case W_INTR ... W_RXCTRL:

   508         case W_SYNC1 ... W_TXBUF:

   509         case W_MISC1 ... W_CLOCK:

   510         case W_MISC2 ... W_EXTINT:

   511             s->wregs[s->reg] = val;

   512             break;

   513         case W_TXCTRL1:

   514         case W_TXCTRL2:

   515             s->wregs[s->reg] = val;

   516             slavio_serial_update_parameters(s);

   517             break;

   518         case W_BRGLO:

   519         case W_BRGHI:

   520             s->wregs[s->reg] = val;

   521             s->rregs[s->reg] = val;

   522             slavio_serial_update_parameters(s);

   523             break;

   524         case W_MINTR:

   525             switch (val & MINTR_RST_MASK) {

   526             case 0:

   527             default:

   528                 break;

   529             case MINTR_RST_B:

   530                 slavio_serial_reset_chn(&serial->chn[0]);

   531                 return;

   532             case MINTR_RST_A:

   533                 slavio_serial_reset_chn(&serial->chn[1]);

   534                 return;

   535             case MINTR_RST_ALL:

   536                 slavio_serial_reset(serial);

   537                 return;

   538             }

   539             break;

   540         default:

   541             break;

   542         }

   543         if (s->reg == 0)

   544             s->reg = newreg;

   545         else

   546             s->reg = 0;

   547         break;

   548     case SERIAL_DATA:

   549         SER_DPRINTF("Write channel %c, ch %d\n", CHN_C(s), val);

   550         s->tx = val;

   551         if (s->wregs[W_TXCTRL2] & TXCTRL2_TXEN) { // tx enabled

   552             if (s->chr)

   553                 qemu_chr_write(s->chr, &s->tx, 1);

   554             else if (s->type == kbd && !s->disabled) {

   555                 handle_kbd_command(s, val);

   556             }

   557         }

   558         s->rregs[R_STATUS] |= STATUS_TXEMPTY; // Tx buffer empty

   559         s->rregs[R_SPEC] |= SPEC_ALLSENT; // All sent

   560         set_txint(s);

   561         break;

   562     default:

   563         break;

   564     }

   565 }

   566 

   567 static uint32_t slavio_serial_mem_readb(void *opaque, target_phys_addr_t addr)

   568 {

   569     SerialState *serial = opaque;

   570     ChannelState *s;

   571     uint32_t saddr;

   572     uint32_t ret;

   573     int channel;

   574 

   575     saddr = (addr & 3) >> 1;

   576     channel = addr >> 2;

   577     s = &serial->chn[channel];

   578     switch (saddr) {

   579     case SERIAL_CTRL:

   580         SER_DPRINTF("Read channel %c, reg[%d] = %2.2x\n", CHN_C(s), s->reg,

   581                     s->rregs[s->reg]);

   582         ret = s->rregs[s->reg];

   583         s->reg = 0;

   584         return ret;

   585     case SERIAL_DATA:

   586         s->rregs[R_STATUS] &= ~STATUS_RXAV;

   587         clr_rxint(s);

   588         if (s->type == kbd || s->type == mouse)

   589             ret = get_queue(s);

   590         else

   591             ret = s->rx;

   592         SER_DPRINTF("Read channel %c, ch %d\n", CHN_C(s), ret);

   593         if (s->chr)

   594             qemu_chr_accept_input(s->chr);

   595         return ret;

   596     default:

   597         break;

   598     }

   599     return 0;

   600 }

   601 

   602 static int serial_can_receive(void *opaque)

   603 {

   604     ChannelState *s = opaque;

   605     int ret;

   606 

   607     if (((s->wregs[W_RXCTRL] & RXCTRL_RXEN) == 0) // Rx not enabled

   608         || ((s->rregs[R_STATUS] & STATUS_RXAV) == STATUS_RXAV))

   609         // char already available

   610         ret = 0;

   611     else

   612         ret = 1;

   613     return ret;

   614 }

   615 

   616 static void serial_receive_byte(ChannelState *s, int ch)

   617 {

   618     SER_DPRINTF("channel %c put ch %d\n", CHN_C(s), ch);

   619     s->rregs[R_STATUS] |= STATUS_RXAV;

   620     s->rx = ch;

   621     set_rxint(s);

   622 }

   623 

   624 static void serial_receive_break(ChannelState *s)

   625 {

   626     s->rregs[R_STATUS] |= STATUS_BRK;

   627     slavio_serial_update_irq(s);

   628 }

   629 

   630 static void serial_receive1(void *opaque, const uint8_t *buf, int size)

   631 {

   632     ChannelState *s = opaque;

   633     serial_receive_byte(s, buf[0]);

   634 }

   635 

   636 static void serial_event(void *opaque, int event)

   637 {

   638     ChannelState *s = opaque;

   639     if (event == CHR_EVENT_BREAK)

   640         serial_receive_break(s);

   641 }

   642 

   643 static CPUReadMemoryFunc *slavio_serial_mem_read[3] = {

   644     slavio_serial_mem_readb,

   645     NULL,

   646     NULL,

   647 };

   648 

   649 static CPUWriteMemoryFunc *slavio_serial_mem_write[3] = {

   650     slavio_serial_mem_writeb,

   651     NULL,

   652     NULL,

   653 };

   654 

   655 static void slavio_serial_save_chn(QEMUFile *f, ChannelState *s)

   656 {

   657     uint32_t tmp = 0;

   658 

   659     qemu_put_be32s(f, &tmp); /* unused, was IRQ.  */

   660     qemu_put_be32s(f, &s->reg);

   661     qemu_put_be32s(f, &s->rxint);

   662     qemu_put_be32s(f, &s->txint);

   663     qemu_put_be32s(f, &s->rxint_under_svc);

   664     qemu_put_be32s(f, &s->txint_under_svc);

   665     qemu_put_8s(f, &s->rx);

   666     qemu_put_8s(f, &s->tx);

   667     qemu_put_buffer(f, s->wregs, SERIAL_REGS);

   668     qemu_put_buffer(f, s->rregs, SERIAL_REGS);

   669 }

   670 

   671 static void slavio_serial_save(QEMUFile *f, void *opaque)

   672 {

   673     SerialState *s = opaque;

   674 

   675     slavio_serial_save_chn(f, &s->chn[0]);

   676     slavio_serial_save_chn(f, &s->chn[1]);

   677 }

   678 

   679 static int slavio_serial_load_chn(QEMUFile *f, ChannelState *s, int version_id)

   680 {

   681     uint32_t tmp;

   682 

   683     if (version_id > 2)

   684         return -EINVAL;

   685 

   686     qemu_get_be32s(f, &tmp); /* unused */

   687     qemu_get_be32s(f, &s->reg);

   688     qemu_get_be32s(f, &s->rxint);

   689     qemu_get_be32s(f, &s->txint);

   690     if (version_id >= 2) {

   691         qemu_get_be32s(f, &s->rxint_under_svc);

   692         qemu_get_be32s(f, &s->txint_under_svc);

   693     }

   694     qemu_get_8s(f, &s->rx);

   695     qemu_get_8s(f, &s->tx);

   696     qemu_get_buffer(f, s->wregs, SERIAL_REGS);

   697     qemu_get_buffer(f, s->rregs, SERIAL_REGS);

   698     return 0;

   699 }

   700 

   701 static int slavio_serial_load(QEMUFile *f, void *opaque, int version_id)

   702 {

   703     SerialState *s = opaque;

   704     int ret;

   705 

   706     ret = slavio_serial_load_chn(f, &s->chn[0], version_id);

   707     if (ret != 0)

   708         return ret;

   709     ret = slavio_serial_load_chn(f, &s->chn[1], version_id);

   710     return ret;

   711 

   712 }

   713 

   714 SerialState *slavio_serial_init(target_phys_addr_t base, qemu_irq irq,

   715                                 CharDriverState *chr1, CharDriverState *chr2)

   716 {

   717     int slavio_serial_io_memory, i;

   718     SerialState *s;

   719 

   720     s = qemu_mallocz(sizeof(SerialState));

   721     if (!s)

   722         return NULL;

   723 

   724     slavio_serial_io_memory = cpu_register_io_memory(0, slavio_serial_mem_read,

   725                                                      slavio_serial_mem_write,

   726                                                      s);

   727     cpu_register_physical_memory(base, SERIAL_SIZE, slavio_serial_io_memory);

   728 

   729     s->chn[0].chr = chr1;

   730     s->chn[1].chr = chr2;

   731     s->chn[0].disabled = 0;

   732     s->chn[1].disabled = 0;

   733 

   734     for (i = 0; i < 2; i++) {

   735         s->chn[i].irq = irq;

   736         s->chn[i].chn = 1 - i;

   737         s->chn[i].type = ser;

   738         if (s->chn[i].chr) {

   739             qemu_chr_add_handlers(s->chn[i].chr, serial_can_receive,

   740                                   serial_receive1, serial_event, &s->chn[i]);

   741         }

   742     }

   743     s->chn[0].otherchn = &s->chn[1];

   744     s->chn[1].otherchn = &s->chn[0];

   745     register_savevm("slavio_serial", base, 2, slavio_serial_save,

   746                     slavio_serial_load, s);

   747     qemu_register_reset(slavio_serial_reset, s);

   748     slavio_serial_reset(s);

   749     return s;

   750 }

   751 

   752 static const uint8_t keycodes[128] = {

   753     127, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 43, 53,

   754     54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 89, 76, 77, 78,

   755     79, 80, 81, 82, 83, 84, 85, 86, 87, 42, 99, 88, 100, 101, 102, 103,

   756     104, 105, 106, 107, 108, 109, 110, 47, 19, 121, 119, 5, 6, 8, 10, 12,

   757     14, 16, 17, 18, 7, 98, 23, 68, 69, 70, 71, 91, 92, 93, 125, 112,

   758     113, 114, 94, 50, 0, 0, 124, 9, 11, 0, 0, 0, 0, 0, 0, 0,

   759     90, 0, 46, 22, 13, 111, 52, 20, 96, 24, 28, 74, 27, 123, 44, 66,

   760     0, 45, 2, 4, 48, 0, 0, 21, 0, 0, 0, 0, 0, 120, 122, 67,

   761 };

   762 

   763 static const uint8_t e0_keycodes[128] = {

   764     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   765     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 90, 76, 0, 0,

   766     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   767     0, 0, 0, 0, 0, 109, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0,

   768     0, 0, 0, 0, 0, 0, 0, 68, 69, 70, 0, 91, 0, 93, 0, 112,

   769     113, 114, 94, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   770     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   771     1, 3, 25, 26, 49, 52, 72, 73, 97, 99, 111, 118, 120, 122, 67, 0,

   772 };

   773 

   774 static void sunkbd_event(void *opaque, int ch)

   775 {

   776     ChannelState *s = opaque;

   777     int release = ch & 0x80;

   778 

   779     KBD_DPRINTF("Untranslated keycode %2.2x (%s)\n", ch, release? "release" :

   780                 "press");

   781     switch (ch) {

   782     case 58: // Caps lock press

   783         s->caps_lock_mode ^= 1;

   784         if (s->caps_lock_mode == 2)

   785             return; // Drop second press

   786         break;

   787     case 69: // Num lock press

   788         s->num_lock_mode ^= 1;

   789         if (s->num_lock_mode == 2)

   790             return; // Drop second press

   791         break;

   792     case 186: // Caps lock release

   793         s->caps_lock_mode ^= 2;

   794         if (s->caps_lock_mode == 3)

   795             return; // Drop first release

   796         break;

   797     case 197: // Num lock release

   798         s->num_lock_mode ^= 2;

   799         if (s->num_lock_mode == 3)

   800             return; // Drop first release

   801         break;

   802     case 0xe0:

   803         s->e0_mode = 1;

   804         return;

   805     default:

   806         break;

   807     }

   808     if (s->e0_mode) {

   809         s->e0_mode = 0;

   810         ch = e0_keycodes[ch & 0x7f];

   811     } else {

   812         ch = keycodes[ch & 0x7f];

   813     }

   814     KBD_DPRINTF("Translated keycode %2.2x\n", ch);

   815     put_queue(s, ch | release);

   816 }

   817 

   818 static void handle_kbd_command(ChannelState *s, int val)

   819 {

   820     KBD_DPRINTF("Command %d\n", val);

   821     if (s->led_mode) { // Ignore led byte

   822         s->led_mode = 0;

   823         return;

   824     }

   825     switch (val) {

   826     case 1: // Reset, return type code

   827         clear_queue(s);

   828         put_queue(s, 0xff);

   829         put_queue(s, 4); // Type 4

   830         put_queue(s, 0x7f);

   831         break;

   832     case 0xe: // Set leds

   833         s->led_mode = 1;

   834         break;

   835     case 7: // Query layout

   836     case 0xf:

   837         clear_queue(s);

   838         put_queue(s, 0xfe);

   839         put_queue(s, 0); // XXX, layout?

   840         break;

   841     default:

   842         break;

   843     }

   844 }

   845 

   846 static void sunmouse_event(void *opaque,

   847                                int dx, int dy, int dz, int buttons_state)

   848 {

   849     ChannelState *s = opaque;

   850     int ch;

   851 

   852     MS_DPRINTF("dx=%d dy=%d buttons=%01x\n", dx, dy, buttons_state);

   853 

   854     ch = 0x80 | 0x7; /* protocol start byte, no buttons pressed */

   855 

   856     if (buttons_state & MOUSE_EVENT_LBUTTON)

   857         ch ^= 0x4;

   858     if (buttons_state & MOUSE_EVENT_MBUTTON)

   859         ch ^= 0x2;

   860     if (buttons_state & MOUSE_EVENT_RBUTTON)

   861         ch ^= 0x1;

   862 

   863     put_queue(s, ch);

   864 

   865     ch = dx;

   866 

   867     if (ch > 127)

   868         ch=127;

   869     else if (ch < -127)

   870         ch=-127;

   871 

   872     put_queue(s, ch & 0xff);

   873 

   874     ch = -dy;

   875 

   876     if (ch > 127)

   877         ch=127;

   878     else if (ch < -127)

   879         ch=-127;

   880 

   881     put_queue(s, ch & 0xff);

   882 

   883     // MSC protocol specify two extra motion bytes

   884 

   885     put_queue(s, 0);

   886     put_queue(s, 0);

   887 }

   888 

   889 void slavio_serial_ms_kbd_init(target_phys_addr_t base, qemu_irq irq,

   890                                int disabled)

   891 {

   892     int slavio_serial_io_memory, i;

   893     SerialState *s;

   894 

   895     s = qemu_mallocz(sizeof(SerialState));

   896     if (!s)

   897         return;

   898     for (i = 0; i < 2; i++) {

   899         s->chn[i].irq = irq;

   900         s->chn[i].chn = 1 - i;

   901         s->chn[i].chr = NULL;

   902     }

   903     s->chn[0].otherchn = &s->chn[1];

   904     s->chn[1].otherchn = &s->chn[0];

   905     s->chn[0].type = mouse;

   906     s->chn[1].type = kbd;

   907     s->chn[0].disabled = disabled;

   908     s->chn[1].disabled = disabled;

   909 

   910     slavio_serial_io_memory = cpu_register_io_memory(0, slavio_serial_mem_read,

   911                                                      slavio_serial_mem_write,

   912                                                      s);

   913     cpu_register_physical_memory(base, SERIAL_SIZE, slavio_serial_io_memory);

   914 

   915     qemu_add_mouse_event_handler(sunmouse_event, &s->chn[0], 0,

   916                                  "QEMU Sun Mouse");

   917     qemu_add_kbd_event_handler(sunkbd_event, &s->chn[1]);

   918     register_savevm("slavio_serial_mouse", base, 2, slavio_serial_save,

   919                     slavio_serial_load, s);

   920     qemu_register_reset(slavio_serial_reset, s);

   921     slavio_serial_reset(s);

   922 }