palacios/src/devices/keyboard.c

   1 /*
   2  * This file is part of the Palacios Virtual Machine Monitor developed
   3  * by the V3VEE Project with funding from the United States National
   4  * Science Foundation and the Department of Energy.
   5  *
   6  * The V3VEE Project is a joint project between Northwestern University
   7  * and the University of New Mexico.  You can find out more at
   8  * http://www.v3vee.org
   9  *
  10  * Copyright (c) 2008, Peter Dinda <pdinda@northwestern.edu>
  11  * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org>
  12  * All rights reserved.
  13  *
  14  * Author: Peter Dinda <pdinda@northwestern.edu>
  15  *
  16  * This is free software.  You are permitted to use,
  17  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
  18  */
  19
  20 #include <devices/keyboard.h>
  21 #include <palacios/vmm.h>
  22 #include <palacios/vmm_types.h>
  23
  24
  25 #ifndef DEBUG_KEYBOARD
  26 #undef PrintDebug
  27 #define PrintDebug(fmt, args...)
  28 #endif
  29
  30 #define KEYBOARD_DEBUG_80H   0
  31
  32
  33
  34 #define KEYBOARD_60H          0x60  // keyboard microcontroller
  35 #define KEYBOARD_64H          0x64  // onboard microcontroller
  36
  37 #define KEYBOARD_DELAY_80H    0x80  // written for timing
  38
  39 #define KEYBOARD_IRQ          0x1
  40 #define MOUSE_IRQ             0xc
  41
  42
  43 // extract bits for status byte
  44 #define STATUS_OUTPUT_BUFFER_FULL   0x01  // 1=full (data for system)
  45 #define STATUS_INPUT_BUFFER_FULL    0x02  // 1=full (data for 8042)
  46 #define STATUS_SYSTEM               0x04  // 1=self-test-passed
  47 #define STATUS_COMMAND_DATA_AVAIL   0x08  // internal: 0=data on 60h, 0=cmd on 64h
  48 #define STATUS_ENABLED              0x10  // 1=keyboard is enabled
  49 #define STATUS_MOUSE_BUFFER_FULL    0x20  // 1= mouse output buffer full
  50 #define STATUS_TIMEOUT              0x40  // 1=timeout of keybd
  51 #define STATUS_PARITY               0x80  // 1=parity error
  52
  53 // bits for cmd byte
  54
  55 #define CMD_INTR                0x01  // 1=interrupts enabled
  56 #define CMD_MOUSE_INTR          0x02  // 1=interrupts enabled for mouse
  57 #define CMD_SYSTEM              0x04  // 1= self test passed
  58 #define CMD_OVERRIDE            0x08  // FORCE 0 for  PS2
  59 #define CMD_DISABLE             0x10  // 1=disabled keyboard
  60 #define CMD_MOUSE_DISABLE       0x20  // 1=disabled mouse
  61 #define CMD_SCANCODE_XLATE      0x40  // 1=translate to set 1 scancodes
  62 #define CMD_RESERVED            0x80  // should be zero
  63
  64 // bits for the output port
  65
  66
  67 #define OUTPUT_RESET        0x01  // System reset on 0
  68 #define OUTPUT_A20          0x02  // A20 gate (1= A20 is gated)
  69 #define OUTPUT_RES1         0x04  // reserved
  70 #define OUTPUT_RES2         0x08  // reserved
  71 #define OUTPUT_OUTPUT_FULL  0x10  // output buffer full
  72 #define OUTPUT_INPUT_EMPTY  0x20  // input buffer empty
  73 #define OUTPUT_KBD_CLOCK    0x40  // keyboard clock (?)
  74 #define OUTPUT_KBD_DATA     0x80  // keyboard data
  75
  76 // bits for the input port
  77
  78 #define INPUT_RES0          0x01  // reserved
  79 #define INPUT_RES1          0x02  // reserved
  80 #define INPUT_RES2          0x04  // reserved
  81 #define INPUT_RES3          0x08  // reserved
  82 #define INPUT_RAM           0x10  // set to 1 if RAM exists?
  83 #define INPUT_JUMPER        0x20  // manufacturing jumper?
  84 #define INPUT_DISPLAY       0x40  // 0=color, 1=mono
  85 #define INPUT_KBD_INHIBIT   0x80  // 1=inhibit keyboard ?
  86
  87
  88 // for queue operations
  89 #define QUEUE               0
  90 #define OVERWRITE           1
  91
  92 // for queue operations - whether it's data or cmd waiting on 60h
  93 #define DATA                0
  94 #define COMMAND             1
  95
  96 // for queue operations - whether this is keyboard or mouse data on 60h
  97 #define KEYBOARD            0
  98 #define MOUSE               1
  99
 100
 101
 102 //#define QUEUE_SIZE          32
 103
 104
 105 struct keyboard_internal {
 106     //
 107     // 0x60 is the port for the keyboard microcontroller
 108     //   writes are commands
 109     //   reads from it usually return scancodes
 110     //   however, it can also return other data
 111     //   depending on the state of the onboard microcontroller
 112     //
 113     // 0x64 is the port for the onboard microcontroller
 114     //   writes are commands
 115     //   reads are status
 116     //
 117
 118     // state of the onboard microcontroller
 119     // this is needed because sometimes 0x60 reads come
 120     // from the onboard microcontroller
 121     enum {// Normal mode measn we deliver keys
 122         // to the vm and accept commands from it
 123         NORMAL,
 124         // after receiving cmd 0x60
 125         // keybaord uC cmd will subsequently arrive
 126         WRITING_CMD_BYTE,
 127         // after recieving 0xa5
 128         // password arrives on data port, null terminated
 129         TRANSMIT_PASSWD,
 130         // after having reset sent to 0x60
 131         // we immediately ack, and then
 132         // push BAT success (0xaa) after the ack
 133         RESET,
 134         // after having a d1 sent to 64
 135         // we wait for a new output byte on 60
 136         WRITING_OUTPUT_PORT,
 137         // after having a d2 sent to 64
 138         // we wait for a new output byte on 60
 139         // then make it available as a keystroke
 140         INJECTING_KEY,
 141         // after having a d3 sent to 64
 142         // we wait for a new output byte on 60
 143         // then make it available as a mouse event
 144         INJECTING_MOUSE,
 145         // after having a d4 sent to 64
 146         // we wait for a new output byte on 60
 147         // then send it to the mouse
 148         IN_MOUSE,
 149         // After the Keyboard LEDs are enabled
 150         // we wait for the output byte on 64?
 151         SET_LEDS,
 152         // After the Keyboard SET_RATE is called
 153         // we wait for the output byte on 64?
 154         SET_RATE,
 155         // The keyboard requests an ID which
 156         // generates 3 bytes of output...
 157         KBD_ID1,
 158         KBD_ID2,
 159
 160
 161     } state;
 162
 163
 164     enum {
 165         // after receiving a mouse command 0f 0xff
 166         // we return the ack and then the next thing will be the
 167         // bat code (aa - success)
 168         RESET1,
 169         // followed by the device id (00 - mouse)
 170         RESET2,
 171         // Then it goes into stream mode
 172         STREAM1,  //
 173         STREAM2,  //
 174         STREAM3,  // for each of the following bytes in mouse_packet
 175         // this is used for setting sample rate
 176         SAMPLE1,
 177         // this is used for getting device id
 178         DEVICE1,
 179         // just like the stream moes
 180         REMOTE1,
 181         REMOTE2,
 182         REMOTE3,
 183         // For getting status info
 184         STATUS1,
 185         STATUS2,
 186         STATUS3,
 187         // set resolution
 188         SETRES1,
 189     } mouse_state;
 190
 191
 192     uchar_t wrap;
 193     uchar_t mouse_packet[3];  // byte 1: y over, xover, y sign, x sign, 1, middle, right, left
 194     // byte 2: x movement
 195     // byte 3: y movement
 196
 197     uchar_t mouse_needs_ack;  //
 198     uchar_t mouse_done_after_ack;
 199
 200     uchar_t cmd_byte;         //  for keyboard uC - read/written
 201     //     via read/write cmd byte command
 202     uchar_t status_byte;      //  for on-board uC - read via 64h
 203
 204     uchar_t output_byte;      //  output port of onboard uC (e.g. A20)
 205
 206     uchar_t input_byte;       //  input port of onboard uC
 207
 208     // Data for system
 209     uchar_t output_queue;     //
 210     uint_t  output_queue_len; //
 211     //uint_t  output_queue_read;
 212     //uint_t  output_queue_write;
 213
 214
 215 };
 216
 217
 218 static int keyboard_interrupt(struct vm_device * dev, uint_t irq) {
 219     struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
 220
 221     PrintDebug("keyboard: interrupt 0x%x\n", irq);
 222
 223     if (state->cmd_byte & CMD_INTR) {
 224         v3_raise_irq(dev->vm, irq);
 225     }
 226
 227     return 0;
 228 }
 229
 230
 231
 232 //
 233 // push item onto outputqueue, optionally overwriting if there is no room
 234 // returns 0 if successful
 235 //
 236 static int PushToOutputQueue(struct vm_device * dev, uchar_t value, uchar_t overwrite, uchar_t cmd, uchar_t mouse)
 237 {
 238     struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
 239
 240     if ((state->output_queue_len == 0) || overwrite) {
 241
 242         state->output_queue = value;
 243         state->output_queue_len = 1;
 244
 245         if (cmd) {
 246             state->status_byte |= STATUS_COMMAND_DATA_AVAIL;
 247         } else {
 248             state->status_byte &= ~STATUS_COMMAND_DATA_AVAIL;
 249         }
 250
 251         if (mouse) {
 252             state->status_byte |= STATUS_MOUSE_BUFFER_FULL;
 253             keyboard_interrupt(dev, MOUSE_IRQ);
 254         } else {
 255             keyboard_interrupt(dev, KEYBOARD_IRQ);
 256         }
 257
 258         state->status_byte |= STATUS_OUTPUT_BUFFER_FULL;
 259
 260         return 0;
 261
 262     } else {
 263         PrintError("keyboard: PushToOutputQueue Failed - Queue Full\n");
 264         return -1;
 265     }
 266 }
 267
 268
 269 //
 270 // pull item from outputqueue
 271 // returns 0 if successful
 272 //
 273 static int PullFromOutputQueue(struct vm_device * dev, uchar_t * value)
 274 {
 275     struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
 276
 277     if (1 || (state->output_queue_len == 1)) {
 278
 279         *value = state->output_queue;
 280         state->output_queue_len = 0;
 281
 282         if (state->status_byte & STATUS_OUTPUT_BUFFER_FULL) {
 283             state->status_byte &= ~STATUS_OUTPUT_BUFFER_FULL;
 284         }
 285
 286         if (state->status_byte & STATUS_MOUSE_BUFFER_FULL) {
 287             state->status_byte &= ~STATUS_MOUSE_BUFFER_FULL;
 288         }
 289
 290         if (state->status_byte & STATUS_COMMAND_DATA_AVAIL) {
 291             state->status_byte &= ~STATUS_COMMAND_DATA_AVAIL;
 292         } // reset to data
 293
 294
 295         return 0;
 296     } else {
 297         PrintError("keyboard: PullFromOutputQueue Failed - Queue Empty\n");
 298         return -1;
 299     }
 300 }
 301
 302
 303
 304
 305 static int key_event_handler(struct guest_info * info,
 306                              struct v3_keyboard_event * evt,
 307                              void * private_data) {
 308     struct vm_device * dev = (struct vm_device *)private_data;
 309     struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
 310
 311     PrintDebug("keyboard: injected status 0x%x, and scancode 0x%x\n", evt->status, evt->scan_code);
 312
 313     if ( (state->status_byte & STATUS_ENABLED)      // onboard is enabled
 314          && (!(state->cmd_byte & CMD_DISABLE)) )  {   // keyboard is enabled
 315
 316         PushToOutputQueue(dev, evt->scan_code, OVERWRITE, DATA, KEYBOARD);
 317     }
 318
 319     return 0;
 320 }
 321
 322
 323 static int mouse_event_handler(struct guest_info * info,
 324                                struct v3_mouse_event * evt,
 325                                void * private_data) {
 326     struct vm_device * dev = (struct vm_device *)private_data;
 327     struct keyboard_internal * state = (struct keyboard_internal *)(dev->private_data);
 328
 329     PrintDebug("keyboard: injected mouse packet 0x %x %x %x\n",
 330                evt->data[0], evt->data[1], evt->data[2]);
 331
 332     memcpy(state->mouse_packet, evt->data, 3);
 333
 334     state->status_byte |= STATUS_MOUSE_BUFFER_FULL;
 335
 336
 337     switch (state->mouse_state) {
 338         case STREAM1:
 339         case STREAM2:
 340         case STREAM3:
 341             if (!(state->cmd_byte & CMD_MOUSE_DISABLE)) {
 342                 keyboard_interrupt(dev, MOUSE_IRQ);
 343             }
 344             break;
 345         default:
 346             return -1;
 347             break;
 348     }
 349
 350     return 0;
 351 }
 352
 353
 354 static int keyboard_reset_device(struct vm_device * dev)
 355 {
 356     struct keyboard_internal *data = (struct keyboard_internal *)(dev->private_data);
 357
 358     memset(data, 0, sizeof(struct keyboard_internal));
 359
 360     data->state = NORMAL;
 361     data->mouse_state = STREAM1;
 362
 363     data->cmd_byte =
 364         CMD_INTR          // interrupts on
 365         | CMD_MOUSE_INTR  // mouse interupts on
 366         | CMD_SYSTEM ;    // self test passed
 367     // PS2, keyboard+mouse enabled, generic translation
 368
 369     data->status_byte =
 370         STATUS_SYSTEM       // self-tests passed
 371         | STATUS_ENABLED ;  // keyboard ready
 372     // buffers empty, no errors
 373
 374     data->output_byte = 0;  //  ?
 375
 376     data->input_byte = INPUT_RAM;  // we have some
 377     // also display=color, jumper 0, keyboard enabled
 378
 379
 380
 381     PrintDebug("keyboard: reset device\n");
 382
 383     return 0;
 384
 385 }
 386
 387
 388
 389 static int keyboard_start_device(struct vm_device *dev)
 390 {
 391     PrintDebug("keyboard: start device\n");
 392     return 0;
 393 }
 394
 395
 396 static int keyboard_stop_device(struct vm_device *dev)
 397 {
 398     PrintDebug("keyboard: stop device\n");
 399     return 0;
 400 }
 401
 402
 403 static int mouse_read_input(struct vm_device *dev)
 404 {
 405     struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
 406
 407     if (state->mouse_needs_ack) {
 408         state->mouse_needs_ack = 0;
 409
 410         // the ack has been stuffed previously
 411         if (state->mouse_done_after_ack) {
 412             return 1;
 413         } else {
 414             return 0;
 415         }
 416     }
 417
 418     switch (state->mouse_state) {
 419
 420         case RESET1: // requesting the BAT code
 421             PushToOutputQueue(dev, 0xaa, OVERWRITE, DATA, MOUSE) ;  // BAT successful
 422             PrintDebug(" mouse sent BAT code (sucesssful) ");
 423             state->mouse_state = RESET2;
 424
 425             return 0;  // not done with mouse processing yet
 426             break;
 427
 428         case RESET2: // requesting the device id
 429             PushToOutputQueue(dev, 0x00, OVERWRITE, DATA, MOUSE) ;  // normal mouse type
 430             PrintDebug(" mouse sent device id ");
 431             state->mouse_state = STREAM1;
 432
 433             return 1;  // done with mouse processing
 434             break;
 435
 436         case STREAM1: // send data
 437             PushToOutputQueue(dev, state->mouse_packet[0], OVERWRITE, DATA, MOUSE);
 438             PrintDebug(" mouse sent stream data1 ");
 439             state->mouse_state = STREAM2;
 440
 441             return 0;
 442             break;
 443
 444         case STREAM2: // send data
 445             PushToOutputQueue(dev, state->mouse_packet[1], OVERWRITE, DATA, MOUSE);
 446             PrintDebug(" mouse sent stream data2 ");
 447             state->mouse_state = STREAM3;
 448
 449             return 0;
 450             break;
 451
 452         case STREAM3: // send data
 453             PushToOutputQueue(dev, state->mouse_packet[2], OVERWRITE, DATA, MOUSE);
 454             PrintDebug(" mouse sent stream data3 ");
 455             state->mouse_state = STREAM1;
 456
 457             return 1; // now done
 458             break;
 459
 460         case REMOTE1: // send data
 461             PushToOutputQueue(dev, state->mouse_packet[0], OVERWRITE, DATA, MOUSE);
 462             PrintDebug(" mouse sent remote data1 ");
 463             state->mouse_state = REMOTE2;
 464
 465             return 0;
 466             break;
 467
 468         case REMOTE2: // send data
 469             PushToOutputQueue(dev, state->mouse_packet[1], OVERWRITE, DATA, MOUSE);
 470             PrintDebug(" mouse sent remote data2 ");
 471             state->mouse_state = REMOTE3;
 472
 473             return 0;
 474             break;
 475
 476         case REMOTE3: // send data
 477             PushToOutputQueue(dev, state->mouse_packet[2], OVERWRITE, DATA, MOUSE);
 478             PrintDebug(" mouse sent remote data3 ");
 479             state->mouse_state = REMOTE1;
 480
 481             return 1; // now done
 482             break;
 483
 484         case STATUS1: // send data
 485             PushToOutputQueue(dev, 0x0, OVERWRITE, DATA, MOUSE);
 486             PrintDebug(" mouse sent status data1 ");
 487             state->mouse_state = STATUS2;
 488
 489             return 0;
 490             break;
 491
 492         case STATUS2: // send data
 493             PushToOutputQueue(dev, 0x0, OVERWRITE, DATA, MOUSE);
 494             PrintDebug(" mouse sent status data2 ");
 495             state->mouse_state = STATUS3;
 496
 497             return 0;
 498             break;
 499
 500         case STATUS3: // send data
 501             PushToOutputQueue(dev, 0x0, OVERWRITE, DATA, MOUSE);
 502             PrintDebug(" mouse sent status data3 ");
 503             state->mouse_state = STREAM1;
 504
 505             return 1; // now done
 506             break;
 507
 508         case DEVICE1: // send device id
 509             PushToOutputQueue(dev, 0x0, OVERWRITE, DATA, MOUSE);
 510             PrintDebug(" mouse sent device id ");
 511             state->mouse_state = STREAM1;
 512
 513             return 1; // now done
 514             break;
 515
 516         default:
 517             PrintDebug(" mouse has no data ");
 518             return 1; // done
 519             break;
 520     }
 521 }
 522
 523 static int mouse_write_output(struct vm_device * dev, uchar_t data)
 524 {
 525     struct keyboard_internal * state = (struct keyboard_internal *)(dev->private_data);
 526
 527     switch (state->mouse_state) {
 528         case STREAM1:
 529         case STREAM2:
 530         case STREAM3:
 531         case REMOTE1:
 532         case REMOTE2:
 533         case REMOTE3:
 534             switch (data) {
 535
 536                 case 0xff: //reset
 537                     PushToOutputQueue(dev, 0xfe, OVERWRITE, DATA, MOUSE) ;   // no mouse!
 538                     PrintDebug(" mouse reset begins (no mouse) ");
 539
 540                     return 1;  // not done;
 541                     break;
 542
 543                     /*
 544                       case 0xff: //reset
 545                       PushToOutputQueue(dev,0xfa,OVERWRITE,DATA,MOUSE) ;
 546                       PrintDebug(" mouse reset begins ");
 547                       state->mouse_done_after_ack=0;
 548                       state->mouse_needs_ack=1;
 549                       state->mouse_state=RESET1;
 550                       return 0;  // not done;
 551                       break;
 552                     */
 553                 case 0xfe: //resend
 554                     PushToOutputQueue(dev, 0xfa, OVERWRITE, DATA, MOUSE) ;
 555                     PrintDebug(" mouse resend begins ");
 556                     state->mouse_done_after_ack = 0;
 557                     state->mouse_needs_ack = 0;
 558                     state->mouse_state = STREAM1;
 559                     return 0;  // not done
 560                     break;
 561
 562                 case 0xf6: // set defaults
 563                     PushToOutputQueue(dev, 0xfa, OVERWRITE, DATA, MOUSE) ;
 564                     PrintDebug(" mouse set defaults ");
 565                     state->mouse_done_after_ack = 1;
 566                     state->mouse_needs_ack = 1;
 567                     state->mouse_state = STREAM1;
 568                     return 0; // not done
 569                     break;
 570
 571                 case 0xf5: // disable data reporting
 572                     PushToOutputQueue(dev, 0xfa, OVERWRITE, DATA, MOUSE) ;
 573                     state->mouse_done_after_ack = 1;
 574                     state->mouse_needs_ack = 1;
 575                     PrintDebug(" mouse disable data reporting ");
 576                     state->mouse_state = STREAM1;
 577                     return 0; // not done
 578                     break;
 579
 580                 case 0xf4: // enable data reporting
 581                     PushToOutputQueue(dev, 0xfa, OVERWRITE, DATA, MOUSE) ;
 582                     state->mouse_done_after_ack = 1;
 583                     state->mouse_needs_ack = 1;
 584                     PrintDebug(" mouse enable data reporting ");
 585                     state->mouse_state = STREAM1;
 586                     return 0; // not done
 587                     break;
 588
 589                 case 0xf3: // set sample rate
 590                     PushToOutputQueue(dev, 0xfa, OVERWRITE, DATA, MOUSE) ;
 591                     state->mouse_done_after_ack = 0;
 592                     state->mouse_needs_ack = 1;
 593                     PrintDebug(" mouse set sample rate begins ");
 594                     state->mouse_state = SAMPLE1;
 595                     return 0; // not done
 596                     break;
 597
 598                 case 0xf2: // get device id
 599                     PushToOutputQueue(dev, 0xfa, OVERWRITE, DATA, MOUSE) ;
 600                     state->mouse_done_after_ack = 0;
 601                     state->mouse_needs_ack = 1;
 602                     PrintDebug(" mouse get device id begins ");
 603                     state->mouse_state = DEVICE1;
 604                     return 0; // not done
 605                     break;
 606
 607                 case 0xf0: // set remote mode
 608                     PushToOutputQueue(dev, 0xfa, OVERWRITE, DATA, MOUSE) ;
 609                     state->mouse_done_after_ack = 1;
 610                     state->mouse_needs_ack = 1;
 611                     PrintDebug(" mouse set remote mode  ");
 612                     state->mouse_state = REMOTE1;
 613                     return 0; // not done
 614                     break;
 615
 616                 case 0xee: // set wrap mode
 617                     PushToOutputQueue(dev, 0xfa, OVERWRITE, DATA, MOUSE) ;
 618                     state->mouse_done_after_ack = 1;
 619                     state->mouse_needs_ack = 1;
 620                     PrintDebug(" mouse set wrap mode (ignored)  ");
 621                     state->mouse_state = STREAM1;
 622                     return 0; // not done
 623                     break;
 624
 625                 case 0xec: // reset wrap mode
 626                     PushToOutputQueue(dev, 0xfa, OVERWRITE, DATA, MOUSE) ;
 627                     state->mouse_done_after_ack = 1;
 628                     state->mouse_needs_ack = 1;
 629                     PrintDebug(" mouse reset wrap mode (ignored)  ");
 630                     state->mouse_state = STREAM1;
 631                     return 0; // done
 632                     break;
 633
 634                 case 0xeb: // read data
 635                     PushToOutputQueue(dev, 0xfa, OVERWRITE, DATA, MOUSE) ;
 636                     state->mouse_done_after_ack = 0;
 637                     state->mouse_needs_ack = 1;
 638                     PrintDebug(" mouse switch to wrap mode (ignored)  ");
 639                     state->mouse_state = REMOTE1;
 640                     return 0; // not done
 641                     break;
 642
 643                 case 0xea: // set stream mode
 644                     PushToOutputQueue(dev, 0xfa, OVERWRITE, DATA, MOUSE) ;
 645                     state->mouse_done_after_ack = 1;
 646                     state->mouse_needs_ack = 1;
 647                     PrintDebug(" mouse set stream mode  ");
 648                     state->mouse_state = STREAM1;
 649                     return 0; // not done
 650                     break;
 651
 652                 case 0xe9: // status request
 653                     PushToOutputQueue(dev, 0xfa, OVERWRITE, DATA, MOUSE) ;
 654                     state->mouse_done_after_ack = 0;
 655                     state->mouse_needs_ack = 1;
 656                     PrintDebug(" mouse status request begins  ");
 657                     state->mouse_state = STATUS1;
 658                     return 0; // notdone
 659                     break;
 660
 661                 case 0xe8: // set resolution
 662                     PushToOutputQueue(dev, 0xfa, OVERWRITE, DATA, MOUSE) ;
 663                     state->mouse_done_after_ack = 0;
 664                     state->mouse_needs_ack = 1;
 665                     PrintDebug(" mouse set resolution begins  ");
 666                     state->mouse_state = SETRES1;
 667                     return 0; // notdone
 668                     break;
 669
 670                 case 0xe7: // set scaling 2:1
 671                     PushToOutputQueue(dev, 0xfa, OVERWRITE, DATA, MOUSE) ;
 672                     state->mouse_done_after_ack = 1;
 673                     state->mouse_needs_ack = 1;
 674                     PrintDebug(" mouse set scaling 2:1 ");
 675                     state->mouse_state = STREAM1;
 676                     return 0; // not done
 677                     break;
 678
 679                 case 0xe6: // set scaling 1:1
 680                     PushToOutputQueue(dev, 0xfa, OVERWRITE, DATA, MOUSE) ;
 681                     state->mouse_done_after_ack = 1;
 682                     state->mouse_needs_ack = 1;
 683                     PrintDebug(" mouse set scaling 1:1 ");
 684                     state->mouse_state = STREAM1;
 685                     return 0; // done
 686                     break;
 687
 688                 default:
 689                     PrintDebug(" receiving unknown mouse command (0x%x) in acceptable state ", data);
 690                     return 1; // done
 691                     break;
 692
 693             }
 694
 695         default:
 696             PrintDebug(" receiving mouse output in unhandled state (0x%x) ", state->mouse_state);
 697             break;
 698             return 1; // done?
 699             break;
 700     }
 701
 702     PrintDebug(" HUH? ");
 703     return 1; // done
 704 }
 705
 706
 707
 708 #if KEYBOARD_DEBUG_80H
 709 static int keyboard_write_delay(ushort_t port,
 710                                 void * src,
 711                                 uint_t length,
 712                                 struct vm_device * dev)
 713 {
 714
 715     if (length == 1) {
 716         PrintDebug("keyboard: write of 0x%x to 80h\n", *((uchar_t*)src));
 717
 718         return 1;
 719     } else {
 720         PrintDebug("keyboard: write of >1 byte to 80h\n", *((uchar_t*)src));
 721
 722         return length;
 723     }
 724 }
 725
 726 static int keyboard_read_delay(ushort_t port,
 727                                void * dest,
 728                                uint_t length,
 729                                struct vm_device * dev)
 730 {
 731
 732     if (length == 1) {
 733         *((uchar_t*)dest) = v3_inb(port);
 734
 735         PrintDebug("keyboard: read of 0x%x from 80h\n", *((uchar_t*)dest));
 736
 737         return 1;
 738     } else {
 739         PrintDebug("keyboard: read of >1 byte from 80h\n");
 740
 741         return length;
 742     }
 743 }
 744 #endif
 745
 746
 747
 748
 749
 750 static int keyboard_write_command(ushort_t port,
 751                                   void * src,
 752                                   uint_t length,
 753                                   struct vm_device * dev)
 754 {
 755     struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
 756     uchar_t cmd;
 757
 758     // Should always be single byte write
 759
 760     if (length != 1) {
 761         PrintError("keyboard: write of >1 bytes (%d) to 64h\n", length);
 762         return -1;
 763     }
 764
 765     cmd = *((uchar_t*)src);
 766
 767     if (state->state != NORMAL) {
 768         PrintDebug("keyboard: warning - receiving command on 64h but state != NORMAL\n");
 769     }
 770
 771     PrintDebug("keyboard: command 0x%x on 64h\n", cmd);
 772
 773     switch (cmd) {
 774
 775         case 0x20:  // READ COMMAND BYTE (returned in 60h)
 776             PushToOutputQueue(dev, state->cmd_byte, OVERWRITE, COMMAND,KEYBOARD);
 777             state->state = NORMAL;  // the next read on 0x60 will get the right data
 778             PrintDebug("keyboard: command byte 0x%x returned\n", state->cmd_byte);
 779             break;
 780
 781         case 0x60:  // WRITE COMMAND BYTE (read from 60h)
 782             state->state = WRITING_CMD_BYTE; // we need to make sure we send the next 0x60 byte appropriately
 783             PrintDebug("keyboard: prepare to write command byte\n");
 784             break;
 785
 786             // case 0x90-9f - write to output port  (?)
 787
 788         case 0xa1: // Get version number
 789             PushToOutputQueue(dev, 0, OVERWRITE, COMMAND, KEYBOARD);
 790             state->state = NORMAL;
 791             PrintDebug("keyboard: version number 0x0 returned\n");
 792             break;
 793
 794         case 0xa4:  // is password installed?  send result to 0x60
 795             // we don't support passwords
 796             PushToOutputQueue(dev, 0xf1, OVERWRITE, COMMAND, KEYBOARD);
 797             PrintDebug("keyboard: password not installed\n");
 798             state->state = NORMAL;
 799             break;
 800
 801         case 0xa5:  // new password will arrive on 0x60
 802             state->state = TRANSMIT_PASSWD;
 803             PrintDebug("keyboard: pepare to transmit password\n");
 804             break;
 805
 806         case 0xa6:  // check passwd;
 807             // since we do not support passwords, we will simply ignore this
 808             // the implication is that any password check immediately succeeds
 809             // with a blank password
 810             state->state = NORMAL;
 811             PrintDebug("keyboard: password check succeeded\n");
 812             break;
 813
 814         case 0xa7:  // disable mouse
 815             state->cmd_byte |= CMD_MOUSE_DISABLE;
 816             state->state = NORMAL;
 817             PrintDebug("keyboard: mouse disabled\n");
 818             break;
 819
 820         case 0xa8:  // enable mouse
 821             state->cmd_byte &= ~CMD_MOUSE_DISABLE;
 822             state->state = NORMAL;
 823             PrintDebug("keyboard: mouse enabled\n");
 824             break;
 825
 826         case 0xa9:  // mouse interface test  (always succeeds)
 827             PushToOutputQueue(dev, 0, OVERWRITE, COMMAND, KEYBOARD);
 828             PrintDebug("keyboard: mouse interface test succeeded\n");
 829             state->state = NORMAL;
 830             break;
 831
 832         case 0xaa:  // controller self test (always succeeds)
 833             PushToOutputQueue(dev, 0x55, OVERWRITE, COMMAND, KEYBOARD);
 834             PrintDebug("keyboard: controller self test succeeded\n");
 835             state->state = NORMAL;
 836             break;
 837
 838         case 0xab:  // keyboard interface test (always succeeds)
 839             PushToOutputQueue(dev, 0, OVERWRITE, COMMAND, KEYBOARD);
 840             state->state = NORMAL;
 841             PrintDebug("keyboard: keyboard interface test succeeded\n");
 842             break;
 843
 844         case 0xad:  // disable keyboard
 845             state->cmd_byte |= CMD_DISABLE;
 846             state->state = NORMAL;
 847             PrintDebug("keyboard: keyboard disabled\n");
 848             break;
 849
 850         case 0xae:  // enable keyboard
 851             state->cmd_byte &= ~CMD_DISABLE;
 852             state->state = NORMAL;
 853             PrintDebug("keyboard: keyboard enabled\n");
 854             break;
 855
 856         case 0xaf:  // get version
 857             PushToOutputQueue(dev, 0x00, OVERWRITE, COMMAND, KEYBOARD);
 858             state->state = NORMAL;
 859             PrintDebug("keyboard: version 0 returned \n");
 860             break;
 861
 862         case 0xd0: // return microcontroller output on 60h
 863             PushToOutputQueue(dev, state->output_byte, OVERWRITE, COMMAND, KEYBOARD);
 864             state->state = NORMAL;
 865             PrintDebug("keyboard: output byte 0x%x returned\n", state->output_byte);
 866             break;
 867
 868         case 0xd1: // request to write next byte on 60h to the microcontroller output port
 869             state->state = WRITING_OUTPUT_PORT;
 870             PrintDebug("keyboard: prepare to write output byte\n");
 871             break;
 872
 873         case 0xd2:  //  write keyboard buffer (inject key)
 874             state->state = INJECTING_KEY;
 875             PrintDebug("keyboard: prepare to inject key\n");
 876             break;
 877
 878         case 0xd3: //  write mouse buffer (inject mouse)
 879             state->state = INJECTING_MOUSE;
 880             PrintDebug("keyboard: prepare to inject mouse\n");
 881             break;
 882
 883         case 0xd4: // write mouse device (command to mouse?)
 884             state->state = IN_MOUSE;
 885             PrintDebug("keyboard: prepare to inject mouse command\n");
 886             break;
 887
 888         case 0xc0: //  read input port
 889             PushToOutputQueue(dev, state->input_byte, OVERWRITE, COMMAND, KEYBOARD);
 890             state->state = NORMAL;
 891             PrintDebug("keyboard: input byte 0x%x returned\n", state->input_byte);
 892             break;
 893
 894         case 0xc1:  //copy input port lsn to status msn
 895             state->status_byte &= 0x0f;
 896             state->status_byte |= (state->input_byte & 0xf) << 4;
 897             state->state = NORMAL;
 898             PrintDebug("keyboard: copied input byte lsn to status msn\n");
 899             break;
 900
 901         case 0xc2: // copy input port msn to status msn
 902             state->status_byte &= 0x0f;
 903             state->status_byte |= (state->input_byte & 0xf0);
 904             state->state = NORMAL;
 905             PrintDebug("keyboard: copied input byte msn to status msn\n");
 906             break;
 907
 908         case 0xe0: // read test port
 909             PushToOutputQueue(dev, state->output_byte >> 6, OVERWRITE, COMMAND, KEYBOARD);
 910             state->state = NORMAL;
 911             PrintDebug("keyboard: read 0x%x from test port\n", state->output_byte >> 6);
 912             break;
 913
 914
 915         case 0xf0:   // pulse output port
 916         case 0xf1:   // this should pulse 0..3 of cmd_byte on output port
 917         case 0xf2:   // instead of what is currently in output_byte (I think)
 918         case 0xf3:   // main effect is taht if bit zero is zero
 919         case 0xf4:   // should cause reset
 920         case 0xf5:   // I doubt anything more recent than a 286 running
 921         case 0xf6:   // OS2 with the penalty box will care
 922         case 0xf7:
 923         case 0xf8:
 924         case 0xf9:
 925         case 0xfa:
 926         case 0xfb:
 927         case 0xfc:
 928         case 0xfd:
 929         case 0xfe:
 930         case 0xff:
 931
 932             PrintDebug("keyboard: ignoring pulse of 0x%x (low=pulsed) on output port\n", (cmd & 0xf));
 933             state->state = NORMAL;
 934             break;
 935
 936
 937             // case ac  diagonstic - returns 16 bytes from keyboard microcontroler on 60h
 938         default:
 939             PrintDebug("keyboard: ignoring command (unimplemented)\n");
 940             state->state = NORMAL;
 941             break;
 942     }
 943
 944     return 1;
 945
 946 }
 947
 948 static int keyboard_read_status(ushort_t port,
 949                                 void * dest,
 950                                 uint_t length,
 951                                 struct vm_device * dev)
 952 {
 953     struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
 954
 955     if (length == 1) {
 956
 957         PrintDebug("keyboard: read status (64h): ");
 958
 959         *((uchar_t*)dest) = state->status_byte;
 960
 961         PrintDebug("0x%x\n", *((uchar_t*)dest));
 962
 963         return 1;
 964     } else {
 965         PrintError("keyboard: >1 byte read for status (64h)\n");
 966         return -1;
 967     }
 968 }
 969
 970 static int keyboard_write_output(ushort_t port,
 971                                  void * src,
 972                                  uint_t length,
 973                                  struct vm_device * dev)
 974 {
 975     struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
 976
 977     if (length != 1) {
 978         PrintError("keyboard: write of 60h with >1 byte\n");
 979         return -1;
 980     }
 981
 982     uchar_t data = *((uchar_t*)src);
 983
 984     PrintDebug("keyboard: output 0x%x on 60h\n", data);
 985
 986     switch (state->state) {
 987         case WRITING_CMD_BYTE:
 988             state->cmd_byte = data;
 989             state->state = NORMAL;
 990             PrintDebug("keyboard: wrote new command byte 0x%x\n", state->cmd_byte);
 991             break;
 992         case WRITING_OUTPUT_PORT:
 993             state->output_byte = data;
 994             state->state = NORMAL;
 995             PrintDebug("keyboard: wrote new output byte 0x%x\n", state->output_byte);
 996             break;
 997         case INJECTING_KEY:
 998             PushToOutputQueue(dev, data, OVERWRITE, COMMAND, KEYBOARD);  // probably should be a call to deliver_key_to_vmm()
 999             state->state = NORMAL;
1000             PrintDebug("keyboard: injected key 0x%x\n", data);
1001             break;
1002         case INJECTING_MOUSE:
1003             PushToOutputQueue(dev, data, OVERWRITE, DATA, MOUSE);
1004             //      PrintDebug("keyboard: ignoring injected mouse event 0x%x\n", data);
1005             PrintDebug("keyboard: injected mouse event 0x%x\n", data);
1006             state->state = NORMAL;
1007             break;
1008         case IN_MOUSE:
1009             PrintDebug("keyboard: mouse action: ");
1010             if (mouse_write_output(dev, data)) {
1011                 state->state = NORMAL;
1012             }
1013             PrintDebug("\n");
1014             break;
1015         case TRANSMIT_PASSWD:
1016             if (data) {
1017                 //ignore passwd
1018                 PrintDebug("keyboard: ignoring password character 0x%x\n",data);
1019             } else {
1020                 // end of password
1021                 state->state = NORMAL;
1022                 PrintDebug("keyboard: done with password\n");
1023             }
1024             break;
1025         case SET_LEDS:
1026             PrintDebug("Keyboard: LEDs being set...\n");
1027             PushToOutputQueue(dev, 0xfa, OVERWRITE, COMMAND, KEYBOARD);
1028             state->state = NORMAL;
1029             break;
1030         case SET_RATE:
1031             PrintDebug("Keyboard: Rate being set...\n");
1032             PushToOutputQueue(dev, 0xfa, OVERWRITE, COMMAND, KEYBOARD);
1033             state->state = NORMAL;
1034             break;
1035         default:
1036         case NORMAL:
1037             {
1038                 // command is being sent to keyboard controller
1039                 switch (data) {
1040                     case 0xff: // reset
1041                         PushToOutputQueue(dev, 0xfa, OVERWRITE, COMMAND, KEYBOARD); // ack
1042                         state->state = RESET;
1043                         PrintDebug("keyboard: reset complete and acked\n");
1044                         break;
1045                     case 0xf5: // disable scanning
1046                     case 0xf4: // enable scanning
1047                         // ack
1048                         PushToOutputQueue(dev, 0xfa, OVERWRITE, COMMAND, KEYBOARD);
1049                         // should do something here... PAD
1050                         state->state = NORMAL;
1051                         PrintDebug("keyboard: %s scanning done and acked\n", (data == 0xf5) ? "disable" : "enable");
1052                         break;
1053                     case 0xf3:
1054                         PushToOutputQueue(dev, 0xfa, OVERWRITE, COMMAND, KEYBOARD);
1055                         state->state = SET_RATE;
1056                         break;
1057                     case 0xf2: // get keyboard ID
1058                         PushToOutputQueue(dev, 0xfa, OVERWRITE, COMMAND, KEYBOARD);
1059                         state->state = KBD_ID1;
1060                         PrintDebug("Keyboard: Requesting Keyboard ID\n");
1061
1062                         //PushToOutputQueue(dev, 0xab, OVERWRITE, COMMAND, KEYBOARD);
1063                         //state->state = KBD_ID2;
1064                         break;
1065                     case 0xed: // enable keyboard LEDs
1066                         PushToOutputQueue(dev, 0xfa, OVERWRITE, COMMAND, KEYBOARD);
1067                         state->state = SET_LEDS;
1068                         break;
1069                     case 0xfe: // resend
1070                     case 0xfd: // set key type make
1071                     case 0xfc: // set key typ make/break
1072                     case 0xfb: // set key type typematic
1073                     case 0xfa: // set all typematic make/break/typematic
1074                     case 0xf9: // set all make
1075                     case 0xf8: // set all make/break
1076                     case 0xf7: // set all typemaktic
1077                     case 0xf6: // set defaults
1078                         PrintDebug("keyboard: unhandled known command 0x%x on output buffer (60h)\n", data);
1079                         return -1;
1080                         break;
1081                     default:
1082                         PrintDebug("keyboard: unhandled unknown command 0x%x on output buffer (60h)\n", data);
1083                         state->status_byte |= 0x1;
1084                         return -1;
1085                         break;
1086                 }
1087                 break;
1088             }
1089
1090     }
1091
1092     return 1;
1093 }
1094
1095 static int keyboard_read_input(ushort_t port,
1096                                void * dest,
1097                                uint_t length,
1098                                struct vm_device * dev)
1099 {
1100     struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
1101
1102     if (length == 1) {
1103         uchar_t data;
1104         int done_mouse;
1105
1106         PrintDebug("keyboard: read from input (60h): ");
1107
1108         if (state->state == IN_MOUSE) {
1109             done_mouse = mouse_read_input(dev);
1110             if (done_mouse) {
1111                 state->state = NORMAL;
1112             }
1113         }
1114
1115         PullFromOutputQueue(dev, &data);
1116
1117         if (state->state == RESET) {
1118             // We just delivered the ack for the reset
1119             // now we will ready ourselves to deliver the BAT code (success)
1120             PushToOutputQueue(dev, 0xaa, OVERWRITE, COMMAND, KEYBOARD);
1121             state->state = NORMAL;
1122             PrintDebug(" (in reset, pushing BAT test code 0xaa) ");
1123         } else if (state->state == KBD_ID1) {
1124             PushToOutputQueue(dev, 0xab, OVERWRITE, COMMAND, KEYBOARD);
1125             state->state = KBD_ID2;
1126             PrintDebug(" (in kbd id request, pushing 1st ID val) ");
1127         } else if (state->state == KBD_ID2) {
1128             PushToOutputQueue(dev, 0x83, OVERWRITE, COMMAND, KEYBOARD);
1129             state->state = NORMAL;
1130             PrintDebug(" (in kbd id request, pushing 2nd ID val) ");
1131         }
1132
1133         PrintDebug("0x%x\n", data);
1134
1135         *((uchar_t*)dest) = data;
1136
1137         return 1;
1138     } else {
1139         PrintError("keyboard: unknown size read from input (60h)\n");
1140         return -1;
1141     }
1142 }
1143
1144
1145
1146
1147
1148 static int keyboard_init_device(struct vm_device * dev)
1149 {
1150
1151     //  struct keyboard_internal *data = (struct keyboard_internal *) dev->private_data;
1152
1153     PrintDebug("keyboard: init_device\n");
1154
1155     // Would read state here
1156
1157     keyboard_reset_device(dev);
1158
1159     // hook ports
1160     v3_dev_hook_io(dev, KEYBOARD_64H, &keyboard_read_status, &keyboard_write_command);
1161     v3_dev_hook_io(dev, KEYBOARD_60H, &keyboard_read_input, &keyboard_write_output);
1162
1163     v3_hook_host_event(dev->vm, HOST_KEYBOARD_EVT, V3_HOST_EVENT_HANDLER(key_event_handler), dev);
1164     v3_hook_host_event(dev->vm, HOST_MOUSE_EVT, V3_HOST_EVENT_HANDLER(mouse_event_handler), dev);
1165
1166
1167 #if KEYBOARD_DEBUG_80H
1168     v3_dev_hook_io(dev, KEYBOARD_DELAY_80H, &keyboard_read_delay, &keyboard_write_delay);
1169 #endif
1170
1171
1172     //
1173     // We do not hook the IRQ here.  Instead, the underlying device driver
1174     // is responsible to call us back
1175     //
1176
1177     return 0;
1178 }
1179
1180 static int keyboard_deinit_device(struct vm_device *dev)
1181 {
1182
1183     v3_dev_unhook_io(dev, KEYBOARD_60H);
1184     v3_dev_unhook_io(dev, KEYBOARD_64H);
1185 #if KEYBOARD_DEBUG_80H
1186     v3_dev_unhook_io(dev, KEYBOARD_DELAY_80H);
1187 #endif
1188     keyboard_reset_device(dev);
1189     return 0;
1190 }
1191
1192
1193
1194
1195
1196 static struct vm_device_ops dev_ops = {
1197     .init = keyboard_init_device,
1198     .deinit = keyboard_deinit_device,
1199     .reset = keyboard_reset_device,
1200     .start = keyboard_start_device,
1201     .stop = keyboard_stop_device,
1202 };
1203
1204
1205
1206
1207 struct vm_device * v3_create_keyboard() {
1208     struct keyboard_internal * keyboard_state = NULL;
1209
1210     keyboard_state = (struct keyboard_internal *)V3_Malloc(sizeof(struct keyboard_internal));
1211
1212     struct vm_device *device = v3_create_device("KEYBOARD", &dev_ops, keyboard_state);
1213
1214
1215     return device;
1216 }