/////////////////////////////////////////////////////////////////////////
// $Id: keyboard.cc,v 1.81 2003/07/31 19:51:42 vruppert Exp $
/////////////////////////////////////////////////////////////////////////
//
//  Copyright (C) 2002  MandrakeSoft S.A.
//
//    MandrakeSoft S.A.
//    43, rue d'Aboukir
//    75002 Paris - France
//    http://www.linux-mandrake.com/
//    http://www.mandrakesoft.com/
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA


// Now features proper implementation of keyboard opcodes 0xF4 to 0xF6
// Silently ignores PS/2 keyboard extensions (0xF7 to 0xFD)
// Explicit panic on resend (0xFE)
//
// Emmanuel Marty <core@ggi-project.org>

// NB: now the PS/2 mouse support is in, outb changes meaning
// in conjunction with auxb
// auxb == 0 && outb == 0  => both buffers empty (nothing to read)
// auxb == 0 && outb == 1  => keyboard controller output buffer full
// auxb == 1 && outb == 0  => not used
// auxb == 1 && outb == 1  => mouse output buffer full.
// (das)

// Notes from Christophe Bothamy <cbbochs@free.fr>
//
// This file includes code from Ludovic Lange (http://ludovic.lange.free.fr)
// Implementation of 3 scancodes sets mf1,mf2,mf3 with or without translation. 
// Default is mf2 with translation
// Ability to switch between scancodes sets
// Ability to turn translation on or off

// Define BX_PLUGGABLE in files that can be compiled into plugins.  For
// platforms that require a special tag on exported symbols, BX_PLUGGABLE 
// is used to know when we are exporting symbols and when we are importing.
#define BX_PLUGGABLE

#include "bochs.h"
#include <math.h>
#include "scancodes.h"

#define LOG_THIS  theKeyboard->
#define VERBOSE_KBD_DEBUG 0


bx_keyb_c *theKeyboard = NULL;

  int
libkeyboard_LTX_plugin_init(plugin_t *plugin, plugintype_t type, int argc, char *argv[])
{
  // Create one instance of the keyboard device object.
  theKeyboard = new bx_keyb_c ();
  // Before this plugin was loaded, pluginKeyboard pointed to a stub.
  // Now make it point to the real thing.
  bx_devices.pluginKeyboard = theKeyboard;
  // Register this device.
  BX_REGISTER_DEVICE_DEVMODEL (plugin, type, theKeyboard, BX_PLUGIN_KEYBOARD);
  return(0); // Success
}

  void
libkeyboard_LTX_plugin_fini(void)
{
  BX_INFO (("keyboard plugin_fini"));
}

bx_keyb_c::bx_keyb_c(void)
{
  // constructor
  put("KBD");
  settype(KBDLOG);
}

bx_keyb_c::~bx_keyb_c(void)
{
  // destructor
  BX_DEBUG(("Exit."));
}


// flush internal buffer and reset keyboard settings to power-up condition
  void
bx_keyb_c::resetinternals(bx_bool powerup)
{
  Bit32u   i;

  BX_KEY_THIS s.kbd_internal_buffer.num_elements = 0;
  for (i=0; i<BX_KBD_ELEMENTS; i++)
    BX_KEY_THIS s.kbd_internal_buffer.buffer[i] = 0;
  BX_KEY_THIS s.kbd_internal_buffer.head = 0;

  BX_KEY_THIS s.kbd_internal_buffer.expecting_typematic = 0;

  // Default scancode set is mf2 with translation
  BX_KEY_THIS s.kbd_controller.expecting_scancodes_set = 0;
  BX_KEY_THIS s.kbd_controller.current_scancodes_set = 1;
  BX_KEY_THIS s.kbd_controller.scancodes_translate = 1;
  
  if (powerup) {
    BX_KEY_THIS s.kbd_internal_buffer.expecting_led_write = 0;
    BX_KEY_THIS s.kbd_internal_buffer.delay = 1; // 500 mS
    BX_KEY_THIS s.kbd_internal_buffer.repeat_rate = 0x0b; // 10.9 chars/sec
    }
}



  void
bx_keyb_c::init(void)
{
  BX_DEBUG(("Init $Id: keyboard.cc,v 1.81 2003/07/31 19:51:42 vruppert Exp $"));
  Bit32u   i;

  DEV_register_irq(1, "8042 Keyboard controller");
  DEV_register_irq(12, "8042 Keyboard controller (PS/2 mouse)");

  DEV_register_ioread_handler(this, read_handler,
                                      0x0060, "8042 Keyboard controller", 1);
  DEV_register_ioread_handler(this, read_handler,
                                      0x0064, "8042 Keyboard controller", 1);
  DEV_register_iowrite_handler(this, write_handler,
                                      0x0060, "8042 Keyboard controller", 1);
  DEV_register_iowrite_handler(this, write_handler,
                                      0x0064, "8042 Keyboard controller", 1);
  BX_KEY_THIS timer_handle = bx_pc_system.register_timer( this, timer_handler,
                                 bx_options.Okeyboard_serial_delay->get(), 1, 1,
				 "8042 Keyboard controller");

  resetinternals(1);

  BX_KEY_THIS s.kbd_internal_buffer.led_status = 0;
  BX_KEY_THIS s.kbd_internal_buffer.scanning_enabled = 1;

  BX_KEY_THIS s.mouse_internal_buffer.num_elements = 0;
  for (i=0; i<BX_MOUSE_BUFF_SIZE; i++)
    BX_KEY_THIS s.mouse_internal_buffer.buffer[i] = 0;
  BX_KEY_THIS s.mouse_internal_buffer.head = 0;

  //  BX_INFO(("kbd: %04d outb 0 auxb 0",__LINE__)); // das
  BX_KEY_THIS s.kbd_controller.pare = 0;
  BX_KEY_THIS s.kbd_controller.tim  = 0;
  BX_KEY_THIS s.kbd_controller.auxb = 0;
  BX_KEY_THIS s.kbd_controller.keyl = 1;
  BX_KEY_THIS s.kbd_controller.c_d  = 1;
  BX_KEY_THIS s.kbd_controller.sysf = 0;
  BX_KEY_THIS s.kbd_controller.inpb = 0;
  BX_KEY_THIS s.kbd_controller.outb = 0;

  BX_KEY_THIS s.kbd_controller.kbd_clock_enabled = 1;
  BX_KEY_THIS s.kbd_controller.aux_clock_enabled = 0;
  BX_KEY_THIS s.kbd_controller.allow_irq1 = 1;
  BX_KEY_THIS s.kbd_controller.allow_irq12 = 1;
  BX_KEY_THIS s.kbd_controller.kbd_output_buffer = 0;
  BX_KEY_THIS s.kbd_controller.aux_output_buffer = 0;
  BX_KEY_THIS s.kbd_controller.last_comm = 0;
  BX_KEY_THIS s.kbd_controller.expecting_port60h = 0;
  BX_KEY_THIS s.kbd_controller.irq1_requested = 0;
  BX_KEY_THIS s.kbd_controller.irq12_requested = 0;
  BX_KEY_THIS s.kbd_controller.expecting_mouse_parameter = 0;

//BX_DEBUG(( "# Okeyboard_serial_delay is %u usec",
//        (unsigned) bx_options.Okeyboard_serial_delay->get ()));
  BX_KEY_THIS s.kbd_controller.timer_pending = 0;

  // Mouse initialization stuff
  BX_KEY_THIS s.mouse.sample_rate     = 100; // reports per second
  BX_KEY_THIS s.mouse.resolution_cpmm = 4;   // 4 counts per millimeter
  BX_KEY_THIS s.mouse.scaling         = 1;   /* 1:1 (default) */
  BX_KEY_THIS s.mouse.mode            = MOUSE_MODE_RESET;
  BX_KEY_THIS s.mouse.enable          = 0;
  BX_KEY_THIS s.mouse.delayed_dx      = 0;
  BX_KEY_THIS s.mouse.delayed_dy      = 0;

  for (i=0; i<BX_KBD_CONTROLLER_QSIZE; i++)
    BX_KEY_THIS s.controller_Q[i] = 0;
  BX_KEY_THIS s.controller_Qsize = 0;
  BX_KEY_THIS s.controller_Qsource = 0;

  // clear paste buffer
  BX_KEY_THIS pastebuf = NULL;
  BX_KEY_THIS pastebuf_len = 0;
  BX_KEY_THIS pastebuf_ptr = 0;
  BX_KEY_THIS paste_delay_changed ();
  BX_KEY_THIS stop_paste = 0;

  // mouse port installed on system board
  DEV_cmos_set_reg(0x14, DEV_cmos_get_reg(0x14) | 0x04);

#if BX_WITH_WX
  static bx_bool first_time = 1;
  if (first_time) {
    first_time = 0;
    // register shadow params (Experimental, not a complete list by far)
    bx_list_c *list = new bx_list_c (BXP_KBD_PARAMETERS, "Keyboard State", "", 20);
    list->add (new bx_shadow_bool_c (BXP_KBD_IRQ1_REQ, 
	  "Keyboard IRQ1 requested: ", "",
	  &BX_KEY_THIS s.kbd_controller.irq1_requested));
    list->add (new bx_shadow_bool_c (BXP_KBD_IRQ12_REQ,
	  "Keyboard IRQ12 requested: ", "",
	  &BX_KEY_THIS s.kbd_controller.irq12_requested));
    list->add (new bx_shadow_num_c (BXP_KBD_TIMER_PENDING,
	"Keyboard timer pending: ", "",
	&BX_KEY_THIS s.kbd_controller.timer_pending));
    list->add (new bx_shadow_bool_c (BXP_KBD_PARE,
	"Keyboard PARE", "",
	&BX_KEY_THIS s.kbd_controller.pare));
    list->add (new bx_shadow_bool_c (BXP_KBD_TIM,
	"Keyboard TIM", "",
	&BX_KEY_THIS s.kbd_controller.tim));
    list->add (new bx_shadow_bool_c (BXP_KBD_AUXB,
	"Keyboard AUXB", "",
	&BX_KEY_THIS s.kbd_controller.auxb));
    list->add (new bx_shadow_bool_c (BXP_KBD_KEYL,
	"Keyboard KEYL", "",
	&BX_KEY_THIS s.kbd_controller.keyl));
    list->add (new bx_shadow_bool_c (BXP_KBD_C_D,
	"Keyboard C_D", "",
	&BX_KEY_THIS s.kbd_controller.c_d));
    list->add (new bx_shadow_bool_c (BXP_KBD_SYSF,
	"Keyboard SYSF", "",
	&BX_KEY_THIS s.kbd_controller.sysf));
    list->add (new bx_shadow_bool_c (BXP_KBD_INPB,
	"Keyboard INPB", "",
	&BX_KEY_THIS s.kbd_controller.inpb));
    list->add (new bx_shadow_bool_c (BXP_KBD_OUTB,
	"Keyboard OUTB", "",
	&BX_KEY_THIS s.kbd_controller.outb));
  }
#endif
}

  void
