OpenCores
URL https://opencores.org/ocsvn/ao486/ao486/trunk

Subversion Repositories ao486

[/] [ao486/] [trunk/] [bochs486/] [pc_system.h] - Blame information for rev 2

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.