// Originally by David Raingeard (cal2)
// GCC/SDL port by Niels Wagenaar (Linux/WIN32) and Caz (BeOS)
// Cleanups and endian wrongness amelioration by James L. Hammons
+// (C) 2010 Underground Software
+//
+// JLH = James L. Hammons <jlhamm@acm.org>
+//
+// Who When What
+// --- ---------- -------------------------------------------------------------
+// JLH 01/16/2010 Created this log ;-)
+// JLH 01/20/2011 Change rendering to RGBA, removed unnecessary code
+//
// Note: Endian wrongness probably stems from the MAME origins of this emu and
-// the braindead way in which MAME handles memory. :-)
+// the braindead way in which MAME used to handle memory. :-}
//
// Note: TOM has only a 16K memory space
//
#include "jaguar.h"
#include "log.h"
#include "m68k.h"
-#include "objectp.h"
+//#include "memory.h"
+#include "op.h"
#include "settings.h"
-#include "video.h"
#define NEW_TIMER_SYSTEM
#define VDB 0x46
#define VDE 0x48
#define VI 0x4E
+#define PIT0 0x50
+#define PIT1 0x52
#define BG 0x58
#define INT1 0xE0
uint8 tomRam8[0x4000];
uint32 tomWidth, tomHeight;
-static uint32 tom_timer_prescaler;
-static uint32 tom_timer_divider;
-static int32 tom_timer_counter;
-//uint32 tom_scanline;
-//uint32 hblankWidthInPixels = 0;
+uint32 tomTimerPrescaler;
+uint32 tomTimerDivider;
+int32 tomTimerCounter;
uint16 tom_jerry_int_pending, tom_timer_int_pending, tom_object_int_pending,
tom_gpu_int_pending, tom_video_int_pending;
-//uint16 * tom_cry_rgb_mix_lut;
-//int16 * TOMBackbuffer;
-uint32 * TOMBackbuffer;
+
+// These are set by the "user" of the Jaguar core lib, since these are
+// OS/system dependent.
+uint32 * screenBuffer;
+uint32 screenPitch;
static const char * videoMode_to_str[8] =
{ "16 BPP CRY", "24 BPP RGB", "16 BPP DIRECT", "16 BPP RGB",
void tom_render_16bpp_rgb_scanline(uint32 * backbuffer);
void tom_render_16bpp_cry_rgb_mix_scanline(uint32 * backbuffer);
-void tom_render_16bpp_cry_stretch_scanline(uint32 * backbuffer);
-void tom_render_24bpp_stretch_scanline(uint32 * backbuffer);
-void tom_render_16bpp_direct_stretch_scanline(uint32 * backbuffer);
-void tom_render_16bpp_rgb_stretch_scanline(uint32 * backbuffer);
-void tom_render_16bpp_cry_rgb_mix_stretch_scanline(uint32 * backbuffer);
-
-render_xxx_scanline_fn * scanline_render_normal[] =
+//render_xxx_scanline_fn * scanline_render_normal[] =
+render_xxx_scanline_fn * scanline_render[] =
{
tom_render_16bpp_cry_scanline,
tom_render_24bpp_scanline,
tom_render_16bpp_rgb_scanline
};
-render_xxx_scanline_fn * scanline_render_stretch[] =
-{
- tom_render_16bpp_cry_stretch_scanline,
- tom_render_24bpp_stretch_scanline,
- tom_render_16bpp_direct_stretch_scanline,
- tom_render_16bpp_rgb_stretch_scanline,
- tom_render_16bpp_cry_rgb_mix_stretch_scanline,
- tom_render_24bpp_stretch_scanline,
- tom_render_16bpp_direct_stretch_scanline,
- tom_render_16bpp_rgb_stretch_scanline,
-};
-
-render_xxx_scanline_fn * scanline_render[8];
-
-
// Screen info for various games [PAL]...
/*
BIOS
uint32 CRY16ToRGB32[0x10000];
uint32 MIX16ToRGB32[0x10000];
+#warning "This is not endian-safe. !!! FIX !!!"
void TOMFillLookupTables(void)
{
+ // NOTE: Jaguar 16-bit (non-CRY) color is RBG 556 like so:
+ // RRRR RBBB BBGG GGGG
for(uint32 i=0; i<0x10000; i++)
- RGB16ToRGB32[i] = 0xFF000000
- | ((i & 0xF100) >> 8) | ((i & 0xE000) >> 13)
- | ((i & 0x07C0) << 13) | ((i & 0x0700) << 8)
- | ((i & 0x003F) << 10) | ((i & 0x0030) << 4);
-
+//hm. RGB16ToRGB32[i] = 0xFF000000
+// | ((i & 0xF100) >> 8) | ((i & 0xE000) >> 13)
+// | ((i & 0x07C0) << 13) | ((i & 0x0700) << 8)
+// | ((i & 0x003F) << 10) | ((i & 0x0030) << 4);
+ RGB16ToRGB32[i] = 0x000000FF
+ | ((i & 0xF100) << 16) // Red
+ | ((i & 0x003F) << 18) // Green
+ | ((i & 0x07C0) << 5); // Blue
for(uint32 i=0; i<0x10000; i++)
{
- uint32 chrm = (i & 0xF000) >> 12,
- chrl = (i & 0x0F00) >> 8,
- y = (i & 0x00FF);
+ uint32 cyan = (i & 0xF000) >> 12,
+ red = (i & 0x0F00) >> 8,
+ intensity = (i & 0x00FF);
- uint32 r = (((uint32)redcv[chrm][chrl]) * y) >> 8,
- g = (((uint32)greencv[chrm][chrl]) * y) >> 8,
- b = (((uint32)bluecv[chrm][chrl]) * y) >> 8;
+ uint32 r = (((uint32)redcv[cyan][red]) * intensity) >> 8,
+ g = (((uint32)greencv[cyan][red]) * intensity) >> 8,
+ b = (((uint32)bluecv[cyan][red]) * intensity) >> 8;
- CRY16ToRGB32[i] = 0xFF000000 | (b << 16) | (g << 8) | r;
- MIX16ToRGB32[i] = CRY16ToRGB32[i];
+//hm. CRY16ToRGB32[i] = 0xFF000000 | (b << 16) | (g << 8) | r;
+ CRY16ToRGB32[i] = 0x000000FF | (r << 24) | (g << 16) | (b << 8);
+ MIX16ToRGB32[i] = (i & 0x01 ? RGB16ToRGB32[i] : CRY16ToRGB32[i]);
}
-
- for(uint32 i=0; i<0x10000; i++)
- if (i & 0x01)
- MIX16ToRGB32[i] = RGB16ToRGB32[i];
}
void TOMSetPendingJERRYInt(void)
}
//Used in only one place (and for debug purposes): OBJECTP.CPP
+#warning "Used in only one place (and for debug purposes): OBJECTP.CPP !!! FIX !!!"
uint16 TOMGetVDB(void)
{
-// This in NOT VDB!!!
-// return GET16(tomRam8, VBE);
return GET16(tomRam8, VDB);
}
uint32 r = *current_line_buffer++;
current_line_buffer++;
uint32 b = *current_line_buffer++;
- *backbuffer++ = 0xFF000000 | (b << 16) | (g << 8) | r;
+//hm. *backbuffer++ = 0xFF000000 | (b << 16) | (g << 8) | r;
+ *backbuffer++ = 0x000000FF | (r << 24) | (g << 16) | (b << 8);
width--;
}
}
}
}
-/////////////////////////////////////////////////////////////////////
-// This stuff may just go away by itself, especially if we do some //
-// good old OpenGL goodness... //
-/////////////////////////////////////////////////////////////////////
-
-void tom_render_16bpp_cry_rgb_mix_stretch_scanline(uint32 *backbuffer)
-{
- uint16 width=tomWidth;
- uint8 *current_line_buffer=(uint8*)&tomRam8[0x1800];
- while (width)
- {
- uint16 color = *current_line_buffer++;
- color <<= 8;
- color |= *current_line_buffer++;
- *backbuffer++ = MIX16ToRGB32[color];
- current_line_buffer += 2;
- width--;
- }
-}
-
-void tom_render_16bpp_cry_stretch_scanline(uint32 *backbuffer)
-{
- uint32 chrm, chrl, y;
-
- uint16 width=tomWidth;
- uint8 *current_line_buffer=(uint8*)&tomRam8[0x1800];
-
- while (width)
- {
- uint16 color;
- color=*current_line_buffer++;
- color<<=8;
- color|=*current_line_buffer++;
-
- chrm = (color & 0xF000) >> 12;
- chrl = (color & 0x0F00) >> 8;
- y = (color & 0x00FF);
-
- uint16 red = ((((uint32)redcv[chrm][chrl])*y)>>11);
- uint16 green = ((((uint32)greencv[chrm][chrl])*y)>>11);
- uint16 blue = ((((uint32)bluecv[chrm][chrl])*y)>>11);
-
- uint16 color2;
- color2=*current_line_buffer++;
- color2<<=8;
- color2|=*current_line_buffer++;
-
- chrm = (color2 & 0xF000) >> 12;
- chrl = (color2 & 0x0F00) >> 8;
- y = (color2 & 0x00FF);
-
- uint16 red2 = ((((uint32)redcv[chrm][chrl])*y)>>11);
- uint16 green2 = ((((uint32)greencv[chrm][chrl])*y)>>11);
- uint16 blue2 = ((((uint32)bluecv[chrm][chrl])*y)>>11);
-
- red=(red+red2)>>1;
- green=(green+green2)>>1;
- blue=(blue+blue2)>>1;
-
- *backbuffer++=(red<<10)|(green<<5)|blue;
- width--;
- }
-}
-
-void tom_render_24bpp_stretch_scanline(uint32 *backbuffer)
-{
- uint16 width=tomWidth;
- uint8 *current_line_buffer=(uint8*)&tomRam8[0x1800];
-
- while (width)
- {
- uint16 green=*current_line_buffer++;
- uint16 red=*current_line_buffer++;
- /*uint16 nc=*/current_line_buffer++;
- uint16 blue=*current_line_buffer++;
- red>>=3;
- green>>=3;
- blue>>=3;
- *backbuffer++=(red<<10)|(green<<5)|blue;
- current_line_buffer+=4;
- width--;
- }
-}
-
-void tom_render_16bpp_direct_stretch_scanline(uint32 *backbuffer)
-{
- uint16 width=tomWidth;
- uint8 *current_line_buffer=(uint8*)&tomRam8[0x1800];
-
- while (width)
- {
- uint16 color=*current_line_buffer++;
- color<<=8;
- color|=*current_line_buffer++;
- color>>=1;
- *backbuffer++=color;
- current_line_buffer+=2;
- width--;
- }
-}
-
-void tom_render_16bpp_rgb_stretch_scanline(uint32 *backbuffer)
-{
- uint16 width=tomWidth;
- uint8 *current_line_buffer=(uint8*)&tomRam8[0x1800];
-
- while (width)
- {
- uint16 color1=*current_line_buffer++;
- color1<<=8;
- color1|=*current_line_buffer++;
- color1>>=1;
- uint16 color2=*current_line_buffer++;
- color2<<=8;
- color2|=*current_line_buffer++;
- color2>>=1;
- uint16 red=(((color1&0x7c00)>>10)+((color2&0x7c00)>>10))>>1;
- uint16 green=(((color1&0x00003e0)>>5)+((color2&0x00003e0)>>5))>>1;
- uint16 blue=(((color1&0x0000001f))+((color2&0x0000001f)))>>1;
-
- color1=(red<<10)|(blue<<5)|green;
- *backbuffer++=color1;
- width--;
- }
-}
-
-void TOMResetBackbuffer(uint32 * backbuffer)
+/*void TOMResetBackbuffer(uint32 * backbuffer)
{
TOMBackbuffer = backbuffer;
-}
+}*/
//
// Process a single scanline
if (scanline & 0x01) // Execute OP only on even lines (non-interlaced only!)
return;
+//Hm, it seems that the OP needs to execute from zero, so let's try it:
+// And it works! But need to do some optimizations in the OP to keep it from attempting
+// to do a scanline render in the non-display area... [DONE]
+//this seems to cause a regression in certain games, like rayman
+//which means I have to dig thru the asic nets to see what's wrong...
+#if 1
+// 16 isn't enough, and neither is 32 for raptgun. 32 fucks up Rayman
if (scanline >= (uint16)GET16(tomRam8, VDB) && scanline < (uint16)GET16(tomRam8, VDE))
+// if (scanline >= ((uint16)GET16(tomRam8, VDB) - 32) && scanline < (uint16)GET16(tomRam8, VDE))
{
if (render)
{
}
else
inActiveDisplayArea = false;
+#else
+ inActiveDisplayArea =
+ (scanline >= (uint16)GET16(tomRam8, VDB) && scanline < (uint16)GET16(tomRam8, VDE)
+ ? true : false);
- // Try to take PAL into account...
+ if (scanline < (uint16)GET16(tomRam8, VDE))
+ {
+ if (render)//With JaguarExecuteNew() this is always true...
+ {
+ uint8 * current_line_buffer = (uint8 *)&tomRam8[0x1800];
+ uint8 bgHI = tomRam8[BG], bgLO = tomRam8[BG + 1];
+
+ // Clear line buffer with BG
+ if (GET16(tomRam8, VMODE) & BGEN) // && (CRY or RGB16)...
+ for(uint32 i=0; i<720; i++)
+ *current_line_buffer++ = bgHI, *current_line_buffer++ = bgLO;
+
+// OPProcessList(scanline, render);
+//This seems to take care of it...
+ OPProcessList(scanline, inActiveDisplayArea);
+ }
+ }
+#endif
+
+ // Try to take PAL into account... [We do now!]
uint16 topVisible = (vjs.hardwareTypeNTSC ? TOP_VISIBLE_VC : TOP_VISIBLE_VC_PAL),
bottomVisible = (vjs.hardwareTypeNTSC ? BOTTOM_VISIBLE_VC : BOTTOM_VISIBLE_VC_PAL);
+ uint32 * TOMCurrentLine = &(screenBuffer[((scanline - topVisible) / 2) * screenPitch]);
// Here's our virtualized scanline code...
if (inActiveDisplayArea)
{
//NOTE: The following doesn't put BORDER color on the sides... !!! FIX !!!
-#warning The following doesn't put BORDER color on the sides... !!! FIX !!!
+#warning "The following doesn't put BORDER color on the sides... !!! FIX !!!"
if (vjs.renderType == RT_NORMAL)
- scanline_render[TOMGetVideoMode()](TOMBackbuffer);
+// scanline_render[TOMGetVideoMode()](TOMBackbuffer);
+ scanline_render[TOMGetVideoMode()](TOMCurrentLine);
else//TV type render
{
/*
else
{
// If outside of VDB & VDE, then display the border color
- uint32 * currentLineBuffer = TOMBackbuffer;
+ uint32 * currentLineBuffer = TOMCurrentLine;
uint8 g = tomRam8[BORD1], r = tomRam8[BORD1 + 1], b = tomRam8[BORD2 + 1];
- uint32 pixel = 0xFF000000 | (b << 16) | (g << 8) | r;
+//Hm. uint32 pixel = 0xFF000000 | (b << 16) | (g << 8) | r;
+ uint32 pixel = 0x000000FF | (r << 24) | (g << 16) | (b << 8);
for(uint32 i=0; i<tomWidth; i++)
*currentLineBuffer++ = pixel;
}
-
- TOMBackbuffer += GetSDLScreenWidthInPixels();
}
}
//
void TOMInit(void)
{
+ TOMFillLookupTables();
OPInit();
BlitterInit();
TOMReset();
- // Setup the non-stretchy scanline rendering...
- memcpy(scanline_render, scanline_render_normal, sizeof(scanline_render));
- TOMFillLookupTables();
}
void TOMDone(void)
// memory_free(tom_cry_rgb_mix_lut);
}
-/*uint32 tom_getHBlankWidthInPixels(void)
-{
- return hblankWidthInPixels;
-}*/
-
uint32 TOMGetVideoModeWidth(void)
{
//These widths are pretty bogus. Should use HDB1/2 & HDE/HBB & PWIDTH to calc the width...
tom_gpu_int_pending = 0;
tom_video_int_pending = 0;
- tom_timer_prescaler = 0; // TOM PIT is disabled
- tom_timer_divider = 0;
- tom_timer_counter = 0;
- memcpy(scanline_render, scanline_render_normal, sizeof(scanline_render));
+ tomTimerPrescaler = 0; // TOM PIT is disabled
+ tomTimerDivider = 0;
+ tomTimerCounter = 0;
}
//
// offset &= 0xFF3FFF;
#ifdef TOM_DEBUG
- WriteLog("TOM: Reading byte at %06X\n", offset);
+ WriteLog("TOM: Reading byte at %06X for %s\n", offset, whoName[who]);
#endif
if ((offset >= GPU_CONTROL_RAM_BASE) && (offset < GPU_CONTROL_RAM_BASE+0x20))
else if ((offset >= 0xF02200) && (offset < 0xF022A0))
return BlitterReadByte(offset, who);
else if (offset == 0xF00050)
- return tom_timer_prescaler >> 8;
+ return tomTimerPrescaler >> 8;
else if (offset == 0xF00051)
- return tom_timer_prescaler & 0xFF;
+ return tomTimerPrescaler & 0xFF;
else if (offset == 0xF00052)
- return tom_timer_divider >> 8;
+ return tomTimerDivider >> 8;
else if (offset == 0xF00053)
- return tom_timer_divider & 0xFF;
+ return tomTimerDivider & 0xFF;
return tomRam8[offset & 0x3FFF];
}
//???Is this needed???
// offset &= 0xFF3FFF;
#ifdef TOM_DEBUG
- WriteLog("TOM: Reading word at %06X\n", offset);
+ WriteLog("TOM: Reading word at %06X for %s\n", offset, whoName[who]);
#endif
if (offset >= 0xF02000 && offset <= 0xF020FF)
WriteLog("TOM: Read attempted from GPU register file by %s (unimplemented)!\n", whoName[who]);
if (offset == 0xF000E0)
{
+ // For reading, should only return the lower 5 bits...
uint16 data = (tom_jerry_int_pending << 4) | (tom_timer_int_pending << 3)
| (tom_object_int_pending << 2) | (tom_gpu_int_pending << 1)
| (tom_video_int_pending << 0);
else if ((offset >= 0xF02200) && (offset < 0xF022A0))
return BlitterReadWord(offset, who);
else if (offset == 0xF00050)
- return tom_timer_prescaler;
+ return tomTimerPrescaler;
else if (offset == 0xF00052)
- return tom_timer_divider;
+ return tomTimerDivider;
offset &= 0x3FFF;
return (TOMReadByte(offset, who) << 8) | TOMReadByte(offset + 1, who);
}
+#define TOM_STRICT_MEMORY_ACCESS
//
// TOM byte access (write)
//
void TOMWriteByte(uint32 offset, uint8 data, uint32 who/*=UNKNOWN*/)
{
+#ifdef TOM_DEBUG
+ WriteLog("TOM: Writing byte %02X at %06X", data, offset);
+#endif
//???Is this needed???
// Perhaps on the writes--32-bit writes that is! And masked with FF7FFF...
+#ifndef TOM_STRICT_MEMORY_ACCESS
offset &= 0xFF3FFF;
-
+#else
+ // "Fast" (32-bit only) write access to the GPU
+// if ((offset >= 0xF0A100) && (offset <= 0xF0BFFF))
+ if ((offset >= 0xF08000) && (offset <= 0xF0BFFF))
+ offset &= 0xFF7FFF;
+#endif
#ifdef TOM_DEBUG
- WriteLog("TOM: Writing byte %02X at %06X\n", data, offset);
+ WriteLog(" -->[%06X] by %s\n", offset, whoName[who]);
+#endif
+
+#ifdef TOM_STRICT_MEMORY_ACCESS
+ // Sanity check ("Aww, there ain't no Sanity Clause...")
+ if ((offset < 0xF00000) || (offset > 0xF03FFF))
+ return;
#endif
if ((offset >= GPU_CONTROL_RAM_BASE) && (offset < GPU_CONTROL_RAM_BASE+0x20))
}
else if (offset == 0xF00050)
{
- tom_timer_prescaler = (tom_timer_prescaler & 0x00FF) | (data << 8);
+ tomTimerPrescaler = (tomTimerPrescaler & 0x00FF) | (data << 8);
TOMResetPIT();
return;
}
else if (offset == 0xF00051)
{
- tom_timer_prescaler = (tom_timer_prescaler & 0xFF00) | data;
+ tomTimerPrescaler = (tomTimerPrescaler & 0xFF00) | data;
TOMResetPIT();
return;
}
else if (offset == 0xF00052)
{
- tom_timer_divider = (tom_timer_divider & 0x00FF) | (data << 8);
+ tomTimerDivider = (tomTimerDivider & 0x00FF) | (data << 8);
TOMResetPIT();
return;
}
else if (offset == 0xF00053)
{
- tom_timer_divider = (tom_timer_divider & 0xFF00) | data;
+ tomTimerDivider = (tomTimerDivider & 0xFF00) | data;
TOMResetPIT();
return;
}
//
void TOMWriteWord(uint32 offset, uint16 data, uint32 who/*=UNKNOWN*/)
{
-//???Is this needed???
+#ifdef TOM_DEBUG
+ WriteLog("TOM: Writing byte %04X at %06X", data, offset);
+#endif
+//???Is this needed??? Yes, but we need to be more vigilant than this.
+#ifndef TOM_STRICT_MEMORY_ACCESS
offset &= 0xFF3FFF;
-
+#else
+ // "Fast" (32-bit only) write access to the GPU
+// if ((offset >= 0xF0A100) && (offset <= 0xF0BFFF))
+ if ((offset >= 0xF08000) && (offset <= 0xF0BFFF))
+ offset &= 0xFF7FFF;
+#endif
#ifdef TOM_DEBUG
- WriteLog("TOM: Writing word %04X at %06X\n", data, offset);
+ WriteLog(" -->[%06X] by %s\n", offset, whoName[who]);
#endif
+
+#ifdef TOM_STRICT_MEMORY_ACCESS
+ // Sanity check
+ if ((offset < 0xF00000) || (offset > 0xF03FFF))
+ return;
+#endif
+
if (offset == 0xF00000 + MEMCON1)
WriteLog("TOM: Memory Configuration 1 written by %s: %04X\n", whoName[who], data);
if (offset == 0xF00000 + MEMCON2)
}*/
else if (offset == 0xF00050)
{
- tom_timer_prescaler = data;
+ tomTimerPrescaler = data;
TOMResetPIT();
return;
}
else if (offset == 0xF00052)
{
- tom_timer_divider = data;
+ tomTimerDivider = data;
TOMResetPIT();
return;
}
tom_timer_int_pending = 0;
if (data & 0x1000)
tom_jerry_int_pending = 0;
+
+// return;
}
else if ((offset >= 0xF02200) && (offset <= 0xF0229F))
{
// Writing to one CLUT writes to the other
offset &= 0x5FF; // Mask out $F00600 (restrict to $F00400-5FF)
// Watch out for unaligned writes here! (Not fixed yet)
+#warning "!!! Watch out for unaligned writes here !!! FIX !!!"
SET16(tomRam8, offset, data);
SET16(tomRam8, offset + 0x200, data);
}
offset &= 0x3FFF;
if (offset == 0x28) // VMODE (Why? Why not OBF?)
//Actually, we should check to see if the Enable bit of VMODE is set before doing this... !!! FIX !!!
-#warning Actually, we should check to see if the Enable bit of VMODE is set before doing this... !!! FIX !!!
+#warning "Actually, we should check to see if the Enable bit of VMODE is set before doing this... !!! FIX !!!"
objectp_running = 1;
if (offset >= 0x30 && offset <= 0x4E)
if (offset == 0x2E || offset == 0x36 || offset == 0x54)
data &= 0x03FF; // These are all 10-bit registers
- TOMWriteByte(offset, data >> 8, who);
- TOMWriteByte(offset+1, data & 0xFF, who);
+// Fix a lockup bug... :-P
+ TOMWriteByte(0xF00000 | offset, data >> 8, who);
+ TOMWriteByte(0xF00000 | (offset+1), data & 0xFF, who);
if (offset == VDB)
WriteLog("TOM: Vertical Display Begin written by %s: %u\n", whoName[who], data);
WriteLog("TOM: Vertical Period written by %s: %u (%sinterlaced)\n", whoName[who], data, (data & 0x01 ? "non-" : ""));
if (offset == HDB1)
WriteLog("TOM: Horizontal Display Begin 1 written by %s: %u\n", whoName[who], data);
+if (offset == HDB2)
+ WriteLog("TOM: Horizontal Display Begin 2 written by %s: %u\n", whoName[who], data);
if (offset == HDE)
WriteLog("TOM: Horizontal Display End written by %s: %u\n", whoName[who], data);
if (offset == HP)
WriteLog("TOM: Horizontal Blank End written by %s: %u\n", whoName[who], data);
if (offset == VMODE)
WriteLog("TOM: Video Mode written by %s: %04X. PWIDTH = %u, MODE = %s, flags:%s%s (VC = %u)\n", whoName[who], data, ((data >> 9) & 0x07) + 1, videoMode_to_str[(data & MODE) >> 1], (data & BGEN ? " BGEN" : ""), (data & VARMOD ? " VARMOD" : ""), GET16(tomRam8, VC));
+if (offset == PIT0)
+ WriteLog("TOM: PIT0 written by %s: %u\n", whoName[who], data);
+if (offset == PIT1)
+ WriteLog("TOM: PIT1 written by %s: %u\n", whoName[who], data);
+//if (offset == INT1)
+// WriteLog("TOM: CPU Interrupt Control written by %s: $%04X (%s%s%s%s%s)\n", whoName[who], data, (data & 0x01 ? "Video" : ""), (data & 0x02 ? " GPU" : ""), (data & 0x04 ? " OP" : ""), (data & 0x08 ? " TOMPIT" : ""), (data & 0x10 ? " Jerry" : ""));
// detect screen resolution changes
//This may go away in the future, if we do the virtualized screen thing...
//This may go away soon!
+// TOM Shouldn't be mucking around with this, it's up to the host system to properly
+// handle this kind of crap.
+// NOTE: This is needed somehow, need to get rid of the dependency on this crap.
+#warning "!!! Need to get rid of this dependency !!!"
+#if 1
if ((offset >= 0x28) && (offset <= 0x4F))
{
uint32 width = TOMGetVideoModeWidth(), height = TOMGetVideoModeHeight();
{
tomWidth = width, tomHeight = height;
- if (vjs.renderType == RT_NORMAL)
- ResizeScreen(tomWidth, tomHeight);
+#warning "!!! TOM: ResizeScreen commented out !!!"
+// No need to resize anything, since we're prepared for this...
+// if (vjs.renderType == RT_NORMAL)
+// ResizeScreen(tomWidth, tomHeight);
}
}
+#endif
}
int TOMIRQEnabled(int irq)
return tomRam8[INT1 + 1/*0xE1*/] & (1 << irq);
}
-//unused
-/*void tom_set_irq_latch(int irq, int enabled)
-{
- tomRam8[0xE0] = (tomRam8[0xE0] & (~(1<<irq))) | (enabled ? (1<<irq) : 0);
-}*/
-
-//unused
-/*uint16 tom_irq_control_reg(void)
-{
- return (tomRam8[0xE0] << 8) | tomRam8[0xE1];
-}*/
-
// NEW:
// TOM Programmable Interrupt Timer handler
// NOTE: TOM's PIT is only enabled if the prescaler is != 0
// Need to remove previous timer from the queue, if it exists...
RemoveCallback(TOMPITCallback);
- if (tom_timer_prescaler)
+ if (tomTimerPrescaler)
{
- double usecs = (float)(tom_timer_prescaler + 1) * (float)(tom_timer_divider + 1) * RISC_CYCLE_IN_USEC;
+ double usecs = (float)(tomTimerPrescaler + 1) * (float)(tomTimerDivider + 1) * RISC_CYCLE_IN_USEC;
SetCallbackTime(TOMPITCallback, usecs);
}
#endif
// once the timer system is stable.
void TOMExecPIT(uint32 cycles)
{
- if (tom_timer_prescaler)
+ if (tomTimerPrescaler)
{
- tom_timer_counter -= cycles;
+ tomTimerCounter -= cycles;
- if (tom_timer_counter <= 0)
+ if (tomTimerCounter <= 0)
{
TOMSetPendingTimerInt();
GPUSetIRQLine(GPUIRQ_TIMER, ASSERT_LINE); // GPUSetIRQLine does the 'IRQ enabled' checking
if (TOMIRQEnabled(IRQ_TIMER))
- m68k_set_irq(7); // Cause a 68000 NMI...
+ m68k_set_irq(2); // Cause a 68000 IPL 2...
TOMResetPIT();
}
}
}
-
void TOMPITCallback(void)
{
-// INT1_RREG |= 0x08; // Set TOM PIT interrupt pending
+// INT1_RREG |= 0x08; // Set TOM PIT interrupt pending
TOMSetPendingTimerInt();
- GPUSetIRQLine(GPUIRQ_TIMER, ASSERT_LINE); // It does the 'IRQ enabled' checking
+ GPUSetIRQLine(GPUIRQ_TIMER, ASSERT_LINE); // It does the 'IRQ enabled' checking
// if (INT1_WREG & 0x08)
if (TOMIRQEnabled(IRQ_TIMER))
- m68k_set_irq(7); // Generate 68K NMI
+ m68k_set_irq(2); // Generate a 68K IPL 2...
TOMResetPIT();
}
projects / virtualjaguar / blobdiff