bx_keyb_c::reset(unsigned type)
{
  if (BX_KEY_THIS pastebuf != NULL) {
    BX_KEY_THIS stop_paste = 1;
  }
}

  void
bx_keyb_c::paste_delay_changed()
{
  BX_KEY_THIS pastedelay = bx_options.Okeyboard_paste_delay->get()/BX_IODEV_HANDLER_PERIOD;
  BX_INFO(("will paste characters every %d keyboard ticks",BX_KEY_THIS pastedelay));
}

  // static IO port read callback handler
  // redirects to non-static class handler to avoid virtual functions

// read function - the big picture:
// if address == data port then
//    if byte for mouse then return it
//    else if byte for keyboard then return it
// else address== status port
//    assemble the status bits and return them.
//
  Bit32u
bx_keyb_c::read_handler(void *this_ptr, Bit32u address, unsigned io_len)
{
#if !BX_USE_KEY_SMF
  bx_keyb_c *class_ptr = (bx_keyb_c *) this_ptr;

  return( class_ptr->read(address, io_len) );
}


  Bit32u
bx_keyb_c::read(Bit32u   address, unsigned io_len)
{
#else
  UNUSED(this_ptr);
#endif  // !BX_USE_KEY_SMF

//BX_DEBUG(( "read from port 0x%04x", (unsigned) address));

  if (address == 0x60) { /* output buffer */
    Bit8u   val;
    if (BX_KEY_THIS s.kbd_controller.auxb) { /* mouse byte available */
      val = BX_KEY_THIS s.kbd_controller.aux_output_buffer;
      BX_KEY_THIS s.kbd_controller.aux_output_buffer = 0;
      //      BX_INFO(("kbd: %04d outb 0 auxb 0",__LINE__)); // das
      BX_KEY_THIS s.kbd_controller.outb = 0;
      BX_KEY_THIS s.kbd_controller.auxb = 0;
      BX_KEY_THIS s.kbd_controller.irq12_requested = 0;

      if (BX_KEY_THIS s.controller_Qsize) {
        unsigned i;
        BX_KEY_THIS s.kbd_controller.aux_output_buffer = BX_KEY_THIS s.controller_Q[0];
	//	BX_INFO(("kbd: %04d outb 1 auxb 1",__LINE__)); // das
        BX_KEY_THIS s.kbd_controller.outb = 1;
        BX_KEY_THIS s.kbd_controller.auxb = 1;
        if (BX_KEY_THIS s.kbd_controller.allow_irq12)
          BX_KEY_THIS s.kbd_controller.irq12_requested = 1;
        for (i=0; i<BX_KEY_THIS s.controller_Qsize-1; i++) {
          // move Q elements towards head of queue by one
          BX_KEY_THIS s.controller_Q[i] = BX_KEY_THIS s.controller_Q[i+1];
          }
        BX_KEY_THIS s.controller_Qsize--;
        }

//BX_DEBUG(("mouse: ___io_read aux = 0x%02x", (unsigned) val));

      DEV_pic_lower_irq(12);
      activate_timer();
      BX_DEBUG(("READ(%02x) (from mouse) = %02x", (unsigned) address,
          (unsigned) val));
      return val;
      }
    else if (BX_KEY_THIS s.kbd_controller.outb) { /* kbd byte available */
      val = BX_KEY_THIS s.kbd_controller.kbd_output_buffer;
      // BX_INFO(("kbd: %04d outb 0 auxb 0",__LINE__)); // das
      BX_KEY_THIS s.kbd_controller.outb = 0;
      BX_KEY_THIS s.kbd_controller.auxb = 0;
      BX_KEY_THIS s.kbd_controller.irq1_requested = 0;
//BX_DEBUG(( "___io_read kbd"));

      if (BX_KEY_THIS s.controller_Qsize) {
        unsigned i;
        BX_KEY_THIS s.kbd_controller.aux_output_buffer = BX_KEY_THIS s.controller_Q[0];
	//	BX_INFO(("kbd: %04d outb 1 auxb 1",__LINE__)); // das
        BX_KEY_THIS s.kbd_controller.outb = 1;
        BX_KEY_THIS s.kbd_controller.auxb = 1;
        if (BX_KEY_THIS s.kbd_controller.allow_irq1)
          BX_KEY_THIS s.kbd_controller.irq1_requested = 1;
        for (i=0; i<BX_KEY_THIS s.controller_Qsize-1; i++) {
          // move Q elements towards head of queue by one
          BX_KEY_THIS s.controller_Q[i] = BX_KEY_THIS s.controller_Q[i+1];
          }
	BX_DEBUG(("s.controller_Qsize: %02X",BX_KEY_THIS s.controller_Qsize));
        BX_KEY_THIS s.controller_Qsize--;
        }

      DEV_pic_lower_irq(1);
      activate_timer();
      BX_DEBUG(("READ(%02x) = %02x", (unsigned) address,
          (unsigned) val));
      return val;
      }
    else {
        BX_DEBUG(("num_elements = %d", BX_KEY_THIS s.kbd_internal_buffer.num_elements));
        BX_DEBUG(("read from port 60h with outb empty"));
//        val = BX_KEY_THIS s.kbd_controller.kbd_output_buffer;
      return BX_KEY_THIS s.kbd_controller.kbd_output_buffer;
      }
    }

#if BX_CPU_LEVEL >= 2
  else if (address == 0x64) { /* status register */

    return (BX_KEY_THIS s.kbd_controller.pare << 7)  |
          (BX_KEY_THIS s.kbd_controller.tim  << 6)  |
          (BX_KEY_THIS s.kbd_controller.auxb << 5)  |
          (BX_KEY_THIS s.kbd_controller.keyl << 4)  |
          (BX_KEY_THIS s.kbd_controller.c_d  << 3)  |
          (BX_KEY_THIS s.kbd_controller.sysf << 2)  |
          (BX_KEY_THIS s.kbd_controller.inpb << 1)  |
          BX_KEY_THIS s.kbd_controller.outb;
    }

#else /* BX_CPU_LEVEL > 0 */
  /* XT MODE, System 8255 Mode Register */
  else if (address == 0x64) { /* status register */
    BX_DEBUG(("IO read from port 64h, system 8255 mode register"));
    return BX_KEY_THIS s.kbd_controller.outb;
    }
#endif /* BX_CPU_LEVEL > 0 */

  BX_PANIC(("unknown address in io read to keyboard port %x",
      (unsigned) address));
  return 0; /* keep compiler happy */
}


  // static IO port write callback handler
  // redirects to non-static class handler to avoid virtual functions

  void
