Keyboard.h

Go to the documentation of this file.

/* ES40 emulator.
 * Copyright (C) 2007-2008 by the ES40 Emulator Project
 *
 * WWW    : http://sourceforge.net/projects/es40
 * E-mail : camiel@camicom.com
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 * 
 * Although this is not required, the author would appreciate being notified of, 
 * and receiving any modifications you may make to the source code that might serve
 * the general public.
 */

#if !defined(INCLUDED_KEYBOARD_H)
#define INCLUDED_KEYBOARD_H

#include "SystemComponent.h"
#include "gui/gui.h"

#define BX_KBD_ELEMENTS     16
#define BX_MOUSE_BUFF_SIZE  48

#define MOUSE_MODE_RESET    10
#define MOUSE_MODE_STREAM   11
#define MOUSE_MODE_REMOTE   12
#define MOUSE_MODE_WRAP     13

class CKeyboard : public CSystemComponent, public Poco::Runnable
{
  public:
    CKeyboard(CConfigurator* cfg, CSystem* c);
    virtual       ~CKeyboard();

    virtual void  check_state();
    virtual void  WriteMem(int index, u64 address, int dsize, u64 data);
    virtual u64   ReadMem(int index, u64 address, int dsize);
    virtual int   SaveState(FILE* f);
    virtual int   RestoreState(FILE* f);
    virtual void  run();
    void          execute();

    void          gen_scancode(u32 key);

    virtual void  init();
    virtual void  start_threads();
    virtual void  stop_threads();
  private:
    Poco::Thread * myThread;
    bool      StopThread;

    u8        read_60();
    void      write_60(u8 data);
    u8        read_64();
    void      write_64(u8 data);
    void      resetinternals(bool powerup);
    void      enQ(u8 scancode);
    void      controller_enQ(u8 data, unsigned source);
    void      set_kbd_clock_enable(u8 value);
    void      set_aux_clock_enable(u8 value);
    void      ctrl_to_kbd(u8 value);
    void      enQ_imm(u8 val);
    void      ctrl_to_mouse(u8 value);
    bool      mouse_enQ_packet(u8 b1, u8 b2, u8 b3, u8 b4);
    void      mouse_enQ(u8 mouse_data);
    unsigned  periodic();

    //  void kbd_clock();
    void      create_mouse_packet(bool force_enq);

    struct SKb_state
    {

      struct SAli_kbdc_status
      {
        bool  pare;     
        bool  tim;      
        bool  auxb;     
        bool  keyl;     
        bool  c_d;      
        bool  sysf;     
        bool  inpb;     
        bool  outb;     
      } status;

      /* internal to our version of the keyboard controller */
      bool  kbd_clock_enabled;
      bool  aux_clock_enabled;
      bool  allow_irq1;
      bool  allow_irq12;
      u8    kbd_output_buffer;
      u8    aux_output_buffer;
      u8    last_comm;
      u8    expecting_port60h;
      u8    expecting_mouse_parameter;
      u8    last_mouse_command;
      u32   timer_pending;
      bool  irq1_requested;
      bool  irq12_requested;
      bool  scancodes_translate;
      bool  expecting_scancodes_set;
      u8    current_scancodes_set;
      bool  bat_in_progress;

      struct SAli_mouse
      {
        bool  captured; // host mouse capture enabled

        //      u8   type;
        u8    sample_rate;
        u8    resolution_cpmm;          // resolution in counts per mm
        u8    scaling;
        u8    mode;
        u8    saved_mode;               // the mode prior to entering wrap mode
        bool  enable;

        u8 get_status_byte()
        {

          // top bit is 0 , bit 6 is 1 if remote mode.
          u8  ret = (u8) ((mode == MOUSE_MODE_REMOTE) ? 0x40 : 0);
          ret |= (enable << 5);
          ret |= (scaling == 1) ? 0 : (1 << 4);
          ret |= ((button_status & 0x1) << 2);
          ret |= ((button_status & 0x2) << 0);
          return ret;
        }

        u8 get_resolution_byte()
        {
          u8  ret = 0;

          switch(resolution_cpmm)
          {
          case 1:   ret = 0; break;
          case 2:   ret = 1; break;
          case 4:   ret = 2; break;
          case 8:   ret = 3; break;
          default:  FAILURE(NotImplemented, "mouse: invalid resolution_cpmm");
          };
          return ret;
        }

        u8    button_status;
        s16   delayed_dx;
        s16   delayed_dy;
        s16   delayed_dz;
        u8    im_request;
        bool  im_mode;
      } mouse;

      struct SAli_kbdib
      {
        int   num_elements;
        u8    buffer[BX_KBD_ELEMENTS];
        int   head;
        bool  expecting_typematic;
        bool  expecting_led_write;
        bool  expecting_make_break;
        u8    delay;
        u8    repeat_rate;
        u8    led_status;
        bool  scanning_enabled;
      } kbd_internal_buffer;

      struct SAli_mib
      {
        int num_elements;
        u8  buffer[BX_MOUSE_BUFF_SIZE];
        int head;
      } mouse_internal_buffer;

#define BX_KBD_CONTROLLER_QSIZE 5
      u8        kbd_controller_Q[BX_KBD_CONTROLLER_QSIZE];
      unsigned  kbd_controller_Qsize;
      unsigned  kbd_controller_Qsource; 
    } state;
};

extern CKeyboard*   theKeyboard;
#endif // !defined(INCLUDED_KEYBOARD_H)

Project space on SourceForge.net