vcs.maemo.org Git - qemu/blob - hw/slavio_serial.c

   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 "vl.h"
  25 /* debug serial */
  26 //#define DEBUG_SERIAL
  27
  28 /* debug keyboard */
  29 //#define DEBUG_KBD
  30
  31 /* debug mouse */
  32 //#define DEBUG_MOUSE
  33
  34 /*
  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
  38  *
  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.
  42  *
  43  */
  44
  45 /*
  46  * Modifications:
  47  *  2006-Aug-10  Igor Kovalenko :   Renamed KBDQueue to SERIOQueue, implemented
  48  *                                  serial mouse queue.
  49  *                                  Implemented serial mouse protocol.
  50  */
  51
  52 #ifdef DEBUG_SERIAL
  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)
  57 #else
  58 #define SER_DPRINTF(fmt, args...)
  59 #endif
  60 #ifdef DEBUG_KBD
  61 #define KBD_DPRINTF(fmt, args...) \
  62 do { printf("KBD: " fmt , ##args); } while (0)
  63 #else
  64 #define KBD_DPRINTF(fmt, args...)
  65 #endif
  66 #ifdef DEBUG_MOUSE
  67 #define MS_DPRINTF(fmt, args...) \
  68 do { printf("MSC: " fmt , ##args); } while (0)
  69 #else
  70 #define MS_DPRINTF(fmt, args...)
  71 #endif
  72
  73 typedef enum {
  74     chn_a, chn_b,
  75 } chn_id_t;
  76
  77 typedef enum {
  78     ser, kbd, mouse,
  79 } chn_type_t;
  80
  81 #define SERIO_QUEUE_SIZE 256
  82
  83 typedef struct {
  84     uint8_t data[SERIO_QUEUE_SIZE];
  85     int rptr, wptr, count;
  86 } SERIOQueue;
  87
  88 typedef struct ChannelState {
  89     int irq;
  90     int reg;
  91     int rxint, txint, rxint_under_svc, txint_under_svc;
  92     chn_id_t chn; // this channel, A (base+4) or B (base+0)
  93     chn_type_t type;
  94     struct ChannelState *otherchn;
  95     uint8_t rx, tx, wregs[16], rregs[16];
  96     SERIOQueue queue;
  97     CharDriverState *chr;
  98 } ChannelState;
  99
 100 struct SerialState {
 101     struct ChannelState chn[2];
 102 };
 103
 104 #define SERIAL_MAXADDR 7
 105
 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);
 110
 111 static void put_queue(void *opaque, int b)
 112 {
 113     ChannelState *s = opaque;
 114     SERIOQueue *q = &s->queue;
 115
 116     SER_DPRINTF("put: 0x%02x\n", b);
 117     if (q->count >= SERIO_QUEUE_SIZE)
 118         return;
 119     q->data[q->wptr] = b;
 120     if (++q->wptr == SERIO_QUEUE_SIZE)
 121         q->wptr = 0;
 122     q->count++;
 123     serial_receive_byte(s, 0);
 124 }
 125
 126 static uint32_t get_queue(void *opaque)
 127 {
 128     ChannelState *s = opaque;
 129     SERIOQueue *q = &s->queue;
 130     int val;
 131
 132     if (q->count == 0) {
 133         return 0;
 134     } else {
 135         val = q->data[q->rptr];
 136         if (++q->rptr == SERIO_QUEUE_SIZE)
 137             q->rptr = 0;
 138         q->count--;
 139     }
 140     KBD_DPRINTF("get 0x%02x\n", val);
 141     if (q->count > 0)
 142         serial_receive_byte(s, 0);
 143     return val;
 144 }
 145
 146 static int slavio_serial_update_irq_chn(ChannelState *s)
 147 {
 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
 153         return 1;
 154     }
 155     return 0;
 156 }
 157
 158 static void slavio_serial_update_irq(ChannelState *s)
 159 {
 160     int irq;
 161
 162     irq = slavio_serial_update_irq_chn(s);
 163     irq |= slavio_serial_update_irq_chn(s->otherchn);
 164
 165     pic_set_irq(s->irq, irq);
 166 }
 167
 168 static void slavio_serial_reset_chn(ChannelState *s)
 169 {
 170     int i;
 171
 172     s->reg = 0;
 173     for (i = 0; i < SERIAL_MAXADDR; i++) {
 174         s->rregs[i] = 0;
 175         s->wregs[i] = 0;
 176     }
 177     s->wregs[4] = 4;
 178     s->wregs[9] = 0xc0;
 179     s->wregs[11] = 8;
 180     s->wregs[14] = 0x30;
 181     s->wregs[15] = 0xf8;
 182     s->rregs[0] = 0x44;
 183     s->rregs[1] = 6;
 184
 185     s->rx = s->tx = 0;
 186     s->rxint = s->txint = 0;
 187     s->rxint_under_svc = s->txint_under_svc = 0;
 188 }
 189
 190 static void slavio_serial_reset(void *opaque)
 191 {
 192     SerialState *s = opaque;
 193     slavio_serial_reset_chn(&s->chn[0]);
 194     slavio_serial_reset_chn(&s->chn[1]);
 195 }
 196
 197 static inline void clr_rxint(ChannelState *s)
 198 {
 199     s->rxint = 0;
 200     s->rxint_under_svc = 0;
 201     if (s->chn == 0)
 202         s->rregs[3] &= ~0x20;
 203     else {
 204         s->otherchn->rregs[3] &= ~4;
 205     }
 206     if (s->txint)
 207         set_txint(s);
 208     else
 209         s->rregs[2] = 6;
 210     slavio_serial_update_irq(s);
 211 }
 212
 213 static inline void set_rxint(ChannelState *s)
 214 {
 215     s->rxint = 1;
 216     if (!s->txint_under_svc) {
 217         s->rxint_under_svc = 1;
 218         if (s->chn == 0)
 219             s->rregs[3] |= 0x20;
 220         else {
 221             s->otherchn->rregs[3] |= 4;
 222         }
 223         s->rregs[2] = 4;
 224         slavio_serial_update_irq(s);
 225     }
 226 }
 227
 228 static inline void clr_txint(ChannelState *s)
 229 {
 230     s->txint = 0;
 231     s->txint_under_svc = 0;
 232     if (s->chn == 0)
 233         s->rregs[3] &= ~0x10;
 234     else {
 235         s->otherchn->rregs[3] &= ~2;
 236     }
 237     if (s->rxint)
 238         set_rxint(s);
 239     else
 240         s->rregs[2] = 6;
 241     slavio_serial_update_irq(s);
 242 }
 243
 244 static inline void set_txint(ChannelState *s)
 245 {
 246     s->txint = 1;
 247     if (!s->rxint_under_svc) {
 248         s->txint_under_svc = 1;
 249         if (s->chn == 0)
 250             s->rregs[3] |= 0x10;
 251         else {
 252             s->otherchn->rregs[3] |= 2;
 253         }
 254         s->rregs[2] = 0;
 255         slavio_serial_update_irq(s);
 256     }
 257 }
 258
 259 static void slavio_serial_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
 260 {
 261     SerialState *ser = opaque;
 262     ChannelState *s;
 263     uint32_t saddr;
 264     int newreg, channel;
 265
 266     val &= 0xff;
 267     saddr = (addr & 3) >> 1;
 268     channel = (addr & SERIAL_MAXADDR) >> 2;
 269     s = &ser->chn[channel];
 270     switch (saddr) {
 271     case 0:
 272         SER_DPRINTF("Write channel %c, reg[%d] = %2.2x\n", channel? 'b' : 'a', s->reg, val & 0xff);
 273         newreg = 0;
 274         switch (s->reg) {
 275         case 0:
 276             newreg = val & 7;
 277             val &= 0x38;
 278             switch (val) {
 279             case 8:
 280                 newreg |= 0x8;
 281                 break;
 282             case 0x28:
 283                 clr_txint(s);
 284                 break;
 285             case 0x38:
 286                 if (s->rxint_under_svc)
 287                     clr_rxint(s);
 288                 else if (s->txint_under_svc)
 289                     clr_txint(s);
 290                 break;
 291             default:
 292                 break;
 293             }
 294             break;
 295         case 1 ... 8:
 296         case 10 ... 15:
 297             s->wregs[s->reg] = val;
 298             break;
 299         case 9:
 300             switch (val & 0xc0) {
 301             case 0:
 302             default:
 303                 break;
 304             case 0x40:
 305                 slavio_serial_reset_chn(&ser->chn[1]);
 306                 return;
 307             case 0x80:
 308                 slavio_serial_reset_chn(&ser->chn[0]);
 309                 return;
 310             case 0xc0:
 311                 slavio_serial_reset(ser);
 312                 return;
 313             }
 314             break;
 315         default:
 316             break;
 317         }
 318         if (s->reg == 0)
 319             s->reg = newreg;
 320         else
 321             s->reg = 0;
 322         break;
 323     case 1:
 324         SER_DPRINTF("Write channel %c, ch %d\n", channel? 'b' : 'a', val);
 325         if (s->wregs[5] & 8) { // tx enabled
 326             s->tx = val;
 327             if (s->chr)
 328                 qemu_chr_write(s->chr, &s->tx, 1);
 329             else if (s->type == kbd) {
 330                 handle_kbd_command(s, val);
 331             }
 332             s->rregs[0] |= 4; // Tx buffer empty
 333             s->rregs[1] |= 1; // All sent
 334             set_txint(s);
 335         }
 336         break;
 337     default:
 338         break;
 339     }
 340 }
 341
 342 static uint32_t slavio_serial_mem_readb(void *opaque, target_phys_addr_t addr)
 343 {
 344     SerialState *ser = opaque;
 345     ChannelState *s;
 346     uint32_t saddr;
 347     uint32_t ret;
 348     int channel;
 349
 350     saddr = (addr & 3) >> 1;
 351     channel = (addr & SERIAL_MAXADDR) >> 2;
 352     s = &ser->chn[channel];
 353     switch (saddr) {
 354     case 0:
 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];
 357         s->reg = 0;
 358         return ret;
 359     case 1:
 360         s->rregs[0] &= ~1;
 361         clr_rxint(s);
 362         if (s->type == kbd || s->type == mouse)
 363             ret = get_queue(s);
 364         else
 365             ret = s->rx;
 366         SER_DPRINTF("Read channel %c, ch %d\n", channel? 'b' : 'a', ret);
 367         return ret;
 368     default:
 369         break;
 370     }
 371     return 0;
 372 }
 373
 374 static int serial_can_receive(void *opaque)
 375 {
 376     ChannelState *s = opaque;
 377     int ret;
 378
 379     if (((s->wregs[3] & 1) == 0) // Rx not enabled
 380         || ((s->rregs[0] & 1) == 1)) // char already available
 381         ret = 0;
 382     else
 383         ret = 1;
 384     SER_DPRINTF("can receive %d\n", ret);
 385     return ret;
 386 }
 387
 388 static void serial_receive_byte(ChannelState *s, int ch)
 389 {
 390     SER_DPRINTF("put ch %d\n", ch);
 391     s->rregs[0] |= 1;
 392     s->rx = ch;
 393     set_rxint(s);
 394 }
 395
 396 static void serial_receive_break(ChannelState *s)
 397 {
 398     s->rregs[0] |= 0x80;
 399     slavio_serial_update_irq(s);
 400 }
 401
 402 static void serial_receive1(void *opaque, const uint8_t *buf, int size)
 403 {
 404     ChannelState *s = opaque;
 405     serial_receive_byte(s, buf[0]);
 406 }
 407
 408 static void serial_event(void *opaque, int event)
 409 {
 410     ChannelState *s = opaque;
 411     if (event == CHR_EVENT_BREAK)
 412         serial_receive_break(s);
 413 }
 414
 415 static CPUReadMemoryFunc *slavio_serial_mem_read[3] = {
 416     slavio_serial_mem_readb,
 417     slavio_serial_mem_readb,
 418     slavio_serial_mem_readb,
 419 };
 420
 421 static CPUWriteMemoryFunc *slavio_serial_mem_write[3] = {
 422     slavio_serial_mem_writeb,
 423     slavio_serial_mem_writeb,
 424     slavio_serial_mem_writeb,
 425 };
 426
 427 static void slavio_serial_save_chn(QEMUFile *f, ChannelState *s)
 428 {
 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);
 439 }
 440
 441 static void slavio_serial_save(QEMUFile *f, void *opaque)
 442 {
 443     SerialState *s = opaque;
 444
 445     slavio_serial_save_chn(f, &s->chn[0]);
 446     slavio_serial_save_chn(f, &s->chn[1]);
 447 }
 448
 449 static int slavio_serial_load_chn(QEMUFile *f, ChannelState *s, int version_id)
 450 {
 451     if (version_id > 2)
 452         return -EINVAL;
 453
 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);
 461     }
 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);
 466     return 0;
 467 }
 468
 469 static int slavio_serial_load(QEMUFile *f, void *opaque, int version_id)
 470 {
 471     SerialState *s = opaque;
 472     int ret;
 473
 474     ret = slavio_serial_load_chn(f, &s->chn[0], version_id);
 475     if (ret != 0)
 476         return ret;
 477     ret = slavio_serial_load_chn(f, &s->chn[1], version_id);
 478     return ret;
 479
 480 }
 481
 482 SerialState *slavio_serial_init(int base, int irq, CharDriverState *chr1, CharDriverState *chr2)
 483 {
 484     int slavio_serial_io_memory, i;
 485     SerialState *s;
 486
 487     s = qemu_mallocz(sizeof(SerialState));
 488     if (!s)
 489         return NULL;
 490
 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);
 493
 494     s->chn[0].chr = chr1;
 495     s->chn[1].chr = chr2;
 496
 497     for (i = 0; i < 2; i++) {
 498         s->chn[i].irq = irq;
 499         s->chn[i].chn = 1 - i;
 500         s->chn[i].type = ser;
 501         if (s->chn[i].chr) {
 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);
 504         }
 505     }
 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);
 511     return s;
 512 }
 513
 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,
 523 };
 524
 525 static void sunkbd_event(void *opaque, int ch)
 526 {
 527     ChannelState *s = opaque;
 528     int release = ch & 0x80;
 529
 530     ch = keycodes[ch & 0x7f];
 531     KBD_DPRINTF("Keycode %d (%s)\n", ch, release? "release" : "press");
 532     put_queue(s, ch | release);
 533 }
 534
 535 static void handle_kbd_command(ChannelState *s, int val)
 536 {
 537     KBD_DPRINTF("Command %d\n", val);
 538     switch (val) {
 539     case 1: // Reset, return type code
 540         put_queue(s, 0xff);
 541         put_queue(s, 5); // Type 5
 542         break;
 543     case 7: // Query layout
 544         put_queue(s, 0xfe);
 545         put_queue(s, 0x20); // XXX, layout?
 546         break;
 547     default:
 548         break;
 549     }
 550 }
 551
 552 static void sunmouse_event(void *opaque,
 553                                int dx, int dy, int dz, int buttons_state)
 554 {
 555     ChannelState *s = opaque;
 556     int ch;
 557
 558     /* XXX: SDL sometimes generates nul events: we delete them */
 559     if (dx == 0 && dy == 0 && dz == 0 && buttons_state == 0)
 560         return;
 561     MS_DPRINTF("dx=%d dy=%d buttons=%01x\n", dx, dy, buttons_state);
 562
 563     ch = 0x80 | 0x7; /* protocol start byte, no buttons pressed */
 564
 565     if (buttons_state & MOUSE_EVENT_LBUTTON)
 566         ch ^= 0x4;
 567     if (buttons_state & MOUSE_EVENT_MBUTTON)
 568         ch ^= 0x2;
 569     if (buttons_state & MOUSE_EVENT_RBUTTON)
 570         ch ^= 0x1;
 571
 572     put_queue(s, ch);
 573
 574     ch = dx;
 575
 576     if (ch > 127)
 577         ch=127;
 578     else if (ch < -127)
 579         ch=-127;
 580
 581     put_queue(s, ch & 0xff);
 582
 583     ch = -dy;
 584
 585     if (ch > 127)
 586         ch=127;
 587     else if (ch < -127)
 588         ch=-127;
 589
 590     put_queue(s, ch & 0xff);
 591
 592     // MSC protocol specify two extra motion bytes
 593
 594     put_queue(s, 0);
 595     put_queue(s, 0);
 596 }
 597
 598 void slavio_serial_ms_kbd_init(int base, int irq)
 599 {
 600     int slavio_serial_io_memory, i;
 601     SerialState *s;
 602
 603     s = qemu_mallocz(sizeof(SerialState));
 604     if (!s)
 605         return;
 606     for (i = 0; i < 2; i++) {
 607         s->chn[i].irq = irq;
 608         s->chn[i].chn = 1 - i;
 609         s->chn[i].chr = NULL;
 610     }
 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;
 615
 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);
 618
 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);
 623 }