bx_keyb_c::write_handler(void *this_ptr, Bit32u address, Bit32u value, unsigned io_len)
{
#if !BX_USE_KEY_SMF
  bx_keyb_c *class_ptr = (bx_keyb_c *) this_ptr;

  class_ptr->write(address, value, io_len);
}

  void
bx_keyb_c::write( Bit32u   address, Bit32u   value, unsigned io_len)
{
#else
  UNUSED(this_ptr);
#endif  // !BX_USE_KEY_SMF
  Bit8u   command_byte;
  static int kbd_initialized=0;

  BX_DEBUG(("keyboard: 8-bit write to %04x = %02x", (unsigned)address, (unsigned)value));

  switch (address) {
    case 0x60: // input buffer
      // if expecting data byte from command last sent to port 64h
      if (BX_KEY_THIS s.kbd_controller.expecting_port60h) {
        BX_KEY_THIS s.kbd_controller.expecting_port60h = 0;
        // data byte written last to 0x60
        BX_KEY_THIS s.kbd_controller.c_d = 0;
        if (BX_KEY_THIS s.kbd_controller.inpb) {
          BX_PANIC(("write to port 60h, not ready for write"));
          }
        switch (BX_KEY_THIS s.kbd_controller.last_comm) {
          case 0x60: // write command byte
            {
            bx_bool scan_convert, disable_keyboard,
                    disable_aux;

            scan_convert = (value >> 6) & 0x01;
            disable_aux      = (value >> 5) & 0x01;
            disable_keyboard = (value >> 4) & 0x01;
            BX_KEY_THIS s.kbd_controller.sysf = (value >> 2) & 0x01;
            BX_KEY_THIS s.kbd_controller.allow_irq1  = (value >> 0) & 0x01;
            BX_KEY_THIS s.kbd_controller.allow_irq12 = (value >> 1) & 0x01;
            set_kbd_clock_enable(!disable_keyboard);
            set_aux_clock_enable(!disable_aux);
            if (BX_KEY_THIS s.kbd_controller.allow_irq12 && BX_KEY_THIS s.kbd_controller.auxb)
              BX_KEY_THIS s.kbd_controller.irq12_requested = 1;
            else if (BX_KEY_THIS s.kbd_controller.allow_irq1  && BX_KEY_THIS s.kbd_controller.outb)
              BX_KEY_THIS s.kbd_controller.irq1_requested = 1;

			BX_DEBUG(( " allow_irq12 set to %u", (unsigned)
				BX_KEY_THIS s.kbd_controller.allow_irq12));
            if ( !scan_convert )
              BX_ERROR(("keyboard: (mch) scan convert turned off"));

	    // (mch) NT needs this
	    BX_KEY_THIS s.kbd_controller.scancodes_translate = scan_convert;
            }
            break;
          case 0xd1: // write output port
            BX_DEBUG(("write output port with value %02xh",
                (unsigned) value));
            BX_SET_ENABLE_A20( (value & 0x02) != 0 );
            if (!(value & 0x01))
				BX_PANIC(("IO write: processor reset requested!"));
            break;
          case 0xd4: // Write to mouse
            // I don't think this enables the AUX clock
            //set_aux_clock_enable(1); // enable aux clock line
            kbd_ctrl_to_mouse(value);
            // ??? should I reset to previous value of aux enable?
            break;

          case 0xd3: // write mouse output buffer
            // Queue in mouse output buffer
            controller_enQ(value, 1);
            break;

	  case 0xd2:
	    // Queue in keyboard output buffer
	    controller_enQ(value, 0);
	    break;

          default:
            BX_PANIC(("=== unsupported write to port 60h(lastcomm=%02x): %02x",
              (unsigned) BX_KEY_THIS s.kbd_controller.last_comm, (unsigned) value));
          }
        }
      else {
        // data byte written last to 0x60
        BX_KEY_THIS s.kbd_controller.c_d = 0;
        BX_KEY_THIS s.kbd_controller.expecting_port60h = 0;
        /* pass byte to keyboard */
        /* ??? should conditionally pass to mouse device here ??? */
        if (BX_KEY_THIS s.kbd_controller.kbd_clock_enabled==0) {
          BX_ERROR(("keyboard disabled & send of byte %02x to kbd",
            (unsigned) value));
          }
        kbd_ctrl_to_kbd(value);
        }
      break;

    case 0x64: // control register
      // command byte written last to 0x64
      BX_KEY_THIS s.kbd_controller.c_d = 1;
      BX_KEY_THIS s.kbd_controller.last_comm = value;
      // most commands NOT expecting port60 write next
      BX_KEY_THIS s.kbd_controller.expecting_port60h = 0;

      switch (value) {
        case 0x20: // get keyboard command byte
          BX_DEBUG(("get keyboard command byte"));
          // controller output buffer must be empty
          if (BX_KEY_THIS s.kbd_controller.outb) {
			BX_ERROR(("kbd: OUTB set and command 0x%02x encountered", value));
            break;
            }
          command_byte =
            (BX_KEY_THIS s.kbd_controller.scancodes_translate << 6) |
            ((!BX_KEY_THIS s.kbd_controller.aux_clock_enabled) << 5) |
            ((!BX_KEY_THIS s.kbd_controller.kbd_clock_enabled) << 4) |
            (0 << 3) |
            (BX_KEY_THIS s.kbd_controller.sysf << 2) |
            (BX_KEY_THIS s.kbd_controller.allow_irq12 << 1) |
            (BX_KEY_THIS s.kbd_controller.allow_irq1  << 0);
          controller_enQ(command_byte, 0);
          break;
        case 0x60: // write command byte
          BX_DEBUG(("write command byte"));
          // following byte written to port 60h is command byte
          BX_KEY_THIS s.kbd_controller.expecting_port60h = 1;
          break;

        case 0xa1:
          BX_ERROR(("Dummy out Green PC for now : 0xa1"));
          break;

        case 0xa7: // disable the aux device
          set_aux_clock_enable(0);
          BX_DEBUG(("aux device disabled"));
          break;
        case 0xa8: // enable the aux device
          set_aux_clock_enable(1);
          BX_DEBUG(("aux device enabled"));
          break;
        case 0xa9: // Test Mouse Port
          // controller output buffer must be empty
          if (BX_KEY_THIS s.kbd_controller.outb) {
			BX_PANIC(("kbd: OUTB set and command 0x%02x encountered", value));
            break;
            }
          controller_enQ(0x00, 0); // no errors detected
          break;
        case 0xaa: // motherboard controller self test
          BX_DEBUG(("Self Test"));
	  if( kbd_initialized == 0 )
	  {
	    BX_KEY_THIS s.controller_Qsize = 0;
	    BX_KEY_THIS s.kbd_controller.outb = 0;
	    kbd_initialized++;
	  }
          // controller output buffer must be empty
          if (BX_KEY_THIS s.kbd_controller.outb) {
		BX_ERROR(("kbd: OUTB set and command 0x%02x encountered", value));
            break;
            }
	  // (mch) Why is this commented out??? Enabling
          BX_KEY_THIS s.kbd_controller.sysf = 1; // self test complete
          controller_enQ(0x55, 0); // controller OK
          break;
        case 0xab: // Interface Test
          // controller output buffer must be empty
          if (BX_KEY_THIS s.kbd_controller.outb) {
BX_PANIC(("kbd: OUTB set and command 0x%02x encountered", value));
            break;
            }
          controller_enQ(0x00, 0);
          break;
        case 0xad: // disable keyboard
          set_kbd_clock_enable(0);
          BX_DEBUG(("keyboard disabled"));
          break;
        case 0xae: // enable keyboard
          set_kbd_clock_enable(1);
          BX_DEBUG(("keyboard enabled"));
          break;
        case 0xc0: // read input port
          // controller output buffer must be empty
          if (BX_KEY_THIS s.kbd_controller.outb) {
BX_PANIC(("kbd: OUTB set and command 0x%02x encountered", value));
            break;
            }
          // keyboard power normal
          controller_enQ(0x00, 0);
          break;
        case 0xd0: // read output port: next byte read from port 60h
          BX_DEBUG(("io write to port 64h, command d0h (partial)"));
          // controller output buffer must be empty
          if (BX_KEY_THIS s.kbd_controller.outb) {
BX_PANIC(("kbd: OUTB set and command 0x%02x encountered", value));
            break;
            }
          controller_enQ(
              (BX_KEY_THIS s.kbd_controller.auxb << 5) |
              (BX_KEY_THIS s.kbd_controller.outb << 4) |
              (BX_GET_ENABLE_A20() << 1) |
              0x01, 0);
          break;

        case 0xd1: // write output port: next byte written to port 60h
          BX_DEBUG(("write output port"));
          // following byte to port 60h written to output port
          BX_KEY_THIS s.kbd_controller.expecting_port60h = 1;
          break;

        case 0xd3: // write mouse output buffer
	  //FIXME: Why was this a panic?
          BX_DEBUG(("io write 0x64: command = 0xD3(write mouse outb)"));
	  // following byte to port 60h written to output port as mouse write.
          BX_KEY_THIS s.kbd_controller.expecting_port60h = 1;
          break;

        case 0xd4: // write to mouse
          BX_DEBUG(("io write 0x64: command = 0xD4 (write to mouse)"));
          // following byte written to port 60h
          BX_KEY_THIS s.kbd_controller.expecting_port60h = 1;
          break;

        case 0xd2: // write keyboard output buffer
	  BX_DEBUG(("io write 0x64: write keyboard output buffer"));
	  BX_KEY_THIS s.kbd_controller.expecting_port60h = 1;
	  break;
        case 0xdd: // Disable A20 Address Line
	  BX_SET_ENABLE_A20(0);
	  break;
        case 0xdf: // Enable A20 Address Line
	  BX_SET_ENABLE_A20(1);
	  break;
        case 0xc1: // Continuous Input Port Poll, Low
        case 0xc2: // Continuous Input Port Poll, High
        case 0xe0: // Read Test Inputs
          BX_PANIC(("io write 0x64: command = %02xh", (unsigned) value));
          break;

        case 0xfe: // System Reset, transition to real mode
          BX_INFO(("system reset"));
          bx_pc_system.ResetSignal( PCS_SET ); /* XXX is this right? */
	  {
	  for (int i=0; i<BX_SMP_PROCESSORS; i++) 
            BX_CPU(i)->reset(BX_RESET_HARDWARE);
	  }
          // Use bx_pc_system if necessary bx_cpu.reset_cpu();
          // bx_pc_system.ResetSignal( PCS_SET );
          break;

        default:
          if (value==0xff || (value>=0xf0 && value<=0xfd)) {
            /* useless pulse output bit commands ??? */
            BX_DEBUG(("io write to port 64h, useless command %02x",
                (unsigned) value));
            return;
	    }
          BX_PANIC(("unsupported io write to keyboard port %x, value = %x",
            (unsigned) address, (unsigned) value));
          break;
        }
      break;

    default: BX_PANIC(("unknown address in bx_keyb_c::write()"));
    }
}

