pc_system.h

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: pc_system.h,v 1.44 2008/03/19 18:36:17 sshwarts Exp $
   3 /////////////////////////////////////////////////////////////////////////
   4 //
   5 //  Copyright (C) 2004  MandrakeSoft S.A.
   6 //
   7 //    MandrakeSoft S.A.
   8 //    43, rue d'Aboukir
   9 //    75002 Paris - France
  10 //    http://www.linux-mandrake.com/
  11 //    http://www.mandrakesoft.com/
  12 //
  13 //  This library is free software; you can redistribute it and/or
  14 //  modify it under the terms of the GNU Lesser General Public
  15 //  License as published by the Free Software Foundation; either
  16 //  version 2 of the License, or (at your option) any later version.
  17 //
  18 //  This library is distributed in the hope that it will be useful,
  19 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21 //  Lesser General Public License for more details.
  22 //
  23 //  You should have received a copy of the GNU Lesser General Public
  24 //  License along with this library; if not, write to the Free Software
  25 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  26
  27 #ifndef BX_PCSYS_H
  28 #define BX_PCSYS_H
  29
  30 #define BX_MAX_TIMERS 64
  31 #define BX_NULL_TIMER_HANDLE 10000
  32
  33 typedef void (*bx_timer_handler_t)(void *);
  34
  35 BOCHSAPI extern class bx_pc_system_c bx_pc_system;
  36
  37 #ifdef PROVIDE_M_IPS
  38 extern double m_ips;
  39 #endif
  40
  41 class BOCHSAPI bx_pc_system_c : private logfunctions {
  42 private:
  43
  44   // ===============================
  45   // Timer oriented private features
  46   // ===============================
  47
  48   struct {
  49     bx_bool inUse;      // Timer slot is in-use (currently registered).
  50     Bit64u  period;     // Timer periodocity in cpu ticks.
  51     Bit64u  timeToFire; // Time to fire next (in absolute ticks).
  52     bx_bool active;     // 0=inactive, 1=active.
  53     bx_bool continuous; // 0=one-shot timer, 1=continuous periodicity.
  54     bx_timer_handler_t funct;  // A callback function for when the
  55                                //   timer fires.
  56     void *this_ptr;            // The this-> pointer for C++ callbacks
  57                                //   has to be stored as well.
  58 #define BxMaxTimerIDLen 32
  59     char id[BxMaxTimerIDLen]; // String ID of timer.
  60   } timer[BX_MAX_TIMERS];
  61
  62   unsigned   numTimers;  // Number of currently allocated timers.
  63   unsigned   triggeredTimer;  // ID of the actually triggered timer.
  64   Bit32u     currCountdown; // Current countdown ticks value (decrements to 0).
  65   Bit32u     currCountdownPeriod; // Length of current countdown period.
  66   Bit64u     ticksTotal; // Num ticks total since start of emulator execution.
  67   Bit64u     lastTimeUsec; // Last sequentially read time in usec.
  68   Bit64u     usecSinceLast; // Number of useconds claimed since then.
  69
  70   // A special null timer is always inserted in the timer[0] slot.  This
  71   // make sure that at least one timer is always active, and that the
  72   // duration is always less than a maximum 32-bit integer, so a 32-bit
  73   // counter can be used for the current countdown.
  74   static const Bit64u NullTimerInterval;
  75   static void nullTimer(void* this_ptr);
  76
  77 #if !defined(PROVIDE_M_IPS)
  78   // This is the emulator speed, as measured in millions of
  79   // x86 instructions per second that it can emulate on some hypothetically
  80   // nomimal workload.
  81   double     m_ips; // Millions of Instructions Per Second
  82 #endif
  83
  84   // This handler is called when the function which decrements the clock
  85   // ticks finds that an event has occurred.
  86   void   countdownEvent(void);
  87
  88 public:
  89
  90   // ==============================
  91   // Timer oriented public features
  92   // ==============================
  93
  94   void   initialize(Bit32u ips);
  95   int    register_timer(void *this_ptr, bx_timer_handler_t, Bit32u useconds,
  96                          bx_bool continuous, bx_bool active, const char *id);
  97   bx_bool unregisterTimer(unsigned timerID);
  98   void   start_timers(void);
  99   void   activate_timer(unsigned timer_index, Bit32u useconds, bx_bool continuous);
 100   void   deactivate_timer(unsigned timer_index);
 101   unsigned triggeredTimerID(void) {
 102     return triggeredTimer;
 103   }
 104   static BX_CPP_INLINE void tick1(void) {
 105     if (--bx_pc_system.currCountdown == 0) {
 106       bx_pc_system.countdownEvent();
 107     }
 108   }
 109   static BX_CPP_INLINE void tickn(Bit32u n) {
 110     while (n >= bx_pc_system.currCountdown) {
 111       n -= bx_pc_system.currCountdown;
 112       bx_pc_system.currCountdown = 0;
 113       bx_pc_system.countdownEvent();
 114       // bx_pc_system.currCountdown is adjusted to new value by countdownevent().
 115     }
 116     // 'n' is not (or no longer) >= the countdown size.  We can just decrement
 117     // the remaining requested ticks and continue.
 118     bx_pc_system.currCountdown -= n;
 119   }
 120
 121   int register_timer_ticks(void* this_ptr, bx_timer_handler_t, Bit64u ticks,
 122                            bx_bool continuous, bx_bool active, const char *id);
 123   void activate_timer_ticks(unsigned index, Bit64u instructions,
 124                             bx_bool continuous);
 125   Bit64u time_usec();
 126   Bit64u time_usec_sequential();
 127   static BX_CPP_INLINE Bit64u time_ticks() {
 128     return bx_pc_system.ticksTotal +
 129       Bit64u(bx_pc_system.currCountdownPeriod - bx_pc_system.currCountdown);
 130   }
 131
 132   static BX_CPP_INLINE Bit32u  getNumCpuTicksLeftNextEvent(void) {
 133     return bx_pc_system.currCountdown;
 134   }
 135 #if BX_DEBUGGER
 136   static void timebp_handler(void* this_ptr);
 137 #endif
 138   static void benchmarkTimer(void* this_ptr);
 139
 140   // ===========================
 141   // Non-timer oriented features
 142   // ===========================
 143
 144   bx_bool HRQ;     // Hold Request
 145
 146   // Address line 20 control:
 147   //   1 = enabled: extended memory is accessible
 148   //   0 = disabled: A20 address line is forced low to simulate
 149   //       an 8088 address map
 150   bx_bool enable_a20;
 151
 152   // start out masking physical memory addresses to:
 153   //   8086:      20 bits
 154   //    286:      24 bits
 155   //    386:      32 bits
 156   // when A20 line is disabled, mask physical memory addresses to:
 157   //    286:      20 bits
 158   //    386:      20 bits
 159   bx_phy_address a20_mask;
 160
 161   volatile bx_bool kill_bochs_request;
 162
 163   void set_HRQ(bx_bool val);  // set the Hold ReQuest line
 164   void set_INTR(bx_bool value); // set the INTR line to value
 165
 166   // Cpu and System Reset
 167   int Reset(unsigned type);
 168   Bit8u  IAC(void);
 169
 170   bx_pc_system_c();
 171
 172   Bit32u  inp(Bit16u addr, unsigned io_len) BX_CPP_AttrRegparmN(2);
 173   void    outp(Bit16u addr, Bit32u value, unsigned io_len) BX_CPP_AttrRegparmN(3);
 174   void    set_enable_a20(bx_bool value);
 175   bx_bool get_enable_a20(void);
 176   void    MemoryMappingChanged(void); // flush TLB in all CPUs
 177   void    invlpg(bx_address addr);    // flush TLB page in all CPUs
 178   void    exit(void);
 179   void    register_state(void);
 180 };
 181
 182 #endif