cec9135e9f
"bx_bool" which is always defined as Bit32u on all platforms. In Carbon
specific code, Boolean is still used because the Carbon header files
define it to unsigned char.
- this fixes bug [ 623152 ] MacOSX: Triple Exception Booting win95.
The bug was that some code in Bochs depends on Boolean to be a
32 bit value. (This should be fixed, but I don't know all the places
where it needs to be fixed yet.) Because Carbon defined Boolean as
an unsigned char, Bochs just followed along and used the unsigned char
definition to avoid compile problems. This exposed the dependency
on 32 bit Boolean on MacOS X only and led to major simulation problems,
that could only be reproduced and debugged on that platform.
- On the mailing list we debated whether to make all Booleans into "bool" or
our own type. I chose bx_bool for several reasons.
1. Unlike C++'s bool, we can guarantee that bx_bool is the same size on all
platforms, which makes it much less likely to have more platform-specific
simulation differences in the future. (I spent hours on a borrowed
MacOSX machine chasing bug 618388 before discovering that different sized
Booleans were the problem, and I don't want to repeat that.)
2. We still have at least one dependency on 32 bit Booleans which must be
fixed some time, but I don't want to risk introducing new bugs into the
simulation just before the 2.0 release.
Modified Files:
bochs.h config.h.in gdbstub.cc logio.cc main.cc pc_system.cc
pc_system.h plugin.cc plugin.h bios/rombios.c cpu/apic.cc
cpu/arith16.cc cpu/arith32.cc cpu/arith64.cc cpu/arith8.cc
cpu/cpu.cc cpu/cpu.h cpu/ctrl_xfer16.cc cpu/ctrl_xfer32.cc
cpu/ctrl_xfer64.cc cpu/data_xfer16.cc cpu/data_xfer32.cc
cpu/data_xfer64.cc cpu/debugstuff.cc cpu/exception.cc
cpu/fetchdecode.cc cpu/flag_ctrl_pro.cc cpu/init.cc
cpu/io_pro.cc cpu/lazy_flags.cc cpu/lazy_flags.h cpu/mult16.cc
cpu/mult32.cc cpu/mult64.cc cpu/mult8.cc cpu/paging.cc
cpu/proc_ctrl.cc cpu/segment_ctrl_pro.cc cpu/stack_pro.cc
cpu/tasking.cc debug/dbg_main.cc debug/debug.h debug/sim2.cc
disasm/dis_decode.cc disasm/disasm.h doc/docbook/Makefile
docs-html/cosimulation.html fpu/wmFPUemu_glue.cc
gui/amigaos.cc gui/beos.cc gui/carbon.cc gui/gui.cc gui/gui.h
gui/keymap.cc gui/keymap.h gui/macintosh.cc gui/nogui.cc
gui/rfb.cc gui/sdl.cc gui/siminterface.cc gui/siminterface.h
gui/term.cc gui/win32.cc gui/wx.cc gui/wxmain.cc gui/wxmain.h
gui/x.cc instrument/example0/instrument.cc
instrument/example0/instrument.h
instrument/example1/instrument.cc
instrument/example1/instrument.h
instrument/stubs/instrument.cc instrument/stubs/instrument.h
iodev/cdrom.cc iodev/cdrom.h iodev/cdrom_osx.cc iodev/cmos.cc
iodev/devices.cc iodev/dma.cc iodev/dma.h iodev/eth_arpback.cc
iodev/eth_packetmaker.cc iodev/eth_packetmaker.h
iodev/floppy.cc iodev/floppy.h iodev/guest2host.h
iodev/harddrv.cc iodev/harddrv.h iodev/ioapic.cc
iodev/ioapic.h iodev/iodebug.cc iodev/iodev.h
iodev/keyboard.cc iodev/keyboard.h iodev/ne2k.h
iodev/parallel.h iodev/pci.cc iodev/pci.h iodev/pic.h
iodev/pit.cc iodev/pit.h iodev/pit_wrap.cc iodev/pit_wrap.h
iodev/sb16.cc iodev/sb16.h iodev/serial.cc iodev/serial.h
iodev/vga.cc iodev/vga.h memory/memory.h memory/misc_mem.cc
622 lines
20 KiB
C++
622 lines
20 KiB
C++
/////////////////////////////////////////////////////////////////////////
|
|
// $Id: pit_wrap.cc,v 1.32 2002-10-25 11:44:40 bdenney 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
|
|
|
|
|
|
//Realtime Algorithm (with gettimeofday)
|
|
// HAVE:
|
|
// Real number of usec.
|
|
// Emulated number of usec.
|
|
// WANT:
|
|
// Number of ticks to use.
|
|
// Number of emulated usec to wait until next try.
|
|
//
|
|
// ticks=number of ticks needed to match total real usec.
|
|
// if(desired ticks > max ticks for elapsed real time)
|
|
// ticks = max ticks for elapsed real time.
|
|
// if(desired ticks > max ticks for elapsed emulated usec)
|
|
// ticks = max ticks for emulated usec.
|
|
// next wait ticks = number of ticks until next event.
|
|
// next wait real usec = (current ticks + next wait ticks) * usec per ticks
|
|
// next wait emulated usec = next wait real usec * emulated usec / real usec
|
|
// if(next wait emulated usec < minimum emulated usec for next wait ticks)
|
|
// next wait emulated usec = minimum emulated usec for next wait ticks.
|
|
// if(next wait emulated usec > max emulated usec wait)
|
|
// next wait emulated usec = max emulated usec wait.
|
|
//
|
|
// How to calculate elapsed real time:
|
|
// store an unused time value whenever no ticks are used in a given time.
|
|
// add this to the current elapsed time.
|
|
// How to calculate elapsed emulated time:
|
|
// same as above.
|
|
// Above can be done by not updating last_usec and last_sec.
|
|
//
|
|
// How to calculate emulated usec/real usec:
|
|
// Each time there are actual ticks:
|
|
// Alpha_product(old emulated usec, emulated usec);
|
|
// Alpha_product(old real usec, real usec);
|
|
// Divide resulting values.
|
|
|
|
|
|
#include "bochs.h"
|
|
|
|
#if BX_USE_NEW_PIT
|
|
|
|
#include "pit_wrap.h"
|
|
#define LOG_THIS bx_pit.
|
|
|
|
bx_pit_c bx_pit;
|
|
#if BX_USE_PIT_SMF
|
|
#define this (&bx_pit)
|
|
#endif
|
|
|
|
#ifdef OUT
|
|
# undef OUT
|
|
#endif
|
|
|
|
#define DEBUG_REALTIME_WITH_PRINTF 0
|
|
#define DEBUG_GETTIMEOFDAY_WITH_PRINTF 1
|
|
|
|
|
|
#define TIME_DIVIDER (1)
|
|
#define TIME_MULTIPLIER (1)
|
|
#define TIME_HEADSTART (1)
|
|
#define MIN_USEC_PER_SECOND (150000)
|
|
//USEC_ALPHA is multiplier for the past.
|
|
//USEC_ALPHA_B is 1-USEC_ALPHA, or multiplier for the present.
|
|
#define USEC_ALPHA ((double)(.8))
|
|
#define USEC_ALPHA_B ((double)(((double)1)-USEC_ALPHA))
|
|
#define USEC_ALPHA2 ((double)(.5))
|
|
#define USEC_ALPHA2_B ((double)(((double)1)-USEC_ALPHA2))
|
|
#define ALPHA_LOWER(old,new) ((Bit64u)((old<new)?((USEC_ALPHA*((double)(old)))+(USEC_ALPHA_B*((double)new))):((USEC_ALPHA2*((double)old))+(USEC_ALPHA2_B*((double)new)))))
|
|
#define MIN_MULT (0.9)
|
|
#define MIN_MULT_FLOOR (0.75)
|
|
#define MAX_MULT (1.25)
|
|
#define MAX_MULT_CEILING (1.5)
|
|
#define BX_MAX(a,b) ( ((a)>(b))?(a):(b) )
|
|
#define BX_MIN(a,b) ( ((a)>(b))?(b):(a) )
|
|
|
|
//How many timer ticks per usecond.
|
|
//1.193181MHz Clock
|
|
//1193/1000 Ticks Per usecond.
|
|
#define TICKS_PER_SECOND (1193181)
|
|
#define USEC_PER_SECOND (1000000)
|
|
#define TIME_MULT 1.193
|
|
#define REAL_TICKS_TO_USEC(a) ( ((a)*USEC_PER_SECOND)/TICKS_PER_SECOND )
|
|
#define REAL_USEC_TO_TICKS(a) ( ((a)*TICKS_PER_SECOND)/USEC_PER_SECOND )
|
|
#define AHEAD_CEILING ((Bit64u)(TICKS_PER_SECOND*2))
|
|
#define TICKS_TO_USEC(a) ((BX_USE_REALTIME_PIT)?( ((a)*BX_PIT_THIS s.usec_per_second)/BX_PIT_THIS s.ticks_per_second ):( ((a)*USEC_PER_SECOND)/TICKS_PER_SECOND ))
|
|
#define USEC_TO_TICKS(a) ((BX_USE_REALTIME_PIT)?( ((a)*BX_PIT_THIS s.ticks_per_second)/BX_PIT_THIS s.usec_per_second ):( ((a)*TICKS_PER_SECOND)/USEC_PER_SECOND ))
|
|
|
|
bx_pit_c::bx_pit_c( void )
|
|
{
|
|
put("PIT");
|
|
settype(PITLOG);
|
|
s.speaker_data_on=0;
|
|
|
|
/* 8254 PIT (Programmable Interval Timer) */
|
|
|
|
BX_PIT_THIS s.timer_handle[1] = BX_NULL_TIMER_HANDLE;
|
|
BX_PIT_THIS s.timer_handle[2] = BX_NULL_TIMER_HANDLE;
|
|
BX_PIT_THIS s.timer_handle[0] = BX_NULL_TIMER_HANDLE;
|
|
}
|
|
|
|
bx_pit_c::~bx_pit_c( void )
|
|
{
|
|
}
|
|
|
|
int
|
|
bx_pit_c::init( void )
|
|
{
|
|
bx_devices.register_irq(0, "8254 PIT");
|
|
bx_devices.register_io_read_handler(this, read_handler, 0x0040, "8254 PIT");
|
|
bx_devices.register_io_read_handler(this, read_handler, 0x0041, "8254 PIT");
|
|
bx_devices.register_io_read_handler(this, read_handler, 0x0042, "8254 PIT");
|
|
bx_devices.register_io_read_handler(this, read_handler, 0x0043, "8254 PIT");
|
|
bx_devices.register_io_read_handler(this, read_handler, 0x0061, "8254 PIT");
|
|
|
|
bx_devices.register_io_write_handler(this, write_handler, 0x0040, "8254 PIT");
|
|
bx_devices.register_io_write_handler(this, write_handler, 0x0041, "8254 PIT");
|
|
bx_devices.register_io_write_handler(this, write_handler, 0x0042, "8254 PIT");
|
|
bx_devices.register_io_write_handler(this, write_handler, 0x0043, "8254 PIT");
|
|
bx_devices.register_io_write_handler(this, write_handler, 0x0061, "8254 PIT");
|
|
|
|
BX_DEBUG(("pit: starting init"));
|
|
|
|
BX_PIT_THIS s.speaker_data_on = 0;
|
|
BX_PIT_THIS s.refresh_clock_div2 = 0;
|
|
|
|
BX_PIT_THIS s.timer.init();
|
|
|
|
if (BX_PIT_THIS s.timer_handle[0] == BX_NULL_TIMER_HANDLE) {
|
|
BX_PIT_THIS s.timer_handle[0] = bx_pc_system.register_timer(this, timer_handler, (unsigned) 100 , 1, 1, "pit_wrap");
|
|
}
|
|
BX_DEBUG(("pit: RESETting timer."));
|
|
bx_pc_system.deactivate_timer(BX_PIT_THIS s.timer_handle[0]);
|
|
BX_DEBUG(("deactivated timer."));
|
|
if(BX_PIT_THIS s.timer.get_next_event_time()) {
|
|
bx_pc_system.activate_timer(BX_PIT_THIS s.timer_handle[0],
|
|
BX_MAX(1,TICKS_TO_USEC(BX_PIT_THIS s.timer.get_next_event_time())),
|
|
0);
|
|
BX_DEBUG(("activated timer."));
|
|
}
|
|
BX_PIT_THIS s.last_next_event_time = BX_PIT_THIS s.timer.get_next_event_time();
|
|
BX_PIT_THIS s.last_usec=bx_pc_system.time_usec();
|
|
|
|
BX_PIT_THIS s.total_ticks=0;
|
|
|
|
if (BX_USE_REALTIME_PIT) {
|
|
BX_PIT_THIS s.usec_per_second=USEC_PER_SECOND;
|
|
BX_PIT_THIS s.ticks_per_second=TICKS_PER_SECOND;
|
|
BX_PIT_THIS s.total_sec=0;
|
|
BX_PIT_THIS s.stored_delta=0;
|
|
#if BX_HAVE_REALTIME_USEC
|
|
BX_PIT_THIS s.last_time=((bx_get_realtime64_usec()*(Bit64u)TIME_MULTIPLIER/(Bit64u)TIME_DIVIDER))+(Bit64u)TIME_HEADSTART*(Bit64u)USEC_PER_SECOND;
|
|
#else
|
|
BX_PIT_THIS s.last_time=((time(NULL)*TIME_MULTIPLIER/TIME_DIVIDER)+TIME_HEADSTART)*USEC_PER_SECOND;
|
|
#endif
|
|
BX_PIT_THIS s.max_ticks = AHEAD_CEILING;
|
|
} else {
|
|
BX_PIT_THIS s.total_usec=0;
|
|
}
|
|
|
|
BX_DEBUG(("pit: finished init"));
|
|
|
|
BX_DEBUG(("s.last_usec=%d",BX_PIT_THIS s.last_usec));
|
|
BX_DEBUG(("s.timer_id=%d",BX_PIT_THIS s.timer_handle[0]));
|
|
BX_DEBUG(("s.timer.get_next_event_time=%d",BX_PIT_THIS s.timer.get_next_event_time()));
|
|
BX_DEBUG(("s.last_next_event_time=%d",BX_PIT_THIS s.last_next_event_time));
|
|
|
|
return(1);
|
|
}
|
|
|
|
void
|
|
bx_pit_c::reset(unsigned type)
|
|
{
|
|
}
|
|
|
|
void
|
|
bx_pit_c::timer_handler(void *this_ptr) {
|
|
bx_pit_c * class_ptr = (bx_pit_c *) this_ptr;
|
|
|
|
class_ptr->handle_timer();
|
|
}
|
|
|
|
void
|
|
bx_pit_c::handle_timer() {
|
|
Bit64u time_passed = bx_pc_system.time_usec()-BX_PIT_THIS s.last_usec;
|
|
Bit32u time_passed32 = time_passed;
|
|
|
|
BX_DEBUG(("pit: entering timer handler"));
|
|
|
|
if(time_passed32) {
|
|
periodic(time_passed32);
|
|
}
|
|
BX_PIT_THIS s.last_usec=BX_PIT_THIS s.last_usec + time_passed;
|
|
if(time_passed ||
|
|
(BX_PIT_THIS s.last_next_event_time
|
|
!= BX_PIT_THIS s.timer.get_next_event_time())
|
|
) {
|
|
BX_DEBUG(("pit: RESETting timer."));
|
|
bx_pc_system.deactivate_timer(BX_PIT_THIS s.timer_handle[0]);
|
|
BX_DEBUG(("deactivated timer."));
|
|
if(BX_PIT_THIS s.timer.get_next_event_time()) {
|
|
bx_pc_system.activate_timer(BX_PIT_THIS s.timer_handle[0],
|
|
BX_MAX(1,TICKS_TO_USEC(BX_PIT_THIS s.timer.get_next_event_time())),
|
|
0);
|
|
BX_DEBUG(("activated timer."));
|
|
}
|
|
BX_PIT_THIS s.last_next_event_time = BX_PIT_THIS s.timer.get_next_event_time();
|
|
}
|
|
BX_DEBUG(("s.last_usec=%d",BX_PIT_THIS s.last_usec));
|
|
BX_DEBUG(("s.timer_id=%d",BX_PIT_THIS s.timer_handle[0]));
|
|
BX_DEBUG(("s.timer.get_next_event_time=%x",BX_PIT_THIS s.timer.get_next_event_time()));
|
|
BX_DEBUG(("s.last_next_event_time=%d",BX_PIT_THIS s.last_next_event_time));
|
|
}
|
|
|
|
|
|
// static IO port read callback handler
|
|
// redirects to non-static class handler to avoid virtual functions
|
|
|
|
Bit32u
|
|
bx_pit_c::read_handler(void *this_ptr, Bit32u address, unsigned io_len)
|
|
{
|
|
#if !BX_USE_PIT_SMF
|
|
bx_pit_c *class_ptr = (bx_pit_c *) this_ptr;
|
|
|
|
return( class_ptr->read(address, io_len) );
|
|
}
|
|
|
|
|
|
Bit32u
|
|
bx_pit_c::read( Bit32u address, unsigned int io_len )
|
|
{
|
|
#else
|
|
UNUSED(this_ptr);
|
|
#endif // !BX_USE_PIT_SMF
|
|
BX_DEBUG(("pit: entering read handler"));
|
|
|
|
handle_timer();
|
|
|
|
if (io_len > 1)
|
|
BX_PANIC(("pit: io read from port %04x, len=%u", (unsigned) address,
|
|
(unsigned) io_len));
|
|
|
|
if (bx_dbg.pit)
|
|
BX_INFO(("pit: io read from port %04x", (unsigned) address));
|
|
|
|
switch (address) {
|
|
|
|
case 0x40: /* timer 0 - system ticks */
|
|
return(BX_PIT_THIS s.timer.read(0));
|
|
break;
|
|
case 0x41: /* timer 1 read */
|
|
return(BX_PIT_THIS s.timer.read(1));
|
|
break;
|
|
case 0x42: /* timer 2 read */
|
|
return(BX_PIT_THIS s.timer.read(2));
|
|
break;
|
|
case 0x43: /* timer 1 read */
|
|
return(BX_PIT_THIS s.timer.read(3));
|
|
break;
|
|
|
|
case 0x61:
|
|
/* AT, port 61h */
|
|
BX_PIT_THIS s.refresh_clock_div2 = !BX_PIT_THIS s.refresh_clock_div2;
|
|
return( (BX_PIT_THIS s.timer.read_OUT(2)<<5) |
|
|
(BX_PIT_THIS s.refresh_clock_div2<<4) |
|
|
(BX_PIT_THIS s.speaker_data_on<<1) |
|
|
(BX_PIT_THIS s.timer.read_GATE(2)?1:0) );
|
|
break;
|
|
|
|
default:
|
|
BX_PANIC(("pit: unsupported io read from port %04x", address));
|
|
}
|
|
return(0); /* keep compiler happy */
|
|
}
|
|
|
|
|
|
// static IO port write callback handler
|
|
// redirects to non-static class handler to avoid virtual functions
|
|
|
|
void
|
|
bx_pit_c::write_handler(void *this_ptr, Bit32u address, Bit32u dvalue, unsigned io_len)
|
|
{
|
|
#if !BX_USE_PIT_SMF
|
|
bx_pit_c *class_ptr = (bx_pit_c *) this_ptr;
|
|
|
|
class_ptr->write(address, dvalue, io_len);
|
|
}
|
|
|
|
void
|
|
bx_pit_c::write( Bit32u address, Bit32u dvalue,
|
|
unsigned int io_len )
|
|
{
|
|
#else
|
|
UNUSED(this_ptr);
|
|
#endif // !BX_USE_PIT_SMF
|
|
Bit8u value;
|
|
Bit64u time_passed = bx_pc_system.time_usec()-BX_PIT_THIS s.last_usec;
|
|
Bit32u time_passed32 = time_passed;
|
|
|
|
BX_DEBUG(("pit: entering write handler"));
|
|
|
|
if(time_passed32) {
|
|
periodic(time_passed32);
|
|
}
|
|
BX_PIT_THIS s.last_usec=BX_PIT_THIS s.last_usec + time_passed;
|
|
|
|
value = (Bit8u ) dvalue;
|
|
|
|
if (io_len > 1)
|
|
BX_PANIC(("pit: io write to port %04x, len=%u", (unsigned) address,
|
|
(unsigned) io_len));
|
|
|
|
if (bx_dbg.pit)
|
|
BX_INFO(("pit: write to port %04x = %02x",
|
|
(unsigned) address, (unsigned) value));
|
|
|
|
switch (address) {
|
|
case 0x40: /* timer 0: write count register */
|
|
BX_PIT_THIS s.timer.write(0,value);
|
|
break;
|
|
|
|
case 0x41: /* timer 1: write count register */
|
|
BX_PIT_THIS s.timer.write( 1,value );
|
|
break;
|
|
|
|
case 0x42: /* timer 2: write count register */
|
|
BX_PIT_THIS s.timer.write( 2,value );
|
|
break;
|
|
|
|
case 0x43: /* timer 0-2 mode control */
|
|
BX_PIT_THIS s.timer.write( 3,value );
|
|
break;
|
|
|
|
case 0x61:
|
|
BX_PIT_THIS s.speaker_data_on = (value >> 1) & 0x01;
|
|
/*??? only on AT+ */
|
|
BX_PIT_THIS s.timer.set_GATE(2, value & 0x01);
|
|
#if BX_CPU_LEVEL < 2
|
|
/* ??? XT: */
|
|
bx_kbd_port61h_write(value);
|
|
#endif
|
|
break;
|
|
|
|
default:
|
|
BX_PANIC(("pit: unsupported io write to port %04x = %02x",
|
|
(unsigned) address, (unsigned) value));
|
|
}
|
|
|
|
if ((BX_PIT_THIS s.timer.read_OUT(0))==1) {
|
|
DEV_pic_raise_irq(0);
|
|
} else {
|
|
DEV_pic_lower_irq(0);
|
|
}
|
|
|
|
if(time_passed ||
|
|
(BX_PIT_THIS s.last_next_event_time
|
|
!= BX_PIT_THIS s.timer.get_next_event_time())
|
|
) {
|
|
BX_DEBUG(("pit: RESETting timer."));
|
|
bx_pc_system.deactivate_timer(BX_PIT_THIS s.timer_handle[0]);
|
|
BX_DEBUG(("deactivated timer."));
|
|
if(BX_PIT_THIS s.timer.get_next_event_time()) {
|
|
bx_pc_system.activate_timer(BX_PIT_THIS s.timer_handle[0],
|
|
BX_MAX(1,TICKS_TO_USEC(BX_PIT_THIS s.timer.get_next_event_time())),
|
|
0);
|
|
BX_DEBUG(("activated timer."));
|
|
}
|
|
BX_PIT_THIS s.last_next_event_time = BX_PIT_THIS s.timer.get_next_event_time();
|
|
}
|
|
BX_DEBUG(("s.last_usec=%d",BX_PIT_THIS s.last_usec));
|
|
BX_DEBUG(("s.timer_id=%d",BX_PIT_THIS s.timer_handle[0]));
|
|
BX_DEBUG(("s.timer.get_next_event_time=%x",BX_PIT_THIS s.timer.get_next_event_time()));
|
|
BX_DEBUG(("s.last_next_event_time=%d",BX_PIT_THIS s.last_next_event_time));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
bx_pit_c::SaveState( class state_file *fd )
|
|
{
|
|
fd->write_check ("8254 start");
|
|
fd->write (&BX_PIT_THIS s, sizeof (BX_PIT_THIS s));
|
|
fd->write_check ("8254 end");
|
|
return(0);
|
|
}
|
|
|
|
|
|
int
|
|
bx_pit_c::LoadState( class state_file *fd )
|
|
{
|
|
fd->read_check ("8254 start");
|
|
fd->read (&BX_PIT_THIS s, sizeof (BX_PIT_THIS s));
|
|
fd->read_check ("8254 end");
|
|
return(0);
|
|
}
|
|
|
|
|
|
#if 0
|
|
void
|
|
bx_kbd_port61h_write(Bit8u value)
|
|
{
|
|
// PcError("KBD_PORT61H_WRITE(): not implemented yet");
|
|
UNUSED( value );
|
|
}
|
|
#endif
|
|
|
|
|
|
bx_bool
|
|
bx_pit_c::periodic( Bit32u usec_delta )
|
|
{
|
|
bx_bool prev_timer0_out = BX_PIT_THIS s.timer.read_OUT(0);
|
|
bx_bool want_interrupt = 0;
|
|
Bit32u ticks_delta = 0;
|
|
|
|
#ifdef BX_SCHEDULED_DIE_TIME
|
|
if (bx_pc_system.time_ticks() > BX_SCHEDULED_DIE_TIME) {
|
|
BX_ERROR (("ticks exceeded scheduled die time, quitting"));
|
|
BX_EXIT (2);
|
|
}
|
|
#endif
|
|
|
|
if (BX_USE_REALTIME_PIT) {
|
|
#if BX_HAVE_REALTIME_USEC
|
|
Bit64u real_time_delta = bx_get_realtime64_usec() - BX_PIT_THIS s.last_time;
|
|
Bit64u real_time_total = real_time_delta + BX_PIT_THIS s.total_sec;
|
|
Bit64u em_time_delta = (Bit64u)usec_delta + (Bit64u)BX_PIT_THIS s.stored_delta;
|
|
BX_PIT_THIS s.ticks_per_second = TICKS_PER_SECOND;
|
|
|
|
//Start out with the number of ticks we would like
|
|
// to have to line up with real time.
|
|
ticks_delta = REAL_USEC_TO_TICKS(real_time_total) - BX_PIT_THIS s.total_ticks;
|
|
if(REAL_USEC_TO_TICKS(real_time_total) < BX_PIT_THIS s.total_ticks) {
|
|
//This slows us down if we're already ahead.
|
|
// probably only an issue on startup, but it solves some problems.
|
|
ticks_delta = 0;
|
|
}
|
|
if(ticks_delta > REAL_USEC_TO_TICKS((Bit64u)(MAX_MULT * real_time_delta))) {
|
|
//This keeps us from going too fast in relation to real time.
|
|
ticks_delta = REAL_USEC_TO_TICKS((Bit64u)(MAX_MULT * real_time_delta));
|
|
BX_PIT_THIS s.ticks_per_second = (Bit64u)(MAX_MULT * TICKS_PER_SECOND);
|
|
}
|
|
if(ticks_delta > em_time_delta * TICKS_PER_SECOND / MIN_USEC_PER_SECOND) {
|
|
//This keeps us from having too few instructions between ticks.
|
|
ticks_delta = em_time_delta * TICKS_PER_SECOND / MIN_USEC_PER_SECOND;
|
|
}
|
|
if(ticks_delta > BX_PIT_THIS s.timer.get_next_event_time()) {
|
|
//This keeps us from missing ticks.
|
|
ticks_delta = BX_PIT_THIS s.timer.get_next_event_time();
|
|
}
|
|
|
|
if(ticks_delta) {
|
|
#if DEBUG_GETTIMEOFDAY_WITH_PRINTF
|
|
if(((BX_PIT_THIS s.last_time + real_time_delta) / USEC_PER_SECOND) > (BX_PIT_THIS s.last_time / USEC_PER_SECOND)) {
|
|
printf("useconds: %lld, expected ticks: %lld, ticks: %lld, diff: %lld\n",
|
|
(Bit64u) BX_PIT_THIS s.total_sec,
|
|
(Bit64u)REAL_USEC_TO_TICKS(BX_PIT_THIS s.total_sec),
|
|
(Bit64u)BX_PIT_THIS s.total_ticks,
|
|
(Bit64u)(REAL_USEC_TO_TICKS(BX_PIT_THIS s.total_sec) - BX_PIT_THIS s.total_ticks)
|
|
);
|
|
}
|
|
#endif
|
|
BX_PIT_THIS s.last_time += real_time_delta;
|
|
BX_PIT_THIS s.total_sec += real_time_delta;
|
|
BX_PIT_THIS s.last_sec_usec += em_time_delta;
|
|
// BX_PIT_THIS s.total_usec += em_time_delta;
|
|
BX_PIT_THIS s.stored_delta = 0;
|
|
BX_PIT_THIS s.total_ticks += ticks_delta;
|
|
} else {
|
|
BX_PIT_THIS s.stored_delta = em_time_delta;
|
|
}
|
|
|
|
Bit64u a,b;
|
|
a=(BX_PIT_THIS s.usec_per_second);
|
|
b=((Bit64u)1000000 * em_time_delta / real_time_delta);
|
|
|
|
BX_PIT_THIS s.usec_per_second = ALPHA_LOWER(a,b);
|
|
#else
|
|
ticks_delta=(Bit32u)(USEC_TO_TICKS(usec_delta));
|
|
if((BX_PIT_THIS s.total_ticks + ticks_delta) < (BX_PIT_THIS s.max_ticks)) {
|
|
BX_PIT_THIS s.total_ticks += ticks_delta;
|
|
} else {
|
|
if(BX_PIT_THIS s.total_ticks >= (BX_PIT_THIS s.max_ticks)) {
|
|
ticks_delta = 0;
|
|
} else {
|
|
ticks_delta = (BX_PIT_THIS s.max_ticks) - BX_PIT_THIS s.total_ticks;
|
|
BX_PIT_THIS s.total_ticks += ticks_delta;
|
|
}
|
|
}
|
|
second_update_data();
|
|
#endif
|
|
} else {
|
|
BX_PIT_THIS s.total_usec += usec_delta;
|
|
ticks_delta=(Bit32u)((USEC_TO_TICKS((Bit64u)(BX_PIT_THIS s.total_usec)))-BX_PIT_THIS s.total_ticks);
|
|
BX_PIT_THIS s.total_ticks += ticks_delta;
|
|
|
|
while ((BX_PIT_THIS s.total_ticks >= 1193181) && (BX_PIT_THIS s.total_usec >= 1000000)) {
|
|
BX_PIT_THIS s.total_ticks -= 1193181;
|
|
BX_PIT_THIS s.total_usec -= 1000000;
|
|
}
|
|
}
|
|
|
|
while(ticks_delta>0) {
|
|
Bit32u maxchange=BX_PIT_THIS s.timer.get_next_event_time();
|
|
Bit32u timedelta=maxchange;
|
|
if((maxchange==0) || (maxchange>ticks_delta)) {
|
|
timedelta=ticks_delta;
|
|
}
|
|
BX_PIT_THIS s.timer.clock_all(timedelta);
|
|
if ( (prev_timer0_out==0) ) {
|
|
if ((BX_PIT_THIS s.timer.read_OUT(0))==1) {
|
|
DEV_pic_raise_irq(0);
|
|
prev_timer0_out=1;
|
|
}
|
|
} else {
|
|
if ((BX_PIT_THIS s.timer.read_OUT(0))==0) {
|
|
DEV_pic_lower_irq(0);
|
|
prev_timer0_out=0;
|
|
}
|
|
}
|
|
prev_timer0_out=BX_PIT_THIS s.timer.read_OUT(0);
|
|
ticks_delta-=timedelta;
|
|
}
|
|
|
|
return(want_interrupt);
|
|
}
|
|
|
|
|
|
void
|
|
bx_pit_c::second_update_data(void) {
|
|
Bit64u timediff;
|
|
#if BX_HAVE_REALTIME_USEC
|
|
timediff=((bx_get_realtime64_usec()*(Bit64u)TIME_MULTIPLIER/(Bit64u)TIME_DIVIDER))-(Bit64u)BX_PIT_THIS s.last_time;
|
|
#else
|
|
timediff=((time(NULL)*TIME_MULTIPLIER/TIME_DIVIDER)*USEC_PER_SECOND)-BX_PIT_THIS s.last_time;
|
|
#endif
|
|
BX_PIT_THIS s.last_time += timediff;
|
|
if(timediff) {
|
|
Bit64s tickstemp;
|
|
|
|
BX_PIT_THIS s.total_sec += timediff;
|
|
|
|
BX_PIT_THIS s.max_ticks = BX_MIN( (((BX_PIT_THIS s.total_sec)*(Bit64u)(TICKS_PER_SECOND))/USEC_PER_SECOND) + AHEAD_CEILING , BX_PIT_THIS s.total_ticks + (Bit64u)(TICKS_PER_SECOND*MAX_MULT) );
|
|
|
|
#if DEBUG_REALTIME_WITH_PRINTF
|
|
printf("timediff: %lld, total_sec: %lld, total_ticks: %lld\n",timediff, BX_PIT_THIS s.total_sec, BX_PIT_THIS s.total_ticks);
|
|
#endif
|
|
|
|
tickstemp =
|
|
((((BX_PIT_THIS s.total_sec)*TICKS_PER_SECOND)/USEC_PER_SECOND)-BX_PIT_THIS s.total_ticks)
|
|
+ TICKS_PER_SECOND;
|
|
|
|
// while((BX_PIT_THIS s.total_sec >= 0) && (BX_PIT_THIS s.total_ticks >= TICKS_PER_SECOND)) {
|
|
// BX_PIT_THIS s.total_sec -= 1;
|
|
// BX_PIT_THIS s.total_ticks -= TICKS_PER_SECOND;
|
|
// }
|
|
|
|
if(tickstemp > (TICKS_PER_SECOND*MAX_MULT)) {
|
|
#if DEBUG_REALTIME_WITH_PRINTF
|
|
if (tickstemp>(2*TICKS_PER_SECOND)) {
|
|
printf("Running WAY too slow. tps:%lld\n",tickstemp);
|
|
} else {
|
|
printf("Running slow. tps:%lld\n",tickstemp);
|
|
}
|
|
#endif
|
|
tickstemp = (Bit64u)(TICKS_PER_SECOND*MAX_MULT);
|
|
#if DEBUG_REALTIME_WITH_PRINTF
|
|
printf("..................new tps:%lld\n",tickstemp);
|
|
#endif
|
|
} else if(tickstemp < (TICKS_PER_SECOND*MIN_MULT)) {
|
|
#if DEBUG_REALTIME_WITH_PRINTF
|
|
if(tickstemp<0) {
|
|
printf("Running WAY too fast. tps:%lld\n",tickstemp);
|
|
} else {
|
|
printf("Running fast. tps:%lld\n",tickstemp);
|
|
}
|
|
#endif
|
|
tickstemp = (Bit64u)(TICKS_PER_SECOND*MIN_MULT);
|
|
#if DEBUG_REALTIME_WITH_PRINTF
|
|
printf("..................new tps:%lld\n",tickstemp);
|
|
#endif
|
|
}
|
|
|
|
BX_PIT_THIS s.ticks_per_second = tickstemp;
|
|
|
|
// BX_PIT_THIS s.usec_per_second = ALPHA_LOWER(BX_PIT_THIS s.usec_per_second,((bx_pc_system.time_usec()-BX_PIT_THIS s.last_sec_usec)*USEC_PER_SECOND/timediff));
|
|
BX_PIT_THIS s.usec_per_second = ((bx_pc_system.time_usec()-BX_PIT_THIS s.last_sec_usec)*USEC_PER_SECOND/timediff);
|
|
BX_PIT_THIS s.usec_per_second = BX_MAX(BX_PIT_THIS s.usec_per_second , MIN_USEC_PER_SECOND);
|
|
BX_PIT_THIS s.last_sec_usec = bx_pc_system.time_usec();
|
|
#if DEBUG_REALTIME_WITH_PRINTF
|
|
printf("Parms: ticks_per_second=%lld, usec_per_second=%lld\n",BX_PIT_THIS s.ticks_per_second, BX_PIT_THIS s.usec_per_second);
|
|
printf("total_usec: %lld\n", bx_pc_system.time_usec());
|
|
#endif
|
|
}
|
|
}
|
|
#endif // #if BX_USE_NEW_PIT
|