// service_paste_buf() transfers data from the paste buffer to the hardware
// keyboard buffer.  It tries to transfer as many chars as possible at a
// time, but because different chars require different numbers of scancodes
// we have to be conservative.  Note that this process depends on the
// keymap tables to know what chars correspond to what keys, and which
// chars require a shift or other modifier.
void 
bx_keyb_c::service_paste_buf ()
{
  if (!BX_KEY_THIS pastebuf) return;
  BX_DEBUG (("service_paste_buf: ptr at %d out of %d", BX_KEY_THIS pastebuf_ptr, BX_KEY_THIS pastebuf_len));
  int fill_threshold = BX_KBD_ELEMENTS - 8;
  while ( (BX_KEY_THIS pastebuf_ptr < BX_KEY_THIS pastebuf_len) && ! BX_KEY_THIS stop_paste) {
    if (BX_KEY_THIS s.kbd_internal_buffer.num_elements >= fill_threshold)
      return;
    // there room in the buffer for a keypress and a key release.
    // send one keypress and a key release.
    Bit8u byte = BX_KEY_THIS pastebuf[BX_KEY_THIS pastebuf_ptr];
    BXKeyEntry *entry = bx_keymap.findAsciiChar (byte);
    if (!entry) {
      BX_ERROR (("paste character 0x%02x ignored", byte));
    } else {
      BX_DEBUG (("pasting character 0x%02x. baseKey is %04x", byte, entry->baseKey));
      if (entry->modKey != BX_KEYMAP_UNKNOWN)
        BX_KEY_THIS gen_scancode (entry->modKey);
      BX_KEY_THIS gen_scancode (entry->baseKey);
      BX_KEY_THIS gen_scancode (entry->baseKey | BX_KEY_RELEASED);
      if (entry->modKey != BX_KEYMAP_UNKNOWN)
        BX_KEY_THIS gen_scancode (entry->modKey | BX_KEY_RELEASED);
    }
    BX_KEY_THIS pastebuf_ptr++;
  }
  // reached end of pastebuf.  free the memory it was using.
  delete [] BX_KEY_THIS pastebuf;
  BX_KEY_THIS pastebuf = NULL;
  BX_KEY_THIS stop_paste = 0;
}

// paste_bytes schedules an arbitrary number of ASCII characters to be
// inserted into the hardware queue as it become available.  Any previous
// paste which is still in progress will be thrown out.  BYTES is a pointer
// to a region of memory containing the chars to be pasted. When the paste
// is complete, the keyboard code will call delete [] bytes;
void
bx_keyb_c::paste_bytes (Bit8u *bytes, Bit32s length)
{
  BX_DEBUG (("paste_bytes: %d bytes", length));
  if (BX_KEY_THIS pastebuf) {
    BX_ERROR (("previous paste was not completed!  %d chars lost", 
	  BX_KEY_THIS pastebuf_len - BX_KEY_THIS pastebuf_ptr));
    delete [] BX_KEY_THIS pastebuf;  // free the old paste buffer
  }
  BX_KEY_THIS pastebuf = bytes;
  BX_KEY_THIS pastebuf_ptr = 0;
  BX_KEY_THIS pastebuf_len = length;
  BX_KEY_THIS service_paste_buf ();
}

  void
bx_keyb_c::gen_scancode(Bit32u key)
{
  unsigned char *scancode;
  Bit8u  i;

  BX_DEBUG(( "gen_scancode(): %s %s", bx_keymap.getBXKeyName(key), (key >> 31)?"released":"pressed"));

  if (!BX_KEY_THIS s.kbd_controller.scancodes_translate)
	BX_DEBUG(("keyboard: gen_scancode with scancode_translate cleared"));

  // Ignore scancode if keyboard clock is driven low
  if (BX_KEY_THIS s.kbd_controller.kbd_clock_enabled==0)
    return;

  // Ignore scancode if scanning is disabled
  if (BX_KEY_THIS s.kbd_internal_buffer.scanning_enabled==0)
    return;

  // Switch between make and break code
  if (key & BX_KEY_RELEASED)
    scancode=(unsigned char *)scancodes[(key&0xFF)][BX_KEY_THIS s.kbd_controller.current_scancodes_set].brek;
  else
    scancode=(unsigned char *)scancodes[(key&0xFF)][BX_KEY_THIS s.kbd_controller.current_scancodes_set].make;

  if (BX_KEY_THIS s.kbd_controller.scancodes_translate) {
    // Translate before send
    Bit8u escaped=0x00;

    for (i=0; i<strlen( (const char *)scancode ); i++) {
      if (scancode[i] == 0xF0)
        escaped=0x80;
      else {
	BX_DEBUG(("gen_scancode(): writing translated %02x",translation8042[scancode[i] ] | escaped));
        kbd_enQ(translation8042[scancode[i] ] | escaped );
        escaped=0x00;
      }
    }
  } 
  else {
    // Send raw data
    for (i=0; i<strlen( (const char *)scancode ); i++) {
      BX_DEBUG(("gen_scancode(): writing raw %02x",scancode[i]));
      kbd_enQ( scancode[i] );
    }
  }
}



  void BX_CPP_AttrRegparmN(1)
bx_keyb_c::set_kbd_clock_enable(Bit8u   value)
{
  bx_bool prev_kbd_clock_enabled;

  if (value==0) {
    BX_KEY_THIS s.kbd_controller.kbd_clock_enabled = 0;
    }
  else {
    /* is another byte waiting to be sent from the keyboard ? */
    prev_kbd_clock_enabled = BX_KEY_THIS s.kbd_controller.kbd_clock_enabled;
    BX_KEY_THIS s.kbd_controller.kbd_clock_enabled = 1;

    if (prev_kbd_clock_enabled==0 && BX_KEY_THIS s.kbd_controller.outb==0) {
      activate_timer();
      }
    }
}



  void
bx_keyb_c::set_aux_clock_enable(Bit8u   value)
{
  bx_bool prev_aux_clock_enabled;

  BX_DEBUG(("set_aux_clock_enable(%u)", (unsigned) value));
  if (value==0) {
    BX_KEY_THIS s.kbd_controller.aux_clock_enabled = 0;
    }
  else {
    /* is another byte waiting to be sent from the keyboard ? */
    prev_aux_clock_enabled = BX_KEY_THIS s.kbd_controller.aux_clock_enabled;
    BX_KEY_THIS s.kbd_controller.aux_clock_enabled = 1;
    if (prev_aux_clock_enabled==0 && BX_KEY_THIS s.kbd_controller.outb==0)
      activate_timer();
    }
}

  Bit8u
