int main(void)
{
Timer_t timer; // Create our timer object!
Led_t led; // Create the LED Object on P1.0!
/* Watchdog timer disabled */
WDTCTL = WDTPW + WDTHOLD;
BspInit(); // Set up
(void) TimerMasterInit(100); //100 *10us = 1ms
TimerCtor(&timer);
LedCtor(&led, kPort1, kPin0); //P1.0 (red)
__eint(); // Enable global interrupts
while(true)
{
if (TimerGet(&timer)>100) // 0.2s period (1ms*20)
{
LedToggle(&led);
TimerReset(&timer);
}
}
}
void XMLClient::StartAyncRead() {
try {
Globals::ErrorMessage("StartAyncRead\n");
if (!_socket->is_open()) {
raise(SIGTRAP);
}
TimerReset();
boost::asio::async_read(*_socket,
boost::asio::buffer(data_, max_length), // buff, //boost::asio::buffer(&readBuffer[0], readBuffer.size()),
boost::asio::transfer_at_least(1),
boost::bind(&XMLClient::bytesToRead,
this,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
std::string statcmd = CrclInterface().CRCLGetStatusCmd();
SyncWrite(statcmd);
Globals::Sleep(1000);
} catch (boost::exception & ex) {
//http://theboostcpplibraries.com/boost.exception
std::cerr << boost::diagnostic_information(ex);
_socket->close();
} catch (...) {
_socket->close();
}
}
/************************************************************************************//**
** \brief Starts the user program, if one is present. In this case this function
** does not return.
** \return none.
**
****************************************************************************************/
void CpuStartUserProgram(void)
{
void (*pProgResetHandler)(void);
/* check if a user program is present by verifying the checksum */
if (NvmVerifyChecksum() == BLT_FALSE)
{
/* not a valid user program so it cannot be started */
return;
}
#if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0)
/* invoke callback */
if (CpuUserProgramStartHook() == BLT_FALSE)
{
/* callback requests the user program to not be started */
return;
}
#endif
#if (BOOT_COM_ENABLE > 0)
/* release the communication interface */
ComFree();
#endif
/* reset the timer */
TimerReset();
/* remap user program's vector table */
SCB_VTOR = CPU_USER_PROGRAM_VECTABLE_OFFSET & (blt_int32u)0x1FFFFF80;
/* set the address where the bootloader needs to jump to. this is the address of
* the 2nd entry in the user program's vector table. this address points to the
* user program's reset handler.
*/
pProgResetHandler = (void(*)(void))(*((blt_addr*)CPU_USER_PROGRAM_STARTADDR_PTR));
/* start the user program by activating its reset interrupt service routine */
pProgResetHandler();
} /*** end of CpuStartUserProgram ***/
Timer* TimerCreate(Allocator* alloc)
{
Timer* timer = Allocate(alloc, Timer);
TimerReset(timer);
return timer;
}
////////////////////////////////////////////////////////////
// Check time (reseting it)
////////////////////////////////////////////////////////////
bool TimerCheckReset(struct Timer * TimerData, float Time)
{
// Update elapsed time
TimerData->ElapsedTime = (float)SystemGetTime();
if ( TimerData->ElapsedTime - TimerData->LastCounter >= Time )
{
TimerReset(TimerData);
return true;
}
return false;
}
/************************************************************************************//**
** \brief Initializes the polling based millisecond timer driver.
** \return none.
**
****************************************************************************************/
void TimerInit(void)
{
/* reset the timer configuration */
TimerReset();
/* configure the systick frequency as a 1 ms event generator */
SYSTICK->LOAD = BOOT_CPU_SYSTEM_SPEED_KHZ - 1;
/* reset the current counter value */
SYSTICK->VAL = 0;
/* select core clock as source and enable the timer */
SYSTICK->CTRL = SYSTICK_BIT_CLKSOURCE | SYSTICK_BIT_ENABLE;
/* reset the millisecond counter value */
millisecond_counter = 0;
} /*** end of TimerInit ***/
/************************************************************************************//**
** \brief Initializes the polling based millisecond timer driver.
** \return none.
**
****************************************************************************************/
void TimerInit(void)
{
/* reset the timer configuration. note that this also sets the default prescaler
* to 1, so the free running counter runs at the same speed as the system
* (BOOT_CPU_SYSTEM_SPEED_KHZ).
*/
TimerReset();
/* configure timer channel 0 as a 1 millisecond software timer */
TIMER->tios |= IOS0_BIT;
/* make sure timer 0 interrupt flag is cleared */
TIMER->tflg1 = C0F_BIT;
/* generate output compare event in 1 milliseconds from now */
TIMER->tc[0] = TIMER->tcnt + TIMER_COUNTS_PER_MS;
/* enable the timer subsystem */
TIMER->tscr1 |= TEN_BIT;
/* reset the millisecond counter value */
millisecond_counter = 0;
} /*** end of TimerInit ***/
void main(void)
{
unsigned long Status = 0;
/********************** Configure System clock *************************/
SysCtlClockSet(100000000, SYSCTL_OSC_INT | SYSCTL_XTAL_12_MHZ);
SysCtlDelay(TICK_SLOW);
// Enable LED PORT
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
// Configure LED(PC3) pin into output mode.
xGPIOSPinTypeGPIOOutput(PC3);
// Configure Timer Capture pin(PB26)
GPIOPinFunCfg(GPIOB_BASE, GPIO_PIN_26, GPIO_PB26_TIMCCP0);
TimerCounterCfg(TIMER0_BASE, TIMER_CFG_CNT_CAP0_BOTH);
TimerReset(TIMER0_BASE);
TimerStart(TIMER0_BASE);
while (1)
{
if( (TimerValueGet(TIMER0_BASE) % 10) == 0)
{
if(Status)
{
// Turn on LED
Status = 0;
GPIOPinSet(GPIOC_BASE, GPIO_PIN_3);
}
else
{
// Turn off LED
Status = 1;
GPIOPinClr(GPIOC_BASE, GPIO_PIN_3);
}
}
}
while(1);
}
void TimerInit(void)
{
TimerReset();
#if PRECISE_TIMING
// Start timer thread
#ifdef PRECISE_TIMING_BEOS
wakeup_time_sem = create_sem(1, "Wakeup Time");
timer_thread = spawn_thread(timer_func, "Time Manager", B_REAL_TIME_PRIORITY, NULL);
resume_thread(timer_thread);
#elif PRECISE_TIMING_MACH
pthread_t pthread;
host_get_clock_service(mach_host_self(), REALTIME_CLOCK, &system_clock);
semaphore_create(mach_task_self(), &wakeup_time_sem, SYNC_POLICY_FIFO, 1);
pthread_create(&pthread, NULL, &timer_func, NULL);
#endif
#ifdef PRECISE_TIMING_POSIX
timer_thread_active = timer_thread_init();
#endif
#endif
}
/************************************************************************************//**
** \brief Starts the user program, if one is present. In this case this function
** does not return.
** \return none.
**
****************************************************************************************/
void CpuStartUserProgram(void)
{
void (*pProgResetHandler)(void);
/* check if a user program is present by verifying the checksum */
if (NvmVerifyChecksum() == BLT_FALSE)
{
/* not a valid user program so it cannot be started */
return;
}
#if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0)
/* invoke callback */
if (CpuUserProgramStartHook() == BLT_FALSE)
{
/* callback requests the user program to not be started */
return;
}
#endif
#if (BOOT_COM_ENABLE > 0)
/* release the communication interface */
ComFree();
#endif
/* reset the timer */
TimerReset();
/* copy the user program's interrupt vector table to RAM */
CpuMemCopy(CPU_RAM_VECTORS_START_ADDR, CPU_USER_PROG_VECTORS_START_ADDR, \
CPU_VECTORS_TABLE_SIZE);
/* select RAM vector table */
MEMMAP = 0x02;
/* set the address where the bootloader needs to jump to */
pProgResetHandler = (void*)CPU_RAM_VECTORS_START_ADDR;
/* start the user program by activating its reset interrupt service routine */
pProgResetHandler();
} /*** end of CpuStartUserProgram ***/
VOID DoWM_COMMAND(HWND hwnd, WPARAM wParam, LPARAM lParam)
{
switch (HIWORD(wParam))
{
case EN_CHANGE:
if (fileopen) {
SendMessage(hStatus, SB_SETTEXT, 0, (LPARAM)DirtyMsg);
filedirty = TRUE;
TimerReset();
}
else {
SendMessage(hStatus, SB_SETTEXT, 0, (LPARAM)"File not opened! (save or open new file).");
}
break;
case BN_CLICKED:
if (fileopen) {
if (LOWORD(wParam) == BTN_OPENFOLDER)
OpenFolder(hwnd);
if (LOWORD(wParam) == BTN_REVERT)
Revert(hwnd);
}
else {
if (LOWORD(wParam) == BTN_OPENFILE)
PromptAndLoadFile(hwnd);
}
break;
}
switch (LOWORD(wParam))
{
case ID_FILE_EXIT:
PostMessage(hwnd, WM_CLOSE, 0, 0);
break;
case ID_VIEW_HEADERAREA:
{
HMENU hMenu = GetMenu(hwnd);
statusarea = !statusarea;
CheckMenuItem(hMenu, ID_VIEW_HEADERAREA, statusarea ? MF_CHECKED : MF_UNCHECKED);
FullRedraw(hwnd);
break;
}
case ID_VIEW_STATUSBAR:
{
HMENU hMenu = GetMenu(hwnd);
statusbar = !statusbar;
CheckMenuItem(hMenu, ID_VIEW_STATUSBAR, statusbar ? MF_CHECKED : MF_UNCHECKED);
ShowWindow(hStatus, statusbar);
FullRedraw(hwnd);
break;
}
case ID_VIEW_ORIGINALFILEDATA:
{
HMENU hMenu = GetMenu(hwnd);
OrigDataWindow = !OrigDataWindow;
CheckMenuItem(hMenu, ID_VIEW_ORIGINALFILEDATA, statusbar ? MF_CHECKED : MF_UNCHECKED);
ShowWindow(hOriginalDataWindow, OrigDataWindow);
FullRedraw(hwnd);
break;
}
}
}
int
AOS4_sound_handler::audioTask()
{
uint32 sigMask;
unsigned long clockAdvance = 40;
unsigned int nSamples = (441*clockAdvance) / 10;
unsigned int toFetch = nSamples*2;
boost::int16_t samples[AHI_BUF_SIZE];
_closing = false;
AHIDevice = -1;
PlayBuffer[0] = (UBYTE*)IExec->AllocMem(BUFSIZE, MEMF_SHARED|MEMF_CLEAR);
PlayBuffer[1] = (UBYTE*)IExec->AllocMem(BUFSIZE, MEMF_SHARED|MEMF_CLEAR);
if (!PlayBuffer[0] || !PlayBuffer[1])
{
log_error(_("AOS4: Unable to allocate memory for audio buffer!"));
throw SoundException("AOS4: Unable to allocate memory for audio buffer!");
}
if ((AHImp=(struct MsgPort*) IExec->AllocSysObjectTags(ASOT_PORT, TAG_DONE)) != NULL)
{
if ((AHIio=(struct AHIRequest *) IExec->AllocSysObjectTags(ASOT_IOREQUEST,
ASOIOR_Size, sizeof(struct AHIRequest),
ASOIOR_ReplyPort, AHImp,
TAG_DONE)) != NULL)
{
AHIio->ahir_Version = 4;
AHIDevice = IExec->OpenDevice(AHINAME, 0, (struct IORequest *)AHIio, 0);
if (AHIDevice)
{
if (AHImp) IExec->FreeSysObject(ASOT_PORT, AHImp); AHImp = 0;
if (AHIio) IExec->FreeSysObject(ASOT_IOREQUEST, (struct IORequest *)AHIio); AHIio = 0;
if (PlayBuffer[0]) IExec->FreeMem(PlayBuffer[0],BUFSIZE); PlayBuffer[0] = 0;
if (PlayBuffer[1]) IExec->FreeMem(PlayBuffer[1],BUFSIZE); PlayBuffer[1] = 0;
log_error(_("AOS4: Unable to open AHI Device!"));
throw SoundException("AOS4: Unable to open AHI Device!");
}
IAHI = (struct AHIIFace *) IExec->GetInterface( (struct Library *) AHIio->ahir_Std.io_Device, "main", 1, NULL );
}
else
{
if (PlayBuffer[0]) IExec->FreeMem(PlayBuffer[0],BUFSIZE); PlayBuffer[0] = 0;
if (PlayBuffer[1]) IExec->FreeMem(PlayBuffer[1],BUFSIZE); PlayBuffer[1] = 0;
if (AHImp) IExec->FreeSysObject(ASOT_PORT, AHImp); AHImp = 0;
log_error(_("AOS4: Unable to CreateIORequest!"));
throw SoundException("AOS4: Unable to CreateIORequest!");
}
}
else
{
if (PlayBuffer[0]) IExec->FreeMem(PlayBuffer[0],BUFSIZE); PlayBuffer[0] = 0;
if (PlayBuffer[1]) IExec->FreeMem(PlayBuffer[1],BUFSIZE); PlayBuffer[1] = 0;
log_error(_("AOS4: Unable to CreateMsgPort for AHI Device!"));
throw SoundException("AOS4: Unable to CreateMsgPort for AHI Device!");
}
AHIiocopy = IExec->AllocSysObjectTags(ASOT_IOREQUEST,ASOIOR_Duplicate,AHIio,TAG_DONE);
if(! AHIiocopy)
{
if (AHImp) IExec->FreeSysObject(ASOT_PORT, AHImp); AHImp = 0;
if (AHIio) IExec->FreeSysObject(ASOT_IOREQUEST, (struct IORequest *)AHIio); AHIio = 0;
if (PlayBuffer[0]) IExec->FreeMem(PlayBuffer[0],BUFSIZE); PlayBuffer[0] = 0;
if (PlayBuffer[1]) IExec->FreeMem(PlayBuffer[1],BUFSIZE); PlayBuffer[1] = 0;
log_error(_("AOS4: Not enough memory for AHIiocopy!"));
throw SoundException("AOS4: Not enough memory for AHIiocopy!");
}
AHICurBuf = 0;
Buffer = 0;
BufferPointer = PlayBuffer[0];
BufferFill = 0;
AHIReqSent[0] = false;
AHIReqSent[1] = false;
AHIios[0]=AHIio;
AHIios[1]=(AHIRequest*)AHIiocopy;
log_debug(_("AOS4: audioTask:Initialize timer.."));
TimerInit();
log_debug(_("AOS4: audioTask:Starting Timer.."));
TimerReset(RESET_TIME);
while (true)
{
sigMask = SIGBREAKF_CTRL_C | _timerSig;
uint32 sigGot = IExec->Wait(sigMask);
if (sigGot & SIGBREAKF_CTRL_C)
{
_closing = true;
log_debug(_("AOS4: Closing Audio Thread.."));
break;
}
if (sigGot & _timerSig)
{
IExec->GetMsg(_port);
if (!sound_handler::isPaused())
{
while (toFetch && !_closing)
{
unsigned int n = std::min(toFetch, AHI_BUF_SIZE);
if (!_closing) fetchSamples((boost::int16_t*)&samples, n);
toFetch -= n;
}
toFetch = nSamples*2;
}
if (!_closing) TimerReset(RESET_TIME);
}
}
log_debug(_("AOS4: Cleaning Audio Stuff.."));
if (AHIios[0])
{
if (!IExec->CheckIO((struct IORequest *) AHIios[0]))
{
IExec->AbortIO((struct IORequest *) AHIios[0]);
IExec->WaitIO((struct IORequest *) AHIios[0]);
}
}
if(AHIios[1])
{ // Only if the second request was started
if (!IExec->CheckIO((struct IORequest *) AHIios[1]))
{
IExec->AbortIO((struct IORequest *) AHIios[1]);
IExec->WaitIO((struct IORequest *) AHIios[1]);
}
}
if(!AHIDevice)
if (AHIio) IExec->CloseDevice((struct IORequest *)AHIio);
if (AHIio) IExec->FreeSysObject(ASOT_IOREQUEST,(struct IORequest *)AHIio); AHIio = 0;
if (AHIiocopy) IExec->FreeMem(AHIiocopy,sizeof(struct AHIRequest)); AHIiocopy = 0;
if (AHImp) IExec->FreeSysObject(ASOT_PORT, AHImp); AHImp = 0;
if (IAHI) IExec->DropInterface((struct Interface*) IAHI); IAHI = 0;
if (PlayBuffer[0]) IExec->FreeMem(PlayBuffer[0],BUFSIZE); PlayBuffer[0] = 0;
if (PlayBuffer[1]) IExec->FreeMem(PlayBuffer[1],BUFSIZE); PlayBuffer[1] = 0;
log_debug(_("AOS4: Exit Audio Thread.."));
log_debug(_("AOS4: audioTask:Close timer.."));
TimerExit();
return(RETURN_OK);
}
void Profiler::reset()
{
TimerReset(&timer);
}
Timer::Timer()
{
TimerReset(this);
}
void EmulOp(M68kRegisters *r, uint32 pc, int selector)
{
D(bug("EmulOp %04x at %08x\n", selector, pc));
switch (selector) {
case OP_BREAK: // Breakpoint
printf("*** Breakpoint\n");
Dump68kRegs(r);
break;
case OP_XPRAM1: { // Read/write from/to XPRam
uint32 len = r->d[3];
uint8 *adr = Mac2HostAddr(r->a[3]);
D(bug("XPRAMReadWrite d3: %08lx, a3: %p\n", len, adr));
int ofs = len & 0xffff;
len >>= 16;
if (len & 0x8000) {
len &= 0x7fff;
for (uint32 i=0; i<len; i++)
XPRAM[((ofs + i) & 0xff) + 0x1300] = *adr++;
} else {
for (uint32 i=0; i<len; i++)
*adr++ = XPRAM[((ofs + i) & 0xff) + 0x1300];
}
break;
}
case OP_XPRAM2: // Read from XPRam
r->d[1] = XPRAM[(r->d[1] & 0xff) + 0x1300];
break;
case OP_XPRAM3: // Write to XPRam
XPRAM[(r->d[1] & 0xff) + 0x1300] = r->d[2];
break;
case OP_NVRAM1: { // Read from NVRAM
int ofs = r->d[0];
r->d[0] = XPRAM[ofs & 0x1fff];
bool localtalk = !(XPRAM[0x13e0] || XPRAM[0x13e1]); // LocalTalk enabled?
switch (ofs) {
case 0x13e0: // Disable LocalTalk (use EtherTalk instead)
if (localtalk)
r->d[0] = 0x00;
break;
case 0x13e1:
if (localtalk)
r->d[0] = 0x01;
break;
case 0x13e2:
if (localtalk)
r->d[0] = 0x00;
break;
case 0x13e3:
if (localtalk)
r->d[0] = 0x0a;
break;
}
break;
}
case OP_NVRAM2: // Write to NVRAM
XPRAM[r->d[0] & 0x1fff] = r->d[1];
break;
case OP_NVRAM3: // Read/write from/to NVRAM
if (r->d[3]) {
r->d[0] = XPRAM[(r->d[4] + 0x1300) & 0x1fff];
} else {
XPRAM[(r->d[4] + 0x1300) & 0x1fff] = r->d[5];
r->d[0] = 0;
}
break;
case OP_FIX_MEMTOP: // Fixes MemTop in BootGlobs during startup
D(bug("Fix MemTop\n"));
WriteMacInt32(BootGlobsAddr - 20, RAMBase + RAMSize); // MemTop
r->a[6] = RAMBase + RAMSize;
break;
case OP_FIX_MEMSIZE: { // Fixes physical/logical RAM size during startup
D(bug("Fix MemSize\n"));
uint32 diff = ReadMacInt32(0x1ef8) - ReadMacInt32(0x1ef4);
WriteMacInt32(0x1ef8, RAMSize); // Physical RAM size
WriteMacInt32(0x1ef4, RAMSize - diff); // Logical RAM size
break;
}
case OP_FIX_BOOTSTACK: // Fixes boot stack pointer in boot 3 resource
D(bug("Fix BootStack\n"));
r->a[1] = r->a[7] = RAMBase + RAMSize * 3 / 4;
break;
case OP_SONY_OPEN: // Floppy driver functions
r->d[0] = SonyOpen(r->a[0], r->a[1]);
break;
case OP_SONY_PRIME:
r->d[0] = SonyPrime(r->a[0], r->a[1]);
break;
case OP_SONY_CONTROL:
r->d[0] = SonyControl(r->a[0], r->a[1]);
break;
case OP_SONY_STATUS:
r->d[0] = SonyStatus(r->a[0], r->a[1]);
break;
case OP_DISK_OPEN: // Disk driver functions
r->d[0] = DiskOpen(r->a[0], r->a[1]);
break;
case OP_DISK_PRIME:
r->d[0] = DiskPrime(r->a[0], r->a[1]);
break;
case OP_DISK_CONTROL:
r->d[0] = DiskControl(r->a[0], r->a[1]);
break;
case OP_DISK_STATUS:
r->d[0] = DiskStatus(r->a[0], r->a[1]);
break;
case OP_CDROM_OPEN: // CD-ROM driver functions
r->d[0] = CDROMOpen(r->a[0], r->a[1]);
break;
case OP_CDROM_PRIME:
r->d[0] = CDROMPrime(r->a[0], r->a[1]);
break;
case OP_CDROM_CONTROL:
r->d[0] = CDROMControl(r->a[0], r->a[1]);
break;
case OP_CDROM_STATUS:
r->d[0] = CDROMStatus(r->a[0], r->a[1]);
break;
case OP_AUDIO_DISPATCH: // Audio component functions
r->d[0] = gMacAudio->Dispatch(r->a[3], r->a[4]);
break;
case OP_SOUNDIN_OPEN: // Sound input driver functions
r->d[0] = gMacAudio->InOpen(r->a[0], r->a[1]);
break;
case OP_SOUNDIN_PRIME:
r->d[0] = gMacAudio->InPrime(r->a[0], r->a[1]);
break;
case OP_SOUNDIN_CONTROL:
r->d[0] = gMacAudio->InControl(r->a[0], r->a[1]);
break;
case OP_SOUNDIN_STATUS:
r->d[0] = gMacAudio->InStatus(r->a[0], r->a[1]);
break;
case OP_SOUNDIN_CLOSE:
r->d[0] = gMacAudio->InClose(r->a[0], r->a[1]);
break;
case OP_ADBOP: // ADBOp() replacement
gADBInput->Op(r->d[0], Mac2HostAddr(ReadMacInt32(r->a[0])));
break;
case OP_INSTIME: // InsTime() replacement
r->d[0] = InsTime(r->a[0], r->d[1]);
break;
case OP_RMVTIME: // RmvTime() replacement
r->d[0] = RmvTime(r->a[0]);
break;
case OP_PRIMETIME: // PrimeTime() replacement
r->d[0] = PrimeTime(r->a[0], r->d[0]);
break;
case OP_MICROSECONDS: // Microseconds() replacement
Microseconds(r->a[0], r->d[0]);
break;
case OP_PUT_SCRAP: // PutScrap() patch
PutScrap(ReadMacInt32(r->a[7] + 8), Mac2HostAddr(ReadMacInt32(r->a[7] + 4)), ReadMacInt32(r->a[7] + 12));
break;
case OP_GET_SCRAP: // GetScrap() patch
GetScrap((void **)Mac2HostAddr(ReadMacInt32(r->a[7] + 4)), ReadMacInt32(r->a[7] + 8), ReadMacInt32(r->a[7] + 12));
break;
case OP_DEBUG_STR: // DebugStr() shows warning message
if (PrefsFindBool("nogui")) {
uint8 *pstr = Mac2HostAddr(ReadMacInt32(r->a[7] + 4));
char str[256];
int i;
for (i=0; i<pstr[0]; i++)
str[i] = pstr[i+1];
str[i] = 0;
WarningAlert(str);
}
break;
case OP_INSTALL_DRIVERS: { // Patch to install our own drivers during startup
// Install drivers
InstallDrivers();
// Patch MakeExecutable()
MakeExecutableTvec = FindLibSymbol("\023PrivateInterfaceLib", "\016MakeExecutable");
D(bug("MakeExecutable TVECT at %08x\n", MakeExecutableTvec));
WriteMacInt32(MakeExecutableTvec, NativeFunction(NATIVE_MAKE_EXECUTABLE));
#if defined(__powerpc__) /* Native PowerPC */
WriteMacInt32(MakeExecutableTvec + 4, (uint32)TOC);
#endif
// Patch DebugStr()
static const uint8 proc_template[] = {
M68K_EMUL_OP_DEBUG_STR >> 8, M68K_EMUL_OP_DEBUG_STR & 0xFF,
0x4e, 0x74, // rtd #4
0x00, 0x04
};
BUILD_SHEEPSHAVER_PROCEDURE(proc);
WriteMacInt32(0x1dfc, proc);
break;
}
case OP_NAME_REGISTRY: // Patch Name Registry and initialize CallUniversalProc
r->d[0] = (uint32)-1;
PatchNameRegistry();
InitCallUniversalProc();
break;
case OP_RESET: // Early in MacOS reset
D(bug("*** RESET ***\n"));
TimerReset();
MacOSUtilReset();
gMacAudio->Reset();
// Enable DR emulator (disabled for now)
if (PrefsFindBool("jit68k") && 0) {
D(bug("DR activated\n"));
WriteMacInt32(KernelDataAddr + 0x17a0, 3); // Prepare for DR emulator activation
WriteMacInt32(KernelDataAddr + 0x17c0, DR_CACHE_BASE);
WriteMacInt32(KernelDataAddr + 0x17c4, DR_CACHE_SIZE);
WriteMacInt32(KernelDataAddr + 0x1b04, DR_CACHE_BASE);
WriteMacInt32(KernelDataAddr + 0x1b00, DR_EMULATOR_BASE);
memcpy((void *)DR_EMULATOR_BASE, (void *)(ROMBase + 0x370000), DR_EMULATOR_SIZE);
MakeExecutable(0, DR_EMULATOR_BASE, DR_EMULATOR_SIZE);
}
break;
case OP_IRQ: // Level 1 interrupt
WriteMacInt16(ReadMacInt32(KernelDataAddr + 0x67c), 0); // Clear interrupt
r->d[0] = 0;
if (HasMacStarted()) {
if (InterruptFlags & INTFLAG_VIA) {
ClearInterruptFlag(INTFLAG_VIA);
#if !PRECISE_TIMING
TimerInterrupt();
#endif
ExecuteNative(NATIVE_VIDEO_VBL);
static int tick_counter = 0;
if (++tick_counter >= 60) {
tick_counter = 0;
SonyInterrupt();
DiskInterrupt();
CDROMInterrupt();
}
r->d[0] = 1; // Flag: 68k interrupt routine executes VBLTasks etc.
}
if (InterruptFlags & INTFLAG_SERIAL) {
ClearInterruptFlag(INTFLAG_SERIAL);
SerialInterrupt();
}
if (InterruptFlags & INTFLAG_ETHER) {
ClearInterruptFlag(INTFLAG_ETHER);
ExecuteNative(NATIVE_ETHER_IRQ);
}
if (InterruptFlags & INTFLAG_TIMER) {
ClearInterruptFlag(INTFLAG_TIMER);
TimerInterrupt();
}
if (InterruptFlags & INTFLAG_AUDIO) {
ClearInterruptFlag(INTFLAG_AUDIO);
gMacAudio->Interrupt();
}
if (InterruptFlags & INTFLAG_ADB) {
ClearInterruptFlag(INTFLAG_ADB);
gADBInput->Interrupt();
}
} else
r->d[0] = 1;
break;
case OP_SCSI_DISPATCH: { // SCSIDispatch() replacement
uint32 ret = ReadMacInt32(r->a[7]);
uint16 sel = ReadMacInt16(r->a[7] + 4);
r->a[7] += 6;
// D(bug("SCSIDispatch(%d)\n", sel));
int stack;
switch (sel) {
case 0: // SCSIReset
WriteMacInt16(r->a[7], SCSIReset());
stack = 0;
break;
case 1: // SCSIGet
WriteMacInt16(r->a[7], SCSIGet());
stack = 0;
break;
case 2: // SCSISelect
case 11: // SCSISelAtn
WriteMacInt16(r->a[7] + 2, SCSISelect(ReadMacInt8(r->a[7] + 1)));
stack = 2;
break;
case 3: // SCSICmd
WriteMacInt16(r->a[7] + 6, SCSICmd(ReadMacInt16(r->a[7]), Mac2HostAddr(ReadMacInt32(r->a[7] + 2))));
stack = 6;
break;
case 4: // SCSIComplete
WriteMacInt16(r->a[7] + 12, SCSIComplete(ReadMacInt32(r->a[7]), ReadMacInt32(r->a[7] + 4), ReadMacInt32(r->a[7] + 8)));
stack = 12;
break;
case 5: // SCSIRead
case 8: // SCSIRBlind
WriteMacInt16(r->a[7] + 4, SCSIRead(ReadMacInt32(r->a[7])));
stack = 4;
break;
case 6: // SCSIWrite
case 9: // SCSIWBlind
WriteMacInt16(r->a[7] + 4, SCSIWrite(ReadMacInt32(r->a[7])));
stack = 4;
break;
case 10: // SCSIStat
WriteMacInt16(r->a[7], SCSIStat());
stack = 0;
break;
case 12: // SCSIMsgIn
WriteMacInt16(r->a[7] + 4, 0);
stack = 4;
break;
case 13: // SCSIMsgOut
WriteMacInt16(r->a[7] + 2, 0);
stack = 2;
break;
case 14: // SCSIMgrBusy
WriteMacInt16(r->a[7], SCSIMgrBusy());
stack = 0;
break;
default:
printf("FATAL: SCSIDispatch: illegal selector\n");
stack = 0;
//!! SysError(12)
}
r->a[0] = ret;
r->a[7] += stack;
break;
}
case OP_SCSI_ATOMIC: // SCSIAtomic() replacement
D(bug("SCSIAtomic\n"));
r->d[0] = (uint32)-7887;
break;
case OP_CHECK_SYSV: { // Check we are not using MacOS < 8.1 with a NewWorld ROM
r->a[1] = r->d[1];
r->a[0] = ReadMacInt32(r->d[1]);
uint32 sysv = ReadMacInt16(r->a[0]);
D(bug("Detected MacOS version %d.%d.%d\n", (sysv >> 8) & 0xf, (sysv >> 4) & 0xf, sysv & 0xf));
if (ROMType == ROMTYPE_NEWWORLD && sysv < 0x0801)
r->d[1] = 0;
break;
}
case OP_NTRB_17_PATCH:
r->a[2] = ReadMacInt32(r->a[7]);
r->a[7] += 4;
if (ReadMacInt16(r->a[2] + 6) == 17)
PatchNativeResourceManager();
break;
case OP_NTRB_17_PATCH2:
r->a[7] += 8;
PatchNativeResourceManager();
break;
case OP_NTRB_17_PATCH3:
r->a[2] = ReadMacInt32(r->a[7]);
r->a[7] += 4;
D(bug("%d %d\n", ReadMacInt16(r->a[2]), ReadMacInt16(r->a[2] + 6)));
if (ReadMacInt16(r->a[2]) == 11 && ReadMacInt16(r->a[2] + 6) == 17)
PatchNativeResourceManager();
break;
case OP_NTRB_17_PATCH4:
r->d[0] = ReadMacInt16(r->a[7]);
r->a[7] += 2;
D(bug("%d %d\n", ReadMacInt16(r->a[2]), ReadMacInt16(r->a[2] + 6)));
if (ReadMacInt16(r->a[2]) == 11 && ReadMacInt16(r->a[2] + 6) == 17)
PatchNativeResourceManager();
break;
case OP_CHECKLOAD: { // vCheckLoad() patch
uint32 type = ReadMacInt32(r->a[7]);
r->a[7] += 4;
int16 id = ReadMacInt16(r->a[2]);
if (r->a[0] == 0)
break;
uint32 adr = ReadMacInt32(r->a[0]);
if (adr == 0)
break;
uint16 *p = (uint16 *)Mac2HostAddr(adr);
uint32 size = ReadMacInt32(adr - 8) & 0xffffff;
CheckLoad(type, id, p, size);
break;
}
case OP_EXTFS_COMM: // External file system routines
WriteMacInt16(r->a[7] + 14, ExtFSComm(ReadMacInt16(r->a[7] + 12), ReadMacInt32(r->a[7] + 8), ReadMacInt32(r->a[7] + 4)));
break;
case OP_EXTFS_HFS:
WriteMacInt16(r->a[7] + 20, ExtFSHFS(ReadMacInt32(r->a[7] + 16), ReadMacInt16(r->a[7] + 14), ReadMacInt32(r->a[7] + 10), ReadMacInt32(r->a[7] + 6), ReadMacInt16(r->a[7] + 4)));
break;
case OP_IDLE_TIME:
// Sleep if no events pending
if (ReadMacInt32(0x14c) == 0)
idle_wait();
r->a[0] = ReadMacInt32(0x2b6);
break;
case OP_IDLE_TIME_2:
// Sleep if no events pending
if (ReadMacInt32(0x14c) == 0)
idle_wait();
r->d[0] = (uint32)-2;
break;
default:
printf("FATAL: EMUL_OP called with bogus selector %08x\n", selector);
QuitEmulator();
break;
}
}