bx_keyb_c::get_kbd_enable(void)
{
  BX_DEBUG(("get_kbd_enable(): getting kbd_clock_enabled of: %02x",
      (unsigned) BX_KEY_THIS s.kbd_controller.kbd_clock_enabled));

  return(BX_KEY_THIS s.kbd_controller.kbd_clock_enabled);
}

  void
bx_keyb_c::controller_enQ(Bit8u   data, unsigned source)
{
  // source is 0 for keyboard, 1 for mouse

  BX_DEBUG(("controller_enQ(%02x) source=%02x", (unsigned) data,source));

  if (BX_KEY_THIS s.kbd_controller.outb)
    BX_ERROR(("controller_enQ(): OUTB set!"));

  // see if we need to Q this byte from the controller
  // remember this includes mouse bytes.
  if (BX_KEY_THIS s.kbd_controller.outb) {
    if (BX_KEY_THIS s.controller_Qsize >= BX_KBD_CONTROLLER_QSIZE)
      BX_PANIC(("controller_enq(): controller_Q full!"));
    BX_KEY_THIS s.controller_Q[BX_KEY_THIS s.controller_Qsize++] = data;
    BX_KEY_THIS s.controller_Qsource = source;
    return;
    }

  // the Q is empty
  if (source == 0) { // keyboard
    BX_KEY_THIS s.kbd_controller.kbd_output_buffer = data;
    //    BX_INFO(("kbd: %04d outb 1 auxb 0",__LINE__)); // das
    BX_KEY_THIS s.kbd_controller.outb = 1;
    BX_KEY_THIS s.kbd_controller.auxb = 0;
    BX_KEY_THIS s.kbd_controller.inpb = 0;
    if (BX_KEY_THIS s.kbd_controller.allow_irq1)
      BX_KEY_THIS s.kbd_controller.irq1_requested = 1;
    }
  else { // mouse
    BX_KEY_THIS s.kbd_controller.aux_output_buffer = data;
    //    BX_INFO(("kbd: %04d outb 1 auxb 1",__LINE__)); // das
    BX_KEY_THIS s.kbd_controller.outb = 1;
    BX_KEY_THIS s.kbd_controller.auxb = 1;
    BX_KEY_THIS s.kbd_controller.inpb = 0;
    if (BX_KEY_THIS s.kbd_controller.allow_irq12)
      BX_KEY_THIS s.kbd_controller.irq12_requested = 1;
    }
}

void
bx_keyb_c::kbd_enQ_imm(Bit8u val)
{
      int tail;

      if (BX_KEY_THIS s.kbd_internal_buffer.num_elements >= BX_KBD_ELEMENTS) {
	    BX_PANIC(("internal keyboard buffer full (imm)"));
	    return;
      }

      /* enqueue scancode in multibyte internal keyboard buffer */
      tail = (BX_KEY_THIS s.kbd_internal_buffer.head + BX_KEY_THIS s.kbd_internal_buffer.num_elements) %
	    BX_KBD_ELEMENTS;

      BX_KEY_THIS s.kbd_controller.kbd_output_buffer = val;
      //      BX_INFO(("kbd: %04d outb 1",__LINE__)); // das
      BX_KEY_THIS s.kbd_controller.outb = 1;

      if (BX_KEY_THIS s.kbd_controller.allow_irq1)
	    BX_KEY_THIS s.kbd_controller.irq1_requested = 1;
}


  void
bx_keyb_c::kbd_enQ(Bit8u scancode)
{
  int tail;

  BX_DEBUG(("kbd_enQ(0x%02x)", (unsigned) scancode));

  if (BX_KEY_THIS s.kbd_internal_buffer.num_elements >= BX_KBD_ELEMENTS) {
    BX_INFO(("internal keyboard buffer full, ignoring scancode.(%02x)",
      (unsigned) scancode));
    return;
    }

  /* enqueue scancode in multibyte internal keyboard buffer */
  BX_DEBUG(("kbd_enQ: putting scancode 0x%02x in internal buffer",
      (unsigned) scancode));
  tail = (BX_KEY_THIS s.kbd_internal_buffer.head + BX_KEY_THIS s.kbd_internal_buffer.num_elements) %
   BX_KBD_ELEMENTS;
  BX_KEY_THIS s.kbd_internal_buffer.buffer[tail] = scancode;
  BX_KEY_THIS s.kbd_internal_buffer.num_elements++;

  if (!BX_KEY_THIS s.kbd_controller.outb && BX_KEY_THIS s.kbd_controller.kbd_clock_enabled) {
    activate_timer();
    BX_DEBUG(("activating timer..."));
    return;
    }
//BX_DEBUG(( "# not activating timer...");
//BX_DEBUG(( "#   allow_irq1 = %u", (unsigned) BX_KEY_THIS s.kbd_controller.allow_irq1);
//BX_DEBUG(( "#   outb       = %u", (unsigned) BX_KEY_THIS s.kbd_controller.outb);
//BX_DEBUG(( "#   clock_enab = %u", (unsigned) BX_KEY_THIS s.kbd_controller.kbd_clock_enabled);
//BX_DEBUG(( "#   out_buffer = %u", (unsigned) BX_KEY_THIS s.kbd_controller.kbd_output_buffer);
}

  bx_bool BX_CPP_AttrRegparmN(3)
bx_keyb_c::mouse_enQ_packet(Bit8u   b1, Bit8u   b2, Bit8u   b3)
{
  if ((BX_KEY_THIS s.mouse_internal_buffer.num_elements + 3) >= BX_MOUSE_BUFF_SIZE) {
    return(0); /* buffer doesn't have the space */
    }

//BX_DEBUG(("mouse: enQ_packet(%02x, %02x, %02x)",
//  (unsigned) b1, (unsigned) b2, (unsigned) b3));

  mouse_enQ(b1);
  mouse_enQ(b2);
  mouse_enQ(b3);
  return(1);
}


  void
bx_keyb_c::mouse_enQ(Bit8u   mouse_data)
{
  int tail;

  BX_DEBUG(("mouse_enQ(%02x)", (unsigned) mouse_data));

  if (BX_KEY_THIS s.mouse_internal_buffer.num_elements >= BX_MOUSE_BUFF_SIZE) {
    BX_ERROR(("mouse: internal mouse buffer full, ignoring mouse data.(%02x)",
      (unsigned) mouse_data));
    return;
    }
//BX_DEBUG(( "# mouse_enq() aux_clock_enabled = %u",
//  (unsigned) BX_KEY_THIS s.kbd_controller.aux_clock_enabled);

  /* enqueue mouse data in multibyte internal mouse buffer */
  tail = (BX_KEY_THIS s.mouse_internal_buffer.head + BX_KEY_THIS s.mouse_internal_buffer.num_elements) %
   BX_MOUSE_BUFF_SIZE;
  BX_KEY_THIS s.mouse_internal_buffer.buffer[tail] = mouse_data;
  BX_KEY_THIS s.mouse_internal_buffer.num_elements++;

  if (!BX_KEY_THIS s.kbd_controller.outb && BX_KEY_THIS s.kbd_controller.aux_clock_enabled) {
    activate_timer();
//BX_DEBUG(( "# activating timer...");
    return;
    }
//BX_DEBUG(( "# not activating timer...");
//BX_DEBUG(( "#   allow_irq12= %u", (unsigned) BX_KEY_THIS s.kbd_controller.allow_irq12);
//BX_DEBUG(( "#   outb       = %u", (unsigned) BX_KEY_THIS s.kbd_controller.outb);
//BX_DEBUG(( "#   clock_enab = %u", (unsigned) BX_KEY_THIS s.kbd_controller.aux_clock_enabled);
//BX_DEBUG(( "#   out_buffer = %u", (unsigned) BX_KEY_THIS s.kbd_controller.aux_output_buffer);
}

  void
bx_keyb_c::kbd_ctrl_to_kbd(Bit8u   value)
{

  BX_DEBUG(("controller passed byte %02xh to keyboard", value));

  if (BX_KEY_THIS s.kbd_internal_buffer.expecting_typematic) {
    BX_KEY_THIS s.kbd_internal_buffer.expecting_typematic = 0;
    BX_KEY_THIS s.kbd_internal_buffer.delay = (value >> 5) & 0x03;
    switch (BX_KEY_THIS s.kbd_internal_buffer.delay) {
      case 0: BX_INFO(("setting delay to 250 mS (unused)")); break;
      case 1: BX_INFO(("setting delay to 500 mS (unused)")); break;
      case 2: BX_INFO(("setting delay to 750 mS (unused)")); break;
      case 3: BX_INFO(("setting delay to 1000 mS (unused)")); break;
      }
    BX_KEY_THIS s.kbd_internal_buffer.repeat_rate = value & 0x1f;
    double cps = 1 /((double)(8 + (value & 0x07)) * (double)exp(log((double)2) * (double)((value >> 3) & 0x03)) * 0.00417);
    BX_INFO(("setting repeat rate to %.1f cps (unused)", cps));
    kbd_enQ(0xFA); // send ACK
    return;
    }

  if (BX_KEY_THIS s.kbd_internal_buffer.expecting_led_write) {
    BX_KEY_THIS s.kbd_internal_buffer.expecting_led_write = 0;
    BX_KEY_THIS s.kbd_internal_buffer.led_status = value;
    BX_DEBUG(("LED status set to %02x",
      (unsigned) BX_KEY_THIS s.kbd_internal_buffer.led_status));
    kbd_enQ(0xFA); // send ACK %%%
    return;
    }

  if (BX_KEY_THIS s.kbd_controller.expecting_scancodes_set) {
    BX_KEY_THIS s.kbd_controller.expecting_scancodes_set = 0;
    if( value != 0 ) {
      if( value<4 ) {
        BX_KEY_THIS s.kbd_controller.current_scancodes_set = (value-1);
        BX_INFO(("Switched to scancode set %d\n",
          (unsigned) BX_KEY_THIS s.kbd_controller.current_scancodes_set + 1));
        kbd_enQ(0xFA);
        } 
      else {
        BX_ERROR(("Received scancodes set out of range: %d\n", value ));
        kbd_enQ(0xFF); // send ERROR
        }
      } 
    else {
      // Send current scancodes set to port 0x60
      kbd_enQ( 1 + (BX_KEY_THIS s.kbd_controller.current_scancodes_set) ); 
      }
    return;
    }

  switch (value) {
    case 0x00: // ??? ignore and let OS timeout with no response
      kbd_enQ(0xFA); // send ACK %%%
      return;
      break;

    case 0x05: // ???
	  // (mch) trying to get this to work...
          BX_KEY_THIS s.kbd_controller.sysf = 1;
	  kbd_enQ_imm(0xfe);
      return;
      break;

    case 0xed: // LED Write
      BX_KEY_THIS s.kbd_internal_buffer.expecting_led_write = 1;
      kbd_enQ_imm(0xFA); // send ACK %%%
      return;
      break;

    case 0xee: // echo
      kbd_enQ(0xEE); // return same byte (EEh) as echo diagnostic
      return;
      break;

    case 0xf0: // Select alternate scan code set
      BX_KEY_THIS s.kbd_controller.expecting_scancodes_set = 1;
      BX_DEBUG(("Expecting scancode set info...\n"));
      kbd_enQ(0xFA); // send ACK
      return;
      break;

    case 0xf2:  // identify keyboard
      BX_INFO(("identify keyboard command received"));

      // XT sends nothing, AT sends ACK 
      // MFII with translation sends ACK+ABh+41h
      // MFII without translation sends ACK+ABh+83h
      if (bx_options.Okeyboard_type->get() != BX_KBD_XT_TYPE) {
        kbd_enQ(0xFA); 
        if (bx_options.Okeyboard_type->get() == BX_KBD_MF_TYPE) {
          kbd_enQ(0xAB);
          
          if(BX_KEY_THIS s.kbd_controller.scancodes_translate)
            kbd_enQ(0x41);
          else
            kbd_enQ(0x83);
          }
        }
      return;
      break;

    case 0xf3:  // typematic info
      BX_KEY_THIS s.kbd_internal_buffer.expecting_typematic = 1;
      BX_INFO(("setting typematic info"));
      kbd_enQ(0xFA); // send ACK
      return;
      break;

    case 0xf4:  // enable keyboard
      BX_KEY_THIS s.kbd_internal_buffer.scanning_enabled = 1;
      kbd_enQ(0xFA); // send ACK
      return;
      break;

    case 0xf5:  // reset keyboard to power-up settings and disable scanning
      resetinternals(1);
      kbd_enQ(0xFA); // send ACK
      BX_KEY_THIS s.kbd_internal_buffer.scanning_enabled = 0;
      BX_INFO(("reset-disable command received"));
      return;
      break;

    case 0xf6:  // reset keyboard to power-up settings and enable scanning
      resetinternals(1);
      kbd_enQ(0xFA); // send ACK
      BX_KEY_THIS s.kbd_internal_buffer.scanning_enabled = 1;
      BX_INFO(("reset-enable command received"));
      return;
      break;

    case 0xf7:  // PS/2 Set All Keys To Typematic
    case 0xf8:  // PS/2 Set All Keys to Make/Break
    case 0xf9:  // PS/2 PS/2 Set All Keys to Make
    case 0xfa:  // PS/2 Set All Keys to Typematic Make/Break
    case 0xfb:  // PS/2 Set Key Type to Typematic
    case 0xfc:  // PS/2 Set Key Type to Make/Break
    case 0xfd:  // PS/2 Set Key Type to Make
      // Silently ignore and let the OS timeout, for now.
      // If anyone has code around that makes use of that, I can
      // provide documentation on their behavior (ask core@ggi-project.org)
      return;
      break;

    case 0xfe:  // resend. aiiee.
      BX_PANIC( ("got 0xFE (resend)"));
      return;
      break;

    case 0xff:  // reset: internal keyboard reset and afterwards the BAT
      BX_DEBUG(("reset command received"));
      resetinternals(1);
      kbd_enQ(0xFA); // send ACK
      kbd_enQ(0xAA); // BAT test passed
      return;
      break;

    case 0xd3:
      kbd_enQ(0xfa);
      return;

    default:
			/* XXX fix this properly:
			http://panda.cs.ndsu.nodak.edu/~achapwes/PICmicro/mouse/mouse.html
			http://sourceforge.net/tracker/index.php?func=detail&aid=422457&group_id=12580&atid=112580
			 */
      BX_ERROR(("kbd_ctrl_to_kbd(): got value of %02x",
        (unsigned) value));
      kbd_enQ(0xFA); /* send ACK ??? */
      return;
      break;
    }
}

  void
bx_keyb_c::timer_handler(void *this_ptr)
{
  bx_keyb_c *class_ptr = (bx_keyb_c *) this_ptr;
  unsigned retval;

  // retval=class_ptr->periodic( bx_options.Okeyboard_serial_delay->get());
  retval=class_ptr->periodic(1);

  if(retval&0x01)
    DEV_pic_raise_irq(1);
  if(retval&0x02)
    DEV_pic_raise_irq(12);
}

  unsigned
bx_keyb_c::periodic( Bit32u   usec_delta )
{
/*  static int multiple=0; */
  static unsigned count_before_paste=0;
  Bit8u   retval;

  UNUSED( usec_delta );

  if (BX_KEY_THIS s.kbd_controller.kbd_clock_enabled ) {
    if(++count_before_paste>=BX_KEY_THIS pastedelay) {
      // after the paste delay, consider adding moving more chars
      // from the paste buffer to the keyboard buffer.
      BX_KEY_THIS service_paste_buf ();
      count_before_paste=0;
    }
  }

  retval = BX_KEY_THIS s.kbd_controller.irq1_requested | (BX_KEY_THIS s.kbd_controller.irq12_requested << 1);
  BX_KEY_THIS s.kbd_controller.irq1_requested = 0;
  BX_KEY_THIS s.kbd_controller.irq12_requested = 0;

  if ( BX_KEY_THIS s.kbd_controller.timer_pending == 0 ) {
    return(retval);
    }

  if ( usec_delta >= BX_KEY_THIS s.kbd_controller.timer_pending ) {
    BX_KEY_THIS s.kbd_controller.timer_pending = 0;
    }
  else {
    BX_KEY_THIS s.kbd_controller.timer_pending -= usec_delta;
    return(retval);
    }

  if (BX_KEY_THIS s.kbd_controller.outb) {
    return(retval);
    }

  /* nothing in outb, look for possible data xfer from keyboard or mouse */
  if (BX_KEY_THIS s.kbd_controller.kbd_clock_enabled && BX_KEY_THIS s.kbd_internal_buffer.num_elements) {
//BX_DEBUG(( "#   servicing keyboard code");
    BX_DEBUG(("service_keyboard: key in internal buffer waiting"));
    BX_KEY_THIS s.kbd_controller.kbd_output_buffer =
      BX_KEY_THIS s.kbd_internal_buffer.buffer[BX_KEY_THIS s.kbd_internal_buffer.head];
    //    BX_INFO(("kbd: %04d outb 1",__LINE__)); // das
    BX_KEY_THIS s.kbd_controller.outb = 1;
    // commented out since this would override the current state of the
    // mouse buffer flag - no bug seen - just seems wrong (das)
    //    BX_KEY_THIS s.kbd_controller.auxb = 0;
//BX_DEBUG(( "# ___kbd::periodic kbd");
    BX_KEY_THIS s.kbd_internal_buffer.head = (BX_KEY_THIS s.kbd_internal_buffer.head + 1) %
      BX_KBD_ELEMENTS;
    BX_KEY_THIS s.kbd_internal_buffer.num_elements--;
    if (BX_KEY_THIS s.kbd_controller.allow_irq1)
      BX_KEY_THIS s.kbd_controller.irq1_requested = 1;
    }
  else { 
    create_mouse_packet(0);
    if (BX_KEY_THIS s.kbd_controller.aux_clock_enabled && BX_KEY_THIS s.mouse_internal_buffer.num_elements) {
//BX_DEBUG(( "#   servicing mouse code");
      BX_DEBUG(("service_keyboard: key(from mouse) in internal buffer waiting"));
      BX_KEY_THIS s.kbd_controller.aux_output_buffer =
	BX_KEY_THIS s.mouse_internal_buffer.buffer[BX_KEY_THIS s.mouse_internal_buffer.head];

    //    BX_INFO(("kbd: %04d outb 1 auxb 1",__LINE__)); //das
      BX_KEY_THIS s.kbd_controller.outb = 1;
      BX_KEY_THIS s.kbd_controller.auxb = 1;
//BX_DEBUG(( "# ___kbd:periodic aux");
      BX_KEY_THIS s.mouse_internal_buffer.head = (BX_KEY_THIS s.mouse_internal_buffer.head + 1) %
	BX_MOUSE_BUFF_SIZE;
      BX_KEY_THIS s.mouse_internal_buffer.num_elements--;
//BX_DEBUG(( "#   allow12 = %u", (unsigned) BX_KEY_THIS s.kbd_controller.allow_irq12);
      if (BX_KEY_THIS s.kbd_controller.allow_irq12)
	BX_KEY_THIS s.kbd_controller.irq12_requested = 1;
    }
    else {
      BX_DEBUG(("service_keyboard(): no keys waiting"));
    }
  }
  return(retval);
}




  void
bx_keyb_c::activate_timer(void)
{
  if (BX_KEY_THIS s.kbd_controller.timer_pending == 0) {
    // BX_KEY_THIS s.kbd_controller.timer_pending = bx_options.Okeyboard_serial_delay->get ();
    BX_KEY_THIS s.kbd_controller.timer_pending = 1;
    }
}


  void
bx_keyb_c::kbd_ctrl_to_mouse(Bit8u   value)
{
BX_DEBUG(("MOUSE: kbd_ctrl_to_mouse(%02xh)", (unsigned) value));
BX_DEBUG(("  enable = %u", (unsigned) BX_KEY_THIS s.mouse.enable));
BX_DEBUG(("  allow_irq12 = %u",
  (unsigned) BX_KEY_THIS s.kbd_controller.allow_irq12));
BX_DEBUG(("  aux_clock_enabled = %u",
  (unsigned) BX_KEY_THIS s.kbd_controller.aux_clock_enabled));
//BX_DEBUG(( "MOUSE: kbd_ctrl_to_mouse(%02xh)", (unsigned) value));

  // an ACK (0xFA) is always the first response to any valid input
  // received from the system other than Set-Wrap-Mode & Resend-Command


 if (BX_KEY_THIS s.kbd_controller.expecting_mouse_parameter) {
       BX_KEY_THIS s.kbd_controller.expecting_mouse_parameter = 0;
       switch (BX_KEY_THIS s.kbd_controller.last_mouse_command) {
	     case 0xf3: // Set Mouse Sample Rate
		   BX_KEY_THIS s.mouse.sample_rate = value;
		   BX_DEBUG(("[mouse] Sampling rate set: %d Hz", value));
		   controller_enQ(0xFA, 1); // ack
		   break;

	     case 0xe8: // Set Mouse Resolution
		   switch (value) {
			 case 0:
			       BX_KEY_THIS s.mouse.resolution_cpmm = 1;
			       break;
			 case 1:
			       BX_KEY_THIS s.mouse.resolution_cpmm = 2;
			       break;
			 case 2:
			       BX_KEY_THIS s.mouse.resolution_cpmm = 4;
			       break;
			 case 3:
			       BX_KEY_THIS s.mouse.resolution_cpmm = 8;
			       break;
			 default:
			       BX_PANIC(("[mouse] Unknown resolution %d", value));
			       break;
		   }
		   BX_DEBUG(("[mouse] Resolution set to %d counts per mm",
				   BX_KEY_THIS s.mouse.resolution_cpmm));

		   controller_enQ(0xFA, 1); // ack
		   break;

	     default:
		   BX_PANIC(("MOUSE: unknown last command (%02xh)", (unsigned) BX_KEY_THIS s.kbd_controller.last_mouse_command));
       }
 } else {
  BX_KEY_THIS s.kbd_controller.expecting_mouse_parameter = 0;
  BX_KEY_THIS s.kbd_controller.last_mouse_command = value;

  // test for wrap mode first
  if (BX_KEY_THIS s.mouse.mode == MOUSE_MODE_WRAP) {
    // if not a reset command or reset wrap mode
    // then just echo the byte.
    if ((value != 0xff) && (value != 0xec)) {
      if (bx_dbg.mouse)
	BX_INFO(("[mouse] wrap mode: Ignoring command %0X02.",value));
      controller_enQ(value,1);
      // bail out
      return;
    }
  }
  switch ( value ) {
    case 0xe6: // Set Mouse Scaling to 1:1
      controller_enQ(0xFA, 1); // ACK
      BX_KEY_THIS s.mouse.scaling         = 2;
	  BX_DEBUG(("[mouse] Scaling set to 1:1"));
      break;

    case 0xe7: // Set Mouse Scaling to 2:1
      controller_enQ(0xFA, 1); // ACK
      BX_KEY_THIS s.mouse.scaling         = 2;
	  BX_DEBUG(("[mouse] Scaling set to 2:1"));
      break;

    case 0xe8: // Set Mouse Resolution
      controller_enQ(0xFA, 1); // ACK
      BX_KEY_THIS s.kbd_controller.expecting_mouse_parameter = 1;
      break;

    case 0xea: // Set Stream Mode
      if (bx_dbg.mouse)
	BX_INFO(("[mouse] Mouse stream mode on."));
      BX_KEY_THIS s.mouse.mode = MOUSE_MODE_STREAM;
      controller_enQ(0xFA, 1); // ACK
      break;

    case 0xec: // Reset Wrap Mode
      // unless we are in wrap mode ignore the command
      if ( BX_KEY_THIS s.mouse.mode == MOUSE_MODE_WRAP) {
	if (bx_dbg.mouse)
	  BX_INFO(("[mouse] Mouse wrap mode off."));
	// restore previous mode except disable stream mode reporting.
	// ### TODO disabling reporting in stream mode
	BX_KEY_THIS s.mouse.mode = BX_KEY_THIS s.mouse.saved_mode;
	controller_enQ(0xFA, 1); // ACK
      }
      break;
    case 0xee: // Set Wrap Mode
      // ### TODO flush output queue.
      // ### TODO disable interrupts if in stream mode.
      if (bx_dbg.mouse)
	    BX_INFO(("[mouse] Mouse wrap mode on."));
      BX_KEY_THIS s.mouse.saved_mode = BX_KEY_THIS s.mouse.mode;
      BX_KEY_THIS s.mouse.mode = MOUSE_MODE_WRAP;
      controller_enQ(0xFA, 1); // ACK
      break;

    case 0xf0: // Set Remote Mode (polling mode, i.e. not stream mode.)
      if (bx_dbg.mouse)
	    BX_INFO(("[mouse] Mouse remote mode on."));
      // ### TODO should we flush/discard/ignore any already queued packets?
      BX_KEY_THIS s.mouse.mode = MOUSE_MODE_REMOTE;
      controller_enQ(0xFA, 1); // ACK
      break;


    case 0xf2: // Read Device Type
      controller_enQ(0xFA, 1); // ACK
      controller_enQ(0x00, 1); // Device ID
	  BX_DEBUG(("[mouse] Read mouse ID"));
      break;

    case 0xf3: // Set Mouse Sample Rate (sample rate written to port 60h)
      controller_enQ(0xFA, 1); // ACK
      BX_KEY_THIS s.kbd_controller.expecting_mouse_parameter = 1;
      break;

    case 0xf4: // Enable (in stream mode)
      BX_KEY_THIS s.mouse.enable = 1;
      controller_enQ(0xFA, 1); // ACK
	  BX_DEBUG(("[mouse] Mouse enabled (stream mode)"));
      break;

    case 0xf5: // Disable (in stream mode)
      BX_KEY_THIS s.mouse.enable = 0;
      controller_enQ(0xFA, 1); // ACK
	  BX_DEBUG(("[mouse] Mouse disabled (stream mode)"));
      break;

    case 0xf6: // Set Defaults
      BX_KEY_THIS s.mouse.sample_rate     = 100; /* reports per second (default) */
      BX_KEY_THIS s.mouse.resolution_cpmm = 4; /* 4 counts per millimeter (default) */
      BX_KEY_THIS s.mouse.scaling         = 1;   /* 1:1 (default) */
      BX_KEY_THIS s.mouse.enable          = 0;
      BX_KEY_THIS s.mouse.mode            = MOUSE_MODE_STREAM;
      controller_enQ(0xFA, 1); // ACK
	  BX_DEBUG(("[mouse] Set Defaults"));
      break;

    case 0xff: // Reset
      BX_KEY_THIS s.mouse.sample_rate     = 100; /* reports per second (default) */
      BX_KEY_THIS s.mouse.resolution_cpmm = 4; /* 4 counts per millimeter (default) */
      BX_KEY_THIS s.mouse.scaling         = 1;   /* 1:1 (default) */
      BX_KEY_THIS s.mouse.mode            = MOUSE_MODE_RESET;
      BX_KEY_THIS s.mouse.enable          = 0;
      /* (mch) NT expects an ack here */
      controller_enQ(0xFA, 1); // ACK
      controller_enQ(0xAA, 1); // completion code
      controller_enQ(0x00, 1); // ID code (normal mouse, wheelmouse has id 0x3)
	  BX_DEBUG(("[mouse] Mouse reset"));
      break;

    case 0xe9: // Get mouse information
      // should we ack here? (mch): Yes
      controller_enQ(0xFA, 1); // ACK
      controller_enQ(BX_KEY_THIS s.mouse.get_status_byte(), 1); // status
      controller_enQ(BX_KEY_THIS s.mouse.get_resolution_byte(), 1); // resolution
      controller_enQ(BX_KEY_THIS s.mouse.sample_rate, 1); // sample rate
	  BX_DEBUG(("[mouse] Get mouse information"));
      break;

    case 0xeb: // Read Data (send a packet when in Remote Mode)
      controller_enQ(0xFA, 1); // ACK
      // perhaps we should be adding some movement here.
      mouse_enQ_packet( ((BX_KEY_THIS s.mouse.button_status & 0x0f) | 0x08),
			0x00, 0x00 ); // bit3 of first byte always set
      //assumed we really aren't in polling mode, a rather odd assumption.
      BX_ERROR(("[mouse] Warning: Read Data command partially supported."));
      break;

    default:
      //FEh Resend
      BX_PANIC(("MOUSE: kbd_ctrl_to_mouse(%02xh)", (unsigned) value));
    }
 }
}

void
bx_keyb_c::create_mouse_packet(bool force_enq) {
  Bit8u   b1, b2, b3;

  //  BX_DEBUG("Calling create_mouse_packet: force_enq=%d\n",force_enq);

  if(BX_KEY_THIS s.mouse_internal_buffer.num_elements && !force_enq)
    return;

  //  BX_DEBUG("Got to first milestone: force_enq=%d\n",force_enq);

  Bit16s delta_x = BX_KEY_THIS s.mouse.delayed_dx;
  Bit16s delta_y = BX_KEY_THIS s.mouse.delayed_dy;
  Bit8u button_state=BX_KEY_THIS s.mouse.button_status | 0x08;

  if(!force_enq && !delta_x && !delta_y) {
    return;
  }

  //  BX_DEBUG("Got to second milestone: delta_x=%d, delta_y=%d\n",delta_x,delta_y);

  if(delta_x>254) delta_x=254;
  if(delta_x<-254) delta_x=-254;
  if(delta_y>254) delta_y=254;
  if(delta_y<-254) delta_y=-254;

  b1 = (button_state & 0x0f) | 0x08; // bit3 always set

  if ( (delta_x>=0) && (delta_x<=255) ) {
    b2 = (Bit8u) delta_x;
    BX_KEY_THIS s.mouse.delayed_dx-=delta_x;
    }
  else if ( delta_x > 255 ) {
    b2 = (Bit8u) 0xff;
    BX_KEY_THIS s.mouse.delayed_dx-=255;
    }
  else if ( delta_x >= -256 ) {
    b2 = (Bit8u) delta_x;
    b1 |= 0x10;
    BX_KEY_THIS s.mouse.delayed_dx-=delta_x;
    }
  else {
    b2 = (Bit8u) 0x00;
    b1 |= 0x10;
    BX_KEY_THIS s.mouse.delayed_dx+=256;
    }

  if ( (delta_y>=0) && (delta_y<=255) ) {
    b3 = (Bit8u) delta_y;
    BX_KEY_THIS s.mouse.delayed_dy-=delta_y;
    }
  else if ( delta_y > 255 ) {
    b3 = (Bit8u) 0xff;
    BX_KEY_THIS s.mouse.delayed_dy-=255;
    }
  else if ( delta_y >= -256 ) {
    b3 = (Bit8u) delta_y;
    b1 |= 0x20;
    BX_KEY_THIS s.mouse.delayed_dy-=delta_y;
    }
  else {
    b3 = (Bit8u) 0x00;
    b1 |= 0x20;
    BX_KEY_THIS s.mouse.delayed_dy+=256;
    }
  mouse_enQ_packet(b1, b2, b3);
}


void
bx_keyb_c::mouse_enabled_changed(bool enabled) {
  if(s.mouse.delayed_dx || BX_KEY_THIS s.mouse.delayed_dy) {
    create_mouse_packet(1);
  }
  s.mouse.delayed_dx=0;
  s.mouse.delayed_dy=0;
  BX_DEBUG(("Keyboard mouse disable called."));
}

  void
bx_keyb_c::mouse_motion(int delta_x, int delta_y, unsigned button_state)
{
  bool force_enq=0;

  // If mouse events are disabled on the GUI headerbar, don't
  // generate any mouse data
  if (bx_options.Omouse_enabled->get () == 0)
    return;


  // don't generate interrupts if we are in remote mode.
  if ( BX_KEY_THIS s.mouse.mode == MOUSE_MODE_REMOTE)
    // is there any point in doing any work if we don't act on the result
    // so go home.
    return;


  // Note: enable only applies in STREAM MODE.
  if ( BX_KEY_THIS s.mouse.enable==0 )
    return;

  // scale down the motion
  if ( (delta_x < -1) || (delta_x > 1) )
    delta_x /= 2;
  if ( (delta_y < -1) || (delta_y > 1) )
    delta_y /= 2;

#ifdef VERBOSE_KBD_DEBUG
  if (delta_x != 0 || delta_y != 0)
    BX_DEBUG(("[mouse] Dx=%d Dy=%d", delta_x, delta_y));
#endif  /* ifdef VERBOSE_KBD_DEBUG */

  if( (delta_x==0) && (delta_y==0) && (BX_KEY_THIS s.mouse.button_status == (button_state & 0x3) ) ) {
    BX_DEBUG(("Ignoring useless mouse_motion call:\n"));
    BX_DEBUG(("This should be fixed in the gui code.\n"));
    return;
  }

  if(BX_KEY_THIS s.mouse.button_status != (button_state & 0x3)) {
    force_enq=1;
  }

  BX_KEY_THIS s.mouse.button_status = button_state & 0x3;

  if(delta_x>255) delta_x=255;
  if(delta_y>255) delta_y=255;
  if(delta_x<-256) delta_x=-256;
  if(delta_y<-256) delta_y=-256;

  BX_KEY_THIS s.mouse.delayed_dx+=delta_x;
  BX_KEY_THIS s.mouse.delayed_dy+=delta_y;

  if((BX_KEY_THIS s.mouse.delayed_dx>255)||
     (BX_KEY_THIS s.mouse.delayed_dx<-256)||
     (BX_KEY_THIS s.mouse.delayed_dy>255)||
     (BX_KEY_THIS s.mouse.delayed_dy<-256)) {
    force_enq=1;
  }

  create_mouse_packet(force_enq);
}


  int
bx_keyb_c::SaveState( class state_file *fd )
{
  fd->write_check ("keyboard start");
  fd->write (&BX_KEY_THIS s, sizeof (BX_KEY_THIS s));
  fd->write_check ("keyboard end");
  return(0);
}


  int
bx_keyb_c::LoadState( class state_file *fd )
{
  fd->read_check ("keyboard start");
  fd->read (&BX_KEY_THIS s, sizeof (BX_KEY_THIS s));
  fd->read_check ("keyboard end");
  return(0);
}

