diff options
Diffstat (limited to 'SrcShared/Hardware')
127 files changed, 40136 insertions, 0 deletions
diff --git a/SrcShared/Hardware/EmBankDRAM.cpp b/SrcShared/Hardware/EmBankDRAM.cpp new file mode 100644 index 0000000..50b6d18 --- /dev/null +++ b/SrcShared/Hardware/EmBankDRAM.cpp @@ -0,0 +1,686 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1998-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +// --------------------------------------------------------------------------- +#pragma mark ===== Includes +// --------------------------------------------------------------------------- + +#include "EmCommon.h" +#include "EmBankDRAM.h" + +#include "DebugMgr.h" // Debug::CheckStepSpy +#include "EmBankSRAM.h" // gRAMBank_Size, gRAM_Memory, gMemoryAccess +#include "EmCPU.h" // GetSP +#include "EmCPU68K.h" // gCPU68K +#include "EmHAL.h" // EmHAL +#include "EmMemory.h" // Memory::InitializeBanks, IsPCInRAM (implicitly, through META_CHECK) +#include "EmPalmFunction.h" // InSysLaunch +#include "EmPalmOS.h" // EmPalmOS::GetBootStack +#include "EmPatchState.h" // META_CHECK calls EmPatchState::IsPCInMemMgr +#include "EmScreen.h" // EmScreen::MarkDirty +#include "EmSession.h" // gSession +#include "MetaMemory.h" // MetaMemory +#include "Profiling.h" // WAITSTATES_DRAM + + +// --------------------------------------------------------------------------- +#pragma mark ===== Types +// --------------------------------------------------------------------------- + +// --------------------------------------------------------------------------- +#pragma mark ===== Functions +// --------------------------------------------------------------------------- + +// --------------------------------------------------------------------------- +#pragma mark ===== Constants +// --------------------------------------------------------------------------- + +const uint32 kMemoryStart = 0x00000000; +const emuptr kGlobalStart = offsetof (LowMemHdrType, globals); + + +// --------------------------------------------------------------------------- +#pragma mark ===== Variables +// --------------------------------------------------------------------------- + +// ----- Saved variables ----------------------------------------------------- + +static uint32 gDynamicHeapSize; + + +// ----- UnSaved variables --------------------------------------------------- + +static EmAddressBank gAddressBank = +{ + EmBankDRAM::GetLong, + EmBankDRAM::GetWord, + EmBankDRAM::GetByte, + EmBankDRAM::SetLong, + EmBankDRAM::SetWord, + EmBankDRAM::SetByte, + EmBankDRAM::GetRealAddress, + EmBankDRAM::ValidAddress, + EmBankDRAM::GetMetaAddress, + EmBankDRAM::AddOpcodeCycles +}; + + +// --------------------------------------------------------------------------- +#pragma mark ===== Inlines +// --------------------------------------------------------------------------- + +static inline int InlineValidAddress (emuptr address, size_t size) +{ + int result = (address + size) <= gRAMBank_Size; + + return result; +} + + +static inline uint8* InlineGetRealAddress (emuptr address) +{ + return (uint8*) &(gRAM_Memory[address]); +} + + +static inline uint8* InlineGetMetaAddress (emuptr address) +{ + return (uint8*) &(gRAM_MetaMemory[address]); +} + + +static void PrvReportBelowStackPointerAccess (emuptr address, size_t size, Bool forRead) +{ + // Can be NULL during bootup. + + if (gStackLow == EmMemNULL) + return; + + // SysLaunch clears out as much RAM as it can, including the area + // below the stack pointer. + + if (::InSysLaunch ()) + return; + + // We can look in the stack for CJ_TAGFENCE, etc. + + if (CEnableFullAccess::AccessOK ()) + return; + + // If the access is in the boot stack, allow it. There's a lot of memory + // allocation going on below the stack pointer, such that it's not too + // clear where the current "low end" of stack should be. + + StackRange bootStack = EmPalmOS::GetBootStack (); + if (address >= bootStack.fBottom && address < bootStack.fTop) + return; + + gSession->ScheduleDeferredError (new EmDeferredErrLowStack ( + gStackLow, gCPU->GetSP (), gStackHigh, + address, size, forRead)); +} + + +static inline void PrvCheckBelowStackPointerAccess (emuptr address, size_t size, Bool forRead) +{ +#if 1 + if (address < gCPU->GetSP () && address >= gStackLow) + { + ::PrvReportBelowStackPointerAccess (address, size, forRead); + } +#endif +} + + +static inline void PrvScreenCheck (uint8* metaAddress, emuptr address, size_t size) +{ +#if defined (macintosh) + + if (size == 1 && !MetaMemory::IsScreenBuffer8 (metaAddress)) + return; + + if (size == 2 && !MetaMemory::IsScreenBuffer16 (metaAddress)) + return; + + if (size == 4 && !MetaMemory::IsScreenBuffer32 (metaAddress)) + return; + +#else + + if (MetaMemory::IsScreenBuffer (metaAddress, size)) + +#endif + + { + EmScreen::MarkDirty (address, size); + } +} + + +#pragma mark - + +// =========================================================================== +// ¥ DRAM Bank Accessors +// =========================================================================== +// These functions provide fetch and store access to the emulator's random +// access memory. + +/*********************************************************************** + * + * FUNCTION: EmBankDRAM::Initialize + * + * DESCRIPTION: Standard initialization function. Responsible for + * initializing this sub-system when a new session is + * created. Will be followed by at least one call to + * Reset or Load. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankDRAM::Initialize (void) +{ +} + + +/*********************************************************************** + * + * FUNCTION: EmBankDRAM::Reset + * + * DESCRIPTION: Standard reset function. Sets the sub-system to a + * default state. This occurs not only on a Reset (as + * from the menu item), but also when the sub-system + * is first initialized (Reset is called after Initialize) + * as well as when the system is re-loaded from an + * insufficient session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankDRAM::Reset (Bool /*hardwareReset*/) +{ +} + + +/*********************************************************************** + * + * FUNCTION: EmBankDRAM::Save + * + * DESCRIPTION: Standard save function. Saves any sub-system state to + * the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankDRAM::Save (SessionFile&) +{ +} + + +/*********************************************************************** + * + * FUNCTION: EmBankDRAM::Load + * + * DESCRIPTION: Standard load function. Loads any sub-system state + * from the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankDRAM::Load (SessionFile&) +{ +} + + +/*********************************************************************** + * + * FUNCTION: EmBankDRAM::Dispose + * + * DESCRIPTION: Standard dispose function. Completely release any + * resources acquired or allocated in Initialize and/or + * Load. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankDRAM::Dispose (void) +{ +} + + +/*********************************************************************** + * + * FUNCTION: EmBankDRAM::SetBankHandlers + * + * DESCRIPTION: Set the bank handlers UAE uses to dispatch memory + * access operations. + * + * PARAMETERS: None + * + * RETURNED: Nothing + * + ***********************************************************************/ + +void EmBankDRAM::SetBankHandlers (void) +{ + // First few memory banks are managed by the functions in EmBankDRAM. + + gDynamicHeapSize = EmHAL::GetDynamicHeapSize (); + + if (gDynamicHeapSize > gRAMBank_Size) + gDynamicHeapSize = gRAMBank_Size; + + uint32 sixtyFourK = 64 * 1024L; + uint32 numBanks = (gDynamicHeapSize + sixtyFourK - 1) / sixtyFourK; + + Memory::InitializeBanks ( gAddressBank, + EmMemBankIndex (kMemoryStart), + numBanks); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDRAM::GetLong +// --------------------------------------------------------------------------- + +uint32 EmBankDRAM::GetLong (emuptr address) +{ + if (address > gDynamicHeapSize) + return EmBankSRAM::GetLong (address); + +#if (PROFILE_MEMORY) + gMemoryAccess[kDRAMLongRead]++; + if (address & 2) + gMemoryAccess[kDRAMLongRead2]++; +#endif + + if (CHECK_FOR_ADDRESS_ERROR && (address & 1) != 0) + { + AddressError (address, sizeof (uint32), true); + } + + register uint8* metaAddress = InlineGetMetaAddress (address); + META_CHECK (metaAddress, address, GetLong, uint32, true); + + ::PrvCheckBelowStackPointerAccess (address, sizeof (uint32), true); + + if (VALIDATE_DRAM_GET && + gMemAccessFlags.fValidate_DRAMGet && + !InlineValidAddress (address, sizeof (uint32))) + { + InvalidAccess (address, sizeof (uint32), true); + } + +#if (HAS_PROFILING) + CYCLE_GETLONG (WAITSTATES_DRAM); +#endif + + return EmMemDoGet32 (gRAM_Memory + address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDRAM::GetWord +// --------------------------------------------------------------------------- + +uint32 EmBankDRAM::GetWord (emuptr address) +{ + if (address > gDynamicHeapSize) + return EmBankSRAM::GetWord (address); + +#if (PROFILE_MEMORY) + gMemoryAccess[kDRAMWordRead]++; +#endif + + if (CHECK_FOR_ADDRESS_ERROR && (address & 1) != 0) + { + AddressError (address, sizeof (uint16), true); + } + + register uint8* metaAddress = InlineGetMetaAddress (address); + META_CHECK (metaAddress, address, GetWord, uint16, true); + + ::PrvCheckBelowStackPointerAccess (address, sizeof (uint16), true); + + if (VALIDATE_DRAM_GET && + gMemAccessFlags.fValidate_DRAMGet && + !InlineValidAddress (address, sizeof (uint16))) + { + InvalidAccess (address, sizeof (uint16), true); + } + +#if (HAS_PROFILING) + CYCLE_GETWORD (WAITSTATES_DRAM); +#endif + + return EmMemDoGet16 (gRAM_Memory + address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDRAM::GetByte +// --------------------------------------------------------------------------- + +uint32 EmBankDRAM::GetByte (emuptr address) +{ + if (address > gDynamicHeapSize) + return EmBankSRAM::GetByte (address); + +#if (PROFILE_MEMORY) + gMemoryAccess[kDRAMByteRead]++; +#endif + + register uint8* metaAddress = InlineGetMetaAddress (address); + META_CHECK (metaAddress, address, GetByte, uint8, true); + + ::PrvCheckBelowStackPointerAccess (address, sizeof (uint8), true); + + if (VALIDATE_DRAM_GET && + gMemAccessFlags.fValidate_DRAMGet && + !InlineValidAddress (address, sizeof (uint8))) + { + InvalidAccess (address, sizeof (uint8), true); + } + +#if (HAS_PROFILING) + CYCLE_GETBYTE (WAITSTATES_DRAM); +#endif + + return EmMemDoGet8 (gRAM_Memory + address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDRAM::SetLong +// --------------------------------------------------------------------------- + +void EmBankDRAM::SetLong (emuptr address, uint32 value) +{ + if (address > gDynamicHeapSize) + { + EmBankSRAM::SetLong (address, value); + return; + } + +#if (PROFILE_MEMORY) + gMemoryAccess[kDRAMLongWrite]++; + if (address & 2) + gMemoryAccess[kDRAMLongWrite2]++; +#endif + + if (CHECK_FOR_ADDRESS_ERROR && (address & 1) != 0) + { + AddressError (address, sizeof (uint32), false); + } + + register uint8* metaAddress = InlineGetMetaAddress (address); + META_CHECK (metaAddress, address, SetLong, uint32, false); + + ::PrvCheckBelowStackPointerAccess (address, sizeof (uint32), false); + + if (VALIDATE_DRAM_SET && + gMemAccessFlags.fValidate_DRAMSet && + !InlineValidAddress (address, sizeof (uint32))) + { + InvalidAccess (address, sizeof (uint32), false); + } + + ::PrvScreenCheck (metaAddress, address, sizeof (uint32)); + +#if (HAS_PROFILING) + CYCLE_PUTLONG (WAITSTATES_DRAM); +#endif + + EmMemDoPut32 (gRAM_Memory + address, value); + +#if FOR_LATER + // Mark that this memory location can now be read from. + + MetaMemory::MarkLongInitialized (address); +#endif + + // See if any interesting memory locations have changed. If so, + // CheckStepSpy will report it. + + Debug::CheckStepSpy (address, sizeof (uint32)); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDRAM::SetWord +// --------------------------------------------------------------------------- + +void EmBankDRAM::SetWord (emuptr address, uint32 value) +{ + if (address > gDynamicHeapSize) + { + EmBankSRAM::SetWord (address, value); + return; + } + +#if (PROFILE_MEMORY) + gMemoryAccess[kDRAMWordWrite]++; +#endif + + if (CHECK_FOR_ADDRESS_ERROR && (address & 1) != 0) + { + AddressError (address, sizeof (uint16), false); + } + + register uint8* metaAddress = InlineGetMetaAddress (address); + META_CHECK (metaAddress, address, SetWord, uint16, false); + + ::PrvCheckBelowStackPointerAccess (address, sizeof (uint16), false); + + if (VALIDATE_DRAM_SET && + gMemAccessFlags.fValidate_DRAMSet && + !InlineValidAddress (address, sizeof (uint16))) + { + InvalidAccess (address, sizeof (uint16), false); + } + + ::PrvScreenCheck (metaAddress, address, sizeof (uint16)); + +#if (HAS_PROFILING) + CYCLE_PUTWORD (WAITSTATES_DRAM); +#endif + + EmMemDoPut16 (gRAM_Memory + address, value); + +#if FOR_LATER + // Mark that this memory location can now be read from. + + MetaMemory::MarkWordInitialized (address); +#endif + + // See if any interesting memory locations have changed. If so, + // CheckStepSpy will report it. + + Debug::CheckStepSpy (address, sizeof (uint16)); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDRAM::SetByte +// --------------------------------------------------------------------------- + +void EmBankDRAM::SetByte (emuptr address, uint32 value) +{ + if (address > gDynamicHeapSize) + { + EmBankSRAM::SetByte (address, value); + return; + } + +#if (PROFILE_MEMORY) + gMemoryAccess[kDRAMByteWrite]++; +#endif + + register uint8* metaAddress = InlineGetMetaAddress (address); + META_CHECK (metaAddress, address, SetByte, uint8, false); + + ::PrvCheckBelowStackPointerAccess (address, sizeof (uint8), false); + + if (VALIDATE_DRAM_SET && + gMemAccessFlags.fValidate_DRAMSet && + !InlineValidAddress (address, sizeof (uint8))) + { + InvalidAccess (address, sizeof (uint8), false); + } + + ::PrvScreenCheck (metaAddress, address, sizeof (uint8)); + +#if (HAS_PROFILING) + CYCLE_PUTBYTE (WAITSTATES_DRAM); +#endif + + EmMemDoPut8 (gRAM_Memory + address, value); + +#if FOR_LATER + // Mark that this memory location can now be read from. + + MetaMemory::MarkByteInitialized (address); +#endif + + // See if any interesting memory locations have changed. If so, + // CheckStepSpy will report it. + + Debug::CheckStepSpy (address, sizeof (uint8)); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDRAM::ValidAddress +// --------------------------------------------------------------------------- + +int EmBankDRAM::ValidAddress (emuptr address, uint32 size) +{ + int result = InlineValidAddress (address, size); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDRAM::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmBankDRAM::GetRealAddress (emuptr address) +{ + return InlineGetRealAddress (address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDRAM::GetMetaAddress +// --------------------------------------------------------------------------- + +uint8* EmBankDRAM::GetMetaAddress (emuptr address) +{ + return InlineGetMetaAddress (address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDRAM::AddOpcodeCycles +// --------------------------------------------------------------------------- + +void EmBankDRAM::AddOpcodeCycles (void) +{ +#if (HAS_PROFILING) + CYCLE_GETWORD (WAITSTATES_DRAM); +#endif +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDRAM::AddressError +// --------------------------------------------------------------------------- + +void EmBankDRAM::AddressError (emuptr address, long size, Bool forRead) +{ + EmAssert (gCPU68K); + gCPU68K->AddressError (address, size, forRead); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDRAM::InvalidAccess +// --------------------------------------------------------------------------- + +void EmBankDRAM::InvalidAccess (emuptr address, long size, Bool forRead) +{ + EmAssert (gCPU68K); + gCPU68K->BusError (address, size, forRead); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDRAM::ProbableCause +// --------------------------------------------------------------------------- + +void EmBankDRAM::ProbableCause (emuptr address, long size, Bool forRead) +{ + EmAssert (gSession); + + Errors::EAccessType whatHappened = MetaMemory::GetWhatHappened (address, size, forRead); + + switch (whatHappened) + { + case Errors::kOKAccess: + break; + + case Errors::kLowMemAccess: + gSession->ScheduleDeferredError (new EmDeferredErrLowMemory (address, size, forRead)); + break; + + case Errors::kGlobalVarAccess: + gSession->ScheduleDeferredError (new EmDeferredErrSystemGlobals (address, size, forRead)); + break; + + case Errors::kScreenAccess: + gSession->ScheduleDeferredError (new EmDeferredErrScreen (address, size, forRead)); + break; + + case Errors::kMemMgrAccess: + gSession->ScheduleDeferredError (new EmDeferredErrMemMgrStructures (address, size, forRead)); + break; + + case Errors::kFreeChunkAccess: + gSession->ScheduleDeferredError (new EmDeferredErrFreeChunk (address, size, forRead)); + break; + + case Errors::kUnlockedChunkAccess: + gSession->ScheduleDeferredError (new EmDeferredErrUnlockedChunk (address, size, forRead)); + break; + + case Errors::kUnknownAccess: + case Errors::kLowStackAccess: + EmAssert (false); + MetaMemory::GetWhatHappened (address, size, forRead); + } +} diff --git a/SrcShared/Hardware/EmBankDRAM.h b/SrcShared/Hardware/EmBankDRAM.h new file mode 100644 index 0000000..c247649 --- /dev/null +++ b/SrcShared/Hardware/EmBankDRAM.h @@ -0,0 +1,49 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1998-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmBankDRAM_h +#define EmBankDRAM_h + + +class SessionFile; + +class EmBankDRAM +{ + public: + static void Initialize (void); + static void Reset (Bool hardwareReset); + static void Save (SessionFile&); + static void Load (SessionFile&); + static void Dispose (void); + + static void SetBankHandlers (void); + + static uint32 GetLong (emuptr address); + static uint32 GetWord (emuptr address); + static uint32 GetByte (emuptr address); + static void SetLong (emuptr address, uint32 value); + static void SetWord (emuptr address, uint32 value); + static void SetByte (emuptr address, uint32 value); + static int ValidAddress (emuptr address, uint32 size); + static uint8* GetRealAddress (emuptr address); + static uint8* GetMetaAddress (emuptr address); + static void AddOpcodeCycles (void); + + private: + static void AddressError (emuptr address, long size, Bool forRead); + static void InvalidAccess (emuptr address, long size, Bool forRead); + static void ProbableCause (emuptr address, long size, Bool forRead); +}; + + +#endif /* EmBankDRAM_h */ diff --git a/SrcShared/Hardware/EmBankDummy.cpp b/SrcShared/Hardware/EmBankDummy.cpp new file mode 100644 index 0000000..356b542 --- /dev/null +++ b/SrcShared/Hardware/EmBankDummy.cpp @@ -0,0 +1,326 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1998-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmBankDummy.h" + +#include "EmBankDRAM.h" // EmBankDRAM::ValidAddress +#include "EmBankSRAM.h" // EmBankSRAM::GetMemoryStart +#include "EmCPU68K.h" // gCPU68K +#include "EmPalmHeap.h" // EmPalmHeap::GetHeapByPtr +#include "EmMemory.h" // Memory::InitializeBanks + + +// =========================================================================== +// ¥ Dummy Bank Accessors +// =========================================================================== +// Dummy banks are non-existent blocks of memory. Dummy bank accessors do +// not do anything. + +static EmAddressBank gAddressBank = +{ + EmBankDummy::GetLong, + EmBankDummy::GetWord, + EmBankDummy::GetByte, + EmBankDummy::SetLong, + EmBankDummy::SetWord, + EmBankDummy::SetByte, + EmBankDummy::GetRealAddress, + EmBankDummy::ValidAddress, + EmBankDummy::GetMetaAddress, + EmBankDummy::AddOpcodeCycles +}; + + +inline Bool HackForHwrGetRAMSize (emuptr address) +{ +// if ((address & 0xFF000000) == EmBankSRAM::GetMemoryStart ()) + if (address == EmBankSRAM::GetMemoryStart () + gRAMBank_Size) + return true; + + return false; +} + + +/*********************************************************************** + * + * FUNCTION: EmBankDummy::Initialize + * + * DESCRIPTION: Standard initialization function. Responsible for + * initializing this sub-system when a new session is + * created. Will be followed by at least one call to + * Reset or Load. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankDummy::Initialize (void) +{ +} + + +/*********************************************************************** + * + * FUNCTION: EmBankDummy::Reset + * + * DESCRIPTION: Standard reset function. Sets the sub-system to a + * default state. This occurs not only on a Reset (as + * from the menu item), but also when the sub-system + * is first initialized (Reset is called after Initialize) + * as well as when the system is re-loaded from an + * insufficient session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankDummy::Reset (Bool /*hardwareReset*/) +{ +} + + +/*********************************************************************** + * + * FUNCTION: EmBankDummy::Save + * + * DESCRIPTION: Standard save function. Saves any sub-system state to + * the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankDummy::Save (SessionFile&) +{ +} + + +/*********************************************************************** + * + * FUNCTION: EmBankDummy::Load + * + * DESCRIPTION: Standard load function. Loads any sub-system state + * from the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankDummy::Load (SessionFile&) +{ +} + + +/*********************************************************************** + * + * FUNCTION: EmBankDummy::Dispose + * + * DESCRIPTION: Standard dispose function. Completely release any + * resources acquired or allocated in Initialize and/or + * Load. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankDummy::Dispose (void) +{ +} + + +/*********************************************************************** + * + * FUNCTION: EmBankDummy::SetBankHandlers + * + * DESCRIPTION: Set the bank handlers UAE uses to dispatch memory + * access operations. + * + * PARAMETERS: None + * + * RETURNED: Nothing + * + ***********************************************************************/ + +void EmBankDummy::SetBankHandlers (void) +{ + Memory::InitializeBanks (gAddressBank, 0, 0xFFFF); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDummy::GetLong +// --------------------------------------------------------------------------- + +uint32 EmBankDummy::GetLong (emuptr address) +{ + // Hack to keep HwrGetRAMSize working: it runs off + // the end of RAM while testing it. + + if (HackForHwrGetRAMSize (address)) + return 0; + + InvalidAccess (address, sizeof (uint32), true); + return ~0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDummy::GetWord +// --------------------------------------------------------------------------- + +uint32 EmBankDummy::GetWord (emuptr address) +{ + // Hack to keep HwrGetRAMSize working: it runs off + // the end of RAM while testing it. + + if (HackForHwrGetRAMSize (address)) + return 0; + + InvalidAccess (address, sizeof (uint16), true); + return ~0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDummy::GetByte +// --------------------------------------------------------------------------- + +uint32 EmBankDummy::GetByte (emuptr address) +{ + // Hack to keep HwrGetRAMSize working: it runs off + // the end of RAM while testing it. + + if (HackForHwrGetRAMSize (address)) + return 0; + + InvalidAccess (address, sizeof (uint8), true); + return ~0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDummy::SetLong +// --------------------------------------------------------------------------- + +void EmBankDummy::SetLong (emuptr address, uint32) +{ + // Hack to keep HwrGetRAMSize working: it runs off + // the end of RAM while testing it. + + if (HackForHwrGetRAMSize (address)) + return; + + InvalidAccess (address, sizeof (uint32), true); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDummy::SetWord +// --------------------------------------------------------------------------- + +void EmBankDummy::SetWord (emuptr address, uint32) +{ + // Hack to keep HwrGetRAMSize working: it runs off + // the end of RAM while testing it. + + if (HackForHwrGetRAMSize (address)) + return; + + InvalidAccess (address, sizeof (uint16), true); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDummy::SetByte +// --------------------------------------------------------------------------- + +void EmBankDummy::SetByte (emuptr address, uint32) +{ + // Hack to keep HwrGetRAMSize working: it runs off + // the end of RAM while testing it. + + if (HackForHwrGetRAMSize (address)) + return; + + InvalidAccess (address, sizeof (uint8), true); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDummy::ValidAddress +// --------------------------------------------------------------------------- + +int EmBankDummy::ValidAddress (emuptr, uint32) +{ + int result = false; + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDummy::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmBankDummy::GetRealAddress (emuptr address) +{ + return (uint8*) address; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDummy::GetMetaAddress +// --------------------------------------------------------------------------- + +uint8* EmBankDummy::GetMetaAddress (emuptr address) +{ + UNUSED_PARAM(address) + + static uint8 dummyBits[4] = {0, 0, 0, 0}; + + return dummyBits; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDummy::AddOpcodeCycles +// --------------------------------------------------------------------------- + +void EmBankDummy::AddOpcodeCycles (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankDummy::InvalidAccess +// --------------------------------------------------------------------------- + +void EmBankDummy::InvalidAccess (emuptr address, long size, Bool forRead) +{ + if (CEnableFullAccess::AccessOK ()) + return; + + EmAssert (gCPU68K); + gCPU68K->BusError (address, size, forRead); +} diff --git a/SrcShared/Hardware/EmBankDummy.h b/SrcShared/Hardware/EmBankDummy.h new file mode 100644 index 0000000..a6ed0de --- /dev/null +++ b/SrcShared/Hardware/EmBankDummy.h @@ -0,0 +1,47 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1998-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmBankDummy_h +#define EmBankDummy_h + + +class SessionFile; + +class EmBankDummy +{ + public: + static void Initialize (void); + static void Reset (Bool hardwareReset); + static void Save (SessionFile&); + static void Load (SessionFile&); + static void Dispose (void); + + static void SetBankHandlers (void); + + static uint32 GetLong (emuptr address); + static uint32 GetWord (emuptr address); + static uint32 GetByte (emuptr address); + static void SetLong (emuptr address, uint32 value); + static void SetWord (emuptr address, uint32 value); + static void SetByte (emuptr address, uint32 value); + static int ValidAddress (emuptr address, uint32 size); + static uint8* GetRealAddress (emuptr address); + static uint8* GetMetaAddress (emuptr address); + static void AddOpcodeCycles (void); + + private: + static void InvalidAccess (emuptr address, long size, Bool forRead); +}; + + +#endif /* EmBankDummy_h */ diff --git a/SrcShared/Hardware/EmBankMapped.cpp b/SrcShared/Hardware/EmBankMapped.cpp new file mode 100644 index 0000000..8ae284a --- /dev/null +++ b/SrcShared/Hardware/EmBankMapped.cpp @@ -0,0 +1,723 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmBankMapped.h" + +#include "EmCPU68K.h" // gCPU68K +#include "EmMemory.h" // Memory::InitializeBanks +#include "Profiling.h" // WAITSTATES_DUMMYBANK + +#include <vector> + + +// =========================================================================== +// ¥ Dummy Bank Accessors +// =========================================================================== +// Dummy banks are non-existent blocks of memory. Dummy bank accessors do +// not do anything. + +static EmAddressBank gAddressBank = +{ + EmBankMapped::GetLong, + EmBankMapped::GetWord, + EmBankMapped::GetByte, + EmBankMapped::SetLong, + EmBankMapped::SetWord, + EmBankMapped::SetByte, + EmBankMapped::GetRealAddress, + EmBankMapped::ValidAddress, + EmBankMapped::GetMetaAddress, + EmBankMapped::AddOpcodeCycles +}; + +struct MapRange +{ + Bool Contains (const void* addr) + { + const char* begin = (const char*) this->realAddress; + const char* end = begin + this->size; + + return ((addr >= begin) && (addr < end)); + } + + Bool Contains (emuptr addr) + { + emuptr begin = this->mappedAddress; + emuptr end = begin + this->size; + + return ((addr >= begin) && (addr < end)); + } + + const void* realAddress; // Address in host's space + emuptr mappedAddress; // Address that emulated code sees + uint32 size; +}; +typedef vector<MapRange> MapRangeList; + +static MapRangeList gMappedRanges; +static MapRangeList::iterator gLastIter; + +// Map in blocks starting at this address. I used to have it way out of +// the way at 0x60000000. However, there's a check in SysGetAppInfo to +// make sure that certain addresses are less than 0x20000000. So set +// kMemoryStart lower than that. +// +// OK...Let's try again. I had changed this to manage 0x18000000 to +// 0x1FFFFFFF. However, the SED 1375 is mapped to 0x1F000000. So let's +// make sure we stay out of that range, too. +// +// Urm...TRG is mapping some stuff into 0x18000000. Now we have to stay +// out of its way, too. + +const emuptr kMemoryStart = 0x13000000; +const emuptr kMemoryFinish = 0x18000000; +const int32 kMemorySize = kMemoryFinish - kMemoryStart; // 80MB + +static MapRangeList::iterator PrvGetMappingInfo (const void* addr); +static MapRangeList::iterator PrvGetMappingInfo (emuptr addr); +static emuptr PrvEnsureAligned (emuptr candidate, const void* addr); +static void PrvInvalidateCache (void); +static void PrvCheckRanges (void); + + +/*********************************************************************** + * + * FUNCTION: EmBankMapped::Initialize + * + * DESCRIPTION: Standard initialization function. Responsible for + * initializing this sub-system when a new session is + * created. Will be followed by at least one call to + * Reset or Load. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankMapped::Initialize (void) +{ + gMappedRanges.clear (); + ::PrvInvalidateCache (); +} + + +/*********************************************************************** + * + * FUNCTION: EmBankMapped::Reset + * + * DESCRIPTION: Standard reset function. Sets the sub-system to a + * default state. This occurs not only on a Reset (as + * from the menu item), but also when the sub-system + * is first initialized (Reset is called after Initialize) + * as well as when the system is re-loaded from an + * insufficient session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankMapped::Reset (Bool /*hardwareReset*/) +{ + // Note: I used to clear out the mapped ranges in this function. + // However, this didn't work out too well. While manually resetting + // the device (as occurs at the end of a debugging session), there + // would be several StMemoryMapper objects instantiated. After the + // reset process, these StMemoryMappers would try to destruct + // themselves, calling EmBankMapped::UnmapPhysicalMemory in the + // process. But since the mapped ranges had been cleared, that + // function would throw an assert. So....I can't think of a reason + // for clearing out the ranges en masse, so let's no do that anymore. +} + + +/*********************************************************************** + * + * FUNCTION: EmBankMapped::Save + * + * DESCRIPTION: Standard save function. Saves any sub-system state to + * the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankMapped::Save (SessionFile&) +{ + // The only state we have to save is in gMappedRanges. We shouldn't + // have to actually save this because there shouldn't be anything in + // there at the moment when we save files. We map in memory ranges + // at the following times: + // + // * Calling system functions + // * Loading .prc, etc., files + // * Mapping in environment strings + // + // The first two should not be in "effect" at the time we save a file. + // The last one we'll leave up to the HostControl system to re-establish. +} + + +/*********************************************************************** + * + * FUNCTION: EmBankMapped::Load + * + * DESCRIPTION: Standard load function. Loads any sub-system state + * from the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankMapped::Load (SessionFile&) +{ +} + + +/*********************************************************************** + * + * FUNCTION: EmBankMapped::Dispose + * + * DESCRIPTION: Standard dispose function. Completely release any + * resources acquired or allocated in Initialize and/or + * Load. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankMapped::Dispose (void) +{ + gMappedRanges.clear (); + ::PrvInvalidateCache (); +} + + +/*********************************************************************** + * + * FUNCTION: EmBankMapped::SetBankHandlers + * + * DESCRIPTION: Set the bank handlers UAE uses to dispatch memory + * access operations. + * + * PARAMETERS: None + * + * RETURNED: Nothing + * + ***********************************************************************/ + +void EmBankMapped::SetBankHandlers (void) +{ + Memory::InitializeBanks (gAddressBank, EmMemBankIndex (kMemoryStart), kMemorySize >> 16); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::GetLong +// --------------------------------------------------------------------------- + +uint32 EmBankMapped::GetLong (emuptr address) +{ + if (CHECK_FOR_ADDRESS_ERROR && (address & 1) != 0) + { + AddressError (address, sizeof (uint32), true); + } + +#if HAS_PROFILING + CYCLE_GETLONG (WAITSTATES_DUMMYBANK); +#endif + + uint8* p = GetRealAddress (address); + + if (p == NULL) + { + return ~0; + } + + return (((uint32) p[0]) << 24) | (((uint32) p[1]) << 16) | (((uint32) p[2]) << 8) | p[3]; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::GetWord +// --------------------------------------------------------------------------- + +uint32 EmBankMapped::GetWord (emuptr address) +{ + if (CHECK_FOR_ADDRESS_ERROR && (address & 1) != 0) + { + AddressError (address, sizeof (uint16), true); + } + +#if HAS_PROFILING + CYCLE_GETWORD (WAITSTATES_DUMMYBANK); +#endif + + uint8* p = GetRealAddress (address); + + if (p == NULL) + { + return ~0; + } + + return (((uint32) p[0]) << 8) | p[1]; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::GetByte +// --------------------------------------------------------------------------- + +uint32 EmBankMapped::GetByte (emuptr address) +{ +#if HAS_PROFILING + CYCLE_GETBYTE (WAITSTATES_DUMMYBANK); +#endif + + uint8* p = GetRealAddress (address); + + if (p == NULL) + { + return ~0; + } + + return p[0]; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::SetLong +// --------------------------------------------------------------------------- + +void EmBankMapped::SetLong (emuptr address, uint32 value) +{ + if (CHECK_FOR_ADDRESS_ERROR && (address & 1) != 0) + { + AddressError (address, sizeof (uint32), false); + } + +#if HAS_PROFILING + CYCLE_PUTLONG (WAITSTATES_DUMMYBANK); +#endif + + uint8* p = GetRealAddress (address); + + if (p == NULL) + { + return; + } + + p[0] = (uint8) (value >> 24); + p[1] = (uint8) (value >> 16); + p[2] = (uint8) (value >> 8); + p[3] = (uint8) (value >> 0); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::SetWord +// --------------------------------------------------------------------------- + +void EmBankMapped::SetWord (emuptr address, uint32 value) +{ + if (CHECK_FOR_ADDRESS_ERROR && (address & 1) != 0) + { + AddressError (address, sizeof (uint16), false); + } + +#if HAS_PROFILING + CYCLE_PUTWORD (WAITSTATES_DUMMYBANK); +#endif + + uint8* p = GetRealAddress (address); + + if (p == NULL) + { + return; + } + + p[0] = (uint8) (value >> 8); + p[1] = (uint8) (value >> 0); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::SetByte +// --------------------------------------------------------------------------- + +void EmBankMapped::SetByte (emuptr address, uint32 value) +{ +#if HAS_PROFILING + CYCLE_PUTBYTE (WAITSTATES_DUMMYBANK); +#endif + + uint8* p = GetRealAddress (address); + + if (p == NULL) + { + return; + } + + p[0] = (uint8) (value >> 0); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::ValidAddress +// --------------------------------------------------------------------------- + +int EmBankMapped::ValidAddress (emuptr address, uint32) +{ + uint8* realAddress = GetRealAddress (address); + int result = realAddress != NULL; + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmBankMapped::GetRealAddress (emuptr address) +{ + MapRangeList::iterator iter = ::PrvGetMappingInfo (address); + + if (iter == gMappedRanges.end ()) + return NULL; + + return ((uint8*) iter->realAddress) + (address - iter->mappedAddress); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::GetMetaAddress +// --------------------------------------------------------------------------- + +uint8* EmBankMapped::GetMetaAddress (emuptr address) +{ + UNUSED_PARAM(address) + + static uint8 dummyBits[4] = {0, 0, 0, 0}; + + return dummyBits; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::GetEmulatedAddress +// --------------------------------------------------------------------------- + +emuptr EmBankMapped::GetEmulatedAddress (const void* address) +{ + MapRangeList::iterator iter = ::PrvGetMappingInfo (address); + + if (iter == gMappedRanges.end ()) + { + EmAssert (false); + return EmMemNULL; + } + + return iter->mappedAddress + ((char*) address - (char*) iter->realAddress); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::AddOpcodeCycles +// --------------------------------------------------------------------------- + +void EmBankMapped::AddOpcodeCycles (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::AddressError +// --------------------------------------------------------------------------- + +void EmBankMapped::AddressError (emuptr address, long size, Bool forRead) +{ + EmAssert (gCPU68K); + gCPU68K->AddressError (address, size, forRead); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::InvalidAccess +// --------------------------------------------------------------------------- + +void EmBankMapped::InvalidAccess (emuptr address, long size, Bool forRead) +{ + EmAssert (gCPU68K); + gCPU68K->BusError (address, size, forRead); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::MapPhysicalMemory +// --------------------------------------------------------------------------- +// Maps a range of physical memory to appear at the same location of the +// emulated Palm OS's virtual memory. + +void EmBankMapped::MapPhysicalMemory (const void* addr, uint32 size) +{ + if (addr == NULL) + return; + + emuptr candidate = ::PrvEnsureAligned (kMemoryStart, addr); + + // If the list is empty, add the item + + if (gMappedRanges.size () == 0) + { + MapRange range; + + range.realAddress = addr; + range.mappedAddress = candidate; + range.size = size; + + gLastIter = gMappedRanges.insert (gMappedRanges.begin (), range); + ::PrvCheckRanges (); + +// ::PrvInvalidateCache (); + + return; + } + + // Find an available space for the range. + + MapRangeList::iterator iter = gMappedRanges.begin (); + + while (iter != gMappedRanges.end ()) + { + // If there's room in front of the current block... + + if (iter->mappedAddress >= candidate + size) + { + // ...insert a map record in front of the current block. + + MapRange range; + + range.realAddress = addr; + range.mappedAddress = candidate; + range.size = size; + + gLastIter = gMappedRanges.insert (iter, range); + ::PrvCheckRanges (); + +// ::PrvInvalidateCache (); + + return; + } + + // No room at the inn...move onto the next block. + + candidate = ::PrvEnsureAligned (iter->mappedAddress + iter->size, addr); + ++iter; + } + + // Couldn't find room at the beginning or the middle of the list. Add to the end. + + MapRangeList::iterator last = gMappedRanges.end (); + iter = last - 1; + + MapRange range; + + range.realAddress = addr; + range.mappedAddress = ::PrvEnsureAligned (iter->mappedAddress + iter->size, addr); + range.size = size; + + gLastIter = gMappedRanges.insert (last, range); + ::PrvCheckRanges (); + +// ::PrvInvalidateCache (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::UnmapPhysicalMemory +// --------------------------------------------------------------------------- +// Unmaps a range of physical memory from appearing at the same location of +// the emulated Palm OS's virtual memory. + +void EmBankMapped::UnmapPhysicalMemory (const void* addr) +{ + if (addr == NULL) + return; + + MapRangeList::iterator iter = ::PrvGetMappingInfo (addr); + + // Take out this assert. Without it, it's possible to unmap ranges + // of memory that we may not have actually mapped in. Being able to + // do that makes things like Reset and Dispose methods easier to write. +// EmAssert (iter != gMappedRanges.end ()); + + if (iter != gMappedRanges.end ()) + { + gMappedRanges.erase (iter); + ::PrvCheckRanges (); + + ::PrvInvalidateCache (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankMapped::GetMappingInfo +// --------------------------------------------------------------------------- + +void EmBankMapped::GetMappingInfo (emuptr addr, void** start, uint32* len) +{ + MapRangeList::iterator iter = ::PrvGetMappingInfo (addr); + + if (iter != gMappedRanges.end ()) + { + if (start) + *start = (void*) iter->realAddress; + + if (len) + *len = iter->size; + } + else + { + if (start) + *start = NULL; + + if (len) + *len = 0; + } +} + + +// --------------------------------------------------------------------------- +// ¥ PrvGetMappingInfo +// --------------------------------------------------------------------------- + +MapRangeList::iterator PrvGetMappingInfo (const void* addr) +{ + if (gLastIter != gMappedRanges.end () && gLastIter->Contains (addr)) + return gLastIter; + + MapRangeList::iterator iter = gMappedRanges.begin (); + while (iter != gMappedRanges.end ()) + { + if (iter->Contains (addr)) + break; + + ++iter; + } + + gLastIter = iter; + + return iter; +} + + +MapRangeList::iterator PrvGetMappingInfo (emuptr addr) +{ + if (gLastIter != gMappedRanges.end () && gLastIter->Contains (addr)) + return gLastIter; + + MapRangeList::iterator iter = gMappedRanges.begin (); + while (iter != gMappedRanges.end ()) + { + if (iter->Contains (addr)) + break; + + ++iter; + } + + gLastIter = iter; + + return iter; +} + + +emuptr PrvEnsureAligned (emuptr candidate, const void* addr) +{ + // Make sure that "candidate" -- which is the candidate + // mapped address -- maintains the same alignment as + // the incoming address. + + while ((candidate & 0x03) != ((uint32) addr & 0x03)) + ++candidate; + + return candidate; +} + +void PrvInvalidateCache (void) +{ + gLastIter = gMappedRanges.end (); +} + +void PrvCheckRanges (void) +{ +#if _DEBUG + /* + Check for overlaps. We iterate over the container with + two iterators: outerIter and innerIter. These two iterators + will allow us to compare all possible combinations of + elements in the container. + + When checking for overlaps, there are six cases to consider: + + *-----------* Segment A + + *---* Possible segment B's. + *----------* + *---------------------------* + *---* + *---------------* + *---* + + An overlap occurs if any part of segment B crosses segment A. + From the drawing, we can see that the first and last possible + segments B's are OK; the others overlap with segment A in + some fashion. Thus, Segment B is OK if it's end is less than + Segment A's start, or its start is greater than segment A's end. + */ + + MapRangeList::iterator outerIter = gMappedRanges.begin (); + while (outerIter != gMappedRanges.end ()) + { + MapRangeList::iterator innerIter = outerIter + 1; + while (innerIter != gMappedRanges.end ()) + { + char* outerStart = (char*) outerIter->realAddress; + char* innerStart = (char*) innerIter->realAddress; + + char* outerEnd = outerStart + outerIter->size; + char* innerEnd = innerStart + innerIter->size; + + if (innerEnd > outerStart && innerStart < outerEnd) + { + EmAssert (false); + } + + ++innerIter; + } + + ++outerIter; + } +#endif +} + diff --git a/SrcShared/Hardware/EmBankMapped.h b/SrcShared/Hardware/EmBankMapped.h new file mode 100644 index 0000000..033c749 --- /dev/null +++ b/SrcShared/Hardware/EmBankMapped.h @@ -0,0 +1,55 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmBankMapped_h +#define EmBankMapped_h + + +class SessionFile; + +class EmBankMapped +{ + public: + static void Initialize (void); + static void Reset (Bool hardwareReset); + static void Save (SessionFile&); + static void Load (SessionFile&); + static void Dispose (void); + + static void SetBankHandlers (void); + + static uint32 GetLong (emuptr address); + static uint32 GetWord (emuptr address); + static uint32 GetByte (emuptr address); + static void SetLong (emuptr address, uint32 value); + static void SetWord (emuptr address, uint32 value); + static void SetByte (emuptr address, uint32 value); + static int ValidAddress (emuptr address, uint32 size); + static uint8* GetRealAddress (emuptr address); + static uint8* GetMetaAddress (emuptr address); + static emuptr GetEmulatedAddress (const void* address); + static void AddOpcodeCycles (void); + + static void MapPhysicalMemory (const void*, uint32); + static void UnmapPhysicalMemory (const void*); + + static void GetMappingInfo (emuptr addr, void** start, uint32* len); + + + private: + static void AddressError (emuptr address, long size, Bool forRead); + static void InvalidAccess (emuptr address, long size, Bool forRead); +}; + + +#endif /* EmBankMapped_h */ diff --git a/SrcShared/Hardware/EmBankROM.cpp b/SrcShared/Hardware/EmBankROM.cpp new file mode 100644 index 0000000..67cb46e --- /dev/null +++ b/SrcShared/Hardware/EmBankROM.cpp @@ -0,0 +1,1617 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1998-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmBankROM.h" + +#include "Byteswapping.h" // ByteswapWords +#include "EmCPU68K.h" // gCPU68K +#include "EmErrCodes.h" // kError_UnsupportedROM +#include "EmHAL.h" // EmHAL +#include "EmMemory.h" // Memory::InitializeBanks, EmMem_memset +#include "EmPalmStructs.h" // EmProxyCardHeaderType +#include "EmSession.h" // GetDevice, ScheduleDeferredError +#include "ErrorHandling.h" // Errors::Throw +#include "Miscellaneous.h" // StWordSwapper, NextPowerOf2 +#include "Profiling.h" // WAITSTATES_ROM +#include "SessionFile.h" // WriteROMFileReference +#include "Strings.r.h" // kStr_BadChecksum + + +// Private function declarations + + +class Card +{ + public: + static Bool CheckCardHeader (const EmProxyCardHeaderType& cardHdr); + static Bool CheckChecksum (const void* p, uint32 romLength); + static Bool Supports328 (const EmAliasCardHeaderType<LAS>& cardHdr); + static Bool SupportsEZ (const EmAliasCardHeaderType<LAS>& cardHdr); + static Bool SupportsVZ (const EmAliasCardHeaderType<LAS>& cardHdr); + static Bool SupportsSZ (const EmAliasCardHeaderType<LAS>& cardHdr); +}; + + +// static member initialization + +emuptr EmBankROM::gROMMemoryStart = kDefaultROMMemoryStart; + +// =========================================================================== +// ¥ ROM Bank Accessors +// =========================================================================== +// These functions provide fetch and store access to the emulator's read only +// memory. + +static EmAddressBank gROMAddressBank = +{ + EmBankROM::GetLong, + EmBankROM::GetWord, + EmBankROM::GetByte, + EmBankROM::SetLong, + EmBankROM::SetWord, + EmBankROM::SetByte, + EmBankROM::GetRealAddress, + EmBankROM::ValidAddress, + EmBankROM::GetMetaAddress, + EmBankROM::AddOpcodeCycles +}; + +static uint32 gROMBank_Size; +static uint32 gManagedROMSize; +static uint32 gROMImage_Size; +static uint32 gROMBank_Mask; +static uint8* gROM_Memory; +static uint8* gROM_MetaMemory; + + +/*********************************************************************** + * + * FUNCTION: EmBankROM::Initialize + * + * DESCRIPTION: Standard initialization function. Responsible for + * initializing this sub-system when a new session is + * created. Will be followed by at least one call to + * Reset or Load. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankROM::Initialize (EmStream& romStream) +{ + // When creating a new session, Initialize is called followed by + // Reset. When loading a session, Initialize is called by Load. + // So it makes sense to load the ROM image here. However, when + // reloading a session as part of a Gremlin Horde, only Load is + // called, so it is critical that all parts of a horde use the + // same ROM image. + + EmBankROM::LoadROM (romStream); +} + + +/*********************************************************************** + * + * FUNCTION: EmBankROM::Reset + * + * DESCRIPTION: Standard reset function. Sets the sub-system to a + * default state. This occurs not only on a Reset (as + * from the menu item), but also when the sub-system + * is first initialized (Reset is called after Initialize) + * as well as when the system is re-loaded from an + * insufficient session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankROM::Reset (Bool /*hardwareReset*/) +{ + memset (gROM_MetaMemory, 0, gROMImage_Size); +} + + +/*********************************************************************** + * + * FUNCTION: EmBankROM::Save + * + * DESCRIPTION: Standard save function. Saves any sub-system state to + * the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankROM::Save (SessionFile& f) +{ + EmAssert (gSession); + Configuration cfg = gSession->GetConfiguration (); + f.WriteROMFileReference (cfg.fROMFile); + + StWordSwapper swapper1 (gROM_MetaMemory, gROMImage_Size); + f.WriteMetaROMImage (gROM_MetaMemory, gROMImage_Size); +} + + +/*********************************************************************** + * + * FUNCTION: EmBankROM::Load + * + * DESCRIPTION: Standard load function. Loads any sub-system state + * from the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankROM::Load (SessionFile& f) +{ + // ROM reference was read when the basic configuration was read + // and passed to EmSession::Initialize, which then called + // EmBankROM::Initialize, which then called EmBankROM::LoadROM. + + EmAssert (gROM_MetaMemory != NULL); + + if (f.ReadMetaROMImage (gROM_MetaMemory)) + { + ByteswapWords (gROM_MetaMemory, gROMImage_Size); + } + else + { + f.SetCanReload (false); + } +} + + +/*********************************************************************** + * + * FUNCTION: EmBankROM::Dispose + * + * DESCRIPTION: Standard dispose function. Completely release any + * resources acquired or allocated in Initialize and/or + * Load. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankROM::Dispose (void) +{ + Platform::DisposeMemory (gROM_Memory); + Platform::DisposeMemory (gROM_MetaMemory); +} + + +/*********************************************************************** + * + * FUNCTION: EmBankROM::SetBankHandlers + * + * DESCRIPTION: Set the bank handlers UAE uses to dispatch memory + * access operations. + * + * PARAMETERS: None + * + * RETURNED: Nothing + * + ***********************************************************************/ + +void EmBankROM::SetBankHandlers (void) +{ + if (EmHAL::ChipSelectsConfigured ()) + { + gROMMemoryStart = EmHAL::GetROMBaseAddress (); + } + + gManagedROMSize = EmHAL::GetROMSize (); + + // Memory banks gROMMemoryStart to <mumble> are managed by the functions + // in EmBankROM. <mumble> is based on the amount of ROM being emulated. + + uint32 first_bank = EmMemBankIndex (EmBankROM::GetMemoryStart ()); + uint32 last_bank = EmMemBankIndex (EmBankROM::GetMemoryStart () + gManagedROMSize - 1); + + Memory::InitializeBanks ( gROMAddressBank, first_bank, + last_bank - first_bank + 1); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankROM::GetLong +// --------------------------------------------------------------------------- + +uint32 EmBankROM::GetLong (emuptr address) +{ +#if PROFILE_MEMORY + gMemoryAccess[kROMLongRead]++; + if (address & 2) + gMemoryAccess[kROMLongRead2]++; +#endif + +#if (CHECK_FOR_ADDRESS_ERROR) + if ((address & 1) != 0) + { + AddressError (address, sizeof (uint32), true); + } +#endif + +#if (VALIDATE_ROM_GET) + if (gMemAccessFlags.fValidate_ROMGet && !ValidAddress (address, sizeof (uint32))) + { + InvalidAccess (address, sizeof (uint32), true); + } +#endif + +#if (PREVENT_USER_ROM_GET || PREVENT_SYSTEM_ROM_GET) + if (EmMemory::IsPCInRAM ()) + { + if (PREVENT_USER_ROM_GET && gMemAccessFlags.fProtect_ROMGet) + { + InvalidAccess (address, sizeof (uint32), true); + } + } + else + { + if (PREVENT_SYSTEM_ROM_GET && gMemAccessFlags.fProtect_SysROMGet) + { + InvalidAccess (address, sizeof (uint32), true); + } + } +#endif + +#if HAS_PROFILING + CYCLE_GETLONG (WAITSTATES_ROM); +#endif + + address &= gROMBank_Mask; + + return EmMemDoGet32 (gROM_Memory + address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankROM::GetWord +// --------------------------------------------------------------------------- + +uint32 EmBankROM::GetWord (emuptr address) +{ +#if PROFILE_MEMORY + gMemoryAccess[kROMWordRead]++; +#endif + +#if (CHECK_FOR_ADDRESS_ERROR) + if ((address & 1) != 0) + { + AddressError (address, sizeof (uint16), true); + } +#endif + +#if (VALIDATE_ROM_GET) + if (gMemAccessFlags.fValidate_ROMGet && !ValidAddress (address, sizeof (uint16))) + { + InvalidAccess (address, sizeof (uint16), true); + } +#endif + +#if (PREVENT_USER_ROM_GET || PREVENT_SYSTEM_ROM_GET) + if (EmMemory::IsPCInRAM ()) + { + if (PREVENT_USER_ROM_GET && gMemAccessFlags.fProtect_ROMGet) + { + InvalidAccess (address, sizeof (uint16), true); + } + } + else + { + if (PREVENT_SYSTEM_ROM_GET && gMemAccessFlags.fProtect_SysROMGet) + { + InvalidAccess (address, sizeof (uint16), true); + } + } +#endif + +#if HAS_PROFILING + CYCLE_GETWORD (WAITSTATES_ROM); +#endif + + address &= gROMBank_Mask; + + return EmMemDoGet16 (gROM_Memory + address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankROM::GetByte +// --------------------------------------------------------------------------- + +uint32 EmBankROM::GetByte (emuptr address) +{ +#if PROFILE_MEMORY + gMemoryAccess[kROMByteRead]++; +#endif + +#if (VALIDATE_ROM_GET) + if (gMemAccessFlags.fValidate_ROMGet && !ValidAddress (address, sizeof (uint8))) + { + InvalidAccess (address, sizeof (uint8), true); + } +#endif + +#if (PREVENT_USER_ROM_GET || PREVENT_SYSTEM_ROM_GET) + if (EmMemory::IsPCInRAM ()) + { + if (PREVENT_USER_ROM_GET && gMemAccessFlags.fProtect_ROMGet) + { + InvalidAccess (address, sizeof (uint8), true); + } + } + else + { + if (PREVENT_SYSTEM_ROM_GET && gMemAccessFlags.fProtect_SysROMGet) + { + InvalidAccess (address, sizeof (uint8), true); + } + } +#endif + +#if HAS_PROFILING + CYCLE_GETBYTE (WAITSTATES_ROM); +#endif + + address &= gROMBank_Mask; + + return EmMemDoGet8 (gROM_Memory + address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankROM::SetLong +// --------------------------------------------------------------------------- + +void EmBankROM::SetLong (emuptr address, uint32 value) +{ +#if PROFILE_MEMORY + gMemoryAccess[kROMLongWrite]++; + if (address & 2) + gMemoryAccess[kROMLongWrite2]++; +#endif + +#if (CHECK_FOR_ADDRESS_ERROR) + if ((address & 1) != 0) + { + AddressError (address, sizeof (uint32), false); + } +#endif + + EmAssert (ValidAddress (address, sizeof (uint32))); + +#if (PREVENT_USER_ROM_SET || PREVENT_SYSTEM_ROM_SET) + if (EmMemory::IsPCInRAM ()) + { + if (PREVENT_USER_ROM_SET && gMemAccessFlags.fProtect_ROMSet) + { + InvalidAccess (address, sizeof (uint32), false); + return; + } + } + else + { + if (PREVENT_SYSTEM_ROM_SET && gMemAccessFlags.fProtect_SysROMSet) + { + InvalidAccess (address, sizeof (uint32), false); + return; + } + } +#endif + +#if HAS_PROFILING + // writing to ROM?? don't know what to make of this + CYCLE_PUTLONG (WAITSTATES_ROM); +#endif + + address &= gROMBank_Mask; + + EmMemDoPut32 (gROM_Memory + address, value); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankROM::SetWord +// --------------------------------------------------------------------------- + +void EmBankROM::SetWord (emuptr address, uint32 value) +{ +#if PROFILE_MEMORY + gMemoryAccess[kROMWordWrite]++; +#endif + +#if (CHECK_FOR_ADDRESS_ERROR) + if ((address & 1) != 0) + { + AddressError (address, sizeof (uint16), false); + } +#endif + + EmAssert (ValidAddress (address, sizeof (uint16))); + +#if (PREVENT_USER_ROM_SET || PREVENT_SYSTEM_ROM_SET) + if (EmMemory::IsPCInRAM ()) + { + if (PREVENT_USER_ROM_SET && gMemAccessFlags.fProtect_ROMSet) + { + InvalidAccess (address, sizeof (uint16), false); + return; + } + } + else + { + if (PREVENT_SYSTEM_ROM_SET && gMemAccessFlags.fProtect_SysROMSet) + { + InvalidAccess (address, sizeof (uint16), false); + return; + } + } +#endif + +#if HAS_PROFILING + // writing to ROM?? don't know what to make of this + CYCLE_PUTWORD (WAITSTATES_ROM); +#endif + + address &= gROMBank_Mask; + + EmMemDoPut16 (gROM_Memory + address, value); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankROM::SetByte +// --------------------------------------------------------------------------- + +void EmBankROM::SetByte (emuptr address, uint32 value) +{ +#if PROFILE_MEMORY + gMemoryAccess[kROMByteWrite]++; +#endif + + EmAssert (ValidAddress (address, sizeof (uint8))); + +#if (PREVENT_USER_ROM_SET || PREVENT_SYSTEM_ROM_SET) + if (EmMemory::IsPCInRAM ()) + { + if (PREVENT_USER_ROM_SET && gMemAccessFlags.fProtect_ROMSet) + { + InvalidAccess (address, sizeof (uint8), false); + return; + } + } + else + { + if (PREVENT_SYSTEM_ROM_SET && gMemAccessFlags.fProtect_SysROMSet) + { + InvalidAccess (address, sizeof (uint8), false); + return; + } + } +#endif + +#if HAS_PROFILING + // writing to ROM?? don't know what to make of this + CYCLE_PUTBYTE (WAITSTATES_ROM); +#endif + + address &= gROMBank_Mask; + + EmMemDoPut8 (gROM_Memory + address, value); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankROM::ValidAddress +// --------------------------------------------------------------------------- + +int EmBankROM::ValidAddress (emuptr address, uint32 size) +{ + address -= gROMMemoryStart; + int result = (address + size) <= (gROMMemoryStart + gROMBank_Size); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankROM::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmBankROM::GetRealAddress (emuptr address) +{ + // Strip the uppermost bit of the address. + + address &= gROMBank_Mask; + + return (uint8*) &gROM_Memory[address]; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankROM::GetMetaAddress +// --------------------------------------------------------------------------- + +uint8* EmBankROM::GetMetaAddress (emuptr address) +{ + // Strip the uppermost bit of the address. + + address &= gROMBank_Mask; + + return (uint8*) &(gROM_MetaMemory[address]); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankROM::AddOpcodeCycles +// --------------------------------------------------------------------------- + +void EmBankROM::AddOpcodeCycles (void) +{ +#if (HAS_PROFILING) + CYCLE_GETWORD (WAITSTATES_ROM); +#endif +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankROM::AddressError +// --------------------------------------------------------------------------- + +void EmBankROM::AddressError (emuptr address, long size, Bool forRead) +{ + EmAssert (gCPU68K); + gCPU68K->AddressError (address, size, forRead); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankROM::InvalidAccess +// --------------------------------------------------------------------------- + +void EmBankROM::InvalidAccess (emuptr address, long size, Bool forRead) +{ + EmAssert (gSession); + gSession->ScheduleDeferredError (new EmDeferredErrROM (address, size, forRead)); +} + + +/*********************************************************************** + * + * FUNCTION: EmBankROM::LoadROM + * + * DESCRIPTION: Does the work of actually loading (and validating a ROM + * from a stream. + * + * PARAMETERS: EmStream hROM + * + * RETURNED: Nothing + * + ***********************************************************************/ + +void EmBankROM::LoadROM (EmStream& hROM) +{ + // Make sure the file is big enough to have a card header. + + if (hROM.GetLength() < (long) EmProxyCardHeaderType::GetSize ()) + Errors::Throw (kError_BadROM); + + // Read the card header. + + EmProxyCardHeaderType cardHeader; + hROM.GetBytes (cardHeader.GetPtr (), cardHeader.GetSize ()); + + // Validate the card header. + + if (!Card::CheckCardHeader (cardHeader)) + Errors::Throw (kError_BadROM); + + // The ROM is made up of two parts: a Big ROM and a Small ROM. ROM image + // files can contain both parts or just the Big ROM part. If it contains + // both parts, then everything is just fine, and we can use it no problem. + // If the Small ROM part is missing, we have to detect that, dummy up a + // small ROM for correct operation, and relocate the Big ROM higher in memory. + + // Both the Big ROM and Small ROM start off with a CardHeaderType struct. + // We just read in one of them. Let's look at where the Big ROM _should_ + // be to see if there's another CardHeader there. If so, we have both parts. + // If not, we have just the Big ROM. + + int32 bigROMOffset; + + if (cardHeader.hdrVersion == 1) + { + bigROMOffset = 0x3000; + } + else + { + // Version 2 CardHeaders contain a "bigROMOffset" field that contains the + // offset from the beginning of the card to where the ROM should + // appear in memory. Normally the card appears at 0x10000000 (which + // would make bigROMOffset something like 0x00C08000), but that + // isn't always the case. The problem is, we don't always know + // where the card beginning will be. For now, we'll assume that + // the ROM wants to live at 0x10C00000, and that the Big ROM will + // want to begin somewhere soon after that. This means we can get by + // with using only the lower bits of bigROMOffset. + + bigROMOffset = cardHeader.bigROMOffset; + bigROMOffset &= 0x000FFFFF; // Allows for 1 Meg offset. + } + + // Make sure the file is big enough to have a Big ROM. + + if (hROM.GetLength() < bigROMOffset) + Errors::Throw (kError_BadROM); + + // We'll use bigROMOffset for later to get to some Big ROM data. + // But we'll also need a value when we read the ROM image into + // memory. This value will be used as an offset into a buffer + // where we'll be reading the ROM image. If we have a Small ROM, + // the offset will be zero. If we have only a Big ROM, the offset + // will be the same value as bigROMOffset. + + uint32 bufferOffset = bigROMOffset; + + // See if there's a card header there, too. + + EmProxyCardHeaderType cardHeader2; + hROM.SetMarker (bigROMOffset, kStreamFromStart); + hROM.GetBytes (cardHeader2.GetPtr (), cardHeader2.GetSize ()); + + if (Card::CheckCardHeader (cardHeader2)) + { + // Looks like, so we don't have to relocate the ROM image. + + bufferOffset = 0; + } + + // The ROM size is now the size of the file plus any offset for + // any small ROM that we have to add and dummy up. + + gROMImage_Size = hROM.GetLength() + bufferOffset; + gROMBank_Size = ::NextPowerOf2 (gROMImage_Size); + + // Read in the ROM image. + + StMemory romImage (gROMImage_Size); + StMemory romMetaImage (gROMImage_Size); + + hROM.SetMarker (0, kStreamFromStart); + hROM.GetBytes (romImage.Get () + bufferOffset, hROM.GetLength()); + + + + // See if the big ROM checksum looks OK. + + Card::CheckChecksum (romImage.Get () + bigROMOffset, gROMImage_Size - bigROMOffset); + + // If we only had a Big ROM, dummy up the Small ROM. All we really + // need to do here is copy the Big ROM's card header to the Small + // ROM area. + // + // Also, clear out this area to 0xFF to look like new Flash RAM. + + if (bufferOffset) + { + memset (romImage, 0xFF, bigROMOffset); + memcpy (romImage.Get (), romImage.Get () + bigROMOffset, EmProxyCardHeaderType::GetSize ()); + } + else + { + // See if the small ROM checksum looks OK. + // Note that checksumBytes is invalid for v1 card headers, + // but in those cases, it's not really used anyway. + + EmAliasCardHeaderType<LAS> cardHdr (romImage.Get ()); + uint32 smallROMSize = cardHdr.checksumBytes; + Card::CheckChecksum (romImage.Get (), smallROMSize); + } + + + // Check that the ROM we just loaded can be run on this device. + + EmAliasCardHeaderType<LAS> cardHdr (romImage.Get ()); + + EmAssert (gSession); + if (Card::SupportsEZ (cardHdr)) + { + if (!gSession->GetDevice ().Supports68EZ328 ()) + { + /* Make a hack for the Prism, Platinum and Edge below since + Handspring seems to report the EZ bit in their ROMs. */ + + if (!gSession->GetDevice ().PrismPlatinumEdgeHack ()) + { + Errors::Throw (kError_WrongROMForType); + } + } + } + else if (Card::SupportsVZ (cardHdr)) + { + if (!gSession->GetDevice ().Supports68VZ328 ()) + { + Errors::Throw (kError_WrongROMForType); + } + } + else if (Card::SupportsSZ (cardHdr)) + { + if (!gSession->GetDevice ().Supports68SZ328 ()) + { + Errors::Throw (kError_WrongROMForType); + } + } + else + { + if (!gSession->GetDevice ().Supports68328 ()) + { + Errors::Throw (kError_WrongROMForType); + } + } + + // Byteswap all the words in the ROM (if necessary). Most accesses + // are 16-bit accesses, so we optimize for that case. + + ByteswapWords (romImage.Get (), gROMImage_Size); + + // Everything seems to be OK. Save the ROM data in some global + // variables for the CPU emulator to access. Make sure that + // gROMBank_Size is a power-of-2. The EmBankROM memory routines + // require this. + + EmAssert (gROM_Memory == NULL); + EmAssert (gROM_MetaMemory == NULL); + + gROM_Memory = (uint8*) romImage.Release (); + gROM_MetaMemory = (uint8*) romMetaImage.Release (); + gROMBank_Mask = gROMBank_Size - 1; + + // Guess the default ROM base address. + // This will be used until the chip selects are set up. + // + // (I tried just setting this to zero, but the Palm OS 3.0 + // startup code probes at 0x10c00008 and 0x10d00008 to see if + // it can find signatures there. If we map the ROM to zero, + // then we'll get bus errors when those accesses are made.) + + gROMMemoryStart = cardHeader.resetVector & 0xFFF00000; + +} + + +#pragma mark - + +// =========================================================================== +// ¥ Flash Bank Accessors +// =========================================================================== +// These functions provide fetch and store access to the emulator's read only +// memory. + +/* + There are five types of flash that our flash manager routines identify: + Mitsubishi, Hitachi, Intel, AMD, and Fujitsu. Of these, only the last + two are really supported right now. Unfortunately, they are the hardest + to emulate. :-( + + To identify the kind of flash being used, our ROM routines: + + - Read a word from FLASHBASE + - Write 0x00FF to FLASHBASE + - Read a word from FLASHBASE + - Write 0x0090 to FLASHBASE + - Read a manufacturer ID (word) from FLASHBASE + - Read a device ID (word) from FLASHBASE + 2 + - Write 0x00FF to FLASHBASE + + Mitsubishi: manufacturer == 0x001C, device == 0x005E + Hitachi: manufacturer == 0x0007, device == 0x0086 + Intel: manufacturer == 0x0089, device == 0x0091 + + If the flash is not one of those, our ROM routines: + + - Read a word from FLASHBASE + - Write 0x00F0 to FLASHBASE + - Write 0x00AA to FLASHBASE + 0xAAAA + - Write 0x0055 to FLASHBASE + 0x5554 + - Write 0x0090 to FLASHBASE + 0xAAAA + - Read a manufacturer ID (word) from FLASHBASE + - Read a device ID (word) from FLASHBASE + 2 + - Write 0x00F0 to FLASHBASE + + AMD: manufacturer == 0x0001, device == 0x0049 + Fujitsu: manufacturer == 0x0004, device == 0x0049 + + + To erase a word of flash, our ROM routines: + + AMD, Fujitsu: + + - Read a word from FLASHBASE + - Write 0x00F0 to FLASHBASE + - Write 0x00AA to FLASHBASE + 0xAAAA + - Write 0x0055 to FLASHBASE + 0x5554 + - Write 0x0080 to FLASHBASE + 0xAAAA + - Write 0x00AA to FLASHBASE + 0xAAAA + - Write 0x0055 to FLASHBASE + 0x5554 + - Write 0x0030 to location to be erased + - Check erase location for 0x0080 + - Read from FLASHBASE + - Write 0x00F0 to FLASHBASE + + Mitsubishi, Hitachi: + + - Read a word from FLASHBASE + - Write 0x00FF to FLASHBASE + - Write 0x0020 to FLASHBASE + - Write 0x00D0 to location to be erased + - Check erase location for 0x0080 + -- If 0x0020 is also set, an error occurred + - Read from FLASHBASE + - Write 0x00FF to FLASHBASE + + Intel + + - Not supported + + To program a block of flash: + + AMD, Fujitsu: + + - Read a word from FLASHBASE + - Write 0x00F0 to FLASHBASE + - For each word to write + - If the word is already there, continue + - Write 0x00AA to FLASHBASE + 0xAAAA + - Write 0x0055 to FLASHBASE + 0x5554 + - Write 0x00A0 to FLASHBASE + 0xAAAA + - Write the word to the dest location + - Check write location for 0x0080 + - Read from FLASHBASE + - Write 0x00F0 to FLASHBASE + + Mitsubishi, Hitachi, Intel: + + - Not supported +*/ + + +enum +{ + kAMDState_Normal, // Read-only mode. Acts like a normal ROM. + // Almost any write of 0x00F0 to any address will get us here. + // Also enter here automatically after Erase or Program operation. + // A write of 0x00AA to 0xAAAA will put us in kAMDState_Unlocked1. + + kAMDState_Unlocked1, // After first unlock cycle (0x00AA written to 0xAAAA) + // Looking for the second unlock cycle (0x0055 written to 0x5554); + // If we find one, go to kAMDState_Unlocked2. + // ??? What happens on other operations? + + kAMDState_Unlocked2, // After second unlock cycle (0x0055 written to 0x5554) + // Now looking for a command to be written to 0xAAAA + // If we find 0x0090, go to kAMDState_Autoselect. + // If we find 0x0080, set gEraseIsSetup and go to kAMDState_Normal. ??? When should gEraseIsSetup get cleared? + // If we find 0x0030, if gEraseIsSetup erase the sector and go to kAMDState_EraseDone. + // If we fine 0x00A0, go to kAMDState_Program. + // ??? What happens on other operations? + + kAMDState_Autoselect, // After a write of 0x0090 to 0x5555. + // A read of 0x0000 returns 0x0001 (manufacturer ID). + // A read of 0x0002 returns 0x0049 (device ID). + // A write of 0x00F0 to any address returns us to kAMDState_Normal. + // ??? What happens on other operations? + + kAMDState_Program, // After a program sequence was entered. + // Accept any write operation and go to kAMDState_ProgramDone. + // ??? What happens on other operations? + + kAMDState_EraseDone, // After a Erase operation. + // On the next read, return successful operation and return to kAMDState_Normal + // ??? What happens on other operations? + + kAMDState_ProgramDone, // After a Program operation. + // On the next read, return successful operation and return to kAMDState_Normal + // ??? What happens on other operations? + kAMDState_Dummy +}; + + +static EmAddressBank gFlashAddressBank = +{ + EmBankFlash::GetLong, + EmBankFlash::GetWord, + EmBankFlash::GetByte, + EmBankFlash::SetLong, + EmBankFlash::SetWord, + EmBankFlash::SetByte, + EmBankFlash::GetRealAddress, + EmBankFlash::ValidAddress, + EmBankFlash::GetMetaAddress, + EmBankFlash::AddOpcodeCycles +}; + +#define FLASHBASE (EmBankROM::GetMemoryStart ()) + +static int gState = kAMDState_Normal; +static Bool gEraseIsSetup; + + +/*********************************************************************** + * + * FUNCTION: EmBankFlash::Initialize + * + * DESCRIPTION: Standard initialization function. Responsible for + * initializing this sub-system when a new session is + * created. Will be followed by at least one call to + * Reset or Load. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankFlash::Initialize (void) +{ +} + + +/*********************************************************************** + * + * FUNCTION: EmBankFlash::Reset + * + * DESCRIPTION: Standard reset function. Sets the sub-system to a + * default state. This occurs not only on a Reset (as + * from the menu item), but also when the sub-system + * is first initialized (Reset is called after Initialize) + * as well as when the system is re-loaded from an + * insufficient session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankFlash::Reset (Bool hardwareReset) +{ + if (hardwareReset) + { + gState = kAMDState_Normal; + } +} + + +/*********************************************************************** + * + * FUNCTION: EmBankFlash::Save + * + * DESCRIPTION: Standard save function. Saves any sub-system state to + * the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankFlash::Save (SessionFile&) +{ + // !!! Save gState && gEraseIsSetup? +} + + +/*********************************************************************** + * + * FUNCTION: EmBankFlash::Load + * + * DESCRIPTION: Standard load function. Loads any sub-system state + * from the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankFlash::Load (SessionFile&) +{ + // !!! Load gState && gEraseIsSetup? +} + + +/*********************************************************************** + * + * FUNCTION: EmBankFlash::Dispose + * + * DESCRIPTION: Standard dispose function. Completely release any + * resources acquired or allocated in Initialize and/or + * Load. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankFlash::Dispose (void) +{ +} + + +/*********************************************************************** + * + * FUNCTION: EmBankFlash::SetBankHandlers + * + * DESCRIPTION: Set the bank handlers UAE uses to dispatch memory + * access operations. + * + * PARAMETERS: None + * + * RETURNED: Nothing + * + ***********************************************************************/ + +void EmBankFlash::SetBankHandlers (void) +{ + gManagedROMSize = EmHAL::GetROMSize (); + + // Memory banks gROMMemoryStart to <mumble> are managed by the functions + // in EmBankROM. <mumble> is based on the amount of ROM being emulated. + + uint32 first_bank = EmMemBankIndex (EmBankROM::GetMemoryStart ()); + uint32 last_bank = EmMemBankIndex (EmBankROM::GetMemoryStart () + gManagedROMSize - 1); + + Memory::InitializeBanks ( gFlashAddressBank, first_bank, + last_bank - first_bank + 1); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankFlash::GetLong +// --------------------------------------------------------------------------- + +uint32 EmBankFlash::GetLong (emuptr address) +{ + return EmBankROM::GetLong (address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankFlash::GetWord +// --------------------------------------------------------------------------- + +uint32 EmBankFlash::GetWord (emuptr address) +{ + switch (gState) + { + case kAMDState_Normal: + // Read-only mode. Acts like a normal ROM. + // Almost any write of 0x00F0 to any address will get us here. + // Also enter here automatically after Erase or Program operation. + // A write of 0x00AA to 0xAAAA will put us in kAMDState_Unlocked1. + + break; + + case kAMDState_Unlocked1: + // After first unlock cycle (0x00AA written to 0xAAAA) + // Looking for the second unlock cycle (0x0055 written to 0x5554); + // If we find one, go to kAMDState_Unlocked2. + // ??? What happens on other operations? + + break; + + case kAMDState_Unlocked2: + // After second unlock cycle (0x0055 written to 0x5554) + // Now looking for a command to be written to 0xAAAA + // If we find 0x0090, go to kAMDState_Autoselect. + // If we find 0x0080, set gEraseIsSetup and go to kAMDState_Normal. ??? When should gEraseIsSetup get cleared? + // If we find 0x0030, if gEraseIsSetup erase the sector and go to kAMDState_ProgramDone. + // If we fine 0x00A0, go to kAMDState_Program. + // ??? What happens on other operations? + + break; + + case kAMDState_Autoselect: + // After a write of 0x0090 to 0x5555. + // A read of 0x0000 returns 0x0001 (manufacturer ID). + // A read of 0x0002 returns 0x0049 (device ID). + // A write of 0x00F0 to any address returns us to kAMDState_Normal. + // ??? What happens on other operations? + + if (address == FLASHBASE) + { + return 0x0001; + } + else if (address == FLASHBASE + 2) + { + return 0x0049; + } + break; + + case kAMDState_Program: + // After a program sequence was entered. + // Accept any write operation and go to kAMDState_ProgramDone. + // ??? What happens on other operations? + + break; + + case kAMDState_EraseDone: + // After a Program or Erase operation. + // On the next read, return successful operation and return to kAMDState_Normal + // ??? What happens on other operations? + + // !!! We should really check that address is the same as the + // one specified in the Erase command. + + gState = kAMDState_Normal; + return 0x0080; + + case kAMDState_ProgramDone: + // After a Program or Erase operation. + // On the next read, return successful operation and return to kAMDState_Normal + // ??? What happens on other operations? + + // !!! We should really check that address is the same as the + // one specified in the Program command. + + gState = kAMDState_Normal; + return 0x0080 & EmBankROM::GetWord (address); + } + + return EmBankROM::GetWord (address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankFlash::GetByte +// --------------------------------------------------------------------------- + +uint32 EmBankFlash::GetByte (emuptr address) +{ + return EmBankROM::GetByte (address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankFlash::SetLong +// --------------------------------------------------------------------------- + +void EmBankFlash::SetLong (emuptr address, uint32 value) +{ + EmBankROM::SetLong (address, value); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankFlash::SetWord +// --------------------------------------------------------------------------- + +void EmBankFlash::SetWord (emuptr address, uint32 value) +{ + switch (gState) + { + case kAMDState_Normal: + // Read-only mode. Acts like a normal ROM. + // Almost any write of 0x00F0 to any address will get us here. + // Also enter here automatically after Erase or Program operation. + // A write of 0x00AA to 0xAAAA will put us in kAMDState_Unlocked1. + + if (address == FLASHBASE + 0xAAAA && value == 0x00AA) + { + gState = kAMDState_Unlocked1; + return; + } + + // Allow these. PrvIdentifyFlashCode probes with these values + // to determine what Flash part we've got. + + if (address == FLASHBASE && (value == 0x00FF || value == 0x00F0 || value == 0x0090)) + { + return; + } + break; + + case kAMDState_Unlocked1: + // After first unlock cycle (0x00AA written to 0xAAAA) + // Looking for the second unlock cycle (0x0055 written to 0x5554); + // If we find one, go to kAMDState_Unlocked2. + // ??? What happens on other operations? + + if (value == 0x00F0) + { + gState = kAMDState_Normal; + return; + } + else if (address == FLASHBASE + 0x5554 && value == 0x0055) + { + gState = kAMDState_Unlocked2; + return; + } + break; + + case kAMDState_Unlocked2: + // After second unlock cycle (0x0055 written to 0x5554) + // Now looking for a command to be written to 0xAAAA + // If we find 0x0090, go to kAMDState_Autoselect. + // If we find 0x0080, set gEraseIsSetup and go to kAMDState_Normal. ??? When should gEraseIsSetup get cleared? + // If we find 0x0030, if gEraseIsSetup erase the sector and go to kAMDState_EraseDone. + // If we fine 0x00A0, go to kAMDState_Program. + // ??? What happens on other operations? + + if (value == 0x00F0) + { + gState = kAMDState_Normal; + return; + } + else if (value == 0x0030 && gEraseIsSetup) + { + const int kEraseValue = 0xFF; +#if 0 + DWord readWriteParmsOffset = EmMemGet32 (0x10C00000 + offsetof (CardHeaderType, readWriteParmsOffset)); + DWord readWriteParmsSize = EmMemGet32 (0x10C00000 + offsetof (CardHeaderType, readWriteParmsSize)); + DWord readOnlyParmsOffset = EmMemGet32 (0x10C00000 + offsetof (CardHeaderType, readOnlyParmsOffset)); + DWord readOnlyParmsSize = 0x00002000; + DWord readWriteWorkingOffset = EmMemGet32 (0x10C00000 + offsetof (CardHeaderType, readWriteWorkingOffset)); + DWord readWriteWorkingSize = EmMemGet32 (0x10C00000 + offsetof (CardHeaderType, readWriteWorkingSize)); + + if (address >= 0x10000000 + readWriteParmsOffset && + address < 0x10000000 + readWriteParmsOffset + readWriteParmsSize) + { + EmMem_memset (0x10000000 + readWriteParmsOffset, kEraseValue, readWriteParmsSize); + } + else if (address >= 0x10000000 + readOnlyParmsOffset && + address < 0x10000000 + readOnlyParmsOffset + readOnlyParmsSize) + { + EmMem_memset (0x10000000 + readOnlyParmsOffset, kEraseValue, readOnlyParmsSize); + } + else if (address >= 0x10000000 + readWriteWorkingOffset && + address < 0x10000000 + readWriteWorkingOffset + readWriteWorkingSize) + { + EmMem_memset (0x10000000 + readWriteWorkingOffset, kEraseValue, readWriteWorkingSize); + } +#endif + + const unsigned long kSector1Start = 0x10C00000; + const unsigned long kSector1Size = 0x00004000; + const unsigned long kSector2Start = 0x10C04000; + const unsigned long kSector2Size = 0x00002000; + const unsigned long kSector3Start = 0x10C06000; + const unsigned long kSector3Size = 0x00002000; + const unsigned long kSector4Start = 0x10C08000; + const unsigned long kSector4Size = 0x00008000; + + CEnableFullAccess munge; + + if (address == kSector1Start) + { + EmMem_memset (kSector1Start, kEraseValue, kSector1Size); + } + else if (address == kSector2Start) + { + EmMem_memset (kSector2Start, kEraseValue, kSector2Size); + } + else if (address == kSector3Start) + { + EmMem_memset (kSector3Start, kEraseValue, kSector3Size); + } + else if (address == kSector4Start) + { + EmMem_memset (kSector4Start, kEraseValue, kSector4Size); + } + + gState = kAMDState_EraseDone; + return; + } + else if (address == FLASHBASE + 0xAAAA) + { + if (value == 0x0090) + { + gState = kAMDState_Autoselect; + return; + } + else if (value == 0x0080) + { + gEraseIsSetup = true; + gState = kAMDState_Normal; + return; + } + else if (value == 0x00A0) + { + gState = kAMDState_Program; + return; + } + } + break; + + case kAMDState_Autoselect: + // After a write of 0x0090 to 0x5555. + // A read of 0x0000 returns 0x0001 (manufacturer ID). + // A read of 0x0002 returns 0x0049 (device ID). + // A write of 0x00F0 to any address returns us to kAMDState_Normal. + // ??? What happens on other operations? + + if (value == 0x00F0) + { + gState = kAMDState_Normal; + return; + } + break; + + case kAMDState_Program: + // After a program sequence was entered. + // Accept any write operation and go to kAMDState_ProgramDone. + // ??? What happens on other operations? + + address &= gROMBank_Mask; + EmMemDoPut16 (gROM_Memory + address, value); + + gState = kAMDState_ProgramDone; + return; + + case kAMDState_EraseDone: + // After a Program or Erase operation. + // On the next read, return successful operation and return to kAMDState_Normal + // ??? What happens on other operations? + + return; + + case kAMDState_ProgramDone: + // After a Program or Erase operation. + // On the next read, return successful operation and return to kAMDState_Normal + // ??? What happens on other operations? + + return; + } + + EmBankROM::SetWord (address, value); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankFlash::SetByte +// --------------------------------------------------------------------------- + +void EmBankFlash::SetByte (emuptr address, uint32 value) +{ + EmBankROM::SetByte (address, value); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankFlash::ValidAddress +// --------------------------------------------------------------------------- + +int EmBankFlash::ValidAddress (emuptr address, uint32 size) +{ + return EmBankROM::ValidAddress (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankFlash::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmBankFlash::GetRealAddress (emuptr address) +{ + // Strip the uppermost bit of the address. + + address &= gROMBank_Mask; + + return (uint8*) &gROM_Memory[address]; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankFlash::GetMetaAddress +// --------------------------------------------------------------------------- + +uint8* EmBankFlash::GetMetaAddress (emuptr address) +{ + // Strip the uppermost bit of the address. + + address &= gROMBank_Mask; + + return (uint8*) &(gROM_MetaMemory[address]); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankFlash::AddOpcodeCycles +// --------------------------------------------------------------------------- + +void EmBankFlash::AddOpcodeCycles (void) +{ +#if (HAS_PROFILING) + CYCLE_GETWORD (WAITSTATES_ROM); +#endif +} + + +#pragma mark - + +// =========================================================================== +// ¥ Card +// =========================================================================== + +// --------------------------------------------------------------------------- +// ¥ Card::CheckCardHeader +// --------------------------------------------------------------------------- +// Determines if the memory pointed to looks like a card header. + +Bool Card::CheckCardHeader (const EmProxyCardHeaderType& cardHdr) +{ + // Make sure the stack size isn't something ludicrous. + + if (cardHdr.initStack == 0 || cardHdr.initStack > 0x000FFFFF) // 1 Meg + return false; + + // Make sure the signature is right. + + if (cardHdr.signature != sysCardSignature) + return false; + + // Make sure the header version isn't ludicrous. + + if (cardHdr.hdrVersion == 0 || cardHdr.hdrVersion > 255) // arbitrary value + return false; + + // Make sure this isn't a "RAM only" card. + + if (cardHdr.flags & memCardHeaderFlagRAMOnly) + return false; + + return true; +} + + +// --------------------------------------------------------------------------- +// ¥ Card::CheckChecksum +// --------------------------------------------------------------------------- +// Determines if the memory pointed to looks like a card header. + +Bool Card::CheckChecksum (const void* p, uint32 fileLength) +{ + EmAliasCardHeaderType<LAS> cardHdr ((void*) p); + + if (cardHdr.hdrVersion == 1) + { + static const UInt16 kDebug20 = 0x9BED; + + UInt16 checksumValue = Crc16CalcBigBlock ((/*non-const*/ void*) p, fileLength, 0); + + // Special hack for 2.0 Debug ROMs. The version with this checksum was + // bogus, so let's make sure we never load it. + + if (checksumValue == kDebug20) + { + // Throw a special error for this one. + + Errors::Throw (kError_UnsupportedROM); + } + + return true; + } + else + { + // The checksum is the cumulative checksum of the ROM image before + // the stored checksum value and the ROM image following the checksum + // value. First, calculate the first part. + + UInt32 chunkSize = cardHdr.offsetof_checksumValue (); + UInt16 checksumValue = Crc16CalcBigBlock ( + (/*non-const*/ void*) p, chunkSize, 0); + + // Now calculate the second part. + + UInt32 skipSize = chunkSize + cardHdr.checksumValue.GetSize (); + checksumValue = Crc16CalcBigBlock ( + ((char*) p) + skipSize, + cardHdr.checksumBytes - skipSize, + checksumValue); + + if (checksumValue == cardHdr.checksumValue) + { + return true; + } + } + + Errors::DoDialog (kStr_BadChecksum, kDlgFlags_OK); + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ Card::Supports328 +// --------------------------------------------------------------------------- + +Bool Card::Supports328 (const EmAliasCardHeaderType<LAS>& cardHdr) +{ + Bool dbMode = false; + + if (cardHdr.hdrVersion < 3 || (cardHdr.flags & memCardHeaderFlag328)) + { + dbMode = true; + } + + return dbMode; +} + + +// --------------------------------------------------------------------------- +// ¥ Card::SupportsEZ +// --------------------------------------------------------------------------- + +Bool Card::SupportsEZ (const EmAliasCardHeaderType<LAS>& cardHdr) +{ + Bool ezMode = false; + + if (cardHdr.hdrVersion >= 3 && (cardHdr.flags & memCardHeaderFlagEZ)) + { + ezMode = true; + } + + return ezMode; +} + + +// --------------------------------------------------------------------------- +// ¥ Card::SupportsVZ +// --------------------------------------------------------------------------- +#define memCardHeaderFlagVZ 0x0040 // ROM Supports 68VZ328 processor + +Bool Card::SupportsVZ (const EmAliasCardHeaderType<LAS>& cardHdr) +{ + Bool vzMode = false; + + if (cardHdr.hdrVersion >= 3 && (cardHdr.flags & memCardHeaderFlagVZ)) + { + vzMode = true; + } + + return vzMode; +} + + +// --------------------------------------------------------------------------- +// ¥ Card::SupportsSZ +// --------------------------------------------------------------------------- +#define memCardHeaderFlagSZ 0x0080 // ROM Supports 68SZ328 processor + +Bool Card::SupportsSZ (const EmAliasCardHeaderType<LAS>& cardHdr) +{ + Bool szMode = false; + + if (cardHdr.hdrVersion >= 3 && (cardHdr.flags & memCardHeaderFlagSZ)) + { + szMode = true; + } + + return szMode; +} diff --git a/SrcShared/Hardware/EmBankROM.h b/SrcShared/Hardware/EmBankROM.h new file mode 100644 index 0000000..f29572b --- /dev/null +++ b/SrcShared/Hardware/EmBankROM.h @@ -0,0 +1,81 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1998-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmBankROM_h +#define EmBankROM_h + +class EmStream; +class SessionFile; + +const emuptr kDefaultROMMemoryStart = 0x10C00000; + +class EmBankROM +{ + public: + static void Initialize (EmStream& hROM); + static void Reset (Bool hardwareReset); + static void Save (SessionFile&); + static void Load (SessionFile&); + static void Dispose (void); + + static void SetBankHandlers (void); + + static uint32 GetLong (emuptr address); + static uint32 GetWord (emuptr address); + static uint32 GetByte (emuptr address); + static void SetLong (emuptr address, uint32 value); + static void SetWord (emuptr address, uint32 value); + static void SetByte (emuptr address, uint32 value); + static int ValidAddress (emuptr address, uint32 size); + static uint8* GetRealAddress (emuptr address); + static uint8* GetMetaAddress (emuptr address); + static void AddOpcodeCycles (void); + + static emuptr GetMemoryStart (void) { return gROMMemoryStart; } + + private: + static void AddressError (emuptr address, long size, Bool forRead); + static void InvalidAccess (emuptr address, long size, Bool forRead); + static void LoadROM (EmStream& hROM); + + static emuptr gROMMemoryStart; +}; + + +class EmBankFlash +{ + public: + static void Initialize (void); + static void Reset (Bool hardwareReset); + static void Save (SessionFile&); + static void Load (SessionFile&); + static void Dispose (void); + + static void SetBankHandlers (void); + + static uint32 GetLong (emuptr address); + static uint32 GetWord (emuptr address); + static uint32 GetByte (emuptr address); + static void SetLong (emuptr address, uint32 value); + static void SetWord (emuptr address, uint32 value); + static void SetByte (emuptr address, uint32 value); + static int ValidAddress (emuptr address, uint32 size); + static uint8* GetRealAddress (emuptr address); + static uint8* GetMetaAddress (emuptr address); + static void AddOpcodeCycles (void); + + static emuptr GetMemoryStart (void) { return kDefaultROMMemoryStart; } +}; + + +#endif /* EmBankROM_h */ diff --git a/SrcShared/Hardware/EmBankRegs.cpp b/SrcShared/Hardware/EmBankRegs.cpp new file mode 100644 index 0000000..c03deb3 --- /dev/null +++ b/SrcShared/Hardware/EmBankRegs.cpp @@ -0,0 +1,694 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmBankRegs.h" + +#include "DebugMgr.h" // Debug::CheckStepSpy +#include "EmCPU.h" // GetPC +#include "EmCPU68K.h" // gCPU68K +#include "EmMemory.h" // gMemAccessFlags, EmMemory::IsPCInRAM +#include "EmSession.h" // GetDevice, ScheduleDeferredError +#include "ErrorHandling.h" // Errors::ReportErrHardwareRegisters +#include "MetaMemory.h" // MetaMemory::InRAMOSComponent +#include "Profiling.h" // WAITSTATES_PLD + + +/* + When emulating memory, UAE divides up the 4GB address space into + 65,536 banks, each of which is 64K long. For more details, see the + comments in EmMemory.cpp. + + For our purposes, we sometimes need to divide up each 64K bank in a + similar fashion. For instance, in order to support accesses to each + of the Dragonball registers, we'd like to assign a handler to each + byte, word, or long of memory in the bank that contains the + Dragonball registers. + + This module supports that further subdivision. EmBankRegs is a bank + handler -- just like the RAM and ROM bank handlers -- in that it is + responsible for memory accesses to one or more 64K banks of memory. + It divides up each 64K bank by making use of instances of EmRegs + subclasses. + + EmRegs subclasses are the moral equivalent of EmBanks, except on a + smaller scale. They are responsible for byte, word, and long memory + accesses to a small range of memory completely contained within a + 64K bank. + + Many such EmRegs instances can be created and installed into the + EmBankRegs object. EmBankRegs stores these EmRegs in a list. When + in comes time for the EmBanks to register which 64K banks they are + responsible for, EmBankRegs iterates over all the EmRegs objects + registered with it, and takes responsibility for each 64K bank that + contains the EmRegs object memory range (an EmRegs object can be + queried as to the memory start and length it is responsible for). + + Later, when a memory access is made to any of the 64K banks + EmBankRegs registered for, it again iterates over the EmRegs objects + installed into it, looking for one that takes responsibility for the + memory address being accessed. When it finds one, it passes off the + request to that object. Otherwise, it signals a bus error. +*/ + + +static EmAddressBank gAddressBank = +{ + EmBankRegs::GetLong, + EmBankRegs::GetWord, + EmBankRegs::GetByte, + EmBankRegs::SetLong, + EmBankRegs::SetWord, + EmBankRegs::SetByte, + EmBankRegs::GetRealAddress, + EmBankRegs::ValidAddress, + NULL, + NULL +}; + + +EmRegsList EmBankRegs::fgSubBanks; +EmRegsList EmBankRegs::fgDisabledSubBanks; + +static EmRegs* gLastSubBank; +static uint64 gLastStart; +static uint32 gLastRange; + +static void PrvSwitchBanks (EmRegsList& fromList, EmRegsList& toList, emuptr address); + +#pragma mark - + + +/*********************************************************************** + * + * FUNCTION: EmBankRegs::Initialize + * + * DESCRIPTION: Standard initialization function. Responsible for + * initializing this sub-system when a new session is + * created. Will be followed by at least one call to + * Reset or Load. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankRegs::Initialize (void) +{ + EmAssert (gSession); + gSession->GetDevice ().CreateRegs (); + + EmRegsList::iterator iter = fgSubBanks.begin (); + while (iter != fgSubBanks.end ()) + { + (*iter)->Initialize (); + ++iter; + } + + // Install the handlers for each affected bank. + + EmBankRegs::SetBankHandlers (); +} + + +/*********************************************************************** + * + * FUNCTION: EmBankRegs::Reset + * + * DESCRIPTION: Standard reset function. Sets the sub-system to a + * default state. This occurs not only on a Reset (as + * from the menu item), but also when the sub-system + * is first initialized (Reset is called after Initialize) + * as well as when the system is re-loaded from an + * insufficient session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankRegs::Reset (Bool hardwareReset) +{ + EmRegsList::iterator iter = fgSubBanks.begin (); + while (iter != fgSubBanks.end ()) + { + (*iter)->Reset (hardwareReset); + ++iter; + } +} + + +/*********************************************************************** + * + * FUNCTION: EmBankRegs::Save + * + * DESCRIPTION: Standard save function. Saves any sub-system state to + * the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankRegs::Save (SessionFile& f) +{ + EmRegsList::iterator iter = fgSubBanks.begin (); + while (iter != fgSubBanks.end ()) + { + (*iter)->Save (f); + ++iter; + } +} + + +/*********************************************************************** + * + * FUNCTION: EmBankRegs::Load + * + * DESCRIPTION: Standard load function. Loads any sub-system state + * from the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankRegs::Load (SessionFile& f) +{ + EmRegsList::iterator iter = fgSubBanks.begin (); + while (iter != fgSubBanks.end ()) + { + (*iter)->Load (f); + ++iter; + } + + gLastSubBank = NULL; +} + + +/*********************************************************************** + * + * FUNCTION: EmBankRegs::Dispose + * + * DESCRIPTION: Standard dispose function. Completely release any + * resources acquired or allocated in Initialize and/or + * Load. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankRegs::Dispose (void) +{ + EmRegsList::iterator iter = fgSubBanks.begin (); + while (iter != fgSubBanks.end ()) + { + (*iter)->Dispose (); + ++iter; + } + + while (fgSubBanks.size () > 0) + { + EmRegs* bank = fgSubBanks[0]; + fgSubBanks.erase (fgSubBanks.begin ()); + delete bank; + } + + gLastSubBank = NULL; +} + + +/*********************************************************************** + * + * FUNCTION: EmBankRegs::SetBankHandlers + * + * DESCRIPTION: Set the bank handlers UAE uses to dispatch memory + * access operations. + * + * PARAMETERS: None + * + * RETURNED: Nothing + * + ***********************************************************************/ + +void EmBankRegs::SetBankHandlers (void) +{ + EmRegsList::iterator iter = fgSubBanks.begin (); + while (iter != fgSubBanks.end ()) + { + (*iter)->SetBankHandlers (gAddressBank); + ++iter; + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankRegs::GetLong +// --------------------------------------------------------------------------- + +uint32 EmBankRegs::GetLong (emuptr address) +{ +#if (CHECK_FOR_ADDRESS_ERROR) + if ((address & 1) != 0) + { + AddressError (address, sizeof (uint32), true); + } +#endif + +#if (PREVENT_USER_REGISTER_GET) + if (gMemAccessFlags.fProtect_RegisterGet && EmMemory::IsPCInRAM () && !MetaMemory::InRAMOSComponent (gCPU->GetPC ())) + { + EmBankRegs::PreventedAccess (address, sizeof (uint32), true); + } +#endif + +#if (VALIDATE_REGISTER_GET) + if (gMemAccessFlags.fValidate_RegisterGet && !ValidAddress (address, sizeof (uint32))) + { + EmBankRegs::InvalidAccess (address, sizeof (uint32), true); + } +#endif + +#if HAS_PROFILING + CYCLE_GETLONG (WAITSTATES_PLD); +#endif + + EmRegs* bank = EmBankRegs::GetSubBank (address, sizeof (uint32)); + + if (bank) + { + return bank->GetLong (address); + } + + EmBankRegs::InvalidAccess (address, sizeof (uint32), true); + return ~0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankRegs::GetWord +// --------------------------------------------------------------------------- + +uint32 EmBankRegs::GetWord (emuptr address) +{ +#if (CHECK_FOR_ADDRESS_ERROR) + if ((address & 1) != 0) + { + AddressError (address, sizeof (uint16), true); + } +#endif + +#if (PREVENT_USER_REGISTER_GET) + if (gMemAccessFlags.fProtect_RegisterGet && EmMemory::IsPCInRAM () && !MetaMemory::InRAMOSComponent (gCPU->GetPC ())) + { + EmBankRegs::PreventedAccess (address, sizeof (uint16), true); + } +#endif + +#if (VALIDATE_REGISTER_GET) + if (gMemAccessFlags.fValidate_RegisterGet && !ValidAddress (address, sizeof (uint16))) + { + EmBankRegs::InvalidAccess (address, sizeof (uint16), true); + } +#endif + +#if HAS_PROFILING + CYCLE_GETWORD (WAITSTATES_PLD); +#endif + + EmRegs* bank = EmBankRegs::GetSubBank (address, sizeof (uint16)); + + if (bank) + { + return bank->GetWord (address); + } + + EmBankRegs::InvalidAccess (address, sizeof (uint16), true); + return ~0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankRegs::GetByte +// --------------------------------------------------------------------------- + +uint32 EmBankRegs::GetByte (emuptr address) +{ +#if (PREVENT_USER_REGISTER_GET) + if (gMemAccessFlags.fProtect_RegisterGet && EmMemory::IsPCInRAM () && !MetaMemory::InRAMOSComponent (gCPU->GetPC ())) + { + EmBankRegs::PreventedAccess (address, sizeof (uint8), true); + } +#endif + +#if (VALIDATE_REGISTER_GET) + if (gMemAccessFlags.fValidate_RegisterGet && !ValidAddress (address, sizeof (uint8))) + { + EmBankRegs::InvalidAccess (address, sizeof (uint8), true); + } +#endif + +#if HAS_PROFILING + CYCLE_GETBYTE (WAITSTATES_PLD); +#endif + + EmRegs* bank = EmBankRegs::GetSubBank (address, sizeof (uint8)); + + if (bank) + { + return bank->GetByte (address); + } + + EmBankRegs::InvalidAccess (address, sizeof (uint8), true); + return ~0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankRegs::SetLong +// --------------------------------------------------------------------------- + +void EmBankRegs::SetLong (emuptr address, uint32 value) +{ +#if PROFILE_MEMORY + gMemoryAccess[kPLDLongWrite]++; + if (address & 2) + gMemoryAccess[kPLDLongWrite2]++; +#endif + +#if (CHECK_FOR_ADDRESS_ERROR) + if ((address & 1) != 0) + { + AddressError (address, sizeof (uint32), false); + } +#endif + +#if (PREVENT_USER_REGISTER_SET) + if (gMemAccessFlags.fProtect_RegisterSet && EmMemory::IsPCInRAM () && !MetaMemory::InRAMOSComponent (gCPU->GetPC ())) + { + EmBankRegs::PreventedAccess (address, sizeof (uint32), false); + } +#endif + +#if (VALIDATE_REGISTER_SET) + if (gMemAccessFlags.fValidate_RegisterSet && !ValidAddress (address, sizeof (uint32))) + { + EmBankRegs::InvalidAccess (address, sizeof (uint32), false); + } +#endif + +#if HAS_PROFILING + CYCLE_PUTLONG (WAITSTATES_PLD); +#endif + + EmRegs* bank = EmBankRegs::GetSubBank (address, sizeof (uint32)); + + if (bank) + { + bank->SetLong (address, value); + + // See if any interesting memory locations have changed. If so, + // CheckStepSpy will report it. + + Debug::CheckStepSpy (address, sizeof (uint32)); + + return; + } + + EmBankRegs::InvalidAccess (address, sizeof (uint32), false); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankRegs::SetWord +// --------------------------------------------------------------------------- + +void EmBankRegs::SetWord (emuptr address, uint32 value) +{ +#if (CHECK_FOR_ADDRESS_ERROR) + if ((address & 1) != 0) + { + AddressError (address, sizeof (uint16), false); + } +#endif + +#if (PREVENT_USER_REGISTER_SET) + if (gMemAccessFlags.fProtect_RegisterSet && EmMemory::IsPCInRAM () && !MetaMemory::InRAMOSComponent (gCPU->GetPC ())) + { + EmBankRegs::PreventedAccess (address, sizeof (uint16), false); + } +#endif + +#if (VALIDATE_REGISTER_SET) + if (gMemAccessFlags.fValidate_RegisterSet && !ValidAddress (address, sizeof (uint16))) + { + EmBankRegs::InvalidAccess (address, sizeof (uint16), false); + } +#endif + +#if HAS_PROFILING + CYCLE_PUTWORD (WAITSTATES_PLD); +#endif + + EmRegs* bank = EmBankRegs::GetSubBank (address, sizeof (uint16)); + + if (bank) + { + bank->SetWord (address, value); + + // See if any interesting memory locations have changed. If so, + // CheckStepSpy will report it. + + Debug::CheckStepSpy (address, sizeof (uint16)); + + return; + } + + EmBankRegs::InvalidAccess (address, sizeof (uint16), false); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankRegs::SetByte +// --------------------------------------------------------------------------- + +void EmBankRegs::SetByte (emuptr address, uint32 value) +{ +#if (PREVENT_USER_REGISTER_SET) + if (gMemAccessFlags.fProtect_RegisterSet && EmMemory::IsPCInRAM () && !MetaMemory::InRAMOSComponent (gCPU->GetPC ())) + { + EmBankRegs::PreventedAccess (address, sizeof (uint8), false); + } +#endif + +#if (VALIDATE_REGISTER_SET) + if (gMemAccessFlags.fValidate_RegisterSet && !ValidAddress (address, sizeof (uint8))) + { + EmBankRegs::InvalidAccess (address, sizeof (uint8), false); + } +#endif + +#if HAS_PROFILING + CYCLE_PUTBYTE (WAITSTATES_PLD); +#endif + + EmRegs* bank = EmBankRegs::GetSubBank (address, sizeof (uint8)); + + if (bank) + { + bank->SetByte (address, value); + + // See if any interesting memory locations have changed. If so, + // CheckStepSpy will report it. + + Debug::CheckStepSpy (address, sizeof (uint8)); + + return; + } + + EmBankRegs::InvalidAccess (address, sizeof (uint8), false); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankRegs::ValidAddress +// --------------------------------------------------------------------------- + +int EmBankRegs::ValidAddress (emuptr address, uint32 size) +{ + EmRegs* bank = EmBankRegs::GetSubBank (address, size); + + if (bank) + { + return true; + } + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankRegs::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmBankRegs::GetRealAddress (emuptr address) +{ + EmRegs* bank = EmBankRegs::GetSubBank (address, 0); + + if (bank) + { + return bank->GetRealAddress (address); + } + + return NULL; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankRegs::AddSubBank +// --------------------------------------------------------------------------- + +void EmBankRegs::AddSubBank (EmRegs* bank) +{ + fgSubBanks.push_back (bank); + gLastSubBank = NULL; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankRegs::EnableSubBank +// --------------------------------------------------------------------------- + +void EmBankRegs::EnableSubBank (emuptr address) +{ + PrvSwitchBanks (fgDisabledSubBanks, fgSubBanks, address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankRegs::DisableSubBank +// --------------------------------------------------------------------------- + +void EmBankRegs::DisableSubBank (emuptr address) +{ + PrvSwitchBanks (fgSubBanks, fgDisabledSubBanks, address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankRegs::GetSubBank +// --------------------------------------------------------------------------- + +EmRegs* EmBankRegs::GetSubBank (emuptr address, long size) +{ + // Cast address to a 64-bit value in case address + size == 0x1 0000 0000. + + uint64 addrStart64 = address; + uint64 addrEnd64 = addrStart64 + size; + + // This cache is a big win. When emulating a Palm IIIc (which uses + // three EmRegs-based objects: EmRegsEZPalmIIIc, EmRegsSED1375, and + // EmRegsFrameBuffer) and doing a Gremlins run, the cache was hit + // 2,356,670 times and missed 19456 times. When doing the same run + // on a Palm V, the cache was missed only the first time. + + if (gLastSubBank && + (addrStart64 >= gLastStart) && + (addrEnd64 <= gLastStart + gLastRange)) + { + return gLastSubBank; + } + + EmRegsList::iterator iter = fgSubBanks.begin (); + while (iter != fgSubBanks.end ()) + { + uint64 start = (*iter)->GetAddressStart (); + uint32 range = (*iter)->GetAddressRange (); + + if ((addrStart64 >= start) && (addrEnd64 <= start + range)) + { + gLastSubBank = *iter; + gLastStart = start; + gLastRange = range; + + return *iter; + } + + ++iter; + } + + return NULL; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankRegs::AddressError +// --------------------------------------------------------------------------- + +void EmBankRegs::AddressError (emuptr address, long size, Bool forRead) +{ + EmAssert (gCPU68K); + gCPU68K->AddressError (address, size, forRead); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankRegs::InvalidAccess +// --------------------------------------------------------------------------- + +void EmBankRegs::InvalidAccess (emuptr address, long size, Bool forRead) +{ + EmAssert (gCPU68K); + gCPU68K->BusError (address, size, forRead); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankRegs::PreventedAccess +// --------------------------------------------------------------------------- + +void EmBankRegs::PreventedAccess (emuptr address, long size, Bool forRead) +{ + EmAssert (gSession); + gSession->ScheduleDeferredError (new EmDeferredErrHardwareRegisters (address, size, forRead)); +} + + +// --------------------------------------------------------------------------- +// ¥ PrvSwitchBanks +// --------------------------------------------------------------------------- + +void PrvSwitchBanks (EmRegsList& fromList, EmRegsList& toList, emuptr address) +{ + EmRegsList::iterator iter = fromList.begin (); + while (iter != fromList.end ()) + { + uint64 start = (*iter)->GetAddressStart (); + uint32 range = (*iter)->GetAddressRange (); + + if ((address >= start) && (address <= start + range)) + { + toList.push_back (*iter); + fromList.erase (iter); + return; + } + + ++iter; + } +} diff --git a/SrcShared/Hardware/EmBankRegs.h b/SrcShared/Hardware/EmBankRegs.h new file mode 100644 index 0000000..284fe4a --- /dev/null +++ b/SrcShared/Hardware/EmBankRegs.h @@ -0,0 +1,56 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmBankRegs_h +#define EmBankRegs_h + +#include "EmRegs.h" // EmRegsList + +class EmBankRegs +{ + public: + static void Initialize (void); + static void Reset (Bool hardwareReset); + static void Save (SessionFile&); + static void Load (SessionFile&); + static void Dispose (void); + + static void SetBankHandlers (void); + + static uint32 GetLong (emuptr address); + static uint32 GetWord (emuptr address); + static uint32 GetByte (emuptr address); + static void SetLong (emuptr address, uint32 value); + static void SetWord (emuptr address, uint32 value); + static void SetByte (emuptr address, uint32 value); + static int ValidAddress (emuptr address, uint32 size); + static uint8* GetRealAddress (emuptr address); + + static void AddSubBank (EmRegs*); + + static void EnableSubBank (emuptr address); + static void DisableSubBank (emuptr address); + + private: + static EmRegs* GetSubBank (emuptr address, long size); + static void AddressError (emuptr address, long size, Bool forRead); + static void InvalidAccess (emuptr address, long size, Bool forRead); + static void PreventedAccess (emuptr address, long size, Bool forRead); + + static EmRegsList fgSubBanks; + static EmRegsList fgDisabledSubBanks; + + friend class EmRegs; // EmBankRegs::InvalidAccess +}; + +#endif /* EmBankRegs_h */ diff --git a/SrcShared/Hardware/EmBankSRAM.cpp b/SrcShared/Hardware/EmBankSRAM.cpp new file mode 100644 index 0000000..4553131 --- /dev/null +++ b/SrcShared/Hardware/EmBankSRAM.cpp @@ -0,0 +1,640 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1998-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmBankSRAM.h" + +#include "Byteswapping.h" // ByteswapWords +#include "DebugMgr.h" // Debug::CheckStepSpy +#include "EmCPU68K.h" // gCPU68K +#include "EmMemory.h" // gRAMBank_Size, gRAM_Memory, gMemoryAccess +#include "EmScreen.h" // EmScreen::MarkDirty +#include "EmSession.h" // GetDevice +#include "MetaMemory.h" // MetaMemory:: +#include "Miscellaneous.h" // StWordSwapper +#include "Profiling.h" // WAITSTATES_SRAM +#include "SessionFile.h" // WriteRAMImage + + +// =========================================================================== +// ¥ SRAM Bank Accessors +// =========================================================================== +// These functions provide fetch and store access to the emulator's random +// access memory. + +static EmAddressBank gAddressBank = +{ + EmBankSRAM::GetLong, + EmBankSRAM::GetWord, + EmBankSRAM::GetByte, + EmBankSRAM::SetLong, + EmBankSRAM::SetWord, + EmBankSRAM::SetByte, + EmBankSRAM::GetRealAddress, + EmBankSRAM::ValidAddress, + EmBankSRAM::GetMetaAddress, + EmBankSRAM::AddOpcodeCycles +}; + + // Note: I'd've used hwrCardBase0 here, except that that + // changes on different hardware. It's 0x10000000 in some + // cases, 0x00000000 in others. + +static const emuptr kMemoryStart = 0x10000000; +static const emuptr kMemoryStartEZ = 0x00000000; +static const emuptr kMemoryStartVZ = 0x00000000; + +emuptr gMemoryStart; + +uint32 gRAMBank_Size; +uint32 gRAMBank_Mask; +uint8* gRAM_Memory; +uint8* gRAM_MetaMemory; + +#if defined (_DEBUG) + + // In debug mode, define a global variable that points to the + // Palm ROM's low-memory globals. That makes it easier to find + // out what's going wrong when something goes wrong. + // + // Keep in mind that on Windows, all values are "wordswapped" + // (each pair of bytes is byteswapped). + + LowMemHdrType* gLowMemory; + +#endif + + +static inline uint8* InlineGetMetaAddress (emuptr address) +{ + return (uint8*) &(gRAM_MetaMemory[address]); +} + +static inline void PrvScreenCheck (uint8* metaAddress, emuptr address, size_t size) +{ +#if defined (macintosh) + + if (size == 1 && !MetaMemory::IsScreenBuffer8 (metaAddress)) + return; + + if (size == 2 && !MetaMemory::IsScreenBuffer16 (metaAddress)) + return; + + if (size == 4 && !MetaMemory::IsScreenBuffer32 (metaAddress)) + return; + +#else + + if (MetaMemory::IsScreenBuffer (metaAddress, size)) + +#endif + + { + EmScreen::MarkDirty (address, size); + } +} + + +/*********************************************************************** + * + * FUNCTION: EmBankSRAM::Initialize + * + * DESCRIPTION: Standard initialization function. Responsible for + * initializing this sub-system when a new session is + * created. Will be followed by at least one call to + * Reset or Load. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankSRAM::Initialize (RAMSizeType ramSize) +{ + EmAssert (gRAM_Memory == NULL); + EmAssert (gRAM_MetaMemory == NULL); + + if (ramSize > 0) + { + gRAMBank_Size = ramSize * 1024; + gRAMBank_Mask = gRAMBank_Size - 1; + gRAM_Memory = (uint8*) Platform::AllocateMemoryClear (gRAMBank_Size); + gRAM_MetaMemory = (uint8*) Platform::AllocateMemoryClear (gRAMBank_Size); + +#if defined (_DEBUG) + // In debug mode, define a global variable that points to the + // Palm ROM's low-memory globals. That makes it easier to find + // out what's going wrong when something goes wrong. + + gLowMemory = (LowMemHdrType*) gRAM_Memory; +#endif + } + + EmAssert (gSession); + + if (gSession->GetDevice ().Supports68EZ328 ()) + { + gMemoryStart = kMemoryStartEZ; + } + else if (gSession->GetDevice ().Supports68VZ328 ()) + { + gMemoryStart = kMemoryStartVZ; + } + else + { + gMemoryStart = kMemoryStart; + } +} + + +/*********************************************************************** + * + * FUNCTION: EmBankSRAM::Reset + * + * DESCRIPTION: Standard reset function. Sets the sub-system to a + * default state. This occurs not only on a Reset (as + * from the menu item), but also when the sub-system + * is first initialized (Reset is called after Initialize) + * as well as when the system is re-loaded from an + * insufficient session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankSRAM::Reset (Bool /*hardwareReset*/) +{ + memset (gRAM_MetaMemory, 0, gRAMBank_Size); +} + + +/*********************************************************************** + * + * FUNCTION: EmBankSRAM::Save + * + * DESCRIPTION: Standard save function. Saves any sub-system state to + * the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankSRAM::Save (SessionFile& f) +{ + StWordSwapper swapper1 (gRAM_Memory, gRAMBank_Size); + f.WriteRAMImage (gRAM_Memory, gRAMBank_Size); + + StWordSwapper swapper2 (gRAM_MetaMemory, gRAMBank_Size); + f.WriteMetaRAMImage (gRAM_MetaMemory, gRAMBank_Size); +} + + +/*********************************************************************** + * + * FUNCTION: EmBankSRAM::Load + * + * DESCRIPTION: Standard load function. Loads any sub-system state + * from the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankSRAM::Load (SessionFile& f) +{ + EmAssert (gRAM_Memory); + EmAssert (gRAM_MetaMemory); + + if (f.ReadRAMImage (gRAM_Memory)) + { + ByteswapWords (gRAM_Memory, gRAMBank_Size); + } + else + { + f.SetCanReload (false); + } + + if (f.ReadMetaRAMImage (gRAM_MetaMemory)) + { + ByteswapWords (gRAM_MetaMemory, gRAMBank_Size); + } + else + { + f.SetCanReload (false); + } +} + + +/*********************************************************************** + * + * FUNCTION: EmBankSRAM::Dispose + * + * DESCRIPTION: Standard dispose function. Completely release any + * resources acquired or allocated in Initialize and/or + * Load. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void EmBankSRAM::Dispose (void) +{ + Platform::DisposeMemory (gRAM_Memory); + Platform::DisposeMemory (gRAM_MetaMemory); +} + + +/*********************************************************************** + * + * FUNCTION: EmBankSRAM::SetBankHandlers + * + * DESCRIPTION: Set the bank handlers UAE uses to dispatch memory + * access operations. + * + * PARAMETERS: None + * + * RETURNED: Nothing + * + ***********************************************************************/ + +void EmBankSRAM::SetBankHandlers (void) +{ + // Memory banks 0x1000 to <mumble> are managed by the functions + // in EmBankSRAM. <mumble> is based on the amount of RAM being emulated. + + long numBanks = EmMemBankIndex (gMemoryStart + gRAMBank_Size - 1) - + EmMemBankIndex (gMemoryStart) + 1; + Memory::InitializeBanks (gAddressBank, EmMemBankIndex (gMemoryStart), numBanks); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankSRAM::GetLong +// --------------------------------------------------------------------------- + +uint32 EmBankSRAM::GetLong (emuptr address) +{ +#if PROFILE_MEMORY + gMemoryAccess[kSRAMLongRead]++; + if (address & 2) + gMemoryAccess[kSRAMLongRead2]++; +#endif + +#if (CHECK_FOR_ADDRESS_ERROR) + if ((address & 1) != 0) + { + AddressError (address, sizeof (uint32), true); + } +#endif + +#if (PREVENT_USER_SRAM_GET) + if (gMemAccessFlags.fProtect_SRAMGet) + { + ProtectedAccess (address, sizeof (uint32), true); + } +#endif + +#if (VALIDATE_SRAM_GET) + if (gMemAccessFlags.fValidate_SRAMGet && !ValidAddress (address, sizeof (uint32))) + { + InvalidAccess (address, sizeof (uint32), true); + } +#endif + +#if HAS_PROFILING + CYCLE_GETLONG (WAITSTATES_SRAM); +#endif + + address &= gRAMBank_Mask; + + return EmMemDoGet32 (gRAM_Memory + address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankSRAM::GetWord +// --------------------------------------------------------------------------- + +uint32 EmBankSRAM::GetWord (emuptr address) +{ +#if PROFILE_MEMORY + gMemoryAccess[kSRAMWordRead]++; +#endif + +#if (CHECK_FOR_ADDRESS_ERROR) + if ((address & 1) != 0) + { + AddressError (address, sizeof (uint16), true); + } +#endif + +#if (PREVENT_USER_SRAM_GET) + if (gMemAccessFlags.fProtect_SRAMGet) + { + ProtectedAccess (address, sizeof (uint16), true); + } +#endif + +#if (VALIDATE_SRAM_GET) + if (gMemAccessFlags.fValidate_SRAMGet && !ValidAddress (address, sizeof (uint16))) + { + InvalidAccess (address, sizeof (uint16), true); + } +#endif + +#if HAS_PROFILING + CYCLE_GETWORD (WAITSTATES_SRAM); +#endif + + address &= gRAMBank_Mask; + + return EmMemDoGet16 (gRAM_Memory + address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankSRAM::GetByte +// --------------------------------------------------------------------------- + +uint32 EmBankSRAM::GetByte (emuptr address) +{ +#if PROFILE_MEMORY + gMemoryAccess[kSRAMByteRead]++; +#endif + +#if (PREVENT_USER_SRAM_GET) + if (gMemAccessFlags.fProtect_SRAMGet) + { + ProtectedAccess (address, sizeof (uint8), true); + } +#endif + +#if (VALIDATE_SRAM_GET) + if (gMemAccessFlags.fValidate_SRAMGet && !ValidAddress (address, sizeof (uint8))) + { + InvalidAccess (address, sizeof (uint8), true); + } +#endif + +#if HAS_PROFILING + CYCLE_GETBYTE (WAITSTATES_SRAM); +#endif + + address &= gRAMBank_Mask; + + return EmMemDoGet8 (gRAM_Memory + address); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankSRAM::SetLong +// --------------------------------------------------------------------------- + +void EmBankSRAM::SetLong (emuptr address, uint32 value) +{ +#if PROFILE_MEMORY + gMemoryAccess[kSRAMLongWrite]++; + if (address & 2) + gMemoryAccess[kSRAMLongWrite2]++; +#endif + +#if (CHECK_FOR_ADDRESS_ERROR) + if ((address & 1) != 0) + { + AddressError (address, sizeof (uint32), false); + } +#endif + +#if (PREVENT_USER_SRAM_SET) + if (gMemAccessFlags.fProtect_SRAMSet) + { + ProtectedAccess (address, sizeof (uint32), false); + } +#endif + +#if (VALIDATE_SRAM_SET) + if (gMemAccessFlags.fValidate_SRAMSet && !ValidAddress (address, sizeof (uint32))) + { + InvalidAccess (address, sizeof (uint32), false); + } +#endif + +#if HAS_PROFILING + CYCLE_PUTLONG (WAITSTATES_SRAM); +#endif + + emuptr phyAddress = address; + phyAddress &= gRAMBank_Mask; + + register uint8* metaAddress = InlineGetMetaAddress (phyAddress); +// META_CHECK (metaAddress, address, SetLong, uint32, false); + ::PrvScreenCheck (metaAddress, address, sizeof (uint32)); + + EmMemDoPut32 (gRAM_Memory + phyAddress, value); + + // See if any interesting memory locations have changed. If so, + // CheckStepSpy will report it. + + Debug::CheckStepSpy (address, sizeof (uint32)); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankSRAM::SetWord +// --------------------------------------------------------------------------- + +void EmBankSRAM::SetWord (emuptr address, uint32 value) +{ +#if PROFILE_MEMORY + gMemoryAccess[kSRAMWordWrite]++; +#endif + +#if (CHECK_FOR_ADDRESS_ERROR) + if ((address & 1) != 0) + { + AddressError (address, sizeof (uint16), false); + } +#endif + +#if (PREVENT_USER_SRAM_SET) + if (gMemAccessFlags.fProtect_SRAMSet) + { + ProtectedAccess (address, sizeof (uint16), false); + } +#endif + +#if (VALIDATE_SRAM_SET) + if (gMemAccessFlags.fValidate_SRAMSet && !ValidAddress (address, sizeof (uint16))) + { + InvalidAccess (address, sizeof (uint16), false); + } +#endif + +#if HAS_PROFILING + CYCLE_PUTWORD (WAITSTATES_SRAM); +#endif + + emuptr phyAddress = address; + phyAddress &= gRAMBank_Mask; + + register uint8* metaAddress = InlineGetMetaAddress (phyAddress); +// META_CHECK (metaAddress, address, SetLong, uint16, false); + ::PrvScreenCheck (metaAddress, address, sizeof (uint16)); + + EmMemDoPut16 (gRAM_Memory + phyAddress, value); + + // See if any interesting memory locations have changed. If so, + // CheckStepSpy will report it. + + Debug::CheckStepSpy (address, sizeof (uint16)); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankSRAM::SetByte +// --------------------------------------------------------------------------- + +void EmBankSRAM::SetByte (emuptr address, uint32 value) +{ +#if PROFILE_MEMORY + gMemoryAccess[kSRAMByteWrite]++; +#endif + +#if (PREVENT_USER_SRAM_SET) + if (gMemAccessFlags.fProtect_SRAMSet) + { + ProtectedAccess (address, sizeof (uint8), false); + } +#endif + +#if (VALIDATE_SRAM_SET) + if (gMemAccessFlags.fValidate_SRAMSet && !ValidAddress (address, sizeof (uint8))) + { + InvalidAccess (address, sizeof (uint8), false); + } +#endif + +#if HAS_PROFILING + CYCLE_PUTBYTE (WAITSTATES_SRAM); +#endif + + emuptr phyAddress = address; + phyAddress &= gRAMBank_Mask; + + register uint8* metaAddress = InlineGetMetaAddress (phyAddress); +// META_CHECK (metaAddress, address, SetLong, uint8, false); + ::PrvScreenCheck (metaAddress, address, sizeof (uint8)); + + EmMemDoPut8 (gRAM_Memory + phyAddress, value); + + // See if any interesting memory locations have changed. If so, + // CheckStepSpy will report it. + + Debug::CheckStepSpy (address, sizeof (uint8)); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankSRAM::ValidAddress +// --------------------------------------------------------------------------- + +int EmBankSRAM::ValidAddress (emuptr address, uint32 size) +{ + address -= gMemoryStart; + int result = (address + size) <= (gMemoryStart + gRAMBank_Size); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankSRAM::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmBankSRAM::GetRealAddress (emuptr address) +{ + // Strip the uppermost bit of the address. + + address &= gRAMBank_Mask; + + return (uint8*) &(gRAM_Memory[address]); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankSRAM::GetMetaAddress +// --------------------------------------------------------------------------- + +uint8* EmBankSRAM::GetMetaAddress (emuptr address) +{ + // Strip the uppermost bit of the address. + + address &= gRAMBank_Mask; + + return (uint8*) &(gRAM_MetaMemory[address]); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankSRAM::AddOpcodeCycles +// --------------------------------------------------------------------------- + +void EmBankSRAM::AddOpcodeCycles (void) +{ +#if (HAS_PROFILING) + CYCLE_GETWORD (WAITSTATES_SRAM); +#endif +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankSRAM::AddressError +// --------------------------------------------------------------------------- + +void EmBankSRAM::AddressError (emuptr address, long size, Bool forRead) +{ + EmAssert (gCPU68K); + gCPU68K->AddressError (address, size, forRead); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankSRAM::InvalidAccess +// --------------------------------------------------------------------------- + +void EmBankSRAM::InvalidAccess (emuptr address, long size, Bool forRead) +{ + EmAssert (gCPU68K); + gCPU68K->BusError (address, size, forRead); +} + + +// --------------------------------------------------------------------------- +// ¥ EmBankSRAM::ProtectedAccess +// --------------------------------------------------------------------------- + +void EmBankSRAM::ProtectedAccess (emuptr address, long size, Bool forRead) +{ + EmAssert (gCPU68K); + gCPU68K->BusError (address, size, forRead); +} + diff --git a/SrcShared/Hardware/EmBankSRAM.h b/SrcShared/Hardware/EmBankSRAM.h new file mode 100644 index 0000000..8f5cb23 --- /dev/null +++ b/SrcShared/Hardware/EmBankSRAM.h @@ -0,0 +1,58 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1998-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmBankSRAM_h +#define EmBankSRAM_h + +class SessionFile; + +extern emuptr gMemoryStart; + + // These are also accessed by the DRAMBank functions. +extern uint32 gRAMBank_Size; +extern uint32 gRAMBank_Mask; +extern uint8* gRAM_Memory; +extern uint8* gRAM_MetaMemory; + + +class EmBankSRAM +{ + public: + static void Initialize (RAMSizeType ramSize); + static void Reset (Bool hardwareReset); + static void Save (SessionFile&); + static void Load (SessionFile&); + static void Dispose (void); + + static void SetBankHandlers (void); + + static uint32 GetLong (emuptr address); + static uint32 GetWord (emuptr address); + static uint32 GetByte (emuptr address); + static void SetLong (emuptr address, uint32 value); + static void SetWord (emuptr address, uint32 value); + static void SetByte (emuptr address, uint32 value); + static int ValidAddress (emuptr address, uint32 size); + static uint8* GetRealAddress (emuptr address); + static uint8* GetMetaAddress (emuptr address); + static void AddOpcodeCycles (void); + + static emuptr GetMemoryStart (void) { return gMemoryStart; } + + private: + static void AddressError (emuptr address, long size, Bool forRead); + static void InvalidAccess (emuptr address, long size, Bool forRead); + static void ProtectedAccess (emuptr address, long size, Bool forRead); +}; + +#endif /* EmBankSRAM_h */ diff --git a/SrcShared/Hardware/EmCPU.cpp b/SrcShared/Hardware/EmCPU.cpp new file mode 100644 index 0000000..22c1031 --- /dev/null +++ b/SrcShared/Hardware/EmCPU.cpp @@ -0,0 +1,68 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1998-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmCPU.h" + + +EmCPU* gCPU; + + +// --------------------------------------------------------------------------- +// ¥ EmCPU::EmCPU +// --------------------------------------------------------------------------- + +EmCPU::EmCPU (EmSession* session) : + fSession (session) +{ + EmAssert (gCPU == NULL); + gCPU = this; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU::~EmCPU +// --------------------------------------------------------------------------- + +EmCPU::~EmCPU (void) +{ + EmAssert (gCPU == this); + gCPU = NULL; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU::Reset +// --------------------------------------------------------------------------- + +void EmCPU::Reset (Bool /*hardwareReset*/) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU::Save +// --------------------------------------------------------------------------- + +void EmCPU::Save (SessionFile&) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU::Load +// --------------------------------------------------------------------------- + +void EmCPU::Load (SessionFile&) +{ +} diff --git a/SrcShared/Hardware/EmCPU.h b/SrcShared/Hardware/EmCPU.h new file mode 100644 index 0000000..a884026 --- /dev/null +++ b/SrcShared/Hardware/EmCPU.h @@ -0,0 +1,69 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1998-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmCPU_h +#define EmCPU_h + +class EmSession; +class SessionFile; + +class EmCPU; +extern EmCPU* gCPU; + +class EmCPU +{ + public: + // ----------------------------------------------------------------------------- + // constructor / destructor + // ----------------------------------------------------------------------------- + + EmCPU (EmSession*); + virtual ~EmCPU (void); + + // ----------------------------------------------------------------------------- + // public methods + // ----------------------------------------------------------------------------- + + // Standard sub-system methods: + // Reset: Resets the state. Called on hardware resets or on + // calls to SysReset. Also called from constructor. + // Save: Saves the state to the given file. + // Load: Loads the state from the given file. Can assume that + // Reset has been called first. + + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + + // Execute the main CPU loop until asked to stop. + + virtual void Execute (void) = 0; + virtual void CheckAfterCycle (void) = 0; + + // Low-level access to CPU state. + + virtual emuptr GetPC (void) = 0; + virtual emuptr GetSP (void) = 0; + virtual uint32 GetRegister (int) = 0; + + virtual void SetPC (emuptr) = 0; + virtual void SetSP (emuptr) = 0; + virtual void SetRegister (int, uint32) = 0; + + virtual Bool Stopped (void) = 0; + + protected: + EmSession* fSession; +}; + +#endif /* EmCPU_h */ diff --git a/SrcShared/Hardware/EmCPU68K.cpp b/SrcShared/Hardware/EmCPU68K.cpp new file mode 100644 index 0000000..e3f00e2 --- /dev/null +++ b/SrcShared/Hardware/EmCPU68K.cpp @@ -0,0 +1,1849 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmCPU68K.h" + +#include "Byteswapping.h" // Canonical +#include "DebugMgr.h" // gExceptionAddress, gExceptionSize, gExceptionForRead +#include "EmBankROM.h" // EmBankROM::GetMemoryStart +#include "EmEventPlayback.h" // EmEventPlayback::ReplayingEvents +#include "EmHAL.h" // EmHAL::GetInterruptLevel +#include "EmMemory.h" // CEnableFullAccess +#include "EmMinimize.h" // IsOn +#include "EmSession.h" // HandleInstructionBreak +#include "Logging.h" // LogAppendMsg +#include "MetaMemory.h" // IsCPUBreak +#include "Platform.h" // GetMilliseconds +#include "SessionFile.h" // WriteDBallRegs, etc. +#include "StringData.h" // kExceptionNames +#include "UAE.h" // cpuop_func, etc. + +#include <algorithm> // find + +#if __profile__ +#include <Profiler.h> +#endif + +#if defined (macintosh) && defined (_DEBUG) && 0 + #define HAS_DEAD_MANS_SWITCH 1 +#else + #define HAS_DEAD_MANS_SWITCH 0 +#endif + +// !!! Why is this here? Shouldn't it be in Profiling.h? +#if HAS_PROFILING +perfRec perftbl[65536]; +#endif + +// Define our own flags for regs.spcflag. Please do not let these +// overlap with UAE-defined flags (should not fall below 0x0002000) +// and avoid using the high bit just for safety. + +#define SPCFLAG_END_OF_CYCLE (0x40000000) + + +// Data needed by UAE. + +int areg_byteinc[] = { 1,1,1,1,1,1,1,2 }; // (normally in newcpu.c) +int imm8_table[] = { 8,1,2,3,4,5,6,7 }; // (normally in newcpu.c) + +int movem_index1[256]; // (normally in newcpu.c) +int movem_index2[256]; // (normally in newcpu.c) +int movem_next[256]; // (normally in newcpu.c) + +cpuop_func* cpufunctbl[65536]; // (normally in newcpu.c) + +uint16 last_op_for_exception_3; /* Opcode of faulting instruction */ +emuptr last_addr_for_exception_3; /* PC at fault time */ +emuptr last_fault_for_exception_3; /* Address that generated the exception */ + +struct regstruct regs; // (normally in newcpu.c) +struct flag_struct regflags; // (normally in support.c) + + +// These variables should strictly be in a sub-system that implements +// the stack overflow checking, etc. However, for performance reasons, +// we need to expose them to UAE (see the CHECK_STACK_POINTER_ASSIGNMENT, +// et al macros), so define them here. +// +// Similar comments for the CheckKernelStack function. + +uae_u32 gStackHigh; +uae_u32 gStackLowWarn; +uae_u32 gStackLow; +uae_u32 gKernelStackOverflowed; + + +// Definitions of the stack frames used in EmCPU68K::ProcessException. + +#include "PalmPack.h" + +struct ExceptionStackFrame1 +{ + uint16 statusRegister; + uint32 programCounter; +}; + +struct ExceptionStackFrame2 +{ + uint16 functionCode; + uint32 accessAddress; + uint16 instructionRegister; + uint16 statusRegister; + uint32 programCounter; +}; + +#include "PalmPackPop.h" + + +EmCPU68K* gCPU68K; + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::Cycle +// --------------------------------------------------------------------------- + +// this guy is a macro instead of an inline function so that "counter" can +// be declared as a variable local to the calling function. The resulting +// code can be more efficient if "counter" can be cached in a register +// instead of being a static or global variable. + +#define CYCLE(sleeping) \ +{ \ + /* Don't do anything if we're in the middle of an ATrap call. We don't */ \ + /* need interrupts firing or tmr counters incrementing. */ \ + \ + EmAssert (session); \ + if (!session->IsNested ()) \ + { \ + /* Perform CPU-specific idling. */ \ + \ + EmHAL::Cycle (sleeping); \ + \ + /* Perform expensive operations. */ \ + \ + if (sleeping || ((++counter & 0x7FFF) == 0)) \ + { \ + this->CycleSlowly (sleeping); \ + } \ + } \ +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::EmCPU68K +// --------------------------------------------------------------------------- + +EmCPU68K::EmCPU68K (EmSession* session) : + EmCPU (session), + fLastTraceAddress (EmMemNULL), + fCycleCount (0), +// fExceptionHandlers (), + fHookJSR (), + fHookJSR_Ind (), + fHookLINK (), + fHookRTE (), + fHookRTS (), + fHookNewPC (), + fHookNewSP () +#if REGISTER_HISTORY + , fRegHistoryIndex (0) +// , fRegHistory () +#endif +#if EXCEPTION_HISTORY + , fExceptionHistoryIndex (0) +// , fExceptionHistory () +#endif +{ + this->InitializeUAETables (); + + EmAssert (gCPU68K == NULL); + gCPU68K = this; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::~EmCPU68K +// --------------------------------------------------------------------------- + +EmCPU68K::~EmCPU68K (void) +{ + EmAssert (gCPU68K == this); + gCPU68K = NULL; +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::Reset +// --------------------------------------------------------------------------- + +void EmCPU68K::Reset (Bool hardwareReset) +{ + fLastTraceAddress = EmMemNULL; + fCycleCount = 0; + +#if REGISTER_HISTORY + fRegHistoryIndex = 0; +#endif + +#if EXCEPTION_HISTORY + fExceptionHistoryIndex = 0; +#endif + + gStackHigh = EmMemEOM; + gStackLowWarn = EmMemNULL; + gStackLow = EmMemNULL; + gKernelStackOverflowed = false; + + if (hardwareReset) + { + // (taken from m68k_reset in newcpu.c) + + // !!! I think that we really need to emulate ROM appearing at NULL. + // That would break our dependency on EmBankROM. + + emuptr romStart = EmBankROM::GetMemoryStart (); + m68k_areg (regs, 7) = EmMemGet32 (romStart); + m68k_setpc (EmMemGet32 (romStart + 4)); + + // Note, on the 68K, the t0 and m flags must always be zero. + + regs.prefetch = 0x0000; + regs.kick_mask = 0xF80000; // (not a 68K register) + regs.s = 1; // supervisor/user state + regs.m = 0; // master/interrupt state + regs.stopped = 0; // (not a 68K register) + regs.t1 = 0; // 1 = trace on any instruction + regs.t0 = 0; // 1 = trace on change of flow + SET_ZFLG (0); + SET_XFLG (0); + SET_CFLG (0); + SET_VFLG (0); + SET_NFLG (0); + regs.spcflags = 0; // (not a 68K register) + regs.intmask = 7; // disable all interrupts + regs.vbr = regs.sfc = regs.dfc = 0; + regs.fpcr = regs.fpsr = regs.fpiar = 0; + } + + Memory::CheckNewPC (m68k_getpc ()); +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::Save +// --------------------------------------------------------------------------- + +void EmCPU68K::Save (SessionFile& f) +{ + // Write out the CPU Registers + + regstruct tempRegs; + this->GetRegisters (tempRegs); + + Canonical (tempRegs); + f.WriteDBallRegs (tempRegs); +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::Load +// --------------------------------------------------------------------------- + +void EmCPU68K::Load (SessionFile& f) +{ + // Read in the CPU Registers. + + regstruct tempRegs; + f.ReadDBallRegs (tempRegs); + + Canonical (tempRegs); + this->SetRegisters (tempRegs); +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::Execute +// --------------------------------------------------------------------------- + +void EmCPU68K::Execute (void) +{ + // This function is the bottleneck for all 68K emulation. It's + // important that it run as quickly as possible. To that end, + // fine tune register allocation as much as we can by hand. + +#if defined(__powerc) || defined(powerc) || \ + defined(__powerpc) || defined(powerpc) || \ + defined(__ppc__) || defined(ppc) + + register int counter = 0; + register cpuop_func** functable = cpufunctbl; + + register uint8** pc_p_p = ®s.pc_p; + register uint8** pc_meta_oldp_p = ®s.pc_meta_oldp; + register uint8** pc_oldp_p = ®s.pc_oldp; + register uint32* spcflags_p = ®s.spcflags; + register EmSession* session = fSession; + + #define pc_p (*pc_p_p) + #define pc_meta_oldp (*pc_meta_oldp_p) + #define pc_oldp (*pc_oldp_p) + #define spcflags (*spcflags_p) + +#elif defined(_MSC_VER) && defined(_M_IX86) + + register int counter = 0; + register cpuop_func** functable = cpufunctbl; + + #define pc_p (regs.pc_p) + #define pc_meta_oldp (regs.pc_meta_oldp) + #define pc_oldp (regs.pc_oldp) + #define spcflags (regs.spcflags) + #define session (fSession) + +#else + + register int counter = 0; + register cpuop_func** functable = cpufunctbl; + + #define pc_p (regs.pc_p) + #define pc_meta_oldp (regs.pc_meta_oldp) + #define pc_oldp (regs.pc_oldp) + #define spcflags (regs.spcflags) + #define session (fSession) + +#endif + +#if HAS_PROFILING_DEBUG + UInt64 readCyclesSaved = 0; + UInt64 writeCyclesSaved = 0; + UInt64 clockCyclesSaved = 0; +#endif + +#if HAS_DEAD_MANS_SWITCH + // ----------------------------------------------------------------------- + // Put in a little dead-man's switch. If this function doesn't exit for a + // long time, let us get into the debugger. + // ----------------------------------------------------------------------- + + uint32 deadManNow; + uint32 deadManStart = Platform::GetMilliseconds (); +#endif + + // ----------------------------------------------------------------------- + // Check for the stopped flag before entering the "execute an opcode" + // section. It could be that we last exited the loop while still in stop + // mode, and we need to wind our way back down to that spot. + // ----------------------------------------------------------------------- + + if ((spcflags & SPCFLAG_STOP) != 0) + goto StoppedLoop; + + while (1) + { +#if REGISTER_HISTORY + // ----------------------------------------------------------------------- + // Save the registers for the post-mortem, but don't record the + // instructions we generate when calling the ROM as a subroutine. We want + // those to be as transparent as possible. In particular, we don't want + // any functions that we call as part of figuring out why a problem + // occurred to knock the problem-causing registers off of our array. + // ----------------------------------------------------------------------- + +// if (!session->IsNested ()) + { + ++fRegHistoryIndex; + fRegHistory[fRegHistoryIndex & (kRegHistorySize - 1)] = regs; + } +#endif + +#if HAS_DEAD_MANS_SWITCH + // ----------------------------------------------------------------------- + // Put in a little dead-man's switch. If this function doesn't exit for a + // long time, let us get into the debugger. + // ----------------------------------------------------------------------- + + deadManNow = Platform::GetMilliseconds (); + if ((deadManNow - deadManStart) > 5000) + { + Platform::Debugger (); + } +#endif + + // ----------------------------------------------------------------------- + // See if we need to halt CPU execution at this location. We could need + // to do this for several reasons, including hitting soft breakpoints or + // needing to execute tailpatches. + // ----------------------------------------------------------------------- + + if (MetaMemory::IsCPUBreak (pc_meta_oldp + (pc_p - pc_oldp))) + { + EmAssert (session); + session->HandleInstructionBreak (); + } + +#if HAS_PROFILING + emuptr pcStart; + pcStart = m68k_getpc (); + + if (gProfilingEnabled) + { + // If detailed, log instruction here + + if (gProfilingDetailed) + { + ProfileInstructionEnter (pcStart); + } + +#if HAS_PROFILING_DEBUG + readCyclesSaved = gReadCycles; + writeCyclesSaved = gWriteCycles; + clockCyclesSaved = gClockCycles; +#endif + + // Turn gProfilingCounted on here so the opcode fetch below is counted. + + gProfilingCounted = true; + } +#endif + + // ======================================================================= + // Execute the opcode. + // ----------------------------------------------------------------------- + // Interestingly, defining "opcode" as an EmOpcode68K (which is a uint32) + // instead of a uint16 (which is all you need to hold the opcode), makes + // a big difference in performance (at least, on Intel). The former + // generates: + // + // mov edx, DWORD PTR _regs+92 + // xor eax, eax + // mov ax, WORD PTR [edx] + // push eax + // call DWORD PTR [edi+eax*4] + // + // while the latter generates: + // + // mov edx, DWORD PTR _regs+92 + // mov ax, WORD PTR [edx] + // and eax, 65535 ; 0000ffffH + // push eax + // call DWORD PTR [edi+eax*4] + // + // This results in an amazing 5% performance difference. What makes it + // even more amazing is that similar optimizations elsewhere don't seem + // to help. For instance, in EmCPU68K::Cycle, there's the expression: + // + // ((++gCounter) & 0x7FFF == 0) + // + // Changing gCounter to a uint16, or changing the expression to: + // + // ((uint16) ++gCounter) == 0) + // + // both result in the period doubling, but also in better code + // generation. However, neither gives better performance. Additionally, + // I tried like heck to optimize the call to IsCPUBreak above. I added + // a preflight check that would skip 70% of the calls to IsCPUBreak (as + // well as the calculation of the parameter passed to it) and re- + // organized the code so that branch prediction would work. However, + // none of that resulted in better performance. + // ----------------------------------------------------------------------- + EmOpcode68K opcode; + // opcode = get_iword (0); +#if HAS_PROFILING + if (gProfilingEnabled) + get_word(regs.pc + ((char*) pc_p - (char*) pc_oldp)); +#endif + opcode = do_get_mem_word (pc_p); + fCycleCount += (functable[opcode]) (opcode); + // ======================================================================= + +#if HAS_PROFILING + if (gProfilingEnabled) + { + // Add in the extra time taken to execute the instruction. + + ProfileIncrementClock (perftbl[opcode].extraCycles); + + // Detail (instruction level) profiling support + + if (gProfilingDetailed) + { + ProfileInstructionExit (pcStart); + } + +#if HAS_PROFILING_DEBUG + // Validity check on EmMemory stuff. + + Boolean tryAgain = false; + + if (perftbl[opcode].readCycles != 0xFF && + gReadCycles - readCyclesSaved != perftbl[opcode].readCycles) + { + gReadMismatch += gReadCycles - readCyclesSaved - perftbl[opcode].readCycles; + } + + if (perftbl[opcode].writeCycles != 0xFF && + gWriteCycles - writeCyclesSaved != perftbl[opcode].writeCycles) + { + gWriteMismatch += gWriteCycles - writeCyclesSaved - perftbl[opcode].writeCycles; + } + + if (tryAgain) + { + (functable[opcode]) (opcode); + } +#endif + } +#endif + + // Perform periodic tasks. + + CYCLE (false); + +StoppedLoop: + + // ----------------------------------------------------------------------- + // Handle special conditions. NB: the code reached by calling + // EmCPU68K::ExecuteSpecial used to be inline in this function. Moving it + // out (thus simplifying both EmCPU68K::Execute and EmCPU68K::ExecuteSpecial) + // sped up the CPU loop by 9%! + // ----------------------------------------------------------------------- + + if (spcflags) + { + if (this->ExecuteSpecial ()) + break; + } + +#if HAS_PROFILING + gProfilingCounted = false; +#endif + } // while (1) + +#undef pc_p +#undef pc_meta_oldp +#undef pc_oldp +#undef spcflags +#undef session +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::ExecuteSimple +// --------------------------------------------------------------------------- + +/* + This is the same loop with the following removed: + + * Comments + * Profiling code + * Profiling debugging code + * Dead mans's check on Mac + * Register history recording + + It's essentially what we get in Release/Non-profile builds. +*/ + +#if 0 + +void EmCPU68K::ExecuteSimple (void) +{ + if ((regs.spcflags & SPCFLAG_STOP) != 0) + goto StoppedLoop; + + while (1) + { + if (MetaMemory::IsCPUBreak (regs.pc_meta_oldp + (regs.pc_p - regs.pc_oldp))) + { + this->HandleInstructionBreak (); + } + + EmOpcode68K opcode; + opcode = get_iword (0); + fCycleCount += cpufunctbl[opcode] (opcode); + + this->Cycle (false); + +StoppedLoop: + if (regs.spcflags) + { + if (this->ExecuteSpecial ()) + break; + } + } +} + +#endif + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::ExecuteSpecial +// --------------------------------------------------------------------------- + +Bool EmCPU68K::ExecuteSpecial (void) +{ + // If we're making subroutine calls, then all we process are requests + // to break from the CPU loop. We don't want interrupts, tracing, etc. + // getting in the way. + + EmAssert (fSession); + if (fSession->IsNested () != 0) + { + return this->CheckForBreak (); + } + + // Check for Reset first. If this is set, don't do anything else. + + if ((regs.spcflags & SPCFLAG_END_OF_CYCLE)) + { + if (fSession->ExecuteSpecial (true)) + return true; + } + + // Execute UAE spcflags-handling code (from do_specialties in newcpu.c). + + // If we're tracing, execute the trace vector. + // + // The check for SPCFLAG_STOP was added in Poser. It's needed + // if we're re-entering ExecuteStopped loop on the Mac after + // exiting in order to handle events. + + if ((regs.spcflags & SPCFLAG_DOTRACE) && !(regs.spcflags & SPCFLAG_STOP)) + { + this->ProcessException (kException_Trace); + } + + if (regs.spcflags & SPCFLAG_STOP) + { + if (this->ExecuteStoppedLoop ()) + { + regs.spcflags &= ~SPCFLAG_BRK; + return true; + } + } + + // Do trace-mode stuff (do_trace from newcpu.c does more, + // but it's only needed for CPU_LEVEL > 0) + + if (regs.spcflags & SPCFLAG_TRACE) + { + if (regs.t1) + { + fLastTraceAddress = m68k_getpc (); + regs.spcflags &= ~SPCFLAG_TRACE; + regs.spcflags |= SPCFLAG_DOTRACE; + } + } + + if ((regs.spcflags & SPCFLAG_DOINT) && !gKernelStackOverflowed) + { + int32 interruptLevel = EmHAL::GetInterruptLevel (); + regs.spcflags &= ~SPCFLAG_DOINT; // was ~(SPCFLAG_INT | SPCFLAG_DOINT) in Greg and Craig, but the latest UAE has this + if ((interruptLevel != -1) && (interruptLevel > regs.intmask)) + { + this->ProcessInterrupt (interruptLevel); + regs.stopped = 0; + } + } + + if (regs.spcflags & SPCFLAG_INT) + { + regs.spcflags &= ~SPCFLAG_INT; + regs.spcflags |= SPCFLAG_DOINT; + } + + // Check for Poser end-of-cycle operations. This is inserted + // before the standard UAE check of the SPCFLAG_BRK flag. + + if ((regs.spcflags & SPCFLAG_END_OF_CYCLE)) + { + regs.spcflags &= ~SPCFLAG_END_OF_CYCLE; + + if (fSession->ExecuteSpecial (false)) + return true; + } + + return this->CheckForBreak (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::ExecuteStoppedLoop +// --------------------------------------------------------------------------- + +Bool EmCPU68K::ExecuteStoppedLoop (void) +{ + register EmSession* session = fSession; + + EmAssert (session); + EmAssert (!session->IsNested ()); + EmAssert (regs.intmask < 7); + + // If we're running Gremlins and the device goes to sleep (as opposed + // to just dozing), pretend the user clicked on the Power button). + + if (EmHAL::GetAsleep () && !session->HasButtonEvent ()) + { + // Turns Hordes off for a moment, as pen events are rejected + // when it's running! + + Bool hordesWasOn = false; + Bool playbackWasOn = false; + Bool minimizationWasOn = false; + + if (Hordes::IsOn ()) + { + Hordes::TurnOn (false); + hordesWasOn = true; + } + + if (EmEventPlayback::ReplayingEvents ()) + { + EmEventPlayback::ReplayEvents (false); + playbackWasOn = true; + } + + if (EmMinimize::IsOn ()) + { + EmMinimize::TurnOn (false); + minimizationWasOn = true; + } + + /* + When posting the button down event for the Power button, include + a flag that causes the event to be posted to the hardware NOW. + Normally, EmSession employs a throttling mechanism that prevents + button events from showing up in the hardware too quickly. This + throttling allows the time for the OS to wakeup and respond to + the hardware interrupt. + + However, the throttling also leads to an incredibly subtle bug + if it's used unconditionally. Consider the following sequence + of events: + + * Gremlins creates a vchrAutoOff event + * The system responds to it and goes to sleep. + * Poser notices the device is asleep while running a Gremlin, + and posts Power button down/up events. + * It's been more than 100msec since the last button event, so + the button event is given to the hardware immediately. + * The system wakes up, notices that the Power key is down, and + sets the flag that says it should stay awake. + * Gremlins starts posting events again. + * Within 100msecs, Gremlins generates another vchrAutoOff event. + * The devices goes to sleep again. Somewhere in the process of + dealing with the vchrAutoOff event, the Power-button up event + is popped off and handled. + * Poser posts Power button down/up events again. + * Because it's been within 100msecs of the last time a button + event was popped off the queue, these events are held in the + queue for a while. + * An RTC interrupt occurs. + * The device wakes up, notices that the Power is not down, and + does NOT set the bit that says to stay awake. + * The devices goes back to sleep after processing the RTC + interrupt. Note that there are still two Power-button events + in EmSession's button queue. + * Poser notices that the device is off, and posts *another* + pair of Power-button down/up events. + * At this point, Poser is in a weird state, where there are too + many events in the queue. In fact, the situation will get + worse, with more and more events piling up and the system + deals with turning itself on and off in response to the pending + button events. The result is that the user sees the device + flashing on and off. + + In order to avoid this problem, have the Power button posted to + the hardware registers immediately, before an interrupt can get + in the way. + + Note that there is another potential bug here. We avoid it for + now, but be careful not to introduce it later. By passing "true" + to PostButtonEvent, we can make the button event available to + the hardware immediately. However, the event is not forced onto + the hardware. Instead, the hardware polls for any pending button + events at some reasonable rate. That is, even if EmSession is + prepared to say that there is a pending button event, EmCPU may + not pick up on it until some time later based on its checking + frequency. + + We avoid this problem for now because the hardware checks for + button events in EmHAL::CycleSlowly, which is called + unconditionally when the processor is moved out of the "stopped" + state. + */ + + if (hordesWasOn || playbackWasOn || minimizationWasOn) + { + EmButtonEvent event (kElement_PowerButton, true); + session->PostButtonEvent (event, true); + + event.fButtonIsDown = false; + session->PostButtonEvent (event); + } + + if (hordesWasOn) + { + Hordes::TurnOn (true); + } + + if (playbackWasOn) + { + EmEventPlayback::ReplayEvents (true); + } + + if (minimizationWasOn) + { + EmMinimize::TurnOn (true); + } + } + + int counter = 0; + + // While the CPU is stopped (because a STOP instruction was + // executed) do some idle tasks. + +#if HAS_DEAD_MANS_SWITCH + // ----------------------------------------------------------------------- + // Put in a little dead-man's switch. If this function doesn't + // exit for a long time, let us get into the debugger. + // ----------------------------------------------------------------------- + + uint32 deadManStart = Platform::GetMilliseconds (); +#endif + + do { +#if HAS_DEAD_MANS_SWITCH + // ----------------------------------------------------------------------- + // Put in a little dead-man's switch. If this function doesn't + // exit for a long time, let us get into the debugger. + // ----------------------------------------------------------------------- + + uint32 deadManNow = Platform::GetMilliseconds (); + if ((deadManNow - deadManStart) > 5000) + { + Platform::Debugger (); + } +#endif + + // ----------------------------------------------------------------------- + // Slow down processing so that the timer used + // to increment the tickcount doesn't run too quickly. + // ----------------------------------------------------------------------- + +#if __profile__ + short oldStatus = ProfilerGetStatus (); + ProfilerSetStatus (false); +#endif + + Platform::Delay (); + +#if __profile__ + ProfilerSetStatus (oldStatus); +#endif + + // Perform periodic tasks. + + CYCLE (true); + + // Process an interrupt (see if it's time to wake up). + + if (regs.spcflags & (SPCFLAG_INT | SPCFLAG_DOINT)) + { + int32 interruptLevel = EmHAL::GetInterruptLevel (); + + regs.spcflags &= ~(SPCFLAG_INT | SPCFLAG_DOINT); + + if ((interruptLevel != -1) && (interruptLevel > regs.intmask)) + { + this->ProcessInterrupt (interruptLevel); + regs.stopped = 0; + regs.spcflags &= ~SPCFLAG_STOP; + } + } + + if (this->CheckForBreak ()) + { + return true; + } + } while (regs.spcflags & SPCFLAG_STOP); + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::CycleSlowly +// --------------------------------------------------------------------------- + +void EmCPU68K::CycleSlowly (Bool sleeping) +{ + EmHAL::CycleSlowly (sleeping); + + // Do some platform-specific stuff. + + Platform::CycleSlowly (); + +#if HAS_OMNI_THREAD + // Check to see if some external thread has asked us to quit. + + EmAssert (fSession); + omni_mutex_lock lock (fSession->fSharedLock); + + if (fSession->fSuspendState.fAllCounters) + { + this->CheckAfterCycle (); + } +#endif +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::CheckAfterCycle +// --------------------------------------------------------------------------- + +void EmCPU68K::CheckAfterCycle (void) +{ + regs.spcflags |= SPCFLAG_END_OF_CYCLE; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::GetPC +// --------------------------------------------------------------------------- + +emuptr EmCPU68K::GetPC (void) +{ +// return this->GetRegister (e68KRegID_PC); + return m68k_getpc (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::GetSP +// --------------------------------------------------------------------------- + +emuptr EmCPU68K::GetSP (void) +{ +// return this->GetRegister (e68KRegID_SSP); + return m68k_areg (regs, 7); +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::GetRegister +// --------------------------------------------------------------------------- + +uint32 EmCPU68K::GetRegister (int index) +{ + uint32 result = 0; + + switch (index) + { + case e68KRegID_D0: result = m68k_dreg (regs, 0); break; + case e68KRegID_D1: result = m68k_dreg (regs, 1); break; + case e68KRegID_D2: result = m68k_dreg (regs, 2); break; + case e68KRegID_D3: result = m68k_dreg (regs, 3); break; + case e68KRegID_D4: result = m68k_dreg (regs, 4); break; + case e68KRegID_D5: result = m68k_dreg (regs, 5); break; + case e68KRegID_D6: result = m68k_dreg (regs, 6); break; + case e68KRegID_D7: result = m68k_dreg (regs, 7); break; + case e68KRegID_A0: result = m68k_areg (regs, 0); break; + case e68KRegID_A1: result = m68k_areg (regs, 1); break; + case e68KRegID_A2: result = m68k_areg (regs, 2); break; + case e68KRegID_A3: result = m68k_areg (regs, 3); break; + case e68KRegID_A4: result = m68k_areg (regs, 4); break; + case e68KRegID_A5: result = m68k_areg (regs, 5); break; + case e68KRegID_A6: result = m68k_areg (regs, 6); break; + case e68KRegID_USP: result = m68k_areg (regs, 7); break; + case e68KRegID_SSP: result = m68k_areg (regs, 7); break; + case e68KRegID_PC: result = m68k_getpc (); break; + case e68KRegID_SR: + this->UpdateSRFromRegisters (); + result = regs.sr; + break; + + default: + EmAssert (false); + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::SetPC +// --------------------------------------------------------------------------- + +void EmCPU68K::SetPC (emuptr newPC) +{ + this->SetRegister (e68KRegID_PC, newPC); +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::SetSP +// --------------------------------------------------------------------------- + +void EmCPU68K::SetSP (emuptr newPC) +{ + this->SetRegister (e68KRegID_SSP, newPC); +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::SetRegister +// --------------------------------------------------------------------------- + +void EmCPU68K::SetRegister (int index, uint32 val) +{ + switch (index) + { + case e68KRegID_D0: m68k_dreg (regs, 0) = val; break; + case e68KRegID_D1: m68k_dreg (regs, 1) = val; break; + case e68KRegID_D2: m68k_dreg (regs, 2) = val; break; + case e68KRegID_D3: m68k_dreg (regs, 3) = val; break; + case e68KRegID_D4: m68k_dreg (regs, 4) = val; break; + case e68KRegID_D5: m68k_dreg (regs, 5) = val; break; + case e68KRegID_D6: m68k_dreg (regs, 6) = val; break; + case e68KRegID_D7: m68k_dreg (regs, 7) = val; break; + case e68KRegID_A0: m68k_areg (regs, 0) = val; break; + case e68KRegID_A1: m68k_areg (regs, 1) = val; break; + case e68KRegID_A2: m68k_areg (regs, 2) = val; break; + case e68KRegID_A3: m68k_areg (regs, 3) = val; break; + case e68KRegID_A4: m68k_areg (regs, 4) = val; break; + case e68KRegID_A5: m68k_areg (regs, 5) = val; break; + case e68KRegID_A6: m68k_areg (regs, 6) = val; break; + case e68KRegID_USP: m68k_areg (regs, 7) = val; break; + case e68KRegID_SSP: m68k_areg (regs, 7) = val; break; + case e68KRegID_PC: m68k_setpc (val); break; + case e68KRegID_SR: + regs.sr = val; + this->UpdateRegistersFromSR (); + break; + + default: + EmAssert (false); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::Stopped +// --------------------------------------------------------------------------- +// Return whether or not the CPU itself is halted. This is seperate from +// whether or not the session (that is, the thread emulating the CPU) is +// halted. + +Bool EmCPU68K::Stopped (void) +{ + return regs.stopped; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::CheckForBreak +// --------------------------------------------------------------------------- +// Check to see if the conditions tell us to break from the CPU Execute loop. + +Bool EmCPU68K::CheckForBreak (void) +{ + if ((regs.spcflags & SPCFLAG_BRK) != 0) + { + regs.spcflags &= ~SPCFLAG_BRK; + return true; + } + + EmAssert (fSession); + return fSession->CheckForBreak (); +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::ProcessInterrupt +// --------------------------------------------------------------------------- + +void EmCPU68K::ProcessInterrupt (int32 interrupt) +{ + this->ProcessException ((ExceptionNumber) (EmHAL::GetInterruptBase () + interrupt)); + + regs.intmask = interrupt; + regs.spcflags |= SPCFLAG_INT; // Check for higher-level interrupts +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::ProcessException +// --------------------------------------------------------------------------- + +void EmCPU68K::ProcessException (ExceptionNumber exception) +{ + // Make sure the Status Register is up-to-date. + + this->UpdateSRFromRegisters (); + +#if EXCEPTION_HISTORY + // Save the exception for the post-mortem + + fExceptionHistoryIndex++; + + long index = fExceptionHistoryIndex & (kExceptionHistorySize - 1); + fExceptionHistory[index].name = kExceptionNames[exception]; + + fExceptionHistory[index].pc = m68k_getpc (); + fExceptionHistory[index].sp = m68k_areg (regs, 7); +#endif + +#if HAS_PROFILING + // Don't count cycles spent in exception handlers against functions. + + // Get and remember the current PC here. This is important to make the + // profiling routines come out right. If Poser decides to completely + // handle the exception and profiling is on, then the handler will return + // true (setting "handled" to true), and adjust the program counter. + // Since "handled" is true, Poser calls ProfileInterruptExit, this time + // with the current PC. ProfileInterruptExit sees the adjusted PC, and + // determines that the funky TRAP $F thing is going on, resulting in it + // pushing a new function-call record on its stack. However, since Poser + // has completely handled the interrupt, we don't want that to happen. + // All we want is to remove the entry recorded by ProfileInterruptEnter. + // By saving the current PC value here and passing it to ProfileInterruptExit + // later, we achieve that affect. ProfileInterruptExit will record an + // "interrupt mismatch", but I can live with that... + + emuptr curpc = m68k_getpc (); + + if (gProfilingEnabled) + { + ProfileInterruptEnter (exception, curpc); + } +#endif + + // Let any custom exception handler have a go at it. If it returns + // true, it handled it completely, and we don't have anything else to do. + // + // By "handled it completely", we could mean one of two things. (1) + // that Poser completely replaced the system function and the ROM + // function was skipped, or (2) Poser dealt with the trap dispatch + // process, setting the PC to the function entry point. + // + // If profiling is on, (2) never occurs because we want to profile the + // trap dispatcher itself. Therefore, only (1) is possible. + + Bool handled = false; + Hook68KExceptionList& fns = fExceptionHandlers[exception]; + Hook68KExceptionList::iterator iter = fns.begin (); + while (iter != fns.end ()) + { + if ((*iter) (exception)) + { + handled = true; + } + + ++iter; + } + + if (handled) + { +#if HAS_PROFILING + if (gProfilingEnabled) + { + ProfileInterruptExit (curpc); + } +#endif + return; + } + + // The following is vaguely modelled after Exception() from newcpu.c + // (The call to MakeSR appears at the start of this method). + + // If not in supervisor mode, set the usp, restore A7 from the isp, + // and transfer to supervisor mode. + + if (!regs.s) + { + regs.usp = m68k_areg (regs, 7); + m68k_areg (regs, 7) = regs.isp; + regs.s = 1; + } + + // Set up the stack frame. + // !!! If we're handling a trace exception, I think that fLastTraceAddress + // comes into play here instead of m68k_getpc. + // !!! Manage this with EmPalmStructs... + + if (exception == kException_BusErr || exception == kException_AddressErr) + { + COMPILE_TIME_ASSERT (sizeof (ExceptionStackFrame2) == 14); + m68k_areg (regs, 7) -= sizeof (ExceptionStackFrame2); + CHECK_STACK_POINTER_DECREMENT (); + + emuptr frame = m68k_areg (regs, 7); + + // Eh...Palm OS doesn't use these 3 anyway... + EmMemPut16 (frame + offsetof (ExceptionStackFrame2, functionCode), 0); + EmMemPut32 (frame + offsetof (ExceptionStackFrame2, accessAddress), 0); + EmMemPut16 (frame + offsetof (ExceptionStackFrame2, instructionRegister), 0); + + EmMemPut16 (frame + offsetof (ExceptionStackFrame2, statusRegister), regs.sr); + EmMemPut32 (frame + offsetof (ExceptionStackFrame2, programCounter), m68k_getpc ()); + } + else + { + COMPILE_TIME_ASSERT (sizeof (ExceptionStackFrame1) == 6); + m68k_areg (regs, 7) -= sizeof (ExceptionStackFrame1); + CHECK_STACK_POINTER_DECREMENT (); + + emuptr frame = m68k_areg (regs, 7); + + EmMemPut16 (frame + offsetof (ExceptionStackFrame1, statusRegister), regs.sr); + EmMemPut32 (frame + offsetof (ExceptionStackFrame1, programCounter), m68k_getpc ()); + } + + emuptr newpc; + { + CEnableFullAccess munge; // Remove blocks on memory access. + + // Get the exception handler address. + newpc = EmMemGet32 (regs.vbr + 4 * exception); + } + + // Check the exception handler address and jam it into the PC. + + this->CheckNewPC (newpc); + m68k_setpc (newpc); + + // Turn tracing off. + + regs.t1 = regs.t0 = regs.m = 0; + regs.spcflags &= ~(SPCFLAG_TRACE | SPCFLAG_DOTRACE); +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::ProcessIllegalInstruction +// --------------------------------------------------------------------------- + +void EmCPU68K::ProcessIllegalInstruction (EmOpcode68K opcode) +{ + // This function is loosely based on op_illg in newcpu.c + + // Process an FTrap. + + if ((opcode & 0xF000) == 0xF000) + { + this->ProcessException (kException_FTrap); + } + + // Process an ATrap. + + else if ((opcode & 0xF000) == 0xA000) + { + this->ProcessException (kException_ATrap); + } + + // Process all other opcodes. + + else + { + this->ProcessException (kException_IllegalInstr); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::ProcessJSR +// --------------------------------------------------------------------------- + +int EmCPU68K::ProcessJSR (emuptr oldPC, emuptr dest) +{ + int handled = false; + + Hook68KJSRList::iterator iter = fHookJSR.begin (); + while (iter != fHookJSR.end ()) + { + if ((*iter) (oldPC, dest)) + { + handled = true; + } + + ++iter; + } + + return handled; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::ProcessJSR_Ind +// --------------------------------------------------------------------------- + +int EmCPU68K::ProcessJSR_Ind (emuptr oldPC, emuptr dest) +{ + int handled = false; + + Hook68KJSR_IndList::iterator iter = fHookJSR_Ind.begin (); + while (iter != fHookJSR_Ind.end ()) + { + if ((*iter) (oldPC, dest)) + { + handled = true; + } + + ++iter; + } + + return handled; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::ProcessLINK +// --------------------------------------------------------------------------- + +void EmCPU68K::ProcessLINK (int linkSize) +{ + Hook68KLINKList::iterator iter = fHookLINK.begin (); + while (iter != fHookLINK.end ()) + { + (*iter) (linkSize); + + ++iter; + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::ProcessRTE +// --------------------------------------------------------------------------- + +int EmCPU68K::ProcessRTE (emuptr dest) +{ + int handled = false; + + Hook68KRTEList::iterator iter = fHookRTE.begin (); + while (iter != fHookRTE.end ()) + { + if ((*iter) (dest)) + { + handled = true; + } + + ++iter; + } + + return handled; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::ProcessRTS +// --------------------------------------------------------------------------- + +int EmCPU68K::ProcessRTS (emuptr dest) +{ + int handled = false; + + Hook68KRTSList::iterator iter = fHookRTS.begin (); + while (iter != fHookRTS.end ()) + { + if ((*iter) (dest)) + { + handled = true; + } + + ++iter; + } + + return handled; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::CheckNewPC +// --------------------------------------------------------------------------- + +void EmCPU68K::CheckNewPC (emuptr dest) +{ + Hook68KNewPCList::iterator iter = fHookNewPC.begin (); + while (iter != fHookNewPC.end ()) + { + (*iter) (dest); + + ++iter; + } + + EmMemory::CheckNewPC (dest); +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::CheckNewSP +// --------------------------------------------------------------------------- + +void EmCPU68K::CheckNewSP (EmStackChangeType type) +{ + Hook68KNewSPList::iterator iter = fHookNewSP.begin (); + while (iter != fHookNewSP.end ()) + { + (*iter) (type); + + ++iter; + } +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::InstallHookException +// ¥ EmCPU68K::InstallHookJSR +// ¥ EmCPU68K::InstallHookJSR_Ind +// ¥ EmCPU68K::InstallHookLINK +// ¥ EmCPU68K::InstallHookRTE +// ¥ EmCPU68K::InstallHookRTS +// ¥ EmCPU68K::InstallHookNewPC +// ¥ EmCPU68K::InstallHookNewSP +// --------------------------------------------------------------------------- + +void EmCPU68K::InstallHookException (ExceptionNumber exceptionNumber, + Hook68KException fn) +{ + fExceptionHandlers[exceptionNumber].push_back (fn); +} + + +void EmCPU68K::InstallHookJSR (Hook68KJSR fn) +{ + fHookJSR.push_back (fn); +} + + +void EmCPU68K::InstallHookJSR_Ind (Hook68KJSR_Ind fn) +{ + fHookJSR_Ind.push_back (fn); +} + + +void EmCPU68K::InstallHookLINK (Hook68KLINK fn) +{ + fHookLINK.push_back (fn); +} + + +void EmCPU68K::InstallHookRTE (Hook68KRTE fn) +{ + fHookRTE.push_back (fn); +} + + +void EmCPU68K::InstallHookRTS (Hook68KRTS fn) +{ + fHookRTS.push_back (fn); +} + + +void EmCPU68K::InstallHookNewPC (Hook68KNewPC fn) +{ + fHookNewPC.push_back (fn); +} + + +void EmCPU68K::InstallHookNewSP (Hook68KNewSP fn) +{ + fHookNewSP.push_back (fn); +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::RemoveHookException +// ¥ EmCPU68K::RemoveHookJSR +// ¥ EmCPU68K::RemoveHookJSR_Ind +// ¥ EmCPU68K::RemoveHookLINK +// ¥ EmCPU68K::RemoveHookRTE +// ¥ EmCPU68K::RemoveHookRTS +// ¥ EmCPU68K::RemoveHookNewPC +// ¥ EmCPU68K::RemoveHookNewSP +// --------------------------------------------------------------------------- + +void EmCPU68K::RemoveHookException (ExceptionNumber exceptionNumber, + Hook68KException fn) +{ + Hook68KExceptionList::iterator iter = find ( + fExceptionHandlers[exceptionNumber].begin (), + fExceptionHandlers[exceptionNumber].end (), + fn); + + if (iter != fExceptionHandlers[exceptionNumber].end ()) + { + fExceptionHandlers[exceptionNumber].erase (iter); + } +} + + +void EmCPU68K::RemoveHookJSR (Hook68KJSR fn) +{ + Hook68KJSRList::iterator iter = find (fHookJSR.begin (), fHookJSR.end (), fn); + + if (iter != fHookJSR.end ()) + { + fHookJSR.erase (iter); + } +} + + +void EmCPU68K::RemoveHookJSR_Ind (Hook68KJSR_Ind fn) +{ + Hook68KJSR_IndList::iterator iter = find (fHookJSR_Ind.begin (), fHookJSR_Ind.end (), fn); + + if (iter != fHookJSR_Ind.end ()) + { + fHookJSR_Ind.erase (iter); + } +} + + +void EmCPU68K::RemoveHookLINK (Hook68KLINK fn) +{ + Hook68KLINKList::iterator iter = find (fHookLINK.begin (), fHookLINK.end (), fn); + + if (iter != fHookLINK.end ()) + { + fHookLINK.erase (iter); + } +} + + +void EmCPU68K::RemoveHookRTE (Hook68KRTE fn) +{ + Hook68KRTEList::iterator iter = find (fHookRTE.begin (), fHookRTE.end (), fn); + + if (iter != fHookRTE.end ()) + { + fHookRTE.erase (iter); + } +} + + +void EmCPU68K::RemoveHookRTS (Hook68KRTS fn) +{ + Hook68KRTSList::iterator iter = find (fHookRTS.begin (), fHookRTS.end (), fn); + + if (iter != fHookRTS.end ()) + { + fHookRTS.erase (iter); + } +} + + +void EmCPU68K::RemoveHookNewPC (Hook68KNewPC fn) +{ + Hook68KNewPCList::iterator iter = find (fHookNewPC.begin (), fHookNewPC.end (), fn); + + if (iter != fHookNewPC.end ()) + { + fHookNewPC.erase (iter); + } +} + + +void EmCPU68K::RemoveHookNewSP (Hook68KNewSP fn) +{ + Hook68KNewSPList::iterator iter = find (fHookNewSP.begin (), fHookNewSP.end (), fn); + + if (iter != fHookNewSP.end ()) + { + fHookNewSP.erase (iter); + } +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::GetRegisters +// --------------------------------------------------------------------------- + +void EmCPU68K::GetRegisters (regstruct& registers) +{ + this->UpdateSRFromRegisters (); + + registers = regs; + registers.pc = m68k_getpc (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::SetRegisters +// --------------------------------------------------------------------------- + +void EmCPU68K::SetRegisters (regstruct& registers) +{ + regs = registers; + this->UpdateRegistersFromSR (); + + m68k_setpc (registers.pc); + + this->CheckNewSP (kStackPointerChanged); +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::UpdateSRFromRegisters +// --------------------------------------------------------------------------- +// Create a 16-bit status register value from the broken out fields. In +// general, we keep the various fields separate for speed of access. However, +// there are times when we need the packed 16-bit field. +// +// This function is called any time the 16-bit representation of the SR is +// needed: +// +// on EORSR +// on ORSR +// on ANDSR +// on MVSR2 +// on MV2SR +// on RTR +// when processing exceptions (EmCPU68K::ProcessException) +// +// SystemPacket::GetRegs +// EmCPU68K::GetRegisters + +void EmCPU68K::UpdateSRFromRegisters (void) +{ + // (taken from MakeSR in newcpu.c) + + regs.sr = ((regs.t1 << 15) | (regs.t0 << 14) + | (regs.s << 13) | (regs.m << 12) | (regs.intmask << 8) + | (GET_XFLG << 4) | (GET_NFLG << 3) | (GET_ZFLG << 2) | (GET_VFLG << 1) + | GET_CFLG); +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::UpdateRegistersFromSR +// --------------------------------------------------------------------------- +// Break out all of the fields from the 16-bit status register into their own +// separate variables. +// +// This function is called any time the SR has been update and needs to be +// re-expanded: +// +// on EORSR +// on ORSR +// on ANDSR +// on MV2SR +// on STOP +// on RTE +// on RTR +// +// SystemPacket::SetRegs +// EmCPU68K::SetRegisters + +void EmCPU68K::UpdateRegistersFromSR (void) +{ + // (taken from MakeFromSR in newcpu.c) + +// int oldm = regs.m; + int olds = regs.s; + + regs.t1 = (regs.sr >> 15) & 1; + regs.t0 = (regs.sr >> 14) & 1; + regs.s = (regs.sr >> 13) & 1; + regs.m = (regs.sr >> 12) & 1; + regs.intmask = (regs.sr >> 8) & 7; + + SET_XFLG ((regs.sr >> 4) & 1); + SET_NFLG ((regs.sr >> 3) & 1); + SET_ZFLG ((regs.sr >> 2) & 1); + SET_VFLG ((regs.sr >> 1) & 1); + SET_CFLG (regs.sr & 1); + + if (olds != regs.s) + { + if (olds) + { + regs.isp = m68k_areg(regs, 7); + m68k_areg(regs, 7) = regs.usp; + } + else + { + regs.usp = m68k_areg(regs, 7); + m68k_areg(regs, 7) = regs.isp; + } + } + + regs.spcflags |= SPCFLAG_INT; + + if (regs.t1 || regs.t0) + { + regs.spcflags |= SPCFLAG_TRACE; + } + else + { + regs.spcflags &= ~(SPCFLAG_TRACE | SPCFLAG_DOTRACE); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::GetCycleCount +// --------------------------------------------------------------------------- + +uint32 EmCPU68K::GetCycleCount (void) +{ + return fCycleCount; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::BusError +// --------------------------------------------------------------------------- + +void EmCPU68K::BusError (emuptr address, long size, Bool forRead) +{ + gExceptionAddress = address; + gExceptionSize = size; + gExceptionForRead = forRead; + + this->ProcessException (kException_BusErr); + + EmAssert (false); // Should never get this far. +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::AddressError +// --------------------------------------------------------------------------- + +void EmCPU68K::AddressError (emuptr address, long size, Bool forRead) +{ + gExceptionAddress = address; + gExceptionSize = size; + gExceptionForRead = forRead; + + this->ProcessException (kException_AddressErr); + + EmAssert (false); // Should never get this far. +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// ¥ EmCPU68K::InitializeUAETables +// --------------------------------------------------------------------------- + +void EmCPU68K::InitializeUAETables (void) +{ + static int initialized; + + // All of the stuff in this function needs to be done only once; + // it doesn't need to be executed every time we create a new CPU. + + if (initialized) + return; + + initialized = true; + + // Initialize some CPU-related tables + // (This initialization code is taken from init_m68k in newcpu.c) + + int i, j; + + for (i = 0 ; i < 256 ; i++) + { + for (j = 0 ; j < 8 ; j++) + { + if (i & (1 << j)) + { + break; + } + } + + movem_index1[i] = j; + movem_index2[i] = 7-j; + movem_next[i] = i & (~(1 << j)); + } + + read_table68k (); + do_merges (); + + // The rest of this code is based on build_cpufunctbl in newcpu.c. + + unsigned long opcode; + struct cputbl* tbl = op_smalltbl_3; + + for (opcode = 0; opcode < 65536; opcode++) + { + cpufunctbl[opcode] = op_illg; + } + + for (i = 0; tbl[i].handler != NULL; i++) + { + if (!tbl[i].specific) + { + cpufunctbl[tbl[i].opcode] = tbl[i].handler; +#if HAS_PROFILING + perftbl[tbl[i].opcode] = tbl[i].perf; +#endif + } + } + + for (opcode = 0; opcode < 65536; opcode++) + { + cpuop_func* f; + + if (table68k[opcode].mnemo == i_ILLG || table68k[opcode].clev > 0) + { + continue; + } + + if (table68k[opcode].handler != -1) + { + f = cpufunctbl[table68k[opcode].handler]; + if (f == op_illg) + { + abort (); + } + + cpufunctbl[opcode] = f; +#if HAS_PROFILING + perftbl[opcode] = perftbl[table68k[opcode].handler]; +#endif + + } + } + + for (i = 0; tbl[i].handler != NULL; i++) + { + if (tbl[i].specific) + { + cpufunctbl[tbl[i].opcode] = tbl[i].handler; +#if HAS_PROFILING + perftbl[tbl[i].opcode] = tbl[i].perf; +#endif + } + } + + // (hey readcpu doesn't free this guy!) + + Platform::DisposeMemory (table68k); +} diff --git a/SrcShared/Hardware/EmCPU68K.h b/SrcShared/Hardware/EmCPU68K.h new file mode 100644 index 0000000..1cdfa08 --- /dev/null +++ b/SrcShared/Hardware/EmCPU68K.h @@ -0,0 +1,334 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmCPU68K_h +#define EmCPU68K_h + +#include "EmCPU.h" // EmCPU + +#include <vector> // vector + +#if REGISTER_HISTORY +#include "UAE.h" // regstruct +#else +struct regstruct; +#endif + +const uint16 kATrapReturnTrapNum = 0x0C; + +/*--------------------------------------------------------------------- + * Register numbering for 68K. Each register must have a unique + * non-zero register number. + *--------------------------------------------------------------------*/ +enum EmCPU68KRegID +{ + e68KRegID_Invalid = 0, /* Zero is an invalid register number */ + e68KRegID_D0 = 1, + e68KRegID_D1 = 2, + e68KRegID_D2 = 3, + e68KRegID_D3 = 4, + e68KRegID_D4 = 5, + e68KRegID_D5 = 6, + e68KRegID_D6 = 7, + e68KRegID_D7 = 8, + e68KRegID_A0 = 9, + e68KRegID_A1 = 10, + e68KRegID_A2 = 11, + e68KRegID_A3 = 12, + e68KRegID_A4 = 13, + e68KRegID_A5 = 14, + e68KRegID_A6 = 15, + e68KRegID_USP = 16, + e68KRegID_SSP = 17, + e68KRegID_PC = 18, + e68KRegID_SR = 19 +}; + + +enum ExceptionNumber +{ + kException_BusErr = 2, // 08 / 2 + kException_AddressErr, // 0C / 3 + kException_IllegalInstr, // 10 / 4 + kException_DivideByZero, // 14 / 5 + kException_Chk, // 18 / 6 + kException_Trap, // 1C / 7 + kException_Privilege, // 20 / 8 + kException_Trace, // 24 / 9 + kException_ATrap, // 28 / A + kException_FTrap, // 2C / B + kException_Reseved12, // 30 / C + kException_Coproc, // 34 / D + kException_FormatErr, // 38 / E + kException_UninitializedInt, // 3C / F + + kException_Reserved0, // 40-5C / 10-17 + kException_Reserved1, + kException_Reserved2, + kException_Reserved3, + kException_Reserved4, + kException_Reserved5, + kException_Reserved6, + kException_Reserved7, + + kException_SpuriousInt, // 60 / 18 + kException_AutoVec1, // 64 / 19 + kException_AutoVec2, // 68 / 1A + kException_AutoVec3, // 6C / 1B + kException_AutoVec4, // 70 / 1C + kException_AutoVec5, // 74 / 1D + kException_AutoVec6, // 78 / 1E + kException_AutoVec7, // 7C / 1F + + kException_Trap0, // 80 - BC / 20 - 2F // For soft breakpoints + kException_Trap1, + kException_Trap2, + kException_Trap3, + kException_Trap4, + kException_Trap5, + kException_Trap6, + kException_Trap7, + kException_Trap8, // For compiled breakpoints + kException_Trap9, + kException_Trap10, + kException_Trap11, + kException_Trap12, + kException_Trap13, // ATrap returns (emulator convention) + kException_Trap14, + kException_Trap15, // Trap dispatcher + + kException_Unassigned0, // C0 - FC / 30 - 3F + kException_Unassigned1, + kException_Unassigned2, + kException_Unassigned3, + kException_Unassigned4, + kException_Unassigned5, + kException_Unassigned6, + kException_Unassigned7, + kException_Unassigned8, + kException_Unassigned9, + kException_Unassigned10, + kException_Unassigned11, + kException_Unassigned12, + kException_Unassigned13, + kException_Unassigned14, + kException_Unassigned15, + + kException_LastException, + + kException_SoftBreak = kException_Trap0 + sysDbgBreakpointTrapNum, + kException_HardBreak = kException_Trap0 + sysDbgTrapNum, + kException_SysCall = kException_Trap0 + sysDispatchTrapNum, + kException_ATrapReturn = kException_Trap0 + kATrapReturnTrapNum +}; + +/* + Grr...this function doesn't appear to be "seen" by VC++. Even in its + presence, an expression involving an ExceptionNumber and an int + results in the message "error C2440: 'initializing' : cannot convert + from 'const int' to 'const enum ExceptionNumber'" + +inline ExceptionNumber operator+ (ExceptionNumber left, int right) +{ + // NB: cast "left" to an integer, or this routine will recurse! + return (ExceptionNumber) ((int) left + right); +} +*/ + +#if EXCEPTION_HISTORY + +struct ExceptionHistoryType +{ + const char* name; + uint32 pc; + uint32 sp; +}; + +#endif + +// Using uint32 instead of uint16 generates slightly better code. +typedef uint32 EmOpcode68K; + +enum EmStackChangeType +{ + kStackPointerChanged, + kStackPointerIncremented, + kStackPointerDecremented, + kStackPointerKernelStackHack +}; + +class EmCPU68K; +typedef Bool (*Hook68KException) (ExceptionNumber); +typedef Bool (*Hook68KJSR) (emuptr oldPC, emuptr dest); +typedef Bool (*Hook68KJSR_Ind) (emuptr oldPC, emuptr dest); +typedef void (*Hook68KLINK) (int linkSize); +typedef Bool (*Hook68KRTE) (emuptr dest); +typedef Bool (*Hook68KRTS) (emuptr dest); +typedef void (*Hook68KNewPC) (emuptr dest); +typedef void (*Hook68KNewSP) (EmStackChangeType); + +typedef vector<Hook68KException> Hook68KExceptionList; +typedef vector<Hook68KJSR> Hook68KJSRList; +typedef vector<Hook68KJSR_Ind> Hook68KJSR_IndList; +typedef vector<Hook68KLINK> Hook68KLINKList; +typedef vector<Hook68KRTE> Hook68KRTEList; +typedef vector<Hook68KRTS> Hook68KRTSList; +typedef vector<Hook68KNewPC> Hook68KNewPCList; +typedef vector<Hook68KNewSP> Hook68KNewSPList; + +class EmCPU68K; +extern EmCPU68K* gCPU68K; + +// These variables should strictly be in a sub-system that implements +// the stack overflow checking, etc. However, for performance reasons, +// we need to expose them to UAE (see the CHECK_STACK_POINTER_ASSIGNMENT, +// et al macros), so define them here. +// +// Similar comments for the CheckKernelStack function. + +extern "C" uint32 gStackHigh; +extern "C" uint32 gStackLowWarn; +extern "C" uint32 gStackLow; +extern "C" uint32 gKernelStackOverflowed; + + +class EmCPU68K : public EmCPU +{ + public: + // ----------------------------------------------------------------------------- + // constructor / destructor + // ----------------------------------------------------------------------------- + + EmCPU68K (EmSession*); + virtual ~EmCPU68K (void); + + // ----------------------------------------------------------------------------- + // public methods + // ----------------------------------------------------------------------------- + + // Standard sub-system methods: + // Reset: Resets the state. Called on hardware resets or on + // calls to SysReset. Also called from constructor. + // Save: Saves the state to the given file. + // Load: Loads the state from the given file. Can assume that + // Reset has been called first. + + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + + // Execute the main CPU loop until asked to stop. + + virtual void Execute (void); + virtual void CheckAfterCycle (void); + + // Low-level access to CPU state. + + virtual emuptr GetPC (void); + virtual emuptr GetSP (void); + virtual uint32 GetRegister (int); + + virtual void SetPC (emuptr); + virtual void SetSP (emuptr); + virtual void SetRegister (int, uint32); + + virtual Bool Stopped (void); + + // Called from routines in EmUAEGlue.cpp + + void ProcessException (ExceptionNumber); + void ProcessIllegalInstruction (EmOpcode68K opcode); + int ProcessJSR (emuptr oldPC, emuptr dest); + int ProcessJSR_Ind (emuptr oldPC, emuptr dest); + void ProcessLINK (int linkSize); + int ProcessRTE (emuptr dest); + int ProcessRTS (emuptr dest); + void CheckNewPC (emuptr dest); + void CheckNewSP (EmStackChangeType); + + // Called by CPU clients who need to be notified when certain + // actions occur. + + void InstallHookException (ExceptionNumber, + Hook68KException); + + void InstallHookJSR (Hook68KJSR); + void InstallHookJSR_Ind (Hook68KJSR_Ind); + void InstallHookLINK (Hook68KLINK); + void InstallHookRTS (Hook68KRTE); + void InstallHookRTE (Hook68KRTS); + void InstallHookNewPC (Hook68KNewPC); + void InstallHookNewSP (Hook68KNewSP); + + void RemoveHookException (ExceptionNumber, + Hook68KException); + + void RemoveHookJSR (Hook68KJSR); + void RemoveHookJSR_Ind (Hook68KJSR_Ind); + void RemoveHookLINK (Hook68KLINK); + void RemoveHookRTS (Hook68KRTE); + void RemoveHookRTE (Hook68KRTS); + void RemoveHookNewPC (Hook68KNewPC); + void RemoveHookNewSP (Hook68KNewSP); + + // Register management. Clients should call Get/SetRegisters for + // the most part. UpdateXFromY are here so that MakeSR and + // MakeFromSR (UAE glue functions) can call them. + + void GetRegisters (regstruct& registers); + void SetRegisters (regstruct& registers); + void UpdateSRFromRegisters (void); + void UpdateRegistersFromSR (void); + + uint32 GetCycleCount (void); + + void BusError (emuptr address, long size, Bool forRead); + void AddressError (emuptr address, long size, Bool forRead); + + private: + Bool ExecuteSpecial (void); + Bool ExecuteStoppedLoop (void); + + void CycleSlowly (Bool sleeping); + Bool CheckForBreak (void); + + void ProcessInterrupt (int32 interrupt); + + void InitializeUAETables (void); + + private: + emuptr fLastTraceAddress; + uint32 fCycleCount; + Hook68KExceptionList fExceptionHandlers[kException_LastException]; + Hook68KJSRList fHookJSR; + Hook68KJSR_IndList fHookJSR_Ind; + Hook68KLINKList fHookLINK; + Hook68KRTEList fHookRTE; + Hook68KRTSList fHookRTS; + Hook68KNewPCList fHookNewPC; + Hook68KNewSPList fHookNewSP; + +#if REGISTER_HISTORY + #define kRegHistorySize 512 + long fRegHistoryIndex; + struct regstruct fRegHistory[kRegHistorySize]; +#endif + +#if EXCEPTION_HISTORY + #define kExceptionHistorySize 512 + long fExceptionHistoryIndex; + struct ExceptionHistoryType fExceptionHistory[kExceptionHistorySize]; +#endif +}; + +#endif // EmCPU68K_h diff --git a/SrcShared/Hardware/EmCPUARM.cpp b/SrcShared/Hardware/EmCPUARM.cpp new file mode 100644 index 0000000..3d57510 --- /dev/null +++ b/SrcShared/Hardware/EmCPUARM.cpp @@ -0,0 +1,398 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmCPUARM.h" + +#include "EmSession.h" // ExecuteSpecial + +/* + This file interfaces between the Palm OS Emulator and the embedded + instance of the ARMulator. + + This version of the ARMulator comes from gdb 5.0, which in turn was + derived from the ARM6 ARMulator from ARM, Inc. ARM apparently no + longer makes public source-code to their version of ARMulator + available, so the version here is probably just a distant cousin + of that version. + + The ARMulator here comes with the following files: + + * armcopro.c + + ARM coprocessor emulation + + * armemu.c + + Main ARM processor emulation. It can be compiled for either + 26-bit or 32-bit modes. + + * arminit.c + + Contains routines to perform one-time initialization of + ARMulator, create an emulator instance, select a processor, + reset a processor, run one or more instructions, or trigger + an abort. + + * armos.c + + (Something to do with knowledge of an ARM-based OS) + + * armrdi.c + + Implements the ARM RDI (Remote Debugger Interface). All + functions are exported via an RDI 1.0 RDIProcVec table + (armul_rdi). + + * armsupp.c + + Support routines for common actions like determining addressing + modes, reading and writing bytes, reading and writing registers, etc. + + * armvirt.c + + A simple memory emulator that maps in RAM pages on demand. + + * bag.c + + A simple dictionary data structure. Used by kid.c to manage + breakpoints. (!!!Why are they managed there and not in armrdi?) + + * communicate.c + + Utility routines to read and write bytes, words, and strings + over a socket. + + * gdbhost.c + + Interface routines between gdb and ARMulator. ARMulator calls + these functions to invoke gdb console facilities. + + * kid.c + + Infinite loops that listens on a socket for ADP packets. It + reads these and invokes the appropriate RDI functions in armrdi.c. + + * main.c + + Front-end application that sits between gdb and ARMulator, intercepting + packets and passing them on. (!!! It's not clear to me why this + intermediary -- implemented in parent.c -- is required.) + + * parent.c + + Implements the loop that listens for packets from either gdb + or ARMulator and forwards them on to the other. + + * thumbemu.c + + Emulator of the Thumb sub-cell. Translates Thumb opcodes into + ARM opcodes, and then invokes the ARM opcode emulator. + + * wrapper.c + + ARMulator wrapper that allows it to be incorporated into the gdb + Simulator system. This includes implementing functions that + respond to the gdb set of remote debugger commands. + + When incorporated into the gdb Simulator system, only the files armcopro.c, + armemu.c, arminit.c, armos.c, armsupp.c, armvirt.c, bag.c thumbemu.c, and + wrapper.c seem to be used. (!!! Why bag.c, when it's only used by kid.c?) +*/ + +#if 0 + +extern "C" +{ +#include "armdefs.h" +#include "armemu.h" +#include "arm/dbg_rdi.h" // RDIProcVec +#include "arm/dbg_hif.h" // Dbg_HostosInterface (struct) +#include "arm/dbg_conf.h" // Dbg_ConfigBlock, Dbg_HostosInterface (typdef) +} + +extern "C" +{ + +int stop_simulator; // Referenced in ARMul_Emulate32 loop + +int mumkid[2] = {1, 2}; // Referenced in kid.c +int kidmum[2] = {3, 4}; // Referenced in kid.c, armrdi.c + +/* RDI interface */ +extern const struct RDIProcVec armul_rdi; + +void ARMul_CheckAfterCycle (void); +void ARMul_SetSession (void* session); + +void EmCPUARM_CheckAfterCycle (void* session) +{ + ((EmSession*) session)->ExecuteSpecial (false); +} + + +/***************************************************************************\ +* Time for the Operating System to initialise itself. * +\***************************************************************************/ + +// Referenced in RDI_open in armrdi.c + +unsigned +ARMul_OSInit (ARMul_State * state) +{ + return (TRUE); +} + +// Referenced in RDI_close in armrdi.c + +void +ARMul_OSExit (ARMul_State * state) +{ +} + +/***************************************************************************\ +* Return the last Operating System Error. * +\***************************************************************************/ + +// Referenced in RDI_info in armrdi.c + +ARMword ARMul_OSLastErrorP (ARMul_State * state) +{ + return 0; +} + +/***************************************************************************\ +* The emulator calls this routine when a SWI instruction is encuntered. The * +* parameter passed is the SWI number (lower 24 bits of the instruction). * +\***************************************************************************/ + +// Referenced in "case 0x7f" of ARMul_Emulate32 in armemu.c +// Referenced in "case 0xf0..0xff" of ARMul_Emulate32 in armemu.c + +unsigned +ARMul_OSHandleSWI (ARMul_State * state, ARMword number) +{ + return (FALSE); +} + +/***************************************************************************\ +* The emulator calls this routine when an Exception occurs. The second * +* parameter is the address of the relevant exception vector. Returning * +* FALSE from this routine causes the trap to be taken, TRUE causes it to * +* be ignored (so set state->Emulate to FALSE!). * +\***************************************************************************/ + +// Referenced in ARMul_Abort in arminit.c + +unsigned +ARMul_OSException (ARMul_State * state, ARMword vector, ARMword pc) +{ + return (FALSE); +} + +} + +#endif + + +#pragma mark - + +EmCPUARM* gCPUARM; + +// --------------------------------------------------------------------------- +// ¥ EmCPUARM::EmCPUARM +// --------------------------------------------------------------------------- + +EmCPUARM::EmCPUARM (EmSession* session) : + EmCPU (session) +{ + this->DoReset (true); + + EmAssert (gCPUARM == NULL); + gCPUARM = this; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPUARM::~EmCPUARM +// --------------------------------------------------------------------------- + +EmCPUARM::~EmCPUARM (void) +{ +#if 0 + /* int i = */ armul_rdi.close (); +#endif + + EmAssert (gCPUARM == this); + gCPUARM = NULL; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPUARM::Reset +// --------------------------------------------------------------------------- + +void EmCPUARM::Reset (Bool hardwareReset) +{ + if (hardwareReset) + { + this->DoReset (false); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPUARM::Save +// --------------------------------------------------------------------------- + +void EmCPUARM::Save (SessionFile&) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPUARM::Load +// --------------------------------------------------------------------------- + +void EmCPUARM::Load (SessionFile&) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPUARM::Execute +// --------------------------------------------------------------------------- + +void EmCPUARM::Execute (void) +{ +#if 0 + PointHandle point; + /* int i = */ armul_rdi.execute (&point); +#endif +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPUARM::CheckAfterCycle +// --------------------------------------------------------------------------- + +void EmCPUARM::CheckAfterCycle (void) +{ +#if 0 + ARMul_CheckAfterCycle (); +#endif +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPUARM::GetPC +// --------------------------------------------------------------------------- + +emuptr EmCPUARM::GetPC (void) +{ + return EmMemNULL; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPUARM::GetSP +// --------------------------------------------------------------------------- + +emuptr EmCPUARM::GetSP (void) +{ + return EmMemNULL; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPUARM::GetRegister +// --------------------------------------------------------------------------- + +uint32 EmCPUARM::GetRegister (int /*index*/) +{ + return 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPUARM::SetPC +// --------------------------------------------------------------------------- + +void EmCPUARM::SetPC (emuptr /*newPC*/) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPUARM::SetSP +// --------------------------------------------------------------------------- + +void EmCPUARM::SetSP (emuptr /*newPC*/) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPUARM::SetRegister +// --------------------------------------------------------------------------- + +void EmCPUARM::SetRegister (int /*index*/, uint32 /*val*/) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPUARM::Stopped +// --------------------------------------------------------------------------- +// Return whether or not the CPU itself is halted. This is seperate from +// whether or not the session (that is, the thread emulating the CPU) is +// halted. + +Bool EmCPUARM::Stopped (void) +{ + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmCPUARM::DoReset +// --------------------------------------------------------------------------- + +void EmCPUARM::DoReset (Bool /*cold*/) +{ +#if 0 + // Taken from RDP_Start in kid.c + + Dbg_ConfigBlock config; + config.processor = 0; + config.memorysize = 1024 * 1024L; + config.bytesex = RDISex_Little; + + Dbg_HostosInterface hostif; + + hostif.dbgprint = NULL; // myprint; // Called in ARMul_DebugPrint, ARMul_DebugPrint_i, which are called only if RDI_VERBOSE is defined. + hostif.dbgpause = NULL; // mypause; // Called in ARMul_DebugPause, which in turn is not called. + hostif.dbgarg = NULL; // stdout; // Passed to dbgprint and dbgpause. + hostif.writec = NULL; // mywritec;// Not called + hostif.readc = NULL; // myreadc; // Not called + hostif.write = NULL; // mywrite; // Not called + hostif.gets = NULL; // mygets; // Not called + hostif.hostosarg = NULL; // Not referenced + hostif.reset = NULL; // mypause; // Not referenced + hostif.resetarg = NULL; // Not referenced + + /* int i = */ armul_rdi.open (cold ? 0 : 1, &config, &hostif, NULL); + + ARMul_SetSession (fSession); +#endif +} diff --git a/SrcShared/Hardware/EmCPUARM.h b/SrcShared/Hardware/EmCPUARM.h new file mode 100644 index 0000000..73c8304 --- /dev/null +++ b/SrcShared/Hardware/EmCPUARM.h @@ -0,0 +1,731 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmCPUARM_h +#define EmCPUARM_h + +#include "EmCPU.h" // EmCPU + +/*--------------------------------------------------------------------- + * ARM Register IDs. All register IDs must be unique even if registers + * are in a different group such as FPU registers. + *--------------------------------------------------------------------*/ +enum EmCPUARMRegID +{ + eARMRegID_Invalid = 0, /* Zero is an invalid register number */ + + /*----------------------------------------------------------- + // User mode registers + //----------------------------------------------------------*/ + eARMRegID_R0 = 1, + eARMRegID_R1, + eARMRegID_R2, + eARMRegID_R3, + eARMRegID_R4, + eARMRegID_R5, + eARMRegID_R6, + eARMRegID_R7, + eARMRegID_R8, + eARMRegID_R9, + eARMRegID_R10, + eARMRegID_R11, + eARMRegID_R12, + eARMRegID_SP, eARMRegID_R13 = eARMRegID_SP, + eARMRegID_LR, eARMRegID_R14 = eARMRegID_LR, + eARMRegID_PC, eARMRegID_R15 = eARMRegID_PC, + eARMRegID_CPSR, + + /*----------------------------------------------------------- + // FIQ mode registers + //----------------------------------------------------------*/ + eARMRegID_R8_fiq, + eARMRegID_R9_fiq, + eARMRegID_R10_fiq, + eARMRegID_R11_fiq, + eARMRegID_R12_fiq, + eARMRegID_R13_fiq, + eARMRegID_R14_fiq, + eARMRegID_SPSR_fiq, + + /*----------------------------------------------------------- + // IRQ mode registers + //----------------------------------------------------------*/ + eARMRegID_R13_irq, + eARMRegID_R14_irq, + eARMRegID_SPSR_irq, + + /*----------------------------------------------------------- + // Supervisor mode registers + //----------------------------------------------------------*/ + eARMRegID_R13_svc, + eARMRegID_R14_svc, + eARMRegID_SPSR_svc, + + /*----------------------------------------------------------- + // Abort mode registers + //----------------------------------------------------------*/ + eARMRegID_R13_abt, + eARMRegID_R14_abt, + eARMRegID_SPSR_abt, + + + /*----------------------------------------------------------- + // Undefined mode registers + //----------------------------------------------------------*/ + eARMRegID_R13_und, + eARMRegID_R14_und, + eARMRegID_SPSR_und, + + /*----------------------------------------------------------- + // SB register (static base). + // + // Any references to R9 can be remapped (in debugger plugin + // preferences) to access this SB register which can be + // described by an expression in the preferences. The + // expression should not contain any references to R9 (since + // this will create an infinite loop (since R9 has been + // remapped to SB)). Any need for the actual value of R9 in + // the SB expression should use the "genreg_gp1" (which means + // "General Register Global Pointer 1") opcode which + // will actually read R9. + //----------------------------------------------------------*/ + eARMRegID_SB, + + /*----------------------------------------------------------- + // Coprocessor 0 registers + //----------------------------------------------------------*/ + eARMRegID_CP0_R0, + eARMRegID_CP0_R1, + eARMRegID_CP0_R2, + eARMRegID_CP0_R3, + eARMRegID_CP0_R4, + eARMRegID_CP0_R5, + eARMRegID_CP0_R6, + eARMRegID_CP0_R7, + eARMRegID_CP0_R8, + eARMRegID_CP0_R9, + eARMRegID_CP0_R10, + eARMRegID_CP0_R11, + eARMRegID_CP0_R12, + eARMRegID_CP0_R13, + eARMRegID_CP0_R14, + eARMRegID_CP0_R15, + eARMRegID_CP0_R16, + eARMRegID_CP0_R17, + eARMRegID_CP0_R18, + eARMRegID_CP0_R19, + eARMRegID_CP0_R20, + eARMRegID_CP0_R21, + eARMRegID_CP0_R22, + eARMRegID_CP0_R23, + eARMRegID_CP0_R24, + eARMRegID_CP0_R25, + eARMRegID_CP0_R26, + eARMRegID_CP0_R27, + eARMRegID_CP0_R28, + eARMRegID_CP0_R29, + eARMRegID_CP0_R30, + eARMRegID_CP0_R31, + + /*----------------------------------------------------------- + // Coprocessor 1 registers + //----------------------------------------------------------*/ + eARMRegID_CP1_R0, + eARMRegID_CP1_R1, + eARMRegID_CP1_R2, + eARMRegID_CP1_R3, + eARMRegID_CP1_R4, + eARMRegID_CP1_R5, + eARMRegID_CP1_R6, + eARMRegID_CP1_R7, + eARMRegID_CP1_R8, + eARMRegID_CP1_R9, + eARMRegID_CP1_R10, + eARMRegID_CP1_R11, + eARMRegID_CP1_R12, + eARMRegID_CP1_R13, + eARMRegID_CP1_R14, + eARMRegID_CP1_R15, + eARMRegID_CP1_R16, + eARMRegID_CP1_R17, + eARMRegID_CP1_R18, + eARMRegID_CP1_R19, + eARMRegID_CP1_R20, + eARMRegID_CP1_R21, + eARMRegID_CP1_R22, + eARMRegID_CP1_R23, + eARMRegID_CP1_R24, + eARMRegID_CP1_R25, + eARMRegID_CP1_R26, + eARMRegID_CP1_R27, + eARMRegID_CP1_R28, + eARMRegID_CP1_R29, + eARMRegID_CP1_R30, + eARMRegID_CP1_R31, + + /*----------------------------------------------------------- + // Coprocessor 2 registers + //----------------------------------------------------------*/ + eARMRegID_CP2_R0, + eARMRegID_CP2_R1, + eARMRegID_CP2_R2, + eARMRegID_CP2_R3, + eARMRegID_CP2_R4, + eARMRegID_CP2_R5, + eARMRegID_CP2_R6, + eARMRegID_CP2_R7, + eARMRegID_CP2_R8, + eARMRegID_CP2_R9, + eARMRegID_CP2_R10, + eARMRegID_CP2_R11, + eARMRegID_CP2_R12, + eARMRegID_CP2_R13, + eARMRegID_CP2_R14, + eARMRegID_CP2_R15, + eARMRegID_CP2_R16, + eARMRegID_CP2_R17, + eARMRegID_CP2_R18, + eARMRegID_CP2_R19, + eARMRegID_CP2_R20, + eARMRegID_CP2_R21, + eARMRegID_CP2_R22, + eARMRegID_CP2_R23, + eARMRegID_CP2_R24, + eARMRegID_CP2_R25, + eARMRegID_CP2_R26, + eARMRegID_CP2_R27, + eARMRegID_CP2_R28, + eARMRegID_CP2_R29, + eARMRegID_CP2_R30, + eARMRegID_CP2_R31, + + /*----------------------------------------------------------- + // Coprocessor 3 registers + //----------------------------------------------------------*/ + eARMRegID_CP3_R0, + eARMRegID_CP3_R1, + eARMRegID_CP3_R2, + eARMRegID_CP3_R3, + eARMRegID_CP3_R4, + eARMRegID_CP3_R5, + eARMRegID_CP3_R6, + eARMRegID_CP3_R7, + eARMRegID_CP3_R8, + eARMRegID_CP3_R9, + eARMRegID_CP3_R10, + eARMRegID_CP3_R11, + eARMRegID_CP3_R12, + eARMRegID_CP3_R13, + eARMRegID_CP3_R14, + eARMRegID_CP3_R15, + eARMRegID_CP3_R16, + eARMRegID_CP3_R17, + eARMRegID_CP3_R18, + eARMRegID_CP3_R19, + eARMRegID_CP3_R20, + eARMRegID_CP3_R21, + eARMRegID_CP3_R22, + eARMRegID_CP3_R23, + eARMRegID_CP3_R24, + eARMRegID_CP3_R25, + eARMRegID_CP3_R26, + eARMRegID_CP3_R27, + eARMRegID_CP3_R28, + eARMRegID_CP3_R29, + eARMRegID_CP3_R30, + eARMRegID_CP3_R31, + + /*----------------------------------------------------------- + // Coprocessor 4 registers + //----------------------------------------------------------*/ + eARMRegID_CP4_R0, + eARMRegID_CP4_R1, + eARMRegID_CP4_R2, + eARMRegID_CP4_R3, + eARMRegID_CP4_R4, + eARMRegID_CP4_R5, + eARMRegID_CP4_R6, + eARMRegID_CP4_R7, + eARMRegID_CP4_R8, + eARMRegID_CP4_R9, + eARMRegID_CP4_R10, + eARMRegID_CP4_R11, + eARMRegID_CP4_R12, + eARMRegID_CP4_R13, + eARMRegID_CP4_R14, + eARMRegID_CP4_R15, + eARMRegID_CP4_R16, + eARMRegID_CP4_R17, + eARMRegID_CP4_R18, + eARMRegID_CP4_R19, + eARMRegID_CP4_R20, + eARMRegID_CP4_R21, + eARMRegID_CP4_R22, + eARMRegID_CP4_R23, + eARMRegID_CP4_R24, + eARMRegID_CP4_R25, + eARMRegID_CP4_R26, + eARMRegID_CP4_R27, + eARMRegID_CP4_R28, + eARMRegID_CP4_R29, + eARMRegID_CP4_R30, + eARMRegID_CP4_R31, + + /*----------------------------------------------------------- + // Coprocessor 5 registers + //----------------------------------------------------------*/ + eARMRegID_CP5_R0, + eARMRegID_CP5_R1, + eARMRegID_CP5_R2, + eARMRegID_CP5_R3, + eARMRegID_CP5_R4, + eARMRegID_CP5_R5, + eARMRegID_CP5_R6, + eARMRegID_CP5_R7, + eARMRegID_CP5_R8, + eARMRegID_CP5_R9, + eARMRegID_CP5_R10, + eARMRegID_CP5_R11, + eARMRegID_CP5_R12, + eARMRegID_CP5_R13, + eARMRegID_CP5_R14, + eARMRegID_CP5_R15, + eARMRegID_CP5_R16, + eARMRegID_CP5_R17, + eARMRegID_CP5_R18, + eARMRegID_CP5_R19, + eARMRegID_CP5_R20, + eARMRegID_CP5_R21, + eARMRegID_CP5_R22, + eARMRegID_CP5_R23, + eARMRegID_CP5_R24, + eARMRegID_CP5_R25, + eARMRegID_CP5_R26, + eARMRegID_CP5_R27, + eARMRegID_CP5_R28, + eARMRegID_CP5_R29, + eARMRegID_CP5_R30, + eARMRegID_CP5_R31, + + /*----------------------------------------------------------- + // Coprocessor 6 registers + //----------------------------------------------------------*/ + eARMRegID_CP6_R0, + eARMRegID_CP6_R1, + eARMRegID_CP6_R2, + eARMRegID_CP6_R3, + eARMRegID_CP6_R4, + eARMRegID_CP6_R5, + eARMRegID_CP6_R6, + eARMRegID_CP6_R7, + eARMRegID_CP6_R8, + eARMRegID_CP6_R9, + eARMRegID_CP6_R10, + eARMRegID_CP6_R11, + eARMRegID_CP6_R12, + eARMRegID_CP6_R13, + eARMRegID_CP6_R14, + eARMRegID_CP6_R15, + eARMRegID_CP6_R16, + eARMRegID_CP6_R17, + eARMRegID_CP6_R18, + eARMRegID_CP6_R19, + eARMRegID_CP6_R20, + eARMRegID_CP6_R21, + eARMRegID_CP6_R22, + eARMRegID_CP6_R23, + eARMRegID_CP6_R24, + eARMRegID_CP6_R25, + eARMRegID_CP6_R26, + eARMRegID_CP6_R27, + eARMRegID_CP6_R28, + eARMRegID_CP6_R29, + eARMRegID_CP6_R30, + eARMRegID_CP6_R31, + + /*----------------------------------------------------------- + // Coprocessor 7 registers + //----------------------------------------------------------*/ + eARMRegID_CP7_R0, + eARMRegID_CP7_R1, + eARMRegID_CP7_R2, + eARMRegID_CP7_R3, + eARMRegID_CP7_R4, + eARMRegID_CP7_R5, + eARMRegID_CP7_R6, + eARMRegID_CP7_R7, + eARMRegID_CP7_R8, + eARMRegID_CP7_R9, + eARMRegID_CP7_R10, + eARMRegID_CP7_R11, + eARMRegID_CP7_R12, + eARMRegID_CP7_R13, + eARMRegID_CP7_R14, + eARMRegID_CP7_R15, + eARMRegID_CP7_R16, + eARMRegID_CP7_R17, + eARMRegID_CP7_R18, + eARMRegID_CP7_R19, + eARMRegID_CP7_R20, + eARMRegID_CP7_R21, + eARMRegID_CP7_R22, + eARMRegID_CP7_R23, + eARMRegID_CP7_R24, + eARMRegID_CP7_R25, + eARMRegID_CP7_R26, + eARMRegID_CP7_R27, + eARMRegID_CP7_R28, + eARMRegID_CP7_R29, + eARMRegID_CP7_R30, + eARMRegID_CP7_R31, + + /*----------------------------------------------------------- + // Coprocessor 8 registers + //----------------------------------------------------------*/ + eARMRegID_CP8_R0, + eARMRegID_CP8_R1, + eARMRegID_CP8_R2, + eARMRegID_CP8_R3, + eARMRegID_CP8_R4, + eARMRegID_CP8_R5, + eARMRegID_CP8_R6, + eARMRegID_CP8_R7, + eARMRegID_CP8_R8, + eARMRegID_CP8_R9, + eARMRegID_CP8_R10, + eARMRegID_CP8_R11, + eARMRegID_CP8_R12, + eARMRegID_CP8_R13, + eARMRegID_CP8_R14, + eARMRegID_CP8_R15, + eARMRegID_CP8_R16, + eARMRegID_CP8_R17, + eARMRegID_CP8_R18, + eARMRegID_CP8_R19, + eARMRegID_CP8_R20, + eARMRegID_CP8_R21, + eARMRegID_CP8_R22, + eARMRegID_CP8_R23, + eARMRegID_CP8_R24, + eARMRegID_CP8_R25, + eARMRegID_CP8_R26, + eARMRegID_CP8_R27, + eARMRegID_CP8_R28, + eARMRegID_CP8_R29, + eARMRegID_CP8_R30, + eARMRegID_CP8_R31, + + /*----------------------------------------------------------- + // Coprocessor 9 registers + //----------------------------------------------------------*/ + eARMRegID_CP9_R0, + eARMRegID_CP9_R1, + eARMRegID_CP9_R2, + eARMRegID_CP9_R3, + eARMRegID_CP9_R4, + eARMRegID_CP9_R5, + eARMRegID_CP9_R6, + eARMRegID_CP9_R7, + eARMRegID_CP9_R8, + eARMRegID_CP9_R9, + eARMRegID_CP9_R10, + eARMRegID_CP9_R11, + eARMRegID_CP9_R12, + eARMRegID_CP9_R13, + eARMRegID_CP9_R14, + eARMRegID_CP9_R15, + eARMRegID_CP9_R16, + eARMRegID_CP9_R17, + eARMRegID_CP9_R18, + eARMRegID_CP9_R19, + eARMRegID_CP9_R20, + eARMRegID_CP9_R21, + eARMRegID_CP9_R22, + eARMRegID_CP9_R23, + eARMRegID_CP9_R24, + eARMRegID_CP9_R25, + eARMRegID_CP9_R26, + eARMRegID_CP9_R27, + eARMRegID_CP9_R28, + eARMRegID_CP9_R29, + eARMRegID_CP9_R30, + eARMRegID_CP9_R31, + + /*----------------------------------------------------------- + // Coprocessor 10 registers + //----------------------------------------------------------*/ + eARMRegID_CP10_R0, + eARMRegID_CP10_R1, + eARMRegID_CP10_R2, + eARMRegID_CP10_R3, + eARMRegID_CP10_R4, + eARMRegID_CP10_R5, + eARMRegID_CP10_R6, + eARMRegID_CP10_R7, + eARMRegID_CP10_R8, + eARMRegID_CP10_R9, + eARMRegID_CP10_R10, + eARMRegID_CP10_R11, + eARMRegID_CP10_R12, + eARMRegID_CP10_R13, + eARMRegID_CP10_R14, + eARMRegID_CP10_R15, + eARMRegID_CP10_R16, + eARMRegID_CP10_R17, + eARMRegID_CP10_R18, + eARMRegID_CP10_R19, + eARMRegID_CP10_R20, + eARMRegID_CP10_R21, + eARMRegID_CP10_R22, + eARMRegID_CP10_R23, + eARMRegID_CP10_R24, + eARMRegID_CP10_R25, + eARMRegID_CP10_R26, + eARMRegID_CP10_R27, + eARMRegID_CP10_R28, + eARMRegID_CP10_R29, + eARMRegID_CP10_R30, + eARMRegID_CP10_R31, + + /*----------------------------------------------------------- + // Coprocessor 11 registers + //----------------------------------------------------------*/ + eARMRegID_CP11_R0, + eARMRegID_CP11_R1, + eARMRegID_CP11_R2, + eARMRegID_CP11_R3, + eARMRegID_CP11_R4, + eARMRegID_CP11_R5, + eARMRegID_CP11_R6, + eARMRegID_CP11_R7, + eARMRegID_CP11_R8, + eARMRegID_CP11_R9, + eARMRegID_CP11_R10, + eARMRegID_CP11_R11, + eARMRegID_CP11_R12, + eARMRegID_CP11_R13, + eARMRegID_CP11_R14, + eARMRegID_CP11_R15, + eARMRegID_CP11_R16, + eARMRegID_CP11_R17, + eARMRegID_CP11_R18, + eARMRegID_CP11_R19, + eARMRegID_CP11_R20, + eARMRegID_CP11_R21, + eARMRegID_CP11_R22, + eARMRegID_CP11_R23, + eARMRegID_CP11_R24, + eARMRegID_CP11_R25, + eARMRegID_CP11_R26, + eARMRegID_CP11_R27, + eARMRegID_CP11_R28, + eARMRegID_CP11_R29, + eARMRegID_CP11_R30, + eARMRegID_CP11_R31, + + /*----------------------------------------------------------- + // Coprocessor 12 registers + //----------------------------------------------------------*/ + eARMRegID_CP12_R0, + eARMRegID_CP12_R1, + eARMRegID_CP12_R2, + eARMRegID_CP12_R3, + eARMRegID_CP12_R4, + eARMRegID_CP12_R5, + eARMRegID_CP12_R6, + eARMRegID_CP12_R7, + eARMRegID_CP12_R8, + eARMRegID_CP12_R9, + eARMRegID_CP12_R10, + eARMRegID_CP12_R11, + eARMRegID_CP12_R12, + eARMRegID_CP12_R13, + eARMRegID_CP12_R14, + eARMRegID_CP12_R15, + eARMRegID_CP12_R16, + eARMRegID_CP12_R17, + eARMRegID_CP12_R18, + eARMRegID_CP12_R19, + eARMRegID_CP12_R20, + eARMRegID_CP12_R21, + eARMRegID_CP12_R22, + eARMRegID_CP12_R23, + eARMRegID_CP12_R24, + eARMRegID_CP12_R25, + eARMRegID_CP12_R26, + eARMRegID_CP12_R27, + eARMRegID_CP12_R28, + eARMRegID_CP12_R29, + eARMRegID_CP12_R30, + eARMRegID_CP12_R31, + + /*----------------------------------------------------------- + // Coprocessor 13 registers + //----------------------------------------------------------*/ + eARMRegID_CP13_R0, + eARMRegID_CP13_R1, + eARMRegID_CP13_R2, + eARMRegID_CP13_R3, + eARMRegID_CP13_R4, + eARMRegID_CP13_R5, + eARMRegID_CP13_R6, + eARMRegID_CP13_R7, + eARMRegID_CP13_R8, + eARMRegID_CP13_R9, + eARMRegID_CP13_R10, + eARMRegID_CP13_R11, + eARMRegID_CP13_R12, + eARMRegID_CP13_R13, + eARMRegID_CP13_R14, + eARMRegID_CP13_R15, + eARMRegID_CP13_R16, + eARMRegID_CP13_R17, + eARMRegID_CP13_R18, + eARMRegID_CP13_R19, + eARMRegID_CP13_R20, + eARMRegID_CP13_R21, + eARMRegID_CP13_R22, + eARMRegID_CP13_R23, + eARMRegID_CP13_R24, + eARMRegID_CP13_R25, + eARMRegID_CP13_R26, + eARMRegID_CP13_R27, + eARMRegID_CP13_R28, + eARMRegID_CP13_R29, + eARMRegID_CP13_R30, + eARMRegID_CP13_R31, + + /*----------------------------------------------------------- + // Coprocessor 14 registers + //----------------------------------------------------------*/ + eARMRegID_CP14_R0, + eARMRegID_CP14_R1, + eARMRegID_CP14_R2, + eARMRegID_CP14_R3, + eARMRegID_CP14_R4, + eARMRegID_CP14_R5, + eARMRegID_CP14_R6, + eARMRegID_CP14_R7, + eARMRegID_CP14_R8, + eARMRegID_CP14_R9, + eARMRegID_CP14_R10, + eARMRegID_CP14_R11, + eARMRegID_CP14_R12, + eARMRegID_CP14_R13, + eARMRegID_CP14_R14, + eARMRegID_CP14_R15, + eARMRegID_CP14_R16, + eARMRegID_CP14_R17, + eARMRegID_CP14_R18, + eARMRegID_CP14_R19, + eARMRegID_CP14_R20, + eARMRegID_CP14_R21, + eARMRegID_CP14_R22, + eARMRegID_CP14_R23, + eARMRegID_CP14_R24, + eARMRegID_CP14_R25, + eARMRegID_CP14_R26, + eARMRegID_CP14_R27, + eARMRegID_CP14_R28, + eARMRegID_CP14_R29, + eARMRegID_CP14_R30, + eARMRegID_CP14_R31, + + /*----------------------------------------------------------- + // Coprocessor 15 registers + //----------------------------------------------------------*/ + eARMRegID_CP15_R0, + eARMRegID_CP15_R1, + eARMRegID_CP15_R2, + eARMRegID_CP15_R3, + eARMRegID_CP15_R4, + eARMRegID_CP15_R5, + eARMRegID_CP15_R6, + eARMRegID_CP15_R7, + eARMRegID_CP15_R8, + eARMRegID_CP15_R9, + eARMRegID_CP15_R10, + eARMRegID_CP15_R11, + eARMRegID_CP15_R12, + eARMRegID_CP15_R13, + eARMRegID_CP15_R14, + eARMRegID_CP15_R15, + eARMRegID_CP15_R16, + eARMRegID_CP15_R17, + eARMRegID_CP15_R18, + eARMRegID_CP15_R19, + eARMRegID_CP15_R20, + eARMRegID_CP15_R21, + eARMRegID_CP15_R22, + eARMRegID_CP15_R23, + eARMRegID_CP15_R24, + eARMRegID_CP15_R25, + eARMRegID_CP15_R26, + eARMRegID_CP15_R27, + eARMRegID_CP15_R28, + eARMRegID_CP15_R29, + eARMRegID_CP15_R30, + eARMRegID_CP15_R31 +}; + + +class EmCPUARM; +extern EmCPUARM* gCPUARM; + +class EmCPUARM : public EmCPU +{ + public: + // ----------------------------------------------------------------------------- + // constructor / destructor + // ----------------------------------------------------------------------------- + + EmCPUARM (EmSession*); + virtual ~EmCPUARM (void); + + // ----------------------------------------------------------------------------- + // public methods + // ----------------------------------------------------------------------------- + + // Standard sub-system methods: + // Reset: Resets the state. Called on hardware resets or on + // calls to SysReset. Also called from constructor. + // Save: Saves the state to the given file. + // Load: Loads the state from the given file. Can assume that + // Reset has been called first. + + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + + // Execute the main CPU loop until asked to stop. + + virtual void Execute (void); + virtual void CheckAfterCycle (void); + + // Low-level access to CPU state. + + virtual emuptr GetPC (void); + virtual emuptr GetSP (void); + virtual uint32 GetRegister (int); + + virtual void SetPC (emuptr); + virtual void SetSP (emuptr); + virtual void SetRegister (int, uint32); + + virtual Bool Stopped (void); + + private: + void DoReset (Bool cold); +}; + +#endif // EmCPUARM_h diff --git a/SrcShared/Hardware/EmHAL.cpp b/SrcShared/Hardware/EmHAL.cpp new file mode 100644 index 0000000..a4b0030 --- /dev/null +++ b/SrcShared/Hardware/EmHAL.cpp @@ -0,0 +1,939 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmHAL.h" + +#include "EmTransportSerial.h" // EmTransportSerial +#include "ErrorHandling.h" // Errors::ReportErrCommPort +#include "PreferenceMgr.h" // gEmuPrefs + +#include "Logging.h" + + +EmHALHandler* EmHAL::fgRootHandler; + +#define PRINTF if (!0) ; else LogAppendMsg + +static void PrvHandlePortOpenErrors (ErrCode err, string errString); + +// --------------------------------------------------------------------------- +// ¥ EmHAL::AddHandler +// --------------------------------------------------------------------------- + +void EmHAL::AddHandler (EmHALHandler* handler) +{ + EmAssert (handler->fNextHandler == NULL); + EmAssert (handler->fPrevHandler == NULL); + EmAssert (fgRootHandler == NULL || fgRootHandler->fPrevHandler == NULL); + + if (fgRootHandler != NULL) + { + fgRootHandler->fPrevHandler = handler; + handler->fNextHandler = fgRootHandler; + } + + fgRootHandler = handler; +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::RemoveHandler +// --------------------------------------------------------------------------- + +void EmHAL::RemoveHandler (EmHALHandler* handler) +{ + if (handler->fNextHandler) + { + handler->fNextHandler->fPrevHandler = handler->fPrevHandler; + } + + if (handler->fPrevHandler) + { + handler->fPrevHandler->fNextHandler = handler->fNextHandler; + } + else + { + fgRootHandler = handler->fNextHandler; + } + + handler->fNextHandler = NULL; + handler->fPrevHandler = NULL; + + EmAssert (handler->fNextHandler == NULL); + EmAssert (handler->fPrevHandler == NULL); + EmAssert (fgRootHandler == NULL || fgRootHandler->fPrevHandler == NULL); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::RemoveHandler +// --------------------------------------------------------------------------- + +void EmHAL::EnsureCoverage (void) +{ +#if 0 + // Rats...can't get this work... + + Bool isHandled[20]; + EmHALHandler* thisHandler = fgRootHandler; + EmHALHandler baseHandler; + + while (thisHandler) + { + typedef void (EmHALHandler::*CycleHandler)(Bool); + CycleHandler p1 = (thisHandler->Cycle); + CycleHandler p2 = (baseHandler.Cycle); + + if (p1 != p2) + { + isHandled[0] = true; + } + + thisHandler = thisHandler->fNextHandler; + } + + for (int ii = 0; ii < sizeof (isHandled); ++ii) + { + EmAssert (isHandled[ii]); + } +#endif +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::Cycle +// --------------------------------------------------------------------------- + +#if 0 // It's inline +void EmHAL::Cycle (Bool sleeping) +{ + EmAssert (EmHAL::GetRootHandler()); + EmHAL::GetRootHandler()->Cycle (sleeping); +} +#endif + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::CycleSlowly +// --------------------------------------------------------------------------- + +void EmHAL::CycleSlowly (Bool sleeping) +{ + EmAssert (EmHAL::GetRootHandler()); + EmHAL::GetRootHandler()->CycleSlowly (sleeping); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::ButtonEvent +// --------------------------------------------------------------------------- + +void EmHAL::ButtonEvent (SkinElementType button, Bool buttonIsDown) +{ + EmAssert (EmHAL::GetRootHandler()); + EmHAL::GetRootHandler()->ButtonEvent (button, buttonIsDown); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::TurnSoundOff +// --------------------------------------------------------------------------- + +void EmHAL::TurnSoundOff (void) +{ + EmAssert (EmHAL::GetRootHandler()); + EmHAL::GetRootHandler()->TurnSoundOff (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::ResetTimer +// --------------------------------------------------------------------------- + +void EmHAL::ResetTimer (void) +{ + EmAssert (EmHAL::GetRootHandler()); + EmHAL::GetRootHandler()->ResetTimer (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::ResetRTC +// --------------------------------------------------------------------------- + +void EmHAL::ResetRTC (void) +{ + EmAssert (EmHAL::GetRootHandler()); + EmHAL::GetRootHandler()->ResetRTC (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetInterruptLevel +// --------------------------------------------------------------------------- + +int32 EmHAL::GetInterruptLevel (void) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetInterruptLevel (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetInterruptBase +// --------------------------------------------------------------------------- + +int32 EmHAL::GetInterruptBase (void) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetInterruptBase (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetLCDScreenOn +// --------------------------------------------------------------------------- +// Called in various portXDataWrite methods to determine if Screen::InvalidateAll +// needs to be called. Typically implemented in the EmRegs<Product> or +// EmRegs<LCDDriver> subclass. + +Bool EmHAL::GetLCDScreenOn (void) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetLCDScreenOn (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetLCDBacklightOn +// --------------------------------------------------------------------------- +// Called in various portXDataWrite methods to determine if Screen::InvalidateAll +// needs to be called. Typically implemented in the EmRegs<Product> or +// EmRegs<LCDDriver> subclass. + +Bool EmHAL::GetLCDBacklightOn (void) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetLCDBacklightOn (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetLCDHasFrame +// --------------------------------------------------------------------------- +// Called by host LCD code to know if it needs to draw a 2-pixel white frame. +// Typically implemented in the EmRegs<Processor> or EmRegs<LCDDriver> subclass. + +Bool EmHAL::GetLCDHasFrame (void) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetLCDHasFrame (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetLCDBeginEnd +// --------------------------------------------------------------------------- +// Called by Screen class in order to mark the memory used for the framebuffer. +// Typically implemented in the EmRegs<Processor> or EmRegs<LCDDriver> subclass. + +void EmHAL::GetLCDBeginEnd (emuptr& begin, emuptr& end) +{ + EmAssert (EmHAL::GetRootHandler()); + EmHAL::GetRootHandler()->GetLCDBeginEnd (begin, end); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetLCDScanlines +// --------------------------------------------------------------------------- +// Fill in the output fields of EmScreenUpdateInfo. Typically implemented in +// the EmRegs<Processor> or EmRegs<LCDDriver> subclass. + +void EmHAL::GetLCDScanlines (EmScreenUpdateInfo& info) +{ + EmAssert (EmHAL::GetRootHandler()); + EmHAL::GetRootHandler()->GetLCDScanlines (info); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetDynamicHeapSize +// --------------------------------------------------------------------------- + +int32 EmHAL::GetDynamicHeapSize (void) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetDynamicHeapSize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetROMSize +// --------------------------------------------------------------------------- + +int32 EmHAL::GetROMSize (void) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetROMSize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetROMBaseAddress +// --------------------------------------------------------------------------- + +emuptr EmHAL::GetROMBaseAddress (void) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetROMBaseAddress (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::ChipSelectsConfigured +// --------------------------------------------------------------------------- + +Bool EmHAL::ChipSelectsConfigured (void) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->ChipSelectsConfigured (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetSystemClockFrequency +// --------------------------------------------------------------------------- + +int32 EmHAL::GetSystemClockFrequency (void) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetSystemClockFrequency (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetCanStop +// --------------------------------------------------------------------------- + +Bool EmHAL::GetCanStop (void) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetCanStop (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetAsleep +// --------------------------------------------------------------------------- + +Bool EmHAL::GetAsleep (void) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetAsleep (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetPortInputValue +// --------------------------------------------------------------------------- + +uint8 EmHAL::GetPortInputValue (int port) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetPortInputValue (port); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetPortInternalValue +// --------------------------------------------------------------------------- + +uint8 EmHAL::GetPortInternalValue (int port) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetPortInternalValue (port); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::PortDataChanged +// --------------------------------------------------------------------------- + +void EmHAL::PortDataChanged (int port, uint8 oldVal, uint8 newVal) +{ + EmAssert (EmHAL::GetRootHandler()); + EmHAL::GetRootHandler()->PortDataChanged (port, oldVal, newVal); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmHAL::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ + EmAssert (EmHAL::GetRootHandler()); + EmHAL::GetRootHandler()->GetKeyInfo (numRows, numCols, keyMap, rows); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::LineDriverChanged +// --------------------------------------------------------------------------- +// Open or close the transports in response to their line drivers being +// enabled or disabled. + +void EmHAL::LineDriverChanged (EmUARTDeviceType type) +{ + ErrCode err = errNone; + EmTransport* transport = gEmuPrefs->GetTransportForDevice (type); + + if (transport) + { + if (EmHAL::GetLineDriverState (type)) + { + err = transport->Open (); + } + else + { + /* err = */ transport->Close (); + } + + if (err != errNone) + { + string errString (transport->GetSpecificName ()); + ::PrvHandlePortOpenErrors (err, errString); + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmHAL::GetLineDriverState (EmUARTDeviceType type) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetLineDriverState (type); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetUARTDevice +// --------------------------------------------------------------------------- +// Return what sort of device is hooked up to the given UART. + +EmUARTDeviceType EmHAL::GetUARTDevice (int uartNum) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetUARTDevice (uartNum); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetLineDriverStates +// --------------------------------------------------------------------------- +// Collect all the states of all the driver types we know about. Pass in to +// this routine a variable of type Bool[kUARTEnd]. + +void EmHAL::GetLineDriverStates (Bool* states) +{ + for (EmUARTDeviceType ii = kUARTBegin; ii < kUARTEnd; ++ii) + { + states[ii] = EmHAL::GetLineDriverState (ii); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::CompareLineDriverStates +// --------------------------------------------------------------------------- +// Collect the current state of all the line drivers, and compare them to +// a previously-saved snapshot. For any differences, call LineDriverChanged. + +void EmHAL::CompareLineDriverStates (const Bool* oldStates) +{ + Bool newStates[kUARTEnd]; + EmHAL::GetLineDriverStates (newStates); + + for (EmUARTDeviceType ii = kUARTBegin; ii < kUARTEnd; ++ii) + { + if (newStates[ii] != oldStates[ii]) + { + EmHAL::LineDriverChanged (ii); + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetDTR +// --------------------------------------------------------------------------- +// DTR is "Data Terminal Ready". In the same way that the RTS signal is +// typically hooked up to the external device's CTS signal, our DTR pin is +// hooked up to the external device's DSR pin. It can be modified in order +// to tell the external device if we can accept any data. + +Bool EmHAL::GetDTR (int uartNum) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetDTR (uartNum); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::DTRChanged +// --------------------------------------------------------------------------- +// Called when the Palm OS changes the setting of the DTR pin. We respond +// to this change by reflecting the setting in the host's DTR pin. + +void EmHAL::DTRChanged (int uartNum) +{ + EmUARTDeviceType type = EmHAL::GetUARTDevice (uartNum); + EmTransport* transport = gEmuPrefs->GetTransportForDevice (type); + EmTransportSerial* serTransport = dynamic_cast<EmTransportSerial*> (transport); + + if (serTransport) + { + Bool state = EmHAL::GetDTR (uartNum); + PRINTF ("EmHAL::DTRChanged: DTR changed in emulated port to %d.", (int) state); + serTransport->SetDTR (state); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetVibrateOn +// --------------------------------------------------------------------------- + +Bool EmHAL::GetVibrateOn (void) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetVibrateOn (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHAL::GetLEDState +// --------------------------------------------------------------------------- + +uint16 EmHAL::GetLEDState (void) +{ + EmAssert (EmHAL::GetRootHandler()); + return EmHAL::GetRootHandler()->GetLEDState (); +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::EmHALHandler +// --------------------------------------------------------------------------- + +EmHALHandler::EmHALHandler (void) : + fNextHandler (NULL), + fPrevHandler (NULL) +{ + EmHAL::AddHandler (this); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::~EmHALHandler +// --------------------------------------------------------------------------- + +EmHALHandler::~EmHALHandler (void) +{ + EmHAL::RemoveHandler (this); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::Cycle +// --------------------------------------------------------------------------- + +void EmHALHandler::Cycle (Bool sleeping) +{ + EmAssert (this->GetNextHandler()); + this->GetNextHandler()->Cycle (sleeping); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::CycleSlowly +// --------------------------------------------------------------------------- + +void EmHALHandler::CycleSlowly (Bool sleeping) +{ + EmAssert (this->GetNextHandler()); + this->GetNextHandler()->CycleSlowly (sleeping); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::ButtonEvent +// --------------------------------------------------------------------------- + +void EmHALHandler::ButtonEvent (SkinElementType button, Bool buttonIsDown) +{ + EmAssert (this->GetNextHandler()); + this->GetNextHandler()->ButtonEvent (button, buttonIsDown); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::TurnSoundOff +// --------------------------------------------------------------------------- + +void EmHALHandler::TurnSoundOff (void) +{ + EmAssert (this->GetNextHandler()); + this->GetNextHandler()->TurnSoundOff (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::ResetTimer +// --------------------------------------------------------------------------- + +void EmHALHandler::ResetTimer (void) +{ + EmAssert (this->GetNextHandler()); + this->GetNextHandler()->ResetTimer (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::ResetRTC +// --------------------------------------------------------------------------- + +void EmHALHandler::ResetRTC (void) +{ + EmAssert (this->GetNextHandler()); + this->GetNextHandler()->ResetRTC (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetInterruptLevel +// --------------------------------------------------------------------------- + +int32 EmHALHandler::GetInterruptLevel (void) +{ + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->GetInterruptLevel (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetInterruptBase +// --------------------------------------------------------------------------- + +int32 EmHALHandler::GetInterruptBase (void) +{ + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->GetInterruptBase (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmHALHandler::GetLCDScreenOn (void) +{ + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->GetLCDScreenOn (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmHALHandler::GetLCDBacklightOn (void) +{ + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->GetLCDBacklightOn (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetLCDHasFrame +// --------------------------------------------------------------------------- + +Bool EmHALHandler::GetLCDHasFrame (void) +{ + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->GetLCDHasFrame (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetLCDBeginEnd +// --------------------------------------------------------------------------- + +void EmHALHandler::GetLCDBeginEnd (emuptr& begin, emuptr& end) +{ + EmAssert (this->GetNextHandler()); + this->GetNextHandler()->GetLCDBeginEnd (begin, end); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetLCDScanlines +// --------------------------------------------------------------------------- + +void EmHALHandler::GetLCDScanlines (EmScreenUpdateInfo& info) +{ + EmAssert (this->GetNextHandler()); + this->GetNextHandler()->GetLCDScanlines (info); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetDynamicHeapSize +// --------------------------------------------------------------------------- + +int32 EmHALHandler::GetDynamicHeapSize (void) +{ + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->GetDynamicHeapSize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetROMSize +// --------------------------------------------------------------------------- + +int32 EmHALHandler::GetROMSize (void) +{ + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->GetROMSize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetROMBaseAddress +// --------------------------------------------------------------------------- + +emuptr EmHALHandler::GetROMBaseAddress (void) +{ + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->GetROMBaseAddress (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::ChipSelectsConfigured +// --------------------------------------------------------------------------- + +Bool EmHALHandler::ChipSelectsConfigured (void) +{ + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->ChipSelectsConfigured (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetSystemClockFrequency +// --------------------------------------------------------------------------- + +int32 EmHALHandler::GetSystemClockFrequency (void) +{ + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->GetSystemClockFrequency (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetCanStop +// --------------------------------------------------------------------------- + +Bool EmHALHandler::GetCanStop (void) +{ + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->GetCanStop (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetAsleep +// --------------------------------------------------------------------------- + +Bool EmHALHandler::GetAsleep (void) +{ + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->GetAsleep (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetPortInputValue +// --------------------------------------------------------------------------- + +uint8 EmHALHandler::GetPortInputValue (int port) +{ + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->GetPortInputValue (port); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetPortInternalValue +// --------------------------------------------------------------------------- + +uint8 EmHALHandler::GetPortInternalValue (int port) +{ + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->GetPortInternalValue (port); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::PortDataChanged +// --------------------------------------------------------------------------- + +void EmHALHandler::PortDataChanged (int port, uint8 oldVal, uint8 newVal) +{ + EmAssert (this->GetNextHandler()); + this->GetNextHandler()->PortDataChanged (port, oldVal, newVal); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmHALHandler::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ + EmAssert (this->GetNextHandler()); + this->GetNextHandler()->GetKeyInfo (numRows, numCols, keyMap, rows); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmHALHandler::GetLineDriverState (EmUARTDeviceType type) +{ + if (EmHALHandler::GetNextHandler()) + { + return EmHALHandler::GetNextHandler()->GetLineDriverState (type); + } + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetUARTDevice +// --------------------------------------------------------------------------- +// Return what sort of device is hooked up to the given UART. + +EmUARTDeviceType EmHALHandler::GetUARTDevice (int uartNum) +{ + if (EmHALHandler::GetNextHandler()) + { + return EmHALHandler::GetNextHandler()->GetUARTDevice (uartNum); + } + + return kUARTNone; +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetDTR +// --------------------------------------------------------------------------- +// DTR is "Data Terminal Ready". In the same way that the RTS signal is +// typically hooked up to the external device's CTS signal, our DTR pin is +// hooked up to the external device's DSR pin. It can be modified in order +// to tell the external device if we can accept any data. + +Bool EmHALHandler::GetDTR (int uartNum) +{ + if (EmHALHandler::GetNextHandler()) + { + return EmHALHandler::GetNextHandler()->GetDTR (uartNum); + } + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetVibrateOn +// --------------------------------------------------------------------------- + +Bool EmHALHandler::GetVibrateOn (void) +{ + if (!this->GetNextHandler()) + return false; + + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->GetVibrateOn (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmHALHandler::GetLEDState +// --------------------------------------------------------------------------- + +uint16 EmHALHandler::GetLEDState (void) +{ + if (!this->GetNextHandler()) + return 0; + + EmAssert (this->GetNextHandler()); + return this->GetNextHandler()->GetLEDState (); +} + + +/*********************************************************************** + * + * FUNCTION: PrvHandlePortOpenErrors + * + * DESCRIPTION: . + * + * PARAMETERS: none. + * + * RETURNED: nothing, but displays one of two warnings if its cases + * are tripped. + * + ***********************************************************************/ + +void PrvHandlePortOpenErrors (ErrCode err, string errString) +{ + switch (err) + { + // access denied, comm port, on Win32 + case 5: + Errors::ReportErrCommPort (errString); + break; + + // comm port error on Mac + case -97: + Errors::ReportErrCommPort (errString); + break; + } +} diff --git a/SrcShared/Hardware/EmHAL.h b/SrcShared/Hardware/EmHAL.h new file mode 100644 index 0000000..4f01752 --- /dev/null +++ b/SrcShared/Hardware/EmHAL.h @@ -0,0 +1,164 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmHAL_h +#define EmHAL_h + +#include "Skins.h" // SkinElementType + +class EmHAL; +class EmPixMap; +class EmScreenUpdateInfo; + +enum +{ + kLEDOff = 0x00, + kLEDGreen = 0x01, + kLEDRed = 0x02 +}; + +enum EmUARTDeviceType +{ + kUARTBegin = 0, + + kUARTSerial = kUARTBegin, + kUARTIR, + kUARTBluetooth, + kUARTMystery, + kUARTNone, + + kUARTEnd +}; + +DEFINE_SCALAR_MODIFIERS (EmUARTDeviceType) + +class EmHALHandler +{ + public: + EmHALHandler (void); + virtual ~EmHALHandler (void); + + virtual void Cycle (Bool sleeping); + virtual void CycleSlowly (Bool sleeping); + + virtual void ButtonEvent (SkinElementType, Bool buttonIsDown); + virtual void TurnSoundOff (void); + virtual void ResetTimer (void); + virtual void ResetRTC (void); + + virtual int32 GetInterruptLevel (void); + virtual int32 GetInterruptBase (void); + + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLCDHasFrame (void); + virtual void GetLCDBeginEnd (emuptr&, emuptr&); + virtual void GetLCDScanlines (EmScreenUpdateInfo& info); + + virtual int32 GetDynamicHeapSize (void); + virtual int32 GetROMSize (void); + virtual emuptr GetROMBaseAddress (void); + virtual Bool ChipSelectsConfigured (void); + virtual int32 GetSystemClockFrequency (void); + virtual Bool GetCanStop (void); + virtual Bool GetAsleep (void); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void PortDataChanged (int, uint8, uint8); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); + + virtual Bool GetLineDriverState (EmUARTDeviceType); + virtual EmUARTDeviceType GetUARTDevice (int uartNum); + + virtual Bool GetDTR (int uartNum); + + virtual Bool GetVibrateOn (void); + virtual uint16 GetLEDState (void); + + protected: + EmHALHandler* GetNextHandler (void) { return fNextHandler; } + + private: + EmHALHandler* fNextHandler; + EmHALHandler* fPrevHandler; + + friend class EmHAL; +}; + + +class EmHAL +{ + public: + static void AddHandler (EmHALHandler*); + static void RemoveHandler (EmHALHandler*); + static void EnsureCoverage (void); + + static void Cycle (Bool sleeping); + static void CycleSlowly (Bool sleeping); + + static void ButtonEvent (SkinElementType, Bool buttonIsDown); + static void TurnSoundOff (void); + static void ResetTimer (void); + static void ResetRTC (void); + + static int32 GetInterruptLevel (void); + static int32 GetInterruptBase (void); + + static Bool GetLCDScreenOn (void); + static Bool GetLCDBacklightOn (void); + static Bool GetLCDHasFrame (void); + static void GetLCDBeginEnd (emuptr&, emuptr&); + static void GetLCDScanlines (EmScreenUpdateInfo& info); + + static int32 GetDynamicHeapSize (void); + static int32 GetROMSize (void); + static emuptr GetROMBaseAddress (void); + static Bool ChipSelectsConfigured (void); + static int32 GetSystemClockFrequency (void); + static Bool GetCanStop (void); + static Bool GetAsleep (void); + + static uint8 GetPortInputValue (int); + static uint8 GetPortInternalValue (int); + static void PortDataChanged (int, uint8, uint8); + static void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); + + static void LineDriverChanged (EmUARTDeviceType); + static Bool GetLineDriverState (EmUARTDeviceType); + static EmUARTDeviceType GetUARTDevice (int uartNum); + + static void GetLineDriverStates (Bool* states); + static void CompareLineDriverStates (const Bool* oldStates); + + static Bool GetDTR (int uartNum); + static void DTRChanged (int uartNum); + + static Bool GetVibrateOn (void); + static uint16 GetLEDState (void); + + private: + static EmHALHandler* GetRootHandler (void) { return fgRootHandler; } + static EmHALHandler* fgRootHandler; +}; + +inline void EmHAL::Cycle (Bool sleeping) +{ + EmAssert (EmHAL::GetRootHandler()); + EmHAL::GetRootHandler()->Cycle (sleeping); +} + + +#endif /* EmHAL_h */ diff --git a/SrcShared/Hardware/EmMemory.cpp b/SrcShared/Hardware/EmMemory.cpp new file mode 100644 index 0000000..90051ac --- /dev/null +++ b/SrcShared/Hardware/EmMemory.cpp @@ -0,0 +1,1342 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1998-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmMemory.h" + +#include "EmBankDRAM.h" // EmBankDRAM::Initialize +#include "EmBankDummy.h" // EmBankDummy::Initialize +#include "EmBankMapped.h" // EmBankMapped::Initialize +#include "EmBankRegs.h" // EmBankRegs::Initialize +#include "EmBankROM.h" // EmBankROM::Initialize +#include "EmBankSRAM.h" // EmBankSRAM::Initialize +#include "EmSession.h" // gSession, GetDevice +#include "MetaMemory.h" // MetaMemory::Initialize + + +#if HAS_PROFILING +#include "Profiling.h" // gProfilingCounted +#endif + + +/* + Hitchhiker's Guide To Accessing Memory + + When emulating CPU instructions, all memory access must be emulated as + well. Additionally, the memory location that the emulated instruction + is accessing is not necessarily the same as the memory location in the + emulator's address space. That is, memory location 0x00001234 in the + emulated process's address space is not the same as memory location + 0x00001234 in the emulator's address space. Instead, the emulated + 0x00001234 is actually 0x00001234 bytes into some buffer that we've + allocate for the purpose of holding the emulated address space's contents. + + There are several ranges of Palm OS memory that we need to emulate: + + - Low-memory RAM (for the dynamic heap) + - High-memory RAM (for the storage heap) + - ROM + - Dragonball and other memory-mapped registers + - Everything else + + Each of these ranges (except for the last one) is managed by a set of + functions for reading from and writing to that memory and a chunk of + memory that we allocate as a "backing store" for that memory. + + Thus, for each of these ranges, we need to quickly determine what set of + functions need to be called. The method for doing this is to divide the + entire 4GB address space into 64K banks, each 64K long. + + Each 64K bank is managed by a set of functions. These functions handle + reading from and writing to that 64K bank, handling 1-byte, 2-byte, and + 4-byte accesses. They also manage mapping from the emulated addres space + to the physical space as viewed by the emulator, and validate memory + addresses. + + Because there are 64K of these 64K banks, the functions that manage each + bank are stored in an array of 64K elements. When we need to invoke a + function for a particular bank, the upper word of the prospective memory + address is used as a "bank index" into this array. From that, the right + set of functions is found, and the desired function from that set of + functions is called. + + This 64K array is very sparse. There are one to four entries for managing + the dynamic heap (depending on whether the dynamic heap is 64K, 96K, 128K, + or 256K), 2 to 128 entries for the storage heap (depending on whether the + storage heap is 128K to 8Meg), 8 to 32 entries for the ROM (again, + depending on its size), and 1 for the Dragonball registers. That leaves + the remaining 64K - 12 entries to be managed by a set of functions that do + little but signal an address error if the memory they manage is being + accessed. + + Pictorally, it looks like this: + + Emulated 4G space: Memory function array Address Bank functions + + 0x00000000 +--------------+ +--------------------------------+ + | 64K |<---| Ptr to fns that mng this range |------+ + 0x00010000 +--------------+ +--------------------------------+ | + | 64K |<---| Ptr to fns that mng this range |------+ + 0x00020000 +--------------+ +--------------------------------+ | + | 64K | +-----> EmBankDRAM::GetLong, EmBankDRAM::SetLong + \/\/\/\/\/\/\/\/ EmBankDRAM::GetWord, EmBankDRAM::SetWord + \/\/\/\/\/\/\/\/ EmBankDRAM::GetByte, EmBankDRAM::SetByte + | 64K | etc. + 0x10000000 +--------------+ +--------------------------------+ + | 64K |<---| Ptr to fns that mng this range |------+ + 0x10010000 +--------------+ +--------------------------------+ | + | 64K |<---| Ptr to fns that mng this range |------+ + 0x10020000 +--------------+ +--------------------------------+ | + | 64K | +-----> EmBankSRAM::GetLong, EmBankSRAM::SetLong + \/\/\/\/\/\/\/\/ EmBankSRAM::GetWord, EmBankSRAM::SetWord + \/\/\/\/\/\/\/\/ EmBankSRAM::GetByte, EmBankSRAM::SetByte + | 64K | etc. + 0x10C00000 +--------------+ +--------------------------------+ + | 64K |<---| Ptr to fns that mng this range |------+ + 0x10C10000 +--------------+ +--------------------------------+ | + | 64K |<---| Ptr to fns that mng this range |------+ + 0x10C20000 +--------------+ +--------------------------------+ | + | 64K | +-----> EmBankROM::GetLong, EmBankROM::SetLong + \/\/\/\/\/\/\/\/ EmBankROM::GetWord, EmBankROM::SetWord + \/\/\/\/\/\/\/\/ EmBankROM::GetByte, EmBankROM::SetByte + | 64K | etc. + 0xFFFE0000 +--------------+ +--------------------------------+ + | 64K |<---| Ptr to fns that mng this range | + 0xFFFF0000 +--------------+ +--------------------------------+ + | 64K |<---| Ptr to fns that mng this range |------+ + 0xFFFFFFFF +--------------+ +--------------------------------+ | + +-----> EmRegs::GetLong, EmRegs::SetLong + EmRegs::GetWord, EmRegs::SetWord + EmRegs::GetByte, EmRegs::SetByte + etc. + + All of the remaining memory function array entries are initialized with + pointers to the EmBankDummy::GetLong, EmBankDummy::SetLong, etc., set of + functions. + + Using EmBankMapped accessors, we also have the facility for mapping memory + from the emulator's address space directly into the emulated address + space. This memory appears as additional RAM that magically appears out + of nowhere. This mechanism makes it easy for us to "inject" data into the + emulated address space. It also makes it easier to call emulated ROM + functions as subroutines. Some ROM functions take as parameters pointers + to memory locations that are to receive values (for example, pointers to + local variables). For those functions, we just map the emulator's stack + into the emulated address space. After that's done, we can pass pointers + to stack-based variables with impunity. + + A 64K bank can be further sub-divided into 1, 2, or 4 byte chunks + spanning any range of the 64K chunk. EmBankRegs manages a collection + of EmRegs objects. The EmRegs abstract base class is sub-classed into + classes that specify the sub-range of the 64K for which they are + responsible and dispatch memory accesses to individual functions + that handle accesses at more-or-less a byte level. + + Mapping from emulated addresses to "real" addresses (that is, the + corresponding memory locations within the buffers we've allocated to + "stand in" for the emulated memory) is performed via macros and inline + functions, described below. + + Executive summary: + + - use EmMemGetFoo if you want the address checked for even/oddness. + - use EmMemDoGetFoo to actually get the value using a physical address. + + EmMemGet32, EmMemGet16, EmMemGet8 + EmMemPut32, EmMemPut16, EmMemPut8 + Inline functions that dispatch to the right bank of functions + using EmMemCallGetFunc, EmMemGetBank, and EmMemBankIndex. + + EmMemBankIndex + Returns a bank index for the given address. + + EmMemGetBank + Gets the right EmAddressBank object. + + EmMemCallGetFunc + Merely calls the given function through the EmAddressBank fn ptr. + + EmMemDoGet32, EmMemDoGet16, EmMemDoGet8 + EmMemDoPut32, EmMemDoPut16, EmMemDoPut8 + Very low-level memory access. They return the value at the + given physical location, byte-swapping if needed. +*/ + +// Types. + +#pragma mark Types + +// Globals. + +#pragma mark Globals + +EmAddressBank* gEmMemBanks[65536]; // (normally defined in memory.c) + +Bool gPCInRAM; +Bool gPCInROM; + +MemAccessFlags gMemAccessFlags = +{ + MASTER_RUNTIME_VALIDATE_SWITCH, + MASTER_RUNTIME_VALIDATE_SWITCH, + MASTER_RUNTIME_VALIDATE_SWITCH, + MASTER_RUNTIME_VALIDATE_SWITCH, + MASTER_RUNTIME_VALIDATE_SWITCH, + MASTER_RUNTIME_VALIDATE_SWITCH, + MASTER_RUNTIME_VALIDATE_SWITCH, + MASTER_RUNTIME_VALIDATE_SWITCH, + MASTER_RUNTIME_VALIDATE_SWITCH, + MASTER_RUNTIME_VALIDATE_SWITCH, + + // User prevention flags. + +// MASTER_RUNTIME_PREVENT_SWITCH, +// MASTER_RUNTIME_PREVENT_SWITCH, +// MASTER_RUNTIME_PREVENT_SWITCH, +// MASTER_RUNTIME_PREVENT_SWITCH, +// MASTER_RUNTIME_PREVENT_SWITCH, +// MASTER_RUNTIME_PREVENT_SWITCH, + false, // SRAM-get + true, // SRAM-set + false, // ROM-get + true, // ROM-set (HACK: We really want it to be true!) + MASTER_RUNTIME_PREVENT_SWITCH, + MASTER_RUNTIME_PREVENT_SWITCH, + +// false, // fCheck_UserChunkGet +// false, // fCheck_UserChunkSet +// false, // fCheck_SysChunkGet +// false, // fCheck_SysChunkSet + + // System prevention flags. + +// MASTER_RUNTIME_PREVENT_SWITCH, +// MASTER_RUNTIME_PREVENT_SWITCH, +// MASTER_RUNTIME_PREVENT_SWITCH, +// MASTER_RUNTIME_PREVENT_SWITCH, +// MASTER_RUNTIME_PREVENT_SWITCH, +// MASTER_RUNTIME_PREVENT_SWITCH, +// false, // SRAM-get +// true, // SRAM-set + false, // ROM-get + true, // ROM-set (HACK: We really want it to be true!) +// MASTER_RUNTIME_PREVENT_SWITCH, +// MASTER_RUNTIME_PREVENT_SWITCH +}; + +MemAccessFlags kZeroMemAccessFlags; + + +#if PROFILE_MEMORY +/* + After 12 Million instructions executed... + + kDRAMLongRead, // 2,797,111 + kDRAMLongRead2, // + kDRAMWordRead, // 1,334,295 + kDRAMByteRead, // 427,936 + + kDRAMLongWrite, // 1,960,933 + kDRAMLongWrite2, // + kDRAMWordWrite, // 800,780 + kDRAMByteWrite, // 213,029 + + kSRAMLongRead, // 4,167 + kSRAMLongRead2, // 4,167 + kSRAMWordRead, // 10,768 + kSRAMByteRead, // 6,295 (jumped WAY up (5-fold) after playing with Address Book / 20 Million instructions) + + kSRAMLongWrite, // 516,246 (stable after boot?) + kSRAMLongWrite2, // + kSRAMWordWrite, // 5,112 + kSRAMByteWrite, // 2,183 + + kROMLongRead, // 10,156 + kROMLongRead2, // + kROMWordRead, // 557,062 + kROMByteRead, // 15,516 + + kROMLongWrite, // 0 + kROMLongWrite2, // + kROMWordWrite, // 0 + kROMByteWrite, // 0 + + kREGLongRead, // 16,638 + kREGLongRead2, // + kREGWordRead, // 30,477 + kREGByteRead, // 3,553 + + kREGLongWrite, // 9,472 + kREGLongWrite2, // + kREGWordWrite, // 20,709 + kREGByteWrite, // 12,656 + + + After 32,439,154 instructions: + + kDRAMLongRead, // 6,466,064 + kDRAMWordRead, // 3,342,826 + kDRAMByteRead, // 940,345 + + kDRAMLongWrite, // 4,136,635 + kDRAMWordWrite, // 1,462,995 + kDRAMByteWrite, // 509,189 + + kSRAMLongRead, // 24,355 + kSRAMWordRead, // 32,190 + kSRAMByteRead, // 75,917 + + kSRAMLongWrite, // 2,074,137 (8-Meg ROM) + kSRAMWordWrite, // 42,050 + kSRAMByteWrite, // 11,292 + + kROMLongRead, // 25,806 + kROMWordRead, // 1,302,897 + kROMByteRead, // 63,590 + + kROMLongWrite, // 0 + kROMWordWrite, // 0 + kROMByteWrite, // 0 + + kREGLongRead, // 32,037 + kREGWordRead, // 74,299 + kREGByteRead, // 91,930 + + kREGLongWrite, // 20,358 + kREGWordWrite, // 57,879 + kREGByteWrite, // 22,592 +*/ + +long gMemoryAccess[kLastEnum]; +#endif + + +#pragma mark - + + +// =========================================================================== +// ¥ Memory +// =========================================================================== + + +// --------------------------------------------------------------------------- +// ¥ Memory::Initialize +// --------------------------------------------------------------------------- +// Initializes the RAM, ROM, and special memory areas of the emulator. Takes +// a stream handle to the ROM. + +void Memory::Initialize ( EmStream& hROM, + RAMSizeType ramSize) +{ + // Clear everything out. + + memset (gEmMemBanks, 0, sizeof (gEmMemBanks)); + + // Initialize the valid memory banks. + + EmBankDummy::Initialize (); + + // Initialize the Hardware registers memory bank. Do this + // *before* initializing the other RAM banks so that we + // know how memory is laid out from the chip selects. + + EmBankRegs::Initialize (); + + // Initialize EmBankDRAM after initializing the EmBankSRAM. The order is + // important for DragonballEZ. On Dragonball devices, DRAM is + // at 0x00000000, and SRAM is at 0x10000000. But on EZ devices, + // both start at 0x00000000. By calling EmBankDRAM::Initialize + // second, we allow it to overwrite the EmAddressBank handlers + // for the part of memory where they overlap. + + EmBankSRAM::Initialize (ramSize); + EmBankDRAM::Initialize (); + + EmBankROM::Initialize (hROM); + + EmBankMapped::Initialize (); + + EmAssert (gSession); + if (gSession->GetDevice ().HasFlash ()) + EmBankFlash::Initialize (); + + MetaMemory::Initialize (); + +// Memory::ResetBankHandlers (); // Can't do this yet. We can't set the + // bank handlers until we know how memory + // is laid out, and that information isn't + // determined until reset. +} + + +/*********************************************************************** + * + * FUNCTION: Memory::Reset + * + * DESCRIPTION: Standard reset function. Sets the sub-system to a + * default state. This occurs not only on a Reset (as + * from the menu item), but also when the sub-system + * is first initialized (Reset is called after Initialize) + * as well as when the system is re-loaded from an + * insufficient session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void Memory::Reset (Bool hardwareReset) +{ + EmBankDummy::Reset (hardwareReset); + EmBankRegs::Reset (hardwareReset); + EmBankSRAM::Reset (hardwareReset); + EmBankDRAM::Reset (hardwareReset); + EmBankROM::Reset (hardwareReset); + EmBankMapped::Reset (hardwareReset); + + EmAssert (gSession); + if (gSession->GetDevice ().HasFlash ()) + EmBankFlash::Reset (hardwareReset); + + Memory::ResetBankHandlers (); + + MetaMemory::Reset (); +} + + +/*********************************************************************** + * + * FUNCTION: Memory::Save + * + * DESCRIPTION: Standard save function. Saves any sub-system state to + * the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void Memory::Save (SessionFile& f) +{ + EmBankDummy::Save (f); + EmBankRegs::Save (f); + EmBankSRAM::Save (f); + EmBankDRAM::Save (f); + EmBankROM::Save (f); + EmBankMapped::Save (f); + + EmAssert (gSession); + if (gSession->GetDevice ().HasFlash ()) + EmBankFlash::Save (f); + + MetaMemory::Save (f); +} + + +/*********************************************************************** + * + * FUNCTION: Memory::Load + * + * DESCRIPTION: Standard load function. Loads any sub-system state + * from the given session file. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void Memory::Load (SessionFile& f) +{ + EmBankDummy::Load (f); + EmBankRegs::Load (f); + EmBankSRAM::Load (f); + EmBankDRAM::Load (f); + EmBankROM::Load (f); + EmBankMapped::Load (f); + + EmAssert (gSession); + if (gSession->GetDevice ().HasFlash ()) + EmBankFlash::Load (f); + + MetaMemory::Load (f); + + Memory::ResetBankHandlers (); +} + + +/*********************************************************************** + * + * FUNCTION: Memory::Dispose + * + * DESCRIPTION: Standard dispose function. Completely release any + * resources acquired or allocated in Initialize and/or + * Load. + * + * PARAMETERS: None. + * + * RETURNED: Nothing. + * + ***********************************************************************/ + +void Memory::Dispose (void) +{ + EmBankDummy::Dispose (); + EmBankRegs::Dispose (); + EmBankSRAM::Dispose (); + EmBankDRAM::Dispose (); + EmBankROM::Dispose (); + EmBankMapped::Dispose (); + + // We can't reliably call GetDevice here. That's because the + // session may not have been initialized (we could be disposing + // of everything because an error condition occurred), and so + // there may be no assigned device yet. So we can't ask that + // device if there's flash. However, EmBankFlash::Dispose + // doesn't do anything, so we don'thave to worry about it + // being called. + +// EmAssert (gSession); +// if (gSession->GetDevice ().HasFlash ()) +// EmBankFlash::Dispose (); + + MetaMemory::Dispose (); +} + + +// --------------------------------------------------------------------------- +// ¥ Memory::InitializeBanks +// --------------------------------------------------------------------------- +// Initializes the specified memory banks with the given data. + +void Memory::InitializeBanks ( EmAddressBank& iBankInitializer, + int32 iStartingBankIndex, + int32 iNumberOfBanks) +{ + for (int32 aBankIndex = iStartingBankIndex; + aBankIndex < iStartingBankIndex + iNumberOfBanks; + aBankIndex++) + { + gEmMemBanks[aBankIndex] = &iBankInitializer; + } +} + + +// --------------------------------------------------------------------------- +// ¥ Memory::ResetBankHandlers +// --------------------------------------------------------------------------- +// Reset the memory bank handlers in response to the chip selects changing. +// Also called on Initialize, Reset, and Load, just to make sure everything's +// nailed down. + +void Memory::ResetBankHandlers (void) +{ + EmBankDummy::SetBankHandlers (); + EmBankRegs::SetBankHandlers (); + EmBankSRAM::SetBankHandlers (); + EmBankDRAM::SetBankHandlers (); + EmBankROM::SetBankHandlers (); + EmBankMapped::SetBankHandlers (); + + if (gSession->GetDevice ().HardwareID () == 0x0a /*halModelIDVisorPrism*/) + { + // Run this one again. Visor Prism has this thing where the USB + // controller is at 0x10800000, but it sets up the ROM chip select + // for 0x10000000 to 0x10FFFFFF. In order to not have EmBankROM + // take control over the USB chip, have EmBankRegs install *after* + // EmBankROM. + EmBankRegs::SetBankHandlers (); + } + + EmAssert (gSession); + if (gSession->GetDevice ().HasFlash ()) + EmBankFlash::SetBankHandlers (); +} + + +// --------------------------------------------------------------------------- +// ¥ Memory::MapPhysicalMemory +// --------------------------------------------------------------------------- +// Maps a range of physical memory to appear at the same location of the +// emulated Palm OS's virtual memory. + +void Memory::MapPhysicalMemory (const void* addr, uint32 size) +{ + EmBankMapped::MapPhysicalMemory (addr, size); +} + + +// --------------------------------------------------------------------------- +// ¥ Memory::UnmapPhysicalMemory +// --------------------------------------------------------------------------- +// Unmaps a range of physical memory from appearing at the same location of +// the emulated Palm OS's virtual memory. + +void Memory::UnmapPhysicalMemory (const void* addr) +{ + EmBankMapped::UnmapPhysicalMemory (addr); +} + + +// --------------------------------------------------------------------------- +// ¥ Memory::GetMappingInfo +// --------------------------------------------------------------------------- + +void Memory::GetMappingInfo (emuptr addr, void** start, uint32* len) +{ + EmBankMapped::GetMappingInfo (addr, start, len); +} + + +// --------------------------------------------------------------------------- +// ¥ Memory::CheckNewPC +// --------------------------------------------------------------------------- + +void Memory::CheckNewPC (emuptr newPC) +{ + gPCInRAM = newPC < EmBankROM::GetMemoryStart (); + gPCInROM = newPC >= EmBankROM::GetMemoryStart (); +} + + +#pragma mark - + +// =========================================================================== +// ¥ CEnableFullAccess +// =========================================================================== + +long CEnableFullAccess::fgAccessCount = 0; + + +// --------------------------------------------------------------------------- +// ¥ CEnableFullAccess::CEnableFullAccess +// --------------------------------------------------------------------------- + +CEnableFullAccess::CEnableFullAccess (void) : + fOldMemAccessFlags (gMemAccessFlags) +#if HAS_PROFILING + , fOldProfilingCounted (gProfilingCounted) +#endif +{ + gMemAccessFlags = kZeroMemAccessFlags; + +#if HAS_PROFILING + gProfilingCounted = false; +#endif + + ++fgAccessCount; +} + + +// --------------------------------------------------------------------------- +// ¥ CEnableFullAccess::~CEnableFullAccess +// --------------------------------------------------------------------------- + +CEnableFullAccess::~CEnableFullAccess (void) +{ + gMemAccessFlags = fOldMemAccessFlags; + +#if HAS_PROFILING + gProfilingCounted = fOldProfilingCounted; +#endif + + --fgAccessCount; +} + + +// --------------------------------------------------------------------------- +// ¥ CEnableFullAccess::AccessOK +// --------------------------------------------------------------------------- + +Bool CEnableFullAccess::AccessOK (void) +{ + return fgAccessCount > 0; +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// These functions with two kinds of "pointers": emuptr's +// and void*'s. Accessing memory for each kind of pointer is different. +// Since the functions are template functions, we can't know at the time we +// write the function what kind of pointer we'll be dealing with, so we can't +// hard-code the memory-accessing method. Instead, we provide all of these +// inline accessors and let the compiler sort it out. +// --------------------------------------------------------------------------- + +inline char _get_byte(const void* p) +{ + return *(char*) p; +} + +inline char _get_byte(emuptr p) +{ + return (char) EmMemGet8(p); +} + +inline void _put_byte(void* p, const uint8 v) +{ + *(uint8*) p = v; +} + +inline void _put_byte(emuptr p, const uint8 v) +{ + EmMemPut8(p, v); +} + +inline uint16 _get_word(const void* p) +{ + return *(uint16*) p; +} + +inline uint16 _get_word(emuptr p) +{ + return (uint16) EmMemGet16(p); +} + +inline void _put_word(void* p, const uint16 v) +{ + *(uint16*) p = v; +} + +inline void _put_word(emuptr p, const uint16 v) +{ + EmMemPut16(p, v); +} + +inline uint32 _get_long(const void* p) +{ + return *(uint32*) p; +} + +inline uint32 _get_long(emuptr p) +{ + return (uint32) EmMemGet32(p); +} + +inline void _put_long(void* p, const uint32 v) +{ + *(uint32*) p = v; +} + +inline void _put_long(emuptr p, const uint32 v) +{ + EmMemPut32(p, v); +} + +inline const void* _get_real_address(const void* p) +{ + return p; +} + +inline const void* _get_real_address(emuptr p) +{ + return EmMemGetRealAddress(p); +} + +template <class T> +inline void _add_delta (T*& v, long delta) +{ + v = (T*) (((char*) v) + delta); +} + +inline void _add_delta (emuptr& v, long delta) +{ + v += delta; +} + +template <class T> +inline void _increment (T& v) +{ + _add_delta (v, 1); +} + +template <class T> +inline void _decrement (T& v) +{ + _add_delta (v, -1); +} + + +#pragma mark - + +/*********************************************************************** + * + * FUNCTION: EmMem_memset + * + * DESCRIPTION: Same as Std C Library memset function. + * + * PARAMETERS: Same as Std C Library memset function. + * + * RETURNED: Same as Std C Library memset function. + * + ***********************************************************************/ + +emuptr EmMem_memset(emuptr dst, int val, size_t len) +{ + emuptr q = dst; + + uint32 longVal = val; + longVal |= (longVal << 8); + longVal |= (longVal << 16); + + EmMemPutFunc longPutter = EmMemGetBank(dst).lput; + EmMemPutFunc bytePutter = EmMemGetBank(dst).bput; + + while ((q & 3) && len > 0) // while there are leading bytes + { + bytePutter(q, val); + q += sizeof (char); + len -= sizeof (char); + } + + while (len >= sizeof (long)) // while there are middle longs + { + longPutter(q, longVal); + q += sizeof (long); + len -= sizeof (long); + } + + while (len > 0) // while there are trailing bytes + { + bytePutter(q, val); + q += sizeof (char); + len -= sizeof (char); + } + + return dst; +} + + +/*********************************************************************** + * + * FUNCTION: EmMem_memchr + * + * DESCRIPTION: Same as Std C Library memchr function. + * + * PARAMETERS: Same as Std C Library memchr function. + * + * RETURNED: Same as Std C Library memchr function. + * + ***********************************************************************/ + +emuptr EmMem_memchr(emuptr src, int val, size_t len) +{ + emuptr p = src; + + ++len; + + while (--len) + { + if (_get_byte (p) == val) + return p; + + _increment (p); + } + + return EmMemNULL; +} + + +/*********************************************************************** + * + * FUNCTION: EmMem_memcmp + * + * DESCRIPTION: Same as Std C Library memcmp function. + * + * PARAMETERS: Same as Std C Library memcmp function. + * + * RETURNED: Same as Std C Library memcmp function. + * + ***********************************************************************/ + +template <class T1, class T2> +int EmMem_memcmp(T1 src1, T2 src2, size_t len) +{ + T1 p1 = src1; + T2 p2 = src2; + + ++len; + + while (--len) + { + unsigned char ch1 = _get_byte (p1); + unsigned char ch2 = _get_byte (p2); + + if (ch1 != ch2) + return (ch1 < ch2) ? -1 : 1; + + _increment (p1); + _increment (p2); + } + + return 0; +} + + // Instantiate EmMem_memcmp's that work with: + // + // dest source + // ------ ------ + // void* emuptr + // const void* emuptr + // emuptr void* + // emuptr const void* + // emuptr emuptr + +template int EmMem_memcmp<void*, emuptr> (void* dst, emuptr src, size_t len); +template int EmMem_memcmp<const void*, emuptr> (const void* dst, emuptr src, size_t len); +template int EmMem_memcmp<emuptr, void*> (emuptr dst, void* src, size_t len); +template int EmMem_memcmp<emuptr, const void*> (emuptr dst, const void* src, size_t len); +template int EmMem_memcmp<emuptr, emuptr> (emuptr dst, emuptr src, size_t len); + + +/*********************************************************************** + * + * FUNCTION: EmMem_memcpy + * + * DESCRIPTION: Same as Std C Library memcpy function. + * + * PARAMETERS: Same as Std C Library memcpy function. + * + * RETURNED: Same as Std C Library memcpy function. + * + ***********************************************************************/ + +template <class T1, class T2> +T1 EmMem_memcpy (T1 dst, T2 src, size_t len) +{ + T1 q = dst; + T2 p = src; + + while (len--) + { + _put_byte(q, _get_byte(p)); + _increment (q); + _increment (p); + } + + return dst; +} + + // Instantiate EmMem_memcpy's that work with: + // + // dest source + // ------ ------ + // void* emuptr + // emuptr void* + // emuptr const void* + // emuptr emuptr + +template void* EmMem_memcpy<void*, emuptr> (void* dst, emuptr src, size_t len); +template emuptr EmMem_memcpy<emuptr, void*> (emuptr dst, void* src, size_t len); +template emuptr EmMem_memcpy<emuptr, const void*> (emuptr dst, const void* src, size_t len); +template emuptr EmMem_memcpy<emuptr, emuptr> (emuptr dst, emuptr src, size_t len); + + +/*********************************************************************** + * + * FUNCTION: EmMem_memmove + * + * DESCRIPTION: Same as Std C Library memmove function. + * + * PARAMETERS: Same as Std C Library memmove function. + * + * RETURNED: Same as Std C Library memmove function. + * + ***********************************************************************/ + +template <class T1, class T2> +T1 EmMem_memmove (T1 dst, T2 src, size_t len) +{ + T1 q = dst; + T2 p = src; + + Bool backward = _get_real_address(dst) <= _get_real_address(src); + + if (backward) + { + while (len--) + { + _put_byte(q, _get_byte(p)); + _increment (q); + _increment (p); + } + } + else + { + _add_delta (q, len); + _add_delta (p, len); + + while (len--) + { + _decrement (q); + _decrement (p); + _put_byte(q, _get_byte(p)); + } + } + + return dst; +} + + // Instantiate EmMem_memmove's that work with: + // + // dest source + // ------ ------ + // void* emuptr + // emuptr void* + // emuptr const void* + // emuptr emuptr + +template void* EmMem_memmove<void*, emuptr> (void* dst, emuptr src, size_t len); +template emuptr EmMem_memmove<emuptr, void*> (emuptr dst, void* src, size_t len); +template emuptr EmMem_memmove<emuptr, const void*> (emuptr dst, const void* src, size_t len); +template emuptr EmMem_memmove<emuptr, emuptr> (emuptr dst, emuptr src, size_t len); + + +#pragma mark - + +/*********************************************************************** + * + * FUNCTION: EmMem_strlen + * + * DESCRIPTION: Same as Std C Library strlen function. + * + * PARAMETERS: Same as Std C Library strlen function. + * + * RETURNED: Same as Std C Library strlen function. + * + ***********************************************************************/ + +size_t EmMem_strlen(emuptr str) +{ + emuptr eos = str; + + while (_get_byte(eos)) + _increment (eos); + + return ((size_t) (eos - str)); +} + + +/*********************************************************************** + * + * FUNCTION: EmMem_strcpy + * + * DESCRIPTION: Same as Std C Library strcpy function. + * + * PARAMETERS: Same as Std C Library strcpy function. + * + * RETURNED: Same as Std C Library strcpy function. + * + ***********************************************************************/ + +template <class T1, class T2> +T1 EmMem_strcpy(T1 dst, T2 src) +{ + T1 q = dst; + T2 p = src; + char ch; + + do { + ch = _get_byte (p); + _increment (p); + _put_byte (q, ch); + _increment (q); + } while (ch); + + return dst; +} + + // Instantiate EmMem_strcpy's that work with: + // + // dest source + // ------ ------ + // char* emuptr + // emuptr char* + // emuptr const char* + // emuptr emuptr + +template char* EmMem_strcpy<char*, emuptr> (char* dst, emuptr src); +template emuptr EmMem_strcpy<emuptr, char*> (emuptr dst, char* src); +template emuptr EmMem_strcpy<emuptr, const char*> (emuptr dst, const char* src); +template emuptr EmMem_strcpy<emuptr, emuptr> (emuptr dst, emuptr src); + + +/*********************************************************************** + * + * FUNCTION: EmMem_strncpy + * + * DESCRIPTION: Same as Std C Library strncpy function. + * + * PARAMETERS: Same as Std C Library strncpy function. + * + * RETURNED: Same as Std C Library strncpy function. + * + ***********************************************************************/ + +template <class T1, class T2> +T1 EmMem_strncpy(T1 dst, T2 src, size_t len) +{ + T1 q = dst; + T2 p = src; + + ++len; + + while (--len) + { + char ch = _get_byte(p); + _increment (p); + + _put_byte (q, ch); + _increment (q); + + if (!ch) + { + while (--len) + { + _put_byte (q, 0); + _increment (q); + } + + break; + } + } + + return dst; +} + + // Instantiate EmMem_strncpy's that work with: + // + // dest source + // ------ ------ + // char* emuptr + // emuptr char* + // emuptr const char* + // emuptr emuptr + +template char* EmMem_strncpy<char*, emuptr> (char* dst, emuptr src, size_t len); +template emuptr EmMem_strncpy<emuptr, char*> (emuptr dst, char* src, size_t len); +template emuptr EmMem_strncpy<emuptr, const char*> (emuptr dst, const char* src, size_t len); +template emuptr EmMem_strncpy<emuptr, emuptr> (emuptr dst, emuptr src, size_t len); + + +/*********************************************************************** + * + * FUNCTION: EmMem_strcat + * + * DESCRIPTION: Same as Std C Library strcat function. + * + * PARAMETERS: Same as Std C Library strcat function. + * + * RETURNED: Same as Std C Library strcat function. + * + ***********************************************************************/ + +template <class T1, class T2> +T1 EmMem_strcat(T1 dst, T2 src) +{ + T1 q = dst; + T2 p = src; + + while (_get_byte (q)) + _increment(q); + + while (_get_byte (p)) + { + _put_byte (q, _get_byte (p)); + _increment(q); + _increment(p); + } + + _put_byte (q, 0); + + return dst; +} + + // Instantiate EmMem_strcat's that work with: + // + // dest source + // ------ ------ + // char* emuptr + // emuptr char* + // emuptr const char* + // emuptr emuptr + +template char* EmMem_strcat<char*, emuptr> (char* dst, emuptr src); +template emuptr EmMem_strcat<emuptr, char*> (emuptr dst, char* src); +template emuptr EmMem_strcat<emuptr, const char*> (emuptr dst, const char* src); +template emuptr EmMem_strcat<emuptr, emuptr> (emuptr dst, emuptr src); + + +/*********************************************************************** + * + * FUNCTION: EmMem_strncat + * + * DESCRIPTION: Same as Std C Library strncat function. + * + * PARAMETERS: Same as Std C Library strncat function. + * + * RETURNED: Same as Std C Library strncat function. + * + ***********************************************************************/ + +template <class T1, class T2> +T1 EmMem_strncat(T1 dst, T2 src, size_t len) +{ + T1 q = dst; + T2 p = src; + + while (_get_byte (q)) + _increment (q); + + ++len; + + while (--len) + { + char ch = _get_byte(p); + _increment (p); + + _put_byte (q, ch); + _increment (q); + + if (!ch) + return dst; + } + + _put_byte (q, 0); + + return dst; +} + + // Instantiate EmMem_strncat's that work with: + // + // dest source + // ------ ------ + // char* emuptr + // emuptr char* + // emuptr const char* + // emuptr emuptr + +template char* EmMem_strncat<char*, emuptr> (char* dst, emuptr src, size_t len); +template emuptr EmMem_strncat<emuptr, char*> (emuptr dst, char* src, size_t len); +template emuptr EmMem_strncat<emuptr, const char*> (emuptr dst, const char* src, size_t len); +template emuptr EmMem_strncat<emuptr, emuptr> (emuptr dst, emuptr src, size_t len); + + +/*********************************************************************** + * + * FUNCTION: EmMem_strcmp + * + * DESCRIPTION: Same as Std C Library strcmp function. + * + * PARAMETERS: Same as Std C Library strcmp function. + * + * RETURNED: Same as Std C Library strcmp function. + * + ***********************************************************************/ + +template <class T1, class T2> +int EmMem_strcmp(T1 dst, T2 src) +{ + T1 p1 = dst; + T2 p2 = src; + + while (1) + { + unsigned char c1 = _get_byte (p1); + unsigned char c2 = _get_byte (p2); + + if (c1 != c2) + return (c1 - c2); + else if (!c1) + break; + + _increment (p1); + _increment (p2); + } + + return 0; +} + + // Instantiate EmMem_strcmp's that work with: + // + // dest source + // ------ ------ + // char* emuptr + // const char* emuptr + // emuptr char* + // emuptr const char* + // emuptr emuptr + +template int EmMem_strcmp<char*, emuptr> (char* dst, emuptr src); +template int EmMem_strcmp<const char*, emuptr> (const char* dst, emuptr src); +template int EmMem_strcmp<emuptr, char*> (emuptr dst, char* src); +template int EmMem_strcmp<emuptr, const char*> (emuptr dst, const char* src); +template int EmMem_strcmp<emuptr, emuptr> (emuptr dst, emuptr src); + + +/*********************************************************************** + * + * FUNCTION: EmMem_strncmp + * + * DESCRIPTION: Same as Std C Library strncmp function. + * + * PARAMETERS: Same as Std C Library strncmp function. + * + * RETURNED: Same as Std C Library strncmp function. + * + ***********************************************************************/ + +template <class T1, class T2> +int EmMem_strncmp(T1 dst, T2 src, size_t len) +{ + T1 p1 = dst; + T2 p2 = src; + + ++len; + + while (--len) + { + unsigned char c1 = _get_byte (p1); + unsigned char c2 = _get_byte (p2); + + if (c1 != c2) + return (c1 - c2); + else if (!c1) + break; + + _increment (p1); + _increment (p2); + } + + return 0; +} + + // Instantiate EmMem_strncmp's that work with: + // + // dest source + // ------ ------ + // char* emuptr + // const char* emuptr + // emuptr char* + // emuptr const char* + // emuptr emuptr + +template int EmMem_strncmp<char*, emuptr> (char* dst, emuptr src, size_t len); +template int EmMem_strncmp<const char*, emuptr> (const char* dst, emuptr src, size_t len); +template int EmMem_strncmp<emuptr, char*> (emuptr dst, char* src, size_t len); +template int EmMem_strncmp<emuptr, const char*> (emuptr dst, const char* src, size_t len); +template int EmMem_strncmp<emuptr, emuptr> (emuptr dst, emuptr src, size_t len); diff --git a/SrcShared/Hardware/EmMemory.h b/SrcShared/Hardware/EmMemory.h new file mode 100644 index 0000000..f10b749 --- /dev/null +++ b/SrcShared/Hardware/EmMemory.h @@ -0,0 +1,457 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1998-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmMemory_h +#define EmMemory_h + +// Normally, I'd assume that these includes were pulled in +// by EmCommon.h. However, EmMemory.h gets included by UAE, +// which doesn't pull in EmCommon.h. So I have to explicitly +// make sure they're included. + +#include "Switches.h" // WORDSWAP_MEMORY, UNALIGNED_LONG_ACCESS +#include "EmTypes.h" // uint32, etc. +#include "EmAssert.h" // EmAssert + +#include "sysconfig.h" // STATIC_INLINE + +#ifdef __cplusplus +extern "C" { +#endif + +// --------------------------------------------------------------------------- +// ¥ EmAddressBank +// --------------------------------------------------------------------------- + +typedef uint32 (*EmMemGetFunc) (emuptr); +typedef void (*EmMemPutFunc) (emuptr, uint32); +typedef uint8* (*EmMemTranslateFunc) (emuptr); +typedef int (*EmMemCheckFunc) (emuptr, uint32); +typedef void (*EmMemCycleFunc) (void); +typedef uint8* (*EmMemTranslateMetaFunc) (emuptr); + +typedef struct EmAddressBank +{ + /* These ones should be self-explanatory... */ + EmMemGetFunc lget, wget, bget; + EmMemPutFunc lput, wput, bput; + + /* Use xlateaddr to translate an Amiga address to a uae_u8 * that can + * be used to address memory without calling the wget/wput functions. + * This doesn't work for all memory banks, so this function may call + * abort(). */ + EmMemTranslateFunc xlateaddr; + + /* To prevent calls to abort(), use check before calling xlateaddr. + * It checks not only that the memory bank can do xlateaddr, but also + * that the pointer points to an area of at least the specified size. + * This is used for example to translate bitplane pointers in custom.c */ + EmMemCheckFunc checkaddr; + + EmMemTranslateMetaFunc xlatemetaaddr; + EmMemCycleFunc EmMemAddOpcodeCycles; +} EmAddressBank; + + +#ifndef ECM_DYNAMIC_PATCH + + extern EmAddressBank* gEmMemBanks[65536]; + +#else // ECM_DYNAMIC_PATCH + + extern EmAddressBank** gDynEmMemBanksP; + +#endif // ECM_DYNAMIC_PATCH + + +// --------------------------------------------------------------------------- +// ¥ Support macros +// --------------------------------------------------------------------------- + +#ifndef ECM_DYNAMIC_PATCH + + #define EmMemBankIndex(addr) (((emuptr)(addr)) >> 16) + + #define EmMemGetBank(addr) (*gEmMemBanks[EmMemBankIndex(addr)]) + #define EmMemPutBank(addr, b) (gEmMemBanks[EmMemBankIndex(addr)] = (b)) + +#else // ECM_DYNAMIC_PATCH + + #define EmMemBankIndex(addr) (((unsigned long)(addr)) >> 16) + + #define EmMemGetBank(addr) (*((gDynEmMemBanksP)[EmMemBankIndex(addr)])) + #define EmMemPutBank(addr, b) ((gDynEmMemBanksP)[EmMemBankIndex(addr)] = (b)) + +#endif // ECM_DYNAMIC_PATCH + +#define EmMemCallGetFunc(func, addr) ((*EmMemGetBank(addr).func)(addr)) +#define EmMemCallPutFunc(func, addr, v) ((*EmMemGetBank(addr).func)(addr, v)) + + +// --------------------------------------------------------------------------- +// ¥ EmMemGet32 +// --------------------------------------------------------------------------- + +STATIC_INLINE uint32 EmMemGet32(emuptr addr) +{ + return EmMemCallGetFunc(lget, addr); +} + +// --------------------------------------------------------------------------- +// ¥ EmMemGet16 +// --------------------------------------------------------------------------- + +STATIC_INLINE uint32 EmMemGet16(emuptr addr) +{ + return EmMemCallGetFunc(wget, addr); +} + +// --------------------------------------------------------------------------- +// ¥ EmMemGet8 +// --------------------------------------------------------------------------- + +STATIC_INLINE uint32 EmMemGet8(emuptr addr) +{ + return EmMemCallGetFunc(bget, addr); +} + +// --------------------------------------------------------------------------- +// ¥ EmMemPut32 +// --------------------------------------------------------------------------- + +STATIC_INLINE void EmMemPut32(emuptr addr, uint32 l) +{ + EmMemCallPutFunc(lput, addr, l); +} + +// --------------------------------------------------------------------------- +// ¥ EmMemPut16 +// --------------------------------------------------------------------------- + +STATIC_INLINE void EmMemPut16(emuptr addr, uint32 w) +{ + EmMemCallPutFunc(wput, addr, w); +} + +// --------------------------------------------------------------------------- +// ¥ EmMemPut8 +// --------------------------------------------------------------------------- + +STATIC_INLINE void EmMemPut8(emuptr addr, uint32 b) +{ + EmMemCallPutFunc(bput, addr, b); +} + +// --------------------------------------------------------------------------- +// ¥ EmMemGetRealAddress +// --------------------------------------------------------------------------- + +STATIC_INLINE uint8* EmMemGetRealAddress(emuptr addr) +{ + return EmMemGetBank(addr).xlateaddr(addr); +} + +// --------------------------------------------------------------------------- +// ¥ EmMemCheckAddress +// --------------------------------------------------------------------------- + +STATIC_INLINE int EmMemCheckAddress(emuptr addr, uint32 size) +{ + return EmMemGetBank(addr).checkaddr(addr, size); +} + +// --------------------------------------------------------------------------- +// ¥ EmMemAddOpcodeCycles +// --------------------------------------------------------------------------- + +STATIC_INLINE void EmMemAddOpcodeCycles(emuptr addr) +{ + EmAssert (EmMemGetBank(addr).EmMemAddOpcodeCycles); + EmMemGetBank(addr).EmMemAddOpcodeCycles(); +} + +// --------------------------------------------------------------------------- +// ¥ EmMemGetMetaAddress +// --------------------------------------------------------------------------- + +STATIC_INLINE uint8* EmMemGetMetaAddress(emuptr addr) +{ + EmAssert(EmMemGetBank(addr).xlatemetaaddr); + return EmMemGetBank(addr).xlatemetaaddr(addr); +} + +// --------------------------------------------------------------------------- +// ¥ EmMemDoGet32 +// --------------------------------------------------------------------------- + +STATIC_INLINE uint32 EmMemDoGet32 (void* a) +{ +#if WORDSWAP_MEMORY || !UNALIGNED_LONG_ACCESS + return (((uint32) *(((uint16*) a) + 0)) << 16) | + (((uint32) *(((uint16*) a) + 1))); +#else + return *(uint32*) a; +#endif +} + +// --------------------------------------------------------------------------- +// ¥ EmMemDoGet16 +// --------------------------------------------------------------------------- + +STATIC_INLINE uint16 EmMemDoGet16 (void* a) +{ + return *(uint16*) a; +} + +// --------------------------------------------------------------------------- +// ¥ EmMemDoGet8 +// --------------------------------------------------------------------------- + +STATIC_INLINE uint8 EmMemDoGet8 (void* a) +{ +#if WORDSWAP_MEMORY + return *(uint8*) ((long) a ^ 1); +#else + return *(uint8*) a; +#endif +} + +// --------------------------------------------------------------------------- +// ¥ EmMemDoPut32 +// --------------------------------------------------------------------------- + +STATIC_INLINE void EmMemDoPut32 (void* a, uint32 v) +{ +#if WORDSWAP_MEMORY || !UNALIGNED_LONG_ACCESS + *(((uint16*) a) + 0) = (uint16) (v >> 16); + *(((uint16*) a) + 1) = (uint16) (v); +#else + *(uint32*) a = v; +#endif +} + +// --------------------------------------------------------------------------- +// ¥ EmMemDoPut16 +// --------------------------------------------------------------------------- + +STATIC_INLINE void EmMemDoPut16 (void* a, uint16 v) +{ + *(uint16*) a = v; +} + +// --------------------------------------------------------------------------- +// ¥ EmMemDoPut8 +// --------------------------------------------------------------------------- + +STATIC_INLINE void EmMemDoPut8 (void* a, uint8 v) +{ +#if WORDSWAP_MEMORY + *(uint8*) ((long) a ^ 1) = v; +#else + *(uint8*) a = v; +#endif +} + + +#ifdef __cplusplus +} +#endif + + +#ifdef __cplusplus + +class EmStream; + + +// Types. + +// This struct is used to control access to memory. The first set of fields +// are booleans which, when set to true, turn on address validation for the +// various ranges of memory. The second second set of fields are booleans +// which, when set to true, prevent access by user applications to the various +// ranges of memory. + +struct MemAccessFlags +{ + Bool fValidate_DummyGet; + Bool fValidate_DummySet; + Bool fValidate_RegisterGet; + Bool fValidate_RegisterSet; + Bool fValidate_DRAMGet; + Bool fValidate_DRAMSet; + Bool fValidate_SRAMGet; + Bool fValidate_SRAMSet; + Bool fValidate_ROMGet; + Bool fValidate_ROMSet; + +// Bool fProtect_LowMemGet; +// Bool fProtect_LowMemSet; +// Bool fProtect_GlobalGet; +// Bool fProtect_GlobalSet; +// Bool fProtect_ScreenGet; +// Bool fProtect_ScreenSet; + Bool fProtect_SRAMGet; + Bool fProtect_SRAMSet; + Bool fProtect_ROMGet; + Bool fProtect_ROMSet; + Bool fProtect_RegisterGet; + Bool fProtect_RegisterSet; + +// Bool fCheck_UserChunkGet; +// Bool fCheck_UserChunkSet; +// Bool fCheck_SysChunkGet; +// Bool fCheck_SysChunkSet; + +// Bool fProtect_SysLowMemGet; +// Bool fProtect_SysLowMemSet; +// Bool fProtect_SysGlobalGet; +// Bool fProtect_SysGlobalSet; +// Bool fProtect_SysScreenGet; +// Bool fProtect_SysScreenSet; +// Bool fProtect_SysSRAMGet; +// Bool fProtect_SysSRAMSet; + Bool fProtect_SysROMGet; + Bool fProtect_SysROMSet; +// Bool fProtect_SysRegisterGet; +// Bool fProtect_SysRegisterSet; +}; + + +// Globals. + +extern MemAccessFlags gMemAccessFlags; +extern Bool gPCInRAM; +extern Bool gPCInROM; + +#if PROFILE_MEMORY +enum +{ + kDRAMLongRead, kDRAMLongRead2, kDRAMWordRead, kDRAMByteRead, + kDRAMLongWrite, kDRAMLongWrite2, kDRAMWordWrite, kDRAMByteWrite, + kSRAMLongRead, kSRAMLongRead2, kSRAMWordRead, kSRAMByteRead, + kSRAMLongWrite, kSRAMLongWrite2, kSRAMWordWrite, kSRAMByteWrite, + kROMLongRead, kROMLongRead2, kROMWordRead, kROMByteRead, + kROMLongWrite, kROMLongWrite2, kROMWordWrite, kROMByteWrite, + kREGLongRead, kREGLongRead2, kREGWordRead, kREGByteRead, + kREGLongWrite, kREGLongWrite2, kREGWordWrite, kREGByteWrite, + + kSED1375LongRead, kSED1375LongRead2, kSED1375WordRead, kSED1375ByteRead, + kSED1375LongWrite, kSED1375LongWrite2, kSED1375WordWrite, kSED1375ByteWrite, + + kLastEnum +}; +extern long gMemoryAccess[]; +#endif + +struct EmAddressBank; +class SessionFile; + +// Function prototypes. + +class Memory +{ + public: + static void Initialize (EmStream& hROM, + RAMSizeType ramSize); + static void Reset (Bool hardwareReset); + static void Save (SessionFile&); + static void Load (SessionFile&); + static void Dispose (void); + + static void InitializeBanks (EmAddressBank& iBankInitializer, + int32 iStartingBankIndex, + int32 iNumberOfBanks); + + static void ResetBankHandlers (void); + + static void MapPhysicalMemory (const void*, uint32); + static void UnmapPhysicalMemory (const void*); + static void GetMappingInfo (emuptr, void**, uint32*); + + static void CheckNewPC (emuptr newPC); + static int IsPCInRAM (void) { return gPCInRAM; } + static int IsPCInROM (void) { return gPCInROM; } +}; + +typedef Memory EmMemory; + + +// There are places within the emulator where we'd like to access low-memory +// and/or Dragonball registers. If the PC happens to be in RAM, then +// the checks implied by the above booleans and switches will flag our +// access as an error. Before making such accesses, create an instance +// of CEnableFullAccess to suspend and restore the checks. +// +// Since such accesses are typically "meta" accesses where the emulator is +// accessing memory outside the normal execution of an opcode, we also +// turn off the profiling variable that controls whether or not cycles +// spent accessing memory are counted. + +class CEnableFullAccess +{ + public: + CEnableFullAccess (void); + ~CEnableFullAccess (void); + + static Bool AccessOK (void); + + private: + MemAccessFlags fOldMemAccessFlags; + +#if HAS_PROFILING + Bool fOldProfilingCounted; +#endif + + static long fgAccessCount; +}; + + +// Std C Library-ish routines for manipulating data +// in emulated memory. + +emuptr EmMem_memset(emuptr dst, int val, size_t len); + +emuptr EmMem_memchr(emuptr src, int val, size_t len); + +template <class T1, class T2> +int EmMem_memcmp(T1 src1, T2 src2, size_t len); + +template <class T1, class T2> +T1 EmMem_memcpy (T1 dst, T2 src, size_t len); + +template <class T1, class T2> +T1 EmMem_memmove (T1 dst, T2 src, size_t len); + +size_t EmMem_strlen(emuptr str); + +template <class T1, class T2> +T1 EmMem_strcpy(T1 dst, T2 src); + +template <class T1, class T2> +T1 EmMem_strncpy(T1 dst, T2 src, size_t len); + +template <class T1, class T2> +T1 EmMem_strcat(T1 dst, T2 src); + +template <class T1, class T2> +T1 EmMem_strncat(T1 dst, T2 src, size_t len); + +template <class T1, class T2> +int EmMem_strcmp(T1 dst, T2 src); + +template <class T1, class T2> +int EmMem_strncmp(T1 dst, T2 src, size_t len); + +#endif // __cplusplus + +#endif /* EmMemory_h */ diff --git a/SrcShared/Hardware/EmRegs.cpp b/SrcShared/Hardware/EmRegs.cpp new file mode 100644 index 0000000..bd1c50a --- /dev/null +++ b/SrcShared/Hardware/EmRegs.cpp @@ -0,0 +1,499 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegs.h" + +#include "Byteswapping.h" // Canonical +#include "EmBankRegs.h" // EmBankRegs::InvalidAccess +#include "EmMemory.h" // Memory::InitializeBanks, EmMemBankIndex + +/* + EmRegs is a base class for subclasses that manage the accessing of + emulated memory at a byte, word, or long level. See comments in + EmRegsBank.cpp for a description on how EmRegs objects are managed, + and EmMemory for how memory in general is emulated. + + EmRegs subclasses are suited for managing hardware registers, such + as the Dragonball [EZ | VZ] hardware registers, the USB registers + in the Handspring Visor, or the special PLD registers in some of the + Palm VII devices. + + To create a new EmRegs subclass that can handle accesses to a special + range of memory, do the following: + + * Create a subclass of EmRegs + + * Provide implementations for the pure virtual functions: + + * SetSubBankHandlers: this method needs to call EmRegs::SetHandler + to install a read and write function for each memory location + that can be accessed. It should also first call the base + class SetSubBankHandlers in order to install default handlers + for all memory locations in the memory range the subclass manages. + + * GetRealAddress: given an address in emulated space, this function + returns the real address from the point of view of the emulator. + For instance, if your EmRegs subclass manages the memory range + 0x17000000 to 0x17001000, and you have created a 4K buffer to + represent this memory range, then GetRealAddress would be like: + + return &fMyBuffer[address - 0x17000000]; + + * GetAddressStart: returns the base address of the memory range + managed by this class. In the example above, this method would + return 0x17000000. + + * GetAddressRange: returns the range of memory managed by this + class. In the example above, this method would return 0x1000. + + * Define read and write function handlers for each memory location + in the managed range. These functions handlers are installed in + your SetSubBankHandlers override. EmBankRegs will call these + handlers as appropriate. + + * Optionally implement Initialize, Reset, Save, Load, and Dispose + overrides. You will usually override Initialize to create any + buffers required to hold your data, and correspondingly dispose + of those resources in a Dispose override. Most subclasses will + need to override Reset in order to initialize their emulated + registers. And override Save and Load if you want to save and + restore your registers to the session (.psf) file. + + * In the appropriate case statement in EmDevice::CreateRegs, create + an instance of your EmRegs class and install it by calling + EmBankRegs::AddSubBank. +*/ + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::EmRegs +// --------------------------------------------------------------------------- + +EmRegs::EmRegs (void) : + fReadFunctions (), + fWriteFunctions () +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::~EmRegs +// --------------------------------------------------------------------------- + +EmRegs::~EmRegs (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::Initialize +// --------------------------------------------------------------------------- + +void EmRegs::Initialize (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::Reset +// --------------------------------------------------------------------------- + +void EmRegs::Reset (Bool /*hardwareReset*/) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::Save +// --------------------------------------------------------------------------- + +void EmRegs::Save (SessionFile&) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::Load +// --------------------------------------------------------------------------- + +void EmRegs::Load (SessionFile&) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::Dispose +// --------------------------------------------------------------------------- + +void EmRegs::Dispose (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::SetBankHandlers +// --------------------------------------------------------------------------- + +void EmRegs::SetBankHandlers (EmAddressBank& bank) +{ + emuptr address = this->GetAddressStart (); + uint32 range = this->GetAddressRange (); + uint32 numBanks = EmMemBankIndex (address + range - 1) - EmMemBankIndex (address) + 1; + + Memory::InitializeBanks (bank, EmMemBankIndex (address), numBanks); + + this->SetSubBankHandlers (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegs::SetSubBankHandlers (void) +{ + this->SetHandler (&EmRegs::UnsupportedRead, &EmRegs::UnsupportedWrite, + this->GetAddressStart (), this->GetAddressRange ()); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::GetLong +// --------------------------------------------------------------------------- + +uint32 EmRegs::GetLong (emuptr address) +{ +// EmAssert (this->ValidAddress (address, 4)); + + long offset = address - this->GetAddressStart (); + ReadFunction fn = fReadFunctions [offset]; + EmAssert (fn); + + return (this->*fn) (address, 4); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::GetWord +// --------------------------------------------------------------------------- + +uint32 EmRegs::GetWord (emuptr address) +{ +// EmAssert (this->ValidAddress (address, 2)); + + long offset = address - this->GetAddressStart (); + ReadFunction fn = fReadFunctions [offset]; + EmAssert (fn); + + return (this->*fn) (address, 2); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::GetByte +// --------------------------------------------------------------------------- + +uint32 EmRegs::GetByte (emuptr address) +{ +// EmAssert (this->ValidAddress (address, 1)); + + long offset = address - this->GetAddressStart (); + ReadFunction fn = fReadFunctions [offset]; + EmAssert (fn); + + return (this->*fn) (address, 1); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::SetLong +// --------------------------------------------------------------------------- + +void EmRegs::SetLong (emuptr address, uint32 value) +{ +// EmAssert (this->ValidAddress (address, 4)); + + long offset = address - this->GetAddressStart (); + WriteFunction fn = fWriteFunctions [offset]; + EmAssert (fn); + + (this->*fn) (address, 4, value); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::SetWord +// --------------------------------------------------------------------------- + +void EmRegs::SetWord (emuptr address, uint32 value) +{ +// EmAssert (this->ValidAddress (address, 2)); + + long offset = address - this->GetAddressStart (); + WriteFunction fn = fWriteFunctions [offset]; + EmAssert (fn); + + (this->*fn) (address, 2, value); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::SetByte +// --------------------------------------------------------------------------- + +void EmRegs::SetByte (emuptr address, uint32 value) +{ +// EmAssert (this->ValidAddress (address, 1)); + + long offset = address - this->GetAddressStart (); + WriteFunction fn = fWriteFunctions [offset]; + EmAssert (fn); + + (this->*fn) (address, 1, value); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::ValidAddress +// --------------------------------------------------------------------------- + +int EmRegs::ValidAddress (emuptr address, uint32 size) +{ + UNUSED_PARAM (size); + + int result = false; + unsigned long offset = address - this->GetAddressStart (); + + if (offset < fReadFunctions.size ()) + { + ReadFunction fn = fReadFunctions [offset]; + result = (fn != &EmRegs::UnsupportedRead); + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmRegs::GetRealAddress (emuptr address) +{ + UNUSED_PARAM (address); + + // Sub-class's responsibility. + + return NULL; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::SetHandler +// --------------------------------------------------------------------------- + +void EmRegs::SetHandler (ReadFunction read, WriteFunction write, + uint32 start, int count) +{ + if (fReadFunctions.size () == 0) + { + uint32 range = this->GetAddressRange (); + + fReadFunctions.resize (range, &EmRegs::UnsupportedRead); + fWriteFunctions.resize (range, &EmRegs::UnsupportedWrite); + } + + int index = start - this->GetAddressStart (); + + EmAssert (index >= 0); + EmAssert (index < (long) fReadFunctions.size ()); + + for (int ii = 0; ii < count; ++ii, ++index) + { + fReadFunctions[index] = read; + fWriteFunctions[index] = write; + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::UnsupportedRead +// --------------------------------------------------------------------------- + +uint32 EmRegs::UnsupportedRead (emuptr address, int size) +{ + if (!CEnableFullAccess::AccessOK ()) + { + EmBankRegs::PreventedAccess (address, size, true); + } + + return ~0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::UnsupportedWrite +// --------------------------------------------------------------------------- + +void EmRegs::UnsupportedWrite (emuptr address, int size, uint32 value) +{ + UNUSED_PARAM(value) + + if (!CEnableFullAccess::AccessOK ()) + { + EmBankRegs::PreventedAccess (address, size, false); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::StdReadBE +// --------------------------------------------------------------------------- +// Read registers in a strict Big Endian fashion. + +uint32 EmRegs::StdReadBE (emuptr address, int size) +{ + uint8* realAddr = this->GetRealAddress (address); + + if (size == 1) + return *(uint8*) realAddr; + + if (size == 2) + { + uint16 result16 = *(uint16*) realAddr; + Canonical (result16); + return result16; + } + +#if UNALIGNED_LONG_ACCESS + + uint32 result32 = *(uint32*) realAddr; + Canonical (result32); + return result32; + +#else + + return (realAddr[0] << 24) | + (realAddr[1] << 16) | + (realAddr[2] << 8) | + (realAddr[3] << 0); + +#endif +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::StdWriteBE +// --------------------------------------------------------------------------- +// Write registers in a strict Big Endian fashion. + +void EmRegs::StdWriteBE (emuptr address, int size, uint32 value) +{ + uint8* realAddr = this->GetRealAddress (address); + + if (size == 1) + { + *(uint8*) realAddr = value; + } + + else if (size == 2) + { + uint16 value16 = value; + Canonical (value16); + *(uint16*) realAddr = value16; + } + + else if (size == 4) + { +#if UNALIGNED_LONG_ACCESS + + Canonical (value); + *(uint32*) realAddr = value; + +#else + + realAddr[0] = (uint8) (value >> 24); + realAddr[1] = (uint8) (value >> 16); + realAddr[2] = (uint8) (value >> 8); + realAddr[3] = (uint8) (value >> 0); + +#endif + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::StdRead +// --------------------------------------------------------------------------- +// Read registers using the routines in maccess.h + +uint32 EmRegs::StdRead (emuptr address, int size) +{ + uint8* realAddr = this->GetRealAddress (address); + + if (size == 1) + return EmMemDoGet8 (realAddr); + + if (size == 2) + return EmMemDoGet16 (realAddr); + + return EmMemDoGet32 (realAddr); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::StdWrite +// --------------------------------------------------------------------------- +// Write registers using the routines in maccess.h + +void EmRegs::StdWrite (emuptr address, int size, uint32 value) +{ + uint8* realAddr = this->GetRealAddress (address); + + if (size == 1) + EmMemDoPut8 (realAddr, value); + + else if (size == 2) + EmMemDoPut16 (realAddr, value); + + else + EmMemDoPut32 (realAddr, value); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::ZeroRead +// --------------------------------------------------------------------------- + +uint32 EmRegs::ZeroRead (emuptr address, int size) +{ + UNUSED_PARAM(address) + UNUSED_PARAM(size) + + return 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs::NullWrite +// --------------------------------------------------------------------------- + +void EmRegs::NullWrite (emuptr address, int size, uint32 value) +{ + UNUSED_PARAM(address) + UNUSED_PARAM(size) + UNUSED_PARAM(value) + + // Do nothing (for read-only registers). +} diff --git a/SrcShared/Hardware/EmRegs.h b/SrcShared/Hardware/EmRegs.h new file mode 100644 index 0000000..1a48907 --- /dev/null +++ b/SrcShared/Hardware/EmRegs.h @@ -0,0 +1,77 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegs_h +#define EmRegs_h + +#include <vector> + +class SessionFile; +struct EmAddressBank; + +class EmRegs +{ + public: + EmRegs (void); + virtual ~EmRegs (void); + + virtual void Initialize (void); + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + virtual void Dispose (void); + + void SetBankHandlers (EmAddressBank&); + virtual void SetSubBankHandlers (void) = 0; + + virtual uint32 GetLong (emuptr address); + virtual uint32 GetWord (emuptr address); + virtual uint32 GetByte (emuptr address); + virtual void SetLong (emuptr address, uint32 value); + virtual void SetWord (emuptr address, uint32 value); + virtual void SetByte (emuptr address, uint32 value); + virtual int ValidAddress (emuptr address, uint32 size); + virtual uint8* GetRealAddress (emuptr address) = 0; + virtual emuptr GetAddressStart (void) = 0; + virtual uint32 GetAddressRange (void) = 0; + + protected: + typedef uint32 (EmRegs::*ReadFunction) (emuptr address, int size); + typedef void (EmRegs::*WriteFunction) (emuptr address, int size, uint32 value); + + void SetHandler (ReadFunction read, + WriteFunction write, + uint32 start, int count); + + uint32 UnsupportedRead (emuptr address, int size); + uint32 StdRead (emuptr address, int size); + uint32 StdReadBE (emuptr address, int size); + uint32 ZeroRead (emuptr address, int size); + + void UnsupportedWrite (emuptr address, int size, uint32 value); + void StdWrite (emuptr address, int size, uint32 value); + void StdWriteBE (emuptr address, int size, uint32 value); + void NullWrite (emuptr address, int size, uint32 value); + + private: + typedef vector<ReadFunction> ReadFunctionList; + typedef vector<WriteFunction> WriteFunctionList; + + ReadFunctionList fReadFunctions; + WriteFunctionList fWriteFunctions; +}; + + +typedef vector<EmRegs*> EmRegsList; + +#endif /* EmRegs_h */ diff --git a/SrcShared/Hardware/EmRegs328.cpp b/SrcShared/Hardware/EmRegs328.cpp new file mode 100644 index 0000000..0f33398 --- /dev/null +++ b/SrcShared/Hardware/EmRegs328.cpp @@ -0,0 +1,2803 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegs328.h" +#include "EmRegs328Prv.h" + +#include "Byteswapping.h" // Canonical +#include "EmHAL.h" // EmHAL +#include "EmMemory.h" // gMemAccessFlags, EmMem_memcpy +#include "EmPixMap.h" // SetSize, SetRowBytes, etc. +#include "EmScreen.h" // EmScreenUpdateInfo +#include "EmSession.h" // GetDevice +#include "Hordes.h" // Hordes::IsOn +#include "Logging.h" // LogAppendMsg +#include "Miscellaneous.h" // GetHostTime +#include "PreferenceMgr.h" // Preference +#include "SessionFile.h" // WriteHwrDBallType, etc. +#include "UAE.h" // regs, SPCFLAG_INT + +#include "PalmPack.h" +#define NON_PORTABLE + #include "HwrMiscFlags.h" // hwrMiscFlagID1 + + // Some platform-specific -- yet fairly portable -- defines. + #define hwrTD1PortENoBacklight 0x80 // (H) high if no backlight present + +#undef NON_PORTABLE +#include "PalmPackPop.h" + +/* + This file controls the emulation of the Dragonball registers. + + As a subclass of EmRegs, EmRegs328 registers with EmBankRegs + for control of the memory range 0xFFFFF000 to 0xFFFFFB14. If + an application accesses a memory location in that range, + EmBankRegs calls on of the Set/GetLong/Word/Byte methods of + this class. + + EmRegs328 provides handlers when particular memory addresses + are accessed. For instance, if the UART TX register is written + to, EmRegs328 will arrange for any data byte to be sent out + the host computer's serial port. If the UART RX register is + read, EmRegs328 will respond with any byte in the buffer that + contains data received from the host computer's serial port. + + Not all Dragonball registers are emulated the same way as on + an actual device. Some registers control hardware that exists + on the device only, there being no analog on the host computer. + For those registers, simple handlers are installed that write + the specified value to the register and return that value later + when the register is read. + + Other registers require extensive support. The UART registers + are examples of that, as the above text indicates. + + In the Palm OS source code, the Dragonball registers are + represented by th HwrM68328Type data type. We use this same type + in Poser to provide the "backing memory" for the registers. That + is, if some emulated code writes to a Dragonball register, we + store that value in a variable of type HwrM68328Type. + + (Note that there's really no guarantee that the compiler used to + build Poser will lay out the fields of HwrM68328Type in the same + way expected by the Palm OS. Poser has a mechanism for creating + buffers with fields that have the same layout as Palm OS-defined + structs (see EmPalmStructs.h). However, using that mechanism in + this module is deadly to performance. In particular, the Cycle + method is called after every opcode is executed, and making that + method go through the indirection and byteswapping required by + the EmPalmStructs facilities totally kills performance. In one + test, a Gremlins run increased from 1m 24s to 1m 56s, or by about + 30%. With targetted caching of the fields used in Cycle, we can + regain most of that performance. However, not all the performance + is regained, and the resulting code is not very maintainable.) +*/ + + #define hwr328chipID328 0x33 + #define hwr328maskID1H58B 0x30 + +static const uint32 ADDRESS_MASK = 0x0000FFF0; + +#define PRINTF if (1) ; else LogAppendMsg + +// Values used to initialize the DragonBall registers. + +const HwrM68328Type kInitial68328RegisterValues = +{ + 0x0C, // Byte scr; // $000: System Control Register + { 0 }, // Byte ___filler0[0x004-0x001]; + + // The following ID stuff is not present on earlier chips (before ??) + hwr328chipID328, // Byte chipID; // $004: Chip ID Register + hwr328maskID1H58B, // Byte maskID; // $005: Mask ID Register + 0x00, // Word swID; // $006: Software ID Register + { 0 }, // Byte ___filler1[0x100-0x008]; + + 0x0000, // Word csAGroupBase; // $100: Chip Select Group A Base Register + 0x0000, // Word csBGroupBase; // $102: Chip Select Group B Base Register + 0x0000, // Word csCGroupBase; // $104: Chip Select Group C Base Register + 0x0000, // Word csDGroupBase; // $106: Chip Select Group D Base Register + + 0x0000, // Word csAGroupMask; // $108: Chip Select Group A Mask Register + 0x0000, // Word csBGroupMask; // $10A: Chip Select Group B Mask Register + 0x0000, // Word csCGroupMask; // $10C: Chip Select Group C Mask Register + 0x0000, // Word csDGroupMask; // $10E: Chip Select Group D Mask Register + + 0x00010006, // DWord csASelect0; // $110: Group A Chip Select 0 Register + 0x00010006, // DWord csASelect1; // $114: Group A Chip Select 1 Register + 0x00010006, // DWord csASelect2; // $118: Group A Chip Select 2 Register + 0x00010006, // DWord csASelect3; // $11C: Group A Chip Select 3 Register + + 0x00000000, // DWord csBSelect0; // $120: Group B Chip Select 0 Register + 0x00000000, // DWord csBSelect1; // $124: Group B Chip Select 1 Register + 0x00000000, // DWord csBSelect2; // $128: Group B Chip Select 2 Register + 0x00000000, // DWord csBSelect3; // $12C: Group B Chip Select 3 Register + + 0x00010006, // DWord csCSelect0; // $130: Group C Chip Select 0 Register + 0x00010006, // DWord csCSelect1; // $134: Group C Chip Select 1 Register + 0x00010006, // DWord csCSelect2; // $138: Group C Chip Select 2 Register + 0x00010006, // DWord csCSelect3; // $13C: Group C Chip Select 3 Register + + 0x00000000, // DWord csDSelect0; // $140: Group D Chip Select 0 Register + 0x00000000, // DWord csDSelect1; // $144: Group D Chip Select 1 Register + 0x00000000, // DWord csDSelect2; // $148: Group D Chip Select 2 Register + 0x00000000, // DWord csDSelect3; // $14C: Group D Chip Select 3 Register + + 0x0000, // Word csDebug; // $150: Chip Select debug register + { 0 }, // Byte ___filler2[0x200-0x152]; + + 0x2400, // Word pllControl; // $200: PLL Control Register + 0x0123, // Word pllFreqSel; // $202: PLL Frequency Select Register + 0x0000, // Word pllTest; // $204: PLL Test Register + { 0 }, // Byte __filler44; + 0x1F, // Byte pwrControl; // $207: Power Control Register + + { 0 }, // Byte ___filler3[0x300-0x208]; + + 0x00, // Byte intVector; // $300: Interrupt Vector Register + { 0 }, // Byte ___filler4; + 0x0000, // Word intControl; // $302: Interrupt Control Register + 0x00FF, // Word intMaskHi; // $304: Interrupt Mask Register/HIGH word + 0xFFFF, // Word intMaskLo; // $306: Interrupt Mask Register/LOW word + 0x00FF, // Word intWakeupEnHi; // $308: Interrupt Wakeup Enable Register + 0xFFFF, // Word intWakeupEnLo; // $30A: Interrupt Wakeup Enable Register + 0x0000, // Word intStatusHi; // $30C: Interrupt Status Register/HIGH word + 0x0000, // Word intStatusLo; // $30E: Interrupt Status Register/LOW word + 0x0000, // Word intPendingHi; // $310: Interrupt Pending Register + 0x0000, // Word intPendingLo; // $312: Interrupt Pending Register + + { 0 }, // Byte ___filler4a[0x400-0x314]; + + 0x00, // Byte portADir; // $400: Port A Direction Register + 0x00, // Byte portAData; // $401: Port A Data Register + { 0 }, // Byte ___filler5; + 0x00, // Byte portASelect; // $403: Port A Select Register + + { 0 }, // Byte ___filler6[4]; + + 0x00, // Byte portBDir; // $408: Port B Direction Register + 0x00, // Byte portBData; // $409: Port B Data Register + { 0 }, // Byte ___filler7; + 0x00, // Byte portBSelect; // $40B: Port B Select Register + + { 0 }, // Byte ___filler8[4]; + + 0x00, // Byte portCDir; // $410: Port C Direction Register + 0x00, // Byte portCData; // $411: Port C Data Register + { 0 }, // Byte ___filler9; + 0x00, // Byte portCSelect; // $413: Port C Select Register + + { 0 }, // Byte ___filler10[4]; + + 0x00, // Byte portDDir; // $418: Port D Direction Register + 0x00, // Byte portDData; // $419: Port D Data Register + 0xFF, // Byte portDPullupEn; // $41A: Port D Pull-up Enable + { 0 }, // Byte ___filler11; + 0x00, // Byte portDPolarity; // $41C: Port D Polarity Register + 0x00, // Byte portDIntReqEn; // $41D: Port D Interrupt Request Enable + { 0 }, // Byte ___filler12; + 0x00, // Byte portDIntEdge; // $41F: Port D IRQ Edge Register + + 0x00, // Byte portEDir; // $420: Port E Direction Register + 0x00, // Byte portEData; // $421: Port E Data Register + 0x80, // Byte portEPullupEn; // $422: Port E Pull-up Enable + 0x80, // Byte portESelect; // $423: Port E Select Register + + { 0 }, // Byte ___filler14[4]; + + 0x00, // Byte portFDir; // $428: Port F Direction Register + 0x00, // Byte portFData; // $429: Port F Data Register + 0xFF, // Byte portFPullupEn; // $42A: Port F Pull-up Enable + 0xFF, // Byte portFSelect; // $42B: Port F Select Register + + { 0 }, // Byte ___filler16[4]; + + 0x00, // Byte portGDir; // $430: Port G Direction Register + 0x00, // Byte portGData; // $431: Port G Data Register + 0xFF, // Byte portGPullupEn; // $432: Port G Pull-up Enable + 0xFF, // Byte portGSelect; // $433: Port G Select Register + + { 0 }, // Byte ___filler18[4]; + + 0x00, // Byte portJDir; // $438: Port J Direction Register + 0x00, // Byte portJData; // $439: Port J Data Register + { 0 }, // Byte ___filler19; + 0x00, // Byte portJSelect; // $43B: Port J Select Register + + { 0 }, // Byte ___filler19a[4]; + + 0x00, // Byte portKDir; // $440: Port K Direction Register + 0x00, // Byte portKData; // $441: Port K Data Register + 0x3F, // Byte portKPullupEn; // $442: Port K Pull-up Enable + 0x3F, // Byte portKSelect; // $443: Port K Select Register + + { 0 }, // Byte ___filler21[4]; + + 0x00, // Byte portMDir; // $448: Port M Direction Register + 0x00, // Byte portMData; // $449: Port M Data Register + 0xFF, // Byte portMPullupEn; // $44A: Port M Pull-up Enable Register + 0x02, // Byte portMSelect; // $44B: Port M Select Register + + { 0 }, // Byte ___filler22[4]; + + { 0 }, // Byte ___filler23[0x500-0x450]; + + 0x0000, // Word pwmControl; // $500: PWM Control Register + 0x0000, // Word pwmPeriod; // $502: PWM Period Register + 0x0000, // Word pwmWidth; // $504: PWM Width Register + 0x0000, // Word pwmCounter; // $506: PWM Counter + + { 0 }, // Byte ___filler24[0x600-0x508]; + + 0x0000, // Word tmr1Control; // $600: Timer 1 Control Register + 0x0000, // Word tmr1Prescaler; // $602: Timer 1 Prescaler Register + 0xFFFF, // Word tmr1Compare; // $604: Timer 1 Compare Register + 0x0000, // Word tmr1Capture; // $606: Timer 1 Capture Register + 0x0000, // Word tmr1Counter; // $608: Timer 1 Counter Register + 0x0000, // Word tmr1Status; // $60A: Timer 1 Status Register + + 0x0000, // Word tmr2Control; // $60C: Timer 2 Control Register + 0x0000, // Word tmr2Prescaler; // $60E: Timer 2 Prescaler Register + 0xFFFF, // Word tmr2Compare; // $610: Timer 2 Compare Register + 0x0000, // Word tmr2Capture; // $612: Timer 2 Capture Register + 0x0000, // Word tmr2Counter; // $614: Timer 2 Counter Register + 0x0000, // Word tmr2Status; // $616: Timer 2 Status Register + + 0x0000, // Word wdControl; // $618: Watchdog Control Register + 0x0000, // Word wdReference; // $61A: Watchdog Reference Register + 0x0000, // Word wdCounter; // $61C: Watchdog Counter + + { 0 }, // Byte ___filler25[0x700-0x61E]; + + 0x0000, // Word spiSlave; // $700: SPI Slave Register + + { 0 }, // Byte ___filler26[0x800-0x702]; + + 0x0000, // Word spiMasterData; // $800: SPI Master Data Register + 0x0000, // Word spiMasterControl; // $802: SPI Master Control Register + + { 0 }, // Byte ___filler27[0x900-0x804]; + + 0x0000, // Word uControl; // $900: Uart Control Register + 0x003F, // Word uBaud; // $902: Uart Baud Control Register + 0x0000, // Word uReceive; // $904: Uart Receive Register + 0x0000, // Word uTransmit; // $906: Uart Transmit Register + 0x0000, // Word uMisc; // $908: Uart Miscellaneous Register + + { 0 }, // Byte ___filler28[0xA00-0x90A]; + + 0x00000000, // DWord lcdStartAddr; // $A00: Screen Starting Address Register + { 0 }, // Byte ___filler29; + 0xFF, // Byte lcdPageWidth; // $A05: Virtual Page Width Register + { 0 }, // Byte ___filler30[2]; + 0x03FF, // Word lcdScreenWidth; // $A08: Screen Width Register + 0x01FF, // Word lcdScreenHeight; // $A0A: Screen Height Register + { 0 }, // Byte ___filler31[0xA18-0xA0C]; + 0x0000, // Word lcdCursorXPos; // $A18: Cursor X Position + 0x0000, // Word lcdCursorYPos; // $A1A: Cursor Y Position + 0x0101, // Word lcdCursorWidthHeight; // $A1C: Cursor Width and Height + { 0 }, // Byte ___filler32; + 0x7F, // Byte lcdBlinkControl; // $A1F: Blink Control Register + 0x00, // Byte lcdPanelControl; // $A20: Panel Interface Control Register + 0x00, // Byte lcdPolarity; // $A21: Polarity Config Register + 0x00, // Byte ___filler33; + 0x00, // Byte lcdACDRate; // $A23: ACD (M) Rate Control Register + 0x00, // Byte ___filler34; + 0x00, // Byte lcdPixelClock; // $A25: Pixel Clock Divider Register + 0x00, // Byte ___filler35; + 0x40, // Byte lcdClockControl; // $A27: Clocking Control Register + 0x00, // Byte ___filler36; + 0x3E, // Byte lcdLastBufferAddr; // $A29: Last Buffer Address Register + 0x00, // Byte ___filler37; + 0x3F, // Byte lcdOctetTermCount; // $A2B: Octet Terminal Count Register + 0x00, // Byte ___filler38; + 0x00, // Byte lcdPanningOffset; // $A2D: Panning Offset Register + { 0 }, // Byte ___filler39[3]; + 0xB9, // Byte lcdFrameRate; // $A31: Frame Rate Control Modulation Register + 0x1073, // Word lcdGrayPalette; // $A32: Gray Palette Mapping Register + 0x00, // Byte lcdReserved; // $A34: Reserved + + { 0 }, // Byte ___filler40[0xB00-0xA35]; + + 0x00000000, // DWord rtcHourMinSec; // $B00: RTC Hours, Minutes, Seconds Register + 0x00000000, // DWord rtcAlarm; // $B04: RTC Alarm Register + 0x00000000, // DWord rtcReserved; // $B08: RTC Reserved + 0x0000, // Word rtcControl; // $B0C: RTC Control Register + 0x0000, // Word rtcIntStatus; // $B0E: RTC Interrupt Status Register + 0x0000, // Word rtcIntEnable; // $B10: RTC Interrupt Enable Register + 0x0000 // Word stopWatch; // $B12: Stopwatch Minutes +}; + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::EmRegs328 +// --------------------------------------------------------------------------- + +EmRegs328::EmRegs328 (void) : + EmRegs (), + f68328Regs (), + fHotSyncButtonDown (0), + fTmr2CurrentMilliseconds (0), + fTmr2StartMilliseconds (0), + fKeyBits (0), + fLastTmr1Status (0), + fLastTmr2Status (0), + fPortDEdge (0), + fPortDDataCount (0), + fHour (0), + fMin (0), + fSec (0), + fTick (0), + fCycle (0), + fUART (NULL) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::~EmRegs328 +// --------------------------------------------------------------------------- + +EmRegs328::~EmRegs328 (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::Initialize +// --------------------------------------------------------------------------- + +void EmRegs328::Initialize (void) +{ + EmRegs::Initialize (); + + fUART = new EmUARTDragonball (EmUARTDragonball::kUART_Dragonball, 0); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::Reset +// --------------------------------------------------------------------------- + +void EmRegs328::Reset (Bool hardwareReset) +{ + EmRegs::Reset (hardwareReset); + + if (hardwareReset) + { + f68328Regs = kInitial68328RegisterValues; + + // Byteswap all the words in the Dragonball registers (if necessary). + + Canonical (f68328Regs); + ByteswapWords (&f68328Regs, sizeof(f68328Regs)); + + fKeyBits = 0; + fLastTmr1Status = 0; + fLastTmr2Status = 0; + fPortDEdge = 0; + fPortDDataCount = 0; + + // React to the new data in the UART registers. + + Bool sendTxData = false; + EmRegs328::UARTStateChanged (sendTxData); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::Save +// --------------------------------------------------------------------------- + +void EmRegs328::Save (SessionFile& f) +{ + EmRegs::Save (f); + + StWordSwapper swapper1 (&f68328Regs, sizeof(f68328Regs)); + f.WriteHwrDBallType (f68328Regs); + f.FixBug (SessionFile::kBugByteswappedStructs); + + const long kCurrentVersion = 4; + + Chunk chunk; + EmStreamChunk s (chunk); + + s << kCurrentVersion; + s << fHotSyncButtonDown; + s << fLastTmr1Status; + s << fLastTmr2Status; + s << fPortDEdge; + + // Added in version 2. + + s << fKeyBits; + + // Added in version 3. + + s << fHour; + s << fMin; + s << fSec; + s << fTick; + s << fCycle; + + // Added in version 4. + + s << fPortDDataCount; + + f.WriteDBallState (chunk); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::Load +// --------------------------------------------------------------------------- + +void EmRegs328::Load (SessionFile& f) +{ + EmRegs::Load (f); + + if (f.ReadHwrDBallType (f68328Regs)) + { + // The Windows version of Poser 2.1d29 and earlier did not write + // out structs in the correct format. The fields of the struct + // were written out in Little-Endian format, not Big-Endian. To + // address this problem, the bug has been fixed, and a new field + // is added to the file format indicating that the bug has been + // fixed. With the new field (the "bug bit"), Poser can identify + // old files from new files and read them in accordingly. + // + // With the bug fixed, the .psf files should now be interchangeable + // across platforms (modulo other bugs...). + + if (!f.IncludesBugFix (SessionFile::kBugByteswappedStructs)) + { + Canonical (f68328Regs); + } + ByteswapWords (&f68328Regs, sizeof(f68328Regs)); + + // React to the new data in the UART registers. + + Bool sendTxData = false; + EmRegs328::UARTStateChanged (sendTxData); + + // Reset gMemAccessFlags.fProtect_SRAMSet + + gMemAccessFlags.fProtect_SRAMSet = (READ_REGISTER (csASelect1) & 0x0008) != 0; + } + else + { + f.SetCanReload (false); + } + + Chunk chunk; + if (f.ReadDBallState (chunk)) + { + long version; + EmStreamChunk s (chunk); + + s >> version; + + if (version >= 1) + { + s >> fHotSyncButtonDown; + s >> fTmr2CurrentMilliseconds; + s >> fTmr2StartMilliseconds; + s >> fLastTmr1Status; + s >> fLastTmr2Status; + s >> fPortDEdge; + } + + if (version >= 2) + { + s >> fKeyBits; + } + + if (version >= 3) + { + s >> fHour; + s >> fMin; + s >> fSec; + s >> fTick; + s >> fCycle; + } + + if (version >= 4) + { + s >> fPortDDataCount; + } + } + else + { + f.SetCanReload (false); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::Dispose +// --------------------------------------------------------------------------- + +void EmRegs328::Dispose (void) +{ + delete fUART; + fUART = NULL; + + EmRegs::Dispose (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegs328::SetSubBankHandlers (void) +{ + // Install base handlers. + + EmRegs::SetSubBankHandlers (); + + // Now add standard/specialized handers for the defined registers. + + INSTALL_HANDLER (StdRead, StdWrite, scr); + + INSTALL_HANDLER (StdRead, NullWrite, chipID); + INSTALL_HANDLER (StdRead, NullWrite, maskID); + INSTALL_HANDLER (StdRead, NullWrite, swID); + + INSTALL_HANDLER (StdRead, StdWrite, csAGroupBase); + INSTALL_HANDLER (StdRead, StdWrite, csBGroupBase); + INSTALL_HANDLER (StdRead, StdWrite, csCGroupBase); + INSTALL_HANDLER (StdRead, StdWrite, csDGroupBase); + + INSTALL_HANDLER (StdRead, StdWrite, csAGroupMask); + INSTALL_HANDLER (StdRead, StdWrite, csBGroupMask); + INSTALL_HANDLER (StdRead, StdWrite, csCGroupMask); + INSTALL_HANDLER (StdRead, StdWrite, csDGroupMask); + + INSTALL_HANDLER (StdRead, StdWrite, csASelect0); + INSTALL_HANDLER (StdRead, csASelect1Write, csASelect1); + INSTALL_HANDLER (StdRead, StdWrite, csASelect2); + INSTALL_HANDLER (StdRead, StdWrite, csASelect3); + + INSTALL_HANDLER (StdRead, StdWrite, csBSelect0); + INSTALL_HANDLER (StdRead, StdWrite, csBSelect1); + INSTALL_HANDLER (StdRead, StdWrite, csBSelect2); + INSTALL_HANDLER (StdRead, StdWrite, csBSelect3); + + INSTALL_HANDLER (StdRead, csCSelect0Write, csCSelect0); + INSTALL_HANDLER (StdRead, csCSelect1Write, csCSelect1); + INSTALL_HANDLER (StdRead, StdWrite, csCSelect2); + INSTALL_HANDLER (StdRead, StdWrite, csCSelect3); + + INSTALL_HANDLER (StdRead, StdWrite, csDSelect0); + INSTALL_HANDLER (StdRead, StdWrite, csDSelect1); + INSTALL_HANDLER (StdRead, StdWrite, csDSelect2); + INSTALL_HANDLER (StdRead, StdWrite, csDSelect3); + INSTALL_HANDLER (StdRead, StdWrite, csDebug); + + INSTALL_HANDLER (StdRead, StdWrite, pllControl); + INSTALL_HANDLER (pllFreqSelRead, StdWrite, pllFreqSel); + INSTALL_HANDLER (StdRead, StdWrite, pllTest); + INSTALL_HANDLER (StdRead, StdWrite, pwrControl); + + INSTALL_HANDLER (StdRead, StdWrite, intVector); + INSTALL_HANDLER (StdRead, StdWrite, intControl); + INSTALL_HANDLER (StdRead, intMaskHiWrite, intMaskHi); + INSTALL_HANDLER (StdRead, intMaskLoWrite, intMaskLo); + INSTALL_HANDLER (StdRead, StdWrite, intWakeupEnHi); + INSTALL_HANDLER (StdRead, StdWrite, intWakeupEnLo); + INSTALL_HANDLER (StdRead, intStatusHiWrite, intStatusHi); + INSTALL_HANDLER (StdRead, NullWrite, intStatusLo); + INSTALL_HANDLER (StdRead, NullWrite, intPendingHi); + INSTALL_HANDLER (StdRead, NullWrite, intPendingLo); + + INSTALL_HANDLER (StdRead, StdWrite, portADir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portAData); + INSTALL_HANDLER (StdRead, StdWrite, portASelect); + + INSTALL_HANDLER (StdRead, StdWrite, portBDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portBData); + INSTALL_HANDLER (StdRead, StdWrite, portBSelect); + + INSTALL_HANDLER (StdRead, StdWrite, portCDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portCData); + INSTALL_HANDLER (StdRead, StdWrite, portCSelect); + + INSTALL_HANDLER (StdRead, StdWrite, portDDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portDData); + INSTALL_HANDLER (StdRead, StdWrite, portDPullupEn); + INSTALL_HANDLER (StdRead, StdWrite, portDPolarity); + INSTALL_HANDLER (StdRead, portDIntReqEnWrite, portDIntReqEn); + INSTALL_HANDLER (StdRead, StdWrite, portDIntEdge); + + INSTALL_HANDLER (StdRead, StdWrite, portEDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portEData); + INSTALL_HANDLER (StdRead, StdWrite, portEPullupEn); + INSTALL_HANDLER (StdRead, StdWrite, portESelect); + + INSTALL_HANDLER (StdRead, StdWrite, portFDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portFData); + INSTALL_HANDLER (StdRead, StdWrite, portFPullupEn); + INSTALL_HANDLER (StdRead, StdWrite, portFSelect); + + INSTALL_HANDLER (StdRead, StdWrite, portGDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portGData); + INSTALL_HANDLER (StdRead, StdWrite, portGPullupEn); + INSTALL_HANDLER (StdRead, StdWrite, portGSelect); + + INSTALL_HANDLER (StdRead, StdWrite, portJDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portJData); + INSTALL_HANDLER (StdRead, StdWrite, portJSelect); + + INSTALL_HANDLER (StdRead, StdWrite, portKDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portKData); + INSTALL_HANDLER (StdRead, StdWrite, portKPullupEn); + INSTALL_HANDLER (StdRead, StdWrite, portKSelect); + + INSTALL_HANDLER (StdRead, StdWrite, portMDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portMData); + INSTALL_HANDLER (StdRead, StdWrite, portMPullupEn); + INSTALL_HANDLER (StdRead, StdWrite, portMSelect); + + INSTALL_HANDLER (StdRead, StdWrite, pwmControl); + INSTALL_HANDLER (StdRead, StdWrite, pwmPeriod); + INSTALL_HANDLER (StdRead, StdWrite, pwmWidth); + INSTALL_HANDLER (StdRead, NullWrite, pwmCounter); + + INSTALL_HANDLER (StdRead, StdWrite, tmr1Control); + INSTALL_HANDLER (StdRead, StdWrite, tmr1Prescaler); + INSTALL_HANDLER (StdRead, StdWrite, tmr1Compare); + INSTALL_HANDLER (StdRead, StdWrite, tmr1Capture); + INSTALL_HANDLER (StdRead, NullWrite, tmr1Counter); + INSTALL_HANDLER (tmr1StatusRead, tmr1StatusWrite, tmr1Status); + + INSTALL_HANDLER (StdRead, StdWrite, tmr2Control); + INSTALL_HANDLER (StdRead, StdWrite, tmr2Prescaler); + INSTALL_HANDLER (StdRead, StdWrite, tmr2Compare); + INSTALL_HANDLER (StdRead, StdWrite, tmr2Capture); + INSTALL_HANDLER (StdRead, NullWrite, tmr2Counter); + INSTALL_HANDLER (tmr2StatusRead, tmr2StatusWrite, tmr2Status); + + INSTALL_HANDLER (StdRead, StdWrite, wdControl); + INSTALL_HANDLER (StdRead, StdWrite, wdReference); + INSTALL_HANDLER (StdRead, wdCounterWrite, wdCounter); + + INSTALL_HANDLER (StdRead, StdWrite, spiSlave); + INSTALL_HANDLER (StdRead, StdWrite, spiMasterData); + INSTALL_HANDLER (StdRead, spiMasterControlWrite, spiMasterControl); + + INSTALL_HANDLER (uartRead, uartWrite, uControl); + INSTALL_HANDLER (uartRead, uartWrite, uBaud); + INSTALL_HANDLER (uartRead, uartWrite, uReceive); + INSTALL_HANDLER (uartRead, uartWrite, uTransmit); + INSTALL_HANDLER (uartRead, uartWrite, uMisc); + + INSTALL_HANDLER (StdRead, lcdRegisterWrite, lcdStartAddr); + INSTALL_HANDLER (StdRead, lcdRegisterWrite, lcdPageWidth); + INSTALL_HANDLER (StdRead, lcdRegisterWrite, lcdScreenWidth); + INSTALL_HANDLER (StdRead, lcdRegisterWrite, lcdScreenHeight); + INSTALL_HANDLER (StdRead, StdWrite, lcdCursorXPos); + INSTALL_HANDLER (StdRead, StdWrite, lcdCursorYPos); + INSTALL_HANDLER (StdRead, StdWrite, lcdCursorWidthHeight); + INSTALL_HANDLER (StdRead, StdWrite, lcdBlinkControl); + INSTALL_HANDLER (StdRead, lcdRegisterWrite, lcdPanelControl); + INSTALL_HANDLER (StdRead, StdWrite, lcdPolarity); + INSTALL_HANDLER (StdRead, StdWrite, lcdACDRate); + INSTALL_HANDLER (StdRead, StdWrite, lcdPixelClock); + INSTALL_HANDLER (StdRead, StdWrite, lcdClockControl); + INSTALL_HANDLER (StdRead, StdWrite, lcdLastBufferAddr); + INSTALL_HANDLER (StdRead, StdWrite, lcdOctetTermCount); + INSTALL_HANDLER (StdRead, StdWrite, lcdPanningOffset); + INSTALL_HANDLER (StdRead, StdWrite, lcdFrameRate); + INSTALL_HANDLER (StdRead, StdWrite, lcdGrayPalette); + INSTALL_HANDLER (StdRead, StdWrite, lcdReserved); + + INSTALL_HANDLER (rtcHourMinSecRead, StdWrite, rtcHourMinSec); + INSTALL_HANDLER (StdRead, StdWrite, rtcAlarm); + INSTALL_HANDLER (StdRead, StdWrite, rtcReserved); + INSTALL_HANDLER (StdRead, rtcControlWrite, rtcControl); + INSTALL_HANDLER (StdRead, rtcIntStatusWrite, rtcIntStatus); + INSTALL_HANDLER (StdRead, rtcIntEnableWrite, rtcIntEnable); + INSTALL_HANDLER (StdRead, StdWrite, stopWatch); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmRegs328::GetRealAddress (emuptr address) +{ + uint8* loc = ((uint8*) &f68328Regs) + (address - kMemoryStart); + + return loc; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetAddressStart +// --------------------------------------------------------------------------- + +emuptr EmRegs328::GetAddressStart (void) +{ + return kMemoryStart; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetAddressRange +// --------------------------------------------------------------------------- + +uint32 EmRegs328::GetAddressRange (void) +{ + COMPILE_TIME_ASSERT (kMemorySize == 0x0B14); + + return kMemorySize; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::Cycle +// --------------------------------------------------------------------------- +// Handles periodic events that need to occur when the processor cycles (like +// updating timer registers). This function is called in two places from +// Emulator::Execute. Interestingly, the loop runs 3% FASTER if this function +// is in its own separate function instead of being inline. + +#if 0 +static int calibrated; +static int increment; +static int timesCalled; +static uint32 startingTime; + +static void PrvCalibrate (uint16 tmrCompare) +{ + // Calibrate the the value by which we increment the counter. + // The counter is set up so that it times out after 10 milliseconds + // so that it can increment the Palm OS's tick counter 100 times + // a second. We would like tmrCounter to surpass tmrCompare + // after 10 milliseconds. So figure out by how much we need to + // increment it in order for that to happen. + + // If timer is disabled; reset calibration. + + if (tmrCompare == 0xFFFF) + { + startingTime = 0; + } + + // If timer is enabled, restart calibration. + + else if (startingTime == 0) + { + startingTime = Platform::GetMilliseconds(); + timesCalled = 0; + increment = 1; + } + + // If calibration is started, continue it. + + else + { + timesCalled++; + + uint32 now = Platform::GetMilliseconds(); + if (now - startingTime > 100) + { + calibrated = true; + increment = tmrCompare / (timesCalled / 10); + } + } +} +#endif + +void EmRegs328::Cycle (Bool sleeping) +{ +#if 0 + // Cycle is *very* sensitive to timing issue. With this section + // of code, a Gremlins run can slow down by 5%. + if (!calibrated) + { + ::PrvCalibrate (READ_REGISTER (tmr2Compare)); + } +#else + #if _DEBUG + #define increment 20 + #else + #define increment 4 + #endif +#endif + + // Determine whether timer 2 is enabled. + + if ((READ_REGISTER (tmr2Control) & hwr328TmrControlEnable) != 0) + { + // If so, increment the timer. + + WRITE_REGISTER (tmr2Counter, READ_REGISTER (tmr2Counter) + (sleeping ? 1 : increment)); + + // Determine whether the timer has reached the specified count. + + if (sleeping || READ_REGISTER (tmr2Counter) > READ_REGISTER (tmr2Compare)) + { + // Flag the occurrence of the successful comparison. + + WRITE_REGISTER (tmr2Status, READ_REGISTER (tmr2Status) | hwr328TmrStatusCompare); + + // If the Free Run/Restart flag is not set, clear the counter. + + if ((READ_REGISTER (tmr2Control) & hwr328TmrControlFreeRun) == 0) + { + WRITE_REGISTER (tmr2Counter, 0); + } + + // If the timer interrupt is enabled, post an interrupt. + + if ((READ_REGISTER (tmr2Control) & hwr328TmrControlEnInterrupt) != 0) + { + WRITE_REGISTER (intPendingLo, READ_REGISTER (intPendingLo) | hwr328IntLoTimer2); + EmRegs328::UpdateInterrupts (); + } + } + } + + if ((fCycle += increment) > READ_REGISTER (tmr2Compare)) + { + fCycle = 0; + + if (++fTick >= 100) + { + fTick = 0; + + if (++fSec >= 60) + { + fSec = 0; + + if (++fMin >= 60) + { + fMin = 0; + + if (++fHour >= 24) + { + fHour = 0; + } + } + } + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::CycleSlowly +// --------------------------------------------------------------------------- +// Handles periodic events that need to occur when the processor cycles (like +// updating timer registers). This function is called in two places from +// Emulator::Execute. Interestingly, the loop runs 3% FASTER if this function +// is in its own separate function instead of being inline. + +void EmRegs328::CycleSlowly (Bool sleeping) +{ + UNUSED_PARAM(sleeping) + + // See if a hard button is pressed. + + EmAssert (gSession); + if (gSession->HasButtonEvent ()) + { + EmButtonEvent event = gSession->GetButtonEvent (); + if (event.fButton == kElement_CradleButton) + { + EmRegs328::HotSyncEvent (event.fButtonIsDown); + } + else + { + EmRegs328::ButtonEvent (event.fButton, event.fButtonIsDown); + } + } + + // See if there's anything new ("Put the data on the bus") + + EmRegs328::UpdateUARTState (false); + + // Check to see if the RTC alarm is ready to go off. First see + // if the RTC is enabled, and that the alarm event isn't already + // registered (the latter check is just an optimization). + + if ((READ_REGISTER (rtcIntEnable) & hwr328RTCIntEnableAlarm) != 0 && + (READ_REGISTER (rtcIntStatus) & hwr328RTCIntStatusAlarm) == 0) + { + uint32 rtcAlarm = READ_REGISTER (rtcAlarm); + + long almHour = (rtcAlarm & hwr328RTCAlarmHoursMask) >> hwr328RTCAlarmHoursOffset; + long almMin = (rtcAlarm & hwr328RTCAlarmMinutesMask) >> hwr328RTCAlarmMinutesOffset; + long almSec = (rtcAlarm & hwr328RTCAlarmSecondsMask) >> hwr328RTCAlarmSecondsOffset; + long almInSeconds = (almHour * 60 * 60) + (almMin * 60) + almSec; + + long nowHour; + long nowMin; + long nowSec; + ::GetHostTime (&nowHour, &nowMin, &nowSec); + long nowInSeconds = (nowHour * 60 * 60) + (nowMin * 60) + nowSec; + + if (almInSeconds <= nowInSeconds) + { + WRITE_REGISTER (rtcIntStatus, READ_REGISTER (rtcIntStatus) | hwr328RTCIntStatusAlarm); + EmRegs328::UpdateRTCInterrupts (); + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::TurnSoundOff +// --------------------------------------------------------------------------- + +void EmRegs328::TurnSoundOff (void) +{ + uint16 pwmControl = READ_REGISTER (pwmControl); + WRITE_REGISTER (pwmControl, pwmControl & ~hwr328PWMControlEnable); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::ResetTimer +// --------------------------------------------------------------------------- + +void EmRegs328::ResetTimer (void) +{ + WRITE_REGISTER (tmr2Counter, 0); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::ResetRTC +// --------------------------------------------------------------------------- + +void EmRegs328::ResetRTC (void) +{ + fHour = 15; + fMin = 0; + fSec = 0; + fTick = 0; + fCycle = 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetInterruptLevel +// --------------------------------------------------------------------------- + +int32 EmRegs328::GetInterruptLevel (void) +{ + uint16 intStatusHi = READ_REGISTER (intStatusHi); + uint16 intStatusLo = READ_REGISTER (intStatusLo); + + // Level 7 = IRQ7. + + if ((intStatusHi & hwr328IntHiNMI) != 0) + return 7; + + // Level 6 = SPIS, TMR1, IRQ6. + + if ((intStatusHi & (hwr328IntHiTimer1 | hwr328IntHiSPIS | hwr328IntHiIRQ6)) != 0) + return 6; + + // Level 5 = PEN. + + if ((intStatusHi & hwr328IntHiPen) != 0) + return 5; + + // Level 4 = SPIM, TMR2, UART, WDT, RTC, KB, PWM, INT0 - INT7. + + if ((intStatusLo & ( hwr328IntLoAllKeys | + hwr328IntLoPWM | + hwr328IntLoKbd | + // hwr328IntLoLCDC | + hwr328IntLoRTC | + hwr328IntLoWDT | + hwr328IntLoTimer2 | + hwr328IntLoSPIM)) != 0) + return 4; + + // Level 3 = IRQ3. + + if ((intStatusHi & hwr328IntHiIRQ3) != 0) + return 3; + + // Level 2 = IRQ2. + + if ((intStatusHi & hwr328IntHiIRQ2) != 0) + return 2; + + // Level 1 = IRQ1. + + if ((intStatusHi & hwr328IntHiIRQ1) != 0) + return 1; + + // Level 0. + + return -1; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetInterruptBase +// --------------------------------------------------------------------------- + +int32 EmRegs328::GetInterruptBase (void) +{ + return READ_REGISTER (intVector) & 0xF8; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetLCDHasFrame +// --------------------------------------------------------------------------- + +Bool EmRegs328::GetLCDHasFrame (void) +{ + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetLCDBeginEnd +// --------------------------------------------------------------------------- + +void EmRegs328::GetLCDBeginEnd (emuptr& begin, emuptr& end) +{ + emuptr baseAddr = READ_REGISTER (lcdStartAddr); + int rowBytes = READ_REGISTER (lcdPageWidth) * 2; + int height = READ_REGISTER (lcdScreenHeight) + 1; + + begin = baseAddr; + end = baseAddr + rowBytes * height; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetLCDScanlines +// --------------------------------------------------------------------------- + +void EmRegs328::GetLCDScanlines (EmScreenUpdateInfo& info) +{ + // Get the screen metrics. + + int32 bpp = 1 << (READ_REGISTER (lcdPanelControl) & 0x01); + int32 width = READ_REGISTER (lcdScreenWidth) + 1; + int32 height = READ_REGISTER (lcdScreenHeight) + 1; + int32 rowBytes = READ_REGISTER (lcdPageWidth) * 2; + emuptr baseAddr = READ_REGISTER (lcdStartAddr); + + info.fLeftMargin = READ_REGISTER (lcdPanningOffset) & 0x0F; + + EmPixMapFormat format = bpp == 1 ? kPixMapFormat1 : + bpp == 2 ? kPixMapFormat2 : + bpp == 4 ? kPixMapFormat4 : + kPixMapFormat8; + + RGBList colorTable; + this->PrvGetPalette (colorTable); + + // Set format, size, and color table of EmPixMap. + + info.fImage.SetSize (EmPoint (width, height)); + info.fImage.SetFormat (format); + info.fImage.SetRowBytes (rowBytes); + info.fImage.SetColorTable (colorTable); + + // Determine first and last scanlines to fetch, and fetch them. + + info.fFirstLine = (info.fScreenLow - baseAddr) / rowBytes; + info.fLastLine = (info.fScreenHigh - baseAddr - 1) / rowBytes + 1; + + long firstLineOffset = info.fFirstLine * rowBytes; + long lastLineOffset = info.fLastLine * rowBytes; + + EmMem_memcpy ( + (void*) ((uint8*) info.fImage.GetBits () + firstLineOffset), + baseAddr + firstLineOffset, + lastLineOffset - firstLineOffset); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetUARTDevice +// --------------------------------------------------------------------------- +// Return what sort of device is hooked up to the given UART. + +EmUARTDeviceType EmRegs328::GetUARTDevice (int /*uartNum*/) +{ + Bool serEnabled = this->GetLineDriverState (kUARTSerial); + Bool irEnabled = this->GetLineDriverState (kUARTIR); + + // It's probably an error to have them both enabled at the same + // time. !!! TBD: make this an error message. + + EmAssert (!(serEnabled && irEnabled)); + + if (serEnabled) + return kUARTSerial; + + if (irEnabled) + return kUARTIR; + + return kUARTNone; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetDynamicHeapSize +// --------------------------------------------------------------------------- + +int32 EmRegs328::GetDynamicHeapSize (void) +{ + uint32 result = 0; + + uint32 csCSelect0 = READ_REGISTER (csCSelect0) & ADDRESS_MASK; + uint32 csCSelect1 = READ_REGISTER (csCSelect1) & ADDRESS_MASK; + + if (csCSelect0 == 0x0000 && csCSelect1 == 0x0000) + { + result = 0 * 1024L; + } + else if (csCSelect0 == 0x0070 && csCSelect1 == 0x0000) + { + result = 32 * 1024L; + } + else if (csCSelect0 == 0x00F0 && csCSelect1 == 0x0000) + { + result = 64 * 1024L; + } + else if (csCSelect0 == 0x0070 && csCSelect1 == 0x0070) + { + // This one's odd, but the Symbol seems to (temporarily) + // set up this configuration when running with 2Meg of RAM. + result = 96 * 1024L; + } + else if (csCSelect0 == 0x00F0 && csCSelect1 == 0x0070) + { + result = 96 * 1024L; + } + else if (csCSelect0 == 0x01F0 && csCSelect1 == 0x0000) + { + result = 128 * 1024L; + } + else if (csCSelect0 == 0x03F0 && csCSelect1 == 0x0000) + { + result = 256 * 1024L; + } + else + { + EmAssert (false); + } + + if (!ChipSelectsConfigured()) + { + result = 16 * 1024L * 1024L; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetROMSize +// --------------------------------------------------------------------------- + +int32 EmRegs328::GetROMSize (void) +{ + uint32 result = 2 * 1024L * 1024L; + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetROMBaseAddress +// --------------------------------------------------------------------------- + +emuptr EmRegs328::GetROMBaseAddress (void) +{ + if (!this->ChipSelectsConfigured()) + { + return 0xFFFFFFFF; + } + + return 0x10C00000; // use known value +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::ChipSelectsConfigured +// --------------------------------------------------------------------------- + +Bool EmRegs328::ChipSelectsConfigured (void) +{ + return READ_REGISTER (csAGroupBase) & 0x0001; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetSystemClockFrequency +// --------------------------------------------------------------------------- + +int32 EmRegs328::GetSystemClockFrequency (void) +{ + uint16 pllControl = READ_REGISTER (pllControl); + uint16 pllFreqSel = READ_REGISTER (pllFreqSel); + + uint16 PC = (pllFreqSel & 0x00FF); + uint16 QC = (pllFreqSel & 0x0F00) >> 8; + + uint32 result = 32768L * (14 * (PC + 1) + QC + 1); + + // Divide by the system clock scaler, if needed. + + switch (pllControl & 0x0F00) + { + case hwr328PLLControlSysVCODiv2: + result /= 2; + break; + + case hwr328PLLControlSysVCODiv4: + result /= 4; + break; + + case hwr328PLLControlSysVCODiv8: + result /= 8; + break; + + case hwr328PLLControlSysVCODiv16: + result /= 16; + break; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetCanStop +// --------------------------------------------------------------------------- + +Bool EmRegs328::GetCanStop (void) +{ + // Make sure Timer 2 is enabled or the RTC interrupt is enabled. + + if ((READ_REGISTER (tmr2Control) & hwr328TmrControlEnable) != 0) + return true; + + if ((READ_REGISTER (rtcIntEnable) & hwr328RTCIntEnableAlarm) != 0) + return true; + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetAsleep +// --------------------------------------------------------------------------- + +Bool EmRegs328::GetAsleep (void) +{ + return ((READ_REGISTER (pllControl) & hwr328PLLControlDisable) != 0); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetPortInputValue +// --------------------------------------------------------------------------- +// Return the GPIO values for the pins on the port. These values are used +// if the select pins are high. + +uint8 EmRegs328::GetPortInputValue (int port) +{ + uint8 result = 0; + + if (port == 'D') + { + result = this->GetPortInternalValue (port); + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetPortInternalValue +// --------------------------------------------------------------------------- +// Return the dedicated values for the pins on the port. These values are +// used if the select pins are low. + +uint8 EmRegs328::GetPortInternalValue (int port) +{ + uint8 result = 0; + + if (port == 'C') + { + // This makes the power on key work. If the signal is not asserted, the + // unit will not transition between asleep and awake (cf. HwrSleep, HwrWake). + + result |= hwr328PortCNMI; + } + + else if (port == 'D') + { + // If the ID_DETECT pin is asserted, load the data lines with the + // hardware ID. + + if (EmRegs328::IDDetectAsserted ()) + { + result |= EmRegs328::GetHardwareID (); + } + + // Otherwise, load the lines with keyboard information. + + else + { + // Get the INT bits that need to be set. + + result |= this->GetKeyBits (); + } + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::PortDataChanged +// --------------------------------------------------------------------------- + +void EmRegs328::PortDataChanged (int port, uint8, uint8 newValue) +{ + if (port == 'D') + { + // Clear the interrupt bits that are having a 1 written to them. + // Only clear them if they're configured as edge-senstive. + + uint8 portDIntEdge = READ_REGISTER (portDIntEdge); + + PRINTF ("EmRegs328::PortDataChanged (D): fPortDEdge = 0x%02lX", (uint32) (uint8) fPortDEdge); + PRINTF ("EmRegs328::PortDataChanged (D): portDIntEdge = 0x%02lX", (uint32) (uint8) portDIntEdge); + PRINTF ("EmRegs328::PortDataChanged (D): newValue = 0x%02lX", (uint32) (uint8) newValue); + + fPortDEdge &= ~(newValue & portDIntEdge); + + PRINTF ("EmRegs328::PortDataChanged (D): fPortDEdge = 0x%02lX", (uint32) (uint8) fPortDEdge); + + // Set the new interrupt state. + + EmRegs328::UpdatePortDInterrupts (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::pllFreqSelRead +// --------------------------------------------------------------------------- + +uint32 EmRegs328::pllFreqSelRead (emuptr address, int size) +{ + // Simulate the rising and falling of the CLK32 signal so that functions + // like HwrPreRAMInit, HwrShutDownPLL, PrvSetPLL, and PrvShutDownPLL + // won't hang. + + uint16 pllFreqSel = READ_REGISTER (pllFreqSel) ^ 0x8000; + WRITE_REGISTER (pllFreqSel, pllFreqSel); + + // Finish up by doing a standard read. + + return EmRegs328::StdRead (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::portXDataRead +// --------------------------------------------------------------------------- + +uint32 EmRegs328::portXDataRead (emuptr address, int) +{ + // The value read can come from three different places: + // + // - the value what was written to the data register + // - any dedicated inputs + // - any GPIO inputs + // + // The value returned depends on the settings of the SEL and DIR + // registers. So let's get those settings, the values from the three + // input sources, and build up a return value based on those. + + int port = GetPort (address); + + uint8 sel = StdRead (address + 2, 1); + uint8 dir = StdRead (address - 1, 1); + uint8 output = StdRead (address + 0, 1); + uint8 input = EmHAL::GetPortInputValue (port); + uint8 intFn = EmHAL::GetPortInternalValue (port); + + uint8 xsel = sel; + uint8 xdir = dir; + uint8 xoutput = output; + uint8 xinput = input; + uint8 xintFn = intFn; + + if (port == 'D') + { + sel = 0xFF; // No "select" bit in low nybble, so set for IO values. + + // The system will poll portD twice in KeyBootKeys to see + // if any keys are down. Wait at least that long before + // letting up any boot keys maintained by the session. When we + // do call ReleaseBootKeys, set our counter to -1 as a flag not + // to call it any more. + + if (fPortDDataCount != 0xFFFFFFFF && ++fPortDDataCount >= 2 * 2) + { + fPortDDataCount = 0xFFFFFFFF; + gSession->ReleaseBootKeys (); + } + } + + // Use the internal chip function bits if the "sel" bits are zero. + + intFn &= ~sel; + + // Otherwise, use the I/O bits. + + output &= sel & dir; // Use the output bits if the "dir" is one. + input &= sel & ~dir; // Use the input bits if the "dir" is zero. + + // Assert that there are no overlaps. + + EmAssert ((output & input) == 0); + EmAssert ((output & intFn) == 0); + EmAssert ((input & intFn) == 0); + + // Mush everything together. + + uint8 result = output | input | intFn; + + // If this is port D, flip the bits if the POLARITY register says to. + // (!!! Does this inversion apply only to input bits? That is, the + // bits where the "dir" register has 0 bits?) + + if (0 && port == 'D') + { + uint8 polarity = READ_REGISTER (portDPolarity); + PRINTF ("EmRegs328::portXDataRead: polarity = 0x%02lX", (uint32) polarity); + result ^= polarity; + } + + PRINTF ("EmRegs328::port%cDataRead: sel dir output input intFn result", (char) port); + PRINTF ("EmRegs328::port%cDataRead: 0x%02lX 0x%02lX 0x%02lX 0x%02lX 0x%02lX 0x%02lX", + (char) port, (uint32) xsel, (uint32) xdir, (uint32) xoutput, (uint32) xinput, (uint32) xintFn, (uint32) result); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::tmr1StatusRead +// --------------------------------------------------------------------------- + +uint32 EmRegs328::tmr1StatusRead (emuptr address, int size) +{ + uint16 tmr1Counter = READ_REGISTER (tmr1Counter) + 16; + uint16 tmr1Compare = READ_REGISTER (tmr1Compare); + uint16 tmr1Control = READ_REGISTER (tmr1Control); + + // Increment the timer. + + WRITE_REGISTER (tmr1Counter, tmr1Counter); + + // If the timer has passed the specified value... + + if ( (tmr1Counter - tmr1Compare) < 16 ) + { + // Set the flag saying the timer timed out. + + uint16 tmr1Status = READ_REGISTER (tmr1Status) | hwr328TmrStatusCompare; + WRITE_REGISTER (tmr1Status, tmr1Status); + + // If it's not a free-running timer, reset it to zero. + + if ((tmr1Control & hwr328TmrControlFreeRun) == 0) + { + WRITE_REGISTER (tmr1Counter, 0); + } + } + + // Remember this guy for later (see EmRegs328::tmr1StatusWrite()) + + fLastTmr1Status |= READ_REGISTER (tmr1Status); + + // Finish up by doing a standard read. + + return EmRegs328::StdRead (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::tmr2StatusRead +// --------------------------------------------------------------------------- + +uint32 EmRegs328::tmr2StatusRead (emuptr address, int size) +{ +#if 0 // (Greg doesn't do this for Timer 2...I wonder why) + + /* + ram_rom.cpp: DBReg::tmr2StatusRead: Hmm, I don't update the TMR2 count + value. As with everything else that's missing in my DragonBall + emulation, it's probably because I never found anything that needed it. + If you know otherwise, by all means implement it. Also, the magic value + of 16 counts per status read seemed to be about right for the programmed + timer 1 frequency. It isn't likely to be right for timer 2. + + -- Greg + */ + + uint16 tmr2Counter = READ_REGISTER (tmr2Counter) + 16; + uint16 tmr2Compare = READ_REGISTER (tmr2Compare); + uint16 tmr2Control = READ_REGISTER (tmr2Control); + + // Increment the timer. + + WRITE_REGISTER (tmr2Counter, tmr2Counter); + + // If the timer has passed the specified value... + + if ( (tmr2Counter - tmr2Compare) < 16 ) + { + // Set the flag saying the timer timed out. + + uint16 tmr2Status = READ_REGISTER (tmr1Status) | hwr328TmrStatusCompare; + WRITE_REGISTER (tmr2Status, tmr2Status); + + // If it's not a free-running timer, reset it to zero. + + if ( (tmr2Control & hwr328TmrControlFreeRun) == 0 ) + WRITE_REGISTER (tmr2Counter, 0); + } +#endif + + fLastTmr2Status |= READ_REGISTER (tmr2Status); // remember this guy for later (see EmRegs328::tmr2StatusWrite()) + + // Finish up by doing a standard read. + + return EmRegs328::StdRead (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::uartRead +// --------------------------------------------------------------------------- + +uint32 EmRegs328::uartRead (emuptr address, int size) +{ + // If this is a full read, get the next byte from the FIFO. + + Bool refreshRxData = (address == addressof (uReceive)) && (size == 2); + + // See if there's anything new ("Put the data on the bus") + + EmRegs328::UpdateUARTState (refreshRxData); + + // Finish up by doing a standard read. + + return EmRegs328::StdRead (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::rtcHourMinSecRead +// --------------------------------------------------------------------------- + +uint32 EmRegs328::rtcHourMinSecRead (emuptr address, int size) +{ + // Get the desktop machine's time. + + long hour, min, sec; + + if (Hordes::IsOn ()) + { + hour = fHour; + min = fMin; + sec = fSec; + } + else + { + ::GetHostTime (&hour, &min, &sec); + } + + // Update the register. + + WRITE_REGISTER (rtcHourMinSec, (hour << hwr328RTCHourMinSecHoursOffset) + | (min << hwr328RTCHourMinSecMinutesOffset) + | (sec << hwr328RTCHourMinSecSecondsOffset)); + + // Finish up by doing a standard read. + + return EmRegs328::StdRead (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::csASelect1Write +// --------------------------------------------------------------------------- + +void EmRegs328::csASelect1Write (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegs328::StdWrite (address, size, value); + + // Check its new state and update our ram-protect flag. + + gMemAccessFlags.fProtect_SRAMSet = (READ_REGISTER (csASelect1) & 0x0008) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::csCSelect0Write +// --------------------------------------------------------------------------- + +void EmRegs328::csCSelect0Write (emuptr address, int size, uint32 value) +{ + uint32 csCSelect0 = READ_REGISTER (csCSelect0); + + // Do a standard update of the register. + + EmRegs328::StdWrite (address, size, value); + + // Check to see if the unprotected memory range changed. + + if ((csCSelect0 & ADDRESS_MASK) != (READ_REGISTER (csCSelect0) & ADDRESS_MASK)) + { + EmAssert (gSession); + gSession->ScheduleResetBanks (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::csCSelect1Write +// --------------------------------------------------------------------------- + +void EmRegs328::csCSelect1Write (emuptr address, int size, uint32 value) +{ + uint32 csCSelect1 = READ_REGISTER (csCSelect1); + + // Do a standard update of the register. + + EmRegs328::StdWrite (address, size, value); + + // Check to see if the unprotected memory range changed. + + if ((csCSelect1 & ADDRESS_MASK) != (READ_REGISTER (csCSelect1) & ADDRESS_MASK)) + { + EmAssert (gSession); + gSession->ScheduleResetBanks (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::intMaskHiWrite +// --------------------------------------------------------------------------- + +void EmRegs328::intMaskHiWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegs328::StdWrite (address, size, value); + + // Respond to the new interrupt state. + + EmRegs328::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::intMaskLoWrite +// --------------------------------------------------------------------------- + +void EmRegs328::intMaskLoWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegs328::StdWrite (address, size, value); + + // Respond to the new interrupt state. + + EmRegs328::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::intStatusHiWrite +// --------------------------------------------------------------------------- + +void EmRegs328::intStatusHiWrite (emuptr address, int size, uint32 value) +{ + // IRQ1, IRQ2, IRQ3, IRQ6 and IRQ7 are cleared by writing to their + // respective status bits. We handle those there. Since there are + // no interrupt status bits like this in intStatusLo, we don't need + // a handler for that register; we only handle intStatusHi. + + // Even though this is a 16-bit register as defined by the Palm headers, + // it's a 32-bit register according to Dragonball docs, and is in fact + // accessed that way in the kernal files (cf. HwrIRQ4Handler). In those + // cases, we're still only interested in access to the IRQ# bits, so we + // can turn 4-byte accesses into 2-byte accesses. + + if (size == 4) + value >>= 16; + + // Take into account the possibility of 1-byte accesses, too. If we're + // accessing the upper byte, just return. If we're accessing the lower + // byte, we can treat it as a 2-byte access. + + else if (size == 1 && address == addressof (intStatusHi)) + return; + + // Now we can treat the rest of this function as a word-write to intStatusHi. + + uint16 intPendingHi = READ_REGISTER (intPendingHi); + + // For each interrupt: + // If we're writing to that interrupt's status bit and its edge bit is set: + // - clear the interrupt's pending bit + // - respond to the new interrupt state. + + #undef CLEAR_PENDING_INTERRUPT + #define CLEAR_PENDING_INTERRUPT(edge, irq) \ + if ( (READ_REGISTER (intControl) & edge) && (value & (irq)) ) \ + { \ + intPendingHi &= ~(irq); \ + } + + CLEAR_PENDING_INTERRUPT (hwr328IntCtlEdge1, hwr328IntHiIRQ1); + CLEAR_PENDING_INTERRUPT (hwr328IntCtlEdge2, hwr328IntHiIRQ2); + CLEAR_PENDING_INTERRUPT (hwr328IntCtlEdge3, hwr328IntHiIRQ3); + CLEAR_PENDING_INTERRUPT (hwr328IntCtlEdge6, hwr328IntHiIRQ6); + + // IRQ7 is not edge-programmable, so clear it if we're merely writing to it. + + if (value & hwr328IntHiNMI) + { + intPendingHi &= ~(hwr328IntHiNMI); + } + + // If we're emulating the user pressing the hotsync button, make sure the + // interrupt stays asserted. (!!! Should we use the same technique for + // other buttons, too? It doesn't seem to be needed right now, but doing + // that may more closely mirror the hardware.) + + if (fHotSyncButtonDown) + { + intPendingHi |= hwr328IntHiIRQ1; + } + else + { + intPendingHi &= ~hwr328IntHiIRQ1; + } + + WRITE_REGISTER (intPendingHi, intPendingHi); + EmRegs328::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::portXDataWrite +// --------------------------------------------------------------------------- + +void EmRegs328::portXDataWrite (emuptr address, int size, uint32 value) +{ + // Get the old value before updating it. + + uint8 oldValue = StdRead (address, size); + + // Take a snapshot of the line driver states. + + Bool driverStates[kUARTEnd]; + EmHAL::GetLineDriverStates (driverStates); + + // Now update the value with a standard write. + + StdWrite (address, size, value); + + // Let anyone know that it's changed. + + int port = GetPort (address); + PRINTF ("EmRegs328::port%cDataWrite: oldValue = 0x%02lX", (char) port, (uint32) (uint8) oldValue); + PRINTF ("EmRegs328::port%cDataWrite: newValue = 0x%02lX", (char) port, (uint32) (uint8) value); + + EmHAL::PortDataChanged (port, oldValue, value); + + // Respond to any changes in the line driver states. + + EmHAL::CompareLineDriverStates (driverStates); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::portDIntReqEnWrite +// --------------------------------------------------------------------------- + +void EmRegs328::portDIntReqEnWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegs328::StdWrite (address, size, value); + + // Set the new interrupt state. + + EmRegs328::UpdatePortDInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::tmr1StatusWrite +// --------------------------------------------------------------------------- + +void EmRegs328::tmr1StatusWrite (emuptr address, int size, uint32 value) +{ + UNUSED_PARAM(address) + UNUSED_PARAM(size) + + EmAssert (size == 2); // This function's a hell of a lot easier to write if + // we assume only full-register access. + + // Get the current value. + + uint16 tmr1Status = READ_REGISTER (tmr1Status); + + // If the user had previously read the status bits while they + // were set, then it's OK for them to be clear now. Otherwise, + // we have to merge any set status bits back in. + + tmr1Status &= value | ~fLastTmr1Status; // fLastTmr1Status was set in EmRegs328::tmr1StatusRead() + + WRITE_REGISTER (tmr1Status, tmr1Status); + + fLastTmr1Status = 0; + if ((tmr1Status & hwr328TmrStatusCompare) == 0) + { + uint16 intPendingHi = READ_REGISTER (intPendingHi) & ~hwr328IntHiTimer1; + WRITE_REGISTER (intPendingHi, intPendingHi); + + // Respond to the new interrupt state. + + EmRegs328::UpdateInterrupts (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::tmr2StatusWrite +// --------------------------------------------------------------------------- + +void EmRegs328::tmr2StatusWrite (emuptr address, int size, uint32 value) +{ + UNUSED_PARAM(address) + UNUSED_PARAM(size) + + EmAssert (size == 2); // This function's a hell of a lot easier to write if + // we assume only full-register access. + + // Get the current value. + + uint16 tmr2Status = READ_REGISTER (tmr2Status); + + // If the user had previously read the status bits while they + // were set, then it's OK for them to be clear now. Otherwise, + // we have to merge any set status bits back in. + + tmr2Status &= value | ~fLastTmr2Status; // fLastTmr2Status was set in EmRegs328::tmr2StatusRead() + + WRITE_REGISTER (tmr2Status, tmr2Status); + + fLastTmr2Status = 0; + if ( (tmr2Status & hwr328TmrStatusCompare) == 0 ) + { + uint16 intPendingLo = READ_REGISTER (intPendingLo) & ~hwr328IntLoTimer2; + WRITE_REGISTER (intPendingLo, intPendingLo); + + // Respond to the new interrupt state. + + EmRegs328::UpdateInterrupts (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::wdCounterWrite +// --------------------------------------------------------------------------- + +void EmRegs328::wdCounterWrite (emuptr address, int size, uint32 value) +{ + UNUSED_PARAM(address) + UNUSED_PARAM(size) + UNUSED_PARAM(value) + + // Always set it to zero (a write to this register always resets it). + + WRITE_REGISTER (wdCounter, 0); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::spiMasterControlWrite +// --------------------------------------------------------------------------- + +void EmRegs328::spiMasterControlWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegs328::StdWrite (address, size, value); + + // Get the current value. + + uint16 spiMasterControl = READ_REGISTER (spiMasterControl); + + // Check to see if data exchange and interrupts are enabled. + + #define BIT_MASK (hwr328SPIMControlExchange | hwr328SPIMControlIntEnable) + if ((spiMasterControl & BIT_MASK) != 0) + { + // If so, assert the interrupt and clear the exchange bit. + + spiMasterControl |= hwr328SPIMControlIntStatus; + spiMasterControl &= ~hwr328SPIMControlExchange; + + WRITE_REGISTER (spiMasterControl, spiMasterControl); + +/* + // If we wanted digitizer data, load it into the SPIM data register. + + switch (READ_REGISTER (portFData) & hwrTD1PortFPanelMask) + { + case (hwrTD1PortFPanelCfgXMeas): + WRITE_REGISTER (spiMasterData, (0xFF - Hardware::fgPen_HorzLocation) * 2); + break; + + case (hwrTD1PortFPanelCfgYMeas): + WRITE_REGISTER (spiMasterData, (0xFF - Hardware::fgPen_VertLocation) * 2); + break; + } +*/ + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::uartWrite +// --------------------------------------------------------------------------- + +void EmRegs328::uartWrite(emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegs328::StdWrite (address, size, value); + + // If this write included the TX_DATA field, signal that it needs to + // be transmitted. + + Bool sendTxData = + ((address == addressof (uTransmit)) && (size == 2)) || + ((address == addressof (uTransmit) + 1) && (size == 1)); + + // React to any changes. + + EmRegs328::UARTStateChanged (sendTxData); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::lcdRegisterWrite +// --------------------------------------------------------------------------- + +void EmRegs328::lcdRegisterWrite(emuptr address, int size, uint32 value) +{ + // First, get the old value in case we need to see what changed. + + uint32 oldValue = EmRegs328::StdRead (address, size); + + // Do a standard update of the register. + + EmRegs328::StdWrite (address, size, value); + + // Note what changed. + + if (address == addressof (lcdScreenWidth)) + { + EmScreen::InvalidateAll (); + } + else if (address == addressof (lcdScreenHeight)) + { + EmScreen::InvalidateAll (); + } + else if (address == addressof (lcdPanelControl)) + { + if (((value ^ oldValue) & hwr328LcdPanelControlGrayScale) != 0) + { + EmScreen::InvalidateAll (); + } + } + else if (address == addressof (lcdStartAddr)) + { + // Make sure the low-bit is always zero. + + uint32 lcdStartAddr = READ_REGISTER (lcdStartAddr) & 0xFFFFFFFE; + WRITE_REGISTER (lcdStartAddr, lcdStartAddr); + + EmScreen::InvalidateAll (); + } + else if (address == addressof (lcdPageWidth)) + { + if (value != oldValue) + { + EmScreen::InvalidateAll (); + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::rtcControlWrite +// --------------------------------------------------------------------------- + +void EmRegs328::rtcControlWrite(emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegs328::StdWrite (address, size, value); + + // Respond to the new interrupt state. + + EmRegs328::UpdateRTCInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::rtcIntStatusWrite +// --------------------------------------------------------------------------- + +void EmRegs328::rtcIntStatusWrite(emuptr address, int size, uint32 value) +{ + // Status bits are cleared by writing ones to them. + + // If we're doing a byte-write to the upper byte, shift the byte + // so that we can treat the operation as a word write. If we're + // doing a byte-write to the lower byte, this extension will happen + // automatically. + + if (address == addressof (rtcIntStatus) && size == 1) + value <<= 8; + + // Get the current value. + + uint16 rtcIntStatus = READ_REGISTER (rtcIntStatus); + + // Clear the requested bits. + + rtcIntStatus &= ~value; + + // Update the register. + + WRITE_REGISTER (rtcIntStatus, rtcIntStatus); + + // Respond to the new interrupt state. + + EmRegs328::UpdateRTCInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::rtcIntEnableWrite +// --------------------------------------------------------------------------- + +void EmRegs328::rtcIntEnableWrite(emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegs328::StdWrite (address, size, value); + + // Respond to the new interrupt state. + + EmRegs328::UpdateRTCInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::ButtonEvent +// --------------------------------------------------------------------------- +// Handles a Palm device button event by updating the appropriate registers. + +void EmRegs328::ButtonEvent (SkinElementType button, Bool buttonIsDown) +{ + uint16 bitNumber = this->ButtonToBits (button); + + // Get the bits that should have been set with the previous set + // of pressed keys. We use this old value to update the port D interrupts. + + uint8 oldBits = this->GetKeyBits (); + + // Update the set of keys that are currently pressed. + + if (buttonIsDown) + { + fKeyBits |= bitNumber; // Remember the key bit + } + else + { + fKeyBits &= ~bitNumber; // Forget the key bit + } + + // Now get the new set of bits that should be set. + + uint8 newBits = this->GetKeyBits (); + + PRINTF ("EmRegs328::ButtonEvent: fKeyBits = 0x%04lX", (uint32) fKeyBits); + PRINTF ("EmRegs328::ButtonEvent: oldBits = 0x%02lX", (uint32) oldBits); + PRINTF ("EmRegs328::ButtonEvent: newBits = 0x%02lX", (uint32) newBits); + + // Set the interrupt bits for the bits that went from off to on. + // These get cleared when portDData is written to. + + fPortDEdge |= newBits & ~oldBits; + + PRINTF ("EmRegs328::ButtonEvent: fPortDEdge = 0x%02lX", (uint32) fPortDEdge); + + // Set the new interrupt state. + + EmRegs328::UpdatePortDInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::HotSyncEvent +// --------------------------------------------------------------------------- +// Handles a HotSync button event by updating the appropriate registers. + +void EmRegs328::HotSyncEvent (Bool iButton_IsDown) +{ + // If the button changes state, set or clear the HotSync interrupt. + + uint16 intPendingHi = READ_REGISTER (intPendingHi); + + if (iButton_IsDown) + { + intPendingHi |= hwr328IntHiIRQ1; + fHotSyncButtonDown = true; + } + else + { + intPendingHi &= ~hwr328IntHiIRQ1; + fHotSyncButtonDown = false; + } + + WRITE_REGISTER (intPendingHi, intPendingHi); + + EmRegs328::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetKeyBits +// --------------------------------------------------------------------------- + +uint8 EmRegs328::GetKeyBits (void) +{ + // Return the key bits + + uint8 portDPullupEn = READ_REGISTER (portDPullupEn); // Interested where bits are one + uint8 keyBits = portDPullupEn & fKeyBits; + + PRINTF ("EmRegs328::GetKeyBits: keyBits = 0x%02lX", (uint32) keyBits); + + return keyBits; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::ButtonToBits +// --------------------------------------------------------------------------- + +uint16 EmRegs328::ButtonToBits (SkinElementType button) +{ + uint16 bitNumber = 0; + switch (button) + { + case kElement_None: break; + + case kElement_PowerButton: bitNumber = keyBitPower; break; + case kElement_UpButton: bitNumber = keyBitPageUp; break; + case kElement_DownButton: bitNumber = keyBitPageDown; break; + case kElement_App1Button: bitNumber = keyBitHard1; break; + case kElement_App2Button: bitNumber = keyBitHard2; break; + case kElement_App3Button: bitNumber = keyBitHard3; break; + case kElement_App4Button: bitNumber = keyBitHard4; break; + case kElement_CradleButton: bitNumber = keyBitCradle; break; + case kElement_Antenna: bitNumber = keyBitAntenna; break; + case kElement_ContrastButton: bitNumber = keyBitContrast; break; + +/* + // Symbol-specific + case kElement_TriggerLeft: bitNumber = keyBitTrigLeft; break; + case kElement_TriggerCenter: bitNumber = keyBitTrigCenter; break; + case kElement_TriggerRight: bitNumber = keyBitTrigRight; break; + case kElement_UpButtonLeft: bitNumber = keyBitPageUpLeft; break; + case kElement_UpButtonRight: bitNumber = keyBitPageUpRight; break; + case kElement_DownButtonLeft: bitNumber = keyBitPageDownLeft; break; + case kElement_DownButtonRight: bitNumber = keyBitPageDownRight; break; +*/ + default: EmAssert (false); + } + + return bitNumber; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::UpdateInterrupts +// --------------------------------------------------------------------------- +// Determines whether an interrupt has occurred by copying the Interrupt +// Pending Register to the Interrupt Status Register. + +void EmRegs328::UpdateInterrupts (void) +{ + // Copy the Interrupt Pending Register to the Interrupt Status + // Register, but ignore interrupts that are being masked. + + // Note: this function is not sensitive to the byte ordering of the registers, + // so their contents don't need to be accessed via READ_REGISTER or WRITE_REGISTER. + + f68328Regs.intStatusHi = f68328Regs.intPendingHi & ~f68328Regs.intMaskHi; + f68328Regs.intStatusLo = f68328Regs.intPendingLo & ~f68328Regs.intMaskLo; + + PRINTF ("EmRegs328::UpdateInterrupts: intMask = 0x%04lX %04lX", + (uint32) f68328Regs.intMaskHi, (uint32) f68328Regs.intMaskLo); + + PRINTF ("EmRegs328::UpdateInterrupts: intPending = 0x%04lX %04lX", + (uint32) f68328Regs.intPendingHi, (uint32) f68328Regs.intPendingLo); + + // If the Interrupt Status Register isn't clear, flag an interrupt. + + if (f68328Regs.intStatusHi || f68328Regs.intStatusLo) + { + regs.spcflags |= SPCFLAG_INT; + + PRINTF ("EmRegs328::UpdateInterrupts: intStatus = 0x%04lX %04lX", + (uint32) f68328Regs.intStatusHi, (uint32) f68328Regs.intStatusLo); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::UpdatePortDInterrupts +// --------------------------------------------------------------------------- +// Determine what interrupts need to be generated based on the current +// settings in portDData and fPortDEdge. + +void EmRegs328::UpdatePortDInterrupts (void) +{ + // Update INT0-INT7 of the Interrupt-Pending register (bits 8-15 of the low word). + + // First, get those bits and clear them out. + + uint16 intPendingLo = READ_REGISTER (intPendingLo) & ~hwr328IntLoAllKeys; + + + // Initialize the variable to hold the new interrupt settings. + + uint8 newBits = 0; + + + // Get some other values we're going to need: + + uint8 portDDir = READ_REGISTER (portDDir); // Interrupt on inputs only (when pin is low) + uint8 portDData = EmHAL::GetPortInputValue ('D'); + uint8 portDPolarity = READ_REGISTER (portDPolarity); + uint8 portDIntReqEn = READ_REGISTER (portDIntReqEn); + uint8 portDIntEdge = READ_REGISTER (portDIntEdge); + + + // We have a line-level interrupt if: + // + // - line-level interrupts are requested + // - the GPIO bit matches the polarity bit + + newBits |= ~portDIntEdge & portDData & portDPolarity; + newBits |= ~portDIntEdge & ~portDData & ~portDPolarity; + + + // We have an edge interrupt if: + // + // - edge interrupts are requested + // - an edge has been recorded + // + // Note that we should distinguish between rising and falling edges. + // For historical reasons, that's not done, and the Palm OS doesn't + // look for them, so it's OK for now. + + newBits |= portDIntEdge & fPortDEdge & portDPolarity; + newBits |= portDIntEdge & 0 & ~portDPolarity; + + + // Only have interrupts if they're enabled and the pin is configured for input. + + newBits &= portDIntReqEn & ~portDDir; + + PRINTF ("EmRegs328::UpdatePortDInterrupts: Dir Data Pol Req Edg PDE bits"); + PRINTF ("EmRegs328::UpdatePortDInterrupts: 0x%02lX 0x%02lX 0x%02lX 0x%02lX 0x%02lX 0x%02lX 0x%02lX", + (uint32) portDDir, (uint32) portDData, (uint32) portDPolarity, (uint32) portDIntReqEn, (uint32) portDIntEdge, + (uint32) fPortDEdge, (uint32) newBits); + + + // Merge in the new values and write out the result. + + intPendingLo |= (((uint16) newBits) << 8) & hwr328IntLoAllKeys; + WRITE_REGISTER (intPendingLo, intPendingLo); + + + // Respond to the new interrupt state. + + EmRegs328::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::UpdateRTCInterrupts +// --------------------------------------------------------------------------- +// Determine whether to set or clear the RTC bit in the interrupt pending +// register based on the current RTC register values. + +void EmRegs328::UpdateRTCInterrupts (void) +{ + // See if the RTC is enabled. + + Bool rtcEnabled = (READ_REGISTER (rtcControl) & hwr328RTCControlRTCEnable) != 0; + + // See if there are any RTC events that need to trigger an interrupt. + +#define BITS_TO_CHECK ( \ + hwr328RTCIntEnableSec | \ + hwr328RTCIntEnable24Hr | \ + hwr328RTCIntEnableAlarm | \ + hwr328RTCIntEnableMinute | \ + hwr328RTCIntEnableStopWatch ) + + uint16 rtcIntStatus = READ_REGISTER (rtcIntStatus); + uint16 rtcIntEnable = READ_REGISTER (rtcIntEnable); + uint16 rtcIntPending = rtcIntStatus & rtcIntEnable & BITS_TO_CHECK; + + Bool havePendingEvents = rtcIntPending != 0; + + // If the RTC is enabled and there are pending events, set the interrupt. + // Otherwise, clear the interrupt. + + uint16 intPendingLo = READ_REGISTER (intPendingLo); + + if (rtcEnabled && havePendingEvents) + { + intPendingLo |= hwr328IntLoRTC; // have events, so set interrupt + } + else + { + intPendingLo &= ~hwr328IntLoRTC; // no events, so clear interrupt + } + + // Update the interrupt pending register. + + WRITE_REGISTER (intPendingLo, intPendingLo); + + // Respond to the new interrupt state. + + EmRegs328::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::IDDetectAsserted +// --------------------------------------------------------------------------- +// cf. HwrIdentifyFeatures and HwrPreRAMInit. + +Bool EmRegs328::IDDetectAsserted (void) +{ + uint8 portEDir = READ_REGISTER (portEDir); + uint8 portEData = READ_REGISTER (portEData); + uint8 portEPullupEn = READ_REGISTER (portEPullupEn); + const uint8 kMask = hwrTD1PortENoBacklight; + + return (portEDir & kMask) == kMask && + (portEData & kMask) == 0 && + (portEPullupEn & kMask) == 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetHardwareID +// --------------------------------------------------------------------------- + +UInt8 EmRegs328::GetHardwareID (void) +{ + // Determine the hardware ID. + + // Note: Because of a Poser bug, I don't think any of the following actually + // gets executed. 328 ROMs first check to see if they're on a PalmPilot + // by executing the following: + // + // if (!(baseP->portEData & hwrTD1PortENoBacklight)) { + // ...on PalmPilot... + // } else { + // ...execute ID DETECT... + // } + // + // In Poser, hwrTD1PortENoBacklight is always zero (that's the bug), and + // so we always think we're on a PalmPilot, regardless of what 328 device + // we selected. + + EmAssert (gSession); + + EmDevice device = gSession->GetDevice (); + long miscFlags = device.HardwareID (); + + // Reverse map the following: +// GHwrMiscFlags = 0; +// if ( (keyState & keyBitHard1) == 0) GHwrMiscFlags |= hwrMiscFlagID1; +// if ( (keyState & keyBitHard2) == 0) GHwrMiscFlags |= hwrMiscFlagID2; +// if ( (keyState & keyBitHard3) == 0) GHwrMiscFlags |= hwrMiscFlagID3; +// if ( (keyState & keyBitHard4) == 0) GHwrMiscFlags |= hwrMiscFlagID4; + + uint8 keyState = ~0; + + if ((miscFlags & hwrMiscFlagID1) != 0) keyState &= ~keyBitHard1; + if ((miscFlags & hwrMiscFlagID2) != 0) keyState &= ~keyBitHard2; + if ((miscFlags & hwrMiscFlagID3) != 0) keyState &= ~keyBitHard3; + if ((miscFlags & hwrMiscFlagID4) != 0) keyState &= ~keyBitHard4; + + return keyState; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::UARTStateChanged +// --------------------------------------------------------------------------- + +void EmRegs328::UARTStateChanged (Bool sendTxData) +{ + EmUARTDragonball::State state (EmUARTDragonball::kUART_Dragonball); + + EmRegs328::MarshalUARTState (state); + fUART->StateChanged (state, sendTxData); + EmRegs328::UnmarshalUARTState (state); + + EmRegs328::UpdateUARTInterrupts (state); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::UpdateUARTState +// --------------------------------------------------------------------------- + +void EmRegs328::UpdateUARTState (Bool refreshRxData) +{ + EmUARTDragonball::State state (EmUARTDragonball::kUART_Dragonball); + + EmRegs328::MarshalUARTState (state); + fUART->UpdateState (state, refreshRxData); + UnmarshalUARTState (state); + + EmRegs328::UpdateUARTInterrupts (state); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::UpdateUARTInterrupts +// --------------------------------------------------------------------------- + +void EmRegs328::UpdateUARTInterrupts (const EmUARTDragonball::State& state) +{ + // Generate the appropriate interrupts. + + if (state.RX_FULL_ENABLE && state.RX_FIFO_FULL || + state.RX_HALF_ENABLE && state.RX_FIFO_HALF || + state.RX_RDY_ENABLE && state.DATA_READY || + state.TX_EMPTY_ENABLE && state.TX_FIFO_EMPTY || + state.TX_HALF_ENABLE && state.TX_FIFO_HALF || + state.TX_AVAIL_ENABLE && state.TX_AVAIL) + { + // Set the UART interrupt. + + WRITE_REGISTER (intPendingLo, READ_REGISTER (intPendingLo) | hwr328IntLoUART); + } + else + { + // Clear the UART interrupt. + + WRITE_REGISTER (intPendingLo, READ_REGISTER (intPendingLo) & ~hwr328IntLoUART); + } + + // Respond to the new interrupt state. + + EmRegs328::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::MarshalUARTState +// --------------------------------------------------------------------------- + +void EmRegs328::MarshalUARTState (EmUARTDragonball::State& state) +{ + uint16 uControl = READ_REGISTER (uControl); + uint16 uBaud = READ_REGISTER (uBaud); + uint16 uReceive = READ_REGISTER (uReceive); + uint16 uTransmit = READ_REGISTER (uTransmit); + uint16 uMisc = READ_REGISTER (uMisc); + + state.UART_ENABLE = (uControl & hwr328UControlUARTEnable) != 0; + state.RX_ENABLE = (uControl & hwr328UControlRxEnable) != 0; + state.TX_ENABLE = (uControl & hwr328UControlTxEnable) != 0; + state.RX_CLK_CONT = (uControl & hwr328UControlRxClock1x) != 0; + state.PARITY_EN = (uControl & hwr328UControlParityEn) != 0; + state.ODD_EVEN = (uControl & hwr328UControlParityOdd) != 0; + state.STOP_BITS = (uControl & hwr328UControlStopBits2) != 0; + state.CHAR8_7 = (uControl & hwr328UControlDataBits8) != 0; + state.GPIO_DELTA_ENABLE = (uControl & hwr328UControlGPIODeltaEn) != 0; // 68328 only +// state.OLD_ENABLE = (uControl & hwrEZ328UControlOldDataEn) != 0; // 68EZ328 only + state.CTS_DELTA_ENABLE = (uControl & hwr328UControlCTSDeltaEn) != 0; + state.RX_FULL_ENABLE = (uControl & hwr328UControlRxFullEn) != 0; + state.RX_HALF_ENABLE = (uControl & hwr328UControlRxHalfEn) != 0; + state.RX_RDY_ENABLE = (uControl & hwr328UControlRxRdyEn) != 0; + state.TX_EMPTY_ENABLE = (uControl & hwr328UControlTxEmptyEn) != 0; + state.TX_HALF_ENABLE = (uControl & hwr328UControlTxHalfEn) != 0; + state.TX_AVAIL_ENABLE = (uControl & hwr328UControlTxAvailEn) != 0; + + // Baud control register bits + // These are all values the user sets; we just look at them. + + state.GPIO_DELTA = (uBaud & hwr328UBaudGPIODelta) != 0; // 68328 only + state.GPIO = (uBaud & hwr328UBaudGPIOData) != 0; // 68328 only + state.GPIO_DIR = (uBaud & hwr328UBaudGPIODirOut) != 0; // 68328 only + state.GPIO_SRC = (uBaud & hwr328UBaudGPIOSrcBaudGen) != 0; // 68328 only +// state.UCLK_DIR = (uBaud & hwrEZ328UBaudUCLKDirOut) != 0; // 68EZ328 only + state.BAUD_SRC = (uBaud & hwr328UBaudBaudSrcGPIO) != 0; + state.DIVIDE = (uBaud & hwr328UBaudDivider) >> hwr328UBaudDivideBitOffset; + state.PRESCALER = (uBaud & hwr328UBaudPrescaler); + + // Receive register bits + // These are all input bits; we set them, not the user. + + state.RX_FIFO_FULL = (uReceive & hwr328UReceiveFIFOFull) != 0; + state.RX_FIFO_HALF = (uReceive & hwr328UReceiveFIFOHalf) != 0; + state.DATA_READY = (uReceive & hwr328UReceiveDataRdy) != 0; +// state.OLD_DATA = (uReceive & hwrEZ328UReceiveOldData) != 0; // 68EZ328 only + state.OVRUN = (uReceive & hwr328UReceiveOverrunErr) != 0; + state.FRAME_ERROR = (uReceive & hwr328UReceiveFrameErr) != 0; + state.BREAK = (uReceive & hwr328UReceiveBreakErr) != 0; + state.PARITY_ERROR = (uReceive & hwr328UReceiveParityErr) != 0; + state.RX_DATA = (uReceive & hwr328UReceiveData); + + // Transmitter register bits + // We set everything except TX_DATA; the user sets that + // value and ONLY that value. + + state.TX_FIFO_EMPTY = (uTransmit & hwr328UTransmitFIFOEmpty) != 0; + state.TX_FIFO_HALF = (uTransmit & hwr328UTransmitFIFOHalf) != 0; + state.TX_AVAIL = (uTransmit & hwr328UTransmitTxAvail) != 0; + state.SEND_BREAK = (uTransmit & hwr328UTransmitSendBreak) != 0; + state.IGNORE_CTS = (uTransmit & hwr328UTransmitIgnoreCTS) != 0; +// state.BUSY = (uTransmit & hwrEZ328UTransmitBusy) != 0; // 68EZ328 only + state.CTS_STATUS = (uTransmit & hwr328UTransmitCTSStatus) != 0; + state.CTS_DELTA = (uTransmit & hwr328UTransmitCTSDelta) != 0; + state.TX_DATA = (uTransmit & hwr328UTransmitData); + + // Misc register bits + // These are all values the user sets; we just look at them. + +// state.BAUD_TEST = (uMisc & hwrEZ328UMiscBaudTest) != 0; // 68EZ328 only + state.CLK_SRC = (uMisc & hwr328UMiscClkSrcGPIO) != 0; + state.FORCE_PERR = (uMisc & hwr328UMiscForceParityErr) != 0; + state.LOOP = (uMisc & hwr328UMiscLoopback) != 0; +// state.BAUD_RESET = (uMisc & hwrEZ328UMiscBaudReset) != 0; // 68EZ328 only +// state.IR_TEST = (uMisc & hwrEZ328UMiscIRTestEn) != 0; // 68EZ328 only + state.RTS_CONT = (uMisc & hwr328UMiscRTSThruFIFO) != 0; + state.RTS = (uMisc & hwr328UMiscRTSOut) != 0; + state.IRDA_ENABLE = (uMisc & hwr328UMiscIRDAEn) != 0; + state.IRDA_LOOP = (uMisc & hwr328UMiscLoopIRDA) != 0; +// state.RX_POL = (uMisc & hwrEZ328UMiscRXPolarityInv) != 0; // 68EZ328 only +// state.TX_POL = (uMisc & hwrEZ328UMiscTXPolarityInv) != 0; // 68EZ328 only +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::UnmarshalUARTState +// --------------------------------------------------------------------------- + +void EmRegs328::UnmarshalUARTState (const EmUARTDragonball::State& state) +{ + uint16 uControl = 0; + uint16 uBaud = 0; + uint16 uReceive = 0; + uint16 uTransmit = 0; + uint16 uMisc = 0; + + if (state.UART_ENABLE) uControl |= hwr328UControlUARTEnable; + if (state.RX_ENABLE) uControl |= hwr328UControlRxEnable; + if (state.TX_ENABLE) uControl |= hwr328UControlTxEnable; + if (state.RX_CLK_CONT) uControl |= hwr328UControlRxClock1x; + if (state.PARITY_EN) uControl |= hwr328UControlParityEn; + if (state.ODD_EVEN) uControl |= hwr328UControlParityOdd; + if (state.STOP_BITS) uControl |= hwr328UControlStopBits2; + if (state.CHAR8_7) uControl |= hwr328UControlDataBits8; + if (state.GPIO_DELTA_ENABLE)uControl |= hwr328UControlGPIODeltaEn; // 68328 only +// if (state.OLD_ENABLE) uControl |= hwrEZ328UControlOldDataEn; // 68EZ328 only + if (state.CTS_DELTA_ENABLE) uControl |= hwr328UControlCTSDeltaEn; + if (state.RX_FULL_ENABLE) uControl |= hwr328UControlRxFullEn; + if (state.RX_HALF_ENABLE) uControl |= hwr328UControlRxHalfEn; + if (state.RX_RDY_ENABLE) uControl |= hwr328UControlRxRdyEn; + if (state.TX_EMPTY_ENABLE) uControl |= hwr328UControlTxEmptyEn; + if (state.TX_HALF_ENABLE) uControl |= hwr328UControlTxHalfEn; + if (state.TX_AVAIL_ENABLE) uControl |= hwr328UControlTxAvailEn; + + // Baud control register bits + // These are all values the user sets; we just look at them. + + if (state.GPIO_DELTA) uBaud |= hwr328UBaudGPIODelta; // 68328 only + if (state.GPIO) uBaud |= hwr328UBaudGPIOData; // 68328 only + if (state.GPIO_DIR) uBaud |= hwr328UBaudGPIODirOut; // 68328 only + if (state.GPIO_SRC) uBaud |= hwr328UBaudGPIOSrcBaudGen; // 68328 only +// if (state.UCLK_DIR) uBaud |= hwrEZ328UBaudUCLKDirOut; // 68EZ328 only + if (state.BAUD_SRC) uBaud |= hwr328UBaudBaudSrcGPIO; + + uBaud |= (state.DIVIDE << hwr328UBaudDivideBitOffset) & hwr328UBaudDivider; + uBaud |= (state.PRESCALER) & hwr328UBaudPrescaler; + + // Receive register bits + // These are all input bits; we set them, not the user. + + if (state.RX_FIFO_FULL) uReceive |= hwr328UReceiveFIFOFull; + if (state.RX_FIFO_HALF) uReceive |= hwr328UReceiveFIFOHalf; + if (state.DATA_READY) uReceive |= hwr328UReceiveDataRdy; +// if (state.OLD_DATA) uReceive |= hwrEZ328UReceiveOldData; // 68EZ328 only + if (state.OVRUN) uReceive |= hwr328UReceiveOverrunErr; + if (state.FRAME_ERROR) uReceive |= hwr328UReceiveFrameErr; + if (state.BREAK) uReceive |= hwr328UReceiveBreakErr; + if (state.PARITY_ERROR) uReceive |= hwr328UReceiveParityErr; + + uReceive |= (state.RX_DATA) & hwr328UReceiveData; + + // Transmitter register bits + // We set everything except TX_DATA; the user sets that + // value and ONLY that value. + + if (state.TX_FIFO_EMPTY) uTransmit |= hwr328UTransmitFIFOEmpty; + if (state.TX_FIFO_HALF) uTransmit |= hwr328UTransmitFIFOHalf; + if (state.TX_AVAIL) uTransmit |= hwr328UTransmitTxAvail; + if (state.SEND_BREAK) uTransmit |= hwr328UTransmitSendBreak; + if (state.IGNORE_CTS) uTransmit |= hwr328UTransmitIgnoreCTS; +// if (state.BUSY) uTransmit |= hwrEZ328UTransmitBusy; // 68EZ328 only + if (state.CTS_STATUS) uTransmit |= hwr328UTransmitCTSStatus; + if (state.CTS_DELTA) uTransmit |= hwr328UTransmitCTSDelta; + + uTransmit |= (state.TX_DATA) & hwr328UTransmitData; + + // Misc register bits + // These are all values the user sets; we just look at them. + +// if (state.BAUD_TEST) uMisc |= hwrEZ328UMiscBaudTest; // 68EZ328 only + if (state.CLK_SRC) uMisc |= hwr328UMiscClkSrcGPIO; + if (state.FORCE_PERR) uMisc |= hwr328UMiscForceParityErr; + if (state.LOOP) uMisc |= hwr328UMiscLoopback; +// if (state.BAUD_RESET) uMisc |= hwrEZ328UMiscBaudReset; // 68EZ328 only +// if (state.IR_TEST) uMisc |= hwrEZ328UMiscIRTestEn; // 68EZ328 only + if (state.RTS_CONT) uMisc |= hwr328UMiscRTSThruFIFO; + if (state.RTS) uMisc |= hwr328UMiscRTSOut; + if (state.IRDA_ENABLE) uMisc |= hwr328UMiscIRDAEn; + if (state.IRDA_LOOP) uMisc |= hwr328UMiscLoopIRDA; +// if (state.RX_POL) uMisc |= hwrEZ328UMiscRXPolarityInv; // 68EZ328 only +// if (state.TX_POL) uMisc |= hwrEZ328UMiscTXPolarityInv; // 68EZ328 only + + WRITE_REGISTER (uControl, uControl); + WRITE_REGISTER (uBaud, uBaud); + WRITE_REGISTER (uReceive, uReceive); + WRITE_REGISTER (uTransmit, uTransmit); + WRITE_REGISTER (uMisc, uMisc); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::GetPort +// --------------------------------------------------------------------------- +// Given an address, return a value indicating what port it is associated with. + +int EmRegs328::GetPort (emuptr address) +{ + const long MASK = 0x00000FF8; + + switch (address & MASK) + { + case 0x0400: return 'A'; + case 0x0408: return 'B'; + case 0x0410: return 'C'; + case 0x0418: return 'D'; + case 0x0420: return 'E'; + case 0x0428: return 'F'; + case 0x0430: return 'G'; + case 0x0438: return 'J'; + case 0x0440: return 'K'; + case 0x0448: return 'M'; + } + + EmAssert (false); + return 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328::PrvGetPalette +// --------------------------------------------------------------------------- + +void EmRegs328::PrvGetPalette (RGBList& thePalette) +{ + // !!! TBD + Preference<RGBType> pref1 (kPrefKeyBackgroundColor); + Preference<RGBType> pref2 (kPrefKeyHighlightColor); + + RGBType foreground (0, 0, 0); + RGBType background; + + if (this->GetLCDBacklightOn ()) + { + if (pref2.Loaded ()) + background = *pref2; + else + background = ::SkinGetHighlightColor (); + } + else + { + if (pref1.Loaded ()) + background = *pref1; + else + background = ::SkinGetBackgroundColor (); + } + + long br = ((long) background.fRed); + long bg = ((long) background.fGreen); + long bb = ((long) background.fBlue); + + long dr = ((long) foreground.fRed) - ((long) background.fRed); + long dg = ((long) foreground.fGreen) - ((long) background.fGreen); + long db = ((long) foreground.fBlue) - ((long) background.fBlue); + + int32 bpp = 1 << (READ_REGISTER (lcdPanelControl) & 0x01); + int32 numColors = 1 << bpp; + thePalette.resize (numColors); + + for (int color = 0; color < numColors; ++color) + { + thePalette[color].fRed = (UInt8) (br + dr * color / (numColors - 1)); + thePalette[color].fGreen = (UInt8) (bg + dg * color / (numColors - 1)); + thePalette[color].fBlue = (UInt8) (bb + db * color / (numColors - 1)); + } +} + + diff --git a/SrcShared/Hardware/EmRegs328.h b/SrcShared/Hardware/EmRegs328.h new file mode 100644 index 0000000..2ea7011 --- /dev/null +++ b/SrcShared/Hardware/EmRegs328.h @@ -0,0 +1,146 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegs328_h +#define EmRegs328_h + +#include "EmHAL.h" // EmHALHandler +#include "EmRegs.h" // EmRegs +#include "EmStructs.h" // RGBList +#include "EmUARTDragonball.h" // EmUARTDragonball::State + +class EmScreenUpdateInfo; + + +class EmRegs328 : public EmRegs, public EmHALHandler +{ + public: + EmRegs328 (void); + virtual ~EmRegs328 (void); + + // EmRegs overrides + virtual void Initialize (void); + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + virtual void Dispose (void); + + virtual void SetSubBankHandlers (void); + virtual uint8* GetRealAddress (emuptr address); + virtual emuptr GetAddressStart (void); + virtual uint32 GetAddressRange (void); + + // EmHALHandler overrides + virtual void Cycle (Bool sleeping); + virtual void CycleSlowly (Bool sleeping); + + virtual void ButtonEvent (SkinElementType, Bool buttonIsDown); + virtual void TurnSoundOff (void); + virtual void ResetTimer (void); + virtual void ResetRTC (void); + + virtual int32 GetInterruptLevel (void); + virtual int32 GetInterruptBase (void); + + virtual Bool GetLCDScreenOn (void) = 0; + virtual Bool GetLCDBacklightOn (void) = 0; + virtual Bool GetLCDHasFrame (void); + virtual void GetLCDBeginEnd (emuptr&, emuptr&); + virtual void GetLCDScanlines (EmScreenUpdateInfo& info); + + virtual EmUARTDeviceType GetUARTDevice (int uartNum); + virtual int32 GetDynamicHeapSize (void); + virtual int32 GetROMSize (void); + virtual emuptr GetROMBaseAddress (void); + virtual Bool ChipSelectsConfigured (void); + virtual int32 GetSystemClockFrequency (void); + virtual Bool GetCanStop (void); + virtual Bool GetAsleep (void); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void PortDataChanged (int, uint8, uint8); + + private: + uint32 pllFreqSelRead (emuptr address, int size); + uint32 portXDataRead (emuptr address, int size); + uint32 tmr1StatusRead (emuptr address, int size); + uint32 tmr2StatusRead (emuptr address, int size); + uint32 uartRead (emuptr address, int size); + uint32 rtcHourMinSecRead (emuptr address, int size); + + void csASelect1Write (emuptr address, int size, uint32 value); + void csCSelect0Write (emuptr address, int size, uint32 value); + void csCSelect1Write (emuptr address, int size, uint32 value); + void intMaskHiWrite (emuptr address, int size, uint32 value); + void intMaskLoWrite (emuptr address, int size, uint32 value); + void intStatusHiWrite (emuptr address, int size, uint32 value); + void portXDataWrite (emuptr address, int size, uint32 value); + void portDIntReqEnWrite (emuptr address, int size, uint32 value); + void tmr1StatusWrite (emuptr address, int size, uint32 value); + void tmr2StatusWrite (emuptr address, int size, uint32 value); + void wdCounterWrite (emuptr address, int size, uint32 value); + void spiMasterControlWrite (emuptr address, int size, uint32 value); + void uartWrite (emuptr address, int size, uint32 value); + void lcdRegisterWrite (emuptr address, int size, uint32 value); + void rtcControlWrite (emuptr address, int size, uint32 value); + void rtcIntStatusWrite (emuptr address, int size, uint32 value); + void rtcIntEnableWrite (emuptr address, int size, uint32 value); + + protected: + void HotSyncEvent (Bool buttonIsDown); + + virtual uint8 GetKeyBits (void); + virtual uint16 ButtonToBits (SkinElementType); + + protected: + void UpdateInterrupts (void); + void UpdatePortDInterrupts (void); + void UpdateRTCInterrupts (void); + + protected: + Bool IDDetectAsserted (void); + UInt8 GetHardwareID (void); + + protected: + void UARTStateChanged (Bool sendTxData); + void UpdateUARTState (Bool refreshRxData); + void UpdateUARTInterrupts (const EmUARTDragonball::State& state); + void MarshalUARTState (EmUARTDragonball::State& state); + void UnmarshalUARTState (const EmUARTDragonball::State& state); + + protected: + int GetPort (emuptr address); + void PrvGetPalette (RGBList& thePalette); + + protected: + HwrM68328Type f68328Regs; + bool fHotSyncButtonDown; + uint32 fTmr2CurrentMilliseconds; + uint32 fTmr2StartMilliseconds; + uint16 fKeyBits; + uint16 fLastTmr1Status; + uint16 fLastTmr2Status; + uint8 fPortDEdge; + uint32 fPortDDataCount; + + uint32 fHour; + uint32 fMin; + uint32 fSec; + uint32 fTick; + uint32 fCycle; + + EmUARTDragonball* fUART; +}; + +#endif /* EmRegs328_h */ diff --git a/SrcShared/Hardware/EmRegs328PalmIII.h b/SrcShared/Hardware/EmRegs328PalmIII.h new file mode 100644 index 0000000..67e39b0 --- /dev/null +++ b/SrcShared/Hardware/EmRegs328PalmIII.h @@ -0,0 +1,21 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegs328PalmIII_h +#define EmRegs328PalmIII_h + +#include "EmRegs328PalmPilot.h" // EmRegs328PalmPilot + +typedef EmRegs328PalmPilot EmRegs328PalmIII; + +#endif /* EmRegs328PalmIII_h */ diff --git a/SrcShared/Hardware/EmRegs328PalmPilot.cpp b/SrcShared/Hardware/EmRegs328PalmPilot.cpp new file mode 100644 index 0000000..25ce276 --- /dev/null +++ b/SrcShared/Hardware/EmRegs328PalmPilot.cpp @@ -0,0 +1,82 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegs328PalmPilot.h" +#include "EmRegs328Prv.h" + +#include "PalmPack.h" +#define NON_PORTABLE + #include "328Jerry/IncsPrv/HardwareTD1.h" // hwrTD1PortFLCDEnableOn, etc. +#undef NON_PORTABLE +#include "PalmPackPop.h" + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328PalmPilot::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegs328PalmPilot::GetLCDScreenOn (void) +{ + return (READ_REGISTER (portFData) & hwrTD1PortFLCDEnableOn) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328PalmPilot::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegs328PalmPilot::GetLCDBacklightOn (void) +{ + return (READ_REGISTER (portGData) & hwrTD1PortGBacklightOn) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328PalmPilot::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmRegs328PalmPilot::GetLineDriverState (EmUARTDeviceType type) +{ + if (type == kUARTSerial) + return (READ_REGISTER (portGData) & hwrTD1PortGSerialOn) != 0; + + if (type == kUARTIR) + return (READ_REGISTER (portJData) & hwrTD1PortJIrOn) == 0; + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328PalmPilot::GetPortInputValue +// --------------------------------------------------------------------------- +// Return the GPIO values for the pins on the port. These values are used +// if the select pins are high. + +uint8 EmRegs328PalmPilot::GetPortInputValue (int port) +{ + uint8 result = EmRegs328::GetPortInputValue (port); + + if (port == 'M') + { + // Ensure that bit hwrTD1PortMDockIn is set. If it's clear, HotSync + // will sync via the modem instead of the serial port. + + result |= hwrTD1PortMDockIn; + } + + return result; +} diff --git a/SrcShared/Hardware/EmRegs328PalmPilot.h b/SrcShared/Hardware/EmRegs328PalmPilot.h new file mode 100644 index 0000000..00d2e75 --- /dev/null +++ b/SrcShared/Hardware/EmRegs328PalmPilot.h @@ -0,0 +1,30 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegs328PalmPilot_h +#define EmRegs328PalmPilot_h + +#include "EmRegs328.h" // EmRegs328 + + +class EmRegs328PalmPilot : public EmRegs328 +{ + public: + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLineDriverState (EmUARTDeviceType); + + virtual uint8 GetPortInputValue (int); +}; + +#endif /* EmRegs328PalmPilot_h */ diff --git a/SrcShared/Hardware/EmRegs328PalmVII.h b/SrcShared/Hardware/EmRegs328PalmVII.h new file mode 100644 index 0000000..4763967 --- /dev/null +++ b/SrcShared/Hardware/EmRegs328PalmVII.h @@ -0,0 +1,21 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegs328PalmVII_h +#define EmRegs328PalmVII_h + +#include "EmRegs328PalmPilot.h" // EmRegs328PalmPilot + +typedef EmRegs328PalmPilot EmRegs328PalmVII; + +#endif /* EmRegs328PalmVII_h */ diff --git a/SrcShared/Hardware/EmRegs328Pilot.h b/SrcShared/Hardware/EmRegs328Pilot.h new file mode 100644 index 0000000..d380978 --- /dev/null +++ b/SrcShared/Hardware/EmRegs328Pilot.h @@ -0,0 +1,21 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegs328Pilot_h +#define EmRegs328Pilot_h + +#include "EmRegs328PalmPilot.h" // EmRegs328PalmPilot + +typedef EmRegs328PalmPilot EmRegs328Pilot; + +#endif /* EmRegs328Pilot_h */ diff --git a/SrcShared/Hardware/EmRegs328Prv.h b/SrcShared/Hardware/EmRegs328Prv.h new file mode 100644 index 0000000..8b09f33 --- /dev/null +++ b/SrcShared/Hardware/EmRegs328Prv.h @@ -0,0 +1,45 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegs328Prv_h +#define EmRegs328Prv_h + +#include "EmRegsPrv.h" + +// Location and range of registers + +const uint32 kMemoryStart = 0xFFFFF000; +const uint32 kMemorySize = sizeof (HwrM68328Type); + + +// Macro to return the Dragonball address of the specified register + +#define addressof(x) (kMemoryStart + offsetof(HwrM68328Type, x)) + + +// Macros for reading/writing Dragonball registers. + +#define READ_REGISTER(reg) \ + _get_reg (&f68328Regs.reg) + +#define WRITE_REGISTER(reg, value) \ + _put_reg (&f68328Regs.reg, value) + + +// Macro for installing Dragonball register handlers + +#define INSTALL_HANDLER(read, write, reg) \ + this->SetHandler ((ReadFunction) &EmRegs328::read, (WriteFunction) &EmRegs328::write, addressof (reg), sizeof (f68328Regs.reg)) + + +#endif /* EmRegs328Prv_h */ diff --git a/SrcShared/Hardware/EmRegs328Symbol1700.cpp b/SrcShared/Hardware/EmRegs328Symbol1700.cpp new file mode 100644 index 0000000..0b5a305 --- /dev/null +++ b/SrcShared/Hardware/EmRegs328Symbol1700.cpp @@ -0,0 +1,121 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegs328Symbol1700.h" +#include "EmRegs328Prv.h" + +#define keyBitTrigLeft 0x0400 +#define keyBitTrigCenter 0x0800 +#define keyBitTrigRight 0x1000 +#define keyBitPageUpLeft keyBitPageUp +#define keyBitPageUpRight keyBitPageDown +#define keyBitPageDownLeft 0x2000 +#define keyBitPageDownRight 0x4000 + + +#define keyBitMask 0x0F // Which bits in port D we use for keys + +#define portDKbdCols 0xF0 +#define portDKbdRows 0x0F + +#define portDKbdCol0 0x10 +#define portDKbdCol1 0x20 +#define portDKbdCol2 0x40 +#define portDKbdCol3 0x80 + +#define portDKbdRow0 0x01 +#define portDKbdRow1 0x02 +#define portDKbdRow2 0x04 +#define portDKbdRow3 0x08 + + +const int kNumButtonRows = 4; +const int kNumButtonCols = 4; + +const uint16 kButtonMap[kNumButtonRows][kNumButtonCols] = +{ + { keyBitPower, keyBitTrigLeft, keyBitTrigCenter, keyBitTrigRight }, + { keyBitHard1, keyBitHard2, keyBitHard3, keyBitHard4 }, + { keyBitPageUpLeft, keyBitPageUpRight, keyBitPageDownLeft, keyBitPageDownRight }, + { keyBitContrast, 0, 0, 0 } +}; + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328Symbol1700::GetKeyBits +// --------------------------------------------------------------------------- + +uint8 EmRegs328Symbol1700::GetKeyBits (void) +{ + uint8 portDData = READ_REGISTER (portDData); + + Bool cols[4]; + cols[0] = (portDData & portDKbdCol0) == 0; + cols[1] = (portDData & portDKbdCol1) == 0; + cols[2] = (portDData & portDKbdCol2) == 0; + cols[3] = (portDData & portDKbdCol3) == 0; + + uint8 keyData = 0; + + // Walk the columns, looking for one that is requested. + + for (int col = 0; col < kNumButtonCols; ++col) + { + if (cols[col]) + { + // Walk the rows. + + for (int row = 0; row < kNumButtonRows; ++row) + { + // Get the key corresponding to this row and column. + // If we've recorded (in fgKeyBits) that this key is + // pressed, then set its row bit. + + if ((fKeyBits & kButtonMap[row][col]) != 0) + { + keyData |= 1 << (col + 4); + keyData |= 1 << row; + } + } + } + } + + return keyData; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs328Symbol1700::ButtonToBits +// --------------------------------------------------------------------------- + +uint16 EmRegs328Symbol1700::ButtonToBits (SkinElementType button) +{ + uint16 bitNumber = 0; + switch (button) + { + default: + bitNumber = EmRegs328PalmPilot::ButtonToBits (button); + break; + + case kElement_TriggerLeft: bitNumber = keyBitTrigLeft; break; + case kElement_TriggerCenter: bitNumber = keyBitTrigCenter; break; + case kElement_TriggerRight: bitNumber = keyBitTrigRight; break; + case kElement_UpButtonLeft: bitNumber = keyBitPageUpLeft; break; + case kElement_UpButtonRight: bitNumber = keyBitPageUpRight; break; + case kElement_DownButtonLeft: bitNumber = keyBitPageDownLeft; break; + case kElement_DownButtonRight: bitNumber = keyBitPageDownRight; break; + } + + return bitNumber; +} diff --git a/SrcShared/Hardware/EmRegs328Symbol1700.h b/SrcShared/Hardware/EmRegs328Symbol1700.h new file mode 100644 index 0000000..8690c80 --- /dev/null +++ b/SrcShared/Hardware/EmRegs328Symbol1700.h @@ -0,0 +1,26 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegs328Symbol1700_h +#define EmRegs328Symbol1700_h + +#include "EmRegs328PalmPilot.h" // EmRegs328PalmPilot + +class EmRegs328Symbol1700 : public EmRegs328PalmPilot +{ + public: + virtual uint8 GetKeyBits (void); + virtual uint16 ButtonToBits (SkinElementType); +}; + +#endif /* EmRegs328Symbol1700_h */ diff --git a/SrcShared/Hardware/EmRegsASICSymbol1700.cpp b/SrcShared/Hardware/EmRegsASICSymbol1700.cpp new file mode 100644 index 0000000..ff2ab2f --- /dev/null +++ b/SrcShared/Hardware/EmRegsASICSymbol1700.cpp @@ -0,0 +1,168 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsASICSymbol1700.h" + +// Given a register (specified by its field name), return its address +// in emulated space. + +#define addressof(reg) \ + (this->GetAddressStart () + fRegs.offsetof_##reg ()) + + +// Macro to help the installation of handlers for a register. + +#define INSTALL_HANDLER(read, write, reg) \ + this->SetHandler ( (ReadFunction) &EmRegsASICSymbol1700::read, \ + (WriteFunction) &EmRegsASICSymbol1700::write, \ + addressof (reg), \ + fRegs.reg.GetSize ()) + + +// --------------------------------------------------------------------------- +// ¥ EmRegsASICSymbol1700::EmRegsASICSymbol1700 +// --------------------------------------------------------------------------- + +EmRegsASICSymbol1700::EmRegsASICSymbol1700 (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsASICSymbol1700::~EmRegsASICSymbol1700 +// --------------------------------------------------------------------------- + +EmRegsASICSymbol1700::~EmRegsASICSymbol1700 (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsASICSymbol1700::Initialize +// --------------------------------------------------------------------------- + +void EmRegsASICSymbol1700::Initialize (void) +{ + EmRegs::Initialize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsASICSymbol1700::Reset +// --------------------------------------------------------------------------- + +void EmRegsASICSymbol1700::Reset (Bool hardwareReset) +{ + EmRegs::Reset (hardwareReset); + + memset (fRegs.GetPtr (), 0, fRegs.GetSize ()); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsASICSymbol1700::Save +// --------------------------------------------------------------------------- + +void EmRegsASICSymbol1700::Save (SessionFile& f) +{ + EmRegs::Save (f); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsASICSymbol1700::Load +// --------------------------------------------------------------------------- + +void EmRegsASICSymbol1700::Load (SessionFile& f) +{ + EmRegs::Load (f); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsASICSymbol1700::Dispose +// --------------------------------------------------------------------------- + +void EmRegsASICSymbol1700::Dispose (void) +{ + EmRegs::Dispose (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsASICSymbol1700::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegsASICSymbol1700::SetSubBankHandlers (void) +{ + // Install base handlers. + + EmRegs::SetSubBankHandlers (); + + // Now add standard/specialized handers for the defined registers. + + // Install the first three by hand instead of using our + // INSTALL_HANDLER macro. That macro doesn't support the + // installation of a field that's an array. + this->SetHandler ( (ReadFunction) &EmRegsASICSymbol1700::StdReadBE, \ + (WriteFunction) &EmRegsASICSymbol1700::StdWriteBE, \ + addressof (S24IO), \ + 64); + this->SetHandler ( (ReadFunction) &EmRegsASICSymbol1700::StdReadBE, \ + (WriteFunction) &EmRegsASICSymbol1700::StdWriteBE, \ + addressof (S24Attribute), \ + 32); + this->SetHandler ( (ReadFunction) &EmRegsASICSymbol1700::StdReadBE, \ + (WriteFunction) &EmRegsASICSymbol1700::StdWriteBE, \ + addressof (UART8251MacroSelect),\ + 4); + +// INSTALL_HANDLER (StdReadBE, StdWriteBE, S24IO); +// INSTALL_HANDLER (StdReadBE, StdWriteBE, S24Attribute); +// INSTALL_HANDLER (StdReadBE, StdWriteBE, UART8251MacroSelect); + INSTALL_HANDLER (StdReadBE, StdWriteBE, ScannerDecoderControl); + INSTALL_HANDLER (StdReadBE, StdWriteBE, Control); + INSTALL_HANDLER (StdReadBE, StdWriteBE, GPIOData); + INSTALL_HANDLER (StdReadBE, StdWriteBE, GPIODirection); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsASICSymbol1700::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmRegsASICSymbol1700::GetRealAddress (emuptr address) +{ + return (uint8*) fRegs.GetPtr () + address - this->GetAddressStart (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsASICSymbol1700::GetAddressStart +// --------------------------------------------------------------------------- + +emuptr EmRegsASICSymbol1700::GetAddressStart (void) +{ + return 0x11000000; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsASICSymbol1700::GetAddressRange +// --------------------------------------------------------------------------- + +uint32 EmRegsASICSymbol1700::GetAddressRange (void) +{ + return fRegs.GetSize (); +} diff --git a/SrcShared/Hardware/EmRegsASICSymbol1700.h b/SrcShared/Hardware/EmRegsASICSymbol1700.h new file mode 100644 index 0000000..6b15d33 --- /dev/null +++ b/SrcShared/Hardware/EmRegsASICSymbol1700.h @@ -0,0 +1,44 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsASICSymbol1700_h +#define EmRegsASICSymbol1700_h + +#include "EmPalmStructs.h" +#include "EmRegs.h" + +class SessionFile; + + +class EmRegsASICSymbol1700 : public EmRegs +{ + public: + EmRegsASICSymbol1700 (void); + virtual ~EmRegsASICSymbol1700 (void); + + virtual void Initialize (void); + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + virtual void Dispose (void); + + virtual void SetSubBankHandlers (void); + virtual uint8* GetRealAddress (emuptr address); + virtual emuptr GetAddressStart (void); + virtual uint32 GetAddressRange (void); + + private: + EmProxyHwrSymbolASICType fRegs; +}; + +#endif /* EmRegsASICSymbol1700_h */ diff --git a/SrcShared/Hardware/EmRegsEZ.cpp b/SrcShared/Hardware/EmRegsEZ.cpp new file mode 100644 index 0000000..f56144d --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZ.cpp @@ -0,0 +1,2655 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsEZ.h" +#include "EmRegsEZPrv.h" + +#include "Byteswapping.h" // Canonical +#include "EmHAL.h" // EmHAL +#include "EmMemory.h" // gMemAccessFlags, EmMem_memcpy +#include "EmPixMap.h" // SetSize, SetRowBytes, etc. +#include "EmScreen.h" // EmScreenUpdateInfo +#include "EmSession.h" // GetDevice +#include "EmSPISlave.h" // DoExchange +#include "Hordes.h" // Hordes::IsOn +#include "Logging.h" // LogAppendMsg +#include "Miscellaneous.h" // GetHostTime +#include "PreferenceMgr.h" // Preference +#include "SessionFile.h" // WriteHwrDBallEZType, etc. +#include "UAE.h" // regs, SPCFLAG_INT + +#include "PalmPack.h" +#define NON_PORTABLE + #include "HwrMiscFlags.h" // hwrMiscFlagID1 + + #define hwrEZ328maskID1J83G 0x05 + + // Some platform-specific -- yet fairly portable -- defines. + #define hwrEZPortGIDDetect 0x04 // (L) ID select (drives kbd) + #define hwrEZPortDKbdCol0 0x01 // (H) Keyboard Column 0 (aka INT0) + #define hwrEZPortDKbdCol1 0x02 // (H) Keyboard Column 1 (aka INT1) + #define hwrEZPortDKbdCol2 0x04 // (H) Keyboard Column 2 (aka INT2) + #define hwrEZPortDKbdCol3 0x08 // (H) Keyboard Column 3 (aka INT3) + #define hwrEZPortDKeyBits 0x0F // (H) All Keyboard Columns + +#undef NON_PORTABLE +#include "PalmPackPop.h" + +static const uint16 UPSIZ = 0x1800; // Mask to get the unprotected memory size from csDSelect. +static const uint16 SIZ = 0x000E; // Mask to get the memory size from csASelect. +static const uint16 EN = 0x0001; // Mask to get the enable bit from csASelect. + +static const uint16 gBaseAddressShift = 13; // Shift to get base address from CSGBx register value + +#define PRINTF if (1) ; else LogAppendMsg + +// Values used to initialize the DragonBallEZ registers. + +static const HwrM68EZ328Type kInitial68EZ328RegisterValues = +{ + 0x1C, // Byte scr; // $000: System Control Register + { 0 }, // Byte ___filler0[0x004-0x001]; + hwrEZ328chipIDEZ, // Byte chipID; // $004: Chip ID Register + hwrEZ328maskID1J83G, // Byte maskID; // $005: Mask ID Register + 0x00, // Word swID; // $006: Software ID Register + { 0 }, // Byte ___filler1[0x100-0x008]; + + 0x0000, // Word csAGroupBase; // $100: Chip Select Group A Base Register + 0x0000, // Word csBGroupBase; // $102: Chip Select Group B Base Register + 0x0000, // Word csCGroupBase; // $104: Chip Select Group C Base Register + 0x0000, // Word csDGroupBase; // $106: Chip Select Group D Base Register + + { 0 }, // Byte ___filler6[0x110-0x108]; + + 0x00E0, // Word csASelect; // $110: Group A Chip Select Register + 0x0000, // Word csBSelect; // $112: Group B Chip Select Register + 0x0000, // Word csCSelect; // $114: Group C Chip Select Register + 0x0000, // Word csDSelect; // $116: Group D Chip Select Register + + 0x0060, // Word emuCS; // $118: EMU Chip Select Register + + { 0 }, // Byte ___filler2[0x200-0x11A]; + + 0x2430, // Word pllControl; // $200: PLL Control Register + 0x0123, // Word pllFreqSel; // $202: PLL Frequency Select Register + 0, // !!! ---> Marked as reserved in 1.4 Word pllTest; // $204: PLL Test Register (do not access) + { 0 }, // Byte ___filler44; + 0x1F, // Byte pwrControl; // $207: Power Control Register + + { 0 }, // Byte ___filler3[0x300-0x208]; + + 0x00, // Byte intVector; // $300: Interrupt Vector Register + { 0 }, // Byte ___filler4; + 0x0000, // Word intControl; // $302: Interrupt Control Register + 0x00FF, // Word intMaskHi; // $304: Interrupt Mask Register/HIGH word + 0xFFFF, // Word intMaskLo; // $306: Interrupt Mask Register/LOW word + { 0 }, // Byte ___filler7[0x30c-0x308]; + 0x0000, // Word intStatusHi; // $30C: Interrupt Status Register/HIGH word + 0x0000, // Word intStatusLo; // $30E: Interrupt Status Register/LOW word + 0x0000, // Word intPendingHi; // $310: Interrupt Pending Register + 0x0000, // Word intPendingLo; // $312: Interrupt Pending Register + + { 0 }, // Byte ___filler4a[0x400-0x314]; + + 0x00, // Byte portADir; // $400: Port A Direction Register + 0x00, // Byte portAData; // $401: Port A Data Register + 0xFF, // Byte portAPullupEn; // $402: Port A Pullup Enable (similar to Select on DB) + { 0 }, // Byte ___filler8[5]; + + 0x00, // Byte portBDir; // $408: Port B Direction Register + 0x00, // Byte portBData; // $409: Port B Data Register + 0xFF, // Byte portBPullupEn; // $40A: Port B Pullup Enable + 0xFF, // Byte portBSelect; // $40B: Port B Select Register + + { 0 }, // Byte ___filler9[4]; + + 0x00, // Byte portCDir; // $410: Port C Direction Register + 0x00, // Byte portCData; // $411: Port C Data Register + 0xFF, // Byte portCPulldnEn; // $412: Port C Pulldown Enable + 0xFF, // Byte portCSelect; // $413: Port C Select Register + + { 0 }, // Byte ___filler10[4]; + + 0x00, // Byte portDDir; // $418: Port D Direction Register + 0x00, // Byte portDData; // $419: Port D Data Register + 0xFF, // Byte portDPullupEn; // $41A: Port D Pull-up Enable + 0xF0, // Byte portDSelect; // $41B: Port D Select Register + 0x00, // Byte portDPolarity; // $41C: Port D Polarity Register + 0x00, // Byte portDIntReqEn; // $41D: Port D Interrupt Request Enable + 0x00, // Byte portDKbdIntEn; // $41E: Port D Keyboard Interrupt Enable + 0x00, // Byte portDIntEdge; // $41F: Port D IRQ Edge Register + + 0x00, // Byte portEDir; // $420: Port E Direction Register + 0x00, // Byte portEData; // $421: Port E Data Register + 0xFF, // Byte portEPullupEn; // $422: Port E Pull-up Enable + 0xFF, // Byte portESelect; // $423: Port E Select Register + + { 0 }, // Byte ___filler14[4]; + + 0x00, // Byte portFDir; // $428: Port F Direction Register + 0x00, // Byte portFData; // $429: Port F Data Register + 0xFF, // Byte portFPullupdnEn; // $42A: Port F Pull-up/down Enable + 0x00, // Byte portFSelect; // $42B: Port F Select Register + + { 0 }, // Byte ___filler16[4]; + + 0x00, // Byte portGDir; // $430: Port G Direction Register + 0x00, // Byte portGData; // $431: Port G Data Register + 0x3D, // Byte portGPullupEn; // $432: Port G Pull-up Enable + 0x08, // Byte portGSelect; // $433: Port G Select Register + + { 0 }, // Byte ___filler2000[0x500-0x434]; + + 0x0020, // Word pwmControl; // $500: PWM Control Register + 0x00, // Byte pwmSampleHi; // $502: PWM Sample - high byte + 0x00, // Byte pwmSampleLo; // $503: PWM Sample - low byte + 0xFE, // Byte pwmPeriod; // $504: PWM Period + 0x00, // Byte pwmCounter; // $505: PWM Counter + + { 0 }, // Byte ___filler24[0x600-0x506]; + + 0x0000, // Word tmr1Control; // $600: Timer 1 Control Register + 0x0000, // Word tmr1Prescaler; // $602: Timer 1 Prescaler Register + 0xFFFF, // Word tmr1Compare; // $604: Timer 1 Compare Register + 0x0000, // Word tmr1Capture; // $606: Timer 1 Capture Register + 0x0000, // Word tmr1Counter; // $608: Timer 1 Counter Register + 0x0000, // Word tmr1Status; // $60A: Timer 1 Status Register + + { 0 }, // Byte ___filler25[0x800-0x61E]; + + 0x0000, // Word spiMasterData; // $800: SPI Master Data Register + 0x0000, // Word spiMasterControl; // $802: SPI Master Control Register + + { 0 }, // Byte ___filler27[0x900-0x804]; + + 0x0000, // Word uControl; // $900: Uart Control Register + 0x003F, // Word uBaud; // $902: Uart Baud Control Register + 0x0000, // Word uReceive; // $904: Uart Receive Register + 0x0000, // Word uTransmit; // $906: Uart Transmit Register + 0x0000, // Word uMisc; // $908: Uart Miscellaneous Register + 0x0000, // Word uNonIntPresc; // $90A: Uart IRDA Non-Integer Prescaler + + { 0 }, // Byte ___filler28[0xA00-0x90C]; + + 0x00000000, // DWord lcdStartAddr; // $A00: Screen Starting Address Register + { 0 }, // Byte ___filler29; + 0xFF, // Byte lcdPageWidth; // $A05: Virtual Page Width Register + { 0 }, // Byte ___filler30[2]; + 0x03FF, // Word lcdScreenWidth; // $A08: Screen Width Register + 0x01FF, // Word lcdScreenHeight; // $A0A: Screen Height Register + { 0 }, // Byte ___filler31[0xA18-0xA0C]; + 0x0000, // Word lcdCursorXPos; // $A18: Cursor X Position + 0x0000, // Word lcdCursorYPos; // $A1A: Cursor Y Position + 0x0101, // Word lcdCursorWidthHeight; // $A1C: Cursor Width and Height + { 0 }, // Byte ___filler32; + 0x7F, // Byte lcdBlinkControl; // $A1F: Blink Control Register + 0x00, // Byte lcdPanelControl; // $A20: Panel Interface Control Register + 0x00, // Byte lcdPolarity; // $A21: Polarity Config Register + { 0 }, // Byte ___filler33; + 0x00, // Byte lcdACDRate; // $A23: ACD (M) Rate Control Register + { 0 }, // Byte ___filler34; + 0x00, // Byte lcdPixelClock; // $A25: Pixel Clock Divider Register + { 0 }, // Byte ___filler35; + 0x40, // Byte lcdClockControl; // $A27: Clocking Control Register + { 0 }, // Byte ___filler36; + 0xFF, // Byte lcdRefreshRateAdj; // $A29: Refresh Rate Adjustment Register + { 0 }, // Byte ___filler2003[0xA2D-0xA2A]; + 0x00, // Byte lcdPanningOffset; // $A2D: Panning Offset Register + + { 0 }, // Byte ___filler37[0xA31-0xA2E]; + + 0xB9, // Byte lcdFrameRate; // $A31: Frame Rate Control Modulation Register + { 0 }, // Byte ___filler2004; + 0x84, // Byte lcdGrayPalette; // $A33: Gray Palette Mapping Register + 0x00, // Byte lcdReserved; // $A34: Reserved + { 0 }, // Byte ___filler2005; + 0x0000, // Word lcdContrastControlPWM; // $A36: Contrast Control + + { 0 }, // Byte ___filler40[0xB00-0xA38]; + + 0x00000000, // DWord rtcHourMinSec; // $B00: RTC Hours, Minutes, Seconds Register + 0x00000000, // DWord rtcAlarm; // $B04: RTC Alarm Register + { 0 }, // Byte ___filler2001[0xB0A-0xB08]; + 0x0001, // Word rtcWatchDog; // $B0A: RTC Watchdog Timer + 0x00, // Word rtcControl; // $B0C: RTC Control Register + 0x00, // Word rtcIntStatus; // $B0E: RTC Interrupt Status Register + 0x00, // Word rtcIntEnable; // $B10: RTC Interrupt Enable Register + 0x00, // Word stopWatch; // $B12: Stopwatch Minutes + { 0 }, // Byte ___filler2002[0xB1A-0xB14]; + 0x0000, // Word rtcDay; // $B1A: RTC Day + 0x0000, // Word rtcDayAlarm; // $B1C: RTC Day Alarm + + { 0 }, // Byte ___filler41[0xC00-0xB1E]; + + 0x0000, // Word dramConfig; // $C00: DRAM Memory Config Register + 0x0000, // Word dramControl; // $C02: DRAM Control Register + + { 0 }, // Byte ___filler42[0xD00-0xC04]; + + 0x00000000, // DWord emuAddrCompare; // $D00: Emulation Address Compare Register + 0x00000000, // DWord emuAddrMask; // $D04: Emulation Address Mask Register + 0x0000, // Word emuControlCompare; // $D08: Emulation Control Compare Register + 0x0000, // Word emuControlMask; // $D0A: Emulation Control Mask Register + 0x0000, // Word emuControl; // $DOC: Emulation Control Register + 0x0000 // Word emuStatus; // $D0E: Emulation Status Register +}; + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::EmRegsEZ +// --------------------------------------------------------------------------- + +EmRegsEZ::EmRegsEZ (void) : + EmRegs (), + f68EZ328Regs (), + fHotSyncButtonDown (0), + fKeyBits (0), + fLastTmr1Status (0), + fPortDEdge (0), + fPortDDataCount (0), + fHour (0), + fMin (0), + fSec (0), + fTick (0), + fCycle (0), + fUART (NULL) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::~EmRegsEZ +// --------------------------------------------------------------------------- + +EmRegsEZ::~EmRegsEZ (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::Initialize +// --------------------------------------------------------------------------- + +void EmRegsEZ::Initialize (void) +{ + EmRegs::Initialize (); + + fUART = new EmUARTDragonball (EmUARTDragonball::kUART_DragonballEZ, 0); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::Reset +// --------------------------------------------------------------------------- + +void EmRegsEZ::Reset (Bool hardwareReset) +{ + EmRegs::Reset (hardwareReset); + + if (hardwareReset) + { + f68EZ328Regs = kInitial68EZ328RegisterValues; + + // Byteswap all the words in the DragonballEZ registers (if necessary). + + Canonical (f68EZ328Regs); + ByteswapWords (&f68EZ328Regs, sizeof(f68EZ328Regs)); + + fKeyBits = 0; + fLastTmr1Status = 0; + fPortDEdge = 0; + fPortDDataCount = 0; + + // React to the new data in the UART registers. + + Bool sendTxData = false; + EmRegsEZ::UARTStateChanged (sendTxData); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::Save +// --------------------------------------------------------------------------- + +void EmRegsEZ::Save (SessionFile& f) +{ + EmRegs::Save (f); + + StWordSwapper swapper1 (&f68EZ328Regs, sizeof(f68EZ328Regs)); +// StCanonical<HwrM68EZ328Type> swapper2 (f68EZ328Regs); + f.WriteHwrDBallEZType (f68EZ328Regs); + f.FixBug (SessionFile::kBugByteswappedStructs); + + const long kCurrentVersion = 3; + + Chunk chunk; + EmStreamChunk s (chunk); + + s << kCurrentVersion; + + s << fHotSyncButtonDown; + s << fKeyBits; + s << fLastTmr1Status; + s << fPortDEdge; + + + // Added in version 2. + + s << fHour; + s << fMin; + s << fSec; + s << fTick; + s << fCycle; + + // Added in version 3. + + s << fPortDDataCount; + + f.WriteDBallEZState (chunk); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::Load +// --------------------------------------------------------------------------- + +void EmRegsEZ::Load (SessionFile& f) +{ + EmRegs::Load (f); + + if (f.ReadHwrDBallEZType (f68EZ328Regs)) + { + // The Windows version of Poser 2.1d29 and earlier did not write + // out structs in the correct format. The fields of the struct + // were written out in Little-Endian format, not Big-Endian. To + // address this problem, the bug has been fixed, and a new field + // is added to the file format indicating that the bug has been + // fixed. With the new field (the "bug bit"), Poser can identify + // old files from new files and read them in accordingly. + // + // With the bug fixed, the .psf files should now be interchangeable + // across platforms (modulo other bugs...). + + if (!f.IncludesBugFix (SessionFile::kBugByteswappedStructs)) + { + Canonical (f68EZ328Regs); + } + ByteswapWords (&f68EZ328Regs, sizeof(f68EZ328Regs)); + + // React to the new data in the UART registers. + + Bool sendTxData = false; + EmRegsEZ::UARTStateChanged (sendTxData); + + // Reset gMemAccessFlags.fProtect_SRAMSet + + gMemAccessFlags.fProtect_SRAMSet = (READ_REGISTER (csDSelect) & 0x2000) != 0; + } + else + { + f.SetCanReload (false); + } + + Chunk chunk; + if (f.ReadDBallEZState (chunk)) + { + long version; + EmStreamChunk s (chunk); + + s >> version; + + if (version >= 1) + { + s >> fHotSyncButtonDown; + s >> fKeyBits; + s >> fLastTmr1Status; + s >> fPortDEdge; + } + + if (version >= 2) + { + s >> fHour; + s >> fMin; + s >> fSec; + s >> fTick; + s >> fCycle; + } + + if (version >= 3) + { + s >> fPortDDataCount; + } + } + else + { + f.SetCanReload (false); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::Dispose +// --------------------------------------------------------------------------- + +void EmRegsEZ::Dispose (void) +{ + delete fUART; + fUART = NULL; + + EmRegs::Dispose (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegsEZ::SetSubBankHandlers (void) +{ + // Install base handlers. + + EmRegs::SetSubBankHandlers (); + + // Now add standard/specialized handers for the defined registers. + + INSTALL_HANDLER (StdRead, StdWrite, scr); + + INSTALL_HANDLER (StdRead, NullWrite, chipID); + INSTALL_HANDLER (StdRead, NullWrite, maskID); + INSTALL_HANDLER (StdRead, NullWrite, swID); + + INSTALL_HANDLER (StdRead, StdWrite, csAGroupBase); + INSTALL_HANDLER (StdRead, StdWrite, csBGroupBase); + INSTALL_HANDLER (StdRead, StdWrite, csCGroupBase); + INSTALL_HANDLER (StdRead, StdWrite, csDGroupBase); + + INSTALL_HANDLER (StdRead, csASelectWrite, csASelect); + INSTALL_HANDLER (StdRead, StdWrite, csBSelect); + INSTALL_HANDLER (StdRead, StdWrite, csCSelect); + INSTALL_HANDLER (StdRead, csDSelectWrite, csDSelect); + + INSTALL_HANDLER (StdRead, StdWrite, emuCS); + + INSTALL_HANDLER (StdRead, StdWrite, pllControl); + INSTALL_HANDLER (pllFreqSelRead, StdWrite, pllFreqSel); + INSTALL_HANDLER (StdRead, StdWrite, pllTest); + INSTALL_HANDLER (StdRead, StdWrite, pwrControl); + + INSTALL_HANDLER (StdRead, StdWrite, intVector); + INSTALL_HANDLER (StdRead, StdWrite, intControl); + INSTALL_HANDLER (StdRead, intMaskHiWrite, intMaskHi); + INSTALL_HANDLER (StdRead, intMaskLoWrite, intMaskLo); + INSTALL_HANDLER (StdRead, intStatusHiWrite, intStatusHi); + INSTALL_HANDLER (StdRead, NullWrite, intStatusLo); + INSTALL_HANDLER (StdRead, NullWrite, intPendingHi); + INSTALL_HANDLER (StdRead, NullWrite, intPendingLo); + + INSTALL_HANDLER (StdRead, StdWrite, portADir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portAData); + INSTALL_HANDLER (StdRead, StdWrite, portAPullupEn); + + INSTALL_HANDLER (StdRead, StdWrite, portBDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portBData); + INSTALL_HANDLER (StdRead, StdWrite, portBPullupEn); + INSTALL_HANDLER (StdRead, StdWrite, portBSelect); + + INSTALL_HANDLER (StdRead, StdWrite, portCDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portCData); + INSTALL_HANDLER (StdRead, StdWrite, portCPulldnEn); + INSTALL_HANDLER (StdRead, StdWrite, portCSelect); + + INSTALL_HANDLER (StdRead, StdWrite, portDDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portDData); + INSTALL_HANDLER (StdRead, StdWrite, portDPullupEn); + INSTALL_HANDLER (StdRead, StdWrite, portDSelect); + INSTALL_HANDLER (StdRead, StdWrite, portDPolarity); + INSTALL_HANDLER (StdRead, portDIntReqEnWrite, portDIntReqEn); + INSTALL_HANDLER (StdRead, StdWrite, portDKbdIntEn); + INSTALL_HANDLER (StdRead, StdWrite, portDIntEdge); + + INSTALL_HANDLER (StdRead, StdWrite, portEDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portEData); + INSTALL_HANDLER (StdRead, StdWrite, portEPullupEn); + INSTALL_HANDLER (StdRead, StdWrite, portESelect); + + INSTALL_HANDLER (StdRead, StdWrite, portFDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portFData); + INSTALL_HANDLER (StdRead, StdWrite, portFPullupdnEn); + INSTALL_HANDLER (StdRead, StdWrite, portFSelect); + + INSTALL_HANDLER (StdRead, StdWrite, portGDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portGData); + INSTALL_HANDLER (StdRead, StdWrite, portGPullupEn); + INSTALL_HANDLER (StdRead, StdWrite, portGSelect); + + INSTALL_HANDLER (StdRead, StdWrite, pwmControl); + INSTALL_HANDLER (StdRead, StdWrite, pwmSampleHi); + INSTALL_HANDLER (StdRead, StdWrite, pwmSampleLo); + INSTALL_HANDLER (StdRead, StdWrite, pwmPeriod); + INSTALL_HANDLER (StdRead, NullWrite, pwmCounter); + + INSTALL_HANDLER (StdRead, StdWrite, tmr1Control); + INSTALL_HANDLER (StdRead, StdWrite, tmr1Prescaler); + INSTALL_HANDLER (StdRead, StdWrite, tmr1Compare); + INSTALL_HANDLER (StdRead, StdWrite, tmr1Capture); + INSTALL_HANDLER (StdRead, NullWrite, tmr1Counter); + INSTALL_HANDLER (tmr1StatusRead, tmr1StatusWrite, tmr1Status); + + INSTALL_HANDLER (StdRead, StdWrite, spiMasterData); + INSTALL_HANDLER (StdRead, spiMasterControlWrite, spiMasterControl); + + INSTALL_HANDLER (uartRead, uartWrite, uControl); + INSTALL_HANDLER (uartRead, uartWrite, uBaud); + INSTALL_HANDLER (uartRead, uartWrite, uReceive); + INSTALL_HANDLER (uartRead, uartWrite, uTransmit); + INSTALL_HANDLER (uartRead, uartWrite, uMisc); + INSTALL_HANDLER (uartRead, uartWrite, uNonIntPresc); + + INSTALL_HANDLER (StdRead, lcdRegisterWrite, lcdStartAddr); + INSTALL_HANDLER (StdRead, lcdRegisterWrite, lcdPageWidth); + INSTALL_HANDLER (StdRead, lcdRegisterWrite, lcdScreenWidth); + INSTALL_HANDLER (StdRead, lcdRegisterWrite, lcdScreenHeight); + INSTALL_HANDLER (StdRead, StdWrite, lcdCursorXPos); + INSTALL_HANDLER (StdRead, StdWrite, lcdCursorYPos); + INSTALL_HANDLER (StdRead, StdWrite, lcdCursorWidthHeight); + INSTALL_HANDLER (StdRead, StdWrite, lcdBlinkControl); + INSTALL_HANDLER (StdRead, lcdRegisterWrite, lcdPanelControl); + INSTALL_HANDLER (StdRead, StdWrite, lcdPolarity); + INSTALL_HANDLER (StdRead, StdWrite, lcdACDRate); + INSTALL_HANDLER (StdRead, StdWrite, lcdPixelClock); + INSTALL_HANDLER (StdRead, StdWrite, lcdClockControl); + INSTALL_HANDLER (StdRead, StdWrite, lcdRefreshRateAdj); + INSTALL_HANDLER (StdRead, StdWrite, lcdPanningOffset); + INSTALL_HANDLER (StdRead, StdWrite, lcdFrameRate); + INSTALL_HANDLER (StdRead, StdWrite, lcdGrayPalette); + INSTALL_HANDLER (StdRead, StdWrite, lcdContrastControlPWM); + INSTALL_HANDLER (rtcHourMinSecRead, StdWrite, rtcHourMinSec); + + INSTALL_HANDLER (StdRead, StdWrite, rtcAlarm); + INSTALL_HANDLER (StdRead, StdWrite, rtcWatchDog); + INSTALL_HANDLER (StdRead, rtcControlWrite, rtcControl); + INSTALL_HANDLER (StdRead, rtcIntStatusWrite, rtcIntStatus); + INSTALL_HANDLER (StdRead, rtcIntEnableWrite, rtcIntEnable); + INSTALL_HANDLER (StdRead, StdWrite, stopWatch); + INSTALL_HANDLER (StdRead, StdWrite, rtcDay); + INSTALL_HANDLER (StdRead, StdWrite, rtcDayAlarm); + + INSTALL_HANDLER (StdRead, StdWrite, dramConfig); + INSTALL_HANDLER (StdRead, StdWrite, dramControl); + + INSTALL_HANDLER (StdRead, StdWrite, emuAddrCompare); + INSTALL_HANDLER (StdRead, StdWrite, emuAddrMask); + INSTALL_HANDLER (StdRead, StdWrite, emuControlCompare); + INSTALL_HANDLER (StdRead, StdWrite, emuControlMask); + INSTALL_HANDLER (StdRead, StdWrite, emuControl); + INSTALL_HANDLER (StdRead, StdWrite, emuStatus); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmRegsEZ::GetRealAddress (emuptr address) +{ + uint8* loc = ((uint8*) &f68EZ328Regs) + (address - kMemoryStart); + + return loc; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetAddressStart +// --------------------------------------------------------------------------- + +emuptr EmRegsEZ::GetAddressStart (void) +{ + return kMemoryStart; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetAddressRange +// --------------------------------------------------------------------------- + +uint32 EmRegsEZ::GetAddressRange (void) +{ + return kMemorySize; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::Cycle +// --------------------------------------------------------------------------- +// Handles periodic events that need to occur when the processor cycles (like +// updating timer registers). This function is called in two places from +// Emulator::Execute. Interestingly, the loop runs 3% FASTER if this function +// is in its own separate function instead of being inline. + +void EmRegsEZ::Cycle (Bool sleeping) +{ +#if _DEBUG + #define increment 20 +#else + #define increment 4 +#endif + + // Determine whether timer is enabled. + + if ((READ_REGISTER (tmr1Control) & hwrEZ328TmrControlEnable) != 0) + { + // If so, increment the timer. + + WRITE_REGISTER (tmr1Counter, READ_REGISTER (tmr1Counter) + (sleeping ? 1 : increment)); + + // Determine whether the timer has reached the specified count. + + if (sleeping || READ_REGISTER (tmr1Counter) > READ_REGISTER (tmr1Compare)) + { + // Flag the occurrence of the successful comparison. + + WRITE_REGISTER (tmr1Status, READ_REGISTER (tmr1Status) | hwrEZ328TmrStatusCompare); + + // If the Free Run/Restart flag is not set, clear the counter. + + if ((READ_REGISTER (tmr1Control) & hwrEZ328TmrControlFreeRun) == 0) + { + WRITE_REGISTER (tmr1Counter, 0); + } + + // If the timer interrupt is enabled, post an interrupt. + + if ((READ_REGISTER (tmr1Control) & hwrEZ328TmrControlEnInterrupt) != 0) + { + WRITE_REGISTER (intPendingLo, READ_REGISTER (intPendingLo) | hwrEZ328IntLoTimer); + EmRegsEZ::UpdateInterrupts (); + } + } + } + + if ((fCycle += increment) > READ_REGISTER (tmr1Compare)) + { + fCycle = 0; + + if (++fTick >= 100) + { + fTick = 0; + + if (++fSec >= 60) + { + fSec = 0; + + if (++fMin >= 60) + { + fMin = 0; + + if (++fHour >= 24) + { + fHour = 0; + } + } + } + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::CycleSlowly +// --------------------------------------------------------------------------- +// Handles periodic events that need to occur when the processor cycles (like +// updating timer registers). This function is called in two places from +// Emulator::Execute. Interestingly, the loop runs 3% FASTER if this function +// is in its own separate function instead of being inline. + +void EmRegsEZ::CycleSlowly (Bool sleeping) +{ + UNUSED_PARAM(sleeping) + + // See if a hard button is pressed. + + + EmAssert (gSession); + if (gSession->HasButtonEvent ()) + { + EmButtonEvent event = gSession->GetButtonEvent (); + if (event.fButton == kElement_CradleButton) + { + EmRegsEZ::HotSyncEvent (event.fButtonIsDown); + } + else + { + EmRegsEZ::ButtonEvent (event.fButton, event.fButtonIsDown); + } + } + + // See if there's anything new ("Put the data on the bus") + + EmRegsEZ::UpdateUARTState (false); + + // Check to see if the RTC alarm is ready to go off. First see + // if the RTC is enabled, and that the alarm event isn't already + // registered (the latter check is just an optimization). + + if ((READ_REGISTER (rtcIntEnable) & hwrEZ328RTCIntEnableAlarm) != 0 && + (READ_REGISTER (rtcIntStatus) & hwrEZ328RTCIntStatusAlarm) == 0) + { + uint32 rtcAlarm = READ_REGISTER (rtcAlarm); + + long almHour = (rtcAlarm & hwrEZ328RTCAlarmHoursMask) >> hwrEZ328RTCAlarmHoursOffset; + long almMin = (rtcAlarm & hwrEZ328RTCAlarmMinutesMask) >> hwrEZ328RTCAlarmMinutesOffset; + long almSec = (rtcAlarm & hwrEZ328RTCAlarmSecondsMask) >> hwrEZ328RTCAlarmSecondsOffset; + long almInSeconds = (almHour * 60 * 60) + (almMin * 60) + almSec; + + long nowHour; + long nowMin; + long nowSec; + ::GetHostTime (&nowHour, &nowMin, &nowSec); + long nowInSeconds = (nowHour * 60 * 60) + (nowMin * 60) + nowSec; + + if (almInSeconds <= nowInSeconds) + { + WRITE_REGISTER (rtcIntStatus, READ_REGISTER (rtcIntStatus) | hwrEZ328RTCIntStatusAlarm); + EmRegsEZ::UpdateRTCInterrupts (); + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::TurnSoundOff +// --------------------------------------------------------------------------- + +void EmRegsEZ::TurnSoundOff (void) +{ + uint16 pwmControl = READ_REGISTER (pwmControl); + WRITE_REGISTER (pwmControl, pwmControl & ~hwrEZ328PWMControlEnable); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::ResetTimer +// --------------------------------------------------------------------------- + +void EmRegsEZ::ResetTimer (void) +{ + WRITE_REGISTER (tmr1Counter, 0); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::ResetRTC +// --------------------------------------------------------------------------- + +void EmRegsEZ::ResetRTC (void) +{ + fHour = 15; + fMin = 0; + fSec = 0; + fTick = 0; + fCycle = 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetInterruptLevel +// --------------------------------------------------------------------------- + +int32 EmRegsEZ::GetInterruptLevel (void) +{ + uint16 intStatusHi = READ_REGISTER (intStatusHi); + uint16 intStatusLo = READ_REGISTER (intStatusLo); + + // Level 7 = EMUIRQ. + + if ((intStatusHi & hwrEZ328IntHiEMU) != 0) + return 7; + + // Level 6 = IRQ6, TMR, PWM. + + if ((intStatusHi & (hwrEZ328IntHiIRQ6)) != 0) + return 6; + + if ((intStatusLo & (hwrEZ328IntLoTimer | hwrEZ328IntLoPWM)) != 0) + return 6; + + // Level 5 = PEN. + + if ((intStatusHi & hwrEZ328IntHiPen) != 0) + return 5; + + // Level 4 = SPIM, UART, WDT, RTC, RTC Sample, KB, INT0 - INT3. + + if ((intStatusLo & ( hwrEZ328IntLoSPIM | + hwrEZ328IntLoUART | + hwrEZ328IntLoWDT | + hwrEZ328IntLoRTC | + hwrEZ328IntLoKbd | + hwrEZ328IntLoInt3 | + hwrEZ328IntLoInt2 | + hwrEZ328IntLoInt1 | + hwrEZ328IntLoInt0)) != 0) + return 4; + + if ((intStatusHi & hwrEZ328IntHiSampleTimer) != 0) + return 4; + + // Level 3 = IRQ3. + + if ((intStatusHi & hwrEZ328IntHiIRQ3) != 0) + return 3; + + // Level 2 = IRQ2. + + if ((intStatusHi & hwrEZ328IntHiIRQ2) != 0) + return 2; + + // Level 1 = IRQ1. + + if ((intStatusHi & hwrEZ328IntHiIRQ1) != 0) + return 1; + + // Level 0. + + return -1; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetInterruptBase +// --------------------------------------------------------------------------- + +int32 EmRegsEZ::GetInterruptBase (void) +{ + return READ_REGISTER (intVector) & 0xF8; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetLCDHasFrame +// --------------------------------------------------------------------------- + +Bool EmRegsEZ::GetLCDHasFrame (void) +{ + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetLCDBeginEnd +// --------------------------------------------------------------------------- + +void EmRegsEZ::GetLCDBeginEnd (emuptr& begin, emuptr& end) +{ + emuptr baseAddr = READ_REGISTER (lcdStartAddr); + int rowBytes = READ_REGISTER (lcdPageWidth) * 2; + int height = READ_REGISTER (lcdScreenHeight) + 1; + + begin = baseAddr; + end = baseAddr + rowBytes * height; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetLCDScanlines +// --------------------------------------------------------------------------- + +void EmRegsEZ::GetLCDScanlines (EmScreenUpdateInfo& info) +{ + // Get the screen metrics. + + int32 bpp = 1 << (READ_REGISTER (lcdPanelControl) & 0x03); + int32 width = READ_REGISTER (lcdScreenWidth); + int32 height = READ_REGISTER (lcdScreenHeight) + 1; + int32 rowBytes = READ_REGISTER (lcdPageWidth) * 2; + emuptr baseAddr = READ_REGISTER (lcdStartAddr); + + info.fLeftMargin = READ_REGISTER (lcdPanningOffset) & 0x0F; + + EmPixMapFormat format = bpp == 1 ? kPixMapFormat1 : + bpp == 2 ? kPixMapFormat2 : + bpp == 4 ? kPixMapFormat4 : + kPixMapFormat8; + + RGBList colorTable; + this->PrvGetPalette (colorTable); + + // Set format, size, and color table of EmPixMap. + + info.fImage.SetSize (EmPoint (width, height)); + info.fImage.SetFormat (format); + info.fImage.SetRowBytes (rowBytes); + info.fImage.SetColorTable (colorTable); + + // Determine first and last scanlines to fetch, and fetch them. + + info.fFirstLine = (info.fScreenLow - baseAddr) / rowBytes; + info.fLastLine = (info.fScreenHigh - baseAddr - 1) / rowBytes + 1; + + emuptr firstLineAddr = baseAddr + (info.fFirstLine * rowBytes); + emuptr lastLineAddr = baseAddr + (info.fLastLine * rowBytes); + + // TODO: probably move to <M68EZ328Hwr.h> + const long hwrEZ328LcdPageSize = 0x00020000; // 128K + const long hwrEZ328LcdPageMask = 0xFFFE0000; + + uint8* dst = ((uint8*) info.fImage.GetBits () + firstLineAddr - baseAddr); + emuptr boundaryAddr = ((baseAddr & hwrEZ328LcdPageMask) + hwrEZ328LcdPageSize); + + if (lastLineAddr <= boundaryAddr) + { + // Bits don't cross the 128K boundary + } + else if (firstLineAddr >= boundaryAddr) + { + // Bits are all beyond the 128K boundary + + firstLineAddr -= hwrEZ328LcdPageSize; // wrap around + lastLineAddr -= hwrEZ328LcdPageSize; + } + else + { + // Bits straddle the 128K boundary; + // copy the first part here, the wrapped part below + + EmMem_memcpy ((void*) dst, firstLineAddr, boundaryAddr - firstLineAddr); + dst += (boundaryAddr - firstLineAddr); + + firstLineAddr = boundaryAddr - hwrEZ328LcdPageSize; + lastLineAddr -= hwrEZ328LcdPageSize; // wrap around + } + + EmMem_memcpy ((void*) dst, firstLineAddr, lastLineAddr - firstLineAddr); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetUARTDevice +// --------------------------------------------------------------------------- +// Return what sort of device is hooked up to the given UART. + +EmUARTDeviceType EmRegsEZ::GetUARTDevice (int /*uartNum*/) +{ + Bool serEnabled = this->GetLineDriverState (kUARTSerial); + Bool irEnabled = this->GetLineDriverState (kUARTIR); + + // It's probably an error to have them both enabled at the same + // time. !!! TBD: make this an error message. + + EmAssert (!(serEnabled && irEnabled)); + + if (serEnabled) + return kUARTSerial; + + if (irEnabled) + return kUARTIR; + + return kUARTNone; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetDynamicHeapSize +// --------------------------------------------------------------------------- + +int32 EmRegsEZ::GetDynamicHeapSize (void) +{ + int32 result = 0; + + uint16 csDSelect = READ_REGISTER (csDSelect); + + switch (csDSelect & UPSIZ) + { + case 0x0000: + result = 32 * 1024L; + break; + + case 0x0800: + result = 64 * 1024L; + break; + + case 0x1000: + result = 128 * 1024L; + break; + + case 0x1800: + result = 256 * 1024L; + break; + + default: + EmAssert (false); + break; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetROMSize +// --------------------------------------------------------------------------- + +int32 EmRegsEZ::GetROMSize (void) +{ + /* + SIZ Chip-Select Size + + This field determines the memory range of the chip-select. For CSA + and CSB, chip-select size is between 128K and 16M. For CSC and CSD, + chip-select size is between 32K and 4M. + + 000 = 128K (32K for CSC and CSD). + 001 = 256K (64K for CSC and CSD). + 010 = 512K (128K for CSC and CSD). + 011 = 1M (256K for CSC and CSD). + 100 = 2M (512K for CSC and CSD). + 101 = 4M (1M for CSC and CSD). + 110 = 8M (2M for CSC and CSD). + 111 = 16M (4M for CSC and CSD). + */ + + uint16 csASelect = READ_REGISTER (csASelect); + uint32 result = (128 * 1024L) << ((csASelect & SIZ) >> 1); + + if ((csASelect & EN) == 0) + { + result = 16 * 1024L * 1024L; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetROMBaseAddress +// --------------------------------------------------------------------------- + +uint32 EmRegsEZ::GetROMBaseAddress (void) +{ + /* + csAGroupBase: Chip-select Group Base Address register + + The csAGroupBase register stores the base address (bits 14-28 of + the address) in the top 15 bits. The low bit is always zero. + Shifting this value by 13 gives the ROM base address. + + E.g: If the base address is 0x10C00000, then csAGroupBase will + contain 0x10C00000 >> 13 (base 10) = 0x8600. + + If the enable bit of the CSA register is low, the chip selects + have not yet been set up. In this case, return an invalid value. + */ + + if (!this->ChipSelectsConfigured()) + { + return 0xFFFFFFFF; + } + + uint16 csAGroupBase = READ_REGISTER (csAGroupBase); + uint32 result = csAGroupBase << gBaseAddressShift; + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::ChipSelectsConfigured +// --------------------------------------------------------------------------- + +Bool EmRegsEZ::ChipSelectsConfigured (void) +{ + return READ_REGISTER (csASelect) & EN; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetSystemClockFrequency +// --------------------------------------------------------------------------- + +int32 EmRegsEZ::GetSystemClockFrequency (void) +{ + uint16 pllControl = READ_REGISTER (pllControl); + uint16 pllFreqSel = READ_REGISTER (pllFreqSel); + + // Convert the 32.768KHz clock (CLK32) into the PLLCLK frequency. + + uint16 PC = (pllFreqSel & 0x00FF); + uint16 QC = (pllFreqSel & 0x0F00) >> 8; + + uint32 result = 32768L * (14 * (PC + 1) + QC + 1); + + // Divide by the prescaler, if needed. + + if ((pllControl & 0x0020) != 0) + { + result /= 2; + } + + // Divide by the system clock scaler, if needed. + + switch (pllControl & 0x0F00) + { + case hwrEZ328PLLControlSysDMADiv2: + result /= 2; + break; + + case hwrEZ328PLLControlSysDMADiv4: + result /= 4; + break; + + case hwrEZ328PLLControlSysDMADiv8: + result /= 8; + break; + + case hwrEZ328PLLControlSysDMADiv16: + result /= 16; + break; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetCanStop +// --------------------------------------------------------------------------- + +Bool EmRegsEZ::GetCanStop (void) +{ + // Make sure Timer is enabled or the RTC interrupt is enabled. + + if ((READ_REGISTER (tmr1Control) & hwrEZ328TmrControlEnable) != 0) + return true; + + if ((READ_REGISTER (rtcIntEnable) & hwrEZ328RTCIntEnableAlarm) != 0) + return true; + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetAsleep +// --------------------------------------------------------------------------- + +Bool EmRegsEZ::GetAsleep (void) +{ + return ((READ_REGISTER (pllControl) & hwrEZ328PLLControlDisable) != 0); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetPortInputValue +// --------------------------------------------------------------------------- +// Return the GPIO values for the pins on the port. These values are used +// if the select pins are high. + +uint8 EmRegsEZ::GetPortInputValue (int port) +{ + uint8 result = 0; + + if (port == 'D') + { + result = this->GetPortInternalValue (port); + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetPortInternalValue +// --------------------------------------------------------------------------- +// Return the dedicated values for the pins on the port. These values are +// used if the select pins are low. + +uint8 EmRegsEZ::GetPortInternalValue (int port) +{ + uint8 result = 0; + + if (port == 'D') + { + // If the ID_DETECT pin is asserted, load the data lines with the + // hardware ID. + + if (EmRegsEZ::IDDetectAsserted ()) + { + result = EmRegsEZ::GetHardwareID (); + } + + // Otherwise, load the lines with keyboard information. + + else + { + // Get the INT bits that need to be set. + + result = this->GetKeyBits (); + } + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::PortDataChanged +// --------------------------------------------------------------------------- + +void EmRegsEZ::PortDataChanged (int port, uint8, uint8 newValue) +{ + if (port == 'D') + { + // Clear the interrupt bits that are having a 1 written to them. + // Only clear them if they're configured as edge-senstive. + + uint8 portDIntEdge = READ_REGISTER (portDIntEdge); + + PRINTF ("EmRegsEZ::PortDataChanged (D): fPortDEdge = 0x%02lX", (uint32) (uint8) fPortDEdge); + PRINTF ("EmRegsEZ::PortDataChanged (D): portDIntEdge = 0x%02lX", (uint32) (uint8) portDIntEdge); + PRINTF ("EmRegsEZ::PortDataChanged (D): newValue = 0x%02lX", (uint32) (uint8) newValue); + + fPortDEdge &= ~(newValue & portDIntEdge); + + PRINTF ("EmRegsEZ::PortDataChanged (D): fPortDEdge = 0x%02lX", (uint32) (uint8) fPortDEdge); + + // Set the new interrupt state. + + EmRegsEZ::UpdatePortDInterrupts (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::pllFreqSelRead +// --------------------------------------------------------------------------- + +uint32 EmRegsEZ::pllFreqSelRead (emuptr address, int size) +{ + // Simulate the rising and falling of the CLK32 signal so that functions + // like HwrPreRAMInit, HwrShutDownPLL, PrvSetPLL, and PrvShutDownPLL + // won't hang. + + uint16 pllFreqSel = READ_REGISTER (pllFreqSel) ^ 0x8000; + WRITE_REGISTER (pllFreqSel, pllFreqSel); + + // Finish up by doing a standard read. + + return EmRegsEZ::StdRead (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::portXDataRead +// --------------------------------------------------------------------------- + +uint32 EmRegsEZ::portXDataRead (emuptr address, int) +{ + // The value read can come from three different places: + // + // - the value what was written to the data register + // - any dedicated inputs + // - any GPIO inputs + // + // The value returned depends on the settings of the SEL and DIR + // registers. So let's get those settings, the values from the three + // input sources, and build up a return value based on those. + + int port = GetPort (address); + + uint8 sel = StdRead (address + 2, 1); + uint8 dir = StdRead (address - 1, 1); + uint8 output = StdRead (address + 0, 1); + uint8 input = EmHAL::GetPortInputValue (port); + uint8 intFn = EmHAL::GetPortInternalValue (port); + + if (port == 'D') + { + sel |= 0x0F; // No "select" bit in low nybble, so set for IO values. + + // The system will poll portD 18 times in KeyBootKeys to see + // if any keys are down. Wait at least that long before + // letting up any boot keys maintained by the session. When we + // do call ReleaseBootKeys, set our counter to -1 as a flag not + // to call it any more. + + if (fPortDDataCount != 0xFFFFFFFF && ++fPortDDataCount >= 18 * 2) + { + fPortDDataCount = 0xFFFFFFFF; + gSession->ReleaseBootKeys (); + } + } + + // Use the internal chip function bits if the "sel" bits are zero. + + intFn &= ~sel; + + // Otherwise, use the I/O bits. + + output &= sel & dir; // Use the output bits if the "dir" is one. + input &= sel & ~dir; // Use the input bits if the "dir" is zero. + + // Assert that there are no overlaps. + + EmAssert ((output & input) == 0); + EmAssert ((output & intFn) == 0); + EmAssert ((input & intFn) == 0); + + // Mush everything together. + + uint8 result = output | input | intFn; + + // If this is port D, flip the bits if the POLARITY register says to. + // (!!! Does this inversion apply only to input bits? That is, the + // bits where the "dir" register has 0 bits?) + + if (0 && port == 'D') + { + uint8 polarity = READ_REGISTER (portDPolarity); + PRINTF ("EmRegsEZ::portXDataRead: polarity = 0x%02lX", (uint32) polarity); + result ^= polarity; + } + + PRINTF ("EmRegsEZ::port%cDataRead: sel dir output input intFn result", (char) port); + PRINTF ("EmRegsEZ::port%cDataRead: 0x%02lX 0x%02lX 0x%02lX 0x%02lX 0x%02lX 0x%02lX", + (char) port, (uint32) sel, (uint32) dir, (uint32) output, (uint32) input, (uint32) intFn, (uint32) result); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::tmr1StatusRead +// --------------------------------------------------------------------------- + +uint32 EmRegsEZ::tmr1StatusRead (emuptr address, int size) +{ + uint16 tmr1Counter = READ_REGISTER (tmr1Counter) + 16; + uint16 tmr1Compare = READ_REGISTER (tmr1Compare); + uint16 tmr1Control = READ_REGISTER (tmr1Control); + + // Increment the timer. + + WRITE_REGISTER (tmr1Counter, tmr1Counter); + + // If the timer has passed the specified value... + + if ((tmr1Counter - tmr1Compare) < 16) + { + // Set the flag saying the timer timed out. + + uint16 tmr1Status = READ_REGISTER (tmr1Status) | hwrEZ328TmrStatusCompare; + WRITE_REGISTER (tmr1Status, tmr1Status); + + // If it's not a free-running timer, reset it to zero. + + if ((tmr1Control & hwrEZ328TmrControlFreeRun) == 0) + { + WRITE_REGISTER (tmr1Counter, 0); + } + } + + // Remember this guy for later (see EmRegsEZ::tmr1StatusWrite()) + + fLastTmr1Status |= READ_REGISTER (tmr1Status); + + // Finish up by doing a standard read. + + return EmRegsEZ::StdRead (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::uartRead +// --------------------------------------------------------------------------- + +uint32 EmRegsEZ::uartRead (emuptr address, int size) +{ + // If this is a full read, get the next byte from the FIFO. + + Bool refreshRxData = (address == addressof (uReceive)) && (size == 2); + + // See if there's anything new ("Put the data on the bus") + + EmRegsEZ::UpdateUARTState (refreshRxData); + + // Finish up by doing a standard read. + + return EmRegsEZ::StdRead (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::rtcHourMinSecRead +// --------------------------------------------------------------------------- + +uint32 EmRegsEZ::rtcHourMinSecRead (emuptr address, int size) +{ + // Get the desktop machine's time. + + long hour, min, sec; + + if (Hordes::IsOn ()) + { + hour = fHour; + min = fMin; + sec = fSec; + } + else + { + ::GetHostTime (&hour, &min, &sec); + } + + // Update the register. + + WRITE_REGISTER (rtcHourMinSec, (hour << hwrEZ328RTCHourMinSecHoursOffset) + | (min << hwrEZ328RTCHourMinSecMinutesOffset) + | (sec << hwrEZ328RTCHourMinSecSecondsOffset)); + + // Finish up by doing a standard read. + + return EmRegsEZ::StdRead (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::csASelectWrite +// --------------------------------------------------------------------------- + +void EmRegsEZ::csASelectWrite (emuptr address, int size, uint32 value) +{ + // Get the current value. + + uint16 csASelect = READ_REGISTER (csASelect); + + // Do a standard update of the register. + + EmRegsEZ::StdWrite (address, size, value); + + // Check to see if the unprotected memory range changed. + + if ((csASelect & SIZ) != (READ_REGISTER (csASelect) & SIZ)) + { + EmAssert (gSession); + gSession->ScheduleResetBanks (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::csDSelectWrite +// --------------------------------------------------------------------------- + +void EmRegsEZ::csDSelectWrite (emuptr address, int size, uint32 value) +{ + // Get the current value. + + uint16 csDSelect = READ_REGISTER (csDSelect); + + // Do a standard update of the register. + + EmRegsEZ::StdWrite (address, size, value); + + // Check its new state and update our ram-protect flag. + + gMemAccessFlags.fProtect_SRAMSet = (READ_REGISTER (csDSelect) & 0x2000) != 0; + + // Check to see if the unprotected memory range changed. + + if ((csDSelect & UPSIZ) != (READ_REGISTER (csDSelect) & UPSIZ)) + { + EmAssert (gSession); + gSession->ScheduleResetBanks (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::intMaskHiWrite +// --------------------------------------------------------------------------- + +void EmRegsEZ::intMaskHiWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsEZ::StdWrite (address, size, value); + + // Respond to the new interrupt state. + + EmRegsEZ::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::intMaskLoWrite +// --------------------------------------------------------------------------- + +void EmRegsEZ::intMaskLoWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsEZ::StdWrite (address, size, value); + + // Respond to the new interrupt state. + + EmRegsEZ::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::intStatusHiWrite +// --------------------------------------------------------------------------- + +void EmRegsEZ::intStatusHiWrite (emuptr address, int size, uint32 value) +{ + // IRQ1, IRQ2, IRQ3, IRQ6 and IRQ7 are cleared by writing to their + // respective status bits. We handle those there. Since there are + // no interrupt status bits like this in intStatusLo, we don't need + // a handler for that register; we only handle intStatusHi. + + // Even though this is a 16-bit register as defined by the Palm headers, + // it's a 32-bit register according to DragonballEZ docs, and is in fact + // accessed that way in the kernal files (cf. HwrIRQ4Handler). In those + // cases, we're still only interested in access to the IRQ# bits, so we + // can turn 4-byte accesses into 2-byte accesses. + + if (size == 4) + value >>= 16; + + // Take into account the possibility of 1-byte accesses, too. If we're + // accessing the upper byte, just return. If we're accessing the lower + // byte, we can treat it as a 2-byte access. + + else if (size == 1 && address == addressof (intStatusHi)) + return; + + // Now we can treat the rest of this function as a word-write to intStatusHi. + + uint16 intPendingHi = READ_REGISTER (intPendingHi); + + // For each interrupt: + // If we're writing to that interrupt's status bit and its edge bit is set: + // - clear the interrupt's pending bit + // - respond to the new interrupt state. + + #undef CLEAR_PENDING_INTERRUPT + #define CLEAR_PENDING_INTERRUPT(edge, irq) \ + if ((READ_REGISTER (intControl) & edge) && (value & (irq))) \ + { \ + intPendingHi &= ~(irq); \ + } + + CLEAR_PENDING_INTERRUPT (hwrEZ328IntCtlEdge1, hwrEZ328IntHiIRQ1); + CLEAR_PENDING_INTERRUPT (hwrEZ328IntCtlEdge2, hwrEZ328IntHiIRQ2); + CLEAR_PENDING_INTERRUPT (hwrEZ328IntCtlEdge3, hwrEZ328IntHiIRQ3); + CLEAR_PENDING_INTERRUPT (hwrEZ328IntCtlEdge6, hwrEZ328IntHiIRQ6); + + // IRQ7 is not edge-programmable, so clear it if we're merely writing to it. + // !!! Double check this for EZ! + + if (value & hwrEZ328IntHiEMU) + { + intPendingHi &= ~(hwrEZ328IntHiEMU); + } + + // If we're emulating the user pressing the hotsync button, make sure the + // interrupt stays asserted. (!!! Should we use the same technique for + // other buttons, too? It doesn't seem to be needed right now, but doing + // that may more closely mirror the hardware.) + + if (fHotSyncButtonDown) + { + intPendingHi |= hwrEZ328IntHiIRQ1; + } + else + { + intPendingHi &= ~hwrEZ328IntHiIRQ1; + } + + // This makes the power on key work. If the signal is asserted, the + // unit will not transition between asleep and awake (cf. HwrSleep, HwrWake). + + intPendingHi &= ~hwrEZ328IntHiIRQ6; + + WRITE_REGISTER (intPendingHi, intPendingHi); + EmRegsEZ::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::portXDataWrite +// --------------------------------------------------------------------------- + +void EmRegsEZ::portXDataWrite (emuptr address, int size, uint32 value) +{ + // Get the old value before updating it. + + uint8 oldValue = StdRead (address, size); + + // Take a snapshot of the line driver states. + + Bool driverStates[kUARTEnd]; + EmHAL::GetLineDriverStates (driverStates); + + // Now update the value with a standard write. + + StdWrite (address, size, value); + + // Let anyone know that it's changed. + + int port = GetPort (address); + PRINTF ("EmRegsEZ::port%cDataWrite: oldValue = 0x%02lX", (char) port, (uint32) (uint8) oldValue); + PRINTF ("EmRegsEZ::port%cDataWrite: newValue = 0x%02lX", (char) port, (uint32) (uint8) value); + + EmHAL::PortDataChanged (port, oldValue, value); + + // Respond to any changes in the line driver states. + + EmHAL::CompareLineDriverStates (driverStates); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::portDIntReqEnWrite +// --------------------------------------------------------------------------- + +void EmRegsEZ::portDIntReqEnWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsEZ::StdWrite (address, size, value); + + // Set the new interrupt state. + + EmRegsEZ::UpdatePortDInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::tmr1StatusWrite +// --------------------------------------------------------------------------- + +void EmRegsEZ::tmr1StatusWrite (emuptr address, int size, uint32 value) +{ + UNUSED_PARAM(address) + UNUSED_PARAM(size) + + EmAssert (size == 2); // This function's a hell of a lot easier to write if + // we assume only full-register access. + + // Get the current value. + + uint16 tmr1Status = READ_REGISTER (tmr1Status); + + // If the user had previously read the status bits while they + // were set, then it's OK for them to be clear now. Otherwise, + // we have to merge any set status bits back in. + + tmr1Status &= value | ~fLastTmr1Status; // fLastTmr1Status was set in EmRegsEZ::tmr1StatusRead() + + WRITE_REGISTER (tmr1Status, tmr1Status); + + fLastTmr1Status = 0; + if ((tmr1Status & hwrEZ328TmrStatusCompare) == 0) + { + uint16 intPendingLo = READ_REGISTER (intPendingLo) & ~hwrEZ328IntLoTimer; + WRITE_REGISTER (intPendingLo, intPendingLo); + + // Respond to the new interrupt state. + + EmRegsEZ::UpdateInterrupts (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::spiMasterControlWrite +// --------------------------------------------------------------------------- + +void EmRegsEZ::spiMasterControlWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsEZ::StdWrite (address, size, value); + + // Get the current value. + + uint16 spiMasterData = READ_REGISTER (spiMasterData); + uint16 spiMasterControl = READ_REGISTER (spiMasterControl); + + // Check to see if data exchange and interrupts are enabled. + + #define BIT_MASK (hwrEZ328SPIMControlExchange | hwrEZ328SPIMControlEnable) + if ((spiMasterControl & BIT_MASK) == BIT_MASK) + { + // If the SPI is hooked up to something, talk with it. + + EmSPISlave* spiSlave = this->GetSPISlave (); + if (spiSlave) + { + // Write out the old data, read in the new data. + + uint16 newData = spiSlave->DoExchange (spiMasterControl, spiMasterData); + + // Shift in the new data. + + uint16 numBits = (spiMasterControl & hwrEZ328SPIMControlBitsMask) + 1; + + uint16 oldBitsMask = ~0 << numBits; + uint16 newBitsMask = ~oldBitsMask; + + spiMasterData = /*((spiMasterData << numBits) & oldBitsMask) | */ + (newData & newBitsMask); + + WRITE_REGISTER (spiMasterData, spiMasterData); + } + + // Assert the interrupt and clear the exchange bit. + + spiMasterControl |= hwrEZ328SPIMControlIntStatus; + spiMasterControl &= ~hwrEZ328SPIMControlExchange; + + WRITE_REGISTER (spiMasterControl, spiMasterControl); + + // If hwrEZ328SPIMControlIntEnable is set, trigger an interrupt. + + if ((spiMasterControl & hwrEZ328SPIMControlIntEnable) != 0) + { + uint16 intPendingLo = READ_REGISTER (intPendingLo); + intPendingLo |= hwrEZ328IntLoSPIM; + WRITE_REGISTER (intPendingLo, intPendingLo); + this->UpdateInterrupts (); + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::uartWrite +// --------------------------------------------------------------------------- + +void EmRegsEZ::uartWrite(emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsEZ::StdWrite (address, size, value); + + // If this write included the TX_DATA field, signal that it needs to + // be transmitted. + + Bool sendTxData = + ((address == addressof (uTransmit)) && (size == 2)) || + ((address == addressof (uTransmit) + 1) && (size == 1)); + + // React to any changes. + + EmRegsEZ::UARTStateChanged (sendTxData); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::lcdRegisterWrite +// --------------------------------------------------------------------------- + +void EmRegsEZ::lcdRegisterWrite (emuptr address, int size, uint32 value) +{ + // First, get the old value in case we need to see what changed. + + uint32 oldValue = EmRegsEZ::StdRead (address, size); + + // Do a standard update of the register. + + EmRegsEZ::StdWrite (address, size, value); + + // Note what changed. + + if (address == addressof (lcdScreenWidth)) + { + EmScreen::InvalidateAll (); + } + else if (address == addressof (lcdScreenHeight)) + { + EmScreen::InvalidateAll (); + } + else if (address == addressof (lcdPanelControl)) + { + // hwrEZ328LcdPanelControlGrayScale is incorrectly defined as 0x01, + // so use the hard-coded value of 0x03 here. + +// if (((value ^ oldValue) & hwrEZ328LcdPanelControlGrayScale) != 0) + if (((value ^ oldValue) & 0x03) != 0) + { + EmScreen::InvalidateAll (); + } + } + else if (address == addressof (lcdStartAddr)) + { + // Make sure the low-bit is always zero. + // Make sure bits 31-29 are always zero. + + uint32 lcdStartAddr = READ_REGISTER (lcdStartAddr) & 0x1FFFFFFE; + WRITE_REGISTER (lcdStartAddr, lcdStartAddr); + + EmScreen::InvalidateAll (); + } + else if (address == addressof (lcdPageWidth)) + { + if (value != oldValue) + { + EmScreen::InvalidateAll (); + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::rtcControlWrite +// --------------------------------------------------------------------------- + +void EmRegsEZ::rtcControlWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsEZ::StdWrite (address, size, value); + + // Respond to the new interrupt state. + + EmRegsEZ::UpdateRTCInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::rtcIntStatusWrite +// --------------------------------------------------------------------------- + +void EmRegsEZ::rtcIntStatusWrite (emuptr address, int size, uint32 value) +{ + // Status bits are cleared by writing ones to them. + + // If we're doing a byte-write to the upper byte, shift the byte + // so that we can treat the operation as a word write. If we're + // doing a byte-write to the lower byte, this extension will happen + // automatically. + + if (address == addressof (rtcIntStatus) && size == 1) + value <<= 8; + + // Get the current value. + + uint16 rtcIntStatus = READ_REGISTER (rtcIntStatus); + + // Clear the requested bits. + + rtcIntStatus &= ~value; + + // Update the register. + + WRITE_REGISTER (rtcIntStatus, rtcIntStatus); + + // Respond to the new interrupt state. + + EmRegsEZ::UpdateRTCInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::rtcIntEnableWrite +// --------------------------------------------------------------------------- + +void EmRegsEZ::rtcIntEnableWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsEZ::StdWrite (address, size, value); + + // Respond to the new interrupt state. + + EmRegsEZ::UpdateRTCInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::ButtonEvent +// --------------------------------------------------------------------------- +// Handles a Palm device button event by updating the appropriate registers. + +void EmRegsEZ::ButtonEvent (SkinElementType button, Bool buttonIsDown) +{ + uint16 bitNumber = this->ButtonToBits (button); + + // Get the bits that should have been set with the previous set + // of pressed keys. We use this old value to update the port D interrupts. + + uint8 oldBits = this->GetKeyBits (); + + // Update the set of keys that are currently pressed. + + if (buttonIsDown) + { + fKeyBits |= bitNumber; // Remember the key bit + } + else + { + fKeyBits &= ~bitNumber; // Forget the key bit + } + + // Now get the new set of bits that should be set. + + uint8 newBits = this->GetKeyBits (); + + PRINTF ("EmRegsEZ::ButtonEvent: fKeyBits = 0x%04lX", (uint32) fKeyBits); + PRINTF ("EmRegsEZ::ButtonEvent: oldBits = 0x%02lX", (uint32) oldBits); + PRINTF ("EmRegsEZ::ButtonEvent: newBits = 0x%02lX", (uint32) newBits); + + // Set the interrupt bits for the bits that went from off to on. + // These get cleared when portDData is written to. + + fPortDEdge |= newBits & ~oldBits; + + PRINTF ("EmRegsEZ::ButtonEvent: fPortDEdge = 0x%02lX", (uint32) fPortDEdge); + + // Set the new interrupt state. + + EmRegsEZ::UpdatePortDInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::HotSyncEvent +// --------------------------------------------------------------------------- +// Handles a HotSync button event by updating the appropriate registers. + +void EmRegsEZ::HotSyncEvent (Bool buttonIsDown) +{ + // If the button changes state, set or clear the HotSync interrupt. + + uint16 intPendingHi = READ_REGISTER (intPendingHi); + + if (buttonIsDown) + { + intPendingHi |= hwrEZ328IntHiIRQ1; + fHotSyncButtonDown = true; + } + else + { + intPendingHi &= ~hwrEZ328IntHiIRQ1; + fHotSyncButtonDown = false; + } + + WRITE_REGISTER (intPendingHi, intPendingHi); + + EmRegsEZ::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetKeyBits +// --------------------------------------------------------------------------- + +uint8 EmRegsEZ::GetKeyBits (void) +{ + // "Keys" (that is, buttons) are read from the Port D Data register. + // There are 7 or 8 keys that can be pressed, but only 4 bits are + // available in the Port D Data register for reporting pressed keys. + // Therefore, the keys are organized into a matrix, one row or which + // can be requested and reported at a time. This function determines + // what row is being requested, and sets the appropriate Port D Data + // bits for the keys are are currently pressed. + + int numRows; + int numCols; + uint16 keyMap[16]; + Bool rows[4]; + + this->GetKeyInfo (&numRows, &numCols, keyMap, rows); + + uint8 keyData = 0; + + // Walk the rows, looking for one that is requested. + + for (int row = 0; row < numRows; ++row) + { + if (rows[row]) + { + // Walk the columns, looking for ones that have a pressed key. + + for (int col = 0; col < numCols; ++col) + { + // Get the key corresponding to this row and column. + // If we've recorded (in fKeyBits) that this key is + // pressed, then set its column bit. + + uint16 key = keyMap[row * numCols + col]; + if ((key & fKeyBits) != 0) + { + keyData |= (1 << col); + } + } + } + } + + UInt8 portFDir = READ_REGISTER (portFDir); + UInt8 portFData = READ_REGISTER (portFData); + + PRINTF ("EmRegsEZ::GetKeyBits: numRows = %d, numCols = %d", numRows, numCols); + PRINTF ("EmRegsEZ::GetKeyBits: portFDir = 0x%02lX, portFData = 0x%02lX", (uint32) portFDir, (uint32) portFData); + PRINTF ("EmRegsEZ::GetKeyBits: rows[0] = %d, [1] = %d, [2] = %d, [3] = %d", rows[0], rows[1], rows[2], rows[3]); +// PRINTF ("EmRegsEZ::GetKeyBits: keyMap[0] = %2d, [1] = %2d, [2] = %2d, [3] = %2d", keyMap[0], keyMap[1], keyMap[2], keyMap[3]); +// PRINTF ("EmRegsEZ::GetKeyBits: keyMap[4] = %2d, [5] = %2d, [6] = %2d, [7] = %2d", keyMap[4], keyMap[5], keyMap[6], keyMap[7]); +// PRINTF ("EmRegsEZ::GetKeyBits: keyMap[8] = %2d, [9] = %2d, [A] = %2d, [B] = %2d", keyMap[8], keyMap[9], keyMap[10], keyMap[11]); +// PRINTF ("EmRegsEZ::GetKeyBits: keyMap[C] = %2d, [D] = %2d, [E] = %2d, [F] = %2d", keyMap[12], keyMap[13], keyMap[14], keyMap[15]); + PRINTF ("EmRegsEZ::GetKeyBits: fKeyBits = 0x%04lX", (uint32) fKeyBits); + PRINTF ("EmRegsEZ::GetKeyBits: keyData = 0x%02lX", (uint32) keyData); + + return keyData; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::ButtonToBits +// --------------------------------------------------------------------------- + +uint16 EmRegsEZ::ButtonToBits (SkinElementType button) +{ + uint16 bitNumber = 0; + switch (button) + { + case kElement_None: break; + + case kElement_PowerButton: bitNumber = keyBitPower; break; + case kElement_UpButton: bitNumber = keyBitPageUp; break; + case kElement_DownButton: bitNumber = keyBitPageDown; break; + case kElement_App1Button: bitNumber = keyBitHard1; break; + case kElement_App2Button: bitNumber = keyBitHard2; break; + case kElement_App3Button: bitNumber = keyBitHard3; break; + case kElement_App4Button: bitNumber = keyBitHard4; break; + case kElement_CradleButton: bitNumber = keyBitCradle; break; + case kElement_Antenna: bitNumber = keyBitAntenna; break; + case kElement_ContrastButton: bitNumber = keyBitContrast; break; + + default: EmAssert (false); + } + + return bitNumber; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave* EmRegsEZ::GetSPISlave (void) +{ + return NULL; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::UpdateInterrupts +// --------------------------------------------------------------------------- +// Determines whether an interrupt has occurred by copying the Interrupt +// Pending Register to the Interrupt Status Register. + +void EmRegsEZ::UpdateInterrupts (void) +{ + // Copy the Interrupt Pending Register to the Interrupt Status + // Register, but ignore interrupts that are being masked. + + // Note: this function is not sensitive to the byte ordering of the registers, + // so their contents don't need to be accessed via READ_REGISTER or WRITE_REGISTER. + + f68EZ328Regs.intStatusHi = f68EZ328Regs.intPendingHi & ~f68EZ328Regs.intMaskHi; + f68EZ328Regs.intStatusLo = f68EZ328Regs.intPendingLo & ~f68EZ328Regs.intMaskLo; + + PRINTF ("EmRegsEZ::UpdateInterrupts: intMask = 0x%04lX %04lX", + (uint32) f68EZ328Regs.intMaskHi, (uint32) f68EZ328Regs.intMaskLo); + + PRINTF ("EmRegsEZ::UpdateInterrupts: intPending = 0x%04lX %04lX", + (uint32) f68EZ328Regs.intPendingHi, (uint32) f68EZ328Regs.intPendingLo); + + // If the Interrupt Status Register isn't clear, flag an interrupt. + + if (f68EZ328Regs.intStatusHi || f68EZ328Regs.intStatusLo) + { + regs.spcflags |= SPCFLAG_INT; + + PRINTF ("EmRegsEZ::UpdateInterrupts: intStatus = 0x%04lX %04lX", + (uint32) f68EZ328Regs.intStatusHi, (uint32) f68EZ328Regs.intStatusLo); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::UpdatePortDInterrupts +// --------------------------------------------------------------------------- +// Determine what interrupts need to be generated based on the current +// settings in portDData and fPortDEdge. + +void EmRegsEZ::UpdatePortDInterrupts (void) +{ + // Update INT0-INT3 of the Interrupt-Pending register (bits 8-11 of the low word). + + PRINTF ("EmRegsEZ::UpdatePortDInterrupts:"); + + // First, get those bits and clear them out. + + uint16 intPendingLo = READ_REGISTER (intPendingLo) & ~hwrEZ328IntLoAllKeys; + + + // Initialize the variable to hold the new interrupt settings. + + uint8 newBits = 0; + + + // Get some other values we're going to need: + + uint8 portDDir = READ_REGISTER (portDDir); // Interrupt on inputs only (when pin is low) + uint8 portDData = EmHAL::GetPortInputValue ('D'); + uint8 portDPolarity = READ_REGISTER (portDPolarity); + uint8 portDIntReqEn = READ_REGISTER (portDIntReqEn); + uint8 portDKbdIntEn = READ_REGISTER (portDKbdIntEn); + uint8 portDIntEdge = READ_REGISTER (portDIntEdge); + + // We have a line-level interrupt if: + // + // - line-level interrupts are requested + // - the GPIO bit matches the polarity bit + + newBits |= ~portDIntEdge & portDData & portDPolarity; + newBits |= ~portDIntEdge & ~portDData & ~portDPolarity; + + + // We have an edge interrupt if: + // + // - edge interrupts are requested + // - an edge has been recorded + // + // Note that we should distinguish between rising and falling edges. + // For historical reasons, that's not done, and the Palm OS doesn't + // look for them, so it's OK for now. + // + // Edge interrupts on INT[3:0] should not wake up a sleeping device. + + uint16 pllControl = READ_REGISTER (pllControl); + + if (pllControl & hwrEZ328PLLControlDisable) + { + newBits |= portDIntEdge & fPortDEdge & portDPolarity & 0xF0; + newBits |= portDIntEdge & 0 & ~portDPolarity & 0xF0; + } + else + { + newBits |= portDIntEdge & fPortDEdge & portDPolarity; + newBits |= portDIntEdge & 0 & ~portDPolarity; + } + + + // Only have interrupts if they're enabled and the pin is configured for input. + + newBits &= portDIntReqEn & ~portDDir; + + PRINTF ("EmRegsEZ::UpdatePortDInterrupts: Dir Data Pol Req Edg PDE bits"); + PRINTF ("EmRegsEZ::UpdatePortDInterrupts: 0x%02lX 0x%02lX 0x%02lX 0x%02lX 0x%02lX 0x%02lX 0x%02lX", + (uint32) portDDir, (uint32) portDData, (uint32) portDPolarity, (uint32) portDIntReqEn, (uint32) portDIntEdge, + (uint32) fPortDEdge, (uint32) newBits); + + + // Determine if the KB interrupt needs to be asserted. It is if: + // + // A Port D Data bit is on. + // The bit is configured for input (?) + // The bit is configured to be OR'd into the interrupt. + + uint8 KB = portDData & ~portDDir & portDKbdIntEn; + + if (KB) + intPendingLo |= hwrEZ328IntLoKbd; + else + intPendingLo &= ~hwrEZ328IntLoKbd; + + + // Merge in the new values and write out the result. + + intPendingLo |= (((uint16) newBits) << hwrEZ328IntLoInt0Bit) & hwrEZ328IntLoAllKeys; + WRITE_REGISTER (intPendingLo, intPendingLo); + + + // Respond to the new interrupt state. + + EmRegsEZ::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::UpdateRTCInterrupts +// --------------------------------------------------------------------------- +// Determine whether to set or clear the RTC bit in the interrupt pending +// register based on the current RTC register values. + +void EmRegsEZ::UpdateRTCInterrupts (void) +{ + // See if the RTC is enabled. + + Bool rtcEnabled = (READ_REGISTER (rtcControl) & hwrEZ328RTCControlRTCEnable) != 0; + + // See if there are any RTC events that need to trigger an interrupt. + +#define BITS_TO_CHECK ( \ + hwrEZ328RTCIntEnableSec | \ + hwrEZ328RTCIntEnable24Hr | \ + hwrEZ328RTCIntEnableAlarm | \ + hwrEZ328RTCIntEnableMinute | \ + hwrEZ328RTCIntEnableStopWatch ) + + uint16 rtcIntStatus = READ_REGISTER (rtcIntStatus); + uint16 rtcIntEnable = READ_REGISTER (rtcIntEnable); + uint16 rtcIntPending = rtcIntStatus & rtcIntEnable & BITS_TO_CHECK; + + Bool havePendingEvents = rtcIntPending != 0; + + // If the RTC is enabled and there are pending events, set the interrupt. + // Otherwise, clear the interrupt. + + uint16 intPendingLo = READ_REGISTER (intPendingLo); + + if (rtcEnabled && havePendingEvents) + { + intPendingLo |= hwrEZ328IntLoRTC; // have events, so set interrupt + } + else + { + intPendingLo &= ~hwrEZ328IntLoRTC; // no events, so clear interrupt + } + + // Update the interrupt pending register. + + WRITE_REGISTER (intPendingLo, intPendingLo); + + // Respond to the new interrupt state. + + EmRegsEZ::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::IDDetectAsserted +// --------------------------------------------------------------------------- +// cf. HwrIdentifyFeatures and HwrPreRAMInit. + +Bool EmRegsEZ::IDDetectAsserted (void) +{ + uint8 portGDir = READ_REGISTER(portGDir); + uint8 portGData = READ_REGISTER(portGData); + uint8 portGPullupEn = READ_REGISTER(portGPullupEn); + uint8 portGSelect = READ_REGISTER(portGSelect); + const uint8 kMask = hwrEZPortGIDDetect; + + return (portGDir & kMask) == kMask && + (portGData & kMask) == 0 && + (portGPullupEn & kMask) == 0 && + (portGSelect & kMask) == kMask; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetHardwareID +// --------------------------------------------------------------------------- + +UInt8 EmRegsEZ::GetHardwareID (void) +{ + // Determine the hardware ID. + + EmAssert (gSession); + + EmDevice device = gSession->GetDevice (); + long miscFlags = device.HardwareID (); + + // Reverse map the following: + +// GHwrMiscFlags = 0; +// if ((keyState & hwrEZPortDKbdCol0) == 0) GHwrMiscFlags |= hwrMiscFlagID1; +// if ((keyState & hwrEZPortDKbdCol1) == 0) GHwrMiscFlags |= hwrMiscFlagID2; +// if ((keyState & hwrEZPortDKbdCol2) == 0) GHwrMiscFlags |= hwrMiscFlagID3; +// if ((keyState & hwrEZPortDKbdCol3) == 0) GHwrMiscFlags |= hwrMiscFlagID4; + + UInt8 keyState = ~0; + + if ((miscFlags & hwrMiscFlagID1) != 0) keyState &= ~hwrEZPortDKbdCol0; + if ((miscFlags & hwrMiscFlagID2) != 0) keyState &= ~hwrEZPortDKbdCol1; + if ((miscFlags & hwrMiscFlagID3) != 0) keyState &= ~hwrEZPortDKbdCol2; + if ((miscFlags & hwrMiscFlagID4) != 0) keyState &= ~hwrEZPortDKbdCol3; + + return keyState; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::UARTStateChanged +// --------------------------------------------------------------------------- + +void EmRegsEZ::UARTStateChanged (Bool sendTxData) +{ + EmUARTDragonball::State state (EmUARTDragonball::kUART_DragonballEZ); + + EmRegsEZ::MarshalUARTState (state); + fUART->StateChanged (state, sendTxData); + EmRegsEZ::UnmarshalUARTState (state); + + EmRegsEZ::UpdateUARTInterrupts (state); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::UpdateUARTState +// --------------------------------------------------------------------------- + +void EmRegsEZ::UpdateUARTState (Bool refreshRxData) +{ + EmUARTDragonball::State state (EmUARTDragonball::kUART_DragonballEZ); + + EmRegsEZ::MarshalUARTState (state); + fUART->UpdateState (state, refreshRxData); + EmRegsEZ::UnmarshalUARTState (state); + + EmRegsEZ::UpdateUARTInterrupts (state); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::UpdateUARTInterrupts +// --------------------------------------------------------------------------- + +void EmRegsEZ::UpdateUARTInterrupts (const EmUARTDragonball::State& state) +{ + // Generate the appropriate interrupts. + + if (state.RX_FULL_ENABLE && state.RX_FIFO_FULL || + state.RX_HALF_ENABLE && state.RX_FIFO_HALF || + state.RX_RDY_ENABLE && state.DATA_READY || + state.TX_EMPTY_ENABLE && state.TX_FIFO_EMPTY || + state.TX_HALF_ENABLE && state.TX_FIFO_HALF || + state.TX_AVAIL_ENABLE && state.TX_AVAIL) + { + // Set the UART interrupt. + + WRITE_REGISTER (intPendingLo, READ_REGISTER (intPendingLo) | hwrEZ328IntLoUART); + } + else + { + // Clear the UART interrupt. + + WRITE_REGISTER (intPendingLo, READ_REGISTER (intPendingLo) & ~hwrEZ328IntLoUART); + } + + // Respond to the new interrupt state. + + EmRegsEZ::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::MarshalUARTState +// --------------------------------------------------------------------------- + +void EmRegsEZ::MarshalUARTState (EmUARTDragonball::State& state) +{ + uint16 uControl = READ_REGISTER (uControl); + uint16 uBaud = READ_REGISTER (uBaud); + uint16 uReceive = READ_REGISTER (uReceive); + uint16 uTransmit = READ_REGISTER (uTransmit); + uint16 uMisc = READ_REGISTER (uMisc); + + state.UART_ENABLE = (uControl & hwrEZ328UControlUARTEnable) != 0; + state.RX_ENABLE = (uControl & hwrEZ328UControlRxEnable) != 0; + state.TX_ENABLE = (uControl & hwrEZ328UControlTxEnable) != 0; + state.RX_CLK_CONT = (uControl & hwrEZ328UControlRxClock1xSync) != 0; + state.PARITY_EN = (uControl & hwrEZ328UControlParityEn) != 0; + state.ODD_EVEN = (uControl & hwrEZ328UControlParityOdd) != 0; + state.STOP_BITS = (uControl & hwrEZ328UControlStopBits2) != 0; + state.CHAR8_7 = (uControl & hwrEZ328UControlDataBits8) != 0; +// state.GPIO_DELTA_ENABLE = (uControl & hwr328UControlGPIODeltaEn) != 0; // 68328 only + state.OLD_ENABLE = (uControl & hwrEZ328UControlOldDataEn) != 0; // 68EZ328 only + state.CTS_DELTA_ENABLE = (uControl & hwrEZ328UControlCTSDeltaEn) != 0; + state.RX_FULL_ENABLE = (uControl & hwrEZ328UControlRxFullEn) != 0; + state.RX_HALF_ENABLE = (uControl & hwrEZ328UControlRxHalfEn) != 0; + state.RX_RDY_ENABLE = (uControl & hwrEZ328UControlRxRdyEn) != 0; + state.TX_EMPTY_ENABLE = (uControl & hwrEZ328UControlTxEmptyEn) != 0; + state.TX_HALF_ENABLE = (uControl & hwrEZ328UControlTxHalfEn) != 0; + state.TX_AVAIL_ENABLE = (uControl & hwrEZ328UControlTxAvailEn) != 0; + + // Baud control register bits + // These are all values the user sets; we just look at them. + +// state.GPIO_DELTA = (uBaud & hwr328UBaudGPIODelta) != 0; // 68328 only +// state.GPIO = (uBaud & hwr328UBaudGPIOData) != 0; // 68328 only +// state.GPIO_DIR = (uBaud & hwr328UBaudGPIODirOut) != 0; // 68328 only +// state.GPIO_SRC = (uBaud & hwrEZ328UBaudGPIOSrcBaudGen) != 0; // 68328 only + state.UCLK_DIR = (uBaud & hwrEZ328UBaudUCLKDirOut) != 0; // 68EZ328 only + state.BAUD_SRC = (uBaud & hwrEZ328UBaudBaudSrcUCLK) != 0; + state.DIVIDE = (uBaud & hwrEZ328UBaudDivider) >> hwrEZ328UBaudDivideBitOffset; + state.PRESCALER = (uBaud & hwrEZ328UBaudPrescaler); + + // Receive register bits + // These are all input bits; we set them, not the user. + + state.RX_FIFO_FULL = (uReceive & hwrEZ328UReceiveFIFOFull) != 0; + state.RX_FIFO_HALF = (uReceive & hwrEZ328UReceiveFIFOHalf) != 0; + state.DATA_READY = (uReceive & hwrEZ328UReceiveDataRdy) != 0; + state.OLD_DATA = (uReceive & hwrEZ328UReceiveOldData) != 0; // 68EZ328 only + state.OVRUN = (uReceive & hwrEZ328UReceiveOverrunErr) != 0; + state.FRAME_ERROR = (uReceive & hwrEZ328UReceiveFrameErr) != 0; + state.BREAK = (uReceive & hwrEZ328UReceiveBreakErr) != 0; + state.PARITY_ERROR = (uReceive & hwrEZ328UReceiveParityErr) != 0; + state.RX_DATA = (uReceive & hwrEZ328UReceiveData); + + // Transmitter register bits + // We set everything except TX_DATA; the user sets that + // value and ONLY that value. + + state.TX_FIFO_EMPTY = (uTransmit & hwrEZ328UTransmitFIFOEmpty) != 0; + state.TX_FIFO_HALF = (uTransmit & hwrEZ328UTransmitFIFOHalf) != 0; + state.TX_AVAIL = (uTransmit & hwrEZ328UTransmitTxAvail) != 0; + state.SEND_BREAK = (uTransmit & hwrEZ328UTransmitSendBreak) != 0; + state.IGNORE_CTS = (uTransmit & hwrEZ328UTransmitIgnoreCTS) != 0; + state.BUSY = (uTransmit & hwrEZ328UTransmitBusy) != 0; // 68EZ328 only + state.CTS_STATUS = (uTransmit & hwrEZ328UTransmitCTSStatus) != 0; + state.CTS_DELTA = (uTransmit & hwrEZ328UTransmitCTSDelta) != 0; + state.TX_DATA = (uTransmit & hwrEZ328UTransmitData); + + // Misc register bits + // These are all values the user sets; we just look at them. + + state.BAUD_TEST = (uMisc & hwrEZ328UMiscBaudTest) != 0; // 68EZ328 only + state.CLK_SRC = (uMisc & hwrEZ328UMiscClkSrcUCLK) != 0; + state.FORCE_PERR = (uMisc & hwrEZ328UMiscForceParityErr) != 0; + state.LOOP = (uMisc & hwrEZ328UMiscLoopback) != 0; + state.BAUD_RESET = (uMisc & hwrEZ328UMiscBaudReset) != 0; // 68EZ328 only + state.IR_TEST = (uMisc & hwrEZ328UMiscIRTestEn) != 0; // 68EZ328 only + state.RTS_CONT = (uMisc & hwrEZ328UMiscRTSThruFIFO) != 0; + state.RTS = (uMisc & hwrEZ328UMiscRTSOut) != 0; + state.IRDA_ENABLE = (uMisc & hwrEZ328UMiscIRDAEn) != 0; + state.IRDA_LOOP = (uMisc & hwrEZ328UMiscLoopIRDA) != 0; + state.RX_POL = (uMisc & hwrEZ328UMiscRXPolarityInv) != 0; // 68EZ328 only + state.TX_POL = (uMisc & hwrEZ328UMiscTXPolarityInv) != 0; // 68EZ328 only +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::UnmarshalUARTState +// --------------------------------------------------------------------------- + +void EmRegsEZ::UnmarshalUARTState (const EmUARTDragonball::State& state) +{ + uint16 uControl = 0; + uint16 uBaud = 0; + uint16 uReceive = 0; + uint16 uTransmit = 0; + uint16 uMisc = 0; + + if (state.UART_ENABLE) uControl |= hwrEZ328UControlUARTEnable; + if (state.RX_ENABLE) uControl |= hwrEZ328UControlRxEnable; + if (state.TX_ENABLE) uControl |= hwrEZ328UControlTxEnable; + if (state.RX_CLK_CONT) uControl |= hwrEZ328UControlRxClock1xSync; + if (state.PARITY_EN) uControl |= hwrEZ328UControlParityEn; + if (state.ODD_EVEN) uControl |= hwrEZ328UControlParityOdd; + if (state.STOP_BITS) uControl |= hwrEZ328UControlStopBits2; + if (state.CHAR8_7) uControl |= hwrEZ328UControlDataBits8; +// if (state.GPIO_DELTA_ENABLE)uControl |= hwr328UControlGPIODeltaEn; // 68328 only + if (state.OLD_ENABLE) uControl |= hwrEZ328UControlOldDataEn; // 68EZ328 only + if (state.CTS_DELTA_ENABLE) uControl |= hwrEZ328UControlCTSDeltaEn; + if (state.RX_FULL_ENABLE) uControl |= hwrEZ328UControlRxFullEn; + if (state.RX_HALF_ENABLE) uControl |= hwrEZ328UControlRxHalfEn; + if (state.RX_RDY_ENABLE) uControl |= hwrEZ328UControlRxRdyEn; + if (state.TX_EMPTY_ENABLE) uControl |= hwrEZ328UControlTxEmptyEn; + if (state.TX_HALF_ENABLE) uControl |= hwrEZ328UControlTxHalfEn; + if (state.TX_AVAIL_ENABLE) uControl |= hwrEZ328UControlTxAvailEn; + + // Baud control register bits + // These are all values the user sets; we just look at them. + +// if (state.GPIO_DELTA) uBaud |= hwr328UBaudGPIODelta; // 68328 only +// if (state.GPIO) uBaud |= hwr328UBaudGPIOData; // 68328 only +// if (state.GPIO_DIR) uBaud |= hwr328UBaudGPIODirOut; // 68328 only +// if (state.GPIO_SRC) uBaud |= hwr328UBaudGPIOSrcBaudGen; // 68328 only + if (state.UCLK_DIR) uBaud |= hwrEZ328UBaudUCLKDirOut; // 68EZ328 only + if (state.BAUD_SRC) uBaud |= hwrEZ328UBaudBaudSrcUCLK; + + uBaud |= (state.DIVIDE << hwrEZ328UBaudDivideBitOffset) & hwrEZ328UBaudDivider; + uBaud |= (state.PRESCALER) & hwrEZ328UBaudPrescaler; + + // Receive register bits + // These are all input bits; we set them, not the user. + + if (state.RX_FIFO_FULL) uReceive |= hwrEZ328UReceiveFIFOFull; + if (state.RX_FIFO_HALF) uReceive |= hwrEZ328UReceiveFIFOHalf; + if (state.DATA_READY) uReceive |= hwrEZ328UReceiveDataRdy; + if (state.OLD_DATA) uReceive |= hwrEZ328UReceiveOldData; // 68EZ328 only + if (state.OVRUN) uReceive |= hwrEZ328UReceiveOverrunErr; + if (state.FRAME_ERROR) uReceive |= hwrEZ328UReceiveFrameErr; + if (state.BREAK) uReceive |= hwrEZ328UReceiveBreakErr; + if (state.PARITY_ERROR) uReceive |= hwrEZ328UReceiveParityErr; + + uReceive |= (state.RX_DATA) & hwrEZ328UReceiveData; + + // Transmitter register bits + // We set everything except TX_DATA; the user sets that + // value and ONLY that value. + + if (state.TX_FIFO_EMPTY) uTransmit |= hwrEZ328UTransmitFIFOEmpty; + if (state.TX_FIFO_HALF) uTransmit |= hwrEZ328UTransmitFIFOHalf; + if (state.TX_AVAIL) uTransmit |= hwrEZ328UTransmitTxAvail; + if (state.SEND_BREAK) uTransmit |= hwrEZ328UTransmitSendBreak; + if (state.IGNORE_CTS) uTransmit |= hwrEZ328UTransmitIgnoreCTS; + if (state.BUSY) uTransmit |= hwrEZ328UTransmitBusy; // 68EZ328 only + if (state.CTS_STATUS) uTransmit |= hwrEZ328UTransmitCTSStatus; + if (state.CTS_DELTA) uTransmit |= hwrEZ328UTransmitCTSDelta; + + uTransmit |= (state.TX_DATA) & hwrEZ328UTransmitData; + + // Misc register bits + // These are all values the user sets; we just look at them. + + if (state.BAUD_TEST) uMisc |= hwrEZ328UMiscBaudTest; // 68EZ328 only + if (state.CLK_SRC) uMisc |= hwrEZ328UMiscClkSrcUCLK; + if (state.FORCE_PERR) uMisc |= hwrEZ328UMiscForceParityErr; + if (state.LOOP) uMisc |= hwrEZ328UMiscLoopback; + if (state.BAUD_RESET) uMisc |= hwrEZ328UMiscBaudReset; // 68EZ328 only + if (state.IR_TEST) uMisc |= hwrEZ328UMiscIRTestEn; // 68EZ328 only + if (state.RTS_CONT) uMisc |= hwrEZ328UMiscRTSThruFIFO; + if (state.RTS) uMisc |= hwrEZ328UMiscRTSOut; + if (state.IRDA_ENABLE) uMisc |= hwrEZ328UMiscIRDAEn; + if (state.IRDA_LOOP) uMisc |= hwrEZ328UMiscLoopIRDA; + if (state.RX_POL) uMisc |= hwrEZ328UMiscRXPolarityInv; // 68EZ328 only + if (state.TX_POL) uMisc |= hwrEZ328UMiscTXPolarityInv; // 68EZ328 only + + WRITE_REGISTER (uControl, uControl); + WRITE_REGISTER (uBaud, uBaud); + WRITE_REGISTER (uReceive, uReceive); + WRITE_REGISTER (uTransmit, uTransmit); + WRITE_REGISTER (uMisc, uMisc); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::GetPort +// --------------------------------------------------------------------------- +// Given an address, return a value indicating what port it is associated with. + +int EmRegsEZ::GetPort (emuptr address) +{ + const long MASK = 0x00000FF8; + + switch (address & MASK) + { + case 0x0400: return 'A'; + case 0x0408: return 'B'; + case 0x0410: return 'C'; + case 0x0418: return 'D'; + case 0x0420: return 'E'; + case 0x0428: return 'F'; + case 0x0430: return 'G'; + } + + EmAssert (false); + return 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZ::PrvGetPalette +// --------------------------------------------------------------------------- + +void EmRegsEZ::PrvGetPalette (RGBList& thePalette) +{ + // !!! TBD + Preference<RGBType> pref1 (kPrefKeyBackgroundColor); + Preference<RGBType> pref2 (kPrefKeyHighlightColor); + + RGBType foreground (0, 0, 0); + RGBType background; + + if (this->GetLCDBacklightOn ()) + { + if (pref2.Loaded ()) + background = *pref2; + else + background = ::SkinGetHighlightColor (); + } + else + { + if (pref1.Loaded ()) + background = *pref1; + else + background = ::SkinGetBackgroundColor (); + } + + long br = ((long) background.fRed); + long bg = ((long) background.fGreen); + long bb = ((long) background.fBlue); + + long dr = ((long) foreground.fRed) - ((long) background.fRed); + long dg = ((long) foreground.fGreen) - ((long) background.fGreen); + long db = ((long) foreground.fBlue) - ((long) background.fBlue); + + int32 bpp = 1 << (READ_REGISTER (lcdPanelControl) & 0x03); + int32 numColors = 1 << bpp; + thePalette.resize (numColors); + + for (int color = 0; color < numColors; ++color) + { + thePalette[color].fRed = (UInt8) (br + dr * color / (numColors - 1)); + thePalette[color].fGreen = (UInt8) (bg + dg * color / (numColors - 1)); + thePalette[color].fBlue = (UInt8) (bb + db * color / (numColors - 1)); + } +} diff --git a/SrcShared/Hardware/EmRegsEZ.h b/SrcShared/Hardware/EmRegsEZ.h new file mode 100644 index 0000000..d9c69b2 --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZ.h @@ -0,0 +1,143 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsEZ_h +#define EmRegsEZ_h + +#include "EmHAL.h" // EmHALHandler +#include "EmRegs.h" // EmRegs +#include "EmStructs.h" // RGBList +#include "EmUARTDragonball.h" // EmUARTDragonball::State + +class EmScreenUpdateInfo; +class EmSPISlave; + + +class EmRegsEZ : public EmRegs, public EmHALHandler +{ + public: + EmRegsEZ (void); + virtual ~EmRegsEZ (void); + + // EmRegs overrides + virtual void Initialize (void); + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + virtual void Dispose (void); + + virtual void SetSubBankHandlers (void); + virtual uint8* GetRealAddress (emuptr address); + virtual emuptr GetAddressStart (void); + virtual uint32 GetAddressRange (void); + + // EmHALHandler overrides + virtual void Cycle (Bool sleeping); + virtual void CycleSlowly (Bool sleeping); + + virtual void ButtonEvent (SkinElementType, Bool buttonIsDown); + virtual void TurnSoundOff (void); + virtual void ResetTimer (void); + virtual void ResetRTC (void); + + virtual int32 GetInterruptLevel (void); + virtual int32 GetInterruptBase (void); + + virtual Bool GetLCDScreenOn (void) = 0; + virtual Bool GetLCDBacklightOn (void) = 0; + virtual Bool GetLCDHasFrame (void); + virtual void GetLCDBeginEnd (emuptr&, emuptr&); + virtual void GetLCDScanlines (EmScreenUpdateInfo& info); + + virtual EmUARTDeviceType GetUARTDevice (int uartNum); + virtual int32 GetDynamicHeapSize (void); + virtual int32 GetROMSize (void); + virtual emuptr GetROMBaseAddress (void); + virtual Bool ChipSelectsConfigured (void); + virtual int32 GetSystemClockFrequency (void); + virtual Bool GetCanStop (void); + virtual Bool GetAsleep (void); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void PortDataChanged (int, uint8, uint8); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) = 0; + + protected: + uint32 pllFreqSelRead (emuptr address, int size); + uint32 portXDataRead (emuptr address, int size); + uint32 tmr1StatusRead (emuptr address, int size); + uint32 uartRead (emuptr address, int size); + uint32 rtcHourMinSecRead (emuptr address, int size); + + void csASelectWrite (emuptr address, int size, uint32 value); + void csDSelectWrite (emuptr address, int size, uint32 value); + void intMaskHiWrite (emuptr address, int size, uint32 value); + void intMaskLoWrite (emuptr address, int size, uint32 value); + void intStatusHiWrite (emuptr address, int size, uint32 value); + void portXDataWrite (emuptr address, int size, uint32 value); + void portDIntReqEnWrite (emuptr address, int size, uint32 value); + void tmr1StatusWrite (emuptr address, int size, uint32 value); + void spiMasterControlWrite (emuptr address, int size, uint32 value); + void uartWrite (emuptr address, int size, uint32 value); + void lcdRegisterWrite (emuptr address, int size, uint32 value); + void rtcControlWrite (emuptr address, int size, uint32 value); + void rtcIntStatusWrite (emuptr address, int size, uint32 value); + void rtcIntEnableWrite (emuptr address, int size, uint32 value); + + protected: + void HotSyncEvent (Bool buttonIsDown); + + virtual uint8 GetKeyBits (void); + virtual uint16 ButtonToBits (SkinElementType); + virtual EmSPISlave* GetSPISlave (void); + + protected: + void UpdateInterrupts (void); + void UpdatePortDInterrupts (void); + void UpdateRTCInterrupts (void); + + protected: + Bool IDDetectAsserted (void); + UInt8 GetHardwareID (void); + + protected: + void UARTStateChanged (Bool sendTxData); + void UpdateUARTState (Bool refreshRxData); + void UpdateUARTInterrupts (const EmUARTDragonball::State& state); + void MarshalUARTState (EmUARTDragonball::State& state); + void UnmarshalUARTState (const EmUARTDragonball::State& state); + + protected: + int GetPort (emuptr address); + void PrvGetPalette (RGBList& thePalette); + + protected: + HwrM68EZ328Type f68EZ328Regs; + bool fHotSyncButtonDown; + uint16 fKeyBits; + uint16 fLastTmr1Status; + uint8 fPortDEdge; + uint32 fPortDDataCount; + + uint32 fHour; + uint32 fMin; + uint32 fSec; + uint32 fTick; + uint32 fCycle; + + EmUARTDragonball* fUART; +}; + +#endif /* EmRegsEZ_h */ diff --git a/SrcShared/Hardware/EmRegsEZPalmIIIc.cpp b/SrcShared/Hardware/EmRegsEZPalmIIIc.cpp new file mode 100644 index 0000000..bc4744e --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZPalmIIIc.cpp @@ -0,0 +1,222 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsEZPalmIIIc.h" +#include "EmRegsEZPrv.h" + +#include "EmSPISlaveADS784x.h" // EmSPISlaveADS784x + +#include "PalmPack.h" +#define NON_PORTABLE + #include "EZAustin/IncsPrv/HardwareAustin.h" // hwrEZPortCKbdRow0, hwrEZPortBRS232Enable, etc. +#undef NON_PORTABLE +#include "PalmPackPop.h" + +const int kNumButtonRows = 3; +const int kNumButtonCols = 4; + +const uint16 kButtonMap[kNumButtonRows][kNumButtonCols] = +{ + { keyBitHard1, keyBitHard2, keyBitHard3, keyBitHard4 }, + { keyBitPageUp, keyBitPageDown, 0, 0 }, + { keyBitPower, keyBitContrast, keyBitHard2, 0 } +}; + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmIIIc::EmRegsEZPalmIIIc +// --------------------------------------------------------------------------- + +EmRegsEZPalmIIIc::EmRegsEZPalmIIIc (void) : + EmRegsEZ (), + fSPISlaveADC (new EmSPISlaveADS784x (kChannelSet2)) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmIIIc::~EmRegsEZPalmIIIc +// --------------------------------------------------------------------------- + +EmRegsEZPalmIIIc::~EmRegsEZPalmIIIc (void) +{ + delete fSPISlaveADC; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmIIIc::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsEZPalmIIIc::GetLCDScreenOn (void) +{ + // Override the Dragonball version and let the SED 1375 handle it. + + return EmHALHandler::GetLCDScreenOn (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmIIIc::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsEZPalmIIIc::GetLCDBacklightOn (void) +{ + // Override the Dragonball version and let the SED 1375 handle it. + + return EmHALHandler::GetLCDBacklightOn (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmIIIc::GetLCDHasFrame +// --------------------------------------------------------------------------- + +Bool EmRegsEZPalmIIIc::GetLCDHasFrame (void) +{ + // Override the Dragonball version and let the SED 1375 handle it. + + return EmHALHandler::GetLCDHasFrame (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmIIIc::GetLCDBeginEnd +// --------------------------------------------------------------------------- + +void EmRegsEZPalmIIIc::GetLCDBeginEnd (emuptr& begin, emuptr& end) +{ + // Override the Dragonball version and let the SED 1375 handle it. + + EmHALHandler::GetLCDBeginEnd (begin, end); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmIIIc::GetLCDScanlines +// --------------------------------------------------------------------------- + +void EmRegsEZPalmIIIc::GetLCDScanlines (EmScreenUpdateInfo& info) +{ + // Override the Dragonball version and let the SED 1375 handle it. + + EmHALHandler::GetLCDScanlines (info); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmIIIc::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmRegsEZPalmIIIc::GetLineDriverState (EmUARTDeviceType type) +{ + if (type == kUARTSerial) + return (READ_REGISTER (portBData) & hwrEZPortBRS232Enable) != 0; + + if (type == kUARTIR) + return (READ_REGISTER (portGData) & hwrEZPortGIRShutdown) == 0; + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmIIIc::GetPortInputValue +// --------------------------------------------------------------------------- +// Return the GPIO values for the pins on the port. These values are used +// if the select pins are high. + +uint8 EmRegsEZPalmIIIc::GetPortInputValue (int port) +{ + uint8 result = EmRegsEZ::GetPortInputValue (port); + + if (port == 'F') + { + // Ensure that bit hwrEZPortFIXTRNL2 is set. If it's clear, HotSync + // will sync via the modem instead of the serial port. + + // Make sure hwrEZPortFLCDPowered is always set, or HwrDisplayWake will hang + + result |= hwrEZPortFIXTRNL2 | hwrEZPortFLCDPowered; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmIIIc::GetPortInternalValue +// --------------------------------------------------------------------------- +// Return the dedicated values for the pins on the port. These values are +// used if the select pins are low. + +uint8 EmRegsEZPalmIIIc::GetPortInternalValue (int port) +{ + uint8 result = EmRegsEZ::GetPortInternalValue (port); + + if (port == 'D') + { + // Make sure that hwrEZPortDPowerFail is set. If it's clear, + // the battery code will make the device go to sleep immediately. + + result |= hwrEZPortDPowerFail; + + // Make sure hwrEZPortDAdapterInstalled is set, or the dock-status routines + // will report that we're powered (even if we aren't docked!). + + result |= hwrEZPortDAdapterInstalled; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmIIIc::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmRegsEZPalmIIIc::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ + *numRows = kNumButtonRows; + *numCols = kNumButtonCols; + + memcpy (keyMap, kButtonMap, sizeof (kButtonMap)); + + // Determine what row is being asked for. + + UInt8 portCDir = READ_REGISTER (portCDir); + UInt8 portCData = READ_REGISTER (portCData); + + rows[0] = (portCDir & hwrEZPortCKbdRow0) != 0 && (portCData & hwrEZPortCKbdRow0) == 0; + rows[1] = (portCDir & hwrEZPortCKbdRow1) != 0 && (portCData & hwrEZPortCKbdRow1) == 0; + rows[2] = (portCDir & hwrEZPortCKbdRow2) != 0 && (portCData & hwrEZPortCKbdRow2) == 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmIIIc::GetSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave* EmRegsEZPalmIIIc::GetSPISlave (void) +{ + if ((READ_REGISTER (portBData) & hwrEZPortBCS_ADC) == 0) + { + return fSPISlaveADC; + } + + return NULL; +} diff --git a/SrcShared/Hardware/EmRegsEZPalmIIIc.h b/SrcShared/Hardware/EmRegsEZPalmIIIc.h new file mode 100644 index 0000000..704f8a0 --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZPalmIIIc.h @@ -0,0 +1,48 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsEZPalmIIIc_h +#define EmRegsEZPalmIIIc_h + +#include "EmRegsEZ.h" + +class EmScreenUpdateInfo; + + +class EmRegsEZPalmIIIc : public EmRegsEZ +{ + public: + EmRegsEZPalmIIIc (void); + virtual ~EmRegsEZPalmIIIc (void); + + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLCDHasFrame (void); + virtual void GetLCDBeginEnd (emuptr&, emuptr&); + virtual void GetLCDScanlines (EmScreenUpdateInfo& info); + + virtual Bool GetLineDriverState (EmUARTDeviceType type); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); + + protected: + virtual EmSPISlave* GetSPISlave (void); + + private: + EmSPISlave* fSPISlaveADC; +}; + +#endif /* EmRegsEZPalmIIIc_h */ diff --git a/SrcShared/Hardware/EmRegsEZPalmIIIe.h b/SrcShared/Hardware/EmRegsEZPalmIIIe.h new file mode 100644 index 0000000..a0f356d --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZPalmIIIe.h @@ -0,0 +1,21 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsEZPalmIIIe_h +#define EmRegsEZPalmIIIe_h + +#include "EmRegsEZPalmV.h" + +typedef EmRegsEZPalmV EmRegsEZPalmIIIe; + +#endif /* EmRegsEZPalmIIIe_h */ diff --git a/SrcShared/Hardware/EmRegsEZPalmIIIx.h b/SrcShared/Hardware/EmRegsEZPalmIIIx.h new file mode 100644 index 0000000..7ab02de --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZPalmIIIx.h @@ -0,0 +1,21 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsEZPalmIIIx_h +#define EmRegsEZPalmIIIx_h + +#include "EmRegsEZPalmV.h" + +typedef EmRegsEZPalmV EmRegsEZPalmIIIx; + +#endif /* EmRegsEZPalmIIIx_h */ diff --git a/SrcShared/Hardware/EmRegsEZPalmM100.cpp b/SrcShared/Hardware/EmRegsEZPalmM100.cpp new file mode 100644 index 0000000..684d0ee --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZPalmM100.cpp @@ -0,0 +1,247 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsEZPalmM100.h" +#include "EmRegsEZPrv.h" + +#include "EmSession.h" // GetDevice +#include "EmSPISlaveADS784x.h" // EmSPISlaveADS784x + + +// The following are taken from the m100 version of HardwareEZ.h. + +/************************************************************************ + * Port B Bit settings + ************************************************************************/ +#define hwrEZPortBKbdRow0 0x01 +#define hwrEZPortBLCDVccOff 0x02 // (L) LCD Vcc On +#define hwrEZPortBKbdRow1 0x08 +#define hwrEZPortBKbdRow2 0x40 +#define hwrEZPortBKbdRows 0x49 + +#define hwrEZPortBLCDAdjOn 0x40 // (L) LCD Contrast Adjust On (Brad Rev 0) + + +/************************************************************************ + * Port C Bit settings + ************************************************************************/ +#define hwrEZPortCLCDEnableOn 0x80 // (H) LCD Enable + + +/************************************************************************ + * Port D Bit settings + ************************************************************************/ +#define hwrEZPortDKbdCol0 0x01 // (H) Keyboard Column 0 (aka INT0) +#define hwrEZPortDKbdCol1 0x02 // (H) Keyboard Column 1 (aka INT1) +#define hwrEZPortDKbdCol2 0x04 // (H) Keyboard Column 2 (aka INT2) +#define hwrEZPortDKbdCol3 0x08 // (H) Keyboard Column 3 (aka INT3) +#define hwrEZPortDKeyBits 0x0F // (H) All Keyboard Columns +#define hwrEZPortDDockButton 0x10 // (L) Dock Button (aka IRQ1) (edge, negative) +#define hwrEZPortD232Enable 0x20 // (L) Serial Shutdown on Sumo Rev 1 (aka IRQ2) +#define hwrEZPortDLCDBiasOn 0x40 // (H) LCD Bias on +#define hwrEZPortDPowerFail 0x80 // (L) Power Fail Interrupt (aka IRQ6) (level, low) + +#define hwrEZPortDDataMaskBeforeWrite (~(hwrEZPortDKeyBits)) // Don't write ones to these bits! +#define hwrEZPortDKeyOffset 0x0 // bits to shift to put Col 0 in msb + + +/************************************************************************ + * Port E Bit settings + ************************************************************************/ +#define hwrEZPortESpiTxD 0x01 // (L) SPI TXD (Internal) +#define hwrEZPortESpiRxD 0x02 // (L) SPI RXD (Internal) +#define hwrEZPortESpiClk 0x04 // SPI Clock +#define hwrEZPortESpiBits 0x07 // all the SPI bits +#define hwrEZPortERXD 0x10 // external RXD +#define hwrEZPortETXD 0x20 // external TXD +#define hwrEZPortECTS 0x80 // external CTS + +/************************************************************************ + * Port F Bit settings + ************************************************************************/ +#define hwrEZPortFLCDBiasData 0x01 // LCD Bias data +#define hwrEZPortFPenIO 0x02 // (L) Pen Interrupt,Pen I/O +#define hwrEZPortFLCDBiasStrb 0x04 // LCD Bias strobe +#define hwrEZPortFBacklightOn 0x20 // (H) Backlight on +#define hwrEZPortFLCDDispOn 0x40 // (H) LCD display on +#define hwrEZPortFLCDBiasClk 0x80 // LCD Bias clock + +#define hwrEZPortFLCDAdjOn 0x01 // (L) LCD Contrast Adjust On (Brad Rev 1) +#define hwrEZPortF232Enable 0x04 // (L) Shutdown Serial +#define hwrEZPortFContrastPWM 0x01 // (L) PWM output for LCD contrast + + +/************************************************************************ + * Port G Bit settings + ************************************************************************/ +#define hwrEZPortGDTACK 0x01 // (L) DTACK +#define hwrEZPortGFree1 0x02 // (-) FREE5 +#define hwrEZPortGIDDetect 0x04 // (L) ID select (drives kbd) +#define hwrEZPortGLiIonVoltReadDis 0x08 // (L) Enable A/D Voltage Divider +#define hwrEZPortGIRShutdown 0x10 // (H) Shutdown IRDA +#define hwrEZPortGADCOff 0x20 // (L) A/D Select + + +const int kNumButtonRows = 3; +const int kNumButtonCols = 4; + +const uint16 kButtonMap[kNumButtonRows][kNumButtonCols] = +{ + { keyBitHard1, keyBitHard2, keyBitHard3, keyBitHard4 }, + { 0, keyBitPageDown, 0, 0 }, + { keyBitPower, keyBitPageUp, keyBitHard2, 0 } +}; + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmM100::EmRegsEZPalmM100 +// --------------------------------------------------------------------------- + +EmRegsEZPalmM100::EmRegsEZPalmM100 (void) : + EmRegsEZ (), + fSPISlaveADC (new EmSPISlaveADS784x (kChannelSet2)) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmM100::~EmRegsEZPalmM100 +// --------------------------------------------------------------------------- + +EmRegsEZPalmM100::~EmRegsEZPalmM100 (void) +{ + delete fSPISlaveADC; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmM100::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsEZPalmM100::GetLCDScreenOn (void) +{ + return (READ_REGISTER (portFData) & hwrEZPortFLCDDispOn) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmM100::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsEZPalmM100::GetLCDBacklightOn (void) +{ + return (READ_REGISTER (portFData) & hwrEZPortFBacklightOn) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmM100::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmRegsEZPalmM100::GetLineDriverState (EmUARTDeviceType type) +{ + if (type == kUARTSerial) + return (READ_REGISTER (portDData) & hwrEZPortD232Enable) != 0; + + if (type == kUARTIR) + return (READ_REGISTER (portGData) & hwrEZPortGIRShutdown) == 0; + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmM100::GetPortInputValue +// --------------------------------------------------------------------------- +// Return the GPIO values for the pins on the port. These values are used +// if the select pins are high. + +uint8 EmRegsEZPalmM100::GetPortInputValue (int port) +{ + uint8 result = EmRegsEZ::GetPortInputValue (port); + + if (port == 'E') + { + // Return the hardware sub-ID. + + EmAssert (gSession); + + EmDevice device = gSession->GetDevice (); + result |= ~device.HardwareSubID (); + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmM100::GetPortInternalValue +// --------------------------------------------------------------------------- +// Return the dedicated values for the pins on the port. These values are +// used if the select pins are low. + +uint8 EmRegsEZPalmM100::GetPortInternalValue (int port) +{ + uint8 result = EmRegsEZ::GetPortInternalValue (port); + + if (port == 'D') + { + // Make sure that hwrEZPortDPowerFail is set. If it's clear, + // the battery code will make the device go to sleep immediately. + + result |= hwrEZPortDPowerFail; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmM100::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmRegsEZPalmM100::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ + *numRows = kNumButtonRows; + *numCols = kNumButtonCols; + + memcpy (keyMap, kButtonMap, sizeof (kButtonMap)); + + // Determine what row is being asked for. + + UInt8 portBDir = READ_REGISTER (portBDir); + UInt8 portBData = READ_REGISTER (portBData); + + rows[0] = (portBDir & hwrEZPortBKbdRow0) != 0 && (portBData & hwrEZPortBKbdRow0) == 0; + rows[1] = (portBDir & hwrEZPortBKbdRow1) != 0 && (portBData & hwrEZPortBKbdRow1) == 0; + rows[2] = (portBDir & hwrEZPortBKbdRow2) != 0 && (portBData & hwrEZPortBKbdRow2) == 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmM100::GetSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave* EmRegsEZPalmM100::GetSPISlave (void) +{ + if ((READ_REGISTER (portGData) & hwrEZPortGADCOff) == 0) + { + return fSPISlaveADC; + } + + return NULL; +} diff --git a/SrcShared/Hardware/EmRegsEZPalmM100.h b/SrcShared/Hardware/EmRegsEZPalmM100.h new file mode 100644 index 0000000..6b32d36 --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZPalmM100.h @@ -0,0 +1,41 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsEZm100_h +#define EmRegsEZm100_h + +#include "EmRegsEZ.h" + +class EmRegsEZPalmM100 : public EmRegsEZ +{ + public: + EmRegsEZPalmM100 (void); + virtual ~EmRegsEZPalmM100 (void); + + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLineDriverState (EmUARTDeviceType type); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); + + protected: + virtual EmSPISlave* GetSPISlave (void); + + private: + EmSPISlave* fSPISlaveADC; +}; + +#endif /* EmRegsEZm100_h */ diff --git a/SrcShared/Hardware/EmRegsEZPalmV.cpp b/SrcShared/Hardware/EmRegsEZPalmV.cpp new file mode 100644 index 0000000..ad59040 --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZPalmV.cpp @@ -0,0 +1,179 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsEZPalmV.h" +#include "EmRegsEZPrv.h" + +#include "EmDevice.h" // HardwareSubID +#include "EmSession.h" // GetDevice +#include "EmSPISlaveADS784x.h" // EmSPISlaveADS784x + +#include "PalmPack.h" +#define NON_PORTABLE + #include "EZSumo/IncsPrv/HardwareEZ.h" // hwrEZPortCLCDEnableOn, etc. +#undef NON_PORTABLE +#include "PalmPackPop.h" + +const int kNumButtonRows = 3; +const int kNumButtonCols = 4; + +const uint16 kButtonMap[kNumButtonRows][kNumButtonCols] = +{ + { keyBitHard1, keyBitHard2, keyBitHard3, keyBitHard4 }, + { keyBitPageUp, keyBitPageDown, 0, 0 }, + { keyBitPower, keyBitContrast, keyBitHard2, 0 } +}; + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmV::EmRegsEZPalmV +// --------------------------------------------------------------------------- + +EmRegsEZPalmV::EmRegsEZPalmV (void) : + EmRegsEZ (), + fSPISlaveADC (new EmSPISlaveADS784x (kChannelSet2)) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmV::~EmRegsEZPalmV +// --------------------------------------------------------------------------- + +EmRegsEZPalmV::~EmRegsEZPalmV (void) +{ + delete fSPISlaveADC; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmV::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsEZPalmV::GetLCDScreenOn (void) +{ + return (READ_REGISTER (portCData) & hwrEZPortCLCDEnableOn) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmV::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsEZPalmV::GetLCDBacklightOn (void) +{ + return (READ_REGISTER (portFData) & hwrEZPortFBacklightOn) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmV::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmRegsEZPalmV::GetLineDriverState (EmUARTDeviceType type) +{ + if (type == kUARTSerial) + return (READ_REGISTER (portDData) & hwrEZPortD232Enable) != 0; + + if (type == kUARTIR) + return (READ_REGISTER (portGData) & hwrEZPortGIRShutdown) == 0; + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmV::GetPortInputValue +// --------------------------------------------------------------------------- +// Return the GPIO values for the pins on the port. These values are used +// if the select pins are high. + +uint8 EmRegsEZPalmV::GetPortInputValue (int port) +{ + uint8 result = EmRegsEZ::GetPortInputValue (port); + + if (port == 'E') + { + // Return the hardware sub-ID. + + EmAssert (gSession); + + EmDevice device = gSession->GetDevice (); + result |= ~device.HardwareSubID (); + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmV::GetPortInternalValue +// --------------------------------------------------------------------------- +// Return the dedicated values for the pins on the port. These values are +// used if the select pins are low. + +uint8 EmRegsEZPalmV::GetPortInternalValue (int port) +{ + uint8 result = EmRegsEZ::GetPortInternalValue (port); + + if (port == 'D') + { + // Make sure that hwrEZPortDPowerFail is set. If it's clear, + // the battery code will make the device go to sleep immediately. + + result |= hwrEZPortDPowerFail; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmV::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmRegsEZPalmV::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ + *numRows = kNumButtonRows; + *numCols = kNumButtonCols; + + memcpy (keyMap, kButtonMap, sizeof (kButtonMap)); + + // Determine what row is being asked for. + + UInt8 portFDir = READ_REGISTER (portFDir); + UInt8 portFData = READ_REGISTER (portFData); + + rows[0] = (portFDir & hwrEZPortFKbdRow0) != 0 && (portFData & hwrEZPortFKbdRow0) == 0; + rows[1] = (portFDir & hwrEZPortFKbdRow1) != 0 && (portFData & hwrEZPortFKbdRow1) == 0; + rows[2] = (portFDir & hwrEZPortFKbdRow2) != 0 && (portFData & hwrEZPortFKbdRow2) == 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmV::GetSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave* EmRegsEZPalmV::GetSPISlave (void) +{ + if ((READ_REGISTER (portGData) & hwrEZPortGADCOff) == 0) + { + return fSPISlaveADC; + } + + return NULL; +} diff --git a/SrcShared/Hardware/EmRegsEZPalmV.h b/SrcShared/Hardware/EmRegsEZPalmV.h new file mode 100644 index 0000000..16dc0e0 --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZPalmV.h @@ -0,0 +1,42 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsEZPalmV_h +#define EmRegsEZPalmV_h + +#include "EmRegsEZ.h" + + +class EmRegsEZPalmV : public EmRegsEZ +{ + public: + EmRegsEZPalmV (void); + virtual ~EmRegsEZPalmV (void); + + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLineDriverState (EmUARTDeviceType type); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); + + protected: + virtual EmSPISlave* GetSPISlave (void); + + private: + EmSPISlave* fSPISlaveADC; +}; + +#endif /* EmRegsEZPalmV_h */ diff --git a/SrcShared/Hardware/EmRegsEZPalmVII.cpp b/SrcShared/Hardware/EmRegsEZPalmVII.cpp new file mode 100644 index 0000000..edc6da7 --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZPalmVII.cpp @@ -0,0 +1,41 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsEZPalmVII.h" +#include "EmRegsEZPrv.h" + +#include "PalmPack.h" +#define NON_PORTABLE + #include "EZSumo/IncsPrv/HardwareEZ.h" // hwrEZPortGIRShutdown +#undef NON_PORTABLE +#include "PalmPackPop.h" + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmVII::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmRegsEZPalmVII::GetLineDriverState (EmUARTDeviceType type) +{ + if (type == kUARTSerial) + // Pass this on to the PLD handler. + return EmHALHandler::GetLineDriverState (type); + + if (type == kUARTIR) + return (READ_REGISTER (portGData) & hwrEZPortGIRShutdown) == 0; + + return false; +} diff --git a/SrcShared/Hardware/EmRegsEZPalmVII.h b/SrcShared/Hardware/EmRegsEZPalmVII.h new file mode 100644 index 0000000..d5a4386 --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZPalmVII.h @@ -0,0 +1,26 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsEZPalmVII_h +#define EmRegsEZPalmVII_h + +#include "EmRegsEZPalmV.h" + + +class EmRegsEZPalmVII : public EmRegsEZPalmV +{ + public: + virtual Bool GetLineDriverState (EmUARTDeviceType type); +}; + +#endif /* EmRegsEZPalmVII_h */ diff --git a/SrcShared/Hardware/EmRegsEZPalmVIIx.cpp b/SrcShared/Hardware/EmRegsEZPalmVIIx.cpp new file mode 100644 index 0000000..1659dcc --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZPalmVIIx.cpp @@ -0,0 +1,192 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsEZPalmVIIx.h" +#include "EmRegsEZPrv.h" + +#include "EmDevice.h" // HardwareSubID +#include "EmSession.h" // GetDevice +#include "EmSPISlaveADS784x.h" // EmSPISlaveADS784x + +#include "PalmPack.h" +#define NON_PORTABLE + #include "EZSumo/IncsPrv/HardwareEZ.h" // hwrEZPortCLCDEnableOn, etc. +#undef NON_PORTABLE +#include "PalmPackPop.h" + +// As near as I can tell, PalmVIIx uses the same hardware defs as +// a Sumo, but with this one bit difference. Actually, there are +// other Port F and G differences, but they aren't (currently) +// relevent to Poser. + +#undef hwrEZPortFKbdRow0 +#define hwrEZPortFKbdRow0 0x01 // (L) Keyboard Row 0 + + +const int kNumButtonRows = 3; +const int kNumButtonCols = 4; + + +// ============================== PalmVIIx ============================== + +const uint16 kButtonMap[kNumButtonRows][kNumButtonCols] = +{ + { keyBitHard1, keyBitHard2, keyBitHard3, keyBitHard4 }, + { keyBitPageUp, keyBitPageDown, 0, 0 }, + { keyBitPower, keyBitContrast, keyBitHard2, 0 } +}; + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmVIIx::EmRegsEZPalmVIIx +// --------------------------------------------------------------------------- + +EmRegsEZPalmVIIx::EmRegsEZPalmVIIx (void) : + EmRegsEZ (), + fSPISlaveADC (new EmSPISlaveADS784x (kChannelSet2)) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmVIIx::~EmRegsEZPalmVIIx +// --------------------------------------------------------------------------- + +EmRegsEZPalmVIIx::~EmRegsEZPalmVIIx (void) +{ + delete fSPISlaveADC; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmVIIx::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsEZPalmVIIx::GetLCDScreenOn (void) +{ + return (READ_REGISTER (portCData) & hwrEZPortCLCDEnableOn) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmVIIx::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsEZPalmVIIx::GetLCDBacklightOn (void) +{ + return (READ_REGISTER (portFData) & hwrEZPortFBacklightOn) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmVIIx::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmRegsEZPalmVIIx::GetLineDriverState (EmUARTDeviceType type) +{ + if (type == kUARTSerial) + // Pass this on to the PLD handler. + return EmHALHandler::GetLineDriverState (type); + + if (type == kUARTIR) + return (READ_REGISTER (portGData) & hwrEZPortGIRShutdown) == 0; + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmVIIx::GetPortInputValue +// --------------------------------------------------------------------------- +// Return the GPIO values for the pins on the port. These values are used +// if the select pins are high. + +uint8 EmRegsEZPalmVIIx::GetPortInputValue (int port) +{ + uint8 result = EmRegsEZ::GetPortInputValue (port); + + if (port == 'E') + { + // Return the hardware sub-ID. + + EmAssert (gSession); + + EmDevice device = gSession->GetDevice (); + result |= ~device.HardwareSubID (); + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmVIIx::GetPortInternalValue +// --------------------------------------------------------------------------- +// Return the dedicated values for the pins on the port. These values are +// used if the select pins are low. + +uint8 EmRegsEZPalmVIIx::GetPortInternalValue (int port) +{ + uint8 result = EmRegsEZ::GetPortInternalValue (port); + + if (port == 'D') + { + // Make sure that hwrEZPortDPowerFail is set. If it's clear, + // the battery code will make the device go to sleep immediately. + + result |= hwrEZPortDPowerFail; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmVIIx::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmRegsEZPalmVIIx::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ + *numRows = kNumButtonRows; + *numCols = kNumButtonCols; + + memcpy (keyMap, kButtonMap, sizeof (kButtonMap)); + + // Determine what row is being asked for. + + UInt8 portFDir = READ_REGISTER (portFDir); + UInt8 portFData = READ_REGISTER (portFData); + + rows[0] = (portFDir & hwrEZPortFKbdRow0) != 0 && (portFData & hwrEZPortFKbdRow0) == 0; + rows[1] = (portFDir & hwrEZPortFKbdRow1) != 0 && (portFData & hwrEZPortFKbdRow1) == 0; + rows[2] = (portFDir & hwrEZPortFKbdRow2) != 0 && (portFData & hwrEZPortFKbdRow2) == 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZPalmVIIx::GetSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave* EmRegsEZPalmVIIx::GetSPISlave (void) +{ + if ((READ_REGISTER (portGData) & hwrEZPortGADCOff) == 0) + { + return fSPISlaveADC; + } + + return NULL; +} diff --git a/SrcShared/Hardware/EmRegsEZPalmVIIx.h b/SrcShared/Hardware/EmRegsEZPalmVIIx.h new file mode 100644 index 0000000..57f8faa --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZPalmVIIx.h @@ -0,0 +1,41 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsEZPalmVIIx_h +#define EmRegsEZPalmVIIx_h + +#include "EmRegsEZ.h" + +class EmRegsEZPalmVIIx : public EmRegsEZ +{ + public: + EmRegsEZPalmVIIx (void); + virtual ~EmRegsEZPalmVIIx (void); + + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLineDriverState (EmUARTDeviceType type); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); + + protected: + virtual EmSPISlave* GetSPISlave (void); + + private: + EmSPISlave* fSPISlaveADC; +}; + +#endif /* EmRegsEZPalmVIIx_h */ diff --git a/SrcShared/Hardware/EmRegsEZPalmVx.h b/SrcShared/Hardware/EmRegsEZPalmVx.h new file mode 100644 index 0000000..b348bb3 --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZPalmVx.h @@ -0,0 +1,21 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsEZPalmVx_h +#define EmRegsEZPalmVx_h + +#include "EmRegsEZPalmV.h" + +typedef EmRegsEZPalmV EmRegsEZPalmVx; + +#endif /* EmRegsEZPalmVx_h */ diff --git a/SrcShared/Hardware/EmRegsEZPrv.h b/SrcShared/Hardware/EmRegsEZPrv.h new file mode 100644 index 0000000..660ea30 --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZPrv.h @@ -0,0 +1,45 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsEZPrv_h +#define EmRegsEZPrv_h + +#include "EmRegsPrv.h" + +// Location and range of registers + +const uint32 kMemoryStart = 0xFFFFF000; +const uint32 kMemorySize = sizeof (HwrM68EZ328Type); + + +// Macro to return the DragonballEZ address of the specified register + +#define addressof(x) (kMemoryStart + offsetof(HwrM68EZ328Type, x)) + + +// Macros for reading/writing DragonballEZ registers. + +#define READ_REGISTER(reg) \ + _get_reg (&f68EZ328Regs.reg) + +#define WRITE_REGISTER(reg, value) \ + _put_reg (&f68EZ328Regs.reg, value) + + +// Macro for installing DragonballEZ register handlers + +#define INSTALL_HANDLER(read, write, reg) \ + this->SetHandler ((ReadFunction) &EmRegsEZ::read, (WriteFunction) &EmRegsEZ::write, addressof (reg), sizeof (f68EZ328Regs.reg)) + + +#endif /* EmRegsEZPrv_h */ diff --git a/SrcShared/Hardware/EmRegsEZTRGpro.cpp b/SrcShared/Hardware/EmRegsEZTRGpro.cpp new file mode 100644 index 0000000..cd7926f --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZTRGpro.cpp @@ -0,0 +1,251 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +// This file provides emulation at the register level for TRG's +// TRGpro handheld computer, which uses the EZ processor + + +#include "EmCommon.h" +#include "EmRegsEZTRGpro.h" +#include "EmRegsEZPrv.h" + +#include "EmSPISlaveADS784x.h" // EmSPISlaveADS784x + +#include "PalmPack.h" +#define NON_PORTABLE + #include "EZSumo/IncsPrv/HardwareEZ.h" // hwrEZPortCLCDEnableOn, etc. +#undef NON_PORTABLE +#include "PalmPackPop.h" + +// TRGpro Defines +#define hwrEZPortDCFInit 0x40 +#define hwrEZPortGDO_LATCH 0x08 // SPI DO_LATCH enable +#define hwrEZPortBLCDVccOff 0x02 // LCD VCC off +#define hwrEZPortD232EnableTRGpro 0x20 // RS 232 enable + +const int kNumButtonRows = 3; +const int kNumButtonCols = 4; + +const uint16 kButtonMap[kNumButtonRows][kNumButtonCols] = +{ + { keyBitHard1, keyBitHard2, keyBitHard3, keyBitHard4 }, + { keyBitPageUp, keyBitPageDown, 0, 0 }, + { keyBitPower, keyBitContrast, keyBitHard2, 0 } +}; + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZTRGpro::EmRegsEZTRGpro +// --------------------------------------------------------------------------- + +EmRegsEZTRGpro::EmRegsEZTRGpro (CFBusManager ** fBusMgr) : + EmRegsEZ (), + fSPISlaveADC (new EmSPISlaveADS784x (kChannelSet2)) +{ + *fBusMgr = &CFBus; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZTRGpro::~EmRegsEZTRGpro +// --------------------------------------------------------------------------- + +EmRegsEZTRGpro::~EmRegsEZTRGpro (void) +{ + delete fSPISlaveADC; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZTRGpro::Initialize +// --------------------------------------------------------------------------- + +void EmRegsEZTRGpro::Initialize(void) +{ + bBacklightOn = false; + CFBus.bEnabled = false; + CFBus.Width = kCFBusWidth16; + CFBus.bSwapped = false; + EmRegsEZ::Initialize(); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZTRGpro::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsEZTRGpro::GetLCDScreenOn (void) +{ + return (READ_REGISTER (portCData) & hwrEZPortCLCDEnableOn) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZTRGpro::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsEZTRGpro::GetLCDBacklightOn (void) +{ + return (bBacklightOn); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZTRGpro::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmRegsEZTRGpro::GetLineDriverState (EmUARTDeviceType type) +{ + if (type == kUARTSerial) + return (READ_REGISTER (portDData) & hwrEZPortD232EnableTRGpro) != 0; + + if (type == kUARTIR) + return (READ_REGISTER (portGData) & 0x10) == 0; + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZTRGpro::GetPortInputValue +// --------------------------------------------------------------------------- +// Return the GPIO values for the pins on the port. These values are used +// if the select pins are high. + +uint8 EmRegsEZTRGpro::GetPortInputValue (int port) +{ + uint8 result = EmRegsEZ::GetPortInputValue (port); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZTRGpro::GetPortInternalValue +// --------------------------------------------------------------------------- +// Return the dedicated values for the pins on the port. These values are +// used if the select pins are low. + +uint8 EmRegsEZTRGpro::GetPortInternalValue (int port) +{ + uint8 result = EmRegsEZ::GetPortInternalValue (port); + + if (port == 'D') + { + // Make sure that hwrEZPortDPowerFail is set. If it's clear, + // the battery code will make the device go to sleep immediately. + + result |= (hwrEZPortDCFInit | hwrEZPortDPowerFail); + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZTRGpro::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmRegsEZTRGpro::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ +// KeyRowsType keyRows; + + *numRows = kNumButtonRows; + *numCols = kNumButtonCols; + + memcpy (keyMap, kButtonMap, sizeof (kButtonMap)); + + // Determine what row is being asked for. + rows[0] = Keys.Row[0]; + rows[1] = Keys.Row[1]; + rows[2] = Keys.Row[2]; +} + +void EmRegsEZTRGpro::LatchSpi(void) +{ + uint16 latched = spiUnlatchedVal; + + bBacklightOn = ((latched & SPIBacklightOn) != 0); + CFBus.bEnabled = ((latched & (SPICardBufferOff | + SPICardSlotPwrOff)) == 0); + CFBus.bSwapped = ((latched & SPIBusSwapOff) == 0); + if (latched & SPIBusWidth8) + CFBus.Width = kCFBusWidth8; + else + CFBus.Width = kCFBusWidth16; + Keys.Row[0] = !(latched & SPIKeyRow0); + Keys.Row[1] = !(latched & SPIKeyRow1); + Keys.Row[2] = !(latched & SPIKeyRow2); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZTRGpro::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmRegsEZTRGpro::PortDataChanged (int port, uint8 oldValue, uint8 newValue) +{ + if (port == 'G') + { + // If the the DO_LATCH bit is set, then the recent value + // written to the SPI controller is for us, and not + // the touchscreen + + if (newValue & hwrEZPortGDO_LATCH) + LatchSpi(); + } + + EmRegsEZ::PortDataChanged(port, oldValue, newValue); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZTRGpro::spiWrite +// +// We need to share SPI writes with the touchscreen ... +// --------------------------------------------------------------------------- + +void EmRegsEZTRGpro::spiWrite(emuptr address, int size, uint32 value) +{ + spiUnlatchedVal = value; + EmRegsEZ::spiMasterControlWrite (address, size, value); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZTRGpro::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegsEZTRGpro::SetSubBankHandlers(void) +{ + EmRegsEZ::SetSubBankHandlers(); + this->SetHandler((ReadFunction)&EmRegs::StdRead, + (WriteFunction)&EmRegsEZTRGpro::spiWrite, + addressof(spiMasterData), + sizeof(f68EZ328Regs.spiMasterData)); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZTRGpro::GetSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave* EmRegsEZTRGpro::GetSPISlave (void) +{ + if ((READ_REGISTER (portGData) & hwrEZPortGADCOff) == 0) + { + return fSPISlaveADC; + } + + return NULL; +} diff --git a/SrcShared/Hardware/EmRegsEZTRGpro.h b/SrcShared/Hardware/EmRegsEZTRGpro.h new file mode 100644 index 0000000..25f5c7e --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZTRGpro.h @@ -0,0 +1,76 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsEZTRGpro_h +#define EmRegsEZTRGpro_h + +#include "EmRegsEZ.h" +#include "EmHandEraCFBus.h" + +// -------------------------------------------------------------------------- +// This file is used to emulate the SPI controller ... the SPI performs +// double duty for the TRGpro ... normally, it controls the touch screen ... +// however, if a latch bit is set on Port D, it will use the SPI to +// control the keypad and bus-state +// -------------------------------------------------------------------------- + +#define SPIKeyRow0 0x01 +#define SPIKeyRow1 0x02 +#define SPIKeyRow2 0x04 +#define SPIBusSwapOff 0x08 +#define SPIBacklightOn 0x10 +#define SPICardBufferOff 0x20 +#define SPICardSlotPwrOff 0x40 +#define SPIBusWidth8 0x80 + +#define TRGPRO_NUM_KEY_ROWS 3 + +typedef struct { + uint16 Row[TRGPRO_NUM_KEY_ROWS]; +} TrgProKeys; + + +class EmRegsEZTRGpro : public EmRegsEZ +{ + public: + EmRegsEZTRGpro (CFBusManager ** fBusManager); + virtual ~EmRegsEZTRGpro (void); + + virtual void Initialize (void); + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLineDriverState (EmUARTDeviceType type); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); + virtual void PortDataChanged (int, uint8, uint8); + void SetSubBankHandlers(void); + private: + void spiWrite(emuptr address, int size, uint32 value); + uint16 spiLatchedVal, spiUnlatchedVal; + void LatchSpi(void); + + + protected: + virtual EmSPISlave* GetSPISlave (void); + + private: + EmSPISlave* fSPISlaveADC; + CFBusManager CFBus; + TrgProKeys Keys; + int bBacklightOn; +}; + +#endif /* EmRegsEZTRGpro_h */ diff --git a/SrcShared/Hardware/EmRegsEZTemp.cpp b/SrcShared/Hardware/EmRegsEZTemp.cpp new file mode 100644 index 0000000..a0725f5 --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZTemp.cpp @@ -0,0 +1,18 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsEZTemp.h" +#include "EmRegsEZPrv.h" + + diff --git a/SrcShared/Hardware/EmRegsEZTemp.h b/SrcShared/Hardware/EmRegsEZTemp.h new file mode 100644 index 0000000..7818645 --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZTemp.h @@ -0,0 +1,18 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsEZTemp_h +#define EmRegsEZTemp_h + + +#endif /* EmRegsEZTemp_h */ diff --git a/SrcShared/Hardware/EmRegsEZVisor.cpp b/SrcShared/Hardware/EmRegsEZVisor.cpp new file mode 100644 index 0000000..166158c --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZVisor.cpp @@ -0,0 +1,243 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsEZVisor.h" +#include "EmRegsEZPrv.h" + +#include "EmDevice.h" // HardwareID +#include "EmSession.h" // GetDevice +#include "EmSPISlaveADS784x.h" // EmSPISlaveADS784x + + +const uint16 kVisorButtonMap[kNumButtonRows][kNumButtonCols] = +{ + { keyBitHard1, keyBitHard2, keyBitHard3 }, + { keyBitPageUp, keyBitPageDown, 0 }, + { keyBitPower, keyBitHard4, 0 } +}; + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZVisor::EmRegsEZVisor +// --------------------------------------------------------------------------- + +EmRegsEZVisor::EmRegsEZVisor (void) : + EmRegsEZ (), + fSPISlaveADC (new EmSPISlaveADS784x (kChannelSet2)) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZVisor::~EmRegsEZVisor +// --------------------------------------------------------------------------- + +EmRegsEZVisor::~EmRegsEZVisor (void) +{ + delete fSPISlaveADC; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZVisor::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsEZVisor::GetLCDScreenOn (void) +{ + return (READ_REGISTER (portCData) & hwrLegoPortCLCDEnableOn) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZVisor::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsEZVisor::GetLCDBacklightOn (void) +{ + return (READ_REGISTER (portGData) & hwrLegoPortGBacklightOff) == 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZVisor::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmRegsEZVisor::GetLineDriverState (EmUARTDeviceType type) +{ + if (type == kUARTSerial) + { + uint16 uControl = READ_REGISTER (uControl); + uint16 uMisc = READ_REGISTER (uMisc); + + return (uControl & hwrEZ328UControlUARTEnable) != 0 && + (uMisc & hwrEZ328UMiscIRDAEn) == 0; + } + + if (type == kUARTIR) + { + uint16 uControl = READ_REGISTER (uControl); + uint16 uMisc = READ_REGISTER (uMisc); + + return (uControl & hwrEZ328UControlUARTEnable) != 0 && + (uMisc & hwrEZ328UMiscIRDAEn) != 0; + } + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZVisor::GetPortInputValue +// --------------------------------------------------------------------------- +// Return the GPIO values for the pins on the port. These values are used +// if the select pins are high. + +uint8 EmRegsEZVisor::GetPortInputValue (int port) +{ + uint8 result = EmRegsEZ::GetPortInputValue (port); + + if (port == 'E') + { + /* + Support the Visor model ID. From Bob Petersen at Handspring: + + The Visor ROM only works with 1 device so far. But, the Visor does have + model detect pins so that future ROMs can work on multiple platforms. The + model input pins are connected to port E, bits 0-2 (E[0-2]). To read them, + you have to drive port G bit 2 low and enable the pullups on port E. + */ + +#define modelOutPin 0x04 // EMUIRQ (IRQ7) +#define modelInPins 0x07 // SPI pins on Visor + + UInt8 portGData = READ_REGISTER (portGData); + UInt8 portGDir = READ_REGISTER (portGDir); + UInt8 portGSelect = READ_REGISTER (portGSelect); + + if (((portGData & modelOutPin) == 0) && + ((portGDir & modelOutPin) == modelOutPin) && + ((portGSelect & modelOutPin) == modelOutPin)) + { + EmAssert (gSession); + + EmDevice device = gSession->GetDevice (); + result |= (~device.HardwareID ()) & modelInPins; // <chg 24-Apr-2000 BP> expects inverse output + } + else + { + // The pin for detecting "in cradle" is hwrLegoPortEDock2Off. It should be low + // if in the serial cradle. If it is high, we assume USB. + // -- Bob Petersen + + result &= ~hwrLegoPortEDock2Off; + } + } + else if (port == 'G') + { + // Make sure that hwrLegoPortGPowerFailIrqOff is set. If it's clear, + // the battery code will make the device go to sleep immediately. + + result |= hwrLegoPortGPowerFailIrqOff; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZVisor::GetPortInternalValue +// --------------------------------------------------------------------------- +// Return the dedicated values for the pins on the port. These values are +// used if the select pins are low. + +uint8 EmRegsEZVisor::GetPortInternalValue (int port) +{ + uint8 result = EmRegsEZ::GetPortInternalValue (port); + + if (port == 'D') + { + // Always set the high bit, indicating that there's no memory module + // installed. From Bob Petersen at Handspring: + // + // This is a probe into the module memory, to check for a replacement ROM on a + // card that is plugged in. The card is mapped to 0x20000000 and the card's + // ROM is at 0x28000000. If it finds the card header (FEEDBEEF) and the card + // is plugged in that has a non-zero reset vector, the chip selects are changed + // so B0 addresses 10c00000, and then we jump to the reset vector and boot off + // the card. + // + // This part of the boot code should only be called if it is detected that a + // card is currently plugged in (bit 7 of port D) and we aren't currently + // booting from the card. + + result |= hwrLegoPortDCardInstIrqOff; + + // Ensure that bit hwrLegoPortDDock1IrqOff is set. If it's clear, HotSync + // will sync via the modem instead of the serial port. + + result |= hwrLegoPortDDock1IrqOff; + } + else if (port == 'G') + { + // Make sure that hwrLegoPortGPowerFailIrqOff is set. If it's clear, + // the battery code will make the device go to sleep immediately. + + result |= hwrLegoPortGPowerFailIrqOff; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZVisor::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmRegsEZVisor::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ + *numRows = kNumButtonRows; + *numCols = kNumButtonCols; + + memcpy (keyMap, kVisorButtonMap, sizeof (kVisorButtonMap)); + + // Determine what row is being asked for. + + UInt8 portDDir = READ_REGISTER (portDDir); + UInt8 portDData = READ_REGISTER (portDData); + + UInt8 portGDir = READ_REGISTER (portGDir); + UInt8 portGData = READ_REGISTER (portGData); + + rows[0] = (portGDir & hwrLegoPortGKbdRow0) != 0 && (portGData & hwrLegoPortGKbdRow0) == 0; + rows[1] = (portGDir & hwrLegoPortGKbdRow1) != 0 && (portGData & hwrLegoPortGKbdRow1) == 0; + rows[2] = (portDDir & hwrLegoPortDKbdRow2) != 0 && (portDData & hwrLegoPortDKbdRow2) == 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZVisor::GetSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave* EmRegsEZVisor::GetSPISlave (void) +{ + if ((READ_REGISTER (portGData) & hwrLegoPortGAdcCsOff) == 0) + { + return fSPISlaveADC; + } + + return NULL; +} diff --git a/SrcShared/Hardware/EmRegsEZVisor.h b/SrcShared/Hardware/EmRegsEZVisor.h new file mode 100644 index 0000000..d71c711 --- /dev/null +++ b/SrcShared/Hardware/EmRegsEZVisor.h @@ -0,0 +1,131 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsEZVisor_h +#define EmRegsEZVisor_h + +#include "EmRegsEZ.h" + +// Handspring modelID defines +// DOLATER BP: move the general Handspring-specific stuff to another include file +#define halModelChipIDEZ 0x00 // 0000 0 +#define halModelChipIDVZ 0x08 // 0000 1 +//#define halModelChipIDXZ 0x10 // 0001 0 placeholder + +#define halModelEZIndexLego 0x00 // 000 + +#define halModelVZIndexVisorPlatinum 0x00 // 000 +#define halModelVZIndexVisorPrism 0x02 // 010 +#define halModelVZIndexVisorEdge 0x01 // 001 + + +// Model IDs (combinations of the above)... +// ---------------------------------------- +#define halModelIDLego (halModelChipIDEZ | halModelEZIndexLego) // Lego (Visor) +#define halModelIDVisorPlatinum (halModelChipIDVZ | halModelVZIndexVisorPlatinum) +#define halModelIDVisorPrism (halModelChipIDVZ | halModelVZIndexVisorPrism) +#define halModelIDVisorEdge (halModelChipIDVZ | halModelVZIndexVisorEdge) + + +// Visor pin definitions from Handspring. Mostly the same as a Palm V, +// but with some pins changed and moved around. + + +/************************************************************************ + * Port B Bit settings + ************************************************************************/ +#define hwrLegoPortBLCDVccOff 0x08 // (L) LCD Vcc +#define hwrLegoPortBLCDAdjOn 0x40 // (H) LCD Contrast Voltage + + +/************************************************************************ + * Port C Bit settings + ************************************************************************/ +#define hwrLegoPortCLCDEnableOn 0x80 // (H) LCD Enable + + +/************************************************************************ + * Port D Bit settings + ************************************************************************/ +#define hwrLegoPortDKbdCol0On 0x01 // (H) Keyboard Column 0 +#define hwrLegoPortDKbdCol1On 0x02 // (H) Keyboard Column 1 +#define hwrLegoPortDKbdCol2On 0x04 // (H) Keyboard Column 2 + +#define hwrLegoPortDKbdRow2 0x08 // (H) Keyboard Row 2 + +#define hwrLegoPortDDock1IrqOff 0x10 // (L) Dock1 interrupt +#define hwrLegoPortDSlotIrqOff 0x20 // (L) Slot Interrupt +#define hwrLegoPortDUsbIrqOff 0x40 // (L) USB Interrupt +#define hwrLegoPortDCardInstIrqOff 0x80 // (L) Card Installed Interrupt + +#define hwrLegoPortDKeyBits 0x07 // (H) All Keyboard Columns + + + +/************************************************************************ + * Port E Bit settings + ************************************************************************/ +#define hwrLegoPortESerialTxD 0x20 // ( ) Serial transmit line +#define hwrLegoPortESlotResetOff 0x40 // (L) Slot reset +#define hwrLegoPortEDock2Off 0x80 // (L) Dock2 input + + +/************************************************************************ + * Port F Bit settings + ************************************************************************/ +#define hwrLegoPortFContrast 0x01 // ( ) LCD Contrast PWM output +#define hwrLegoPortFIREnableOff 0x04 // (L) Shutdown IR +#define hwrLegoPortFUsbCsOff 0x80 // (L) USB chip select + + +/************************************************************************ + * Port G Bit settings + ************************************************************************/ +#define hwrLegoPortGBacklightOff 0x01 // (L) Backlight on/off +#define hwrLegoPortGUSBSuspend 0x02 // (X) USB Suspend bit - Output low for active + // - Input for suspend +#define hwrLegoPortGPowerFailIrqOff 0x04 // (L) Power Fail IRQ +#define hwrLegoPortGKbdRow0 0x08 // (H) Keyboard Row 0 +#define hwrLegoPortGKbdRow1 0x10 // (H) Keyboard Row 1 +#define hwrLegoPortGAdcCsOff 0x20 // (L) A/D Select + + +const int kNumButtonRows = 3; +const int kNumButtonCols = 3; + +extern const uint16 kVisorButtonMap[kNumButtonRows][kNumButtonCols]; + + +class EmRegsEZVisor : public EmRegsEZ +{ + public: + EmRegsEZVisor (void); + virtual ~EmRegsEZVisor (void); + + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLineDriverState (EmUARTDeviceType type); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); + + protected: + virtual EmSPISlave* GetSPISlave (void); + + private: + EmSPISlave* fSPISlaveADC; +}; + +#endif /* EmRegsEZVisor_h */ diff --git a/SrcShared/Hardware/EmRegsFrameBuffer.cpp b/SrcShared/Hardware/EmRegsFrameBuffer.cpp new file mode 100644 index 0000000..cb436fd --- /dev/null +++ b/SrcShared/Hardware/EmRegsFrameBuffer.cpp @@ -0,0 +1,241 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsFrameBuffer.h" + +#include "Byteswapping.h" // ByteswapWords +#include "EmMemory.h" // EmMemDoGet32 +#include "EmScreen.h" // EmScreen::MarkDirty +#include "Miscellaneous.h" // StWordSwapper +#include "Platform.h" // Platform::AllocateMemoryClear +#include "SessionFile.h" // SessionFile + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::EmRegsFrameBuffer +// --------------------------------------------------------------------------- + +EmRegsFrameBuffer::EmRegsFrameBuffer (emuptr baseAddr, int32 size) : + fBaseAddr (baseAddr), + fSize (size), + fVideoMem (NULL) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::~EmRegsFrameBuffer +// --------------------------------------------------------------------------- + +EmRegsFrameBuffer::~EmRegsFrameBuffer (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::Initialize +// --------------------------------------------------------------------------- + +void EmRegsFrameBuffer::Initialize (void) +{ + EmRegs::Initialize (); + + // Allocate a chunk of memory for the VRAM space. + + if (!fVideoMem) + { + fVideoMem = Platform::AllocateMemoryClear (fSize); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::Reset +// --------------------------------------------------------------------------- + +void EmRegsFrameBuffer::Reset (Bool hardwareReset) +{ + EmRegs::Reset (hardwareReset); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::Save +// --------------------------------------------------------------------------- + +void EmRegsFrameBuffer::Save (SessionFile& f) +{ + EmRegs::Save (f); + + StWordSwapper swapper (fVideoMem, fSize); + f.WriteSED1375Image (fVideoMem, fSize); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::Load +// --------------------------------------------------------------------------- + +void EmRegsFrameBuffer::Load (SessionFile& f) +{ + EmRegs::Load (f); + + // Read in the LCD image, and then byteswap it. + + if (f.ReadSED1375Image (fVideoMem)) + { + ByteswapWords (fVideoMem, fSize); + } + else + { + f.SetCanReload (false); + } + +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::Dispose +// --------------------------------------------------------------------------- + +void EmRegsFrameBuffer::Dispose (void) +{ + EmRegs::Dispose (); + + Platform::DisposeMemory (fVideoMem); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::GetLong +// --------------------------------------------------------------------------- + +uint32 EmRegsFrameBuffer::GetLong (emuptr address) +{ + uint32 offset = address - fBaseAddr; + return EmMemDoGet32 (((uint8*) fVideoMem) + offset); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::GetWord +// --------------------------------------------------------------------------- + +uint32 EmRegsFrameBuffer::GetWord (emuptr address) +{ + uint32 offset = address - fBaseAddr; + return EmMemDoGet16 (((uint8*) fVideoMem) + offset); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::GetByte +// --------------------------------------------------------------------------- + +uint32 EmRegsFrameBuffer::GetByte (emuptr address) +{ + uint32 offset = address - fBaseAddr; + return EmMemDoGet8 (((uint8*) fVideoMem) + offset); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::SetLong +// --------------------------------------------------------------------------- + +void EmRegsFrameBuffer::SetLong (emuptr address, uint32 value) +{ + uint32 offset = address - fBaseAddr; + EmMemDoPut32 (((uint8*) fVideoMem) + offset, value); + EmScreen::MarkDirty (address, 4); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::SetWord +// --------------------------------------------------------------------------- + +void EmRegsFrameBuffer::SetWord (emuptr address, uint32 value) +{ + uint32 offset = address - fBaseAddr; + EmMemDoPut16 (((uint8*) fVideoMem) + offset, value); + EmScreen::MarkDirty (address, 2); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::SetByte +// --------------------------------------------------------------------------- + +void EmRegsFrameBuffer::SetByte (emuptr address, uint32 value) +{ + uint32 offset = address - fBaseAddr; + EmMemDoPut8 (((uint8*) fVideoMem) + offset, value); + EmScreen::MarkDirty (address, 1); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::ValidAddress +// --------------------------------------------------------------------------- + +int EmRegsFrameBuffer::ValidAddress (emuptr address, uint32 size) +{ + UNUSED_PARAM (address); + UNUSED_PARAM (size); + + return true; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegsFrameBuffer::SetSubBankHandlers (void) +{ + // We don't have handlers for each byte of memory, so there's nothing + // to install here. +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmRegsFrameBuffer::GetRealAddress (emuptr address) +{ + uint32 offset = address - fBaseAddr; + return (uint8*) fVideoMem + offset; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::GetAddressStart +// --------------------------------------------------------------------------- + +emuptr EmRegsFrameBuffer::GetAddressStart (void) +{ + return fBaseAddr; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsFrameBuffer::GetAddressRange +// --------------------------------------------------------------------------- + +uint32 EmRegsFrameBuffer::GetAddressRange (void) +{ + return fSize; +} diff --git a/SrcShared/Hardware/EmRegsFrameBuffer.h b/SrcShared/Hardware/EmRegsFrameBuffer.h new file mode 100644 index 0000000..e2d4741 --- /dev/null +++ b/SrcShared/Hardware/EmRegsFrameBuffer.h @@ -0,0 +1,52 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsFrameBuffer_h +#define EmRegsFrameBuffer_h + +#include "EmRegs.h" + +class SessionFile; + + +class EmRegsFrameBuffer : public EmRegs +{ + public: + EmRegsFrameBuffer (emuptr baseAddr, int32 size); + virtual ~EmRegsFrameBuffer (void); + + virtual void Initialize (void); + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + virtual void Dispose (void); + + virtual uint32 GetLong (emuptr address); + virtual uint32 GetWord (emuptr address); + virtual uint32 GetByte (emuptr address); + virtual void SetLong (emuptr address, uint32 value); + virtual void SetWord (emuptr address, uint32 value); + virtual void SetByte (emuptr address, uint32 value); + virtual int ValidAddress (emuptr address, uint32 size); + virtual void SetSubBankHandlers (void); + virtual uint8* GetRealAddress (emuptr address); + virtual emuptr GetAddressStart (void); + virtual uint32 GetAddressRange (void); + + private: + emuptr fBaseAddr; + int32 fSize; + void* fVideoMem; +}; + +#endif /* EmRegsFrameBuffer_h */ diff --git a/SrcShared/Hardware/EmRegsMediaQ11xx.cpp b/SrcShared/Hardware/EmRegsMediaQ11xx.cpp new file mode 100644 index 0000000..19506b0 --- /dev/null +++ b/SrcShared/Hardware/EmRegsMediaQ11xx.cpp @@ -0,0 +1,4791 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsMediaQ11xx.h" + +#include "EmCPU68K.h" // gCPU68K +#include "EmPixMap.h" // EmPixMap::GetLCDScanlines +#include "EmScreen.h" // EmScreen::InvalidateAll +#include "SessionFile.h" // + +#include "Logging.h" // LogAppendMsg + +#include <algorithm> // swap + + +#define LOG_LINE 0 +#define PRINTF_LINE if (!LOG_LINE) ; else LogAppendMsg + +#define LOG_BLIT 0 +#define PRINTF_BLIT if (!LOG_BLIT) ; else LogAppendMsg + + +/* --------------------------------------------------------------------------- *\ + MediaQ Graphics Engine overview and description + ----------------------------------------------- + + The MediaQ 1100/1132 chip contains a graphics engine used for accelerating + graphics drawing operations. It has the following features: + + * Line drawing + * Rectangle operations (fill, scroll, and BLT) + * Arbitrary transfer operations (using Windows ROP definitions) + * Monochrome and color source data + * Monochrome pattern data + * Colorization of monochrome source and pattern data + * Transparency support + * Clipping support + * Automatic screen flipping + + There are 20 registers reserved for the graphics accelerator. The MediaQ + client generally works by storing necessary values in a subset of those + registers, and then kicks off the drawing process by updating the register + that receives the drawing command. This register (GE00R) is the master + control register. It contains all of the top-level information about what + is to be drawn and how. As needed, other registers are queried for + additional values needed for the operation. Registers not required for + the drawing operation need not be updated before the drawing command is + issued. The drawing operation takes place asynchronously, freeing up the + MediaQ client for other tasks. + + The graphics chip makes use of two FIFOs: a command FIFO and a source data + FIFO. The command FIFO is used to make sure that registers are not + updated and changed out from under a drawing operation currently in + progress. That is, any write access to a register really results in an + entry being added to the command FIFO. Entries are then popped off and + used to update the registers. If the command register is written to, the + drawing operation commences. Any subsequent writes to registers will + still be added to the FIFO, but will stay there until the drawing + operation has completed. If the FIFO is full (it has room only for 16 + commands), the main CPU will stall if it tries to add any more commands. + + Sometimes the drawing operation requires "source data", that is, data from + main memory. The MediaQ chip doesn't have direct access to main RAM, and + so data from there needs to be fed in through a source FIFO. After a + drawing command has been started that requires source data, the MediaQ + client must go into a loop and ensure that this source data FIFO is filled + with the necessary data. Note that this source FIFO contains 16 64-bit + slots. Therefore, the client needs to make sure that information written + to the FIFO occurs in multiples of 64-bits (or 8 bytes). + + GEState + ------- + + This Poser-defined structure is a mirror of the registers used by the + MediaQ graphics acceleration engine. It breaks out all of the pieces of + information packed into those registers, and stores each piece into its + own field for easy access. This unpacking takes place as needed, + generally when a graphics drawing command is issued. + + Following is a description of all the registers and the fields within + those registers. After that are included some notes on how those + registers fit into the bigger picture. + + ************************************************************************** + ========================================================================== + GE00R + ========================================================================== + + GE00R[7:0] rasterOperation + ----------------------------------------------- + Specifies the transfer mode. That is, it defines the way in which the + source data, destination data, and pattern data are combined to + produce the final destination or output data. The values that can be + used here are the same that Microsoft has defined for GDI. + + This register can contain either the ternary ROP codes or the binary + ROP2 codes, depending on the setting of rop2Select (GE00R[25]). + + GE00R[10:8] commandType + ----------------------------------------------- + Specifies the drawing command. Can be one of three values: + + 0 = NOP + 2 = BitBLT + 4 = Line + + All other values are either reserved or undefined. + + Note that BitBLT is used for drawing filled rectangles, scrolling + images in the screen memory, or copy images from main memory to the + screen memory. Monochrome and color source data and patterns are + supported. + + GE00R[11] xDirection + GE00R[12] yDirection + ----------------------------------------------- + Defines the direction in which a BitBLT or line drawing operation + occurs. Values of zero indicate the positive (right or down) + direction; values of one indicate the negative (left or up) direction. + When drawing a line, note that these fields are used only if the + useXY field is set. + + GE00R[13] systemMemory + ----------------------------------------------- + If true, specifies that any source data comes from the source FIFO. + Otherwise, the data comes from display memory, and xSrc (GE03R[11:0]) + and ySrc (GE03R[27:16]) need to be programmed. + + GE00R[14] monoSource + ----------------------------------------------- + Specifies whether the source data is a monochrome (aka, bitonal) + bitmap where each pixel is represented by a single bit, or that the + source data is in color format, where each pixel is defined by an 8 or + 16 bit value, depending on the setting of colorDepth (GE0AR[31:30]). + + GE00R[15] monoPattern + ----------------------------------------------- + Specifies whether the pattern data is a monochrome (aka, bitonal) + bitmap where each pixel is represented by a single bit, or that the + pattern data is in color format, where each pixel is defined by an 8 + or 16 bit value. Note that in the current chip, this bit *MUST* be + set to 1, indicating a monochrome pattern. There doesn't appear to be + any support or any way to specify a color pattern. + + GE00R[16] colorTransEnable + ----------------------------------------------- + Setting this bit enables transparent BitBLT operations when the source + data is in color format. It works in conjunction with + destTransPolarity, colorTransCmpSrc, and destTransColor to determine + if the destination pixel is updated or stays the same. + + GE00R[17] destTransPolarity + ----------------------------------------------- + If color transparency is enabled (that is, colorTransEnable is set), + determines how transparency is achieved. Depending on the setting of + colorTransCmpSrc, either the source data or the dest data is compared + to destTransColor. If destTransPolarity is zero, then the destination + pixel is updated if the result of the comparison is not equal. If + destTransPolarity is one, then the destination pixel is update if the + result is equal. + + GE00R[18] monoTransEnable + ----------------------------------------------- + Setting this bit enables transparent BitBLT operations when the source + data is in monochrome format. It works in conjunction with + monoTransPolarity to determine if the destination pixel is updated or + stays the same. + + GE00R[19] monoTransPolarity + ----------------------------------------------- + If monochrome transparency is enabled (that is, monoTransEnable is + set), determines how transparency is achieved. If this value is zero, + then background (that is, zero) bits in the source are treated as + transparent and don't update the destination. If this value is one, + then foreground (that is, one) bits in the source data are treated as + transparent. + + GE00R[20] memToScreen + ----------------------------------------------- + Specifies LINED (memToScreen == 0) or PACKED (memToScreen == 1) blit + transfer mode. PACKED Mode allows bitmaps that are compact to be + transferred more efficiently. LINE Mode requires each line of bitmap + to be aligned at 64-bit and thus could require padding and realignment + if each line of bitmap to be transfer is non-64-bit aligned. + + GE00R[23] solidSourceColor + ----------------------------------------------- + If set, the actual color source data is effectively ignored, and + instead treated as if it were all fgColorMonoSrc. + + GE00R[24] srcEqualDestStride + ----------------------------------------------- + Specifies whether or not the dest and source have the same "strides" + (that is, "rowBytes" in other terminologies). If the source is the + display, then the source will always be the same as the dest. But if + the source is main memory, then the data comes in through the source + FIFO, and I'm not sure how stride comes in to play there. + + GE00R[25] rop2Select + ----------------------------------------------- + Causes the value in rasterOperation (GE00R[7:0]) to be treated as a + binary ROP2 value instead of a ternary ROP value. The documentation + says that "[3:0] is duplicated to [7:4]". However, it's not clear to + me is the programmer is required to write the register in this + duplicated fashion, or if the hardware aliases the low values into the + high values in some way. In either case, I'm not sure why the + hardware cares. Why wouldn't it just look at the low 4 bits and + ignore the upper 4 bits. My guess is that the hardware performs this + aliasing on its own, and that the result when looking at all 8 bits + has the result of acting like a binary ROP2 code (that is, the any + source data will be ignored -- see comments in PrvUsesSource on how + the ROP value can be examined to see if the pattern, source or + destination have any role in determining the final output value). + + GE00R[26] clipEnable + ----------------------------------------------- + Enable clipping according to the clipLeft, clipTop, clipRight, and + clipBottom fields (registers GE05R and GE06R). + + GE00R[27] autoExecute + ----------------------------------------------- + Setting this bit enables auto-execution of the command after the + destination XY register (GE02R) is written. If it's clear, the + graphics engine command execution starts the command register (GE00R) + is written. + + GE00R[30] solidPattern + ----------------------------------------------- + If set, then all pattern data is forced to the value of the pattern + foreground color register (GE12R). + + GE00R[31] colorTransCmpSrc + ----------------------------------------------- + Used in conjunction with the transparency-enable bits, determines if + the color to be compared comes from the source or destination. + Compare to the source data if it's zero, destination if it's one. + + ========================================================================== + GE01R + ========================================================================== + + GE01R[11:0] (BitBLT) width + GE01R[27:16] (BitBLT) height + ----------------------------------------------- + When a BitBLT operation has been specified, these fields contain the + dimensions (in pixels) of the operation. It is used for both the + source and destination. + + GE01R[31] (BitBLT) xyConversion + ----------------------------------------------- + When a BitBLT operation has been specified, this field controls how + the starting x/y values are interpreted. If this bit is clear, then + the specified x/y values are the first pixel updated. If this bit is + set, then the specified x/y values are the top/left corner of the + rectangle that's updated. + + GE01R[16:0] (Line) gamma + ----------------------------------------------- + When a line drawing operation has been specified, contains a value + identified as "gamma". This is defined in the documentation as + "either -(dm >> 1) - 1 or -(dm >> 1), depending on the quadrant", + where "dm" is the major axis delta. However, there's no mention of + which value is used in what situations. As well, our source code + writes to this field a value that has the same magnitude of dm. That + is dm gets written to its designated field, and -dm gets written to + gamma. + + GE01R[28:17] (Line) majorLength + ----------------------------------------------- + When a line drawing operation has been specified, contains the length + along the major axis. + + GE01R[29] (Line) yIsMajor + ----------------------------------------------- + When a line drawing operation has been specified, specifies which axis + is the major axis (that is, the "long" axis -- a "mostly horizontal" + line has X as the major axis, while a "mostly vertical" line has Y as + the major axis, and a diagonal line can have either defines as its + major axis). If set, Y is the major axis. Otherwise, X is the major + axis. Note that this field is used only if the useXY field is set. + + GE01R[30] (Line) drawLastPixel + ----------------------------------------------- + When a line drawing operation has been specified, specifies whether or + not the last pixel in the rasterization process is drawn. + + GE01R[31] (Line) useXY + ----------------------------------------------- + When a line drawing operation has been specified, specifies the method + used to determine in which direction the line should be drawn. If + this field is set, then the information about direction and slope is + taken from the xDirection, yDirection, and yIsMajor fields. If this + field is clear, then the information is taken from the quadrant field. + + ========================================================================== + GE02R + ========================================================================== + + GE02R[11:0] (BitBLT) xDest + GE02R[27:16] (BitBLT) yDest + ----------------------------------------------- + When a BitBLT operation has been specified, these fields contain the + initial x,y location to receive the blitted data. Note that these + values are always the topLeft of the destination area, regardless of + xDirection and yDirection. + + GE02R[15:13] (BitBLT) monoPatternXOffset + GE02R[31:29] (BitBLT) monoPatternYOffset + ----------------------------------------------- + When a BitBLT operation has been specified, these fields contain the + initial x,y offsets into the monochrome pattern being used. + + GE02R[11:0] (Line) xStart + ----------------------------------------------- + When a line drawing operation has been specified, specifies starting X + position of the line. + + GE02R[28:12] (Line) deltaMajor + ----------------------------------------------- + When a line drawing operation has been specified, specifies the length + of the line along the major axis. See yIsMajor for a definition of + "major axis". + + GE02R[31:29] (Line) quadrant + ----------------------------------------------- + When a line drawing operation has been specified, specifies the + direction and angle in which the line is drawn. This is used only + when the useXY field is clear, and replaces the same information + provided by xDirection, yDirection, and yIsMajor. The field contains + a value from 0 to 7, indicating one of the following 8 quadrants: + + Quadrant 0 (x-major, positive x and y directions) + Quadrant 1 (y-major, positive x and y directions) + Quadrant 2 (y-major, negative x and positive y directions) + Quadrant 3 (x-major, negative x and positive y directions) + Quadrant 4 (x-major, negative x and y directions) + Quadrant 5 (y-major, negative x and y directions) + Quadrant 6 (y-major, positive x and negative y directions) + Quadrant 7 (x-major, positive x and negative y directions) + + ========================================================================== + GE03R + ========================================================================== + + GE03R[11:0] (BitBLT) xSrc + GE03R[27:16] (BitBLT) ySrc + ----------------------------------------------- + When a BitBLT operation has been specified, these fields contain the + initial x,y location from which to read the source data. Only used + when the source data is coming from display memory and not the source + FIFO. That is, used in scrolling operations. Note that these values + are always the topLeft of the source area, regardless of xDirection + and yDirection. + + GE03R[11:0] (Line) yStart + ----------------------------------------------- + When a line drawing operation has been specified, specifies starting Y + position of the line. + + GE03R[28:12] (Line) deltaMinor + ----------------------------------------------- + When a line drawing operation has been specified, specifies the length + of the line along the minor axis. The "minor axis" is the X or Y axis + that is not designated as the major axis. See yIsMajor for a + definition of "major axis". + + ========================================================================== + GE04R + ========================================================================== + + GE04R[15:0] destTransColor + ----------------------------------------------- + When color transparency has been enabled by setting the + colorTransEnable field, specifies the color that should be compared + against. + + ========================================================================== + GE05R/GE06R + ========================================================================== + + GE05R[10:0] clipLeft + GE05R[25:16] clipTop + GE06R[10:0] clipRight + GE06R[25:16] clipBottom + ----------------------------------------------- + When the clippingEnable bit is set, these four fields specify the + clipping boundary. Pixels outside this rectangle are not written. + + ========================================================================== + GE07R/GE08R + ========================================================================== + + GE07R[15:0] fgColorMonoSrc + GE08R[15:0] bgColorMonoSrc + ----------------------------------------------- + When a monochrome source is being used, these two fields contain the + fore- and background colors that should be applied to the bits + representing the pixels. Any 1 bit is replace with fgColorMonoSrc, + and any 0 bit is replaces with bgColorMonoSrc. + + ========================================================================== + GE09R + ========================================================================== + + GE09R[9:0] (Lined) srcLineStride + ----------------------------------------------- + When Lined mode is being used (see memToScreen (GE00R[20])) and + srcEqualDestStride is false, contains the number of bytes in a line + of source data. + + GE09R[27:25] (Lined) srcBitOffset + ----------------------------------------------- + When Lined mode is being used (see memToScreen (GE00R[20])), contains + the bit offset into the byte containing the leftmost pixel. Makes + sense only with a monochrome source. + + GE09R[30:28] (Lined) srcByteOffset + ----------------------------------------------- + When Lined mode is being used (see memToScreen (GE00R[20])), contains + the byte offset of the byte containing the leftmost pixel. + + GE09R[2:0] (Packed) srcLeadingBits + ----------------------------------------------- + When Packed mode is being used (see memToScreen (GE00R[20])), contains + the bit offset into the byte containing the leftmost pixel. Makes + sense only with a monochrome source. + + GE09R[5:3] (Packed) srcLeadingBytes + ----------------------------------------------- + When Packed mode is being used (see memToScreen (GE00R[20])), contains + the byte offset of the byte containing the leftmost pixel. + + GE09R[15:6] (Packed) srcNumBytes + ----------------------------------------------- + When Packed mode is being used (see memToScreen (GE00R[20])), described + in the manual as: Number of 8 bytes amount that MIU needs to fetch from + frame buffer. For off-screen to on-screen packed mode, these 10 bits + represent the number of 8 bytes needed to be fetched by the MIU; the + maximum amount it can address is 16 Kbyte, which is the off screen + monochrome font or monochrome image graphics engine can support for + packed mode. + + GE09R[27:25] (Packed) srcTrailingBits + ----------------------------------------------- + When Packed mode is being used (see memToScreen (GE00R[20])), contains + the number of unused trailing bits in the last byte containing pixel + data. Makes sense only in monochrome mode. + + GE09R[31:28] (Packed) srcTrailingBytes + ----------------------------------------------- + When Packed mode is being used (see memToScreen (GE00R[20])), contains + the number of unused trailing bytes. + + ========================================================================== + GE0AR + ========================================================================== + + GE0AR[9:0] destLineStride + ----------------------------------------------- + Specifies the stride (or rowBytes) of the destination bitmap. The + stride is the number of bytes between the first pixel of one line and + the first pixel of the following lines. This information duplicates + that stored in the graphic controller, but presumably is stored here + as well because the controller and accelerator are separate modules. + + GE0AR[28] monoSrcBitSwap + ----------------------------------------------- + Determines the interpretation of the bits in a monochrome pattern or + source bitmap. If this bit is clear, then bit 7 of a byte is the + leftmost pixel and bit 0 is the rightmost pixel. If this bit is set, + then bit 0 is the leftmost pixel and bit 7 is the rightmost. Having + this bit clear is consistent with Windows CE and Palm, and having it + set is consistent with EPOC. + + GE0AR[29] rotate90 + ----------------------------------------------- + If set, rotates all drawing operation 90 degrees clockwise. + + GE0AR[31:30] colorDepth + ----------------------------------------------- + Determines the number of bits per pixel. If zero, BPP == 8. If one, + BPP == 16. All other settings are undefined. This information + duplicates that stored in the graphic controller, but presumably is + stored here as well because the controller and accelerator are + separate modules. + + ========================================================================== + GE0BR + ========================================================================== + + GE0BR[19:0] baseAddr + ----------------------------------------------- + Determines the base address of the frame buffer, relative to the start + of the buffer. That is, a value of 0x00000 indicates the beginning of + the buffer, not the beginning of RAM. This information duplicates + that stored in the graphic controller, but presumably is stored here + as well because the controller and accelerator are separate modules. + + GE0BR[29] testModeEnable + GE0BR[31:30] testModeControl + ----------------------------------------------- + Test enable and control bits. Unsupported in Poser. + + ========================================================================== + GE0CR + ========================================================================== + + GE0CR[9:0] cmdLineStart + GE0CR[21:12] cmdLineEnd + ----------------------------------------------- + Specifies the beginning and end of the "command start window". + However, there is no explanation of what this window is. + + GE0CR[24] cmdLineControl + ----------------------------------------------- + Controls whether or not the graphics engine needs to check with + graphics controller before starting a command. However, there's no + explanation of how the graphics controller decides whether or not a + command should be started. + + GE0CR[27:26] gc1SwitchControl + ----------------------------------------------- + Controls automatics switching between the main and alternate windows + in the graphic controller. A value of 0 or 2 means that no switching + is performed. A value of 1 means to switch to the main window after + the current drawing command is done. A value of 3 means to switch to + the alternate window when the command is done. + + ========================================================================== + GE0FR + ========================================================================== + + GE0FR[31:0] + ----------------------------------------------- + If testModeEnable is on, this field receives various values, as + defined by testModeControl. + + ========================================================================== + GE10R/GE11R + ========================================================================== + + GE10R[31:0] monoPattern1 + GE11R[31:0] monoPattern2 + ----------------------------------------------- + Together, these fields specify 64 bits of an 8x8 monochrome pattern. + The low-order byte of monoPattern1 contains the 8 bits for the first + line, the next-order byte of monoPattern1 contains the 8 bits for the + next line, etc., all the way up to the high-order byte of monoPattern2 + containing the 8 bits for the last line. + + ========================================================================== + GE12R/GE13R + ========================================================================== + + GE12R[15:0] fgColorMonoPat + GE13R[15:0] bgColorMonoPat + ----------------------------------------------- + When a monochrome pattern is being used, these two fields contain the + fore- and background colors that should be applied to the bits + representing the pixels. Any 1 bit is replace with fgColorMonoPat, + and any 0 bit is replaces with bgColorMonoPat. + + ************************************************************************** + + Notes: + ----------------------------------------------- + Transparency + ----------------------------------------------- + Use destTransPolarity, colorTransCmpSrc, and destTransColor to + determine if the destination needs to be updated. All told, it should + lay out like this: + + destTransPolarity == 0 + colorTransCmpSrc == 0 + Compare destTransColor to the source pixel. + If ==, do not update the destination. + + That is, treat all destTransColor colored pixels + in the source as transparent. + + colorTransCmpSrc == 1 + Compare destTransColor to the destination pixel. + If ==, do not update the destination. + + That is, leave all destTransColor colored pixels + in the destination alone. + + destTransPolarity == 1 + colorTransCmpSrc == 0 + Compare destTransColor to the source pixel. + If !=, do not update the destination. + + That is, transfer all destTransColor colored pixels + from the source to the destination. + + colorTransCmpSrc == 1 + Compare destTransColor to the destination pixel. + If !=, do not update the destination. + + That is, update all destTransColor colored pixels + in the destination with source pixels. + + ROPs + ----------------------------------------------- + Take the pattern, source, and destination, and consider each value one + bit at a time. The three bits from the three values can form eight + combinations. The raster opcode is a bitfield containing the desired + output from each of the combinations. Thus: + + P S D O (output) + --- --- --- --- + 0 0 0 b0 + 0 0 1 b1 + 0 1 0 b2 + 0 1 1 b3 + 1 0 0 b4 + 1 0 1 b5 + 1 1 0 b6 + 1 1 1 b7 + + The output is the byte <b7><b6><b5><b4><b3><b2><b1><b0>. And this + output value is what becomes the raster opcode. Thus, if the raster + opcode is, for example, 0xCC, the table would be: + + P S D O (output) + --- --- --- --- + 0 0 0 0 + 0 0 1 0 + 0 1 0 1 + 0 1 1 1 + 1 0 0 0 + 1 0 1 0 + 1 1 0 1 + 1 1 1 1 + + So, the we look at three bits from the source and they're all zero, + then the output is zero. If they're all one, then the output is one. + If the pattern is one and the source and destination are zero, then + the output is zero. Overall, + + Output[x] = ROP[P[x],S[x],D[x]] + + where "x" is 0..7, and "P[x],S[x],D[x]" is a bitfield composed of the + given bits. + +\* --------------------------------------------------------------------------- */ + +// Given a register (specified by its field name), return its address +// in emulated space. + +#define addressof(x) ( \ + ((emuptr) fRegs.x.GetPtr ()) - \ + ((emuptr) fRegs.GetPtr ()) + \ + ((emuptr) this->GetAddressStart ()) \ + ) + + +// Macro to help the installation of handlers for a register. + +#define INSTALL_HANDLER(read, write, reg) \ + this->SetHandler ( (ReadFunction) &EmRegsMediaQ11xx::read, \ + (WriteFunction) &EmRegsMediaQ11xx::write, \ + addressof (reg), 4) + +// Private inline function for reading a LE register. + +static inline +uint32 PrvReadRegister(uint8* p) +{ +#if EM_HOST_BYTE_ORDER == EM_LITTLE_ENDIAN + + return *(uint32*) p; + +#else + + return + (((UInt32) p[0]) << 0) + + (((UInt32) p[1]) << 8) + + (((UInt32) p[2]) << 16) + + (((UInt32) p[3]) << 24); + +#endif +} + +// Private inline function for writing a LE register + +static inline +void PrvWriteRegister(uint8* p, uint32 value) +{ +#if EM_HOST_BYTE_ORDER == EM_LITTLE_ENDIAN + + *(uint32*) p = value; + +#else + + p[0] = value >> 0; + p[1] = value >> 8; + p[2] = value >> 16; + p[3] = value >> 24; + +#endif +} + + +// Macros to make calling PrvReadRegister and PrvWriteRegister easier. + +#define READ_REGISTER(reg) ::PrvReadRegister ((uint8*) (fRegs.reg.GetPtr ())) +#define WRITE_REGISTER(reg, value) ::PrvWriteRegister ((uint8*) (fRegs.reg.GetPtr ()), value) + + +// ROP values + +#define ROP_SRCCOPY 0xcc +#define ROP_SRCAND 0x88 +//#define ROP_SRCANDNOT 0x77 +#define ROP_SRCANDNOT 0x22 +#define ROP_SRCXOR 0x66 +#define ROP_SRCOR 0xee +#define ROP_SRCCOPYNOT 0x33 +#define ROP_SRCORNOT 0xbb +#define ROP_SRCXORNOT 0x99 + +#define ROP_PATCOPY 0xf0 +#define ROP_PATAND 0xa0 +//#define ROP_PATANDNOT 0x5f +#define ROP_PATANDNOT 0x0a +#define ROP_PATXOR 0x5a +#define ROP_PATOR 0xfa +#define ROP_PATCOPYNOT 0x0f +#define ROP_PATORNOT 0xaf +#define ROP_PATXORNOT 0xa5 + +#define ROP_BLACKNESS 0x00 + + + +#define CMD_FIFO_MASK (0x0000001F) +#define CMD_FIFO_EMPTY (0x00000010) +#define CMD_SRC_MASK (0x00001F00) +#define CMD_SRC_EMPTY (0x00001000) +#define GE_BUSY_H (0x00010000) + + +///////////////////////////////////////////////////////////////////////////// +// Graphics Controller Registers +// +#define GC_CONTROL (0x00) // Graphics Controll Control Reg +#define GC_PWR_SEQ_CONTROL (0x01) // Power Sequencing Control register +#define GC_HTOTAL_HEND (0x02) // Horizontal Display Total & End +#define GC_VTOTAL_VEND (0x03) // Vertical Display Total and End +#define GC_HSYNC (0x04) // Horizontal Sync Start and End +#define GC_VSYNC (0x05) // Vertical Sync Start and End +#define GC_HWINDOW (0x08) // Horizontal Window Start & End +#define GC_VWINDOW (0x09) // Vertical Window Start & End +#define GC_LINE_CLOCK (0x0B) // Line Clock Control +#define GC_START_ADDR (0x0C) // Image Window Start Address +#define GC_ALTWIN_START_ADDR (0x0D) // Alt Image Window Start Address +#define GC_STRIDE (0x0E) // (Alt) Image Window Stride +#define GC_FRAME_CLOCK (0x1A) // Frame Clock Control +#define GC_SIGNALS (0x1B) // Miscellaneous signal register (read only) +#define GC_HPARAM (0x1C) // Horizontal parameter register (read only) +#define GC_VPARAM (0x1D) // Vertical parameter register (read only) + + +// GC_CONTROL register bit definition + +#define GC_ENABLE (1UL << 0) // Controll enabled +#define GC_H_PIX_DBLNG (1UL << 14) // Enable Horizontal Pixel Doubling +#define GC_V_PIX_DBLNG (1UL << 15) // Enable Vertical Scan Line Doubling +#define GC_PIX_DBLNG_MASK (GC_H_PIX_DBLNG | GC_V_PIX_DBLNG) + + +// Palette masks + +#define RED_MASK 0x0000000FC +#define GREEN_MASK 0x00000FC00 +#define BLUE_MASK 0x000FC0000 + + +#define kColorDepth8 0 +#define kColorDepth16 1 + +#define kCommandNOP 0 +#define kCommandBitBLT 2 +#define kCommandLine 4 + +#define kAllRegisters -1 + +static const char* kCommands[] = +{ + "NOP", + "Undefined", + "BitBLT", + "Reserved", + "Line Draw", + "Reserved", + "Undefined", + "Reserved", +}; + +static const char* kDirections[] = +{ + "Positive", + "Negative" +}; + +const struct +{ + uint16 yIsMajor; // 0 = x is major, 1 = y is major + uint16 xDirection; // 0 = x is positive, 1 = x is negative + uint16 yDirection; // 0 = y is positive, 1 = y is negative + const char* text; // Description for debugging. +} kQuadrantDecode[] = +{ + { 0, 0, 0, "x-major, positive x and y directions" }, + { 1, 0, 0, "y-major, positive x and y directions" }, + { 1, 1, 0, "y-major, negative x and positive y directions" }, + { 0, 1, 0, "x-major, negative x and positive y directions" }, + { 0, 1, 1, "x-major, negative x and y directions" }, + { 1, 1, 1, "y-major, negative x and y directions" }, + { 1, 0, 1, "y-major, positive x and negative y directions" }, + { 0, 0, 1, "x-major, positive x and negative y directions" } +}; + +static char* kROPs[] = +{ + "0 BLACKNESS", "DPSoon", "DPSona", "PSon", + "SDPona", "DPon", "PDSxnon", "PDSaon", + "SDPnaa", "PDSxon", "DPna", "PSDnaon", + "SPna", "PDSnaon", "PDSonon", "Pn", + "PDSona", "DSon NOTSRCERASE", "SDPxnon", "SDPaon", + "DPSxnon", "DPSaon", "PSDPSanaxx", "SSPxDSxaxn", + "SPxPDxa", "SDPSanaxn", "PDSPaox", "SDPSxaxn", + "PSDPaox", "DSPDxaxn", "PDSox", "PDSoan", + "DPSnaa", "SDPxon", "DSna", "SPDnaon", + "SPxDSxa", "PDSPanaxn", "SDPSaox", "SDPSxnox", + "DPSxa", "PSDPSaoxxn", "DPSana", "SSPxPDxaxn", + "SPDSoax", "PSDnox", "PSDPxox", "PSDnoan", + "PSna", "SDPnaon", "SDPSoox", "Sn NOTSRCCOPY", + "SPDSaox", "SPDSxnox", "SDPox", "SDPoan", + "PSDPoax", "SPDnox", "SPDSxox", "SPDnoan", + "PSx", "SPDSonox", "SPDSnaox", "PSan", + "PSDnaa", "DPSxon", "SDxPDxa", "SPDSanaxn", + "SDna SRCERASE", "DPSnaon", "DSPDaox", "PSDPxaxn", + "SDPxa", "PDSPDaoxxn", "DPSDoax", "PDSnox", + "SDPana", "SSPxDSxoxn", "PDSPxox", "PDSnoan", + "PDna", "DSPnaon", "DPSDaox", "SPDSxaxn", + "DPSonon", "Dn DSTINVERT", "DPSox", "DPSoan", + "PDSPoax", "DPSnox", "DPx PATINVERT", "DPSDonox", + "DPSDxox", "DPSnoan", "DPSDnaox", "DPan", + "PDSxa", "DSPDSaoxxn", "DSPDoax", "SDPnox", + "SDPSoax", "DSPnox", "DSx SRCINVERT", "SDPSonox", + "DSPDSonoxxn", "PDSxxn", "DPSax", "PSDPSoaxxn", + "SDPax", "PDSPDoaxxn", "SDPSnoax", "PDSxnan", + "PDSana", "SSDxPDxaxn", "SDPSxox", "SDPnoan", + "DSPDxox", "DSPnoan", "SDPSnaox", "DSan", + "PDSax", "DSPDSoaxxn", "DPSDnoax", "SDPxnan", + "SPDSnoax", "DPSxnan", "SPxDSxo", "DPSaan", + "DPSaa", "SPxDSxon", "DPSxna", "SPDSnoaxn", + "SDPxna", "PDSPnoaxn", "DSPDSoaxx", "PDSaxn", + "DSa SRCAND", "SDPSnaoxn", "DSPnoa", "DSPDxoxn", + "SDPnoa", "SDPSxoxn", "SSDxPDxax", "PDSanan", + "PDSxna", "SDPSnoaxn", "DPSDPoaxx", "SPDaxn", + "PSDPSoaxx", "DPSaxn", "DPSxx", "PSDPSonoxx", + "SDPSonoxn", "DSxn", "DPSnax", "SDPSoaxn", + "SPDnax", "DSPDoaxn", "DSPDSaoxx", "PDSxan", + "DPa", "PDSPnaoxn", "DPSnoa", "DPSDxoxn", + "PDSPonoxn", "PDxn", "DSPnax", "PDSPoaxn", + "DPSoa", "DPSoxn", "D", "DPSono", + "SPDSxax", "DPSDaoxn", "DSPnao", "DPno", + "PDSnoa", "PDSPxoxn", "SSPxDSxox", "SDPanan", + "PSDnax", "DPSDoaxn", "DPSDPaoxx", "SDPxan", + "PSDPxax", "DSPDaoxn", "DPSnao", "DSno MERGEPAINT", + "SPDSanax", "SDxPDxan", "DPSxo", "DPSano", + "PSa MERGECOPY", "SPDSnaoxn", "SPDSonoxn", "PSxn", + "SPDnoa", "SPDSxoxn", "SDPnax", "PSDPoaxn", + "SDPoa", "SPDoxn", "DPSDxax", "SPDSaoxn", + "S SRCCOPY", "SDPono", "SDPnao", "SPno", + "PSDnoa", "PSDPxoxn", "PDSnax", "SPDSoaxn", + "SSPxPDxax", "DPSanan", "PSDPSaoxx", "DPSxan", + "PDSPxax", "SDPSaoxn", "DPSDanax", "SPxDSxan", + "SPDnao", "SDno", "SDPxo", "SDPano", + "PDSoa", "PDSoxn", "DSPDxax", "PSDPaoxn", + "SDPSxax", "PDSPaoxn", "SDPSanax", "SPxPDxan", + "SSPxDSxax", "DSPDSanaxxn", "DPSao", "DPSxno", + "SDPao", "SDPxno", "DSo SRCPAINT", "SDPnoo", + "P PATCOPY", "PDSono", "PDSnao", "PSno", + "PSDnao", "PDno", "PDSxo", "PDSano", + "PDSao", "PDSxno", "DPo", "DPSnoo PATPAINT", + "PSo", "PSDnoo", "DPSoo", "1 WHITENESS" +}; + + +// Inline functions. + +inline uint32 EmRegsMediaQ11xx::PrvGetBPP (void) +{ + return 1 << ((READ_REGISTER (gcREG[GC_CONTROL]) & 0x00000070) >> 4); +} + +inline uint32 EmRegsMediaQ11xx::PrvGetWidth (void) +{ + return (READ_REGISTER (gcREG[GC_HWINDOW]) >> 16) + 1; +} + +inline uint32 EmRegsMediaQ11xx::PrvGetHeight (void) +{ + return (READ_REGISTER (gcREG[GC_VWINDOW]) >> 16) + 1; +} + +inline uint32 EmRegsMediaQ11xx::PrvGetRowBytes (void) +{ + return READ_REGISTER (gcREG[GC_STRIDE]) & 0x0000FFFF; +} + +inline uint32 EmRegsMediaQ11xx::PrvGetVideoOffset (void) +{ + return READ_REGISTER (gcREG[GC_START_ADDR]) & 0x0003FFFF; +} + +inline emuptr EmRegsMediaQ11xx::PrvGetVideoBase (void) +{ + return fBaseVideoAddr; +} + +inline emuptr EmRegsMediaQ11xx::PrvGetFrameBuffer (void) +{ + return this->PrvGetVideoBase () + this->PrvGetVideoOffset (); +} + +inline Bool EmRegsMediaQ11xx::PrvGetXDoubling (void) +{ + return (READ_REGISTER (gcREG[GC_CONTROL]) & GC_H_PIX_DBLNG) != 0; +} + +inline Bool EmRegsMediaQ11xx::PrvGetYDoubling (void) +{ + return (READ_REGISTER (gcREG[GC_CONTROL]) & GC_V_PIX_DBLNG) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::EmRegsMediaQ11xx +// --------------------------------------------------------------------------- + +EmRegsMediaQ11xx::EmRegsMediaQ11xx (emuptr baseRegsAddr, emuptr baseVideoAddr) : + fBaseRegsAddr (baseRegsAddr), + fBaseVideoAddr (baseVideoAddr), + fRegs (), +/* fState (), */ +/* fByteLanes (), */ + fLastAddress (EmMemNULL), + fLastSize (0), + fSourceFifo (), + fBlitInProgress (false), + fCurXOffset (0), + fCurYOffset (0), + fUsesPattern (false), + fUsesSource (false), + fLeadingSourcePixels (0), + fTrailingSourcePixels (0), +/* fPatternPipe (), */ + fXPattern (0), + fYPattern (0), +/* fSourcePipe (), */ + fSourcePipeIndex (0), + fSourcePipeMax (0), + fSourcePipeSkip (0), + fXSrc (0), + fYSrc (0), + fXDest (0), + fYDest (0) +{ +#if LOG_LINE || LOG_BLIT + LogGetStdLog ()->SetLogSize (32 * 1024L * 1024L); +#endif + + COMPILE_TIME_ASSERT(countof (kCommands) == 8); + COMPILE_TIME_ASSERT(countof (kDirections) == 2); + COMPILE_TIME_ASSERT(countof (kQuadrantDecode) == 8); + COMPILE_TIME_ASSERT(countof (kROPs) == 256); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::~EmRegsMediaQ11xx +// --------------------------------------------------------------------------- + +EmRegsMediaQ11xx::~EmRegsMediaQ11xx (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::Initialize +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::Initialize (void) +{ + EmRegs::Initialize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::Reset +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::Reset (Bool hardwareReset) +{ + EmRegs::Reset (hardwareReset); + + if (hardwareReset) + { + WRITE_REGISTER (ccREG[0x00], 0x00000000); + WRITE_REGISTER (ccREG[0x01], 0x00000000); + WRITE_REGISTER (ccREG[0x02], 0x00000000); + WRITE_REGISTER (ccREG[0x03], 0x00000000); + WRITE_REGISTER (ccREG[0x04], 0x00000000); + + WRITE_REGISTER (mmREG[0x00], 0x00000000); // (Low nybble only) + WRITE_REGISTER (mmREG[0x01], 0x00000000); // (Low nybble only) + WRITE_REGISTER (mmREG[0x02], 0x00000000); // (Low nybble only) + + WRITE_REGISTER (inREG[0x00], 0x00000000); + WRITE_REGISTER (inREG[0x01], 0x00000000); + WRITE_REGISTER (inREG[0x02], 0x00000000); + WRITE_REGISTER (inREG[0x03], 0x00000000); + + WRITE_REGISTER (gcREG[0x00], 0x00000000); + WRITE_REGISTER (gcREG[0x01], 0x00000000); // (Low byte only) + WRITE_REGISTER (gcREG[0x06], 0x00000000); // (Low word only) + WRITE_REGISTER (gcREG[0x07], 0x00000000); // (Low word only) + + // GC_CONTROL (0x00) // Graphics Controll Control Reg + // GC_PWR_SEQ_CONTROL (0x01) // Power Sequencing Control register + // GC_HTOTAL_HEND (0x02) // Horizontal Display Total & End + // GC_VTOTAL_VEND (0x03) // Vertical Display Total and End + // GC_HSYNC (0x04) // Horizontal Sync Start and End + // GC_VSYNC (0x05) // Vertical Sync Start and End + // GC_HWINDOW (0x08) // Horizontal Window Start & End + // GC_VWINDOW (0x09) // Vertical Window Start & End + // GC_LINE_CLOCK (0x0B) // Line Clock Control + // GC_START_ADDR (0x0C) // Image Window Start Address + // GC_ALTWIN_START_ADDR (0x0D) // Alt Image Window Start Address + // GC_STRIDE (0x0E) // (Alt) Image Window Stride + // GC_FRAME_CLOCK (0x1A) // Frame Clock Control + + // For now, let's initialize all the graphics controller registers to 0. + for (int i = 0x00; i < 0x20; i++) + { + WRITE_REGISTER (gcREG[i], 0x00000000); + } + + WRITE_REGISTER (geREG[0x00], 0x00000000); + WRITE_REGISTER (geREG[0x0C], 0x00000000); + + WRITE_REGISTER (ssREG[0x00], 0x00000000); + WRITE_REGISTER (ssREG[0x01], 0x00000000); + WRITE_REGISTER (ssREG[0x04], 0x00000000); // (Low nybble only) + WRITE_REGISTER (ssREG[0x08], 0x00000000); // (Low byte only) + WRITE_REGISTER (ssREG[0x09], 0x00000000); // (Low byte only) + WRITE_REGISTER (ssREG[0x0A], 0x00000000); // (Low byte only) + WRITE_REGISTER (ssREG[0x0B], 0x00000000); // (Low byte only) + WRITE_REGISTER (ssREG[0x10], 0x00000000); + WRITE_REGISTER (ssREG[0x11], 0x00000000); + WRITE_REGISTER (ssREG[0x13], 0x00000000); + + WRITE_REGISTER (spREG[0x00], 0x00000000); + WRITE_REGISTER (spREG[0x01], 0xF0000000); + WRITE_REGISTER (spREG[0x02], 0x00000000); + WRITE_REGISTER (spREG[0x03], 0x00000000); + WRITE_REGISTER (spREG[0x04], 0x00000000); + WRITE_REGISTER (spREG[0x05], 0x00000000); + WRITE_REGISTER (spREG[0x06], 0x00000000); + WRITE_REGISTER (spREG[0x07], 0x00000000); + WRITE_REGISTER (spREG[0x08], 0x00000000); + + WRITE_REGISTER (dcREG[0x00], 0x00000000); + WRITE_REGISTER (dcREG[0x01], 0xF0000000); + WRITE_REGISTER (dcREG[0x02], 0x00000000); + WRITE_REGISTER (dcREG[0x03], 0x00000000); + WRITE_REGISTER (dcREG[0x04], 0x00000000); + WRITE_REGISTER (dcREG[0x05], 0x00000000); + WRITE_REGISTER (dcREG[0x06], 0x00000000); + WRITE_REGISTER (dcREG[0x07], 0x00000000); + + WRITE_REGISTER (pcREG[0x00], 0x01204D51); + WRITE_REGISTER (pcREG[0x01], 0x02800000); + WRITE_REGISTER (pcREG[0x02], 0x03800000); + WRITE_REGISTER (pcREG[0x03], 0x00000000); + WRITE_REGISTER (pcREG[0x0B], 0x00000100); + WRITE_REGISTER (pcREG[0x0F], 0x00000100); + + WRITE_REGISTER (uhREG[0x00], 0x00000010); // (Low byte only) + WRITE_REGISTER (uhREG[0x01], 0x00000000); + WRITE_REGISTER (uhREG[0x02], 0x00000000); + WRITE_REGISTER (uhREG[0x03], 0x00000000); + WRITE_REGISTER (uhREG[0x04], 0x00000000); + WRITE_REGISTER (uhREG[0x05], 0x00000000); + WRITE_REGISTER (uhREG[0x06], 0x00000000); + WRITE_REGISTER (uhREG[0x07], 0x00000000); + WRITE_REGISTER (uhREG[0x08], 0x00000000); + WRITE_REGISTER (uhREG[0x09], 0x00000000); + WRITE_REGISTER (uhREG[0x0A], 0x00000000); + WRITE_REGISTER (uhREG[0x0B], 0x00000000); + WRITE_REGISTER (uhREG[0x0C], 0x00000000); + WRITE_REGISTER (uhREG[0x0D], 0x00002EDF); + WRITE_REGISTER (uhREG[0x0E], 0x00000000); + WRITE_REGISTER (uhREG[0x0F], 0x00000000); + WRITE_REGISTER (uhREG[0x10], 0x00000000); // (Low word only) + WRITE_REGISTER (uhREG[0x11], 0x00000628); + WRITE_REGISTER (uhREG[0x12], 0x00001102); + WRITE_REGISTER (uhREG[0x13], 0x00000000); + WRITE_REGISTER (uhREG[0x14], 0x00000000); + WRITE_REGISTER (uhREG[0x15], 0x00000000); + WRITE_REGISTER (uhREG[0x16], 0x00000000); + + WRITE_REGISTER (fpREG[0x00], 0x00000000); + WRITE_REGISTER (fpREG[0x01], 0x00000000); + WRITE_REGISTER (fpREG[0x02], 0x0FFCFCFF); + WRITE_REGISTER (fpREG[0x03], 0x00000000); + WRITE_REGISTER (fpREG[0x04], 0x00000000); + WRITE_REGISTER (fpREG[0x05], 0x00000000); + WRITE_REGISTER (fpREG[0x06], 0x00000000); + WRITE_REGISTER (fpREG[0x07], 0x00000000); + WRITE_REGISTER (fpREG[0x0A], 0xF0030000); + WRITE_REGISTER (fpREG[0x0B], 0x00000000); // (Low 12-bits only) + WRITE_REGISTER (fpREG[0x0E], 0x00000000); // (Low byte only) + WRITE_REGISTER (fpREG[0x0F], 0x00000000); + + // (No reset values for color palette and source FIFO) + + WRITE_REGISTER (udREG[0x00], 0x00000000); + WRITE_REGISTER (udREG[0x01], 0x00000000); + WRITE_REGISTER (udREG[0x02], 0x00000000); + WRITE_REGISTER (udREG[0x03], 0x00000000); + WRITE_REGISTER (udREG[0x04], 0x00000000); + WRITE_REGISTER (udREG[0x05], 0x00000000); + WRITE_REGISTER (udREG[0x06], 0x00000000); + WRITE_REGISTER (udREG[0x07], 0x00000000); + WRITE_REGISTER (udREG[0x08], 0x00000000); + WRITE_REGISTER (udREG[0x09], 0x00000000); + WRITE_REGISTER (udREG[0x0A], 0x00000000); + WRITE_REGISTER (udREG[0x0B], 0x00000000); // (Low byte only) + WRITE_REGISTER (udREG[0x0C], 0x00000000); + WRITE_REGISTER (udREG[0x0D], 0x00000000); + WRITE_REGISTER (udREG[0x0E], 0x00000000); + WRITE_REGISTER (udREG[0x0F], 0x00000000); + WRITE_REGISTER (udREG[0x00], 0x00000000); + WRITE_REGISTER (udREG[0x01], 0x00000000); + WRITE_REGISTER (udREG[0x02], 0x00000000); + + // Because DC00R is reset to zero, establish the + // byteswapping lanes corresponding to that. + + this->PrvUpdateByteLanes (); + + fLastAddress = EmMemNULL; + fLastSize = 0; + + fBlitInProgress = false; + + this->PrvGetGEState (kAllRegisters); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::Save +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::Save (SessionFile& f) +{ + const long kCurrentMediaQVersion = 1; + + EmRegs::Save (f); + + Chunk chunk; + EmStreamChunk s (chunk); + + s << kCurrentMediaQVersion; + + s.PutBytes (fRegs.GetPtr (), fRegs.GetSize ()); + + f.WriteMediaQRegsType (chunk); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::Load +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::Load (SessionFile& f) +{ + EmRegs::Load (f); + + Chunk chunk; + + if (!f.ReadMediaQRegsType (chunk)) + { + f.SetCanReload (false); + } + else + { + long version; + + EmStreamChunk s (chunk); + + s >> version; + + if (version >= 1) + { + s.GetBytes (fRegs.GetPtr (), fRegs.GetSize ()); + } + } + + this->PrvUpdateByteLanes (); + + // !!! Save and restore these? + + fLastAddress = EmMemNULL; + fLastSize = 0; + + fBlitInProgress = false; + + this->PrvGetGEState (kAllRegisters); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::Dispose +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::Dispose (void) +{ + EmRegs::Dispose (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::SetSubBankHandlers (void) +{ + // Install base handlers. + + EmRegs::SetSubBankHandlers (); + + // Now add standard/specialized handers for the defined registers. + + INSTALL_HANDLER (MQRead, MQWrite, ccREG[0x00]); + INSTALL_HANDLER (CC01Read, MQWrite, ccREG[0x01]); + INSTALL_HANDLER (MQRead, MQWrite, ccREG[0x02]); + INSTALL_HANDLER (MQRead, MQWrite, ccREG[0x03]); + INSTALL_HANDLER (MQRead, MQWrite, ccREG[0x04]); + + INSTALL_HANDLER (MQRead, MQWrite, mmREG[0x00]); + INSTALL_HANDLER (MQRead, MQWrite, mmREG[0x01]); + INSTALL_HANDLER (MQRead, MQWrite, mmREG[0x02]); + INSTALL_HANDLER (MQRead, MQWrite, mmREG[0x03]); + INSTALL_HANDLER (MQRead, MQWrite, mmREG[0x04]); + + INSTALL_HANDLER (MQRead, MQWrite, inREG[0x00]); + INSTALL_HANDLER (MQRead, MQWrite, inREG[0x01]); + INSTALL_HANDLER (MQRead, MQWrite, inREG[0x02]); + INSTALL_HANDLER (MQRead, MQWrite, inREG[0x03]); + + INSTALL_HANDLER (MQRead, invalidateWrite, gcREG[0x00]); // BPP (et al) + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x01]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x02]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x03]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x04]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x05]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x06]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x07]); + INSTALL_HANDLER (MQRead, invalidateWrite, gcREG[0x08]); // Width + INSTALL_HANDLER (MQRead, invalidateWrite, gcREG[0x09]); // Height + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x0A]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x0B]); + INSTALL_HANDLER (MQRead, invalidateWrite, gcREG[0x0C]); // Base Address + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x0D]); + INSTALL_HANDLER (MQRead, invalidateWrite, gcREG[0x0E]); // Stride + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x0F]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x10]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x11]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x12]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x13]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x14]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x15]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x16]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x17]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x18]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x19]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x1A]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x1B]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x1C]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x1D]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x1E]); + INSTALL_HANDLER (MQRead, MQWrite, gcREG[0x1F]); + + INSTALL_HANDLER (MQRead, GE00Write, geREG[0x00]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x01]); + INSTALL_HANDLER (MQRead, GE02Write, geREG[0x02]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x03]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x04]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x05]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x06]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x07]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x08]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x09]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x0A]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x0B]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x0C]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x0D]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x0E]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x0F]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x10]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x11]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x12]); + INSTALL_HANDLER (MQRead, MQWrite, geREG[0x13]); + + INSTALL_HANDLER (MQRead, MQWrite, ssREG[0x00]); + INSTALL_HANDLER (MQRead, MQWrite, ssREG[0x01]); + INSTALL_HANDLER (MQRead, MQWrite, ssREG[0x04]); // Skip some here + INSTALL_HANDLER (MQRead, MQWrite, ssREG[0x08]); // Skip some here + INSTALL_HANDLER (MQRead, MQWrite, ssREG[0x09]); + INSTALL_HANDLER (MQRead, MQWrite, ssREG[0x0A]); + INSTALL_HANDLER (MQRead, MQWrite, ssREG[0x0B]); + INSTALL_HANDLER (MQRead, MQWrite, ssREG[0x0C]); + INSTALL_HANDLER (MQRead, MQWrite, ssREG[0x0D]); + INSTALL_HANDLER (MQRead, MQWrite, ssREG[0x10]); // Skip some here + INSTALL_HANDLER (MQRead, MQWrite, ssREG[0x11]); + INSTALL_HANDLER (MQRead, MQWrite, ssREG[0x12]); + INSTALL_HANDLER (MQRead, MQWrite, ssREG[0x13]); + INSTALL_HANDLER (MQRead, MQWrite, ssREG[0x14]); + INSTALL_HANDLER (MQRead, MQWrite, ssREG[0x15]); + + INSTALL_HANDLER (MQRead, MQWrite, spREG[0x00]); + INSTALL_HANDLER (MQRead, MQWrite, spREG[0x01]); + INSTALL_HANDLER (MQRead, MQWrite, spREG[0x02]); + INSTALL_HANDLER (MQRead, MQWrite, spREG[0x03]); + INSTALL_HANDLER (MQRead, MQWrite, spREG[0x04]); + INSTALL_HANDLER (MQRead, MQWrite, spREG[0x05]); + INSTALL_HANDLER (MQRead, MQWrite, spREG[0x06]); + INSTALL_HANDLER (MQRead, MQWrite, spREG[0x07]); + INSTALL_HANDLER (MQRead, MQWrite, spREG[0x08]); + + INSTALL_HANDLER (MQRead, DC00Write, dcREG[0x00]); + INSTALL_HANDLER (MQRead, MQWrite, dcREG[0x01]); + INSTALL_HANDLER (MQRead, MQWrite, dcREG[0x02]); + INSTALL_HANDLER (MQRead, MQWrite, dcREG[0x03]); + INSTALL_HANDLER (MQRead, MQWrite, dcREG[0x04]); + INSTALL_HANDLER (MQRead, MQWrite, dcREG[0x05]); + INSTALL_HANDLER (MQRead, MQWrite, dcREG[0x06]); + INSTALL_HANDLER (MQRead, MQWrite, dcREG[0x07]); + + INSTALL_HANDLER (MQRead, MQWrite, pcREG[0x00]); + INSTALL_HANDLER (MQRead, MQWrite, pcREG[0x01]); + INSTALL_HANDLER (MQRead, MQWrite, pcREG[0x02]); + INSTALL_HANDLER (MQRead, MQWrite, pcREG[0x03]); + INSTALL_HANDLER (MQRead, MQWrite, pcREG[0x04]); + INSTALL_HANDLER (MQRead, MQWrite, pcREG[0x05]); + INSTALL_HANDLER (MQRead, MQWrite, pcREG[0x0B]); // Skip some here + INSTALL_HANDLER (MQRead, MQWrite, pcREG[0x0F]); // Skip some here + + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x00]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x01]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x02]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x03]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x04]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x05]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x06]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x07]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x08]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x09]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x0A]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x0B]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x0C]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x0D]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x0E]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x0F]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x10]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x11]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x12]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x13]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x14]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x15]); + INSTALL_HANDLER (MQRead, MQWrite, uhREG[0x16]); + + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x00]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x01]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x02]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x03]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x04]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x05]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x06]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x07]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x08]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x09]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x0A]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x0B]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x0E]); // Skip some here + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x0F]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x10]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x11]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x12]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x13]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x14]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x15]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x16]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x17]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x18]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x19]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x1A]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x1B]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x1C]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x1D]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x1E]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x1F]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x20]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x21]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x22]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x23]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x24]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x25]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x26]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x27]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x28]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x29]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x2A]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x2B]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x2C]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x2D]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x2E]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x2F]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x30]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x31]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x32]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x33]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x34]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x35]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x36]); + INSTALL_HANDLER (MQRead, MQWrite, fpREG[0x37]); + + this->SetHandler ( (ReadFunction) &EmRegsMediaQ11xx::MQRead, + (WriteFunction) &EmRegsMediaQ11xx::invalidateWrite, + addressof (cpREG), 0x0400); + + this->SetHandler ( (ReadFunction) &EmRegsMediaQ11xx::MQRead, + (WriteFunction) &EmRegsMediaQ11xx::SourceFifoWrite, + addressof (sfREG), 0x0400); + + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x00]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x01]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x02]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x03]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x04]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x05]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x06]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x07]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x08]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x09]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x0A]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x0B]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x0C]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x0D]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x0E]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x0F]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x10]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x11]); + INSTALL_HANDLER (MQRead, MQWrite, udREG[0x12]); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmRegsMediaQ11xx::GetRealAddress (emuptr address) +{ + return (uint8*) fRegs.GetPtr () + (address - this->GetAddressStart ()); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::GetAddressStart +// --------------------------------------------------------------------------- + +emuptr EmRegsMediaQ11xx::GetAddressStart (void) +{ + return fBaseRegsAddr; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::GetAddressRange +// --------------------------------------------------------------------------- + +uint32 EmRegsMediaQ11xx::GetAddressRange (void) +{ + return fRegs.GetSize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsMediaQ11xx::GetLCDScreenOn (void) +{ + return ((READ_REGISTER (gcREG[GC_CONTROL]) & GC_ENABLE) != 0); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsMediaQ11xx::GetLCDBacklightOn (void) +{ + return true; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::GetLCDHasFrame +// --------------------------------------------------------------------------- + +Bool EmRegsMediaQ11xx::GetLCDHasFrame (void) +{ + return true; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::GetLCDBeginEnd +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::GetLCDBeginEnd (emuptr& begin, emuptr& end) +{ + int32 height = this->PrvGetHeight (); + int32 rowBytes = this->PrvGetRowBytes (); + emuptr baseAddr = this->PrvGetFrameBuffer (); + + begin = baseAddr; + end = baseAddr + rowBytes * height; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::GetLCDScanlines +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::GetLCDScanlines (EmScreenUpdateInfo& info) +{ + // Get the screen metrics. + int32 bpp = this->PrvGetBPP (); + int32 width = this->PrvGetWidth (); + int32 height = this->PrvGetHeight (); + int32 rowBytes = this->PrvGetRowBytes (); + emuptr baseAddr = this->PrvGetFrameBuffer (); + +#ifdef _DEBUG + Bool xDoubling = this->PrvGetXDoubling (); + Bool yDoubling = this->PrvGetYDoubling (); + + EmAssert (xDoubling == 0 && yDoubling == 0); +#endif + + info.fLeftMargin = 0; + + if (bpp <= 8) + { + EmPixMapFormat format = bpp == 1 ? kPixMapFormat1 : + bpp == 2 ? kPixMapFormat2 : + bpp == 4 ? kPixMapFormat4 : + kPixMapFormat8; + + RGBList colorTable; + this->PrvGetPalette (colorTable); + + // Set format, size, and color table of EmPixMap. + + info.fImage.SetSize (EmPoint (width, height)); + info.fImage.SetFormat (format); + info.fImage.SetRowBytes (rowBytes); + info.fImage.SetColorTable (colorTable); + + // Determine first and last scanlines to fetch, and fetch them. + + info.fFirstLine = (info.fScreenLow - baseAddr) / rowBytes; + info.fLastLine = (info.fScreenHigh - baseAddr - 1) / rowBytes + 1; + + long firstLineOffset = info.fFirstLine * rowBytes; + long lastLineOffset = info.fLastLine * rowBytes; + + EmMem_memcpy ( + (void*) ((uint8*) info.fImage.GetBits () + firstLineOffset), + baseAddr + firstLineOffset, + lastLineOffset - firstLineOffset); + } + else + { + // Set depth, size, and color table of EmPixMap. + + info.fImage.SetSize (EmPoint (width, height)); + info.fImage.SetFormat (kPixMapFormat24RGB); + + // Determine first and last scanlines to fetch. + + info.fFirstLine = (info.fScreenLow - baseAddr) / rowBytes; + info.fLastLine = (info.fScreenHigh - baseAddr - 1) / rowBytes + 1; + + // Get location and rowBytes of source bytes. + + uint8* srcStart = EmMemGetRealAddress (baseAddr); + int32 srcRowBytes = rowBytes; + uint8* srcPtr = srcStart + srcRowBytes * info.fFirstLine; + uint8* srcPtr0 = srcPtr; + + // Get location and rowBytes of destination bytes. + + uint8* destStart = (uint8*) info.fImage.GetBits (); + int32 destRowBytes = info.fImage.GetRowBytes (); + uint8* destPtr = destStart + destRowBytes * info.fFirstLine; + uint8* destPtr0 = destPtr; + + // Get height of range to copy. + + int32 height = info.fLastLine - info.fFirstLine; + + // Copy the pixels from source to dest. + + for (int yy = 0; yy < height; ++yy) + { + for (int xx = 0; xx < width; ++xx) + { + uint8 p1 = EmMemDoGet8 (srcPtr++); // GGGBBBBB + uint8 p2 = EmMemDoGet8 (srcPtr++); // RRRRRGGG + + // Merge the two together so that we get RRRRRGGG GGGBBBBB + + uint16 p; + + p = (p1 << 8) | p2; + + // Shift the bits around, forming RRRRRrrr, GGGGGGgg, and + // BBBBBbbb values, where the lower-case bits are copies of + // the least significant bits in the upper-case bits. + // + // Note that all of this could also be done with three 64K + // lookup tables. If speed is an issue, we might want to + // investigate that. + + if (bpp == 1) + { + uint8 green = ((p >> 3) & 0xFC) | ((p >> 5) & 0x03); + *destPtr++ = green; + *destPtr++ = green; + *destPtr++ = green; + } + else + { + *destPtr++ = ((p >> 8) & 0xF8) | ((p >> 11) & 0x07); + *destPtr++ = ((p >> 3) & 0xFC) | ((p >> 5) & 0x03); + *destPtr++ = ((p << 3) & 0xF8) | ((p >> 0) & 0x07); + } + } + + srcPtr = srcPtr0 += srcRowBytes; + destPtr = destPtr0 += destRowBytes; + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::MQRead +// --------------------------------------------------------------------------- + +uint32 EmRegsMediaQ11xx::MQRead (emuptr address, int size) +{ + // Determine the offset from the beginning of the register memory range + // to the location we want to read. + + uint32 offset = address - this->GetAddressStart (); + + EmAssert (offset < this->GetAddressRange ()); + + // Determine the index for the register being read (treating the entire + // memory range as an array of 32-bit values), and determine the delta + // into the register. + + int index = offset / 4; + int delta = offset - (index * 4); + + EmAssert (delta >= 0); + EmAssert (delta < 4); + + // Get the pointer to the register to read from. + + UInt32 value; + UInt8* p = (UInt8*) fRegs.ccREG[index].GetPtr (); + + if (size == 4) + { + // Make sure we're reading the whole register. + + if ((delta & 3) != 0) + this->AddressError (address, size, true); + + // Get a pointer to the "bytelanes" array that will sort out + // any 32-bit or 16-bit byteswapping for us. + + int* bytelanes = &this->fBytelanes[delta]; + + // Read the value a byte at a time, reconstructing it according + // to the byteswapping rules. + + value = + (((UInt32) p[bytelanes[0]]) << 24) | + (((UInt32) p[bytelanes[1]]) << 16) | + (((UInt32) p[bytelanes[2]]) << 8) | + (((UInt32) p[bytelanes[3]]) << 0); + } + else if (size == 2) + { + // Make sure we're reading from an even address. + // !!! This is really a characteristic of the host + // CPU and bus, not the MediaQ chip. + + if ((delta & 1) != 0) + this->AddressError (address, size, true); + + // Get a pointer to the "bytelanes" array that will sort out + // any 32-bit or 16-bit byteswapping for us. + + int* bytelanes = &this->fBytelanes[delta]; + + // Read the value a byte at a time, reconstructing it according + // to the byteswapping rules. + + value = + (((UInt32) p[bytelanes[0]]) << 8) | + (((UInt32) p[bytelanes[1]]) << 0); + } + else if (size == 1) + { + // Get a pointer to the "bytelanes" array that will sort out + // any 32-bit or 16-bit byteswapping for us. + + int* bytelanes = &this->fBytelanes[delta]; + + // Read the value a byte at a time, reconstructing it according + // to the byteswapping rules. + + value = + (((UInt32) p[bytelanes[0]]) << 0); + } + else + { + EmAssert (false); + value = 0; + } + + return value; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::MQWrite +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::MQWrite (emuptr address, int size, uint32 value) +{ + // Determine the offset from the beginning of the register memory range + // to the location we want to update. + + uint32 offset = address - this->GetAddressStart (); + + EmAssert (offset < this->GetAddressRange ()); + + // Determine the index for the register being updated (treating the entire + // memory range as an array of 32-bit values), and determine the delta + // into the register. + + int index = offset / 4; + int delta = offset - (index * 4); + + EmAssert (delta >= 0); + EmAssert (delta < 4); + + // Get the pointer to the register to update. + + UInt8* p = (UInt8*) fRegs.ccREG[index].GetPtr (); + + if (size == 4) + { + // Make sure we're updating the whole register. + + if ((delta & 3) != 0) + this->AddressError (address, size, false); + + // Get a pointer to the "bytelanes" array that will sort out + // any 32-bit or 16-bit byteswapping for us. + + int* bytelanes = &this->fBytelanes[delta]; + + // Write the value a byte at a time, using the bytelanes array + // to sort out the byteswapping for us. + + p[bytelanes[0]] = value >> 24; + p[bytelanes[1]] = value >> 16; + p[bytelanes[2]] = value >> 8; + p[bytelanes[3]] = value >> 0; + } + else if (size == 2) + { + // Make sure we're updating to an even address. + // !!! This is really a characteristic of the host + // CPU and bus, not the MediaQ chip. + + if ((delta & 1) != 0) + this->AddressError (address, size, false); + + // Get a pointer to the "bytelanes" array that will sort out + // any 32-bit or 16-bit byteswapping for us. + + int* bytelanes = &this->fBytelanes[delta]; + + // Write the value a byte at a time, using the bytelanes array + // to sort out the byteswapping for us. + + p[bytelanes[0]] = value >> 8; + p[bytelanes[1]] = value >> 0; + } + else if (size == 1) + { + // Get a pointer to the "bytelanes" array that will sort out + // any 32-bit or 16-bit byteswapping for us. + + int* bytelanes = &this->fBytelanes[delta]; + + // Write the value a byte at a time, using the bytelanes array + // to sort out the byteswapping for us. + + p[bytelanes[0]] = value >> 0; + } + else + { + EmAssert (false); + } + + fLastAddress = address; + fLastSize = size; + + if (index >= 0x080 && index <= 0x093) + { + this->PrvGetGEState (index - 0x080); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::CC01Read +// --------------------------------------------------------------------------- + +uint32 EmRegsMediaQ11xx::CC01Read (emuptr address, int size) +{ + // Update the Command FIFO size. + // Update the Source FIFO size. + // Also make sure the busy bit is clear. + + uint32 CC01 = READ_REGISTER (ccREG[0x01]); + + CC01 = (CC01 & ~CMD_FIFO_MASK) | (CMD_FIFO_EMPTY & CMD_FIFO_MASK); + CC01 = (CC01 & ~CMD_SRC_MASK) | (CMD_SRC_EMPTY & CMD_SRC_MASK); + CC01 = CC01 & ~GE_BUSY_H; + + WRITE_REGISTER (ccREG[0x01], CC01); + + // Perform a standard read. + + uint32 result = MQRead (address, size); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::DC00Write +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::DC00Write (emuptr address, int size, uint32 value) +{ + // Perform a standard update. + + this->MQWrite (address, size, value); + + this->PrvUpdateByteLanes (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::GE00Write +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::GE00Write (emuptr address, int size, uint32 value) +{ + emuptr lastAddress = this->fLastAddress; + int lastSize = this->fLastSize; + + // Perform a standard update. + + this->MQWrite (address, size, value); + + // If a command was issued, execute it (if autoExecute is false). + + uint32 reg = READ_REGISTER (geREG[0]); + + if ((reg & (1 << 27)) == 0) + { + if (size == 4) + { + this->PrvDoCommand (); + } + else if (size == 2 && lastSize == 2 && address == (lastAddress + 2)) + { + this->PrvDoCommand (); + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::GE02Write +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::GE02Write (emuptr address, int size, uint32 value) +{ + emuptr lastAddress = this->fLastAddress; + int lastSize = this->fLastSize; + + // Perform a standard update. + + this->MQWrite (address, size, value); + + // If a command was issued, execute it (if autoExecute is true). + + uint32 reg = READ_REGISTER (geREG[0]); + + if ((reg & (1 << 27)) != 0) + { + if (size == 4) + { + this->PrvDoCommand (); + } + else if (size == 2 && lastSize == 2 && address == (lastAddress + 2)) + { + this->PrvDoCommand (); + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::SourceFifoWrite +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::SourceFifoWrite (emuptr address, int size, uint32 value) +{ + emuptr lastAddress = this->fLastAddress; + int lastSize = this->fLastSize; + + // Perform a standard update. + + this->MQWrite (address, size, value); + + // If a complete entry was added, push it onto the FIFO, and give the + // blitter a chance to run. + + if (size == 4) + { + value = READ_REGISTER (sfREG[(address >> 2) & 0x0FF]); + fSourceFifo.push_back (value); + this->PrvIncBlitterRun (); + } + else if (size == 2 && lastSize == 2 && address == (lastAddress + 2)) + { + value = READ_REGISTER (sfREG[(address >> 2) & 0x0FF]); + fSourceFifo.push_back (value); + this->PrvIncBlitterRun (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::invalidateWrite +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::invalidateWrite (emuptr address, int size, uint32 value) +{ + // Perform a standard update. + + this->MQWrite (address, size, value); + + // Invalidate the entire LCD area so that it can get redrawn with + // the new palette information. + + EmScreen::InvalidateAll (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::AddressError +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::AddressError (emuptr address, long size, Bool forRead) +{ + EmAssert (false); + EmAssert (gCPU68K); + gCPU68K->AddressError (address, size, forRead); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvGetPalette +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvGetPalette (RGBList& thePalette) +{ + int32 bpp = this->PrvGetBPP (); + int32 numColors = 1 << bpp; + + thePalette.resize (numColors); + + for (int ii = 0; ii < numColors; ++ii) + { + uint32 reg = READ_REGISTER (cpREG[ii]); + + thePalette[ii].fRed = (reg & RED_MASK) >> 0; + thePalette[ii].fGreen = (reg & GREEN_MASK) >> 8; + thePalette[ii].fBlue = (reg & BLUE_MASK) >> 16; + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvUpdateByteLanes +// --------------------------------------------------------------------------- +/* + Figuring out byteswapping: + + Our source code has the following function for writing data to registers: + + void sREGW (volatile UCHAR* addr, ULONG data) + { + UInt16 _data16; + UInt16* dc00R = (UInt16*) (MMIO_BASE + DC_BASE); + + if (*dc00R & 1) // no need to swap data (16BPP mode) within word16 + { + *((UInt16*) addr) = (UInt16) data; // write without swap + *((UInt16*) (addr + 2)) = (UInt16) __rol (data, 16); // get next word16 + } + else + { + _data16 = (UInt16) (data); + _data16 = __rol (_data16, 8); // bswap for Big Endian + *((UInt16*) addr) = _data16; + + _data16 = (UInt16) __rol (data, 16); // get next word16 + _data16 = __rol (_data16, 8); // bswap for Big Endian + *((UInt16 *)(addr + 2)) = _data16; + } + } + + My assumption here is that we want to take a data pattern like 0x01234567 + and end up with it stored in the register as 67 45 23 01. Working from + the code above, if byteswapping is off, we execute the following: + + *((UInt16*) addr) = (UInt16) data; // write without swap + *((UInt16*) (addr + 2)) = (UInt16) __rol (data, 16); // get next word16 + + or: + + *((UInt16*) addr) = 0x4567; // write without swap + *((UInt16*) (addr + 2)) = 0x0123; // get next word16 + + In order for this to result in the right bytes getting written to the + right places in memory, 16-bit byteswapping must be on at the hardware + level. Confirming with the code in the "else" statement: + + _data16 = (UInt16) (data); + _data16 = __rol (_data16, 8); // bswap for Big Endian + *((UInt16*) addr) = _data16; + + _data16 = (UInt16) __rol (data, 16); // get next word16 + _data16 = __rol (_data16, 8); // bswap for Big Endian + *((UInt16 *)(addr + 2)) = _data16; + + or: + + _data16 = 0x4567; + _data16 = 0x6745; // bswap for Big Endian + *((UInt16*) addr) = 0x6745; + + _data16 = 0x0123; // get next word16 + _data16 = 0x2301; // bswap for Big Endian + *((UInt16 *)(addr + 2)) = 0x2301; + + In this case, if 16-bit byteswapping is turned on in the device + configuration register, then that will counteract the byteswapping + performed by the hardware. If, however, 32-bit byteswapping is + enabled in the device configuration register, I'm not sure what + will happen. + + Let's take a look at another example. Registers are often written + using the geREG16 macro. This macro is called twice in order to + update the whole 32-bit register: + + geREG16( GE_WIDTH_L, width ); + geREG16( GE_HEIGHT_H, height ); + + Where: + + #define GE_WIDTH_L (GE_WIDTH_HEIGHT) // 40204h + #define GE_HEIGHT_H (GE_WIDTH_HEIGHT + 2) // 40206h + + There is also a geREG macro used to update the whole 32-bit register + at once: + + geREG( GE_DEST_XY, dstAddr ); + + I find a number of definitions of these macros. The two sets that + appear most likely to be the ones used in our ROM are as follows: + + # mqgeHAL.h + + #define geREG16(id, data) *(pGE16 + (id)) = (UInt16)(data) + #define geREG(id, data) *(pGE + (id)) = (UInt32)(data) + + # mqge.h + + #define geREG16(id, data) *((UInt16 *)(pGE + id)) = __rol( data, 8 ) + #define geREG(id, data) \ + { \ + register UInt32 _data32; \ + _data32 = (data); \ + geREG16(id, (UInt16)_data32); \ + geREG16((id + 2), (UInt16)(_data32 >> 16) ); \ + } + + The second set appears to be more consistant with our first + study case, so let's assume that it represents what's going + on in our ROM. + + What's left unclear is what really happens when writing a 32-bit + value to a 32-bit register, and how the 64-bit source data FIFO + is handled. +*/ + +void EmRegsMediaQ11xx::PrvUpdateByteLanes (void) +{ + // Read the register. + + uint32 reg = READ_REGISTER (dcREG[0x00]); + + // Adjust the bytelanes array to reflect the byteswapping options. + // Without any other adjustments, it appears that the CPU bytelanes + // are set up to swap 16-bit values with the MediaQ chip. + + this->fBytelanes[0] = 1; + this->fBytelanes[1] = 0; + this->fBytelanes[2] = 3; + this->fBytelanes[3] = 2; + + if ((reg & 1) == 1) + { + // Enable little endian mode. Byte swapping is not performed on data. + + } + else if ((reg & 2) == 2) + { + // Enable 32-bit byte swapping for big endian to little endian conversion. + // byte0 <-> byte3, byte1 <-> byte2 + + std::swap (this->fBytelanes[0], this->fBytelanes[3]); + std::swap (this->fBytelanes[1], this->fBytelanes[2]); + } + else + { + // Enable 16-bit Byte swapping for big endian to little endian conversion. + // byte0 <-> byte1, byte2 <-> byte3 + + std::swap (this->fBytelanes[0], this->fBytelanes[1]); + std::swap (this->fBytelanes[2], this->fBytelanes[3]); + } +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvGetGEState +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvGetGEState (int regNum) +{ + uint32 reg; + + // ==================== GE00R ==================== + + if (regNum == kAllRegisters || regNum == 0) + { + reg = READ_REGISTER (geREG[0x00]); + + fState.rasterOperation = (reg >> 0) & 0x000000FF; + fState.commandType = (reg >> 8) & 0x00000007; + fState.xDirection = (reg >> 11) & 0x00000001; + fState.yDirection = (reg >> 12) & 0x00000001; + fState.systemMemory = (reg >> 13) & 0x00000001; + fState.monoSource = (reg >> 14) & 0x00000001; + fState.monoPattern = (reg >> 15) & 0x00000001; + fState.colorTransEnable = (reg >> 16) & 0x00000001; + fState.destTransPolarity = (reg >> 17) & 0x00000001; + fState.monoTransEnable = (reg >> 18) & 0x00000001; + fState.monoTransPolarity = (reg >> 19) & 0x00000001; + fState.memToScreen = (reg >> 20) & 0x00000001; + fState.solidSourceColor = (reg >> 23) & 0x00000001; + fState.srcEqualDestStride = (reg >> 24) & 0x00000001; + fState.rop2Select = (reg >> 25) & 0x00000001; + fState.clipEnable = (reg >> 26) & 0x00000001; + fState.autoExecute = (reg >> 27) & 0x00000001; + fState.solidPattern = (reg >> 30) & 0x00000001; + fState.colorTransCmpSrc = (reg >> 31) & 0x00000001; + } + + // ==================== GE01R ==================== + + if (regNum == kAllRegisters || regNum == 1) + { + reg = READ_REGISTER (geREG[0x01]); + + // BitBLT + + fState.width = (reg >> 0) & 0x00000FFF; + fState.height = (reg >> 16) & 0x00000FFF; + fState.xyConversion = (reg >> 31) & 0x00000001; + + // Line + + fState.gamma = (reg >> 0) & 0x0001FFFF; fState.gamma |= 0xFFFE0000; + fState.majorLength = (reg >> 17) & 0x00000FFF; + fState.yIsMajor = (reg >> 29) & 0x00000001; + fState.drawLastPixel = (reg >> 30) & 0x00000001; + fState.useXY = (reg >> 31) & 0x00000001; + } + + // ==================== GE02R ==================== + + if (regNum == kAllRegisters || regNum == 2) + { + reg = READ_REGISTER (geREG[0x02]); + + // BitBLT + + fState.xDest = (reg >> 0) & 0x00000FFF; + fState.monoPatternXOffset = (reg >> 13) & 0x00000007; + fState.yDest = (reg >> 16) & 0x00000FFF; + fState.monoPatternYOffset = (reg >> 29) & 0x00000007; + + // Line + + fState.xStart = (reg >> 0) & 0x00000FFF; + fState.deltaMajor = (reg >> 12) & 0x0001FFFF; + fState.quadrant = (reg >> 29) & 0x00000007; + } + + // ==================== GE03R ==================== + + if (regNum == kAllRegisters || regNum == 3) + { + reg = READ_REGISTER (geREG[0x03]); + + // BitBLT + + fState.xSrc = (reg >> 0) & 0x00000FFF; + fState.ySrc = (reg >> 16) & 0x00000FFF; + + // Line + + fState.yStart = (reg >> 0) & 0x00000FFF; + fState.deltaMinor = (reg >> 12) & 0x0001FFFF; + } + + // ==================== GE04R ==================== + + if (regNum == kAllRegisters || regNum == 4) + { + reg = READ_REGISTER (geREG[0x04]); + + fState.destTransColor = (reg >> 0) & 0x0000FFFF; + } + + // ==================== GE05R ==================== + + if (regNum == kAllRegisters || regNum == 5) + { + reg = READ_REGISTER (geREG[0x05]); + + fState.clipLeft = (reg >> 0) & 0x000007FF; + fState.clipTop = (reg >> 16) & 0x000003FF; + } + + // ==================== GE06R ==================== + + if (regNum == kAllRegisters || regNum == 6) + { + reg = READ_REGISTER (geREG[0x06]); + + fState.clipRight = (reg >> 0) & 0x000007FF; + fState.clipBottom = (reg >> 16) & 0x000003FF; + } + + // ==================== GE07R ==================== + + if (regNum == kAllRegisters || regNum == 7) + { + reg = READ_REGISTER (geREG[0x07]); + + fState.fgColorMonoSrc = (reg >> 0) & 0x0000FFFF; + } + + // ==================== GE08R ==================== + + if (regNum == kAllRegisters || regNum == 8) + { + reg = READ_REGISTER (geREG[0x08]); + + fState.bgColorMonoSrc = (reg >> 0) & 0x0000FFFF; + } + + // ==================== GE09R ==================== + + if (regNum == kAllRegisters || regNum == 9) + { + reg = READ_REGISTER (geREG[0x09]); + + // Lined Mode + + fState.srcLineStride = (reg >> 0) & 0x000003FF; + fState.srcBitOffset = (reg >> 25) & 0x00000007; + fState.srcByteOffset = (reg >> 28) & 0x00000007; + + // Packed Mode + + fState.srcLeadingBits = (reg >> 0) & 0x00000007; + fState.srcLeadingBytes = (reg >> 3) & 0x00000007; + fState.srcNumBytes = (reg >> 6) & 0x000003FF; + fState.srcTrailingBits = (reg >> 25) & 0x00000007; + fState.srcTrailingBytes = (reg >> 28) & 0x0000000F; + } + + // ==================== GE0AR ==================== + + if (regNum == kAllRegisters || regNum == 10) + { + reg = READ_REGISTER (geREG[0x0A]); + + fState.destLineStride = (reg >> 0) & 0x000003FF; + fState.monoSrcBitSwap = (reg >> 28) & 0x00000001; + fState.rotate90 = (reg >> 29) & 0x00000001; + fState.colorDepth = (reg >> 30) & 0x00000003; + } + + // ==================== GE0BR ==================== + + if (regNum == kAllRegisters || regNum == 11) + { + reg = READ_REGISTER (geREG[0x0B]); + + fState.baseAddr = (reg >> 0) & 0x000FFFFF; + } + + // ==================== GE0CR ==================== + + if (regNum == kAllRegisters || regNum == 12) + { + reg = READ_REGISTER (geREG[0x0C]); + + fState.cmdLineStart = (reg >> 0) & 0x000003FF; + fState.cmdLineEnd = (reg >> 12) & 0x000003FF; + fState.cmdLineControl = (reg >> 24) & 0x00000001; + fState.gc1SwitchControl = (reg >> 26) & 0x00000003; + } + + // ==================== GE0FR ==================== + + // ==================== GE10R ==================== + + if (regNum == kAllRegisters || regNum == 16) + { + reg = READ_REGISTER (geREG[0x10]); + + fState.monoPattern1 = (reg >> 0) & 0xFFFFFFFF; + } + + // ==================== GE11R ==================== + + if (regNum == kAllRegisters || regNum == 17) + { + reg = READ_REGISTER (geREG[0x11]); + + fState.monoPattern2 = (reg >> 0) & 0xFFFFFFFF; + } + + // ==================== GE12R ==================== + + if (regNum == kAllRegisters || regNum == 18) + { + reg = READ_REGISTER (geREG[0x12]); + + fState.fgColorMonoPat = (reg >> 0) & 0x0000FFFF; + } + + // ==================== GE13R ==================== + + if (regNum == kAllRegisters || regNum == 19) + { + reg = READ_REGISTER (geREG[0x13]); + + fState.bgColorMonoPat = (reg >> 0) & 0x0000FFFF; + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvLogGEState +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvLogGEState (void) +{ + LogAppendMsg ("========================================"); + + // ==================== GE00R ==================== + + LogAppendMsg ("GC00R:"); + LogAppendMsg (" xDoubling %s", this->PrvGetXDoubling () ? "TRUE" : "FALSE"); + LogAppendMsg (" yDoubling %s", this->PrvGetYDoubling () ? "TRUE" : "FALSE"); + LogAppendMsg (""); + + // ==================== GE00R ==================== + + LogAppendMsg ("GE00R:"); + LogAppendMsg (" rasterOperation 0x%02X (%s)", fState.rasterOperation, kROPs[fState.rasterOperation]); + LogAppendMsg (" commandType %u (%s)", fState.commandType, kCommands[fState.commandType]); + LogAppendMsg (" xDirection %u (%s)", fState.xDirection, kDirections[fState.xDirection]); + LogAppendMsg (" yDirection %u (%s)", fState.yDirection, kDirections[fState.yDirection]); + LogAppendMsg (" systemMemory %u", fState.systemMemory); + LogAppendMsg (" monoSource %u", fState.monoSource); + LogAppendMsg (" monoPattern %u", fState.monoPattern); + LogAppendMsg (" colorTransEnable %u", fState.colorTransEnable); + LogAppendMsg (" destTransPolarity %u (Transparent if pixel is %s to test color)", fState.destTransPolarity, fState.destTransPolarity ? "NOT equal" : "equal"); + LogAppendMsg (" monoTransEnable %u", fState.monoTransEnable); + LogAppendMsg (" monoTransPolarity %u", fState.monoTransPolarity); + LogAppendMsg (" memToScreen %u (%s)", fState.memToScreen, fState.memToScreen ? "PACKED" : "LINED"); + LogAppendMsg (" solidSourceColor %u", fState.solidSourceColor); + LogAppendMsg (" srcEqualDestStride %u", fState.srcEqualDestStride); + LogAppendMsg (" rop2Select %u", fState.rop2Select); + LogAppendMsg (" clipEnable %u", fState.clipEnable); + LogAppendMsg (" autoExecute %u", fState.autoExecute); + LogAppendMsg (" solidPattern %u", fState.solidPattern); + LogAppendMsg (" colorTransCmpSrc %u (Compare to %s)", fState.colorTransCmpSrc, fState.colorTransCmpSrc ? "Destination" : "Source"); + LogAppendMsg (""); + + // ==================== GE01R ==================== + + // BitBLT + + if (fState.commandType == kCommandBitBLT) + { + LogAppendMsg ("GE01R (BitBLT):"); + LogAppendMsg (" width %u", fState.width); + LogAppendMsg (" height %u", fState.height); + LogAppendMsg (" xyConversion %u", fState.xyConversion); + LogAppendMsg (""); + } + + // Line + + if (fState.commandType == kCommandLine) + { + LogAppendMsg ("GE01R (Line):"); + LogAppendMsg (" gamma %d", fState.gamma); + LogAppendMsg (" majorLength %u", fState.majorLength); + LogAppendMsg (" yIsMajor %u", fState.yIsMajor); + LogAppendMsg (" drawLastPixel %u", fState.drawLastPixel); + LogAppendMsg (" useXY %u", fState.useXY); + LogAppendMsg (""); + } + + // ==================== GE02R ==================== + + // BitBLT + + if (fState.commandType == kCommandBitBLT) + { + LogAppendMsg ("GE02R (BitBLT):"); + LogAppendMsg (" xDest %u", fState.xDest); + LogAppendMsg (" yDest %u", fState.yDest); + LogAppendMsg (" monoPatternXOffset %u", fState.monoPatternXOffset); + LogAppendMsg (" monoPatternYOffset %u", fState.monoPatternYOffset); + LogAppendMsg (""); + } + + // Line + + if (fState.commandType == kCommandLine) + { + LogAppendMsg ("GE02R (Line):"); + LogAppendMsg (" xStart %u", fState.xStart); + LogAppendMsg (" deltaMajor %u", fState.deltaMajor); + LogAppendMsg (" quadrant %u (%s)", fState.quadrant, kQuadrantDecode[fState.quadrant].text); + LogAppendMsg (""); + } + + // ==================== GE03R ==================== + + // BitBLT + + if (fState.commandType == kCommandBitBLT) + { + LogAppendMsg ("GE03R (BitBLT):"); + LogAppendMsg (" xSrc %u", fState.xSrc); + LogAppendMsg (" ySrc %u", fState.ySrc); + LogAppendMsg (""); + } + + // Line + + if (fState.commandType == kCommandLine) + { + LogAppendMsg ("GE03R (Line):"); + LogAppendMsg (" yStart %u", fState.yStart); + LogAppendMsg (" deltaMinor %u", fState.deltaMinor); + LogAppendMsg (""); + } + + // ==================== GE04R ==================== + + if (fState.colorTransEnable) + { + LogAppendMsg ("GE04R:"); + LogAppendMsg (" destTransColor 0x%04X", fState.destTransColor); + LogAppendMsg (""); + } + + // ==================== GE05R/GE06R ==================== + + if (fState.clipEnable) + { + LogAppendMsg ("GE05R/GE06R:"); + LogAppendMsg (" clipLeft %u", fState.clipLeft); + LogAppendMsg (" clipTop %u", fState.clipTop); + LogAppendMsg (" clipRight %u", fState.clipRight); + LogAppendMsg (" clipBottom %u", fState.clipBottom); + LogAppendMsg (""); + } + + // ==================== GE07R/GE08R ==================== + + if (fState.monoSource) + { + LogAppendMsg ("GE07R/GE08R:"); + LogAppendMsg (" fgColorMonoSrc 0x%04X", fState.fgColorMonoSrc); + LogAppendMsg (" bgColorMonoSrc 0x%04X", fState.bgColorMonoSrc); + LogAppendMsg (""); + } + + // ==================== GE09R ==================== + + // Lined Mode + + if (fState.memToScreen == 0) + { + LogAppendMsg ("GE09R (Lined):"); + LogAppendMsg (" srcLineStride %u", fState.srcLineStride); + LogAppendMsg (" srcBitOffset %u", fState.srcBitOffset); + LogAppendMsg (" srcByteOffset %u", fState.srcByteOffset); + LogAppendMsg (""); + } + + // Packed Mode + + if (fState.memToScreen == 1) + { + LogAppendMsg ("GE09R (Packed):"); + LogAppendMsg (" srcLeadingBits %u", fState.srcLeadingBits); + LogAppendMsg (" srcLeadingBytes %u", fState.srcLeadingBytes); + LogAppendMsg (" srcNumBytes %u", fState.srcNumBytes); + LogAppendMsg (" srcTrailingBits %u", fState.srcTrailingBits); + LogAppendMsg (" srcTrailingBytes %u", fState.srcTrailingBytes); + LogAppendMsg (""); + } + + // ==================== GE0AR ==================== + + LogAppendMsg ("GE0AR:"); + LogAppendMsg (" destLineStride %u", fState.destLineStride); + LogAppendMsg (" monoSrcBitSwap %u", fState.monoSrcBitSwap); + LogAppendMsg (" rotate90 %u", fState.rotate90); + LogAppendMsg (" colorDepth %u", fState.colorDepth); + LogAppendMsg (""); + + // ==================== GE0BR ==================== + + LogAppendMsg ("GE0AR:"); + LogAppendMsg (" baseAddr 0x%08X", fState.baseAddr); + LogAppendMsg (""); + + // ==================== GE0CR ==================== + + LogAppendMsg ("GE0CR:"); + LogAppendMsg (" cmdLineStart %u", fState.cmdLineStart); + LogAppendMsg (" cmdLineEnd %u", fState.cmdLineEnd); + LogAppendMsg (" cmdLineControl %u", fState.cmdLineControl); + LogAppendMsg (" gc1SwitchControl %u", fState.gc1SwitchControl); + LogAppendMsg (""); + + // ==================== GE0FR ==================== + + // ==================== GE10R/GE11R ==================== + + if (fState.monoPattern) + { + LogAppendMsg ("GE10R/GE11R:"); + LogAppendMsg (" monoPattern1 0x%08X", fState.monoPattern1); + LogAppendMsg (" monoPattern2 0x%08X", fState.monoPattern2); + LogAppendMsg (""); + } + + // ==================== GE12R/GE13R ==================== + + if (fState.monoPattern) + { + LogAppendMsg ("GE12R/GE13R:"); + LogAppendMsg (" fgColorMonoPat 0x%04X", fState.fgColorMonoPat); + LogAppendMsg (" bgColorMonoPat 0x%04X", fState.bgColorMonoPat); + } + + LogAppendMsg ("========================================"); + + if (fState.commandType == kCommandBitBLT) + { + EmAssert (!( + (fState.width == 25) && + (fState.height == 19) && + (fState.xDest == 0) && + (fState.yDest == 320) && + (fState.xSrc == 0) && + (fState.ySrc == 320) && + 1)); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvDoCommand +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvDoCommand (void) +{ + switch (fState.commandType) + { + case kCommandNOP: + // NOP command -- do nothing + break; + + case kCommandBitBLT: + this->PrvDoBitBLT (); + break; + + case kCommandLine: + this->PrvDoLine (); + break; + + default: + this->PrvIllegalCommand (); + break; + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvDoBitBLT +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvDoBitBLT (void) +{ + this->PrvIncBlitterInit (); + this->PrvIncBlitterRun (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvDoLine +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvDoLine (void) +{ + PRINTF_LINE (" PrvDoLine: &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"); + +#if LOG_LINE + this->PrvLogGEState (); +#endif + + // Draw a line using the information in the GE registers, + // using a Bresenham line drawing algorithm. For a good + // tutorial on this algorithm, see: + // + // <http://www.gamedev.net/reference/articles/article1275.asp> + + // Figure out our starting and ending points. The starting + // point is in the registers. The ending point needs to + // be determined by looking at deltaMajor, deltaMinor, the + // flag that says if the major is the X or Y access, and the + // X and Y directions. + + uint16 yIsMajor; // 0 = x is major, 1 = y is major + uint16 xDirection; // 0 = x is positive, 1 = x is negative + uint16 yDirection; // 0 = y is positive, 1 = y is negative + + if (fState.useXY) + { + yIsMajor = fState.yIsMajor; + xDirection = fState.xDirection; + yDirection = fState.yDirection; + } + else + { + yIsMajor = kQuadrantDecode[fState.quadrant].yIsMajor; + xDirection = kQuadrantDecode[fState.quadrant].xDirection; + yDirection = kQuadrantDecode[fState.quadrant].yDirection; + } + + PRINTF_LINE (" yIsMajor: %d", yIsMajor); + PRINTF_LINE (" xDirection: %d", xDirection); + PRINTF_LINE (" yDirection: %d", yDirection); + + // Get the starting x,y position. We'll be updating these + // variables as we draw the line. + + uint16 x = fState.xStart; + uint16 y = fState.yStart; + + PRINTF_LINE (" x: %d", x); + PRINTF_LINE (" y: %d", y); + + // Get the direction in which the x,y coordinates needs to + // be updated. + + int xAdjust = xDirection ? -1 : 1; + int yAdjust = yDirection ? -1 : 1; + + PRINTF_LINE (" xAdjust: %d", xAdjust); + PRINTF_LINE (" yAdjust: %d", yAdjust); + + // Based on which axis is the major axis, get pointers to + // the major and minor coordinates and the values that will + // be used to update them. + + uint16* major; + uint16* minor; + + int majorAdjust; + int minorAdjust; + + if (yIsMajor) + { + major = &y; + minor = &x; + + majorAdjust = yAdjust; + minorAdjust = xAdjust; + } + else + { + major = &x; + minor = &y; + + majorAdjust = xAdjust; + minorAdjust = yAdjust; + } + + PRINTF_LINE (" major: %d", *major); + PRINTF_LINE (" minor: %d", *minor); + + PRINTF_LINE (" majorAdjust: %d", majorAdjust); + PRINTF_LINE (" minorAdjust: %d", minorAdjust); + + PRINTF_LINE (" gamma: %d", fState.gamma); + PRINTF_LINE (" majorLength: %d", fState.majorLength); + PRINTF_LINE (" deltaMajor: %d", fState.deltaMajor); + + PRINTF_LINE (" ..................."); + + // Initialize "error" (which is used to determine when we + // need to increment the minor axis coordinate) and "count" + // (which is used to iterate over the major axis). + + int error = 0; + uint16 count = 0; + + // Iterate over all the points along the major axis. + + while (count < fState.majorLength) + { + PRINTF_LINE (" count: %d", count); + PRINTF_LINE (" major: %d", *major); + PRINTF_LINE (" minor: %d", *minor); + + // Plot a point. + + uint16 src = 0; // Dummy value. The ROP had better not be one that makes use of a source pixel! + uint16 pen = fState.fgColorMonoPat; + uint16 dest = this->PrvGetPixel (x, y); + + uint16 output = this->PrvAdjustPixel (pen, src, dest, fState.rasterOperation); + + this->PrvSetPixel (output, x, y); + + // Update the major axis coordinate and adjust the error factor. + + *major += majorAdjust; + error += 2 * fState.deltaMinor; + + // See if it's time to update the minor access coordinate. + + if (error > fState.deltaMajor) + { + // Update the minor axis coordinate and adjust the error factor. + + *minor += minorAdjust; + error -= 2 * fState.deltaMajor; + } + + // Keep track of how many points we've plotted. + + count += 1; + } + + PRINTF_LINE (" ..................."); + + // If we need to draw the last pixel, then do it. + + if (fState.drawLastPixel) + { + PRINTF_LINE (" count: %d", count); + PRINTF_LINE (" major: %d", *major); + PRINTF_LINE (" minor: %d", *minor); + + PRINTF_LINE (" ..................."); + + uint16 src = 0; // Dummy value. The ROP had better not be one that makes use of a source pixel! + uint16 pen = fState.fgColorMonoPat; + uint16 dest = this->PrvGetPixel (x, y); + + uint16 output = this->PrvAdjustPixel (pen, src, dest, fState.rasterOperation); + + this->PrvSetPixel (output, x, y); + } + + PRINTF_LINE (" PrvDoLine: &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvIllegalCommand +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvIllegalCommand (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvSrcFifoFilledSlots +// --------------------------------------------------------------------------- + +int EmRegsMediaQ11xx::PrvSrcFifoFilledSlots (void) +{ + return fSourceFifo.size () / 2; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvGetSrcFifoSlot +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvGetSrcFifoSlot (uint32& a, uint32& b) +{ + a = fSourceFifo[0]; + fSourceFifo.erase (fSourceFifo.begin ()); + + b = fSourceFifo[0]; + fSourceFifo.erase (fSourceFifo.begin ()); +} + + +// --------------------------------------------------------------------------- +// Drawing Functions +// --------------------------------------------------------------------------- + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvAdjustPixel +// --------------------------------------------------------------------------- + +uint16 EmRegsMediaQ11xx::PrvAdjustPixel (uint16 pen, uint16 dest, uint8 rOpCode) +{ + uint16 result; + + /* + (From MSDN) + + Each raster-operation code represents a Boolean operation in which the + values of the pixels in the selected pen and the destination bitmap are + combined. The following are the two operands used in these operations. + + Operand Meaning + ------- ------- + P Selected pen + D Destination bitmap + + The Boolean operators used in these operations follow. + + Operator Meaning + -------- ------- + a Bitwise AND + n Bitwise NOT (inverse) + o Bitwise OR + x Bitwise exclusive OR (XOR) + + All Boolean operations are presented in reverse Polish notation. For + example, the following operation replaces the values of the pixels in + the destination bitmap with a combination of the pixel values of the + pen and the selected brush: + + DPo + + Each raster-operation code is a 32-bit integer whose high-order word + is a Boolean operation index and whose low-order word is the operation + code. The 16-bit operation index is a zero-extended 8-bit value that + represents all possible outcomes resulting from the Boolean operation + on two parameters (in this case, the pen and destination values). For + example, the operation indexes for the DPo and DPan operations are shown + in the following list. + + P D DPo Dpan + 0 0 0 1 + 0 1 1 1 + 1 0 1 1 + 1 1 1 0 + + The following list outlines the drawing modes and the Boolean operations + that they represent. + + Raster operation Boolean operation + ---------------- ----------------- + R2_BLACK 0 + R2_COPYPEN P + R2_MASKNOTPEN DPna + R2_MASKPEN DPa + R2_MASKPENNOT PDna + R2_MERGENOTPEN DPno + R2_MERGEPEN DPo + R2_MERGEPENNOT PDno + R2_NOP D + R2_NOT Dn + R2_NOTCOPYPEN Pn + R2_NOTMASKPEN DPan + R2_NOTMERGEPEN DPon + R2_NOTXORPEN DPxn + R2_WHITE 1 + R2_XORPEN DPx + */ + + switch (rOpCode) + { + case 0: /* 0 */ + result = 0; + break; + + case 1: /* DPon */ + result = ~(dest | pen); + break; + + case 2: /* DPna */ + result = dest & ~pen; + break; + + case 3: /* PN */ + result = ~pen; + break; + + case 4: /* PDna */ + result = pen & ~dest; + break; + + case 5: /* Dn */ + result = ~dest; + break; + + case 6: /* DPx */ + result = dest ^ pen; + break; + + case 7: /* DPan */ + result = ~(dest & pen); + break; + + case 8: /* DPa */ + result = dest & pen; + break; + + case 9: /* DPxn */ + result = ~(dest ^ pen); + break; + + case 10: /* D */ + result = dest; + break; + + case 11: /* DPno */ + result = dest | ~pen; + break; + + case 12: /* P */ + result = pen; + break; + + case 13: /* PDno */ + result = pen & ~dest; + break; + + case 14: /* DPo */ + result = dest | pen; + break; + + case 15: /* 1 */ + result = ~0; + break; + + default: + EmAssert (false); + result = 0; + break; + } + +#ifdef _DEBUG + // Double-check the special cases with the generalized code. + + { + const int kNumBits = 8 * sizeof (result); + + uint16 result2 = 0; + + for (int bitNumber = 0; bitNumber < kNumBits; ++bitNumber) + { + uint8 index = (((pen >> bitNumber) & 1) << 1) | + (((dest >> bitNumber) & 1) << 0); + + result2 |= (((rOpCode >> index) & 1) << bitNumber); + } + + EmAssert (result == result2); + } +#endif + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvAdjustPixel +// --------------------------------------------------------------------------- + +uint16 EmRegsMediaQ11xx::PrvAdjustPixel (uint16 pattern, uint16 src, uint16 dest, uint8 rOpCode) +{ + uint16 result; + + /* + (From MSDN) + + Each raster-operation code represents a Boolean operation in which + the values of the pixels in the source, the selected brush, and the + destination are combined. The following are the three operands used + in these operations. + + Operand Meaning + ------- ------- + D Destination bitmap + P Selected brush (also called pattern) + S Source bitmap + + Boolean operators used in these operations follow. + + Operator Meaning + -------- ------- + a Bitwise AND + n Bitwise NOT (inverse) + o Bitwise OR + x Bitwise exclusive OR (XOR) + + --------------------------------------------------------------------- + + (From Keith) + + Here's another way to think about it: take the pattern, source, and + destination, and consider each value one bit at a time. The three + bits from the three values can form eight combinations. The raster + opcode is a bitfield containing the desired output from each of the + combinations. Thus: + + P S D O (output) + --- --- --- --- + 0 0 0 b0 + 0 0 1 b1 + 0 1 0 b2 + 0 1 1 b3 + 1 0 0 b4 + 1 0 1 b5 + 1 1 0 b6 + 1 1 1 b7 + + The output is the byte <b7><b6><b5><b4><b3><b2><b1><b0>. And this + output value is what becomes the raster opcode. Thus, if the raster + opcode is, for example, 0xCC, the table would be: + + P S D O (output) + --- --- --- --- + 0 0 0 0 + 0 0 1 0 + 0 1 0 1 + 0 1 1 1 + 1 0 0 0 + 1 0 1 0 + 1 1 0 1 + 1 1 1 1 + + So, the we look at three bits from the source and they're all zero, + then the output is zero. If they're all one, then the output is + one. If the pattern is one and the source and destination are zero, + then the output is zero. Overall, + + Output[x] = ROP[P[x],S[x],D[x]] + + where "x" is 0..7, and "P[x],S[x],D[x]" is a bitfield composed of + the given bits. + + We will use this generalization for the default case. However, for + the most common raster ops, we can manipulate all bits of all the + incumbant values simultaneously. We special-case those opcodes. + */ + + switch (rOpCode) + { + case 0x00: // 00000042 0 BLACKNESS + result = 0; + break; + + // case 0x01: // 00010289 DPSoon – + // case 0x02: // 00020C89 DPSona – + // case 0x03: // 000300AA PSon – + // case 0x04: // 00040C88 SDPona – + // case 0x05: // 000500A9 DPon – + // case 0x06: // 00060865 PDSxnon – + // case 0x07: // 000702C5 PDSaon – + // case 0x08: // 00080F08 SDPnaa – + // case 0x09: // 00090245 PDSxon – + case 0x0A: // 000A0329 DPna – + result = dest & ~pattern; + break; + + // case 0x0B: // 000B0B2A PSDnaon – + // case 0x0C: // 000C0324 SPna – + // case 0x0D: // 000D0B25 PDSnaon – + // case 0x0E: // 000E08A5 PDSonon – + case 0x0F: // 000F0001 Pn – + result = ~pattern; + break; + + // case 0x10: // 00100C85 PDSona – + case 0x11: // 001100A6 DSon NOTSRCERASE + result = ~(dest | src); + break; + + // case 0x12: // 00120868 SDPxnon – + // case 0x13: // 001302C8 SDPaon – + // case 0x14: // 00140869 DPSxnon – + // case 0x15: // 001502C9 DPSaon – + // case 0x16: // 00165CCA PSDPSanaxx – + // case 0x17: // 00171D54 SSPxDSxaxn – + // case 0x18: // 00180D59 SPxPDxa – + // case 0x19: // 00191CC8 SDPSanaxn – + // case 0x1A: // 001A06C5 PDSPaox – + // case 0x1B: // 001B0768 SDPSxaxn – + // case 0x1C: // 001C06CA PSDPaox – + // case 0x1D: // 001D0766 DSPDxaxn – + // case 0x1E: // 001E01A5 PDSox – + // case 0x1F: // 001F0385 PDSoan – + // case 0x20: // 00200F09 DPSnaa – + // case 0x21: // 00210248 SDPxon – + case 0x22: // 00220326 DSna – + result = dest & ~src; + break; + + // case 0x23: // 00230B24 SPDnaon – + // case 0x24: // 00240D55 SPxDSxa – + // case 0x25: // 00251CC5 PDSPanaxn – + // case 0x26: // 002606C8 SDPSaox – + // case 0x27: // 00271868 SDPSxnox – + // case 0x28: // 00280369 DPSxa – + // case 0x29: // 002916CA PSDPSaoxxn – + // case 0x2A: // 002A0CC9 DPSana – + // case 0x2B: // 002B1D58 SSPxPDxaxn – + // case 0x2C: // 002C0784 SPDSoax – + // case 0x2D: // 002D060A PSDnox – + // case 0x2E: // 002E064A PSDPxox – + // case 0x2F: // 002F0E2A PSDnoan – + // case 0x30: // 0030032A PSna – + // case 0x31: // 00310B28 SDPnaon – + // case 0x32: // 00320688 SDPSoox – + case 0x33: // 00330008 Sn NOTSRCCOPY + result = ~src; + break; + + // case 0x34: // 003406C4 SPDSaox – + // case 0x35: // 00351864 SPDSxnox – + // case 0x36: // 003601A8 SDPox – + // case 0x37: // 00370388 SDPoan – + // case 0x38: // 0038078A PSDPoax – + // case 0x39: // 00390604 SPDnox – + // case 0x3A: // 003A0644 SPDSxox – + // case 0x3B: // 003B0E24 SPDnoan – + // case 0x3C: // 003C004A PSx – + // case 0x3D: // 003D18A4 SPDSonox – + // case 0x3E: // 003E1B24 SPDSnaox – + // case 0x3F: // 003F00EA PSan – + // case 0x40: // 00400F0A PSDnaa – + // case 0x41: // 00410249 DPSxon – + // case 0x42: // 00420D5D SDxPDxa – + // case 0x43: // 00431CC4 SPDSanaxn – + case 0x44: // 00440328 SDna SRCERASE + result = src & ~dest; + break; + + // case 0x45: // 00450B29 DPSnaon – + // case 0x46: // 004606C6 DSPDaox – + // case 0x47: // 0047076A PSDPxaxn – + // case 0x48: // 00480368 SDPxa – + // case 0x49: // 004916C5 PDSPDaoxxn – + // case 0x4A: // 004A0789 DPSDoax – + // case 0x4B: // 004B0605 PDSnox – + // case 0x4C: // 004C0CC8 SDPana – + // case 0x4D: // 004D1954 SSPxDSxoxn – + // case 0x4E: // 004E0645 PDSPxox – + // case 0x4F: // 004F0E25 PDSnoan – + // case 0x50: // 00500325 PDna – + // case 0x51: // 00510B26 DSPnaon – + // case 0x52: // 005206C9 DPSDaox – + // case 0x53: // 00530764 SPDSxaxn – + // case 0x54: // 005408A9 DPSonon – + case 0x55: // 00550009 Dn DSTINVERT + result = ~dest; + break; + + // case 0x56: // 005601A9 DPSox – + // case 0x57: // 00570389 DPSoan – + // case 0x58: // 00580785 PDSPoax – + // case 0x59: // 00590609 DPSnox – + case 0x5A: // 005A0049 DPx PATINVERT + result = dest ^ pattern; + break; + + // case 0x5B: // 005B18A9 DPSDonox – + // case 0x5C: // 005C0649 DPSDxox – + // case 0x5D: // 005D0E29 DPSnoan – + // case 0x5E: // 005E1B29 DPSDnaox – + case 0x5F: // 005F00E9 DPan – + result = ~(dest & pattern); + break; + + // case 0x60: // 00600365 PDSxa – + // case 0x61: // 006116C6 DSPDSaoxxn – + // case 0x62: // 00620786 DSPDoax – + // case 0x63: // 00630608 SDPnox – + // case 0x64: // 00640788 SDPSoax – + // case 0x65: // 00650606 DSPnox – + case 0x66: // 00660046 DSx SRCINVERT + result = dest ^ src; + break; + + // case 0x67: // 006718A8 SDPSonox – + // case 0x68: // 006858A6 DSPDSonoxxn – + // case 0x69: // 00690145 PDSxxn – + // case 0x6A: // 006A01E9 DPSax – + // case 0x6B: // 006B178A PSDPSoaxxn – + // case 0x6C: // 006C01E8 SDPax – + // case 0x6D: // 006D1785 PDSPDoaxxn – + // case 0x6E: // 006E1E28 SDPSnoax – + // case 0x6F: // 006F0C65 PDSxnan – + // case 0x70: // 00700CC5 PDSana – + // case 0x71: // 00711D5C SSDxPDxaxn – + // case 0x72: // 00720648 SDPSxox – + // case 0x73: // 00730E28 SDPnoan – + // case 0x74: // 00740646 DSPDxox – + // case 0x75: // 00750E26 DSPnoan – + // case 0x76: // 00761B28 SDPSnaox – + case 0x77: // 007700E6 DSan – + result = ~(dest & src); + break; + + // case 0x78: // 007801E5 PDSax – + // case 0x79: // 00791786 DSPDSoaxxn – + // case 0x7A: // 007A1E29 DPSDnoax – + // case 0x7B: // 007B0C68 SDPxnan – + // case 0x7C: // 007C1E24 SPDSnoax – + // case 0x7D: // 007D0C69 DPSxnan – + // case 0x7E: // 007E0955 SPxDSxo – + // case 0x7F: // 007F03C9 DPSaan – + // case 0x80: // 008003E9 DPSaa – + // case 0x81: // 00810975 SPxDSxon – + // case 0x82: // 00820C49 DPSxna – + // case 0x83: // 00831E04 SPDSnoaxn – + // case 0x84: // 00840C48 SDPxna – + // case 0x85: // 00851E05 PDSPnoaxn – + // case 0x86: // 008617A6 DSPDSoaxx – + // case 0x87: // 008701C5 PDSaxn – + case 0x88: // 008800C6 DSa SRCAND + result = dest & src; + break; + + // case 0x89: // 00891B08 SDPSnaoxn – + // case 0x8A: // 008A0E06 DSPnoa – + // case 0x8B: // 008B0666 DSPDxoxn – + // case 0x8C: // 008C0E08 SDPnoa – + // case 0x8D: // 008D0668 SDPSxoxn – + // case 0x8E: // 008E1D7C SSDxPDxax – + // case 0x8F: // 008F0CE5 PDSanan – + // case 0x90: // 00900C45 PDSxna – + // case 0x91: // 00911E08 SDPSnoaxn – + // case 0x92: // 009217A9 DPSDPoaxx – + // case 0x93: // 009301C4 SPDaxn – + // case 0x94: // 009417AA PSDPSoaxx – + // case 0x95: // 009501C9 DPSaxn – + // case 0x96: // 00960169 DPSxx – + // case 0x97: // 0097588A PSDPSonoxx – + // case 0x98: // 00981888 SDPSonoxn – + case 0x99: // 00990066 DSxn – + result = ~(dest ^ src); + break; + + // case 0x9A: // 009A0709 DPSnax – + // case 0x9B: // 009B07A8 SDPSoaxn – + // case 0x9C: // 009C0704 SPDnax – + // case 0x9D: // 009D07A6 DSPDoaxn – + // case 0x9E: // 009E16E6 DSPDSaoxx – + // case 0x9F: // 009F0345 PDSxan – + case 0xA0: // 00A000C9 DPa – + result = dest & pattern; + break; + + // case 0xA1: // 00A11B05 PDSPnaoxn – + // case 0xA2: // 00A20E09 DPSnoa – + // case 0xA3: // 00A30669 DPSDxoxn – + // case 0xA4: // 00A41885 PDSPonoxn – + case 0xA5: // 00A50065 PDxn – + result = ~(pattern ^ dest); + break; + + // case 0xA6: // 00A60706 DSPnax – + // case 0xA7: // 00A707A5 PDSPoaxn – + // case 0xA8: // 00A803A9 DPSoa – + // case 0xA9: // 00A90189 DPSoxn – + // case 0xAA: // 00AA0029 D – + // case 0xAB: // 00AB0889 DPSono – + // case 0xAC: // 00AC0744 SPDSxax – + // case 0xAD: // 00AD06E9 DPSDaoxn – + // case 0xAE: // 00AE0B06 DSPnao – + case 0xAF: // 00AF0229 DPno – + result = dest | ~pattern; + break; + + // case 0xB0: // 00B00E05 PDSnoa – + // case 0xB1: // 00B10665 PDSPxoxn – + // case 0xB2: // 00B21974 SSPxDSxox – + // case 0xB3: // 00B30CE8 SDPanan – + // case 0xB4: // 00B4070A PSDnax – + // case 0xB5: // 00B507A9 DPSDoaxn – + // case 0xB6: // 00B616E9 DPSDPaoxx – + // case 0xB7: // 00B70348 SDPxan – + // case 0xB8: // 00B8074A PSDPxax – + // case 0xB9: // 00B906E6 DSPDaoxn – + // case 0xBA: // 00BA0B09 DPSnao – + case 0xBB: // 00BB0226 DSno MERGEPAINT + result = dest | ~src; + break; + + // case 0xBC: // 00BC1CE4 SPDSanax – + // case 0xBD: // 00BD0D7D SDxPDxan – + // case 0xBE: // 00BE0269 DPSxo – + // case 0xBF: // 00BF08C9 DPSano – + case 0xC0: // 00C000CA PSa MERGECOPY + result = pattern & src; + break; + + // case 0xC1: // 00C11B04 SPDSnaoxn – + // case 0xC2: // 00C21884 SPDSonoxn – + // case 0xC3: // 00C3006A PSxn – + // case 0xC4: // 00C40E04 SPDnoa – + // case 0xC5: // 00C50664 SPDSxoxn – + // case 0xC6: // 00C60708 SDPnax – + // case 0xC7: // 00C707AA PSDPoaxn – + // case 0xC8: // 00C803A8 SDPoa – + // case 0xC9: // 00C90184 SPDoxn – + // case 0xCA: // 00CA0749 DPSDxax – + // case 0xCB: // 00CB06E4 SPDSaoxn – + case 0xCC: // 00CC0020 S SRCCOPY + result = src; + break; + + // case 0xCD: // 00CD0888 SDPono – + // case 0xCE: // 00CE0B08 SDPnao – + // case 0xCF: // 00CF0224 SPno – + // case 0xD0: // 00D00E0A PSDnoa – + // case 0xD1: // 00D1066A PSDPxoxn – + // case 0xD2: // 00D20705 PDSnax – + // case 0xD3: // 00D307A4 SPDSoaxn – + // case 0xD4: // 00D41D78 SSPxPDxax – + // case 0xD5: // 00D50CE9 DPSanan – + // case 0xD6: // 00D616EA PSDPSaoxx – + // case 0xD7: // 00D70349 DPSxan – + // case 0xD8: // 00D80745 PDSPxax – + // case 0xD9: // 00D906E8 SDPSaoxn – + // case 0xDA: // 00DA1CE9 DPSDanax – + // case 0xDB: // 00DB0D75 SPxDSxan – + // case 0xDC: // 00DC0B04 SPDnao – + // case 0xDD: // 00DD0228 SDno – + // case 0xDE: // 00DE0268 SDPxo – + // case 0xDF: // 00DF08C8 SDPano – + // case 0xE0: // 00E003A5 PDSoa – + // case 0xE1: // 00E10185 PDSoxn – + // case 0xE2: // 00E20746 DSPDxax – + // case 0xE3: // 00E306EA PSDPaoxn – + // case 0xE4: // 00E40748 SDPSxax – + // case 0xE5: // 00E506E5 PDSPaoxn – + // case 0xE6: // 00E61CE8 SDPSanax – + // case 0xE7: // 00E70D79 SPxPDxan – + // case 0xE8: // 00E81D74 SSPxDSxax – + // case 0xE9: // 00E95CE6 DSPDSanaxxn – + // case 0xEA: // 00EA02E9 DPSao – + // case 0xEB: // 00EB0849 DPSxno – + // case 0xEC: // 00EC02E8 SDPao – + // case 0xED: // 00ED0848 SDPxno – + case 0xEE: // 00EE0086 DSo SRCPAINT + result = dest | src; + break; + + // case 0xEF: // 00EF0A08 SDPnoo – + case 0xF0: // 00F00021 P PATCOPY + result = pattern; + break; + + // case 0xF1: // 00F10885 PDSono – + // case 0xF2: // 00F20B05 PDSnao – + // case 0xF3: // 00F3022A PSno – + // case 0xF4: // 00F40B0A PSDnao – + // case 0xF5: // 00F50225 PDno – + // case 0xF6: // 00F60265 PDSxo – + // case 0xF7: // 00F708C5 PDSano – + // case 0xF8: // 00F802E5 PDSao – + // case 0xF9: // 00F90845 PDSxno – + case 0xFA: // 00FA0089 DPo – + result = dest | pattern; + break; + + case 0xFB: // 00FB0A09 DPSnoo PATPAINT + result = dest | (pattern | ~src); + break; + + // case 0xFC: // 00FC008A PSo – + // case 0xFD: // 00FD0A0A PSDnoo – + // case 0xFE: // 00FE02A9 DPSoo – + case 0xFF: // 00FF0062 1 WHITENESS + result = ~0; + break; + + default: + { + const int kNumBits = 8 * sizeof (result); + + result = 0; + + for (int bitNumber = 0; bitNumber < kNumBits; ++bitNumber) + { + uint8 index = (((pattern >> bitNumber) & 1) << 2) | + (((src >> bitNumber) & 1) << 1) | + (((dest >> bitNumber) & 1) << 0); + + result |= (((rOpCode >> index) & 1) << bitNumber); + } + } + break; + } + +#ifdef _DEBUG + // Double-check the special cases with the generalized code. + + { + const int kNumBits = 8 * sizeof (result); + + uint16 result2 = 0; + + for (int bitNumber = 0; bitNumber < kNumBits; ++bitNumber) + { + uint8 index = (((pattern >> bitNumber) & 1) << 2) | + (((src >> bitNumber) & 1) << 1) | + (((dest >> bitNumber) & 1) << 0); + + result2 |= (((rOpCode >> index) & 1) << bitNumber); + } + + EmAssert (result == result2); + } +#endif + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvSetPixel +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvSetPixel (uint16 pixel, uint16 x, uint16 y) +{ + emuptr pixelLocation = this->PrvGetPixelLocation (x, y); + + switch (fState.colorDepth) + { + case kColorDepth8: + EmMemPut8 (pixelLocation, pixel); + break; + + case kColorDepth16: + EmAssert (::IsEven (pixelLocation)); + EmMemPut16 (pixelLocation, pixel); + break; + + default: + EmAssert (false); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvGetPixel +// --------------------------------------------------------------------------- + +uint16 EmRegsMediaQ11xx::PrvGetPixel (uint16 x, uint16 y) +{ + uint16 result; + emuptr pixelLocation = this->PrvGetPixelLocation (x, y); + + switch (fState.colorDepth) + { + case kColorDepth8: + result = EmMemGet8 (pixelLocation); + break; + + case kColorDepth16: + EmAssert (::IsEven (pixelLocation)); + result = EmMemGet16 (pixelLocation); + break; + + default: + EmAssert (false); + result = 0; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvGetPixelLocation +// --------------------------------------------------------------------------- + +emuptr EmRegsMediaQ11xx::PrvGetPixelLocation (uint16 x, uint16 y) +{ + int bytesPerPixel; + + switch (fState.colorDepth) + { + case kColorDepth8: + bytesPerPixel = 1; + break; + + case kColorDepth16: + bytesPerPixel = 2; + break; + + default: + EmAssert (false); + return 0; + } + + if (fState.rotate90) + { + // Rotate 90 deg clockwise. + + /* + -----x y-- + |+--------------------+| + || || + y| 1 || + | 2 |x + | | + | | + | | + | | + | | + | | + | | + +--------------------+ + + Point 1 is the original point. + Point 2 is the rotated point. + */ + + int16 newX = fState.destLineStride * bytesPerPixel - y; + int16 newY = x; + + x = newX; + y = newY; + } + + emuptr frameBuffer = this->PrvGetVideoBase () + fState.baseAddr; + emuptr scanLine = frameBuffer + (y * fState.destLineStride); + emuptr scanByte = scanLine + (x * bytesPerPixel); + + EmAssert (scanByte >= fBaseVideoAddr); + EmAssert (scanByte + bytesPerPixel <= fBaseVideoAddr + MMIO_OFFSET); + + return scanByte; +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvIncBlitterInit +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvIncBlitterInit (void) +{ + PRINTF_BLIT (" PrvIncBlitterInit: &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"); + +#if LOG_BLIT + this->PrvLogGEState (); +#endif + + fBlitInProgress = true; + + fCurXOffset = 0; + fCurYOffset = 0; + + fUsesPattern = this->PrvUsesPattern (); + fUsesSource = this->PrvUsesSource (); + + if (!fUsesPattern) + PRINTF_BLIT (" PrvIncBlitterInit: pattern not used..."); + + if (!fUsesSource) + PRINTF_BLIT (" PrvIncBlitterInit: source data not used..."); + + if (fState.monoSource) + { + if (fState.monoTransEnable) + { + if (fState.monoTransPolarity) + { + PRINTF_BLIT (" PrvIncBlitterInit: Foreground is transparent..."); + } + else + { + PRINTF_BLIT (" PrvIncBlitterInit: Background is transparent..."); + } + } + } + else if (fState.colorTransEnable) + { + if (fState.destTransPolarity == 0) + { + if (fState.colorTransCmpSrc == 0) + { + PRINTF_BLIT (" PrvIncBlitterInit: Treat all destTransColor pixels in the source as transparent..."); + } + else + { + PRINTF_BLIT (" PrvIncBlitterInit: Leave all destTransColor pixels in the destination alone..."); + } + } + else + { + if (fState.colorTransCmpSrc == 0) + { + PRINTF_BLIT (" PrvIncBlitterInit: Transfer only destTransColor pixels from the source to the destination..."); + } + else + { + PRINTF_BLIT (" PrvIncBlitterInit: Update only destTransColor pixels in the destination with source pixels..."); + } + } + } + + this->PrvPatternPipeInit (); + this->PrvSrcPipeInit (); + this->PrvDestPipeInit (); + + PRINTF_BLIT (" PrvIncBlitterInit: &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvIncBlitterRun +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvIncBlitterRun (void) +{ + if (!fBlitInProgress) + return; + + static long counter = 0; + + PRINTF_BLIT (" PrvIncBlitterRun: **************************************************"); + PRINTF_BLIT (" PrvIncBlitterRun: counter: %u", ++counter); + PRINTF_BLIT (" PrvIncBlitterRun: **************************************************"); + + while (fBlitInProgress) + { + Bool stalled; + + // Get the relevent pixel values. + + uint16 source = this->PrvSrcPipeNextPixel (stalled); + + // If the source FIFO stalled (no more input data for now), + // return false, indicating that the BLT operation is still + // in progress. + + if (stalled) + { + PRINTF_BLIT (" PrvIncBlitterRun: stalled..."); + break; + } + + // Continue getting more pixel values. + + uint16 pattern = this->PrvPatternPipeNextPixel (); + uint16 dest = this->PrvDestPipeNextPixel (); + uint16 output = this->PrvAdjustPixel (pattern, source, dest, + fState.rasterOperation); + + PRINTF_BLIT (" PrvIncBlitterRun: pattern: 0x%04X", pattern); + PRINTF_BLIT (" PrvIncBlitterRun: source: 0x%04X", source); + PRINTF_BLIT (" PrvIncBlitterRun: dest: 0x%04X", dest); + PRINTF_BLIT (" PrvIncBlitterRun: output: 0x%04X", output); + + // Write this pixel as long as it's not transparent or clipped out. + + if (!this->PrvTransparent (source, dest, pattern) && !this->PrvClipped ()) + { + PRINTF_BLIT (" PrvIncBlitterRun: setting..."); + + this->PrvSetPixel (output, fXDest, fYDest); + } + else + { + PRINTF_BLIT (" PrvIncBlitterRun: skipping..."); + } + + // Move to the next X/Y position. + + fBlitInProgress = this->PrvNextXY (); + + if (!fBlitInProgress) + { + EmAssert (this->PrvSrcFifoFilledSlots () == 0); + PRINTF_BLIT (" PrvIncBlitterRun: Completed!"); + } + } + + PRINTF_BLIT (" PrvIncBlitterRun: **************************************************"); +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvPatternPipeInit +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvPatternPipeInit (void) +{ + fXPattern = fState.monoPatternXOffset; + fYPattern = fState.monoPatternYOffset; + + PRINTF_BLIT (" PrvPatternPipeInit: fXPattern: %u", fXPattern); + PRINTF_BLIT (" PrvPatternPipeInit: fYPattern: %u", fYPattern); + + // Expand the specified pattern into a pixel array. + + if (fUsesPattern) + { + // Force the pattern data to be a solid color, if specified. + + if (fState.solidPattern) + { + PRINTF_BLIT (" PrvPatternPipeInit: filling with: 0x%04X", + fState.fgColorMonoPat); + + for (int ii = 0; ii < 64; ++ii) + { + fPatternPipe [ii] = fState.fgColorMonoPat; + } + } + + // If the pattern is specified as a 64-bit array, expand it + // into a 64-byte array with the fore- and background colors set. + + else if (fState.monoPattern) + { + /* + A pattern is an 8x8 structure, for a total of 64 bits. + This is represented on the Palm as an 8 element array + of 8-bit bytes. When translated into MediaQ terms, they + are transferred to the registers with: + + gePAT16( GE_MONO_PAT0_L, *patPtr++ ); + gePAT16( GE_MONO_PAT0_H, *patPtr++ ); + gePAT16( GE_MONO_PAT1_L, *patPtr++ ); + gePAT16( GE_MONO_PAT1_H, *patPtr ); + + where "patPtr" is a UInt16*. Thus, when read back out + as two DWORDs, the LSB of monoPattern1 contains the first + byte of the pattern, the next LSB contains the second + byte, all the way up to where the MSB of monoPattern2 + contains the last byte. + */ + + PRINTF_BLIT (" PrvPatternPipeInit: expanding: 0x%08X 0x%08X", + fState.monoPattern1, fState.monoPattern2); + + this->PrvExpandMono32 (fState.monoPattern1, &fPatternPipe [0], + fState.fgColorMonoPat, fState.bgColorMonoPat); + + this->PrvExpandMono32 (fState.monoPattern2, &fPatternPipe [32], + fState.fgColorMonoPat, fState.bgColorMonoPat); + + uint16* p = fPatternPipe; + UNUSED_PARAM(p); + + PRINTF_BLIT (" PrvPatternPipeInit: 0: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); + PRINTF_BLIT (" PrvPatternPipeInit: 1: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[8+0], p[8+1], p[8+2], p[8+3], p[8+4], p[8+5], p[8+6], p[8+7]); + PRINTF_BLIT (" PrvPatternPipeInit: 2: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[16+0], p[16+1], p[16+2], p[16+3], p[16+4], p[16+5], p[16+6], p[16+7]); + PRINTF_BLIT (" PrvPatternPipeInit: 3: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[24+0], p[24+1], p[24+2], p[24+3], p[24+4], p[24+5], p[24+6], p[24+7]); + PRINTF_BLIT (" PrvPatternPipeInit: 4: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[32+0], p[32+1], p[32+2], p[32+3], p[32+4], p[32+5], p[32+6], p[32+7]); + PRINTF_BLIT (" PrvPatternPipeInit: 5: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[40+0], p[40+1], p[40+2], p[40+3], p[40+4], p[40+5], p[40+6], p[40+7]); + PRINTF_BLIT (" PrvPatternPipeInit: 6: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[48+0], p[48+1], p[48+2], p[48+3], p[48+4], p[48+5], p[48+6], p[48+7]); + PRINTF_BLIT (" PrvPatternPipeInit: 7: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[56+0], p[56+1], p[56+2], p[56+3], p[56+4], p[56+5], p[56+6], p[56+7]); + } + else + { + // The monoPattern bit MUST be programmed to 1, according to + // the docs. Color patterns don't appear to be supported. + + EmAssert (false); + } + } + + // We're not making use of any pattern data. + + else + { + // Do nothing. The pattern array will be garbage, but the theory + // here is that it's not going to be used. + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvPatternPipeNextPixel +// --------------------------------------------------------------------------- + +uint16 EmRegsMediaQ11xx::PrvPatternPipeNextPixel (void) +{ + uint16 result = fPatternPipe [fXPattern + fYPattern * 8]; + + PRINTF_BLIT (" PrvPatternPipeNextPixel: fXPattern: %u", fXPattern); + PRINTF_BLIT (" PrvPatternPipeNextPixel: fYPattern: %u", fYPattern); + PRINTF_BLIT (" PrvPatternPipeNextPixel: result: 0x%04X", result); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvPatternPipeNextX +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvPatternPipeNextX (void) +{ + ++fXPattern; + + if (fXPattern == 8) + { + fXPattern = 0; + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvPatternPipeNextY +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvPatternPipeNextY (void) +{ + ++fYPattern; + fXPattern = fState.monoPatternXOffset; + + if (fYPattern == 8) + { + fYPattern = 0; + } +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvSrcPipeInit +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvSrcPipeInit (void) +{ + fXSrc = fState.xSrc; + fYSrc = fState.ySrc; + + if (fState.xyConversion) + { + if (fState.xDirection) + fXSrc += fState.width - 1; + + if (fState.yDirection) + fYSrc += fState.height - 1; + } + + if (fUsesSource && !fState.solidSourceColor && fState.systemMemory) + { + fLeadingSourcePixels = this->PrvLeadingPixels (); + fTrailingSourcePixels = this->PrvTrailingPixels (); + + PRINTF_BLIT (" PrvSrcPipeInit: fLeadingSourcePixels: %u", fLeadingSourcePixels); + PRINTF_BLIT (" PrvSrcPipeInit: fTrailingSourcePixels: %u", fTrailingSourcePixels); + } + + // Setting both of these variables to the same value will force the + // source pipe to fill itself from the source data FIFO the first + // time we access it (assuming that that's where the source data is + // coming from). + + fSourcePipeIndex = 0; + fSourcePipeMax = 0; + + fSourcePipeSkip = fLeadingSourcePixels; + + PRINTF_BLIT (" PrvSrcPipeInit: fXSrc: %u", fXSrc); + PRINTF_BLIT (" PrvSrcPipeInit: fYSrc: %u", fYSrc); + PRINTF_BLIT (" PrvSrcPipeInit: fSourcePipeSkip: %u", fSourcePipeSkip); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvSrcPipeNextPixel +// --------------------------------------------------------------------------- + +uint16 EmRegsMediaQ11xx::PrvSrcPipeNextPixel (Bool& stalled) +{ + stalled = false; + + if (!fUsesSource) + { + // Return a dummy value. The theory here is that it's not + // going to be used. + + PRINTF_BLIT (" PrvSrcPipeNextPixel: result: <dummy>"); + + return 0; + } + + // Force the source data to be a solid color, if specified. + + if (fState.solidSourceColor) + { + PRINTF_BLIT (" PrvSrcPipeNextPixel: result: 0x%04X (solid)", fState.fgColorMonoSrc); + + return fState.fgColorMonoSrc; + } + + // If we're getting source data from system memory, then read + // the data from the source FIFO. + + if (fState.systemMemory) + { + uint16 result; + + // Loop getting source pixels. Normally, we'll just return + // the first pixel, but we may need to skip some in case we're + // in the part of the scanline before the first valid pixel + // or after the last one. + + while (1) + { + if (fSourcePipeIndex == fSourcePipeMax) + { + this->PrvSrcPipeFill (stalled); + + if (stalled) + return 0; // Return a dummy value + + fSourcePipeIndex = 0; + } + + result = fSourcePipe [fSourcePipeIndex++]; + + if (fSourcePipeSkip == 0) + { + break; + } + + PRINTF_BLIT (" PrvSrcPipeNextPixel: skipping... %u", fSourcePipeSkip); + + --fSourcePipeSkip; + } + + PRINTF_BLIT (" PrvSrcPipeNextPixel: result: 0x%04X", result); + + return result; + } + + // We're getting the source pixel value from the display memory. + + uint16 result = this->PrvGetPixel (fXSrc, fYSrc); + + PRINTF_BLIT (" PrvSrcPipeNextPixel: fXSrc: %u", fXSrc); + PRINTF_BLIT (" PrvSrcPipeNextPixel: fYSrc: %u", fYSrc); + PRINTF_BLIT (" PrvSrcPipeNextPixel: result: 0x%04X", result); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvSrcPipeNextX +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvSrcPipeNextX (void) +{ + fXSrc += (fState.xDirection == 0) ? 1 : -1; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvSrcPipeNextY +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvSrcPipeNextY (void) +{ + fYSrc += (fState.yDirection == 0) ? 1 : -1; + fXSrc = fState.xSrc; + + if (fState.xyConversion) + { + if (fState.xDirection) + fXSrc += fState.width - 1; + } + + fSourcePipeSkip = fTrailingSourcePixels/* + fLeadingSourcePixels*/; + + PRINTF_BLIT (" PrvSrcPipeNextY: fXSrc: %u", fXSrc); + PRINTF_BLIT (" PrvSrcPipeNextY: fYSrc: %u", fYSrc); + PRINTF_BLIT (" PrvSrcPipeNextY: fSourcePipeSkip: %u", fSourcePipeSkip); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvSrcPipeFill +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvSrcPipeFill (Bool& stalled) +{ + // If there's no data in the FIFO, bail out. + + if (this->PrvSrcFifoFilledSlots () == 0) + { + PRINTF_BLIT (" PrvSrcPipeFill: stalled..."); + + stalled = true; + return; + } + + uint16* p = fSourcePipe; + UNUSED_PARAM(p); + + uint32 source1; + uint32 source2; + + this->PrvGetSrcFifoSlot (source1, source2); + + // If the source is monochrome, then expand it. + + if (fState.monoSource) + { + fSourcePipeMax = 64; + + PRINTF_BLIT (" PrvSrcPipeFill: expanding: 0x%08X 0x%08X", + source1, source2); + + this->PrvExpandMono32 (source1, &fSourcePipe[0], + fState.fgColorMonoSrc, fState.bgColorMonoSrc); + + this->PrvExpandMono32 (source2, &fSourcePipe[32], + fState.fgColorMonoSrc, fState.bgColorMonoSrc); + + PRINTF_BLIT (" PrvSrcPipeFill: 0: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); + PRINTF_BLIT (" PrvSrcPipeFill: 1: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[8+0], p[8+1], p[8+2], p[8+3], p[8+4], p[8+5], p[8+6], p[8+7]); + PRINTF_BLIT (" PrvSrcPipeFill: 2: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[16+0], p[16+1], p[16+2], p[16+3], p[16+4], p[16+5], p[16+6], p[16+7]); + PRINTF_BLIT (" PrvSrcPipeFill: 3: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[24+0], p[24+1], p[24+2], p[24+3], p[24+4], p[24+5], p[24+6], p[24+7]); + PRINTF_BLIT (" PrvSrcPipeFill: 4: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[32+0], p[32+1], p[32+2], p[32+3], p[32+4], p[32+5], p[32+6], p[32+7]); + PRINTF_BLIT (" PrvSrcPipeFill: 5: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[40+0], p[40+1], p[40+2], p[40+3], p[40+4], p[40+5], p[40+6], p[40+7]); + PRINTF_BLIT (" PrvSrcPipeFill: 6: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[48+0], p[48+1], p[48+2], p[48+3], p[48+4], p[48+5], p[48+6], p[48+7]); + PRINTF_BLIT (" PrvSrcPipeFill: 7: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[54+0], p[54+1], p[54+2], p[54+3], p[54+4], p[54+5], p[54+6], p[54+7]); + } + + // If the source is in color, then break apart the 64-bit + // value we read into individual pixels. We'll get either + // 4 or 8 pixels, depending on the source depth. + + else if (fState.colorDepth == kColorDepth8) + { + fSourcePipeMax = 8; + + fSourcePipe[0] = (source1 >> 0) & 0x000000FF; + fSourcePipe[1] = (source1 >> 8) & 0x000000FF; + fSourcePipe[2] = (source1 >> 16) & 0x000000FF; + fSourcePipe[3] = (source1 >> 24) & 0x000000FF; + + fSourcePipe[4] = (source2 >> 0) & 0x000000FF; + fSourcePipe[5] = (source2 >> 8) & 0x000000FF; + fSourcePipe[6] = (source2 >> 16) & 0x000000FF; + fSourcePipe[7] = (source2 >> 24) & 0x000000FF; + + PRINTF_BLIT (" PrvSrcPipeFill: 0: 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X", + p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); + } + else if (fState.colorDepth == kColorDepth16) + { + fSourcePipeMax = 4; + + fSourcePipe[0] = (source1 >> 0) & 0x0000FFFF; + fSourcePipe[1] = (source1 >> 16) & 0x0000FFFF; + + fSourcePipe[2] = (source2 >> 0) & 0x0000FFFF; + fSourcePipe[3] = (source2 >> 16) & 0x0000FFFF; + + PRINTF_BLIT (" PrvSrcPipeFill: 0: 0x%04X 0x%04X 0x%04X 0x%04X", + p[0], p[1], p[2], p[3]); + } + else + { + EmAssert (false); + } +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvDestPipeInit +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvDestPipeInit (void) +{ + fXDest = fState.xDest; + fYDest = fState.yDest; + + if (fState.xyConversion) + { + if (fState.xDirection) + fXDest += fState.width - 1; + + if (fState.yDirection) + fYDest += fState.height - 1; + } + + PRINTF_BLIT (" PrvDestPipeInit: fXDest: %u", fXDest); + PRINTF_BLIT (" PrvDestPipeInit: fYDest: %u", fYDest); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvDestPipeNextPixel +// --------------------------------------------------------------------------- + +uint16 EmRegsMediaQ11xx::PrvDestPipeNextPixel (void) +{ + uint16 result = this->PrvGetPixel (fXDest, fYDest); + + PRINTF_BLIT (" PrvDestPipeNextPixel: fXDest: %u", fXDest); + PRINTF_BLIT (" PrvDestPipeNextPixel: fYDest: %u", fYDest); + PRINTF_BLIT (" PrvDestPipeNextPixel: result: 0x%04X", result); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvDestPipeNextX +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvDestPipeNextX (void) +{ + fXDest += (fState.xDirection == 0) ? 1 : -1; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvDestPipeNextY +// --------------------------------------------------------------------------- + +void EmRegsMediaQ11xx::PrvDestPipeNextY (void) +{ + fYDest += (fState.yDirection == 0) ? 1 : -1; + fXDest = fState.xDest; + + if (fState.xyConversion) + { + if (fState.xDirection) + fXDest += fState.width - 1; + } +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvNextXY +// --------------------------------------------------------------------------- +// Increment our X and Y counters. If we we're done, return false. If we've +// moved to the next line, inform the various pipes that we've done that. If +// we've merely moved to the next pixel on the same line, inform the pipes +// that we've done that. + +Bool EmRegsMediaQ11xx::PrvNextXY (void) +{ + fCurXOffset += 1; + + if (fCurXOffset == fState.width) + { + fCurXOffset = 0; + fCurYOffset += 1; + + if (fCurYOffset == fState.height) + { + return false; + } + + this->PrvPatternPipeNextY (); + this->PrvSrcPipeNextY (); + this->PrvDestPipeNextY (); + } + else + { + this->PrvPatternPipeNextX (); + this->PrvSrcPipeNextX (); + this->PrvDestPipeNextX (); + } + + return true; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvTransparent +// --------------------------------------------------------------------------- + +Bool EmRegsMediaQ11xx::PrvTransparent (uint16 source, uint16 dest, uint16 pattern) +{ + if (fState.monoTransEnable) + { + if (fState.monoSource) + { + if (fState.monoTransPolarity == 0) + { + // Source background is transparent. + + if (source == fState.bgColorMonoSrc) + { + PRINTF_BLIT (" PrvTransparent: source == fState.bgColorMonoSrc..."); + return true; + } + } + else + { + // Source foreground is transparent. + + if (source == fState.fgColorMonoSrc) + { + PRINTF_BLIT (" PrvTransparent: source == fState.fgColorMonoSrc..."); + return true; + } + } + } + + if (fState.monoPattern) + { + if (fState.monoTransPolarity == 0) + { + // Source background is transparent. + + if (pattern == fState.bgColorMonoPat) + { + PRINTF_BLIT (" PrvTransparent: pattern == fState.bgColorMonoPat..."); + return true; + } + } + else + { + // Source foreground is transparent. + + if (pattern == fState.fgColorMonoPat) + { + PRINTF_BLIT (" PrvTransparent: pattern == fState.fgColorMonoPat..."); + return true; + } + } + } + } + + if (fState.colorTransEnable) + { + // Compare to source data. + + if (fState.colorTransCmpSrc == 0) + { + if (!fState.monoSource) + { + // Transparent if source is the same as the test color. + + if (fState.destTransPolarity == 0) + { + if (source == fState.destTransColor) + { + PRINTF_BLIT (" PrvTransparent: source == fState.destTransColor..."); + return true; + } + } + + // Transparent if source is different from the test color. + + else + { + if (source != fState.destTransColor) + { + PRINTF_BLIT (" PrvTransparent: source != fState.destTransColor..."); + return true; + } + } + } + } + + // Compare to destination data. + + else + { + // Transparent if dest is the same as the test color. + + if (fState.destTransPolarity == 0) + { + if (dest == fState.destTransColor) + { + PRINTF_BLIT (" PrvTransparent: dest == fState.destTransColor..."); + return true; + } + } + + // Transparent if dest is different from the test color. + + else + { + if (dest != fState.destTransColor) + { + PRINTF_BLIT (" PrvTransparent: dest != fState.destTransColor..."); + return true; + } + } + } + } + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvClipped +// --------------------------------------------------------------------------- + +Bool EmRegsMediaQ11xx::PrvClipped (void) +{ + if (fState.clipEnable) + { + if (fXDest < fState.clipLeft || fXDest >= fState.clipRight || + fYDest < fState.clipTop || fYDest >= fState.clipBottom) + { + PRINTF_BLIT (" PrvWriteIt: clipped out..."); + + return true; + } + } + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvLeadingPixels +// --------------------------------------------------------------------------- + +uint16 EmRegsMediaQ11xx::PrvLeadingPixels (void) +{ + uint16 result; + + if (fState.memToScreen) + { + // Packed Mode + + if (fState.monoSource) + { + result = fState.srcLeadingBits + 8 * fState.srcLeadingBytes; + } + else if (fState.colorDepth == kColorDepth8) + { + result = fState.srcLeadingBytes; + } + else if (fState.colorDepth == kColorDepth16) + { + EmAssert (::IsEven (fState.srcLeadingBytes)); + result = fState.srcLeadingBytes / 2; + } + else + { + EmAssert (false); + result = 0; + } + } + else + { + // Lined Mode + + if (fState.monoSource) + { + result = fState.srcBitOffset + 8 * fState.srcByteOffset; + } + else if (fState.colorDepth == kColorDepth8) + { + result = fState.srcByteOffset; + } + else if (fState.colorDepth == kColorDepth16) + { + EmAssert (::IsEven (fState.srcByteOffset)); + result = fState.srcByteOffset / 2; + } + else + { + EmAssert (false); + result = 0; + } + } + + EmAssert (result < 64); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvTrailingPixels +// --------------------------------------------------------------------------- + +uint16 EmRegsMediaQ11xx::PrvTrailingPixels (void) +{ + uint16 result; + + if (fState.memToScreen) + { + // Packed Mode + + if (fState.monoSource) + { + result = fState.srcTrailingBits + 8 * fState.srcTrailingBytes; + } + else if (fState.colorDepth == kColorDepth8) + { + result = fState.srcTrailingBytes; + } + else if (fState.colorDepth == kColorDepth16) + { + EmAssert (::IsEven (fState.srcTrailingBytes)); + result = fState.srcTrailingBytes / 2; + } + else + { + EmAssert (false); + result = 0; + } + } + else + { + // Lined Mode + + uint16 bytesPerLine; + + if (!fState.systemMemory || fState.srcEqualDestStride) + { + bytesPerLine = fState.destLineStride; + } + else + { + bytesPerLine = fState.srcLineStride; + } + + uint16 pixelsPerLine; + + if (fState.monoSource) + { + pixelsPerLine = bytesPerLine * 8; + } + else if (fState.colorDepth == kColorDepth8) + { + pixelsPerLine = bytesPerLine; + } + else if (fState.colorDepth == kColorDepth16) + { + EmAssert (::IsEven (bytesPerLine)); + pixelsPerLine = bytesPerLine / 2; + } + else + { + EmAssert (false); + pixelsPerLine = 0; + } + + result = pixelsPerLine - (fState.width + fLeadingSourcePixels); + } + + EmAssert (result < 64); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvUsesPattern +// --------------------------------------------------------------------------- +// Return whether or not the specified rasterOperation will require the use +// of a "pattern" value (that is, a pixel value from the pattern registers). +// +// To see if P is used in the output, consider the P, S, D combination +// table again: +// +// P S D O (output) +// --- --- --- --- +// 0 0 0 b0 +// 0 0 1 b1 +// 0 1 0 b2 +// 0 1 1 b3 +// 1 0 0 b4 +// 1 0 1 b5 +// 1 1 0 b6 +// 1 1 1 b7 +// +// If b0 == b4, b1 == b5, b2 == b6, and b3 == b7, then P has not figured into +// the result at all. That is, for any S & D combination, we got the same +// output regardless of what P was. Therefore, we can compare those bits to +// see if P is relevent to the outcome or not. +// +// We can quickly compare the bits by taking the ROP: +// +// b7 b6 b5 b4 b3 b2 b1 b0 +// +// Making a copy of it: +// +// b7 b6 b5 b4 b3 b2 b1 b0 +// b7 b6 b5 b4 b3 b2 b1 b0 +// +// Shifting the copy: +// +// b7 b6 b5 b4 b3 b2 b1 b0 +// 0 0 0 0 b7 b6 b5 b4 +// +// XORing the two: +// +// (b7^0) (b6^0) (b5^0) (b4^0) (b3^b7) (b2^b6) (b1^b5) (b0^b4) +// +// And then masking out bits 4, 5, 6, and 7, as they don't include +// results that we want: +// +// 0 0 0 0 (b3^b7) (b2^b6) (b1^b5) (b0^b4) +// +// Here, we have a bitfield containing the results of comparing the bits +// that we're interested in. We can test the whole result to see if it's +// zero or non-zero. + +Bool EmRegsMediaQ11xx::PrvUsesPattern (void) +{ + uint8 rop = fState.rasterOperation; + uint8 shifted = rop >> 4; + uint8 xored = rop ^ shifted; + uint8 masked = xored & 0x0F; + + return masked != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvUsesSource +// --------------------------------------------------------------------------- +// Return whether or not the specified rasterOperation will require the use +// of a "source" value (that is, a pixel value from a source buffer). +// +// To see if S is used in the output, consider the P, S, D combination +// table again: +// +// P S D O (output) +// --- --- --- --- +// 0 0 0 b0 +// 0 0 1 b1 +// 0 1 0 b2 +// 0 1 1 b3 +// 1 0 0 b4 +// 1 0 1 b5 +// 1 1 0 b6 +// 1 1 1 b7 +// +// If b0 == b2, b1 == b3, b4 == b6, and b5 == b7, then S has not figured into +// the result at all. That is, for any P & D combination, we got the same +// output regardless of what S was. Therefore, we can compare those bits to +// see if S is relevent to the outcome or not. +// +// We can quickly compare the bits by taking the ROP: +// +// b7 b6 b5 b4 b3 b2 b1 b0 +// +// Making a copy of it: +// +// b7 b6 b5 b4 b3 b2 b1 b0 +// b7 b6 b5 b4 b3 b2 b1 b0 +// +// Shifting the copy: +// +// b7 b6 b5 b4 b3 b2 b1 b0 +// 0 0 b7 b6 b5 b4 b3 b2 +// +// XORing the two: +// +// (b7^0) (b6^0) (b5^b7) (b4^b6) (b3^b5) (b2^b4) (b1^b3) (b0^b2) +// +// And then masking out bits 2, 3, 6, and 7, as they don't include +// results that we want: +// +// 0 0 (b5^b7) (b4^b6) 0 0 (b1^b3) (b0^b2) +// +// Here, we have a bitfield containing the results of comparing the bits +// that we're interested in. We can test the whole result to see if it's +// zero or non-zero. + +Bool EmRegsMediaQ11xx::PrvUsesSource (void) +{ + uint8 rop = fState.rasterOperation; + uint8 shifted = rop >> 2; + uint8 xored = rop ^ shifted; + uint8 masked = xored & 0x33; + + return masked != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvExpandMono8 +// --------------------------------------------------------------------------- +// Take a bit pattern, and expand it into an array of color values, where +// elements of the array are set to the foreground color if the bit in the +// pattern is one, and the background color if the bit is zero. + +void EmRegsMediaQ11xx::PrvExpandMono8 (uint8 bits, uint16* results, + uint16 fgColor, uint16 bgColor) +{ + if (fState.monoSrcBitSwap) + { + for (int ii = 0; ii < 8; ++ii) + { + if ((bits & (1 << ii)) != 0) + { + results[ii] = fgColor; + } + else + { + results[ii] = bgColor; + } + } + } + else + { + for (int ii = 0; ii < 8; ++ii) + { + if ((bits & (0x080 >> ii)) != 0) + { + results[ii] = fgColor; + } + else + { + results[ii] = bgColor; + } + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsMediaQ11xx::PrvExpandMono32 +// --------------------------------------------------------------------------- +// Wrapper to perform the expansion of 4 8-bit bitfields in a DWORD. + +void EmRegsMediaQ11xx::PrvExpandMono32 (uint32 bits, uint16* results, + uint16 fgColor, uint16 bgColor) +{ + this->PrvExpandMono8 (bits >> 0, &results[ 0], fgColor, bgColor); + this->PrvExpandMono8 (bits >> 8, &results[ 8], fgColor, bgColor); + this->PrvExpandMono8 (bits >> 16, &results[16], fgColor, bgColor); + this->PrvExpandMono8 (bits >> 24, &results[24], fgColor, bgColor); +} diff --git a/SrcShared/Hardware/EmRegsMediaQ11xx.h b/SrcShared/Hardware/EmRegsMediaQ11xx.h new file mode 100644 index 0000000..2a6a69a --- /dev/null +++ b/SrcShared/Hardware/EmRegsMediaQ11xx.h @@ -0,0 +1,351 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsMediaQ11xx_h +#define EmRegsMediaQ11xx_h + +#include "EmHAL.h" // EmHALHandler +#include "EmRegs.h" // EmRegs +#include "EmPalmStructs.h" // EmProxyHwrMediaQ11xType + +#include <vector> // vector + + +#define T_BASE 0x1F000000L //68KVZ for Palm platform +#define MMIO_OFFSET 0x40000 // starts at 256K address +#define MMIO_BASE (T_BASE + MMIO_OFFSET) + +// This struct is a mirror of the MediaQ graphics enginer registers. As +// the registers are updated, this struct is updated so that we have +// easy access to the values in the registers without having to unpack +// them all the time. + +struct GEState +{ + // * means that I've completely accounted for that field + // and don't have to think about it any more. + // + // - means that I'm not going to support that field and + // so don't ever have to think about it. + // + // ? means that I don't know what this field is for. + + // ==================== GE00R ==================== + + uint8 rasterOperation; // [7:0]* + uint8 commandType; // [10:8]* + uint8 xDirection; // [11]* + uint8 yDirection; // [12]* + uint8 systemMemory; // [13]* + uint8 monoSource; // [14]* + uint8 monoPattern; // [15]* + uint8 colorTransEnable; // [16]* + uint8 destTransPolarity; // [17]* + uint8 monoTransEnable; // [18]* + uint8 monoTransPolarity; // [19]* + uint8 memToScreen; // [20]* + uint8 solidSourceColor; // [23]* + uint8 srcEqualDestStride; // [24]* + uint8 rop2Select; // [25]? + uint8 clipEnable; // [26]* + uint8 autoExecute; // [27]* + uint8 solidPattern; // [30]* + uint8 colorTransCmpSrc; // [31]* + + // ==================== GE01R ==================== + + // BitBLT + + uint16 width; // [11:0]* + uint16 height; // [27:16]* + uint8 xyConversion; // [31]* + + // Line + + int32 gamma; // [16:0]? + uint16 majorLength; // [28:17]* + uint8 yIsMajor; // [29]* + uint8 drawLastPixel; // [30]* + uint8 useXY; // [31]* + + // ==================== GE02R ==================== + + // BitBLT + + uint16 xDest; // [11:0]* + uint8 monoPatternXOffset; // [15:13]* + uint16 yDest; // [27:16]* + uint8 monoPatternYOffset; // [31:29]* + + // Line + + uint16 xStart; // [11:0]* + uint16 deltaMajor; // [28:12]* + uint16 quadrant; // [31:29]* + + // ==================== GE03R ==================== + + // BitBLT + + uint16 xSrc; // [11:0]* + uint16 ySrc; // [27:16]* + + // Line + + uint16 yStart; // [11:0]* + uint16 deltaMinor; // [28:12]* + + // ==================== GE04R ==================== + + uint16 destTransColor; // [15:0]* + + // ==================== GE05R ==================== + + uint16 clipLeft; // [10:0]* + uint16 clipTop; // [25:16]* + + // ==================== GE06R ==================== + + uint16 clipRight; // [10:0]* + uint16 clipBottom; // [25:16]* + + // ==================== GE07R ==================== + + uint16 fgColorMonoSrc; // [15:0]* + + // ==================== GE08R ==================== + + uint16 bgColorMonoSrc; // [15:0]* + + // ==================== GE09R ==================== + + // Lined Mode + + uint16 srcLineStride; // [9:0]* + uint8 srcBitOffset; // [27:25]* + uint8 srcByteOffset; // [30:28]* + + // Packed Mode + + uint8 srcLeadingBits; // [2:0]* + uint8 srcLeadingBytes; // [5:3]* + uint16 srcNumBytes; // [15:6]* + uint8 srcTrailingBits; // [27:25]* + uint8 srcTrailingBytes; // [31:28]* + + // ==================== GE0AR ==================== + + uint16 destLineStride; // [9:0]* + uint8 monoSrcBitSwap; // [28]* + uint8 rotate90; // [29]* + uint8 colorDepth; // [31:30]* + + // ==================== GE0BR ==================== + + uint32 baseAddr; // [19:0]* + uint8 testModeEnable; // [29]- + uint8 testModeControl; // [31:30]- + + // ==================== GE0CR ==================== + + uint16 cmdLineStart; // [9:0]- + uint16 cmdLineEnd; // [21:12]- + uint8 cmdLineControl; // [24]- + uint8 gc1SwitchControl; // [27:26]- + + // ==================== GE0FR ==================== + + // Test register + + // ==================== GE10R ==================== + + uint32 monoPattern1; // [31:0]* + + // ==================== GE11R ==================== + + uint32 monoPattern2; // [31:0]* + + // ==================== GE12R ==================== + + uint16 fgColorMonoPat; // [15:0]* + + // ==================== GE13R ==================== + + uint16 bgColorMonoPat; // [15:0]* +}; + + +class EmRegsMediaQ11xx : public EmRegs, public EmHALHandler +{ + public: + EmRegsMediaQ11xx (emuptr baseRegsAddr, + emuptr baseVideoAddr); + virtual ~EmRegsMediaQ11xx (void); + + // EmRegs overrides + virtual void Initialize (void); + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + virtual void Dispose (void); + + virtual void SetSubBankHandlers (void); + virtual uint8* GetRealAddress (emuptr address); + virtual emuptr GetAddressStart (void); + virtual uint32 GetAddressRange (void); + + // EmHAL overrides + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLCDHasFrame (void); + virtual void GetLCDBeginEnd (emuptr& begin, emuptr& end); + virtual void GetLCDScanlines (EmScreenUpdateInfo& info); + + protected: + uint32 MQRead (emuptr address, int size); + void MQWrite (emuptr address, int size, uint32 value); + + private: + uint32 CC01Read (emuptr address, int size); + + void DC00Write (emuptr address, int size, uint32 value); + void GE00Write (emuptr address, int size, uint32 value); + void GE02Write (emuptr address, int size, uint32 value); + void SourceFifoWrite (emuptr address, int size, uint32 value); + void invalidateWrite (emuptr address, int size, uint32 value); + + private: + void AddressError (emuptr address, long size, Bool forRead); + void PrvGetPalette (RGBList& thePalette); + void PrvUpdateByteLanes (void); + + uint32 PrvGetBPP (void); + uint32 PrvGetWidth (void); + uint32 PrvGetHeight (void); + uint32 PrvGetRowBytes (void); + uint32 PrvGetVideoOffset (void); + uint32 PrvGetVideoBase (void); + uint32 PrvGetFrameBuffer (void); + Bool PrvGetXDoubling (void); + Bool PrvGetYDoubling (void); + + void PrvGetGEState (int regNum); + void PrvLogGEState (); + + void PrvDoCommand (void); + void PrvDoBitBLT (void); + void PrvDoLine (void); + void PrvIllegalCommand (void); + + int PrvSrcFifoFilledSlots (void); + void PrvGetSrcFifoSlot (uint32&, uint32&); + + // Drawing related functions + uint16 PrvAdjustPixel (uint16 pen, + uint16 dest, + uint8 rOpCode); + uint16 PrvAdjustPixel (uint16 pattern, + uint16 src, + uint16 dest, + uint8 rOpCode); + + void PrvSetPixel (uint16 pixel, + uint16 x, uint16 y); + uint16 PrvGetPixel (uint16 x, uint16 y); + emuptr PrvGetPixelLocation (uint16 x, uint16 y); + + void PrvIncBlitterInit (void); + void PrvIncBlitterRun (void); + + void PrvPatternPipeInit (void); + uint16 PrvPatternPipeNextPixel (void); + void PrvPatternPipeNextX (void); + void PrvPatternPipeNextY (void); + + void PrvSrcPipeInit (void); + uint16 PrvSrcPipeNextPixel (Bool& stalled); + void PrvSrcPipeNextX (void); + void PrvSrcPipeNextY (void); + void PrvSrcPipeFill (Bool& stalled); + + void PrvDestPipeInit (void); + uint16 PrvDestPipeNextPixel (void); + void PrvDestPipeNextX (void); + void PrvDestPipeNextY (void); + + Bool PrvNextXY (void); + Bool PrvTransparent (uint16 source, uint16 dest, uint16 pattern); + Bool PrvClipped (void); + uint16 PrvLeadingPixels (void); + uint16 PrvTrailingPixels (void); + + Bool PrvUsesPattern (void); + Bool PrvUsesSource (void); + void PrvExpandMono8 (uint8 bits, uint16* results, + uint16 fgColor, uint16 bgColor); + void PrvExpandMono32 (uint32 bits, uint16* results, + uint16 fgColor, uint16 bgColor); + + private: + emuptr fBaseRegsAddr; + emuptr fBaseVideoAddr; + EmProxyHwrMediaQ11xxType fRegs; + GEState fState; + + int fBytelanes[4]; + emuptr fLastAddress; + int fLastSize; + + vector<uint32> fSourceFifo; + + // Values used while incrementally blitting. + + Bool fBlitInProgress; + + uint16 fCurXOffset; + uint16 fCurYOffset; + + // Some values cached for speed. These are calculated once + // for each blit operation and saved, as they don't vary once + // the blit has started. However, there's no evidence that + // any such caching is needed -- no timing experiments have + // bee performed. + + Bool fUsesPattern; + Bool fUsesSource; + + uint16 fLeadingSourcePixels; + uint16 fTrailingSourcePixels; + + // Pattern pipe data + + uint16 fPatternPipe[64]; + uint16 fXPattern; + uint16 fYPattern; + + // Source pipe data + + uint16 fSourcePipe[64]; + uint16 fSourcePipeIndex; + uint16 fSourcePipeMax; + uint16 fSourcePipeSkip; + uint16 fXSrc; + uint16 fYSrc; + + // Dest pipe data + + uint16 fXDest; + uint16 fYDest; +}; + +#endif // EmRegsMediaQ11xx_h diff --git a/SrcShared/Hardware/EmRegsPLDPalmVIIEZ.cpp b/SrcShared/Hardware/EmRegsPLDPalmVIIEZ.cpp new file mode 100644 index 0000000..6f0bc8b --- /dev/null +++ b/SrcShared/Hardware/EmRegsPLDPalmVIIEZ.cpp @@ -0,0 +1,210 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsPLDPalmVIIEZ.h" + +#include "EmHAL.h" // EmHAL::GetSerialPortOn + +#define NON_PORTABLE +#include "EZSumo/IncsPrv/HardwareEZ.h" // hwrJerryPldBase, hwrJerryPld232Enable +#undef NON_PORTABLE + +// Given a register (specified by its field name), return its address +// in emulated space. + +#define addressof(reg) \ + (this->GetAddressStart () + fRegs.offsetof_##reg ()) + + +// Macro to help the installation of handlers for a register. + +#define INSTALL_HANDLER(read, write, reg) \ + this->SetHandler ( (ReadFunction) &EmRegsPLDPalmVIIEZ::read, \ + (WriteFunction) &EmRegsPLDPalmVIIEZ::write, \ + addressof (reg), \ + fRegs.reg.GetSize ()) + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmVIIEZ::EmRegsPLDPalmVIIEZ +// --------------------------------------------------------------------------- + +EmRegsPLDPalmVIIEZ::EmRegsPLDPalmVIIEZ (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmVIIEZ::~EmRegsPLDPalmVIIEZ +// --------------------------------------------------------------------------- + +EmRegsPLDPalmVIIEZ::~EmRegsPLDPalmVIIEZ (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmVIIEZ::Initialize +// --------------------------------------------------------------------------- + +void EmRegsPLDPalmVIIEZ::Initialize (void) +{ + EmRegs::Initialize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmVIIEZ::Reset +// --------------------------------------------------------------------------- + +void EmRegsPLDPalmVIIEZ::Reset (Bool hardwareReset) +{ + EmRegs::Reset (hardwareReset); + + if (hardwareReset) + { + memset (fRegs.GetPtr (), 0, fRegs.GetSize ()); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmVIIEZ::Save +// --------------------------------------------------------------------------- + +void EmRegsPLDPalmVIIEZ::Save (SessionFile& f) +{ + EmRegs::Save (f); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmVIIEZ::Load +// --------------------------------------------------------------------------- + +void EmRegsPLDPalmVIIEZ::Load (SessionFile& f) +{ + EmRegs::Load (f); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmVIIEZ::Dispose +// --------------------------------------------------------------------------- + +void EmRegsPLDPalmVIIEZ::Dispose (void) +{ + EmRegs::Dispose (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmVIIEZ::GetSerialPortOn +// --------------------------------------------------------------------------- + +Bool EmRegsPLDPalmVIIEZ::GetSerialPortOn (int /*uartNum*/) +{ + return (fRegs.rs232Shdn & hwrJerryPld232Enable) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmVIIEZ::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegsPLDPalmVIIEZ::SetSubBankHandlers (void) +{ + // Install base handlers. + + EmRegs::SetSubBankHandlers (); + + // Now add standard/specialized handers for the defined registers. + + INSTALL_HANDLER (StdReadBE, StdWriteBE, dspOn); + INSTALL_HANDLER (StdReadBE, StdWriteBE, chargeOn); + INSTALL_HANDLER (StdReadBE, StdWriteBE, refOn); + INSTALL_HANDLER (StdReadBE, StdWriteBE, pipaBiasEnable); + INSTALL_HANDLER (StdReadBE, StdWriteBE, dspReset); + INSTALL_HANDLER (StdReadBE, StdWriteBE, ezToDsl); + INSTALL_HANDLER (StdReadBE, rs232ShdnWrite, rs232Shdn); + INSTALL_HANDLER (StdReadBE, StdWriteBE, spareOut); + INSTALL_HANDLER (StdReadBE, StdWriteBE, dTo3Sln); + INSTALL_HANDLER (iXtrnl2Read, StdWriteBE, iXtrnl2); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmVIIEZ::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmRegsPLDPalmVIIEZ::GetRealAddress (emuptr address) +{ + return (uint8*) fRegs.GetPtr () + address - this->GetAddressStart (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmVIIEZ::GetAddressStart +// --------------------------------------------------------------------------- + +emuptr EmRegsPLDPalmVIIEZ::GetAddressStart (void) +{ + return hwrJerryPldBase; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmVIIEZ::GetAddressRange +// --------------------------------------------------------------------------- + +uint32 EmRegsPLDPalmVIIEZ::GetAddressRange (void) +{ + return fRegs.GetSize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmVIIEZ::rs232ShdnWrite +// --------------------------------------------------------------------------- + +void EmRegsPLDPalmVIIEZ::rs232ShdnWrite (emuptr address, int size, uint32 value) +{ + // Take a snapshot of the line driver states. + + Bool driverStates[kUARTEnd]; + EmHAL::GetLineDriverStates (driverStates); + + StdWriteBE (address, size, value); + + // Respond to any changes in the line driver states. + + EmHAL::CompareLineDriverStates (driverStates); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmVIIEZ::iXtrnl2Read +// --------------------------------------------------------------------------- + +uint32 EmRegsPLDPalmVIIEZ::iXtrnl2Read (emuptr address, int size) +{ + uint32 result = StdReadBE (address, size); + + // Ensure that bit 0x0080 is set. If it's clear, HotSync + // will sync via the modem instead of the serial port. + + result |= 0x0080; + + return result; +} diff --git a/SrcShared/Hardware/EmRegsPLDPalmVIIEZ.h b/SrcShared/Hardware/EmRegsPLDPalmVIIEZ.h new file mode 100644 index 0000000..92085f8 --- /dev/null +++ b/SrcShared/Hardware/EmRegsPLDPalmVIIEZ.h @@ -0,0 +1,51 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsPLDPalmVIIEZ_h +#define EmRegsPLDPalmVIIEZ_h + +#include "EmHAL.h" // EmHALHandler +#include "EmPalmStructs.h" // EmProxyHwrJerryPLDType +#include "EmRegs.h" // EmRegs + +class SessionFile; + + +class EmRegsPLDPalmVIIEZ : public EmRegs, public EmHALHandler +{ + public: + EmRegsPLDPalmVIIEZ (void); + virtual ~EmRegsPLDPalmVIIEZ (void); + + virtual void Initialize (void); + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + virtual void Dispose (void); + + virtual Bool GetSerialPortOn (int uartNum); + + virtual void SetSubBankHandlers (void); + virtual uint8* GetRealAddress (emuptr address); + virtual emuptr GetAddressStart (void); + virtual uint32 GetAddressRange (void); + + protected: + void rs232ShdnWrite (emuptr address, int size, uint32 value); + uint32 iXtrnl2Read (emuptr address, int size); + + private: + EmProxyHwrJerryPLDType fRegs; +}; + +#endif /* EmRegsPLDPalmVIIEZ_h */ diff --git a/SrcShared/Hardware/EmRegsPrv.h b/SrcShared/Hardware/EmRegsPrv.h new file mode 100644 index 0000000..d436c47 --- /dev/null +++ b/SrcShared/Hardware/EmRegsPrv.h @@ -0,0 +1,37 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsPrv_h +#define EmRegsPrv_h + +#include "EmMemory.h" // EmMemDoGet8, EmMemDoPut8, etc. + +// Inline functions for reading/writing registers. + +inline int8 _get_reg (int8* a) { return EmMemDoGet8 (a); } +inline int16 _get_reg (int16* a) { return EmMemDoGet16 (a); } +inline int32 _get_reg (int32* a) { return EmMemDoGet32 (a); } + +inline uint8 _get_reg (uint8* a) { return EmMemDoGet8 (a); } +inline uint16 _get_reg (uint16* a) { return EmMemDoGet16 (a); } +inline uint32 _get_reg (uint32* a) { return EmMemDoGet32 (a); } + +inline void _put_reg (int8* a, int8 v) { EmMemDoPut8 (a, v); } +inline void _put_reg (int16* a, int16 v) { EmMemDoPut16 (a, v); } +inline void _put_reg (int32* a, int32 v) { EmMemDoPut32 (a, v); } + +inline void _put_reg (uint8* a, uint8 v) { EmMemDoPut8 (a, v); } +inline void _put_reg (uint16* a, uint16 v) { EmMemDoPut16 (a, v); } +inline void _put_reg (uint32* a, uint32 v) { EmMemDoPut32 (a, v); } + +#endif // EmRegsPrv_h diff --git a/SrcShared/Hardware/EmRegsSED1375.cpp b/SrcShared/Hardware/EmRegsSED1375.cpp new file mode 100644 index 0000000..ea9831b --- /dev/null +++ b/SrcShared/Hardware/EmRegsSED1375.cpp @@ -0,0 +1,506 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsSED1375.h" + +#include "Byteswapping.h" // Canonical +#include "EmMemory.h" // EmMem_memcpy +#include "EmPixMap.h" // SetSize, SetRowBytes, etc. +#include "EmScreen.h" // EmScreen::InvalidateAll +#include "Miscellaneous.h" // StWordSwapper +#include "SessionFile.h" // WriteSED1375RegsType + + +// Given a register (specified by its field name), return its address +// in emulated space. + +#define addressof(reg) \ + (this->GetAddressStart () + fRegs.offsetof_##reg ()) + + +// Macro to help the installation of handlers for a register. + +#define INSTALL_HANDLER(read, write, reg) \ + this->SetHandler ( (ReadFunction) &EmRegsSED1375::read, \ + (WriteFunction) &EmRegsSED1375::write, \ + addressof (reg), \ + fRegs.reg.GetSize ()) + + +#define kCLUTColorIndexMask 0xf000 +#define kCLUTColorsMask 0x0fff + +#define kCLUTRedMask 0x0f00 +#define kCLUTGreenMask 0x00f0 +#define kCLUTBlueMask 0x000f + +#define kCLUTIndexRed 0x4000 +#define kCLUTIndexGreen 0x2000 +#define kCLUTIndexBlue 0x1000 + + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::EmRegsSED1375 +// --------------------------------------------------------------------------- + +EmRegsSED1375::EmRegsSED1375 (emuptr baseRegsAddr, emuptr baseVideoAddr) : + fBaseRegsAddr (baseRegsAddr), + fBaseVideoAddr (baseVideoAddr), + fRegs () +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::~EmRegsSED1375 +// --------------------------------------------------------------------------- + +EmRegsSED1375::~EmRegsSED1375 (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::Initialize +// --------------------------------------------------------------------------- + +void EmRegsSED1375::Initialize (void) +{ + EmRegs::Initialize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::Reset +// --------------------------------------------------------------------------- + +void EmRegsSED1375::Reset (Bool hardwareReset) +{ + EmRegs::Reset (hardwareReset); + + if (hardwareReset) + { + memset (fRegs.GetPtr (), 0, fRegs.GetSize ()); + +// EmAssert ((sed1375ProductCodeExpected | sed1375RevisionCodeExpected) == 0x24); + fRegs.productRevisionCode = 0x24; + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::Save +// --------------------------------------------------------------------------- + +void EmRegsSED1375::Save (SessionFile& f) +{ + EmRegs::Save (f); + + f.WriteSED1375RegsType (*(SED1375RegsType*) fRegs.GetPtr ()); + f.FixBug (SessionFile::kBugByteswappedStructs); + + StWordSwapper swapper1 (fClutData, sizeof (fClutData)); + f.WriteSED1375Palette (fClutData); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::Load +// --------------------------------------------------------------------------- + +void EmRegsSED1375::Load (SessionFile& f) +{ + EmRegs::Load (f); + + // Read in the SED registers. + + if (f.ReadSED1375RegsType (*(SED1375RegsType*) fRegs.GetPtr ())) + { + // The Windows version of Poser 2.1d29 and earlier did not write + // out structs in the correct format. The fields of the struct + // were written out in Little-Endian format, not Big-Endian. To + // address this problem, the bug has been fixed, and a new field + // is added to the file format indicating that the bug has been + // fixed. With the new field (the "bug bit"), Poser can identify + // old files from new files and read them in accordingly. + // + // With the bug fixed, the .psf files should now be interchangeable + // across platforms (modulo other bugs...). + + if (!f.IncludesBugFix (SessionFile::kBugByteswappedStructs)) + { + Canonical (*(SED1375RegsType*) fRegs.GetPtr ()); + } + } + else + { + f.SetCanReload (false); + } + + // Read in the LCD palette, and then byteswap it. + + if (f.ReadSED1375Palette (fClutData)) + { + ::ByteswapWords (fClutData, sizeof (fClutData)); + } + else + { + f.SetCanReload (false); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::Dispose +// --------------------------------------------------------------------------- + +void EmRegsSED1375::Dispose (void) +{ + EmRegs::Dispose (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegsSED1375::SetSubBankHandlers (void) +{ + // Install base handlers. + + EmRegs::SetSubBankHandlers (); + + // Now add standard/specialized handers for the defined registers. + + INSTALL_HANDLER (StdReadBE, NullWrite, productRevisionCode); + INSTALL_HANDLER (StdReadBE, StdWriteBE, mode0); + INSTALL_HANDLER (StdReadBE, invalidateWrite, mode1); + INSTALL_HANDLER (StdReadBE, StdWriteBE, mode2); + INSTALL_HANDLER (StdReadBE, invalidateWrite, horizontalPanelSize); + INSTALL_HANDLER (StdReadBE, invalidateWrite, verticalPanelSizeLSB); + INSTALL_HANDLER (StdReadBE, invalidateWrite, verticalPanelSizeMSB); + INSTALL_HANDLER (StdReadBE, StdWriteBE, FPLineStartPosition); + INSTALL_HANDLER (StdReadBE, StdWriteBE, horizontalNonDisplayPeriod); + INSTALL_HANDLER (StdReadBE, StdWriteBE, FPFRAMEStartPosition); + INSTALL_HANDLER (vertNonDisplayRead, StdWriteBE, verticalNonDisplayPeriod); + INSTALL_HANDLER (StdReadBE, StdWriteBE, MODRate); + INSTALL_HANDLER (StdReadBE, invalidateWrite, screen1StartAddressLSB); + INSTALL_HANDLER (StdReadBE, invalidateWrite, screen1StartAddressMSB); + INSTALL_HANDLER (StdReadBE, StdWriteBE, screen2StartAddressLSB); + INSTALL_HANDLER (StdReadBE, StdWriteBE, screen2StartAddressMSB); + INSTALL_HANDLER (StdReadBE, invalidateWrite, screen1StartAddressMSBit); + INSTALL_HANDLER (StdReadBE, StdWriteBE, memoryAddressOffset); + INSTALL_HANDLER (StdReadBE, StdWriteBE, screen1VerticalSizeLSB); + INSTALL_HANDLER (StdReadBE, StdWriteBE, screen1VerticalSizeMSB); + INSTALL_HANDLER (StdReadBE, StdWriteBE, unused1); + INSTALL_HANDLER (StdReadBE, lookUpTableAddressWrite, lookUpTableAddress); + INSTALL_HANDLER (StdReadBE, StdWriteBE, unused2); + INSTALL_HANDLER (lookUpTableDataRead, lookUpTableDataWrite, lookUpTableData); + INSTALL_HANDLER (StdReadBE, StdWriteBE, GPIOConfigurationControl); + INSTALL_HANDLER (StdReadBE, StdWriteBE, GPIOStatusControl); + INSTALL_HANDLER (StdReadBE, StdWriteBE, scratchPad); + INSTALL_HANDLER (StdReadBE, StdWriteBE, portraitMode); + INSTALL_HANDLER (StdReadBE, StdWriteBE, lineByteCountRegister); + INSTALL_HANDLER (StdReadBE, StdWriteBE, unused3); + INSTALL_HANDLER (StdReadBE, StdWriteBE, unused4); + INSTALL_HANDLER (StdReadBE, StdWriteBE, unused5); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmRegsSED1375::GetRealAddress (emuptr address) +{ + return (uint8*) fRegs.GetPtr () + address - this->GetAddressStart (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::GetAddressStart +// --------------------------------------------------------------------------- + +emuptr EmRegsSED1375::GetAddressStart (void) +{ + return fBaseRegsAddr; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::GetAddressRange +// --------------------------------------------------------------------------- + +uint32 EmRegsSED1375::GetAddressRange (void) +{ + return fRegs.GetSize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsSED1375::GetLCDScreenOn (void) +{ + return ((fRegs.mode1) & sed1375DisplayBlank) == 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsSED1375::GetLCDBacklightOn (void) +{ + return true; // The Backlight is always on for these units. +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::GetLCDHasFrame +// --------------------------------------------------------------------------- + +Bool EmRegsSED1375::GetLCDHasFrame (void) +{ + return true; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::GetLCDBeginEnd +// --------------------------------------------------------------------------- + +void EmRegsSED1375::GetLCDBeginEnd (emuptr& begin, emuptr& end) +{ + // Get the screen metrics. + + int32 bpp = 1 << ((fRegs.mode1 & sed1375BPPMask) >> sed1375BPPShift); + int32 height = ((fRegs.verticalPanelSizeMSB << 8) | fRegs.verticalPanelSizeLSB) + 1; + int32 rowBytes = (fRegs.horizontalPanelSize + 1) * bpp; + uint32 offset = (fRegs.screen1StartAddressMSBit << 17) | + (fRegs.screen1StartAddressMSB << 9) | + (fRegs.screen1StartAddressLSB << 1); + emuptr baseAddr = fBaseVideoAddr + offset; + + begin = baseAddr; + end = baseAddr + rowBytes * height; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::GetLCDScanlines +// --------------------------------------------------------------------------- + +void EmRegsSED1375::GetLCDScanlines (EmScreenUpdateInfo& info) +{ + // Get the screen metrics. + + int32 bpp = 1 << ((fRegs.mode1 & sed1375BPPMask) >> sed1375BPPShift); + int32 width = (fRegs.horizontalPanelSize + 1) * 8; + int32 height = ((fRegs.verticalPanelSizeMSB << 8) | fRegs.verticalPanelSizeLSB) + 1; + int32 rowBytes = (fRegs.horizontalPanelSize + 1) * bpp; + uint32 offset = (fRegs.screen1StartAddressMSBit << 17) | + (fRegs.screen1StartAddressMSB << 9) | + (fRegs.screen1StartAddressLSB << 1); + emuptr baseAddr = fBaseVideoAddr + offset; + + info.fLeftMargin = 0; + + EmPixMapFormat format = bpp == 1 ? kPixMapFormat1 : + bpp == 2 ? kPixMapFormat2 : + bpp == 4 ? kPixMapFormat4 : + kPixMapFormat8; + + RGBList colorTable; + this->PrvGetPalette (colorTable); + + // Set format, size, and color table of EmPixMap. + + info.fImage.SetSize (EmPoint (width, height)); + info.fImage.SetFormat (format); + info.fImage.SetRowBytes (rowBytes); + info.fImage.SetColorTable (colorTable); + + // Determine first and last scanlines to fetch, and fetch them. + + info.fFirstLine = (info.fScreenLow - baseAddr) / rowBytes; + info.fLastLine = (info.fScreenHigh - baseAddr - 1) / rowBytes + 1; + + long firstLineOffset = info.fFirstLine * rowBytes; + long lastLineOffset = info.fLastLine * rowBytes; + + EmMem_memcpy ( + (void*) ((uint8*) info.fImage.GetBits () + firstLineOffset), + baseAddr + firstLineOffset, + lastLineOffset - firstLineOffset); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::invalidateWrite +// --------------------------------------------------------------------------- + +void EmRegsSED1375::invalidateWrite (emuptr address, int size, uint32 value) +{ + this->StdWriteBE (address, size, value); + EmScreen::InvalidateAll (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::vertNonDisplayRead +// --------------------------------------------------------------------------- + +uint32 EmRegsSED1375::vertNonDisplayRead (emuptr address, int size) +{ + UNUSED_PARAM(address) + UNUSED_PARAM(size) + + // Always set the vertical non-display status high since in the real + // hardware, the ROM will check this flag in order to write the CLUT + // registers. + + return (fRegs.verticalNonDisplayPeriod) | sed1375VerticalNonDisplayStatus; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::lookUpTableAddressWrite +// --------------------------------------------------------------------------- + +void EmRegsSED1375::lookUpTableAddressWrite (emuptr address, int size, uint32 value) +{ + this->StdWriteBE (address, size, value); + + value &= 0x0FF; + + fClutData[value] &= kCLUTColorsMask; // Update the rgb index + fClutData[value] |= kCLUTIndexRed; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::lookUpTableDataRead +// --------------------------------------------------------------------------- + +uint32 EmRegsSED1375::lookUpTableDataRead (emuptr address, int size) +{ + EmAssert (size == 1); + + if (size != 1) + return 0; // Error case. + + uint8 clutIndex = (fRegs.lookUpTableAddress); // Get the LUT Addr. + uint16 clutEntry = fClutData[clutIndex]; // Get the entry. + uint8 colorData; + + if ((clutEntry & kCLUTIndexRed) != 0) + { + colorData = (uint8) ((clutEntry & kCLUTRedMask) >> 4); // Get the 4 bits of red. + + fClutData[clutIndex] = // Update the next rgb index + (fClutData[clutIndex] & kCLUTColorsMask) | kCLUTIndexGreen; + } + else if ((clutEntry & kCLUTIndexGreen) != 0) + { + colorData = (uint8) (clutEntry & kCLUTGreenMask); // Get the 4 bits of green + + fClutData[clutIndex] = // Update the next rgb index + (fClutData[clutIndex] & kCLUTColorsMask) | kCLUTIndexBlue; + } + else + { + colorData = (uint8) ((clutEntry & kCLUTBlueMask) << 4); // Get the 4 bits of blue. + + address = (emuptr) (addressof (lookUpTableAddress)); + EmRegsSED1375::lookUpTableAddressWrite (address, 1, (clutIndex + 1) & 0xFF); + } + + return colorData; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::lookUpTableDataWrite +// --------------------------------------------------------------------------- + +void EmRegsSED1375::lookUpTableDataWrite (emuptr address, int size, uint32 value) +{ + EmAssert (size == 1); + + if (size != 1) + return; // Error case. + + uint8 clutIndex = (fRegs.lookUpTableAddress); // Get the LUT Addr. + uint16 clutEntry = fClutData[clutIndex]; // Get the entry. + + uint8 newColor = (uint8) (value & 0x00F0); + + if (clutEntry & kCLUTIndexRed) + { + fClutData[clutIndex] &= ~kCLUTRedMask; // Clear out old red bits. + fClutData[clutIndex] |= newColor << 4; // Save in new red bits. + + fClutData[clutIndex] = // Update the rgb index + (fClutData[clutIndex] & kCLUTColorsMask) | kCLUTIndexGreen; + } + else if (clutEntry & kCLUTIndexGreen) + { + fClutData[clutIndex] &= ~kCLUTGreenMask; // Clear out old red bits. + fClutData[clutIndex] |= newColor; // Save in new green bits. + + fClutData[clutIndex] = // Update the rgb index + (fClutData[clutIndex] & kCLUTColorsMask) | kCLUTIndexBlue; + } + else + { + fClutData[clutIndex] &= ~kCLUTBlueMask; // Clear out old red bits. + fClutData[clutIndex] |= newColor >> 4; // Save in new blue bits. + + address = (emuptr) (addressof (lookUpTableAddress)); + EmRegsSED1375::lookUpTableAddressWrite (address, 1, (clutIndex + 1) & 0xFF); + } + + EmScreen::InvalidateAll (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1375::PrvGetPalette +// --------------------------------------------------------------------------- + +void EmRegsSED1375::PrvGetPalette (RGBList& thePalette) +{ + int32 bpp = 1 << ((fRegs.mode1 & sed1375BPPMask) >> sed1375BPPShift); + int32 numColors = 1 << bpp; + + thePalette.resize (numColors); + + for (int ii = 0; ii < numColors; ++ii) + { + uint16 curEntry = fClutData[ii]; + uint8 color; + + color = (uint8) ((curEntry & kCLUTRedMask) >> 4); + thePalette[ii].fRed = color + (color >> 4); + + color = (uint8) ((curEntry & kCLUTGreenMask) >> 0); + thePalette[ii].fGreen = color + (color >> 4); + + color = (uint8) ((curEntry & kCLUTBlueMask) << 4); + thePalette[ii].fBlue = color + (color >> 4); + } +} diff --git a/SrcShared/Hardware/EmRegsSED1375.h b/SrcShared/Hardware/EmRegsSED1375.h new file mode 100644 index 0000000..7a0e5b5 --- /dev/null +++ b/SrcShared/Hardware/EmRegsSED1375.h @@ -0,0 +1,70 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsSED1375_h +#define EmRegsSED1375_h + +#include "EmHAL.h" // EmHALHandler +#include "EmPalmStructs.h" +#include "EmRegs.h" +#include "EmStructs.h" // RGBList + +class SessionFile; +class EmScreenUpdateInfo; + + +class EmRegsSED1375 : public EmRegs, public EmHALHandler +{ + public: + EmRegsSED1375 (emuptr baseRegsAddr, + emuptr baseVideoAddr); + virtual ~EmRegsSED1375 (void); + + // EmRegs overrides + virtual void Initialize (void); + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + virtual void Dispose (void); + + virtual void SetSubBankHandlers (void); + virtual uint8* GetRealAddress (emuptr address); + virtual emuptr GetAddressStart (void); + virtual uint32 GetAddressRange (void); + + // EmHAL overrides + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLCDHasFrame (void); + virtual void GetLCDBeginEnd (emuptr& begin, emuptr& end); + virtual void GetLCDScanlines (EmScreenUpdateInfo& info); + + private: + uint32 vertNonDisplayRead (emuptr address, int size); + uint32 lookUpTableDataRead (emuptr address, int size); + + void invalidateWrite (emuptr address, int size, uint32 value); + void lookUpTableAddressWrite (emuptr address, int size, uint32 value); + void lookUpTableDataWrite (emuptr address, int size, uint32 value); + + private: + void PrvGetPalette (RGBList& thePalette); + + private: + emuptr fBaseRegsAddr; + emuptr fBaseVideoAddr; + EmProxySED1375RegsType fRegs; + uint16 fClutData[256]; +}; + +#endif /* EmRegsSED1375_h */ diff --git a/SrcShared/Hardware/EmRegsSED1376.cpp b/SrcShared/Hardware/EmRegsSED1376.cpp new file mode 100644 index 0000000..223c24a --- /dev/null +++ b/SrcShared/Hardware/EmRegsSED1376.cpp @@ -0,0 +1,860 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsSED1376.h" + +#include "EmMemory.h" // EmMem_memcpy +#include "EmScreen.h" // EmScreen::InvalidateAll +#include "EmPixMap.h" // EmPixMap::GetLCDScanlines +#include "SessionFile.h" // WriteSED1376RegsType + + +// Given a register (specified by its field name), return its address +// in emulated space. + +#define addressof(reg) \ + (this->GetAddressStart () + fRegs.offsetof_##reg ()) + + +// Macro to help the installation of handlers for a register. + +#define INSTALL_HANDLER(read, write, reg) \ + this->SetHandler ( (ReadFunction) &EmRegsSED1376::read, \ + (WriteFunction) &EmRegsSED1376::write, \ + addressof (reg), \ + fRegs.reg.GetSize ()) + +// Panel type register [10h] +#define sed1376MonoMask 0x40 + +// Display mode register [70h] +#define sed1376DisplayBlankMask 0x80 +#define sed1376BPPMask 0x07 +#define sed1376BPPShift 0x00 + +// REG[0x70] displayMode register +// (Same as previous set, but with Handspring names for their contributed code) +#define sed1376DisplayModeBlank 0x80 +#define sed1376DisplayModeDitherOff 0x40 +#define sed1376DisplayModeHwInvert 0x20 +#define sed1376DisplayModeSwInvert 0x10 +#define sed1376DisplayModeDepthMask 0x07 +#define sed1376DisplayModeDepth16 0x04 +#define sed1376DisplayModeDepth8 0x03 +#define sed1376DisplayModeDepth4 0x02 +#define sed1376DisplayModeDepth2 0x01 +#define sed1376DisplayModeDepth1 0x00 + +// Special effects register [71h] +#define sed1376WordSwapMask 0x80 +#define sed1376ByteSwapMask 0x40 +#define sed1376SubWindowEnableMask 0x10 + +#define hwrDisplayGPIOPCI 0x08 // in GPIOStatusControl0 +#define hwrDisplayGPIOEL_ON 0x10 // in GPIOStatusControl0 +#define hwrDisplayGPIOLCD_ON 0x20 // in GPIOStatusControl0 +#define hwrDisplayGPIOMOD 0x40 // in GPIOStatusControl0 + +// The current SED1376 driver code is completely whacked. It's initialized to use +// the main display for drawing (see HwrDisplayInit in HwrDisplayBootSED1376.c), but +// if you change the base address, it (a) always returns the base of the embedded +// SRAM buffer as the old base address, and (b) stores the new base address in +// ovlyStartAddress (see PrvDisplayBaseAddr in HwrDisplaySED1376.c). Also, the +// splash screen appears to be drawn relative to ovlyStartAddress. Finally, +// there appears to be code to draw a border in the main screen around the +// overlay screen (see PrvDisplayBorder in HwrDisplayBootSED1376.c), however, +// the mainStartAddress registers are never changed to point to this border. +// On top of that, the border is only programmed on the left and right of the +// of the overlay screen, not on the top and bottom. + +#define OVERLAY_IS_MAIN 1 + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::EmRegsSED1376 +// --------------------------------------------------------------------------- + +EmRegsSED1376::EmRegsSED1376 (emuptr baseRegsAddr, emuptr baseVideoAddr) : + fBaseRegsAddr (baseRegsAddr), + fBaseVideoAddr (baseVideoAddr), + fRegs () +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::~EmRegsSED1376 +// --------------------------------------------------------------------------- + +EmRegsSED1376::~EmRegsSED1376 (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::Initialize +// --------------------------------------------------------------------------- + +void EmRegsSED1376::Initialize (void) +{ + EmRegs::Initialize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::Reset +// --------------------------------------------------------------------------- + +void EmRegsSED1376::Reset (Bool hardwareReset) +{ + EmRegs::Reset (hardwareReset); + + if (hardwareReset) + { + memset (fRegs.GetPtr (), 0, fRegs.GetSize ()); + +// EmAssert ((sed1376ProductCodeExpected | sed1376RevisionCodeExpected) == 0x28); + fRegs.productRevisionCode = 0x28; + fRegs.displayBufferSize = 20; // 80K / 4K + fRegs.configurationReadback = 0; + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::Save +// --------------------------------------------------------------------------- + +void EmRegsSED1376::Save (SessionFile& f) +{ + EmRegs::Save (f); + + f.WriteSED1376RegsType (*(SED1376RegsType*) fRegs.GetPtr ()); + f.WriteSED1376Palette (fClutData); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::Load +// --------------------------------------------------------------------------- + +void EmRegsSED1376::Load (SessionFile& f) +{ + EmRegs::Load (f); + + // Read in the SED registers. + + if (!f.ReadSED1376RegsType (*(SED1376RegsType*) fRegs.GetPtr ())) + { + f.SetCanReload (false); + } + + // Read in the LCD palette. + + if (!f.ReadSED1376Palette (fClutData)) + { + f.SetCanReload (false); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::Dispose +// --------------------------------------------------------------------------- + +void EmRegsSED1376::Dispose (void) +{ + EmRegs::Dispose (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegsSED1376::SetSubBankHandlers (void) +{ + // Install base handlers. + + EmRegs::SetSubBankHandlers (); + + // Now add standard/specialized handers for the defined registers. + + INSTALL_HANDLER (StdReadBE, NullWrite, productRevisionCode); + INSTALL_HANDLER (StdReadBE, NullWrite, displayBufferSize); + INSTALL_HANDLER (StdReadBE, NullWrite, configurationReadback); + INSTALL_HANDLER (StdReadBE, StdWriteBE, memoryClockConfiguration); + INSTALL_HANDLER (StdReadBE, StdWriteBE, pixelClockConfiguration); + INSTALL_HANDLER (StdReadBE, StdWriteBE, lutWriteBlue); + INSTALL_HANDLER (StdReadBE, StdWriteBE, lutWriteGreen); + INSTALL_HANDLER (StdReadBE, StdWriteBE, lutWriteRed); + INSTALL_HANDLER (ZeroRead, lutWriteAddressWrite, lutWriteAddress); + INSTALL_HANDLER (StdReadBE, NullWrite, lutReadBlue); + INSTALL_HANDLER (StdReadBE, NullWrite, lutReadGreen); + INSTALL_HANDLER (StdReadBE, NullWrite, lutReadRed); + INSTALL_HANDLER (ZeroRead, lutReadAddressWrite, lutReadAddress); + INSTALL_HANDLER (StdReadBE, StdWriteBE, panelType); + INSTALL_HANDLER (StdReadBE, StdWriteBE, MODRate); + INSTALL_HANDLER (StdReadBE, StdWriteBE, horizontalTotal); + INSTALL_HANDLER (StdReadBE, invalidateWrite, horizontalPeriod); + INSTALL_HANDLER (StdReadBE, StdWriteBE, horizontalPeriodStart0); + INSTALL_HANDLER (StdReadBE, StdWriteBE, horizontalPeriodStart1); + INSTALL_HANDLER (StdReadBE, StdWriteBE, verticalTotal0); + INSTALL_HANDLER (StdReadBE, StdWriteBE, verticalTotal1); + INSTALL_HANDLER (StdReadBE, invalidateWrite, verticalPeriod0); + INSTALL_HANDLER (StdReadBE, invalidateWrite, verticalPeriod1); + INSTALL_HANDLER (StdReadBE, StdWriteBE, verticalPeriodStart0); + INSTALL_HANDLER (StdReadBE, StdWriteBE, verticalPeriodStart1); + INSTALL_HANDLER (StdReadBE, StdWriteBE, FPLINEPulseWidth); + INSTALL_HANDLER (StdReadBE, StdWriteBE, FPLINEPulseStart0); + INSTALL_HANDLER (StdReadBE, StdWriteBE, FPLINEPulseStart1); + INSTALL_HANDLER (StdReadBE, StdWriteBE, FPFRAMEPulseWidth); + INSTALL_HANDLER (StdReadBE, StdWriteBE, FPFRAMEPulseStart0); + INSTALL_HANDLER (StdReadBE, StdWriteBE, FPFRAMEPulseStart1); + INSTALL_HANDLER (StdReadBE, StdWriteBE, DTFD_GCPIndex); + INSTALL_HANDLER (StdReadBE, StdWriteBE, DTFD_GCPData); + INSTALL_HANDLER (StdReadBE, invalidateWrite, displayMode); + INSTALL_HANDLER (StdReadBE, invalidateWrite, specialEffects); + INSTALL_HANDLER (StdReadBE, invalidateWrite, mainStartAddress0); + INSTALL_HANDLER (StdReadBE, invalidateWrite, mainStartAddress1); + INSTALL_HANDLER (StdReadBE, invalidateWrite, mainStartAddress2); + INSTALL_HANDLER (StdReadBE, invalidateWrite, mainLineAddressOffset0); + INSTALL_HANDLER (StdReadBE, invalidateWrite, mainLineAddressOffset1); + INSTALL_HANDLER (StdReadBE, invalidateWrite, ovlyStartAddress0); + INSTALL_HANDLER (StdReadBE, invalidateWrite, ovlyStartAddress1); + INSTALL_HANDLER (StdReadBE, invalidateWrite, ovlyStartAddress2); + INSTALL_HANDLER (StdReadBE, invalidateWrite, ovlyLineAddressOffset0); + INSTALL_HANDLER (StdReadBE, invalidateWrite, ovlyLineAddressOffset1); + INSTALL_HANDLER (StdReadBE, invalidateWrite, ovlyStartXPosition0); + INSTALL_HANDLER (StdReadBE, invalidateWrite, ovlyStartXPosition1); + INSTALL_HANDLER (StdReadBE, invalidateWrite, ovlyStartYPosition0); + INSTALL_HANDLER (StdReadBE, invalidateWrite, ovlyStartYPosition1); + INSTALL_HANDLER (StdReadBE, invalidateWrite, ovlyEndXPosition0); + INSTALL_HANDLER (StdReadBE, invalidateWrite, ovlyEndXPosition1); + INSTALL_HANDLER (StdReadBE, invalidateWrite, ovlyEndYPosition0); + INSTALL_HANDLER (StdReadBE, invalidateWrite, ovlyEndYPosition1); + INSTALL_HANDLER (powerSaveConfigurationRead, StdWriteBE, powerSaveConfiguration); + INSTALL_HANDLER (StdReadBE, StdWriteBE, SoftwareReset); + INSTALL_HANDLER (StdReadBE, StdWriteBE, scratchPad0); + INSTALL_HANDLER (StdReadBE, StdWriteBE, scratchPad1); + INSTALL_HANDLER (StdReadBE, StdWriteBE, GPIOConfiguration0); + INSTALL_HANDLER (StdReadBE, StdWriteBE, GPIOConfiguration1); + INSTALL_HANDLER (StdReadBE, StdWriteBE, GPIOStatusControl0); + INSTALL_HANDLER (StdReadBE, StdWriteBE, GPIOStatusControl1); + INSTALL_HANDLER (StdReadBE, StdWriteBE, PWMClockCVPulseControl); + INSTALL_HANDLER (StdReadBE, StdWriteBE, PWMClockCVPulseConfig); + INSTALL_HANDLER (StdReadBE, StdWriteBE, CVPulseBurstLength); + INSTALL_HANDLER (StdReadBE, StdWriteBE, PWMOutDutyCycle); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmRegsSED1376::GetRealAddress (emuptr address) +{ + return (uint8*) fRegs.GetPtr () + address - this->GetAddressStart (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::GetAddressStart +// --------------------------------------------------------------------------- + +emuptr EmRegsSED1376::GetAddressStart (void) +{ + return fBaseRegsAddr; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::GetAddressRange +// --------------------------------------------------------------------------- + +uint32 EmRegsSED1376::GetAddressRange (void) +{ + return fRegs.GetSize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsSED1376::GetLCDScreenOn (void) +{ +// return ((fRegs.displayMode) & sed1376DisplayBlankMask) == 0; + return ((fRegs.GPIOStatusControl0) & hwrDisplayGPIOLCD_ON) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsSED1376::GetLCDBacklightOn (void) +{ + return ((fRegs.GPIOStatusControl0) & hwrDisplayGPIOEL_ON) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::GetLCDHasFrame +// --------------------------------------------------------------------------- + +Bool EmRegsSED1376::GetLCDHasFrame (void) +{ + return true; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::invalidateWrite +// --------------------------------------------------------------------------- + +void EmRegsSED1376::invalidateWrite (emuptr address, int size, uint32 value) +{ + this->StdWriteBE (address, size, value); + EmScreen::InvalidateAll (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::powerSaveConfigurationRead +// --------------------------------------------------------------------------- + +uint32 EmRegsSED1376::powerSaveConfigurationRead (emuptr address, int size) +{ + UNUSED_PARAM(address) + UNUSED_PARAM(size) + + // Always set the vertical non-display status high since in the real + // hardware, the ROM will check this flag in order to write the CLUT + // registers. + + return (fRegs.powerSaveConfiguration) | 0x80; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::lutWriteAddressWrite +// --------------------------------------------------------------------------- + +void EmRegsSED1376::lutWriteAddressWrite (emuptr address, int size, uint32 value) +{ + UNUSED_PARAM(address) + UNUSED_PARAM(size) + + value &= 0x0FF; + + uint8 red = fRegs.lutWriteRed; + uint8 green = fRegs.lutWriteGreen; + uint8 blue = fRegs.lutWriteBlue; + + fClutData[value] = RGBType ((red & 0xFC) | (red >> 6), + (green & 0xFC) | (green >> 6), + (blue & 0xFC) | (blue >> 6)); + + EmScreen::InvalidateAll (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::lutReadAddressWrite +// --------------------------------------------------------------------------- + +void EmRegsSED1376::lutReadAddressWrite (emuptr address, int size, uint32 value) +{ + UNUSED_PARAM(address) + UNUSED_PARAM(size) + + value &= 0x0FF; + + RGBType rgb = fClutData[value]; + + fRegs.lutReadRed = rgb.fRed & 0xFC; + fRegs.lutReadGreen = rgb.fGreen & 0xFC; + fRegs.lutReadBlue = rgb.fBlue & 0xFC; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376::PrvGetPalette +// --------------------------------------------------------------------------- + +void EmRegsSED1376::PrvGetPalette (RGBList& thePalette) +{ + Bool mono = (fRegs.displayMode & sed1376MonoMask) != 0; + int32 bpp = 1 << ((fRegs.displayMode & sed1376BPPMask) >> sed1376BPPShift); + int32 numColors = 1 << bpp; + + thePalette.resize (numColors); + + for (int ii = 0; ii < numColors; ++ii) + { + if (mono) + { + uint8 green = fClutData[ii].fGreen; + thePalette[ii].fRed = green; + thePalette[ii].fGreen = green; + thePalette[ii].fBlue = green; + } + else + { + thePalette[ii] = fClutData[ii]; + } + } +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376VisorPrism::EmRegsSED1376VisorPrism +// --------------------------------------------------------------------------- + +EmRegsSED1376VisorPrism::EmRegsSED1376VisorPrism (emuptr baseRegsAddr, + emuptr baseVideoAddr) : + EmRegsSED1376 (baseRegsAddr, baseVideoAddr) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376VisorPrism::~EmRegsSED1376VisorPrism +// --------------------------------------------------------------------------- + +EmRegsSED1376VisorPrism::~EmRegsSED1376VisorPrism (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376VisorPrism::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegsSED1376VisorPrism::SetSubBankHandlers (void) +{ + // Install base handlers. + + EmRegsSED1376::SetSubBankHandlers (); + + // Now add standard/specialized handers for the defined registers. + +#undef INSTALL_HANDLER +#define INSTALL_HANDLER(read, write, reg) \ + this->SetHandler ( (ReadFunction) &EmRegsSED1376VisorPrism::read, \ + (WriteFunction) &EmRegsSED1376VisorPrism::write, \ + addressof (reg), \ + fRegs.reg.GetSize ()) + + INSTALL_HANDLER (StdReadBE, reservedWrite, reserved); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376VisorPrism::GetLCDBeginEnd +// --------------------------------------------------------------------------- + +void EmRegsSED1376VisorPrism::GetLCDBeginEnd (emuptr& begin, emuptr& end) +{ + // Get the screen metrics. + + // The hardware is written to in reverse, so the mainStartOffsetX registers + // report the END of the frame buffer, not the beginning. + emuptr baseAddr = fBaseVideoAddr; + + int32 width = ((fRegs.horizontalPeriod + 1) * 8); + int32 height = ((fRegs.verticalPeriod1 << 8) | fRegs.verticalPeriod0) + 1; + int32 rowBytes = ((width * this->PrvGetLCDDepth ()) / 8); + + begin = baseAddr; + end = baseAddr + rowBytes * height; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376VisorPrism::GetLCDScanlines +// --------------------------------------------------------------------------- + +void EmRegsSED1376VisorPrism::GetLCDScanlines (EmScreenUpdateInfo& info) +{ + // Get the screen metrics. + + Bool byteSwapped = (fRegs.specialEffects & sed1376ByteSwapMask) != 0; + Bool mono = (fRegs.displayMode & sed1376MonoMask) != 0; + int32 bpp = 1 << ((fRegs.displayMode & sed1376BPPMask) >> sed1376BPPShift); + + // The hardware is written to in reverse, so the mainStartOffsetX registers + // report the END of the frame buffer, not the beginning. + emuptr baseAddr = fBaseVideoAddr; + + int32 width = ((fRegs.horizontalPeriod + 1) * 8); + int32 height = ((fRegs.verticalPeriod1 << 8) | fRegs.verticalPeriod0) + 1; + int32 rowBytes = ((width * this->PrvGetLCDDepth ()) / 8); + + info.fLeftMargin = 0; + + if (bpp <= 8) + { + EmPixMapFormat format = bpp == 1 ? kPixMapFormat1 : + bpp == 2 ? kPixMapFormat2 : + bpp == 4 ? kPixMapFormat4 : + kPixMapFormat8; + + RGBList colorTable; + this->PrvGetPalette (colorTable); + + // Set format, size, and color table of EmPixMap. + + info.fImage.SetSize (EmPoint (width, height)); + info.fImage.SetFormat (format); + info.fImage.SetRowBytes (rowBytes); + info.fImage.SetColorTable (colorTable); + + // Determine first and last scanlines to fetch, and fetch them. + + info.fFirstLine = (info.fScreenLow - baseAddr) / rowBytes; + info.fLastLine = (info.fScreenHigh - baseAddr - 1) / rowBytes + 1; + + long firstLineOffset = info.fFirstLine * rowBytes; + long lastLineOffset = info.fLastLine * rowBytes; + + EmMem_memcpy ( + (void*) ((uint8*) info.fImage.GetBits () + firstLineOffset), + baseAddr + firstLineOffset, + lastLineOffset - firstLineOffset); + } + else + { + // Set depth, size, and color table of EmPixMap. + + info.fImage.SetSize (EmPoint (width, height)); + info.fImage.SetFormat (kPixMapFormat24RGB); + + // Determine first and last scanlines to fetch. + + info.fFirstLine = (info.fScreenLow - baseAddr) / rowBytes; + info.fLastLine = (info.fScreenHigh - baseAddr - 1) / rowBytes + 1; + + // Get location and rowBytes of source bytes. + + uint8* srcStart = EmMemGetRealAddress (baseAddr); + int32 srcRowBytes = rowBytes; + uint8* srcPtr = srcStart + srcRowBytes * info.fFirstLine; + uint8* srcPtr0 = srcPtr; + + // Get location and rowBytes of destination bytes. + + uint8* destStart = (uint8*) info.fImage.GetBits (); + int32 destRowBytes = info.fImage.GetRowBytes (); + uint8* destPtr = destStart + destRowBytes * info.fFirstLine; + uint8* destPtr0 = destPtr; + + // Get height of range to copy. + + int32 height = info.fLastLine - info.fFirstLine; + + // Copy the pixels from source to dest. + + for (int yy = 0; yy < height; ++yy) + { + for (int xx = 0; xx < width; ++xx) + { + uint8 p1 = EmMemDoGet8 (srcPtr++); // GGGBBBBB + uint8 p2 = EmMemDoGet8 (srcPtr++); // RRRRRGGG + + // Merge the two together so that we get RRRRRGGG GGGBBBBB + + uint16 p; + + if (!byteSwapped) + p = (p2 << 8) | p1; + else + p = (p1 << 8) | p2; + + // Shift the bits around, forming RRRRRrrr, GGGGGGgg, and + // BBBBBbbb values, where the lower-case bits are copies of + // the least significant bits in the upper-case bits. + // + // Note that all of this could also be done with three 64K + // lookup tables. If speed is an issue, we might want to + // investigate that. + + if (mono) + { + uint8 green = ((p >> 3) & 0xFC) | ((p >> 5) & 0x03); + *destPtr++ = green; + *destPtr++ = green; + *destPtr++ = green; + } + else + { + *destPtr++ = ((p >> 8) & 0xF8) | ((p >> 11) & 0x07); + *destPtr++ = ((p >> 3) & 0xFC) | ((p >> 5) & 0x03); + *destPtr++ = ((p << 3) & 0xF8) | ((p >> 0) & 0x07); + } + } + + srcPtr = srcPtr0 += srcRowBytes; + destPtr = destPtr0 += destRowBytes; + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376VisorPrism::PrvGetLCDDepth +// --------------------------------------------------------------------------- + +int32 EmRegsSED1376VisorPrism::PrvGetLCDDepth (void) +{ + UInt8 depth = fRegs.displayMode; + + depth &= sed1376DisplayModeDepthMask; + + switch (depth) + { + case sed1376DisplayModeDepth16: return 16; + case sed1376DisplayModeDepth8: return 8; + case sed1376DisplayModeDepth4: return 4; + case sed1376DisplayModeDepth2: return 2; + case sed1376DisplayModeDepth1: return 1; + default: EmAssert (false); + } + + return 8; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376VisorPrism::reservedWrite +// --------------------------------------------------------------------------- + +void EmRegsSED1376VisorPrism::reservedWrite (emuptr address, int size, uint32 value) +{ + UNUSED_PARAM (address); + UNUSED_PARAM (size); + UNUSED_PARAM (value); +} + + +#pragma mark - + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376PalmGeneric::EmRegsSED1376PalmGeneric +// --------------------------------------------------------------------------- + +EmRegsSED1376PalmGeneric::EmRegsSED1376PalmGeneric (emuptr baseRegsAddr, + emuptr baseVideoAddr) : + EmRegsSED1376 (baseRegsAddr, baseVideoAddr) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376PalmGeneric::~EmRegsSED1376PalmGeneric +// --------------------------------------------------------------------------- + +EmRegsSED1376PalmGeneric::~EmRegsSED1376PalmGeneric (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376PalmGeneric::GetLCDBeginEnd +// --------------------------------------------------------------------------- + +void EmRegsSED1376PalmGeneric::GetLCDBeginEnd (emuptr& begin, emuptr& end) +{ + // Get the screen metrics. + +// Bool wordSwapped = (fRegs.specialEffects & sed1376WordSwapMask) != 0; +// Bool byteSwapped = (fRegs.specialEffects & sed1376ByteSwapMask) != 0; +// int32 bpp = 1 << ((fRegs.displayMode & sed1376BPPMask) >> sed1376BPPShift); +#if !OVERLAY_IS_MAIN +// int32 width = ((fRegs.horizontalPeriod + 1) * 8); + int32 height = ((fRegs.verticalPeriod1 << 8) | fRegs.verticalPeriod0) + 1; + int32 rowBytes = ((fRegs.mainLineAddressOffset1 << 8) | fRegs.mainLineAddressOffset0) * 4; + uint32 offset = (fRegs.mainStartAddress2 << 18) | + (fRegs.mainStartAddress1 << 10) | + (fRegs.mainStartAddress0 << 2); +#else +// int32 left = ((fRegs.ovlyStartXPosition1 << 8) | fRegs.ovlyStartXPosition0) * 32 / bpp; +// int32 right = ((fRegs.ovlyEndXPosition1 << 8) | fRegs.ovlyEndXPosition0) * 32 / bpp; + int32 top = ((fRegs.ovlyStartYPosition1 << 8) | fRegs.ovlyStartYPosition0); + int32 bottom = ((fRegs.ovlyEndYPosition1 << 8) | fRegs.ovlyEndYPosition0); + +// int32 width = right - left + (32 / bpp); + int32 height = bottom - top + 1; + int32 rowBytes = ((fRegs.ovlyLineAddressOffset1 << 8) | fRegs.ovlyLineAddressOffset0) * 4; + uint32 offset = (fRegs.ovlyStartAddress2 << 18) | + (fRegs.ovlyStartAddress1 << 10) | + (fRegs.ovlyStartAddress0 << 2); +#endif + emuptr baseAddr = fBaseVideoAddr + offset; + + begin = baseAddr; + end = baseAddr + rowBytes * height; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsSED1376PalmGeneric::GetLCDScanlines +// --------------------------------------------------------------------------- + +void EmRegsSED1376PalmGeneric::GetLCDScanlines (EmScreenUpdateInfo& info) +{ + // Get the screen metrics. + +// Bool wordSwapped = (fRegs.specialEffects & sed1376WordSwapMask) != 0; + Bool byteSwapped = (fRegs.specialEffects & sed1376ByteSwapMask) != 0; + Bool mono = (fRegs.displayMode & sed1376MonoMask) != 0; + int32 bpp = 1 << ((fRegs.displayMode & sed1376BPPMask) >> sed1376BPPShift); +#if !OVERLAY_IS_MAIN + int32 width = ((fRegs.horizontalPeriod + 1) * 8); + int32 height = ((fRegs.verticalPeriod1 << 8) | fRegs.verticalPeriod0) + 1; + int32 rowBytes = ((fRegs.mainLineAddressOffset1 << 8) | fRegs.mainLineAddressOffset0) * 4; + uint32 offset = (fRegs.mainStartAddress2 << 18) | + (fRegs.mainStartAddress1 << 10) | + (fRegs.mainStartAddress0 << 2); +#else + int32 left = ((fRegs.ovlyStartXPosition1 << 8) | fRegs.ovlyStartXPosition0) * 32 / bpp; + int32 right = ((fRegs.ovlyEndXPosition1 << 8) | fRegs.ovlyEndXPosition0) * 32 / bpp; + int32 top = ((fRegs.ovlyStartYPosition1 << 8) | fRegs.ovlyStartYPosition0); + int32 bottom = ((fRegs.ovlyEndYPosition1 << 8) | fRegs.ovlyEndYPosition0); + + int32 width = right - left + (32 / bpp); + int32 height = bottom - top + 1; + int32 rowBytes = ((fRegs.ovlyLineAddressOffset1 << 8) | fRegs.ovlyLineAddressOffset0) * 4; + uint32 offset = (fRegs.ovlyStartAddress2 << 18) | + (fRegs.ovlyStartAddress1 << 10) | + (fRegs.ovlyStartAddress0 << 2); +#endif + emuptr baseAddr = fBaseVideoAddr + offset; + + info.fLeftMargin = 0; + + if (bpp <= 8) + { + EmPixMapFormat format = bpp == 1 ? kPixMapFormat1 : + bpp == 2 ? kPixMapFormat2 : + bpp == 4 ? kPixMapFormat4 : + kPixMapFormat8; + + RGBList colorTable; + this->PrvGetPalette (colorTable); + + // Set format, size, and color table of EmPixMap. + + info.fImage.SetSize (EmPoint (width, height)); + info.fImage.SetFormat (format); + info.fImage.SetRowBytes (rowBytes); + info.fImage.SetColorTable (colorTable); + + // Determine first and last scanlines to fetch, and fetch them. + + info.fFirstLine = (info.fScreenLow - baseAddr) / rowBytes; + info.fLastLine = (info.fScreenHigh - baseAddr - 1) / rowBytes + 1; + + long firstLineOffset = info.fFirstLine * rowBytes; + long lastLineOffset = info.fLastLine * rowBytes; + + EmMem_memcpy ( + (void*) ((uint8*) info.fImage.GetBits () + firstLineOffset), + baseAddr + firstLineOffset, + lastLineOffset - firstLineOffset); + } + else + { + // Set depth, size, and color table of EmPixMap. + + info.fImage.SetSize (EmPoint (width, height)); + info.fImage.SetFormat (kPixMapFormat24RGB); + + // Determine first and last scanlines to fetch. + + info.fFirstLine = (info.fScreenLow - baseAddr) / rowBytes; + info.fLastLine = (info.fScreenHigh - baseAddr - 1) / rowBytes + 1; + + // Get location and rowBytes of source bytes. + + uint8* srcStart = EmMemGetRealAddress (baseAddr); + int32 srcRowBytes = rowBytes; + uint8* srcPtr = srcStart + srcRowBytes * info.fFirstLine; + uint8* srcPtr0 = srcPtr; + + // Get location and rowBytes of destination bytes. + + uint8* destStart = (uint8*) info.fImage.GetBits (); + int32 destRowBytes = info.fImage.GetRowBytes (); + uint8* destPtr = destStart + destRowBytes * info.fFirstLine; + uint8* destPtr0 = destPtr; + + // Get height of range to copy. + + int32 height = info.fLastLine - info.fFirstLine; + + // Copy the pixels from source to dest. + + for (int yy = 0; yy < height; ++yy) + { + for (int xx = 0; xx < width; ++xx) + { + uint8 p1 = EmMemDoGet8 (srcPtr++); // GGGBBBBB + uint8 p2 = EmMemDoGet8 (srcPtr++); // RRRRRGGG + + // Merge the two together so that we get RRRRRGGG GGGBBBBB + + uint16 p; + + if (!byteSwapped) + p = (p2 << 8) | p1; + else + p = (p1 << 8) | p2; + + // Shift the bits around, forming RRRRRrrr, GGGGGGgg, and + // BBBBBbbb values, where the lower-case bits are copies of + // the least significant bits in the upper-case bits. + // + // Note that all of this could also be done with three 64K + // lookup tables. If speed is an issue, we might want to + // investigate that. + + if (mono) + { + uint8 green = ((p >> 3) & 0xFC) | ((p >> 5) & 0x03); + *destPtr++ = green; + *destPtr++ = green; + *destPtr++ = green; + } + else + { + *destPtr++ = ((p >> 8) & 0xF8) | ((p >> 11) & 0x07); + *destPtr++ = ((p >> 3) & 0xFC) | ((p >> 5) & 0x03); + *destPtr++ = ((p << 3) & 0xF8) | ((p >> 0) & 0x07); + } + } + + srcPtr = srcPtr0 += srcRowBytes; + destPtr = destPtr0 += destRowBytes; + } + } + + if (!this->GetLCDBacklightOn ()) + { + info.fImage.ChangeTone (-10, info.fFirstLine, info.fLastLine); + } +} diff --git a/SrcShared/Hardware/EmRegsSED1376.h b/SrcShared/Hardware/EmRegsSED1376.h new file mode 100644 index 0000000..62a1c56 --- /dev/null +++ b/SrcShared/Hardware/EmRegsSED1376.h @@ -0,0 +1,106 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsSED1376_h +#define EmRegsSED1376_h + +#include "EmHAL.h" // EmHALHandler +#include "EmPalmStructs.h" +#include "EmRegs.h" +#include "EmStructs.h" // RGBList + +class SessionFile; +class EmScreenUpdateInfo; + + +#define sed1376RegsAddr (0x1FF80000) +#define sed1376VideoMemStart (0x1FFA0000) +#define sed1376VideoMemSize (80 * 1024L) + + +class EmRegsSED1376 : public EmRegs, public EmHALHandler +{ + public: + EmRegsSED1376 (emuptr baseRegsAddr, + emuptr baseVideoAddr); + virtual ~EmRegsSED1376 (void); + + // EmRegs overrides + virtual void Initialize (void); + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + virtual void Dispose (void); + + virtual void SetSubBankHandlers (void); + virtual uint8* GetRealAddress (emuptr address); + virtual emuptr GetAddressStart (void); + virtual uint32 GetAddressRange (void); + + // EmHAL overrides + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLCDHasFrame (void); + virtual void GetLCDBeginEnd (emuptr& begin, emuptr& end) = 0; + virtual void GetLCDScanlines (EmScreenUpdateInfo& info) = 0; + + private: + uint32 powerSaveConfigurationRead (emuptr address, int size); + + void invalidateWrite (emuptr address, int size, uint32 value); + void lutWriteAddressWrite (emuptr address, int size, uint32 value); + void lutReadAddressWrite (emuptr address, int size, uint32 value); + + protected: + void PrvGetPalette (RGBList& thePalette); + + protected: + emuptr fBaseRegsAddr; + emuptr fBaseVideoAddr; + EmProxySED1376RegsType fRegs; + RGBType fClutData[256]; +}; + + +class EmRegsSED1376VisorPrism : public EmRegsSED1376 +{ + public: + EmRegsSED1376VisorPrism (emuptr baseRegsAddr, + emuptr baseVideoAddr); + virtual ~EmRegsSED1376VisorPrism (void); + + virtual void SetSubBankHandlers (void); + + virtual void GetLCDBeginEnd (emuptr& begin, emuptr& end); + virtual void GetLCDScanlines (EmScreenUpdateInfo& info); + + private: + void reservedWrite (emuptr address, int size, uint32 value); + + private: + int32 PrvGetLCDDepth (void); +}; + + +class EmRegsSED1376PalmGeneric : public EmRegsSED1376 +{ + public: + EmRegsSED1376PalmGeneric (emuptr baseRegsAddr, + emuptr baseVideoAddr); + virtual ~EmRegsSED1376PalmGeneric (void); + + virtual void GetLCDBeginEnd (emuptr& begin, emuptr& end); + virtual void GetLCDScanlines (EmScreenUpdateInfo& info); +}; + +#endif /* EmRegsSED1376_h */ diff --git a/SrcShared/Hardware/EmRegsSZ.cpp b/SrcShared/Hardware/EmRegsSZ.cpp new file mode 100644 index 0000000..b6b0a96 --- /dev/null +++ b/SrcShared/Hardware/EmRegsSZ.cpp @@ -0,0 +1,17 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsSZ.h" +#include "EmRegsSZPrv.h" + diff --git a/SrcShared/Hardware/EmRegsSZ.h b/SrcShared/Hardware/EmRegsSZ.h new file mode 100644 index 0000000..bc4f3b3 --- /dev/null +++ b/SrcShared/Hardware/EmRegsSZ.h @@ -0,0 +1,18 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsSZ_h +#define EmRegsSZ_h + + +#endif /* EmRegsSZ_h */ diff --git a/SrcShared/Hardware/EmRegsSZPrv.h b/SrcShared/Hardware/EmRegsSZPrv.h new file mode 100644 index 0000000..4c9aaa7 --- /dev/null +++ b/SrcShared/Hardware/EmRegsSZPrv.h @@ -0,0 +1,19 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsSZPrv_h +#define EmRegsSZPrv_h + + + +#endif /* EmRegsSZPrv_h */ diff --git a/SrcShared/Hardware/EmRegsSZTemp.cpp b/SrcShared/Hardware/EmRegsSZTemp.cpp new file mode 100644 index 0000000..7a621bf --- /dev/null +++ b/SrcShared/Hardware/EmRegsSZTemp.cpp @@ -0,0 +1,17 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsSZTemp.h" +#include "EmRegsSZPrv.h" + diff --git a/SrcShared/Hardware/EmRegsSZTemp.h b/SrcShared/Hardware/EmRegsSZTemp.h new file mode 100644 index 0000000..7905540 --- /dev/null +++ b/SrcShared/Hardware/EmRegsSZTemp.h @@ -0,0 +1,20 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsSZTemp_h +#define EmRegsSZTemp_h + +#include "EmRegsSZ.h" + + +#endif /* EmRegsSZTemp_h */ diff --git a/SrcShared/Hardware/EmRegsUSBPhilipsPDIUSBD12.cpp b/SrcShared/Hardware/EmRegsUSBPhilipsPDIUSBD12.cpp new file mode 100644 index 0000000..20df6e1 --- /dev/null +++ b/SrcShared/Hardware/EmRegsUSBPhilipsPDIUSBD12.cpp @@ -0,0 +1,154 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsUSBPhilipsPDIUSBD12.h" + + +// Given a register (specified by its field name), return its address +// in emulated space. + +#undef addressof +#define addressof(reg) \ + (this->GetAddressStart () + fRegs.offsetof_##reg ()) + + +// Macro to help the installation of handlers for a register. + +#undef INSTALL_HANDLER +#define INSTALL_HANDLER(read, write, reg) \ + this->SetHandler ( (ReadFunction) &EmRegsUSBPhilipsPDIUSBD12::read, \ + (WriteFunction) &EmRegsUSBPhilipsPDIUSBD12::write, \ + addressof (reg), \ + fRegs.reg.GetSize ()) + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBPhilipsPDIUSBD12::EmRegsUSBPhilipsPDIUSBD12 +// --------------------------------------------------------------------------- + +EmRegsUSBPhilipsPDIUSBD12::EmRegsUSBPhilipsPDIUSBD12 (emuptr baseAddr) : + fBaseAddr (baseAddr) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBPhilipsPDIUSBD12::~EmRegsUSBPhilipsPDIUSBD12 +// --------------------------------------------------------------------------- + +EmRegsUSBPhilipsPDIUSBD12::~EmRegsUSBPhilipsPDIUSBD12 (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBPhilipsPDIUSBD12::Initialize +// --------------------------------------------------------------------------- + +void EmRegsUSBPhilipsPDIUSBD12::Initialize (void) +{ + EmRegs::Initialize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBPhilipsPDIUSBD12::Reset +// --------------------------------------------------------------------------- + +void EmRegsUSBPhilipsPDIUSBD12::Reset (Bool hardwareReset) +{ + EmRegs::Reset (hardwareReset); + + if (hardwareReset) + { + memset (fRegs.GetPtr (), 0, fRegs.GetSize ()); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBPhilipsPDIUSBD12::Save +// --------------------------------------------------------------------------- + +void EmRegsUSBPhilipsPDIUSBD12::Save (SessionFile& f) +{ + EmRegs::Save (f); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBPhilipsPDIUSBD12::Load +// --------------------------------------------------------------------------- + +void EmRegsUSBPhilipsPDIUSBD12::Load (SessionFile& f) +{ + EmRegs::Load (f); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBPhilipsPDIUSBD12::Dispose +// --------------------------------------------------------------------------- + +void EmRegsUSBPhilipsPDIUSBD12::Dispose (void) +{ + EmRegs::Dispose (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBPhilipsPDIUSBD12::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegsUSBPhilipsPDIUSBD12::SetSubBankHandlers (void) +{ + // Install base handlers. + + EmRegs::SetSubBankHandlers (); + + // Now add standard/specialized handers for the defined registers. + + INSTALL_HANDLER (StdReadBE, StdWriteBE, data); + INSTALL_HANDLER (StdReadBE, StdWriteBE, command); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBPhilipsPDIUSBD12::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmRegsUSBPhilipsPDIUSBD12::GetRealAddress (emuptr address) +{ + return (uint8*) fRegs.GetPtr () + address - this->GetAddressStart (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBPhilipsPDIUSBD12::GetAddressStart +// --------------------------------------------------------------------------- + +emuptr EmRegsUSBPhilipsPDIUSBD12::GetAddressStart (void) +{ + return fBaseAddr; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBPhilipsPDIUSBD12::GetAddressRange +// --------------------------------------------------------------------------- + +uint32 EmRegsUSBPhilipsPDIUSBD12::GetAddressRange (void) +{ + return fRegs.GetSize (); +} diff --git a/SrcShared/Hardware/EmRegsUSBPhilipsPDIUSBD12.h b/SrcShared/Hardware/EmRegsUSBPhilipsPDIUSBD12.h new file mode 100644 index 0000000..71e0b34 --- /dev/null +++ b/SrcShared/Hardware/EmRegsUSBPhilipsPDIUSBD12.h @@ -0,0 +1,42 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsUSBPhilipsPDIUSBD12_h +#define EmRegsUSBPhilipsPDIUSBD12_h + +#include "EmRegs.h" +#include "EmPalmStructs.h" // EmProxyUsbHwrType + +class EmRegsUSBPhilipsPDIUSBD12 : public EmRegs +{ + public: + EmRegsUSBPhilipsPDIUSBD12 (emuptr); + virtual ~EmRegsUSBPhilipsPDIUSBD12 (void); + + virtual void Initialize (void); + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + virtual void Dispose (void); + + virtual void SetSubBankHandlers (void); + virtual uint8* GetRealAddress (emuptr address); + virtual emuptr GetAddressStart (void); + virtual uint32 GetAddressRange (void); + + private: + emuptr fBaseAddr; + EmProxyUsbHwrType fRegs; +}; + +#endif /* EmRegsUSBPhilipsPDIUSBD12_h */ diff --git a/SrcShared/Hardware/EmRegsUSBVisor.cpp b/SrcShared/Hardware/EmRegsUSBVisor.cpp new file mode 100644 index 0000000..ccd4c6e --- /dev/null +++ b/SrcShared/Hardware/EmRegsUSBVisor.cpp @@ -0,0 +1,164 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsUSBVisor.h" + +#include "EmSession.h" // GetDevice +#include "EmHAL.h" // EmHAL::GetROMSize +#include "EmBankROM.h" // EmBankROM::GetMemoryStart + + +// Given a register (specified by its field name), return its address +// in emulated space. + +#define addressof(reg) \ + (this->GetAddressStart () + fRegs.offsetof_##reg ()) + + +// Macro to help the installation of handlers for a register. + +#define INSTALL_HANDLER(read, write, reg) \ + this->SetHandler ( (ReadFunction) &EmRegsUSBVisor::read, \ + (WriteFunction) &EmRegsUSBVisor::write, \ + addressof (reg), \ + fRegs.reg.GetSize ()) + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBVisor::EmRegsUSBVisor +// --------------------------------------------------------------------------- + +EmRegsUSBVisor::EmRegsUSBVisor (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBVisor::~EmRegsUSBVisor +// --------------------------------------------------------------------------- + +EmRegsUSBVisor::~EmRegsUSBVisor (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBVisor::Initialize +// --------------------------------------------------------------------------- + +void EmRegsUSBVisor::Initialize (void) +{ + EmRegs::Initialize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBVisor::Reset +// --------------------------------------------------------------------------- + +void EmRegsUSBVisor::Reset (Bool hardwareReset) +{ + EmRegs::Reset (hardwareReset); + + if (hardwareReset) + { + memset (fRegs.GetPtr (), 0, fRegs.GetSize ()); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBVisor::Save +// --------------------------------------------------------------------------- + +void EmRegsUSBVisor::Save (SessionFile& f) +{ + EmRegs::Save (f); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBVisor::Load +// --------------------------------------------------------------------------- + +void EmRegsUSBVisor::Load (SessionFile& f) +{ + EmRegs::Load (f); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBVisor::Dispose +// --------------------------------------------------------------------------- + +void EmRegsUSBVisor::Dispose (void) +{ + EmRegs::Dispose (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBVisor::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegsUSBVisor::SetSubBankHandlers (void) +{ + // Install base handlers. + + EmRegs::SetSubBankHandlers (); + + // Now add standard/specialized handers for the defined registers. + + INSTALL_HANDLER (StdReadBE, StdWriteBE, data); + INSTALL_HANDLER (StdReadBE, StdWriteBE, command); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBVisor::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmRegsUSBVisor::GetRealAddress (emuptr address) +{ + return (uint8*) fRegs.GetPtr () + address - this->GetAddressStart (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBVisor::GetAddressStart +// --------------------------------------------------------------------------- + +emuptr EmRegsUSBVisor::GetAddressStart (void) +{ + /* + Auto-detect USB hardware base address. In the Visor, the USB hardware + is at CSA1, which resides just after the ROM (CSA0) in memory. + */ + + EmDevice device = gSession->GetDevice (); + if (device.HardwareID () == 0x0a /*halModelIDVisorPrism*/) // in Prism it is not at CSA1 + return (emuptr) 0x10800000L; + + return EmBankROM::GetMemoryStart() + EmHAL::GetROMSize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsUSBVisor::GetAddressRange +// --------------------------------------------------------------------------- + +uint32 EmRegsUSBVisor::GetAddressRange (void) +{ + return fRegs.GetSize (); +} diff --git a/SrcShared/Hardware/EmRegsUSBVisor.h b/SrcShared/Hardware/EmRegsUSBVisor.h new file mode 100644 index 0000000..0468f39 --- /dev/null +++ b/SrcShared/Hardware/EmRegsUSBVisor.h @@ -0,0 +1,44 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsUSBVisor_h +#define EmRegsUSBVisor_h + +#include "EmPalmStructs.h" +#include "EmRegs.h" + +class SessionFile; + + +class EmRegsUSBVisor : public EmRegs +{ + public: + EmRegsUSBVisor (void); + virtual ~EmRegsUSBVisor (void); + + virtual void Initialize (void); + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + virtual void Dispose (void); + + virtual void SetSubBankHandlers (void); + virtual uint8* GetRealAddress (emuptr address); + virtual emuptr GetAddressStart (void); + virtual uint32 GetAddressRange (void); + + private: + EmProxyUsbHwrType fRegs; +}; + +#endif /* EmRegsUSBVisor_h */ diff --git a/SrcShared/Hardware/EmRegsVZ.cpp b/SrcShared/Hardware/EmRegsVZ.cpp new file mode 100644 index 0000000..f646b5b --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZ.cpp @@ -0,0 +1,3116 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsVZ.h" +#include "EmRegsVZPrv.h" + +#include "Byteswapping.h" // Canonical +#include "EmDevice.h" +#include "EmHAL.h" // EmHAL +#include "EmMemory.h" // gMemAccessFlags, EmMem_memcpy +#include "EmPixMap.h" // SetSize, SetRowBytes, etc. +#include "EmScreen.h" // EmScreenUpdateInfo +#include "EmSession.h" // gSession +#include "EmSPISlave.h" // DoExchange +#include "Hordes.h" // Hordes::IsOn +#include "Logging.h" // LogAppendMsg +#include "Miscellaneous.h" // GetHostTime +#include "PreferenceMgr.h" // Preference +#include "SessionFile.h" // WriteHwrDBallVZType, etc. +#include "UAE.h" // regs, SPCFLAG_INT + +#include "PalmPack.h" +#define NON_PORTABLE + #include "HwrMiscFlags.h" // hwrMiscFlagID1 + + // Some platform-specific -- yet fairly portable -- defines. + #define hwrVZPortDKbdCol0 0x01 // (H) Keyboard Column 0 (aka INT0) + #define hwrVZPortDKbdCol1 0x02 // (H) Keyboard Column 1 (aka INT1) + #define hwrVZPortDKbdCol2 0x04 // (H) Keyboard Column 2 (aka INT2) + #define hwrVZPortDKbdCol3 0x08 // (H) Keyboard Column 3 (aka INT3) + #define hwrVZPortDKeyBits 0x0F // All Keyboard Columns + +#undef NON_PORTABLE +#include "PalmPackPop.h" + + +static const uint16 UPSIZMask = 0x1800; // Mask to get the unprotected memory size from csDSelect. +static const uint16 DRAMMask = 0x0200; +static const uint16 SIZMask = 0x000E; // Mask to get the memory size from csASelect. +static const uint16 ENMask = 0x0001; // Mask to get the enable bit from csASelect. + +static const int UPSIZShift = 11; +static const int SIZShift = 1; +static const int ENShift = 0; + +static const uint16 BUPS2Mask = 0x0001; +static const uint16 CUPS2Mask = 0x0004; +static const uint16 DUPS2Mask = 0x0010; +static const uint16 DSIZ3Mask = 0x0040; +static const uint16 EUPENMask = 0x4000; + +static const int BUPS2Shift = 0; +static const int CUPS2Shift = 2; +static const int DUPS2Shift = 4; + +static const int kBaseAddressShift = 13; // Shift to get base address from CSGBx register value + +#define PRINTF if (1) ; else LogAppendMsg + +// Values used to initialize the DragonBallVZ registers. + +static const HwrM68VZ328Type kInitial68VZ328RegisterValues = +{ + 0x1C, // UInt8 scr; // $000: System Control Register + + { 0 }, // UInt8 ___filler0[0x003-0x001]; + + 0x00, // UInt8 pcr; // $003: Peripheral Control Register + 0x56, // UInt8 chipID; // $004: Chip ID Register + 0x01, // UInt8 maskID; // $005: Mask ID Register + 0x0000, // UInt16 swID; // $006: Software ID Register + 0x1FFF, // UInt16 ioDriveControl; // $008: I/O Drive Control Register + + { 0 }, // UInt8 ___filler1[0x100-0x00A]; + + 0x0000, // UInt16 csAGroupBase; // $100: Chip Select Group A Base Register + 0x0000, // UInt16 csBGroupBase; // $102: Chip Select Group B Base Register + 0x0000, // UInt16 csCGroupBase; // $104: Chip Select Group C Base Register + 0x0000, // UInt16 csDGroupBase; // $106: Chip Select Group D Base Register + + 0x0000, // UInt16 csUGroupBase; // $108: Chip Select Upper Group Base Register + + 0x0000, // UInt16 csControl1; // $10A: Chip Select Control Register + 0x0000, // UInt16 csControl2; // $10C: Chip Select Control Register + + { 0 }, // UInt8 ___filler2[0x110-0x10c]; + + 0x00B0, // UInt16 csASelect; // $110: Group A Chip Select Register + 0x0000, // UInt16 csBSelect; // $112: Group B Chip Select Register + 0x0000, // UInt16 csCSelect; // $114: Group C Chip Select Register + 0x0200, // UInt16 csDSelect; // $116: Group D Chip Select Register + + 0x0060, // UInt16 emuCS; // $118: EMU Chip Select Register + + { 0 }, // UInt8 ___filler3[0x200-0x11A]; + + 0x0000, // UInt16 csControl3; // $150: Chip Select Control Register + + { 0 }, // UInt8 ___filler3[0x200-0x11A]; + + 0x24B3, // UInt16 pllControl; // $200: PLL Control Register + 0x0123, // UInt16 pllFreqSel; // $202: CGM Frequency Select Register + + { 0 }, // UInt8 ___filler4[0x207-0x204]; + + 0x1F, // UInt8 pwrControl; // $207: Power Control Register + + { 0 }, // UInt8 ___filler5[0x300-0x208]; + + 0x00, // UInt8 intVector; // $300: Interrupt Vector Register + 0x00, // UInt8 ___filler6; + 0x0000, // UInt16 intControl; // $302: Interrupt Control Register + 0x00FF, // UInt16 intMaskHi; // $304: Interrupt Mask Register/HIGH word + 0xFFFF, // UInt16 intMaskLo; // $306: Interrupt Mask Register/LOW word + { 0 }, // UInt8 ___filler7[0x30c-0x308]; + 0x0000, // UInt16 intStatusHi; // $30C: Interrupt Status Register/HIGH word + 0x0000, // UInt16 intStatusLo; // $30E: Interrupt Status Register/LOW word + 0x0000, // UInt16 intPendingHi; // $310: Interrupt Pending Register/HIGH word + 0x0000, // UInt16 intPendingLo; // $312: Interrupt Pending Register/LOW word + 0x6533, // UInt16 intLevelControl; // $314: Interrupt Level Control Register + + { 0 }, // UInt8 ___filler4a[0x400-0x316]; + + 0x00, // UInt8 portADir; // $400: Port A Direction Register + 0x00, // UInt8 portAData; // $401: Port A Data Register + 0xFF, // UInt8 portAPullupEn; // $402: Port A Pullup Enable + + { 0 }, // UInt8 ___filler8[5]; + + 0x00, // UInt8 portBDir; // $408: Port B Direction Register + 0x00, // UInt8 portBData; // $409: Port B Data Register + 0xFF, // UInt8 portBPullupEn; // $40A: Port B Pullup Enable + 0xFF, // UInt8 portBSelect; // $40B: Port B Select Register + + { 0 }, // UInt8 ___filler9[4]; + + 0x00, // UInt8 portCDir; // $410: Port C Direction Register + 0x00, // UInt8 portCData; // $411: Port C Data Register + 0xFF, // UInt8 portCPulldnEn; // $412: Port C Pulldown Enable + 0xFF, // UInt8 portCSelect; // $413: Port C Select Register + + { 0 }, // UInt8 ___filler10[4]; + + 0x00, // UInt8 portDDir; // $418: Port D Direction Register + 0x00, // UInt8 portDData; // $419: Port D Data Register + 0xFF, // UInt8 portDPullupEn; // $41A: Port D Pull-up Enable + 0xFF, // UInt8 portDSelect; // $41B: Port D Select Register + 0x00, // UInt8 portDPolarity; // $41C: Port D Polarity Register + 0x00, // UInt8 portDIntReqEn; // $41D: Port D Interrupt Request Enable + 0x00, // UInt8 portDKbdIntEn; // $41E: Port D Keyboard Interrupt Enable + 0x00, // UInt8 portDIntEdge; // $41F: Port D IRQ Edge Register + + 0x00, // UInt8 portEDir; // $420: Port E Direction Register + 0x00, // UInt8 portEData; // $421: Port E Data Register + 0xFF, // UInt8 portEPullupEn; // $422: Port E Pull-up Enable + 0xFF, // UInt8 portESelect; // $423: Port E Select Register + + { 0 }, // UInt8 ___filler14[4]; + + 0x00, // UInt8 portFDir; // $428: Port F Direction Register + 0x00, // UInt8 portFData; // $429: Port F Data Register + 0xFF, // UInt8 portFPullupdnEn; // $42A: Port F Pull-up/down Enable + 0x8F, // UInt8 portFSelect; // $42B: Port F Select Register + + { 0 }, // UInt8 ___filler16[4]; + + 0x00, // UInt8 portGDir; // $430: Port G Direction Register + 0x00, // UInt8 portGData; // $431: Port G Data Register + 0x3D, // UInt8 portGPullupEn; // $432: Port G Pull-up Enable + 0x08, // UInt8 portGSelect; // $433: Port G Select Register + + { 0 }, // UInt8 ___filler17[0x438-0x434]; + + 0x00, // UInt8 portJDir; // $438: Port J Direction Register + 0x00, // UInt8 portJData; // $439: Port J Data Register + 0xFF, // UInt8 portJPullupEn; // $43A: Port J Pull-up Enable + 0xEF, // UInt8 portJSelect; // $43B: Port J Select Register + + { 0 }, // UInt8 ___filler18[0x440-0x43C]; + + 0x00, // UInt8 portKDir; // $440: Port K Direction Register + 0x00, // UInt8 portKData; // $441: Port K Data Register + 0xFF, // UInt8 portKPullupdnEn; // $442: Port K Pull-up/down Enable + 0xFF, // UInt8 portKSelect; // $443: Port K Select Register + + { 0 }, // UInt8 ___filler19[0x448-0x444]; + + 0x00, // UInt8 portMDir; // $448: Port M Direction Register + 0x00, // UInt8 portMData; // $449: Port M Data Register + 0x3F, // UInt8 portMPullupdnEn; // $44A: Port M Pull-up/down Enable + 0x3F, // UInt8 portMSelect; // $44B: Port M Select Register + + { 0 }, // UInt8 ___filler20[0x500-0x44C]; + + 0x0020, // UInt16 pwmControl; // $500: PWM 1 Control Register (PWM 1 is the same as the single PWM in EZ) + 0x00, // UInt8 pwmSampleHi; // $502: PWM 1 Sample - high byte + 0x00, // UInt8 pwmSampleLo; // $503: PWM 1 Sample - low byte + 0xFE, // UInt8 pwmPeriod; // $504: PWM 1 Period + 0x00, // UInt8 pwmCounter; // $505: PWM 1 Counter + + { 0 }, // UInt8 ___filler22[0x510-0x506]; + + 0x0000, // UInt16 pwm2Control; // $510: PWM 2 Control Register + 0x0000, // UInt16 pwm2Period; // $512: PWM 2 Period + 0x0000, // UInt16 pwm2Width; // $514: PWM 2 Width + 0x0000, // UInt16 pwm2Counter; // $516: PWM 2 Counter + + { 0 }, // UInt8 ___filler23[0x600-0x518]; + + 0x0000, // UInt16 tmr1Control; // $600: Timer 1 Control Register + 0x0000, // UInt16 tmr1Prescaler; // $602: Timer 1 Prescaler Register + 0xFFFF, // UInt16 tmr1Compare; // $604: Timer 1 Compare Register + 0x0000, // UInt16 tmr1Capture; // $606: Timer 1 Capture Register + 0x0000, // UInt16 tmr1Counter; // $608: Timer 1 Counter Register + 0x0000, // UInt16 tmr1Status; // $60A: Timer 1 Status Register + + { 0 }, // UInt8 ___filler24[0x610-0x60C]; + + 0x0000, // UInt16 tmr2Control; // $610: Timer 2 Control Register + 0x0000, // UInt16 tmr2Prescaler; // $612: Timer 2 Prescaler Register + 0xFFFF, // UInt16 tmr2Compare; // $614: Timer 2 Compare Register + 0x0000, // UInt16 tmr2Capture; // $616: Timer 2 Capture Register + 0x0000, // UInt16 tmr2Counter; // $618: Timer 2 Counter Register + 0x0000, // UInt16 tmr2Status; // $61A: Timer 2 Status Register + + { 0 }, // UInt8 ___filler25[0x700-0x61C]; + + 0x0000, // UInt16 spiRxD; // $700: SPI Unit 1 Receive Data Register + 0x0000, // UInt16 spiTxD; // $702: SPI Unit 1 Transmit Data Register + 0x0000, // UInt16 spiCont1; // $704: SPI Unit 1 Control/Status Register + 0x0000, // UInt16 spiIntCS; // $706: SPI Unit 1 Interrupt control/Status Register + 0x0000, // UInt16 spiTest; // $708: SPI Unit 1 Test Register + 0x0000, // UInt16 spiSpc; // $70A: SPI Unit 1 Sample period counter register + + { 0 }, // UInt8 ___filler26[0x800-0x706]; + + 0x0000, // UInt16 spiMasterData; // $800: SPI Unit 2 Data Register (SPI 2 is the same as the single SPI Master in EZ) + 0x0000, // UInt16 spiMasterControl; // $802: SPI Unit 2 Control/Status Register + + { 0 }, // UInt8 ___filler27[0x900-0x804]; + + 0x0000, // UInt16 uControl; // $900: Uart 1 Status/Control Register (Uart 1 is the same as the single Uart in EZ) + 0x003F, // UInt16 uBaud; // $902: Uart 1 Baud Control Register + 0x0000, // UInt16 uReceive; // $904: Uart 1 Receive Register + 0x0000, // UInt16 uTransmit; // $906: Uart 1 Transmit Register + 0x0000, // UInt16 uMisc; // $908: Uart 1 Miscellaneous Register + 0x0000, // UInt16 uNonIntPresc; // $90A: Uart 1 Non-Integer Prescaler + + { 0 }, // UInt8 ___filler28[0x910-0x90C]; + + 0x0000, // UInt16 u2Control; // $910: Uart 2 Status/Control Register + 0x003F, // UInt16 u2Baud; // $912: Uart 2 Baud Control Register + 0x0000, // UInt16 u2Receive; // $914: Uart 2 Receiver Register + 0x0000, // UInt16 u2Transmit; // $916: Uart 2 Transmitter Register + 0x0000, // UInt16 u2Misc; // $918: Uart 2 Miscellaneous Register + 0x0000, // UInt16 u2NonIntPresc; // $91A: Uart 2 Non-Integer Prescaler + 0x0000, // UInt16 u2FIFOHMark; // $91C: Uart 2 Half Mark FIFO Register + + { 0 }, // UInt8 ___filler28a[0xA00-0x91E]; + + 0x00000000, // UInt32 lcdStartAddr; // $A00: Screen Starting Address Register + { 0 }, // UInt8 ___filler29; + 0xFF, // UInt8 lcdPageWidth; // $A05: Virtual Page Width Register + { 0 }, // UInt8 ___filler30[2]; + 0x03F0, // UInt16 lcdScreenWidth; // $A08: Screen Width Register + 0x01FF, // UInt16 lcdScreenHeight; // $A0A: Screen Height Register + { 0 }, // UInt8 ___filler31[0xA18-0xA0C]; + 0x0000, // UInt16 lcdCursorXPos; // $A18: Cursor X Position + 0x0000, // UInt16 lcdCursorYPos; // $A1A: Cursor Y Position + 0x0101, // UInt16 lcdCursorWidthHeight; // $A1C: Cursor Width and Height + { 0 }, // UInt8 ___filler32; + 0x7F, // UInt8 lcdBlinkControl; // $A1F: Blink Control Register + 0x00, // UInt8 lcdPanelControl; // $A20: Panel Interface Configuration Register + 0x00, // UInt8 lcdPolarity; // $A21: Polarity Config Register + { 0 }, // UInt8 ___filler33; + 0x00, // UInt8 lcdACDRate; // $A23: ACD (M) Rate Control Register + { 0 }, // UInt8 ___filler34; + 0x00, // UInt8 lcdPixelClock; // $A25: Pixel Clock Divider Register + { 0 }, // UInt8 ___filler35; + 0x00, // UInt8 lcdClockControl; // $A27: Clocking Control Register + 0x00FF, // UInt16 lcdRefreshRateAdj; // $A28: Refresh Rate Adjustment Register + { 0 }, // UInt8 ___filler37; + 0x00, // UInt8 lcdReserved1; // $A2B: Reserved + { 0 }, // UInt8 ___filler38; + 0x00, // UInt8 lcdPanningOffset; // $A2D: Panning Offset Register + + { 0 }, // UInt8 ___filler39[0xA31-0xA2E]; + + 0x00, // UInt8 lcdFrameRate; // $A31: Frame Rate Control Modulation Register + { 0 }, // UInt8 ___filler2004; + 0x84, // UInt8 lcdGrayPalette; // $A33: Gray Palette Mapping Register + 0x00, // UInt8 lcdReserved2; // $A34: Reserved + { 0 }, // UInt8 ___filler2005; + 0x0000, // UInt16 lcdContrastControlPWM; // $A36: Contrast Control + 0x00, // UInt8 lcdRefreshModeControl; // $A38: Refresh Mode Control Register + 0x62, // UInt8 lcdDMAControl; // $A39: DMA Control Register + + { 0 }, // UInt8 ___filler40[0xB00-0xA3a]; + + 0x00000000, // UInt32 rtcHourMinSec; // $B00: RTC Hours, Minutes, Seconds Register + 0x00000000, // UInt32 rtcAlarm; // $B04: RTC Alarm Register + { 0 }, // UInt8 ___filler2001[0xB0A-0xB08]; + 0x0001, // UInt16 rtcWatchDog; // $B0A: RTC Watchdog Timer + 0x0080, // UInt16 rtcControl; // $B0C: RTC Control Register + 0x0000, // UInt16 rtcIntStatus; // $B0E: RTC Interrupt Status Register + 0x0000, // UInt16 rtcIntEnable; // $B10: RTC Interrupt Enable Register + 0x003F, // UInt16 stopWatch; // $B12: Stopwatch Minutes + { 0 }, // UInt8 ___filler2002[0xB1A-0xB14]; + 0x0000, // UInt16 rtcDay; // $B1A: RTC Day + 0x0000, // UInt16 rtcDayAlarm; // $B1C: RTC Day Alarm + + { 0 }, // UInt8 ___filler41[0xC00-0xB1E]; + + 0x0000, // UInt16 dramConfig; // $C00: DRAM Memory Config Register + 0x003C, // UInt16 dramControl; // $C02: DRAM Control Register + 0x0000, // UInt16 sdramControl; // $C04: SDRAM Control Register + 0x0000, // UInt16 sdramPwDn; // $C06: SDRAM Power Down Register + + { 0 }, // UInt8 ___filler42[0xD00-0xC08]; + + 0x00000000, // UInt32 emuAddrCompare; // $D00: Emulation Address Compare Register + 0x00000000, // UInt32 emuAddrMask; // $D04: Emulation Address Mask Register + 0x0000, // UInt16 emuControlCompare; // $D08: Emulation Control Compare Register + 0x0000, // UInt16 emuControlMask; // $D0A: Emulation Control Mask Register + 0x0000, // UInt16 emuControl; // $DOC: Emulation Control Register + 0x0000 // UInt16 emuStatus; // $D0E: Emulation Status Register +}; + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::EmRegsVZ +// --------------------------------------------------------------------------- + +EmRegsVZ::EmRegsVZ (void) : + EmRegs (), + f68VZ328Regs (), + fHotSyncButtonDown (0), + fKeyBits (0), + fLastTmr1Status (0), + fLastTmr2Status (0), + fPortDEdge (0), + fPortDDataCount (0), + fHour (0), + fMin (0), + fSec (0), + fTick (0), + fCycle (0) +{ + fUART[0] = NULL; + fUART[1] = NULL; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::~EmRegsVZ +// --------------------------------------------------------------------------- + +EmRegsVZ::~EmRegsVZ (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::Initialize +// --------------------------------------------------------------------------- + +void EmRegsVZ::Initialize (void) +{ + EmRegs::Initialize (); + + fUART[0] = new EmUARTDragonball (EmUARTDragonball::kUART_DragonballVZ, 0); + fUART[1] = new EmUARTDragonball (EmUARTDragonball::kUART_DragonballVZ, 1); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::Reset +// --------------------------------------------------------------------------- + +void EmRegsVZ::Reset (Bool hardwareReset) +{ + EmRegs::Reset (hardwareReset); + if (hardwareReset) + { + + f68VZ328Regs = kInitial68VZ328RegisterValues; + + // Byteswap all the words in the DragonballVZ registers (if necessary). + + Canonical (f68VZ328Regs); + ByteswapWords (&f68VZ328Regs, sizeof(f68VZ328Regs)); + + fKeyBits = 0; + fLastTmr1Status = 0; + fLastTmr2Status = 0; + fPortDEdge = 0; + fPortDDataCount = 0; + + // React to the new data in the UART registers. + + Bool sendTxData = false; + EmRegsVZ::UARTStateChanged (sendTxData, 0); + EmRegsVZ::UARTStateChanged (sendTxData, 1); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::Save +// --------------------------------------------------------------------------- + +void EmRegsVZ::Save (SessionFile& f) +{ + EmRegs::Save (f); + + StWordSwapper swapper (&f68VZ328Regs, sizeof(f68VZ328Regs)); + f.WriteHwrDBallVZType (f68VZ328Regs); + f.FixBug (SessionFile::kBugByteswappedStructs); + + const long kCurrentVersion = 3; + + Chunk chunk; + EmStreamChunk s (chunk); + + s << kCurrentVersion; + + s << fHotSyncButtonDown; + s << fKeyBits; + s << fLastTmr1Status; + s << fLastTmr2Status; + s << fPortDEdge; + + + // Added in version 2. + + s << fHour; + s << fMin; + s << fSec; + s << fTick; + s << fCycle; + + // Added in version 3. + + s << fPortDDataCount; + + f.WriteDBallVZState (chunk); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::Load +// --------------------------------------------------------------------------- + +void EmRegsVZ::Load (SessionFile& f) +{ + EmRegs::Load (f); + + if (f.ReadHwrDBallVZType (f68VZ328Regs)) + { + // The Windows version of Poser 2.1d29 and earlier did not write + // out structs in the correct format. The fields of the struct + // were written out in Little-Endian format, not Big-Endian. To + // address this problem, the bug has been fixed, and a new field + // is added to the file format indicating that the bug has been + // fixed. With the new field (the "bug bit"), Poser can identify + // old files from new files and read them in accordingly. + // + // With the bug fixed, the .psf files should now be interchangeable + // across platforms (modulo other bugs...). + + if (!f.IncludesBugFix (SessionFile::kBugByteswappedStructs)) + { + Canonical (f68VZ328Regs); + } + ByteswapWords (&f68VZ328Regs, sizeof(f68VZ328Regs)); + + // React to the new data in the UART registers. + + Bool sendTxData = false; + EmRegsVZ::UARTStateChanged (sendTxData, 0); + EmRegsVZ::UARTStateChanged (sendTxData, 1); + + // Reset gMemAccessFlags.fProtect_SRAMSet + + gMemAccessFlags.fProtect_SRAMSet = (READ_REGISTER (csDSelect) & 0x2000) != 0; + } + else + { + f.SetCanReload (false); + } + + Chunk chunk; + if (f.ReadDBallVZState (chunk)) + { + long version; + EmStreamChunk s (chunk); + + s >> version; + + if (version >= 1) + { + s >> fHotSyncButtonDown; + s >> fKeyBits; + s >> fLastTmr1Status; + s >> fLastTmr2Status; + s >> fPortDEdge; + } + + if (version >= 2) + { + s >> fHour; + s >> fMin; + s >> fSec; + s >> fTick; + s >> fCycle; + } + + if (version >= 3) + { + s >> fPortDDataCount; + } + } + else + { + f.SetCanReload (false); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::Dispose +// --------------------------------------------------------------------------- + +void EmRegsVZ::Dispose (void) +{ + delete fUART[0]; fUART[0] = NULL; + delete fUART[1]; fUART[1] = NULL; + + EmRegs::Dispose (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegsVZ::SetSubBankHandlers (void) +{ + // Install base handlers. + + EmRegs::SetSubBankHandlers (); + + // Now add standard/specialized handers for the defined registers. + + INSTALL_HANDLER (StdRead, StdWrite, scr); + + INSTALL_HANDLER (StdRead, StdWrite, pcr); + INSTALL_HANDLER (StdRead, NullWrite, chipID); + INSTALL_HANDLER (StdRead, NullWrite, maskID); + INSTALL_HANDLER (StdRead, NullWrite, swID); + INSTALL_HANDLER (StdRead, StdWrite, ioDriveControl); + + INSTALL_HANDLER (StdRead, StdWrite, csAGroupBase); + INSTALL_HANDLER (StdRead, StdWrite, csBGroupBase); + INSTALL_HANDLER (StdRead, StdWrite, csCGroupBase); + INSTALL_HANDLER (StdRead, StdWrite, csDGroupBase); + + INSTALL_HANDLER (StdRead, StdWrite, csUGroupBase); + + INSTALL_HANDLER (StdRead, csControl1Write, csControl1); + INSTALL_HANDLER (StdRead, StdWrite, csControl2); + INSTALL_HANDLER (StdRead, StdWrite, csControl3); + + INSTALL_HANDLER (StdRead, csASelectWrite, csASelect); + INSTALL_HANDLER (StdRead, StdWrite, csBSelect); + INSTALL_HANDLER (StdRead, StdWrite, csCSelect); + INSTALL_HANDLER (StdRead, csDSelectWrite, csDSelect); + + INSTALL_HANDLER (StdRead, StdWrite, emuCS); + + INSTALL_HANDLER (StdRead, StdWrite, pllControl); + INSTALL_HANDLER (pllFreqSelRead, StdWrite, pllFreqSel); + INSTALL_HANDLER (StdRead, StdWrite, pwrControl); + + INSTALL_HANDLER (StdRead, StdWrite, intVector); + INSTALL_HANDLER (StdRead, StdWrite, intControl); + INSTALL_HANDLER (StdRead, intMaskHiWrite, intMaskHi); + INSTALL_HANDLER (StdRead, intMaskLoWrite, intMaskLo); + INSTALL_HANDLER (StdRead, intStatusHiWrite, intStatusHi); + INSTALL_HANDLER (StdRead, NullWrite, intStatusLo); + INSTALL_HANDLER (StdRead, NullWrite, intPendingHi); + INSTALL_HANDLER (StdRead, NullWrite, intPendingLo); + INSTALL_HANDLER (StdRead, StdWrite, intLevelControl); + + INSTALL_HANDLER (StdRead, StdWrite, portADir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portAData); + INSTALL_HANDLER (StdRead, StdWrite, portAPullupEn); + + INSTALL_HANDLER (StdRead, StdWrite, portBDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portBData); + INSTALL_HANDLER (StdRead, StdWrite, portBPullupEn); + INSTALL_HANDLER (StdRead, StdWrite, portBSelect); + + INSTALL_HANDLER (StdRead, StdWrite, portCDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portCData); + INSTALL_HANDLER (StdRead, StdWrite, portCPulldnEn); + INSTALL_HANDLER (StdRead, StdWrite, portCSelect); + + INSTALL_HANDLER (StdRead, StdWrite, portDDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portDData); + INSTALL_HANDLER (StdRead, StdWrite, portDPullupEn); + INSTALL_HANDLER (StdRead, StdWrite, portDSelect); + INSTALL_HANDLER (StdRead, StdWrite, portDPolarity); + INSTALL_HANDLER (StdRead, portDIntReqEnWrite, portDIntReqEn); + INSTALL_HANDLER (StdRead, StdWrite, portDKbdIntEn); + INSTALL_HANDLER (StdRead, StdWrite, portDIntEdge); + + INSTALL_HANDLER (StdRead, StdWrite, portEDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portEData); + INSTALL_HANDLER (StdRead, StdWrite, portEPullupEn); + INSTALL_HANDLER (StdRead, StdWrite, portESelect); + + INSTALL_HANDLER (StdRead, StdWrite, portFDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portFData); + INSTALL_HANDLER (StdRead, StdWrite, portFPullupdnEn); + INSTALL_HANDLER (StdRead, StdWrite, portFSelect); + + INSTALL_HANDLER (StdRead, StdWrite, portGDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portGData); + INSTALL_HANDLER (StdRead, StdWrite, portGPullupEn); + INSTALL_HANDLER (StdRead, StdWrite, portGSelect); + + INSTALL_HANDLER (StdRead, StdWrite, portJDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portJData); + INSTALL_HANDLER (StdRead, StdWrite, portJPullupEn); + INSTALL_HANDLER (StdRead, StdWrite, portJSelect); + + INSTALL_HANDLER (StdRead, StdWrite, portKDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portKData); + INSTALL_HANDLER (StdRead, StdWrite, portKPullupdnEn); + INSTALL_HANDLER (StdRead, StdWrite, portKSelect); + + INSTALL_HANDLER (StdRead, StdWrite, portMDir); + INSTALL_HANDLER (portXDataRead, portXDataWrite, portMData); + INSTALL_HANDLER (StdRead, StdWrite, portMPullupdnEn); + INSTALL_HANDLER (StdRead, StdWrite, portMSelect); + + INSTALL_HANDLER (StdRead, StdWrite, pwmControl); + INSTALL_HANDLER (StdRead, StdWrite, pwmSampleHi); + INSTALL_HANDLER (StdRead, StdWrite, pwmSampleLo); + INSTALL_HANDLER (StdRead, StdWrite, pwmPeriod); + INSTALL_HANDLER (StdRead, NullWrite, pwmCounter); + + INSTALL_HANDLER (StdRead, StdWrite, pwm2Control); + INSTALL_HANDLER (StdRead, StdWrite, pwm2Period); + INSTALL_HANDLER (StdRead, StdWrite, pwm2Width); + INSTALL_HANDLER (StdRead, NullWrite, pwm2Counter); + + INSTALL_HANDLER (StdRead, StdWrite, tmr1Control); + INSTALL_HANDLER (StdRead, StdWrite, tmr1Prescaler); + INSTALL_HANDLER (StdRead, StdWrite, tmr1Compare); + INSTALL_HANDLER (StdRead, StdWrite, tmr1Capture); + INSTALL_HANDLER (StdRead, NullWrite, tmr1Counter); + INSTALL_HANDLER (tmr1StatusRead, tmr1StatusWrite, tmr1Status); + + INSTALL_HANDLER (StdRead, StdWrite, tmr2Control); + INSTALL_HANDLER (StdRead, StdWrite, tmr2Prescaler); + INSTALL_HANDLER (StdRead, StdWrite, tmr2Compare); + INSTALL_HANDLER (StdRead, StdWrite, tmr2Capture); + INSTALL_HANDLER (StdRead, NullWrite, tmr2Counter); + INSTALL_HANDLER (tmr2StatusRead, tmr2StatusWrite, tmr2Status); + + INSTALL_HANDLER (StdRead, StdWrite, spiRxD); + INSTALL_HANDLER (StdRead, StdWrite, spiTxD); + INSTALL_HANDLER (StdRead, spiCont1Write, spiCont1); + INSTALL_HANDLER (StdRead, StdWrite, spiIntCS); + INSTALL_HANDLER (StdRead, StdWrite, spiTest); + INSTALL_HANDLER (StdRead, StdWrite, spiSpc); + + INSTALL_HANDLER (StdRead, StdWrite, spiMasterData); + INSTALL_HANDLER (StdRead, spiMasterControlWrite, spiMasterControl); + + INSTALL_HANDLER (uart1Read, uart1Write, uControl); + INSTALL_HANDLER (uart1Read, uart1Write, uBaud); + INSTALL_HANDLER (uart1Read, uart1Write, uReceive); + INSTALL_HANDLER (uart1Read, uart1Write, uTransmit); + INSTALL_HANDLER (uart1Read, uart1Write, uMisc); + INSTALL_HANDLER (uart1Read, uart1Write, uNonIntPresc); + + INSTALL_HANDLER (uart2Read, uart2Write, u2Control); + INSTALL_HANDLER (uart2Read, uart2Write, u2Baud); + INSTALL_HANDLER (uart2Read, uart2Write, u2Receive); + INSTALL_HANDLER (uart2Read, uart2Write, u2Transmit); + INSTALL_HANDLER (uart2Read, uart2Write, u2Misc); + INSTALL_HANDLER (uart2Read, uart2Write, u2NonIntPresc); + INSTALL_HANDLER (uart2Read, uart2Write, u2FIFOHMark); + + INSTALL_HANDLER (StdRead, lcdRegisterWrite, lcdStartAddr); + INSTALL_HANDLER (StdRead, lcdRegisterWrite, lcdPageWidth); + INSTALL_HANDLER (StdRead, lcdRegisterWrite, lcdScreenWidth); + INSTALL_HANDLER (StdRead, lcdRegisterWrite, lcdScreenHeight); + INSTALL_HANDLER (StdRead, StdWrite, lcdCursorXPos); + INSTALL_HANDLER (StdRead, StdWrite, lcdCursorYPos); + INSTALL_HANDLER (StdRead, StdWrite, lcdCursorWidthHeight); + INSTALL_HANDLER (StdRead, StdWrite, lcdBlinkControl); + INSTALL_HANDLER (StdRead, lcdRegisterWrite, lcdPanelControl); + INSTALL_HANDLER (StdRead, StdWrite, lcdPolarity); + INSTALL_HANDLER (StdRead, StdWrite, lcdACDRate); + INSTALL_HANDLER (StdRead, StdWrite, lcdPixelClock); + INSTALL_HANDLER (StdRead, StdWrite, lcdClockControl); + INSTALL_HANDLER (StdRead, StdWrite, lcdRefreshRateAdj); + INSTALL_HANDLER (StdRead, StdWrite, lcdPanningOffset); + INSTALL_HANDLER (StdRead, StdWrite, lcdFrameRate); + INSTALL_HANDLER (StdRead, StdWrite, lcdGrayPalette); + INSTALL_HANDLER (StdRead, StdWrite, lcdContrastControlPWM); + INSTALL_HANDLER (StdRead, StdWrite, lcdRefreshModeControl); + INSTALL_HANDLER (StdRead, StdWrite, lcdDMAControl); + + INSTALL_HANDLER (rtcHourMinSecRead, StdWrite, rtcHourMinSec); + INSTALL_HANDLER (StdRead, StdWrite, rtcAlarm); + INSTALL_HANDLER (StdRead, StdWrite, rtcWatchDog); + INSTALL_HANDLER (StdRead, rtcControlWrite, rtcControl); + INSTALL_HANDLER (StdRead, rtcIntStatusWrite, rtcIntStatus); + INSTALL_HANDLER (StdRead, rtcIntEnableWrite, rtcIntEnable); + INSTALL_HANDLER (StdRead, StdWrite, stopWatch); + INSTALL_HANDLER (StdRead, StdWrite, rtcDay); + INSTALL_HANDLER (StdRead, StdWrite, rtcDayAlarm); + + INSTALL_HANDLER (StdRead, StdWrite, dramConfig); + INSTALL_HANDLER (StdRead, StdWrite, dramControl); + INSTALL_HANDLER (StdRead, StdWrite, sdramControl); + INSTALL_HANDLER (StdRead, StdWrite, sdramPwDn); + + INSTALL_HANDLER (StdRead, StdWrite, emuAddrCompare); + INSTALL_HANDLER (StdRead, StdWrite, emuAddrMask); + INSTALL_HANDLER (StdRead, StdWrite, emuControlCompare); + INSTALL_HANDLER (StdRead, StdWrite, emuControlMask); + INSTALL_HANDLER (StdRead, StdWrite, emuControl); + INSTALL_HANDLER (StdRead, StdWrite, emuStatus); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmRegsVZ::GetRealAddress (emuptr address) +{ + uint8* loc = ((uint8*) &f68VZ328Regs) + (address - kMemoryStart); + + return loc; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetAddressStart +// --------------------------------------------------------------------------- + +emuptr EmRegsVZ::GetAddressStart (void) +{ + return kMemoryStart; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetAddressRange +// --------------------------------------------------------------------------- + +uint32 EmRegsVZ::GetAddressRange (void) +{ + return kMemorySize; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::Cycle +// --------------------------------------------------------------------------- +// Handles periodic events that need to occur when the processor cycles (like +// updating timer registers). This function is called in two places from +// Emulator::Execute. Interestingly, the loop runs 3% FASTER if this function +// is in its own separate function instead of being inline. + +void EmRegsVZ::Cycle (Bool sleeping) +{ +#if _DEBUG + #define increment 20 +#else + #define increment 4 +#endif + + // ===== Handle Timer 1 ===== + + // Determine whether timer is enabled. + + if ((READ_REGISTER (tmr1Control) & hwrVZ328TmrControlEnable) != 0) + { + // If so, increment the timer. + + WRITE_REGISTER (tmr1Counter, READ_REGISTER (tmr1Counter) + (sleeping ? 1 : increment)); + + // Determine whether the timer has reached the specified count. + + if (sleeping || READ_REGISTER (tmr1Counter) > READ_REGISTER (tmr1Compare)) + { + // Flag the occurrence of the successful comparison. + + WRITE_REGISTER (tmr1Status, READ_REGISTER (tmr1Status) | hwrVZ328TmrStatusCompare); + + // If the Free Run/Restart flag is not set, clear the counter. + + if ((READ_REGISTER (tmr1Control) & hwrVZ328TmrControlFreeRun) == 0) + { + WRITE_REGISTER (tmr1Counter, 0); + } + + // If the timer interrupt is enabled, post an interrupt. + + if ((READ_REGISTER (tmr1Control) & hwrVZ328TmrControlEnInterrupt) != 0) + { + WRITE_REGISTER (intPendingLo, READ_REGISTER (intPendingLo) | hwrVZ328IntLoTimer); + EmRegsVZ::UpdateInterrupts (); + } + } + } + + // ===== Handle Timer 2 ===== + // ===== (Same code, just the name have been changed) ===== + + // Determine whether timer is enabled. + +#if 1 + if ((READ_REGISTER (tmr2Control) & hwrVZ328TmrControlEnable) != 0) + { + // Divide by the prescale amount. We do this by decrementing + // a prescaler counter. Only when this counter reaches zero + // do we increment the timer counter. + + static int prescaleCounter; + + if ((prescaleCounter -= (sleeping ? (increment * 1024) : increment)) <= 0) + { + prescaleCounter = READ_REGISTER (tmr2Prescaler) * 1024; + + // If so, increment the timer. + + WRITE_REGISTER (tmr2Counter, READ_REGISTER (tmr2Counter) + (sleeping ? 1 : increment)); + + // Determine whether the timer has reached the specified count. + + if (sleeping || READ_REGISTER (tmr2Counter) > READ_REGISTER (tmr2Compare)) + { + // Flag the occurrence of the successful comparison. + + WRITE_REGISTER (tmr2Status, READ_REGISTER (tmr2Status) | hwrVZ328TmrStatusCompare); + + // If the Free Run/Restart flag is not set, clear the counter. + + if ((READ_REGISTER (tmr2Control) & hwrVZ328TmrControlFreeRun) == 0) + { + WRITE_REGISTER (tmr2Counter, 0); + } + + // If the timer interrupt is enabled, post an interrupt. + + if ((READ_REGISTER (tmr2Control) & hwrVZ328TmrControlEnInterrupt) != 0) + { + WRITE_REGISTER (intPendingLo, READ_REGISTER (intPendingLo) | hwrVZ328IntLoTimer2); + EmRegsVZ::UpdateInterrupts (); + } + } + } + } +#endif + + // ===== Handle time increment (used when running Gremlins) ===== + + if ((fCycle += increment) > READ_REGISTER (tmr1Compare)) + { + fCycle = 0; + + if (++fTick >= 100) + { + fTick = 0; + + if (++fSec >= 60) + { + fSec = 0; + + if (++fMin >= 60) + { + fMin = 0; + + if (++fHour >= 24) + { + fHour = 0; + } + } + } + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::CycleSlowly +// --------------------------------------------------------------------------- +// Handles periodic events that need to occur when the processor cycles (like +// updating timer registers). This function is called in two places from +// Emulator::Execute. Interestingly, the loop runs 3% FASTER if this function +// is in its own separate function instead of being inline. + +void EmRegsVZ::CycleSlowly (Bool sleeping) +{ + UNUSED_PARAM(sleeping) + + // See if a hard button is pressed. + + EmAssert (gSession); + if (gSession->HasButtonEvent ()) + { + EmButtonEvent event = gSession->GetButtonEvent (); + if (event.fButton == kElement_CradleButton) + { + EmRegsVZ::HotSyncEvent (event.fButtonIsDown); + } + else + { + EmRegsVZ::ButtonEvent (event.fButton, event.fButtonIsDown); + } + } + + // See if there's anything new ("Put the data on the bus") + + EmRegsVZ::UpdateUARTState (false, 0); + EmRegsVZ::UpdateUARTState (false, 1); + + // Check to see if the RTC alarm is ready to go off. First see + // if the RTC is enabled, and that the alarm event isn't already + // registered (the latter check is just an optimization). + + if ((READ_REGISTER (rtcIntEnable) & hwrVZ328RTCIntEnableAlarm) != 0 && + (READ_REGISTER (rtcIntStatus) & hwrVZ328RTCIntStatusAlarm) == 0) + { + uint32 rtcAlarm = READ_REGISTER (rtcAlarm); + + long almHour = (rtcAlarm & hwrVZ328RTCAlarmHoursMask) >> hwrVZ328RTCAlarmHoursOffset; + long almMin = (rtcAlarm & hwrVZ328RTCAlarmMinutesMask) >> hwrVZ328RTCAlarmMinutesOffset; + long almSec = (rtcAlarm & hwrVZ328RTCAlarmSecondsMask) >> hwrVZ328RTCAlarmSecondsOffset; + long almInSeconds = (almHour * 60 * 60) + (almMin * 60) + almSec; + + long nowHour; + long nowMin; + long nowSec; + ::GetHostTime (&nowHour, &nowMin, &nowSec); + long nowInSeconds = (nowHour * 60 * 60) + (nowMin * 60) + nowSec; + + if (almInSeconds <= nowInSeconds) + { + WRITE_REGISTER (rtcIntStatus, READ_REGISTER (rtcIntStatus) | hwrVZ328RTCIntStatusAlarm); + EmRegsVZ::UpdateRTCInterrupts (); + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::TurnSoundOff +// --------------------------------------------------------------------------- + +void EmRegsVZ::TurnSoundOff (void) +{ + uint16 pwmControl = READ_REGISTER (pwmControl); + WRITE_REGISTER (pwmControl, pwmControl & ~hwrVZ328PWMControlEnable); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::ResetTimer +// --------------------------------------------------------------------------- + +void EmRegsVZ::ResetTimer (void) +{ + WRITE_REGISTER (tmr1Counter, 0); + WRITE_REGISTER (tmr2Counter, 0); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::ResetRTC +// --------------------------------------------------------------------------- + +void EmRegsVZ::ResetRTC (void) +{ + fHour = 15; + fMin = 0; + fSec = 0; + fTick = 0; + fCycle = 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetInterruptLevel +// --------------------------------------------------------------------------- + +int32 EmRegsVZ::GetInterruptLevel (void) +{ + /* + From the DragonBall VZ manual, Chapter 9: + + * EMUIRQ or hardware breakpoint interrupt (level 7) + + * IRQ6 external interrupt (level 6) + * Timer unit 1 (level 6) + * Timer unit 2 (configurable from level 1 to 6) + * Pulse-width modulator unit 1 (level 6) + * Pulse-width modulator unit 2 (configurable from level 1 to 6) + + * IRQ5 external interrupt-pen (level 5) + + * Serial peripheral interface unit 1 (configurable from level 1 to 6) + * Serial peripheral interface unit 2 (level 4) + * UART unit 1 (level 4) + * UART unit 2 (configurable from level 1 to 6) + * Software watchdog timer interrupt (level 4) + * Real-time clock (level 4) + * Real-time interrupt (level 4) + * Keyboard interrupt (level 4) + * General-purpose interrupt INT[3:0] (level 4)-these pins can be + used as keyboard interrupts + + * IRQ3 external interrupt (level 3) + * IRQ2 external interrupt (level 2) + * IRQ1 external interrupt (level 1) + */ + + static int8 intLevel[32] = + { + 4, // 0x00 - hwrVZ328IntLoSPIM + 6, // 0x01 - hwrVZ328IntLoTimer + 4, // 0x02 - hwrVZ328IntLoUART + 4, // 0x03 - hwrVZ328IntLoWDT + 4, // 0x04 - hwrVZ328IntLoRTC + 0, // 0x05 - hwrVZ328IntLoTimer2 (configurable - 3 by default, reprogrammed to level 6) + 4, // 0x06 - hwrVZ328IntLoKbd + 6, // 0x07 - hwrVZ328IntLoPWM + + 4, // 0x08 - hwrVZ328IntLoInt0 + 4, // 0x09 - hwrVZ328IntLoInt1 + 4, // 0x0A - hwrVZ328IntLoInt2 + 4, // 0x0B - hwrVZ328IntLoInt3 + 0, // 0x0C - hwrVZ328IntLoUART2 (configurable - 5 by default, reprogrammed to level 4) + 0, // 0x0D - PWM2 (configurable - 3 by default) + -2, // 0x0E - <Unused> + -2, // 0x0F - <Unused> + + 1, // 0x10 - hwrVZ328IntHiIRQ1 + 2, // 0x11 - hwrVZ328IntHiIRQ2 + 3, // 0x12 - hwrVZ328IntHiIRQ3 + 6, // 0x13 - hwrVZ328IntHiIRQ6 + 5, // 0x14 - hwrVZ328IntHiPen + 0, // 0x15 - SPI1 (configurable - 6 by default) + 4, // 0x16 - hwrVZ328IntHiSampleTimer + 7, // 0x17 - hwrVZ328IntHiEMU + + -2, // 0x18 - <Unused> + -2, // 0x19 - <Unused> + -2, // 0x1A - <Unused> + -2, // 0x1B - <Unused> + -2, // 0x1C - <Unused> + -2, // 0x1D - <Unused> + -2, // 0x1E - <Unused> + -2 // 0x1F - <Unused> + }; + + // Load in the configurable interrupt levels. + + uint16 intLevelControl = READ_REGISTER (intLevelControl); + + intLevel[0x15] = (intLevelControl >> 12) & 0x000F; + intLevel[0x0C] = (intLevelControl >> 8) & 0x000F; + intLevel[0x0D] = (intLevelControl >> 4) & 0x000F; + intLevel[0x05] = (intLevelControl >> 0) & 0x000F; + + // !!! HACK: Skywalker sets the interrupt level to zero in order + // to clear it out before setting it to six. Zero is not allowed, + // so mask the problem by replacing it with six. + + if (intLevel[0x05] == 0) + intLevel[0x05] = 6; + +#ifndef NDEBUG + for (int ii = 0; ii < 32; ++ii) + { + EmAssert (intLevel[ii] != 0); + EmAssert (intLevel[ii] != 7 || ii == 0x17); + } +#endif + + // Find the highest interrupt level. + + int8 result = -1; + int index = 0; + + uint16 intStatusHi = READ_REGISTER (intStatusHi); + uint16 intStatusLo = READ_REGISTER (intStatusLo); + uint32 intStatus = (((uint32) intStatusHi) << 16) | intStatusLo; + + while (intStatus) + { + if (intStatus & 1) + { + // Make sure no undefined bits are set. + EmAssert (intLevel[index] >= 0); + + if (result < intLevel[index]) + { + result = intLevel[index]; + } + } + + intStatus >>= 1; + index++; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetInterruptBase +// --------------------------------------------------------------------------- + +int32 EmRegsVZ::GetInterruptBase (void) +{ + return READ_REGISTER (intVector) & 0xF8; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetLCDHasFrame +// --------------------------------------------------------------------------- + +Bool EmRegsVZ::GetLCDHasFrame (void) +{ + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetLCDBeginEnd +// --------------------------------------------------------------------------- + +void EmRegsVZ::GetLCDBeginEnd (emuptr& begin, emuptr& end) +{ + emuptr baseAddr = READ_REGISTER (lcdStartAddr); + int rowBytes = READ_REGISTER (lcdPageWidth) * 2; + int height = READ_REGISTER (lcdScreenHeight) + 1; + + begin = baseAddr; + end = baseAddr + rowBytes * height; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetLCDScanlines +// --------------------------------------------------------------------------- + +void EmRegsVZ::GetLCDScanlines (EmScreenUpdateInfo& info) +{ + // Get the screen metrics. + + int32 bpp = 1 << (READ_REGISTER (lcdPanelControl) & 0x03); + int32 width = READ_REGISTER (lcdScreenWidth); + int32 height = READ_REGISTER (lcdScreenHeight) + 1; + int32 rowBytes = READ_REGISTER (lcdPageWidth) * 2; + emuptr baseAddr = READ_REGISTER (lcdStartAddr); + + info.fLeftMargin = READ_REGISTER (lcdPanningOffset) & 0x0F; + + EmPixMapFormat format = bpp == 1 ? kPixMapFormat1 : + bpp == 2 ? kPixMapFormat2 : + bpp == 4 ? kPixMapFormat4 : + kPixMapFormat8; + + RGBList colorTable; + this->PrvGetPalette (colorTable); + + // Set format, size, and color table of EmPixMap. + + info.fImage.SetSize (EmPoint (width, height)); + info.fImage.SetFormat (format); + info.fImage.SetRowBytes (rowBytes); + info.fImage.SetColorTable (colorTable); + + // Determine first and last scanlines to fetch, and fetch them. + + info.fFirstLine = (info.fScreenLow - baseAddr) / rowBytes; + info.fLastLine = (info.fScreenHigh - baseAddr - 1) / rowBytes + 1; + + long firstLineOffset = info.fFirstLine * rowBytes; + long lastLineOffset = info.fLastLine * rowBytes; + + EmMem_memcpy ( + (void*) ((uint8*) info.fImage.GetBits () + firstLineOffset), + baseAddr + firstLineOffset, + lastLineOffset - firstLineOffset); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetDynamicHeapSize +// --------------------------------------------------------------------------- + +int32 EmRegsVZ::GetDynamicHeapSize (void) +{ + int32 result = 0; + + uint16 csControl = READ_REGISTER (csControl1); + uint16 csDSelect = READ_REGISTER (csDSelect); + + uint16 csDUPSIZ = (csDSelect & UPSIZMask) >> UPSIZShift; + uint16 csDSIZ = (csDSelect & SIZMask) >> SIZShift; + + if ((csControl & EUPENMask) != 0) + { + // Unprotected size = Chip-select Size/2^(7-upsize) + + // Determine upsize. + + // Merge in the extended bit. UPSIZ contains [1:0]. The bit + // in DUPS2 extends this to [2:0]. + + csDUPSIZ |= ((csControl & DUPS2Mask) >> DUPS2Shift) << 2; + + // Determine Chip-select Size. + + long chip_select_size = (32 * 1024L) << csDSIZ; + + if ((csControl & DSIZ3Mask) != 0 && + (csDSelect & DRAMMask) != 0 && + csDSIZ <= 0x01) + { + chip_select_size = (8 * 1024L * 1024L) << csDSIZ; + } + + result = chip_select_size / (1 << (7 - csDUPSIZ)); + } + else + { + result = (32 * 1024L) << csDUPSIZ; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetROMSize +// --------------------------------------------------------------------------- + +int32 EmRegsVZ::GetROMSize (void) +{ + /* + SIZ Chip-Select Size + + This field determines the memory range of the chip-select. For CSA + and CSB, chip-select size is between 128K and 16M. For CSC and CSD, + chip-select size is between 32K and 4M. + + 000 = 128K (32K for CSC and CSD). + 001 = 256K (64K for CSC and CSD). + 010 = 512K (128K for CSC and CSD). + 011 = 1M (256K for CSC and CSD). + 100 = 2M (512K for CSC and CSD). + 101 = 4M (1M for CSC and CSD). + 110 = 8M (2M for CSC and CSD). + 111 = 16M (4M for CSC and CSD). + */ + + uint16 csASelect = READ_REGISTER (csASelect); + uint32 result = (128 * 1024L) << ((csASelect & SIZMask) >> SIZShift); + + if ((csASelect & ENMask) == 0) + { + result = 16 * 1024L * 1024L; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetROMBaseAddress +// --------------------------------------------------------------------------- + +uint32 EmRegsVZ::GetROMBaseAddress (void) +{ + /* + csAGroupBase: Chip-select Group Base Address register + + The csAGroupBase register stores the base address (bits 14-28 of + the address) in the top 15 bits. The low bit is always zero. + Shifting this value by 13 gives the ROM base address. + + E.g: If the base address is 0x10C00000, then csAGroupBase will + contain 0x10C00000 >> 13 (base 10) = 0x8600. + + If the enable bit of the CSA register is low, the chip selects + have not yet been set up. In this case, return an invalid value. + */ + + if (!this->ChipSelectsConfigured()) + { + return 0xFFFFFFFF; + } + + uint16 csAGroupBase = READ_REGISTER (csAGroupBase); + uint32 result = csAGroupBase << kBaseAddressShift; + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::ChipSelectsConfigured +// --------------------------------------------------------------------------- + +Bool EmRegsVZ::ChipSelectsConfigured (void) +{ + return READ_REGISTER (csASelect) & ENMask; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetSystemClockFrequency +// --------------------------------------------------------------------------- + +int32 EmRegsVZ::GetSystemClockFrequency (void) +{ + uint16 pllControl = READ_REGISTER (pllControl); + uint16 pllFreqSel = READ_REGISTER (pllFreqSel); + + // Convert the 32.768KHz clock (CLK32) into the PLLCLK frequency. + + uint16 PC = (pllFreqSel & 0x00FF); + uint16 QC = (pllFreqSel & 0x0F00) >> 8; + + uint32 result = 32768L * 2 * (14 * (PC + 1) + QC + 1); + + // Divide by the first prescaler, if needed. + + if ((pllControl & hwrVZ328PLLControlPreSc1Div2) != 0) + { + result /= 2; + } + + // Divide by the second prescaler, if needed. + + if ((pllControl & hwrVZ328PLLControlPreSc2Div2) != 0) + { + result /= 2; + } + + // Divide by the system clock scaler, if needed. + + switch (pllControl & 0x0F00) + { + case hwrVZ328PLLControlSysDMADiv2: + result /= 2; + break; + + case hwrVZ328PLLControlSysDMADiv4: + result /= 4; + break; + + case hwrVZ328PLLControlSysDMADiv8: + result /= 8; + break; + + case hwrVZ328PLLControlSysDMADiv16: + result /= 16; + break; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetCanStop +// --------------------------------------------------------------------------- + +Bool EmRegsVZ::GetCanStop (void) +{ + // Make sure Timer is enabled or the RTC interrupt is enabled. + + if ((READ_REGISTER (tmr1Control) & hwrVZ328TmrControlEnable) != 0) + return true; + + if ((READ_REGISTER (tmr2Control) & hwrVZ328TmrControlEnable) != 0) + return true; + + if ((READ_REGISTER (rtcIntEnable) & hwrVZ328RTCIntEnableAlarm) != 0) + return true; + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetAsleep +// --------------------------------------------------------------------------- + +Bool EmRegsVZ::GetAsleep (void) +{ + return ((READ_REGISTER (pllControl) & hwrVZ328PLLControlDisable) != 0); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetPortInputValue +// --------------------------------------------------------------------------- +// Return the GPIO values for the pins on the port. These values are used +// if the select pins are high. + +uint8 EmRegsVZ::GetPortInputValue (int port) +{ + uint8 result = 0; + + if (port == 'D') + { + result = this->GetPortInternalValue (port); + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetPortInternalValue +// --------------------------------------------------------------------------- +// Return the dedicated values for the pins on the port. These values are +// used if the select pins are low. + +uint8 EmRegsVZ::GetPortInternalValue (int port) +{ + uint8 result = 0; + + if (port == 'D') + { + // Get the INT bits that need to be set. + + result = this->GetKeyBits (); + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::PortDataChanged +// --------------------------------------------------------------------------- + +void EmRegsVZ::PortDataChanged (int port, uint8, uint8 newValue) +{ + if (port == 'D') + { + // Clear the interrupt bits that are having a 1 written to them. + // Only clear them if they're configured as edge-senstive. + + uint8 portDIntEdge = READ_REGISTER (portDIntEdge); + + PRINTF ("EmRegsVZ::PortDataChanged (D): fPortDEdge = 0x%02lX", (uint32) (uint8) fPortDEdge); + PRINTF ("EmRegsVZ::PortDataChanged (D): portDIntEdge = 0x%02lX", (uint32) (uint8) portDIntEdge); + PRINTF ("EmRegsVZ::PortDataChanged (D): newValue = 0x%02lX", (uint32) (uint8) newValue); + + fPortDEdge &= ~(newValue & portDIntEdge); + + PRINTF ("EmRegsVZ::PortDataChanged (D): fPortDEdge = 0x%02lX", (uint32) (uint8) fPortDEdge); + + // Set the new interrupt state. + + EmRegsVZ::UpdatePortDInterrupts (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::pllFreqSelRead +// --------------------------------------------------------------------------- + +uint32 EmRegsVZ::pllFreqSelRead (emuptr address, int size) +{ + // Simulate the rising and falling of the CLK32 signal so that functions + // like HwrPreRAMInit, HwrShutDownPLL, PrvSetPLL, and PrvShutDownPLL + // won't hang. + + uint16 pllFreqSel = READ_REGISTER (pllFreqSel) ^ 0x8000; + WRITE_REGISTER (pllFreqSel, pllFreqSel); + + // Finish up by doing a standard read. + + return EmRegsVZ::StdRead (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::portXDataRead +// --------------------------------------------------------------------------- + +uint32 EmRegsVZ::portXDataRead (emuptr address, int) +{ + // The value read can come from three different places: + // + // - the value what was written to the data register + // - any dedicated inputs + // - any GPIO inputs + // + // The value returned depends on the settings of the SEL and DIR + // registers. So let's get those settings, the values from the three + // input sources, and build up a return value based on those. + + int port = GetPort (address); + + uint8 sel = StdRead (address + 2, 1); + uint8 dir = StdRead (address - 1, 1); + uint8 output = StdRead (address + 0, 1); + uint8 input = EmHAL::GetPortInputValue (port); + uint8 intFn = EmHAL::GetPortInternalValue (port); + + if (port == 'D') + { + sel |= 0x0F; // No "select" bit in low nybble, so set for IO values. + + // The system will poll portD 18 times in KeyBootKeys to see + // if any keys are down. Wait at least that long before + // letting up any boot keys maintained by the session. When we + // do call ReleaseBootKeys, set our counter to -1 as a flag not + // to call it any more. + + if (fPortDDataCount != 0xFFFFFFFF && ++fPortDDataCount >= 18 * 2) + { + fPortDDataCount = 0xFFFFFFFF; + gSession->ReleaseBootKeys (); + } + } + + // Use the internal chip function bits if the "sel" bits are zero. + + intFn &= ~sel; + + // Otherwise, use the I/O bits. + + output &= sel & dir; // Use the output bits if the "dir" is one. + input &= sel & ~dir; // Use the input bits if the "dir" is zero. + + // Assert that there are no overlaps. + + EmAssert ((output & input) == 0); + EmAssert ((output & intFn) == 0); + EmAssert ((input & intFn) == 0); + + // Mush everything together. + + uint8 result = output | input | intFn; + + // If this is port D, flip the bits if the POLARITY register says to. + // (!!! Does this inversion apply only to input bits? That is, the + // bits where the "dir" register has 0 bits?) + + if (0 && port == 'D') + { + uint8 polarity = READ_REGISTER (portDPolarity); + PRINTF ("EmRegsVZ::portXDataRead: polarity = 0x%02lX", (uint32) polarity); + result ^= polarity; + } + + PRINTF ("EmRegsVZ::port%cDataRead: sel dir output input intFn result", (char) port); + PRINTF ("EmRegsVZ::port%cDataRead: 0x%02lX 0x%02lX 0x%02lX 0x%02lX 0x%02lX 0x%02lX", + (char) port, (uint32) sel, (uint32) dir, (uint32) output, (uint32) input, (uint32) intFn, (uint32) result); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::tmr1StatusRead +// --------------------------------------------------------------------------- + +uint32 EmRegsVZ::tmr1StatusRead (emuptr address, int size) +{ + uint16 tmr1Counter = READ_REGISTER (tmr1Counter) + 16; + uint16 tmr1Compare = READ_REGISTER (tmr1Compare); + uint16 tmr1Control = READ_REGISTER (tmr1Control); + + // Increment the timer. + + WRITE_REGISTER (tmr1Counter, tmr1Counter); + + // If the timer has passed the specified value... + + if ((tmr1Counter - tmr1Compare) < 16) + { + // Set the flag saying the timer timed out. + + uint16 tmr1Status = READ_REGISTER (tmr1Status) | hwrVZ328TmrStatusCompare; + WRITE_REGISTER (tmr1Status, tmr1Status); + + // If it's not a free-running timer, reset it to zero. + + if ((tmr1Control & hwrVZ328TmrControlFreeRun) == 0) + { + WRITE_REGISTER (tmr1Counter, 0); + } + } + + // Remember this guy for later (see EmRegsVZ::tmr1StatusWrite()) + + fLastTmr1Status |= READ_REGISTER (tmr1Status); + + // Finish up by doing a standard read. + + return EmRegsVZ::StdRead (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::tmr2StatusRead +// --------------------------------------------------------------------------- + +uint32 EmRegsVZ::tmr2StatusRead (emuptr address, int size) +{ + uint16 tmr2Counter = READ_REGISTER (tmr2Counter) + 16; + uint16 tmr2Compare = READ_REGISTER (tmr2Compare); + uint16 tmr2Control = READ_REGISTER (tmr2Control); + + // Increment the timer. + + WRITE_REGISTER (tmr2Counter, tmr2Counter); + + // If the timer has passed the specified value... + + if ((tmr2Counter - tmr2Compare) < 16) + { + // Set the flag saying the timer timed out. + + uint16 tmr2Status = READ_REGISTER (tmr2Status) | hwrVZ328TmrStatusCompare; + WRITE_REGISTER (tmr2Status, tmr2Status); + + // If it's not a free-running timer, reset it to zero. + + if ((tmr2Control & hwrVZ328TmrControlFreeRun) == 0) + { + WRITE_REGISTER (tmr2Counter, 0); + } + } + + // Remember this guy for later (see EmRegsVZ::tmr2StatusWrite()) + + fLastTmr2Status |= READ_REGISTER (tmr2Status); + + // Finish up by doing a standard read. + + return EmRegsVZ::StdRead (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::uart1Read +// --------------------------------------------------------------------------- + +uint32 EmRegsVZ::uart1Read (emuptr address, int size) +{ + // If this is a full read, get the next byte from the FIFO. + + Bool refreshRxData = (address == addressof (uReceive)) && (size == 2); + + // See if there's anything new ("Put the data on the bus") + + EmRegsVZ::UpdateUARTState (refreshRxData, 0); + + // Finish up by doing a standard read. + + return EmRegsVZ::StdRead (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::uart2Read +// --------------------------------------------------------------------------- + +uint32 EmRegsVZ::uart2Read (emuptr address, int size) +{ + // If this is a full read, get the next byte from the FIFO. + + Bool refreshRxData = (address == addressof (u2Receive)) && (size == 2); + + // See if there's anything new ("Put the data on the bus") + + EmRegsVZ::UpdateUARTState (refreshRxData, 1); + + // Finish up by doing a standard read. + + return EmRegsVZ::StdRead (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::rtcHourMinSecRead +// --------------------------------------------------------------------------- + +uint32 EmRegsVZ::rtcHourMinSecRead (emuptr address, int size) +{ + // Get the desktop machine's time. + + long hour, min, sec; + + if (Hordes::IsOn ()) + { + hour = fHour; + min = fMin; + sec = fSec; + } + else + { + ::GetHostTime (&hour, &min, &sec); + } + + // Update the register. + + WRITE_REGISTER (rtcHourMinSec, (hour << hwrVZ328RTCHourMinSecHoursOffset) + | (min << hwrVZ328RTCHourMinSecMinutesOffset) + | (sec << hwrVZ328RTCHourMinSecSecondsOffset)); + + // Finish up by doing a standard read. + + return EmRegsVZ::StdRead (address, size); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::csControl1Write +// --------------------------------------------------------------------------- + +void EmRegsVZ::csControl1Write (emuptr address, int size, uint32 value) +{ + // Get the current value. + + uint16 csControl = READ_REGISTER (csControl1); + + // Do a standard update of the register. + + EmRegsVZ::StdWrite (address, size, value); + + // Check to see if the unprotected memory range changed. + + const uint16 bits = EUPENMask | DSIZ3Mask | DUPS2Mask; + + if ((csControl & bits) != (READ_REGISTER (csControl1) & bits)) + { + EmAssert (gSession); + + gSession->ScheduleResetBanks (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::csASelectWrite +// --------------------------------------------------------------------------- + +void EmRegsVZ::csASelectWrite (emuptr address, int size, uint32 value) +{ + // Get the current value. + + uint16 csASelect = READ_REGISTER (csASelect); + + // Do a standard update of the register. + + EmRegsVZ::StdWrite (address, size, value); + + // Check to see if the unprotected memory range changed. + + if ((csASelect & SIZMask) != (READ_REGISTER (csASelect) & SIZMask)) + { + EmAssert (gSession); + + gSession->ScheduleResetBanks (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::csDSelectWrite +// --------------------------------------------------------------------------- + +void EmRegsVZ::csDSelectWrite (emuptr address, int size, uint32 value) +{ + // Get the current value. + + uint16 csDSelect = READ_REGISTER (csDSelect); + + // Do a standard update of the register. + + EmRegsVZ::StdWrite (address, size, value); + + // Check its new state and update our ram-protect flag. + + gMemAccessFlags.fProtect_SRAMSet = (READ_REGISTER (csDSelect) & 0x2000) != 0; + + // Check to see if the unprotected memory range changed. + + if ((csDSelect & UPSIZMask) != (READ_REGISTER (csDSelect) & UPSIZMask)) + { + EmAssert (gSession); + + gSession->ScheduleResetBanks (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::intMaskHiWrite +// --------------------------------------------------------------------------- + +void EmRegsVZ::intMaskHiWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsVZ::StdWrite (address, size, value); + + // Respond to the new interrupt state. + + EmRegsVZ::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::intMaskLoWrite +// --------------------------------------------------------------------------- + +void EmRegsVZ::intMaskLoWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsVZ::StdWrite (address, size, value); + + // Respond to the new interrupt state. + + EmRegsVZ::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::intStatusHiWrite +// --------------------------------------------------------------------------- + +void EmRegsVZ::intStatusHiWrite (emuptr address, int size, uint32 value) +{ + // IRQ1, IRQ2, IRQ3, IRQ6 and IRQ7 are cleared by writing to their + // respective status bits. We handle those there. Since there are + // no interrupt status bits like this in intStatusLo, we don't need + // a handler for that register; we only handle intStatusHi. + + // Even though this is a 16-bit register as defined by the Palm headers, + // it's a 32-bit register according to DragonballVZ docs, and is in fact + // accessed that way in the kernal files (cf. HwrIRQ4Handler). In those + // cases, we're still only interested in access to the IRQ# bits, so we + // can turn 4-byte accesses into 2-byte accesses. + + if (size == 4) + value >>= 16; + + // Take into account the possibility of 1-byte accesses, too. If we're + // accessing the upper byte, just return. If we're accessing the lower + // byte, we can treat it as a 2-byte access. + + else if (size == 1 && address == addressof (intStatusHi)) + return; + + // Now we can treat the rest of this function as a word-write to intStatusHi. + + uint16 intPendingHi = READ_REGISTER (intPendingHi); + + // For each interrupt: + // If we're writing to that interrupt's status bit and its edge bit is set: + // - clear the interrupt's pending bit + // - respond to the new interrupt state. + + #undef CLEAR_PENDING_INTERRUPT + #define CLEAR_PENDING_INTERRUPT(edge, irq) \ + if ((READ_REGISTER (intControl) & edge) && (value & (irq))) \ + { \ + intPendingHi &= ~(irq); \ + } + + CLEAR_PENDING_INTERRUPT (hwrVZ328IntCtlEdge1, hwrVZ328IntHiIRQ1); + CLEAR_PENDING_INTERRUPT (hwrVZ328IntCtlEdge2, hwrVZ328IntHiIRQ2); + CLEAR_PENDING_INTERRUPT (hwrVZ328IntCtlEdge3, hwrVZ328IntHiIRQ3); + CLEAR_PENDING_INTERRUPT (hwrVZ328IntCtlEdge6, hwrVZ328IntHiIRQ6); + + // IRQ7 is not edge-programmable, so clear it if we're merely writing to it. + // !!! Double check this for VZ! + + if (value & hwrVZ328IntHiEMU) + { + intPendingHi &= ~(hwrVZ328IntHiEMU); + } + + // If we're emulating the user pressing the hotsync button, make sure the + // interrupt stays asserted. (!!! Should we use the same technique for + // other buttons, too? It doesn't seem to be needed right now, but doing + // that may more closely mirror the hardware.) + + if (fHotSyncButtonDown) + { + intPendingHi |= hwrVZ328IntHiIRQ1; + } + else + { + intPendingHi &= ~hwrVZ328IntHiIRQ1; + } + + // This makes the power on key work. If the signal is asserted, the + // unit will not transition between asleep and awake (cf. HwrSleep, HwrWake). + + intPendingHi &= ~hwrVZ328IntHiIRQ6; + + WRITE_REGISTER (intPendingHi, intPendingHi); + EmRegsVZ::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::portXDataWrite +// --------------------------------------------------------------------------- + +void EmRegsVZ::portXDataWrite (emuptr address, int size, uint32 value) +{ + // Get the old value before updating it. + + uint8 oldValue = StdRead (address, size); + + // Take a snapshot of the line driver states. + + Bool driverStates[kUARTEnd]; + EmHAL::GetLineDriverStates (driverStates); + + // Take a snapshot of the DTR pin. + + Bool dtrOn = EmHAL::GetDTR (1); + + // Now update the value with a standard write. + + StdWrite (address, size, value); + + // Let anyone know that it's changed. + + int port = GetPort (address); + PRINTF ("EmRegsVZ::port%cDataWrite: oldValue = 0x%02lX", (char) port, (uint32) (uint8) oldValue); + PRINTF ("EmRegsVZ::port%cDataWrite: newValue = 0x%02lX", (char) port, (uint32) (uint8) value); + + EmHAL::PortDataChanged (port, oldValue, value); + + // Respond to any changes in the line driver states. + + EmHAL::CompareLineDriverStates (driverStates); + + // Respond to any change in the DTR pin. + + if (EmHAL::GetDTR (1) != dtrOn) + { + EmHAL::DTRChanged (1); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::portDIntReqEnWrite +// --------------------------------------------------------------------------- + +void EmRegsVZ::portDIntReqEnWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsVZ::StdWrite (address, size, value); + + // Set the new interrupt state. + + EmRegsVZ::UpdatePortDInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::tmr1StatusWrite +// --------------------------------------------------------------------------- + +void EmRegsVZ::tmr1StatusWrite (emuptr address, int size, uint32 value) +{ + UNUSED_PARAM(address) + UNUSED_PARAM(size) + + EmAssert (size == 2); // This function's a hell of a lot easier to write if + // we assume only full-register access. + + // Get the current value. + + uint16 tmr1Status = READ_REGISTER (tmr1Status); + + // If the user had previously read the status bits while they + // were set, then it's OK for them to be clear now. Otherwise, + // we have to merge any set status bits back in. + + tmr1Status &= value | ~fLastTmr1Status; // fLastTmr1Status was set in EmRegsVZ::tmr1StatusRead() + + WRITE_REGISTER (tmr1Status, tmr1Status); + + fLastTmr1Status = 0; + if ((tmr1Status & hwrVZ328TmrStatusCompare) == 0) + { + uint16 intPendingLo = READ_REGISTER (intPendingLo) & ~hwrVZ328IntLoTimer; + WRITE_REGISTER (intPendingLo, intPendingLo); + + // Respond to the new interrupt state. + + EmRegsVZ::UpdateInterrupts (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::tmr2StatusWrite +// --------------------------------------------------------------------------- + +void EmRegsVZ::tmr2StatusWrite (emuptr address, int size, uint32 value) +{ + UNUSED_PARAM(address) + UNUSED_PARAM(size) + + EmAssert (size == 2); // This function's a hell of a lot easier to write if + // we assume only full-register access. + + // Get the current value. + + uint16 tmr2Status = READ_REGISTER (tmr2Status); + + // If the user had previously read the status bits while they + // were set, then it's OK for them to be clear now. Otherwise, + // we have to merge any set status bits back in. + + tmr2Status &= value | ~fLastTmr2Status; // fLastTmr2Status was set in EmRegsVZ::tmr2StatusRead() + + WRITE_REGISTER (tmr2Status, tmr2Status); + + fLastTmr2Status = 0; + if ((tmr2Status & hwrVZ328TmrStatusCompare) == 0) + { + uint16 intPendingLo = READ_REGISTER (intPendingLo) & ~hwrVZ328IntLoTimer2; + WRITE_REGISTER (intPendingLo, intPendingLo); + + // Respond to the new interrupt state. + + EmRegsVZ::UpdateInterrupts (); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::spiCont1Write +// --------------------------------------------------------------------------- + +void EmRegsVZ::spiCont1Write (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsVZ::StdWrite (address, size, value); + + // Get the current value. + + uint16 spiCont1 = READ_REGISTER (spiCont1); + + // Check to see if data exchange and enable are enabled. + + #define BIT_MASK (hwrVZ328SPIMControlExchange | hwrVZ328SPIMControlEnable) + if ((spiCont1 & BIT_MASK) == BIT_MASK) + { + // Clear the exchange bit. + + spiCont1 &= ~hwrVZ328SPIMControlExchange; + + WRITE_REGISTER (spiCont1, spiCont1); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::spiMasterControlWrite +// --------------------------------------------------------------------------- + +void EmRegsVZ::spiMasterControlWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsVZ::StdWrite (address, size, value); + + // Get the current value. + + uint16 spiMasterData = READ_REGISTER (spiMasterData); + uint16 spiMasterControl = READ_REGISTER (spiMasterControl); + + // Check to see if data exchange and enable are enabled. + + #define BIT_MASK (hwrVZ328SPIMControlExchange | hwrVZ328SPIMControlEnable) + if ((spiMasterControl & BIT_MASK) == BIT_MASK) + { + // If the SPI is hooked up to something, talk with it. + + EmSPISlave* spiSlave = this->GetSPISlave (); + if (spiSlave) + { + // Write out the old data, read in the new data. + + uint16 newData = spiSlave->DoExchange (spiMasterControl, spiMasterData); + + // Shift in the new data. + + uint16 numBits = (spiMasterControl & hwrVZ328SPIMControlBitsMask) + 1; + + uint16 oldBitsMask = ~0 << numBits; + uint16 newBitsMask = ~oldBitsMask; + + spiMasterData = /*((spiMasterData << numBits) & oldBitsMask) | */ + (newData & newBitsMask); + + WRITE_REGISTER (spiMasterData, spiMasterData); + } + + // Assert the interrupt and clear the exchange bit. + + spiMasterControl |= hwrVZ328SPIMControlIntStatus; + spiMasterControl &= ~hwrVZ328SPIMControlExchange; + + WRITE_REGISTER (spiMasterControl, spiMasterControl); + + // If hwrVZ328SPIMControlIntEnable is set, trigger an interrupt. + + if ((spiMasterControl & hwrVZ328SPIMControlIntEnable) != 0) + { + uint16 intPendingLo = READ_REGISTER (intPendingLo); + intPendingLo |= hwrVZ328IntLoSPIM; + WRITE_REGISTER (intPendingLo, intPendingLo); + this->UpdateInterrupts (); + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::uart1Write +// --------------------------------------------------------------------------- + +void EmRegsVZ::uart1Write(emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsVZ::StdWrite (address, size, value); + + // If this write included the TX_DATA field, signal that it needs to + // be transmitted. + + Bool sendTxData = + ((address == addressof (uTransmit)) && (size == 2)) || + ((address == addressof (uTransmit) + 1) && (size == 1)); + + // React to any changes. + + EmRegsVZ::UARTStateChanged (sendTxData, 0); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::uart2Write +// --------------------------------------------------------------------------- + +void EmRegsVZ::uart2Write(emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsVZ::StdWrite (address, size, value); + + // If this write included the TX_DATA field, signal that it needs to + // be transmitted. + + Bool sendTxData = + ((address == addressof (u2Transmit)) && (size == 2)) || + ((address == addressof (u2Transmit) + 1) && (size == 1)); + + // React to any changes. + + EmRegsVZ::UARTStateChanged (sendTxData, 1); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::lcdRegisterWrite +// --------------------------------------------------------------------------- + +void EmRegsVZ::lcdRegisterWrite (emuptr address, int size, uint32 value) +{ + // First, get the old value in case we need to see what changed. + + uint32 oldValue = EmRegsVZ::StdRead (address, size); + + // Do a standard update of the register. + + EmRegsVZ::StdWrite (address, size, value); + + // Note what changed. + + if (address == addressof (lcdScreenWidth)) + { + EmScreen::InvalidateAll (); + } + else if (address == addressof (lcdScreenHeight)) + { + EmScreen::InvalidateAll (); + } + else if (address == addressof (lcdPanelControl)) + { + // hwrVZ328LcdPanelControlGrayScale is incorrectly defined as 0x01, + // so use the hard-coded value of 0x03 here. + +// if (((value ^ oldValue) & hwrVZ328LcdPanelControlGrayScale) != 0) + if (((value ^ oldValue) & 0x03) != 0) + { + EmScreen::InvalidateAll (); + } + } + else if (address == addressof (lcdStartAddr)) + { + // Make sure the low-bit is always zero. + // Make sure bits 31-29 are always zero. + + uint32 lcdStartAddr = READ_REGISTER (lcdStartAddr) & 0x1FFFFFFE; + WRITE_REGISTER (lcdStartAddr, lcdStartAddr); + + EmScreen::InvalidateAll (); + } + else if (address == addressof (lcdPageWidth)) + { + if (value != oldValue) + { + EmScreen::InvalidateAll (); + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::rtcControlWrite +// --------------------------------------------------------------------------- + +void EmRegsVZ::rtcControlWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsVZ::StdWrite (address, size, value); + + // Respond to the new interrupt state. + + EmRegsVZ::UpdateRTCInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::rtcIntStatusWrite +// --------------------------------------------------------------------------- + +void EmRegsVZ::rtcIntStatusWrite (emuptr address, int size, uint32 value) +{ + // Status bits are cleared by writing ones to them. + + // If we're doing a byte-write to the upper byte, shift the byte + // so that we can treat the operation as a word write. If we're + // doing a byte-write to the lower byte, this extension will happen + // automatically. + + if (address == addressof (rtcIntStatus) && size == 1) + value <<= 8; + + // Get the current value. + + uint16 rtcIntStatus = READ_REGISTER (rtcIntStatus); + + // Clear the requested bits. + + rtcIntStatus &= ~value; + + // Update the register. + + WRITE_REGISTER (rtcIntStatus, rtcIntStatus); + + // Respond to the new interrupt state. + + EmRegsVZ::UpdateRTCInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::rtcIntEnableWrite +// --------------------------------------------------------------------------- + +void EmRegsVZ::rtcIntEnableWrite (emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. + + EmRegsVZ::StdWrite (address, size, value); + + // Respond to the new interrupt state. + + EmRegsVZ::UpdateRTCInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::ButtonEvent +// --------------------------------------------------------------------------- +// Handles a Palm device button event by updating the appropriate registers. + +void EmRegsVZ::ButtonEvent (SkinElementType button, Bool buttonIsDown) +{ + uint16 bitNumber = this->ButtonToBits (button); + + // Get the bits that should have been set with the previous set + // of pressed keys. We use this old value to update the port D interrupts. + + uint8 oldBits = this->GetKeyBits (); + + // Update the set of keys that are currently pressed. + + if (buttonIsDown) + { + fKeyBits |= bitNumber; // Remember the key bit + } + else + { + fKeyBits &= ~bitNumber; // Forget the key bit + } + + // Now get the new set of bits that should be set. + + uint8 newBits = this->GetKeyBits (); + + PRINTF ("EmRegsVZ::ButtonEvent: fKeyBits = 0x%04lX", (uint32) fKeyBits); + PRINTF ("EmRegsVZ::ButtonEvent: oldBits = 0x%02lX", (uint32) oldBits); + PRINTF ("EmRegsVZ::ButtonEvent: newBits = 0x%02lX", (uint32) newBits); + + // Set the interrupt bits for the bits that went from off to on. + // These get cleared when portDData is written to. + + fPortDEdge |= newBits & ~oldBits; + + PRINTF ("EmRegsVZ::ButtonEvent: fPortDEdge = 0x%02lX", (uint32) fPortDEdge); + + // Set the new interrupt state. + + EmRegsVZ::UpdatePortDInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::HotSyncEvent +// --------------------------------------------------------------------------- +// Handles a HotSync button event by updating the appropriate registers. + +void EmRegsVZ::HotSyncEvent (Bool buttonIsDown) +{ + // If the button changes state, set or clear the HotSync interrupt. + + uint16 intPendingHi = READ_REGISTER (intPendingHi); + + if (buttonIsDown) + { + intPendingHi |= hwrVZ328IntHiIRQ1; + fHotSyncButtonDown = true; + } + else + { + intPendingHi &= ~hwrVZ328IntHiIRQ1; + fHotSyncButtonDown = false; + } + + WRITE_REGISTER (intPendingHi, intPendingHi); + + EmRegsVZ::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetKeyBits +// --------------------------------------------------------------------------- + +uint8 EmRegsVZ::GetKeyBits (void) +{ + // "Keys" (that is, buttons) are read from the Port D Data register. + // There are 7 or 8 keys that can be pressed, but only 4 bits are + // available in the Port D Data register for reporting pressed keys. + // Therefore, the keys are organized into a matrix, one row or which + // can be requested and reported at a time. This function determines + // what row is being requested, and sets the appropriate Port D Data + // bits for the keys are are currently pressed. + + int numRows; + int numCols; + uint16 keyMap[16]; + Bool rows[4]; + + this->GetKeyInfo (&numRows, &numCols, keyMap, rows); + + uint8 keyData = 0; + + // Walk the rows, looking for one that is requested. + + for (int row = 0; row < numRows; ++row) + { + if (rows[row]) + { + // Walk the columns, looking for ones that have a pressed key. + + for (int col = 0; col < numCols; ++col) + { + // Get the key corresponding to this row and column. + // If we've recorded (in fKeyBits) that this key is + // pressed, then set its column bit. + + uint16 key = keyMap[row * numCols + col]; + if ((key & fKeyBits) != 0) + { + keyData |= (1 << col); + } + } + } + } + + return keyData; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::ButtonToBits +// --------------------------------------------------------------------------- + +uint16 EmRegsVZ::ButtonToBits (SkinElementType button) +{ + uint16 bitNumber = 0; + switch (button) + { + case kElement_None: break; + + case kElement_PowerButton: bitNumber = keyBitPower; break; + case kElement_UpButton: bitNumber = keyBitPageUp; break; + case kElement_DownButton: bitNumber = keyBitPageDown; break; + case kElement_App1Button: bitNumber = keyBitHard1; break; + case kElement_App2Button: bitNumber = keyBitHard2; break; + case kElement_App3Button: bitNumber = keyBitHard3; break; + case kElement_App4Button: bitNumber = keyBitHard4; break; + case kElement_CradleButton: bitNumber = keyBitCradle; break; + case kElement_Antenna: bitNumber = keyBitAntenna; break; + case kElement_ContrastButton: bitNumber = keyBitContrast; break; + + default: EmAssert (false); + } + + return bitNumber; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave* EmRegsVZ::GetSPISlave (void) +{ + return NULL; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::UpdateInterrupts +// --------------------------------------------------------------------------- +// Determines whether an interrupt has occurred by copying the Interrupt +// Pending Register to the Interrupt Status Register. + +void EmRegsVZ::UpdateInterrupts (void) +{ + // Copy the Interrupt Pending Register to the Interrupt Status + // Register, but ignore interrupts that are being masked. + + // Note: this function is not sensitive to the byte ordering of the registers, + // so their contents don't need to be accessed via READ_REGISTER or WRITE_REGISTER. + + f68VZ328Regs.intStatusHi = f68VZ328Regs.intPendingHi & ~f68VZ328Regs.intMaskHi; + f68VZ328Regs.intStatusLo = f68VZ328Regs.intPendingLo & ~f68VZ328Regs.intMaskLo; + + PRINTF ("EmRegsVZ::UpdateInterrupts: intMask = 0x%04lX %04lX", + (uint32) f68VZ328Regs.intMaskHi, (uint32) f68VZ328Regs.intMaskLo); + + PRINTF ("EmRegsVZ::UpdateInterrupts: intPending = 0x%04lX %04lX", + (uint32) f68VZ328Regs.intPendingHi, (uint32) f68VZ328Regs.intPendingLo); + + // If the Interrupt Status Register isn't clear, flag an interrupt. + + if (f68VZ328Regs.intStatusHi || f68VZ328Regs.intStatusLo) + { + regs.spcflags |= SPCFLAG_INT; + + PRINTF ("EmRegsVZ::UpdateInterrupts: intStatus = 0x%04lX %04lX", + (uint32) f68VZ328Regs.intStatusHi, (uint32) f68VZ328Regs.intStatusLo); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::UpdatePortDInterrupts +// --------------------------------------------------------------------------- +// Determine what interrupts need to be generated based on the current +// settings in portDData and fPortDEdge. + +void EmRegsVZ::UpdatePortDInterrupts (void) +{ + // Update INT0-INT3 of the Interrupt-Pending register (bits 8-11 of the low word). + + // First, get those bits and clear them out. + + uint16 intPendingLo = READ_REGISTER (intPendingLo) & ~hwrVZ328IntLoAllKeys; + + + // Initialize the variable to hold the new interrupt settings. + + uint8 newBits = 0; + + + // Get some other values we're going to need: + + uint8 portDDir = READ_REGISTER (portDDir); // Interrupt on inputs only (when pin is low) + uint8 portDData = EmHAL::GetPortInputValue ('D'); + uint8 portDPolarity = READ_REGISTER (portDPolarity); + uint8 portDIntReqEn = READ_REGISTER (portDIntReqEn); + uint8 portDKbdIntEn = READ_REGISTER (portDKbdIntEn); + uint8 portDIntEdge = READ_REGISTER (portDIntEdge); + + // We have a line-level interrupt if: + // + // - line-level interrupts are requested + // - the GPIO bit matches the polarity bit + + newBits |= ~portDIntEdge & portDData & portDPolarity; + newBits |= ~portDIntEdge & ~portDData & ~portDPolarity; + + + // We have an edge interrupt if: + // + // - edge interrupts are requested + // - an edge has been recorded + // + // Note that we should distinguish between rising and falling edges. + // For historical reasons, that's not done, and the Palm OS doesn't + // look for them, so it's OK for now. + // + // Edge interrupts on INT[3:0] should not wake up a sleeping device. + + uint16 pllControl = READ_REGISTER (pllControl); + +#if 0 + if ((pllControl & hwrVZ328PLLControlDisable) && !(gSession->GetDevice ().EdgeHack ())) + { + newBits |= portDIntEdge & fPortDEdge & portDPolarity & 0xF0; + newBits |= portDIntEdge & 0 & ~portDPolarity & 0xF0; + } + else +#endif + { + newBits |= portDIntEdge & fPortDEdge & portDPolarity; + newBits |= portDIntEdge & 0 & ~portDPolarity; + } + + + // Only have interrupts if they're enabled and the pin is configured for input. + + newBits &= portDIntReqEn & ~portDDir; + + PRINTF ("EmRegsVZ::UpdatePortDInterrupts: Dir Data Pol Req Edg PDE bits"); + PRINTF ("EmRegsVZ::UpdatePortDInterrupts: 0x%02lX 0x%02lX 0x%02lX 0x%02lX 0x%02lX 0x%02lX 0x%02lX", + (uint32) portDDir, (uint32) portDData, (uint32) portDPolarity, (uint32) portDIntReqEn, (uint32) portDIntEdge, + (uint32) fPortDEdge, (uint32) newBits); + + + // Determine if the KB interrupt needs to be asserted. It is if: + // + // A Port D Data bit is on. + // The bit is configured for input (?) + // The bit is configured to be OR'd into the interrupt. + + if (!gSession->GetDevice ().EdgeHack ()) + { + uint8 KB = portDData & ~portDDir & portDKbdIntEn; + + if (KB) + intPendingLo |= hwrVZ328IntLoKbd; + else + intPendingLo &= ~hwrVZ328IntLoKbd; + } + + + // Merge in the new values and write out the result. + + intPendingLo |= (((uint16) newBits) << hwrVZ328IntLoInt0Bit) & hwrVZ328IntLoAllKeys; + WRITE_REGISTER (intPendingLo, intPendingLo); + + + // Respond to the new interrupt state. + + EmRegsVZ::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::UpdateRTCInterrupts +// --------------------------------------------------------------------------- +// Determine whether to set or clear the RTC bit in the interrupt pending +// register based on the current RTC register values. + +void EmRegsVZ::UpdateRTCInterrupts (void) +{ + // See if the RTC is enabled. + + Bool rtcEnabled = (READ_REGISTER (rtcControl) & hwrVZ328RTCControlRTCEnable) != 0; + + // See if there are any RTC events that need to trigger an interrupt. + +#define BITS_TO_CHECK ( \ + hwrVZ328RTCIntEnableSec | \ + hwrVZ328RTCIntEnable24Hr | \ + hwrVZ328RTCIntEnableAlarm | \ + hwrVZ328RTCIntEnableMinute | \ + hwrVZ328RTCIntEnableStopWatch ) + + uint16 rtcIntStatus = READ_REGISTER (rtcIntStatus); + uint16 rtcIntEnable = READ_REGISTER (rtcIntEnable); + uint16 rtcIntPending = rtcIntStatus & rtcIntEnable & BITS_TO_CHECK; + + Bool havePendingEvents = rtcIntPending != 0; + + // If the RTC is enabled and there are pending events, set the interrupt. + // Otherwise, clear the interrupt. + + uint16 intPendingLo = READ_REGISTER (intPendingLo); + + if (rtcEnabled && havePendingEvents) + { + intPendingLo |= hwrVZ328IntLoRTC; // have events, so set interrupt + } + else + { + intPendingLo &= ~hwrVZ328IntLoRTC; // no events, so clear interrupt + } + + // Update the interrupt pending register. + + WRITE_REGISTER (intPendingLo, intPendingLo); + + // Respond to the new interrupt state. + + EmRegsVZ::UpdateInterrupts (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::UARTStateChanged +// --------------------------------------------------------------------------- + +void EmRegsVZ::UARTStateChanged (Bool sendTxData, int uartNum) +{ + EmUARTDragonball::State state (EmUARTDragonball::kUART_DragonballVZ); + + EmRegsVZ::MarshalUARTState (state, uartNum); + + fUART[uartNum]->StateChanged (state, sendTxData); + + EmRegsVZ::UnmarshalUARTState (state, uartNum); + + EmRegsVZ::UpdateUARTInterrupts (state, uartNum); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::UpdateUARTState +// --------------------------------------------------------------------------- + +void EmRegsVZ::UpdateUARTState (Bool refreshRxData, int uartNum) +{ + EmUARTDragonball::State state (EmUARTDragonball::kUART_DragonballVZ); + + EmRegsVZ::MarshalUARTState (state, uartNum); + + fUART[uartNum]->UpdateState (state, refreshRxData); + + EmRegsVZ::UnmarshalUARTState (state, uartNum); + + EmRegsVZ::UpdateUARTInterrupts (state, uartNum); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::UpdateUARTInterrupts +// --------------------------------------------------------------------------- + +void EmRegsVZ::UpdateUARTInterrupts (const EmUARTDragonball::State& state, int uartNum) +{ + // Generate the appropriate interrupts. + + uint16 whichBit = uartNum == 0 ? hwrVZ328IntLoUART : hwrVZ328IntLoUART2; + +#if 0 + LogAppendMsg ("UpdateUARTInterrupts for UART %d.", uartNum + 1); + + if (uartNum == 1) + { + LogAppendMsg ("RX_FIFO_FULL: %s RX_FIFO_HALF: %s DATA_READY: %s", + state.RX_FIFO_FULL ? "ON " : "off", + state.RX_FIFO_HALF ? "ON " : "off", + state.DATA_READY ? "ON " : "off"); + + LogAppendMsg ("RX_FULL_ENABLE: %s RX_HALF_ENABLE: %s RX_RDY_ENABLE: %s", + state.RX_FULL_ENABLE ? "ON " : "off", + state.RX_HALF_ENABLE ? "ON " : "off", + state.RX_RDY_ENABLE ? "ON " : "off"); + + LogAppendMsg ("TX_FIFO_EMPTY: %s TX_FIFO_HALF: %s TX_AVAIL: %s", + state.TX_FIFO_EMPTY ? "ON " : "off", + state.TX_FIFO_HALF ? "ON " : "off", + state.TX_AVAIL ? "ON " : "off"); + + LogAppendMsg ("TX_EMPTY_ENABLE: %s TX_HALF_ENABLE: %s TX_AVAIL_ENABLE: %s", + state.TX_EMPTY_ENABLE ? "ON " : "off", + state.TX_HALF_ENABLE ? "ON " : "off", + state.TX_AVAIL_ENABLE ? "ON " : "off"); + } +#endif + + if (state.RX_FULL_ENABLE && state.RX_FIFO_FULL || + state.RX_HALF_ENABLE && state.RX_FIFO_HALF || + state.RX_RDY_ENABLE && state.DATA_READY || + state.TX_EMPTY_ENABLE && state.TX_FIFO_EMPTY || + state.TX_HALF_ENABLE && state.TX_FIFO_HALF || + state.TX_AVAIL_ENABLE && state.TX_AVAIL) + { + // Set the UART interrupt. + + WRITE_REGISTER (intPendingLo, READ_REGISTER (intPendingLo) | whichBit); +#if 0 + if (uartNum == 1) + { + LogAppendMsg ("Setting UART %d interrupt.", uartNum + 1); + } +#endif + } + else + { + // Clear the UART interrupt. + + WRITE_REGISTER (intPendingLo, READ_REGISTER (intPendingLo) & ~whichBit); +#if 0 + if (uartNum == 1) + { + LogAppendMsg ("Clearing UART %d interrupt.", uartNum + 1); + } +#endif + } + + // Respond to the new interrupt state. + + EmRegsVZ::UpdateInterrupts (); + +#if 0 + if (uartNum == 1) + { + LogAppendMsg ("intPending = 0x%04lX %04lX", + (uint32) f68VZ328Regs.intPendingHi, + (uint32) f68VZ328Regs.intPendingLo); + + LogAppendMsg ("intMask = 0x%04lX %04lX", + (uint32) f68VZ328Regs.intMaskHi, + (uint32) f68VZ328Regs.intMaskLo); + + LogAppendMsg ("intStatus = 0x%04lX %04lX", + (uint32) f68VZ328Regs.intStatusHi, + (uint32) f68VZ328Regs.intStatusLo); + } +#endif +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::MarshalUARTState +// --------------------------------------------------------------------------- + +void EmRegsVZ::MarshalUARTState (EmUARTDragonball::State& state, int uartNum) +{ + uint16 uControl; + uint16 uBaud; + uint16 uReceive; + uint16 uTransmit; + uint16 uMisc; + uint16 uLevel; + + if (uartNum == 0) + { + uControl = READ_REGISTER (uControl); + uBaud = READ_REGISTER (uBaud); + uReceive = READ_REGISTER (uReceive); + uTransmit = READ_REGISTER (uTransmit); + uMisc = READ_REGISTER (uMisc); + uLevel = 0; + } + else + { + uControl = READ_REGISTER (u2Control); + uBaud = READ_REGISTER (u2Baud); + uReceive = READ_REGISTER (u2Receive); + uTransmit = READ_REGISTER (u2Transmit); + uMisc = READ_REGISTER (u2Misc); + uLevel = READ_REGISTER (u2FIFOHMark); + } + + state.UART_ENABLE = (uControl & hwrVZ328UControlUARTEnable) != 0; + state.RX_ENABLE = (uControl & hwrVZ328UControlRxEnable) != 0; + state.TX_ENABLE = (uControl & hwrVZ328UControlTxEnable) != 0; + state.RX_CLK_CONT = (uControl & hwrVZ328UControlRxClock1xSync) != 0; + state.PARITY_EN = (uControl & hwrVZ328UControlParityEn) != 0; + state.ODD_EVEN = (uControl & hwrVZ328UControlParityOdd) != 0; + state.STOP_BITS = (uControl & hwrVZ328UControlStopBits2) != 0; + state.CHAR8_7 = (uControl & hwrVZ328UControlDataBits8) != 0; +// state.GPIO_DELTA_ENABLE = (uControl & hwr328UControlGPIODeltaEn) != 0; // 68328 only + state.OLD_ENABLE = (uControl & hwrVZ328UControlOldDataEn) != 0; // 68VZ328 only + state.CTS_DELTA_ENABLE = (uControl & hwrVZ328UControlCTSDeltaEn) != 0; + state.RX_FULL_ENABLE = (uControl & hwrVZ328UControlRxFullEn) != 0; + state.RX_HALF_ENABLE = (uControl & hwrVZ328UControlRxHalfEn) != 0; + state.RX_RDY_ENABLE = (uControl & hwrVZ328UControlRxRdyEn) != 0; + state.TX_EMPTY_ENABLE = (uControl & hwrVZ328UControlTxEmptyEn) != 0; + state.TX_HALF_ENABLE = (uControl & hwrVZ328UControlTxHalfEn) != 0; + state.TX_AVAIL_ENABLE = (uControl & hwrVZ328UControlTxAvailEn) != 0; + + // Baud control register bits + // These are all values the user sets; we just look at them. + +// state.GPIO_DELTA = (uBaud & hwr328UBaudGPIODelta) != 0; // 68328 only +// state.GPIO = (uBaud & hwr328UBaudGPIOData) != 0; // 68328 only +// state.GPIO_DIR = (uBaud & hwr328UBaudGPIODirOut) != 0; // 68328 only +// state.GPIO_SRC = (uBaud & hwrVZ328UBaudGPIOSrcBaudGen) != 0; // 68328 only + state.UCLK_DIR = (uBaud & hwrVZ328UBaudUCLKDirOut) != 0; // 68VZ328 only + state.BAUD_SRC = (uBaud & hwrVZ328UBaudBaudSrcUCLK) != 0; + state.DIVIDE = (uBaud & hwrVZ328UBaudDivider) >> hwrVZ328UBaudDivideBitOffset; + state.PRESCALER = (uBaud & hwrVZ328UBaudPrescaler); + + // Receive register bits + // These are all input bits; we set them, not the user. + + state.RX_FIFO_FULL = (uReceive & hwrVZ328UReceiveFIFOFull) != 0; + state.RX_FIFO_HALF = (uReceive & hwrVZ328UReceiveFIFOHalf) != 0; + state.DATA_READY = (uReceive & hwrVZ328UReceiveDataRdy) != 0; + state.OLD_DATA = (uReceive & hwrVZ328UReceiveOldData) != 0; // 68VZ328 only + state.OVRUN = (uReceive & hwrVZ328UReceiveOverrunErr) != 0; + state.FRAME_ERROR = (uReceive & hwrVZ328UReceiveFrameErr) != 0; + state.BREAK = (uReceive & hwrVZ328UReceiveBreakErr) != 0; + state.PARITY_ERROR = (uReceive & hwrVZ328UReceiveParityErr) != 0; + state.RX_DATA = (uReceive & hwrVZ328UReceiveData); + + // Transmitter register bits + // We set everything except TX_DATA; the user sets that + // value and ONLY that value. + + state.TX_FIFO_EMPTY = (uTransmit & hwrVZ328UTransmitFIFOEmpty) != 0; + state.TX_FIFO_HALF = (uTransmit & hwrVZ328UTransmitFIFOHalf) != 0; + state.TX_AVAIL = (uTransmit & hwrVZ328UTransmitTxAvail) != 0; + state.SEND_BREAK = (uTransmit & hwrVZ328UTransmitSendBreak) != 0; + state.IGNORE_CTS = (uTransmit & hwrVZ328UTransmitIgnoreCTS) != 0; + state.BUSY = (uTransmit & hwrVZ328UTransmitBusy) != 0; // 68VZ328 only + state.CTS_STATUS = (uTransmit & hwrVZ328UTransmitCTSStatus) != 0; + state.CTS_DELTA = (uTransmit & hwrVZ328UTransmitCTSDelta) != 0; + state.TX_DATA = (uTransmit & hwrVZ328UTransmitData); + + // Misc register bits + // These are all values the user sets; we just look at them. + + state.BAUD_TEST = (uMisc & hwrVZ328UMiscBaudTest) != 0; // 68VZ328 only + state.CLK_SRC = (uMisc & hwrVZ328UMiscClkSrcUCLK) != 0; + state.FORCE_PERR = (uMisc & hwrVZ328UMiscForceParityErr) != 0; + state.LOOP = (uMisc & hwrVZ328UMiscLoopback) != 0; + state.BAUD_RESET = (uMisc & hwrVZ328UMiscBaudReset) != 0; // 68VZ328 only + state.IR_TEST = (uMisc & hwrVZ328UMiscIRTestEn) != 0; // 68VZ328 only + state.RTS_CONT = (uMisc & hwrVZ328UMiscRTSThruFIFO) != 0; + state.RTS = (uMisc & hwrVZ328UMiscRTSOut) != 0; + state.IRDA_ENABLE = (uMisc & hwrVZ328UMiscIRDAEn) != 0; + state.IRDA_LOOP = (uMisc & hwrVZ328UMiscLoopIRDA) != 0; + state.RX_POL = (uMisc & hwrVZ328UMiscRXPolarityInv) != 0; // 68VZ328 only + state.TX_POL = (uMisc & hwrVZ328UMiscTXPolarityInv) != 0; // 68VZ328 only + + // Level Marker Interrupt + + state.TXFIFO_LEVEL_MARKER = ((uLevel >> 8) & 0x0F); // 68VZ328 only + state.RXFIFO_LEVEL_MARKER = ((uLevel >> 0) & 0x0F); // 68VZ328 only +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::UnmarshalUARTState +// --------------------------------------------------------------------------- + +void EmRegsVZ::UnmarshalUARTState (const EmUARTDragonball::State& state, int uartNum) +{ + uint16 uControl = 0; + uint16 uBaud = 0; + uint16 uReceive = 0; + uint16 uTransmit = 0; + uint16 uMisc = 0; + uint16 uLevel = 0; + + if (state.UART_ENABLE) uControl |= hwrVZ328UControlUARTEnable; + if (state.RX_ENABLE) uControl |= hwrVZ328UControlRxEnable; + if (state.TX_ENABLE) uControl |= hwrVZ328UControlTxEnable; + if (state.RX_CLK_CONT) uControl |= hwrVZ328UControlRxClock1xSync; + if (state.PARITY_EN) uControl |= hwrVZ328UControlParityEn; + if (state.ODD_EVEN) uControl |= hwrVZ328UControlParityOdd; + if (state.STOP_BITS) uControl |= hwrVZ328UControlStopBits2; + if (state.CHAR8_7) uControl |= hwrVZ328UControlDataBits8; +// if (state.GPIO_DELTA_ENABLE)uControl |= hwr328UControlGPIODeltaEn; // 68328 only + if (state.OLD_ENABLE) uControl |= hwrVZ328UControlOldDataEn; // 68VZ328 only + if (state.CTS_DELTA_ENABLE) uControl |= hwrVZ328UControlCTSDeltaEn; + if (state.RX_FULL_ENABLE) uControl |= hwrVZ328UControlRxFullEn; + if (state.RX_HALF_ENABLE) uControl |= hwrVZ328UControlRxHalfEn; + if (state.RX_RDY_ENABLE) uControl |= hwrVZ328UControlRxRdyEn; + if (state.TX_EMPTY_ENABLE) uControl |= hwrVZ328UControlTxEmptyEn; + if (state.TX_HALF_ENABLE) uControl |= hwrVZ328UControlTxHalfEn; + if (state.TX_AVAIL_ENABLE) uControl |= hwrVZ328UControlTxAvailEn; + + // Baud control register bits + // These are all values the user sets; we just look at them. + +// if (state.GPIO_DELTA) uBaud |= hwr328UBaudGPIODelta; // 68328 only +// if (state.GPIO) uBaud |= hwr328UBaudGPIOData; // 68328 only +// if (state.GPIO_DIR) uBaud |= hwr328UBaudGPIODirOut; // 68328 only +// if (state.GPIO_SRC) uBaud |= hwr328UBaudGPIOSrcBaudGen; // 68328 only + if (state.UCLK_DIR) uBaud |= hwrVZ328UBaudUCLKDirOut; // 68VZ328 only + if (state.BAUD_SRC) uBaud |= hwrVZ328UBaudBaudSrcUCLK; + + uBaud |= (state.DIVIDE << hwrVZ328UBaudDivideBitOffset) & hwrVZ328UBaudDivider; + uBaud |= (state.PRESCALER) & hwrVZ328UBaudPrescaler; + + // Receive register bits + // These are all input bits; we set them, not the user. + + if (state.RX_FIFO_FULL) uReceive |= hwrVZ328UReceiveFIFOFull; + if (state.RX_FIFO_HALF) uReceive |= hwrVZ328UReceiveFIFOHalf; + if (state.DATA_READY) uReceive |= hwrVZ328UReceiveDataRdy; + if (state.OLD_DATA) uReceive |= hwrVZ328UReceiveOldData; // 68VZ328 only + if (state.OVRUN) uReceive |= hwrVZ328UReceiveOverrunErr; + if (state.FRAME_ERROR) uReceive |= hwrVZ328UReceiveFrameErr; + if (state.BREAK) uReceive |= hwrVZ328UReceiveBreakErr; + if (state.PARITY_ERROR) uReceive |= hwrVZ328UReceiveParityErr; + + uReceive |= (state.RX_DATA) & hwrVZ328UReceiveData; + + // Transmitter register bits + // We set everything except TX_DATA; the user sets that + // value and ONLY that value. + + if (state.TX_FIFO_EMPTY) uTransmit |= hwrVZ328UTransmitFIFOEmpty; + if (state.TX_FIFO_HALF) uTransmit |= hwrVZ328UTransmitFIFOHalf; + if (state.TX_AVAIL) uTransmit |= hwrVZ328UTransmitTxAvail; + if (state.SEND_BREAK) uTransmit |= hwrVZ328UTransmitSendBreak; + if (state.IGNORE_CTS) uTransmit |= hwrVZ328UTransmitIgnoreCTS; + if (state.BUSY) uTransmit |= hwrVZ328UTransmitBusy; // 68VZ328 only + if (state.CTS_STATUS) uTransmit |= hwrVZ328UTransmitCTSStatus; + if (state.CTS_DELTA) uTransmit |= hwrVZ328UTransmitCTSDelta; + + uTransmit |= (state.TX_DATA) & hwrVZ328UTransmitData; + + // Misc register bits + // These are all values the user sets; we just look at them. + + if (state.BAUD_TEST) uMisc |= hwrVZ328UMiscBaudTest; // 68VZ328 only + if (state.CLK_SRC) uMisc |= hwrVZ328UMiscClkSrcUCLK; + if (state.FORCE_PERR) uMisc |= hwrVZ328UMiscForceParityErr; + if (state.LOOP) uMisc |= hwrVZ328UMiscLoopback; + if (state.BAUD_RESET) uMisc |= hwrVZ328UMiscBaudReset; // 68VZ328 only + if (state.IR_TEST) uMisc |= hwrVZ328UMiscIRTestEn; // 68VZ328 only + if (state.RTS_CONT) uMisc |= hwrVZ328UMiscRTSThruFIFO; + if (state.RTS) uMisc |= hwrVZ328UMiscRTSOut; + if (state.IRDA_ENABLE) uMisc |= hwrVZ328UMiscIRDAEn; + if (state.IRDA_LOOP) uMisc |= hwrVZ328UMiscLoopIRDA; + if (state.RX_POL) uMisc |= hwrVZ328UMiscRXPolarityInv; // 68VZ328 only + if (state.TX_POL) uMisc |= hwrVZ328UMiscTXPolarityInv; // 68VZ328 only + + // Level Marker Interrupt + + uLevel |= (state.TXFIFO_LEVEL_MARKER) << 8; + uLevel |= (state.RXFIFO_LEVEL_MARKER) << 0; + + if (uartNum == 0) + { + WRITE_REGISTER (uControl, uControl); + WRITE_REGISTER (uBaud, uBaud); + WRITE_REGISTER (uReceive, uReceive); + WRITE_REGISTER (uTransmit, uTransmit); + WRITE_REGISTER (uMisc, uMisc); + } + else + { + WRITE_REGISTER (u2Control, uControl); + WRITE_REGISTER (u2Baud, uBaud); + WRITE_REGISTER (u2Receive, uReceive); + WRITE_REGISTER (u2Transmit, uTransmit); + WRITE_REGISTER (u2Misc, uMisc); + WRITE_REGISTER (u2FIFOHMark, uLevel); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::GetPort +// --------------------------------------------------------------------------- +// Given an address, return a value indicating what port it is associated with. + +int EmRegsVZ::GetPort (emuptr address) +{ + const long MASK = 0x00000FF8; + + switch (address & MASK) + { + case 0x0400: return 'A'; + case 0x0408: return 'B'; + case 0x0410: return 'C'; + case 0x0418: return 'D'; + case 0x0420: return 'E'; + case 0x0428: return 'F'; + case 0x0430: return 'G'; + case 0x0438: return 'J'; + case 0x0440: return 'K'; + case 0x0448: return 'M'; + } + + EmAssert (false); + return 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::PrvGetPalette +// --------------------------------------------------------------------------- + +void EmRegsVZ::PrvGetPalette (RGBList& thePalette) +{ + // !!! TBD + Preference<RGBType> pref1 (kPrefKeyBackgroundColor); + Preference<RGBType> pref2 (kPrefKeyHighlightColor); + + RGBType foreground (0, 0, 0); + RGBType background; + + if (this->GetLCDBacklightOn ()) + { + if (pref2.Loaded ()) + background = *pref2; + else + background = ::SkinGetHighlightColor (); + } + else + { + if (pref1.Loaded ()) + background = *pref1; + else + background = ::SkinGetBackgroundColor (); + } + + long br = ((long) background.fRed); + long bg = ((long) background.fGreen); + long bb = ((long) background.fBlue); + + long dr = ((long) foreground.fRed) - ((long) background.fRed); + long dg = ((long) foreground.fGreen) - ((long) background.fGreen); + long db = ((long) foreground.fBlue) - ((long) background.fBlue); + + int32 bpp = 1 << (READ_REGISTER (lcdPanelControl) & 0x03); + int32 numColors = 1 << bpp; + thePalette.resize (numColors); + + for (int color = 0; color < numColors; ++color) + { + thePalette[color].fRed = (UInt8) (br + dr * color / (numColors - 1)); + thePalette[color].fGreen = (UInt8) (bg + dg * color / (numColors - 1)); + thePalette[color].fBlue = (UInt8) (bb + db * color / (numColors - 1)); + } +} diff --git a/SrcShared/Hardware/EmRegsVZ.h b/SrcShared/Hardware/EmRegsVZ.h new file mode 100644 index 0000000..42ad360 --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZ.h @@ -0,0 +1,145 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsVZ_h +#define EmRegsVZ_h + +#include "EmHAL.h" // EmHALHandler +#include "EmRegs.h" // EmRegs +#include "EmStructs.h" // RGBList +#include "EmUARTDragonball.h" // EmUARTDragonball::State + +class EmScreenUpdateInfo; +class EmSPISlave; + + +class EmRegsVZ : public EmRegs, public EmHALHandler +{ + public: + EmRegsVZ (void); + virtual ~EmRegsVZ (void); + + // EmRegs overrides + virtual void Initialize (void); + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + virtual void Dispose (void); + + virtual void SetSubBankHandlers (void); + virtual uint8* GetRealAddress (emuptr address); + virtual emuptr GetAddressStart (void); + virtual uint32 GetAddressRange (void); + + // EmHALHandler overrides + virtual void Cycle (Bool sleeping); + virtual void CycleSlowly (Bool sleeping); + + virtual void ButtonEvent (SkinElementType, Bool buttonIsDown); + virtual void TurnSoundOff (void); + virtual void ResetTimer (void); + virtual void ResetRTC (void); + + virtual int32 GetInterruptLevel (void); + virtual int32 GetInterruptBase (void); + + virtual Bool GetLCDScreenOn (void) = 0; + virtual Bool GetLCDBacklightOn (void) = 0; + virtual Bool GetLCDHasFrame (void); + virtual void GetLCDBeginEnd (emuptr&, emuptr&); + virtual void GetLCDScanlines (EmScreenUpdateInfo& info); + + virtual int32 GetDynamicHeapSize (void); + virtual int32 GetROMSize (void); + virtual emuptr GetROMBaseAddress (void); + virtual Bool ChipSelectsConfigured (void); + virtual int32 GetSystemClockFrequency (void); + virtual Bool GetCanStop (void); + virtual Bool GetAsleep (void); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void PortDataChanged (int, uint8, uint8); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) = 0; + + private: + uint32 pllFreqSelRead (emuptr address, int size); + uint32 portXDataRead (emuptr address, int size); + uint32 tmr1StatusRead (emuptr address, int size); + uint32 tmr2StatusRead (emuptr address, int size); + uint32 uart1Read (emuptr address, int size); + uint32 uart2Read (emuptr address, int size); + uint32 rtcHourMinSecRead (emuptr address, int size); + + void csControl1Write (emuptr address, int size, uint32 value); + void csASelectWrite (emuptr address, int size, uint32 value); + void csDSelectWrite (emuptr address, int size, uint32 value); + void intMaskHiWrite (emuptr address, int size, uint32 value); + void intMaskLoWrite (emuptr address, int size, uint32 value); + void intStatusHiWrite (emuptr address, int size, uint32 value); + void portXDataWrite (emuptr address, int size, uint32 value); + void portDIntReqEnWrite (emuptr address, int size, uint32 value); + void tmr1StatusWrite (emuptr address, int size, uint32 value); + void tmr2StatusWrite (emuptr address, int size, uint32 value); + void spiCont1Write (emuptr address, int size, uint32 value); + void spiMasterControlWrite (emuptr address, int size, uint32 value); + void uart1Write (emuptr address, int size, uint32 value); + void uart2Write (emuptr address, int size, uint32 value); + void lcdRegisterWrite (emuptr address, int size, uint32 value); + void rtcControlWrite (emuptr address, int size, uint32 value); + void rtcIntStatusWrite (emuptr address, int size, uint32 value); + void rtcIntEnableWrite (emuptr address, int size, uint32 value); + + protected: + void HotSyncEvent (Bool buttonIsDown); + + virtual uint8 GetKeyBits (void); + virtual uint16 ButtonToBits (SkinElementType); + virtual EmSPISlave* GetSPISlave (void); + + protected: + void UpdateInterrupts (void); + void UpdatePortDInterrupts (void); + void UpdateRTCInterrupts (void); + + protected: + void UARTStateChanged (Bool sendTxData, int uartNum); + void UpdateUARTState (Bool refreshRxData, int uartNum); + void UpdateUARTInterrupts (const EmUARTDragonball::State& state, int uartNum); + void MarshalUARTState (EmUARTDragonball::State& state, int uartNum); + void UnmarshalUARTState (const EmUARTDragonball::State& state, int uartNum); + + protected: + int GetPort (emuptr address); + void PrvGetPalette (RGBList& thePalette); + + protected: + HwrM68VZ328Type f68VZ328Regs; + bool fHotSyncButtonDown; + uint16 fKeyBits; + uint16 fLastTmr1Status; + uint16 fLastTmr2Status; + uint8 fPortDEdge; + uint32 fPortDDataCount; + + uint32 fHour; + uint32 fMin; + uint32 fSec; + uint32 fTick; + uint32 fCycle; + + EmUARTDragonball* fUART[2]; +}; + +#endif /* EmRegsVZ_h */ diff --git a/SrcShared/Hardware/EmRegsVZHandEra330.cpp b/SrcShared/Hardware/EmRegsVZHandEra330.cpp new file mode 100644 index 0000000..598320e --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZHandEra330.cpp @@ -0,0 +1,608 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsVZTemp.h" +#include "EmRegsVZPrv.h" +#include "EmTRGSD.h" +#include "EmRegsVZHandEra330.h" +#include "EmRegs330CPLD.h" +#include "EmBankRegs.h" // EmBankRegs::DisableSubBank +#include "EmSPISlaveADS784x.h" // EmSPISlaveADS784x +#include "EmSPISlave330Current.h" +#include "EmScreen.h" // EmScreenUpdateInfo +#include "EmDlg.h" // EmDlg::DoCommonDialog + + +#pragma mark - + +const int kNumButtonRows = 4; +const int kNumButtonCols = 4; + +const uint16 kButtonMap[kNumButtonRows][kNumButtonCols] = +{ + { keyBitHard1, keyBitHard2, keyBitHard3, keyBitHard4 }, + { keyBitPageUp, keyBitPageDown, 0, keyBitThumbDown}, + { keyBitPower, 0, keyBitContrast, keyBitThumbPush}, + { 0, 0, 0, keyBitThumbUp}, +}; + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::EmRegsVZHandEra330 +// --------------------------------------------------------------------------- + +EmRegsVZHandEra330::EmRegsVZHandEra330 (HandEra330PortManager ** fPortManager) : + EmRegsVZ (), + fSPISlaveADC (new EmSPISlaveADS784x (kChannelSet2)), + fSPISlaveCurrent (new EmSPISlave330Current ()) +{ + PortD = PortD_DOCK_BTN | + PortD_CD_IRQ | + PortD_CF_IRQ | + PortD_POWER_FAIL; + PortF = PortF_PEN_IO | + PortF_CPLD_CS_F; + PortG = PortG_DTACK | + PortG_A0 | + PortG_Unused | + // PortG_LION | + PortG_Unused2; + PortJ = PortJ_AD_CS; + PortK = PortK_LED_GREEN | + PortK_LED_RED | + PortK_CPLD_TDO | + PortK_CPLD_TCK; + PortM = PortM_CPLD_TDI; + *fPortManager = &PortMgr; + PortMgr.Keys.Row[0] = 1; + PortMgr.Keys.Row[1] = 1; + PortMgr.Keys.Row[2] = 1; + PortMgr.Keys.Row[3] = 1; + PortMgr.LCDOn = false; + PortMgr.BacklightOn = false; + PortMgr.IRPortOn = false; + PortMgr.CFBus.bEnabled = false; + PortMgr.CFBus.Width = kCFBusWidth16; + PortMgr.CFBus.bSwapped = false; + PortMgr.CFInserted = true; + PortMgr.SDInserted = true; + PortMgr.pendingIRQ2 = false; + PortMgr.SDChipSelect = false; + PortMgr.PowerConnected = false; + + // make sure SPI1 fifos are empty + rxHead = rxTail = txHead = txTail = 0; + txFifoEmpty = true; + rxFifoEmpty = true; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::~EmRegsVZHandEra330 +// --------------------------------------------------------------------------- + +EmRegsVZHandEra330::~EmRegsVZHandEra330 (void) +{ + delete fSPISlaveADC; +} + +void EmRegsVZHandEra330::Initialize(void) +{ + EmRegsVZ::Initialize(); + + SD.Initialize(); +} + +void EmRegsVZHandEra330::Dispose (void) +{ + EmRegsVZ::Dispose(); + + SD.Dispose(); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZHandEra330::GetLCDScreenOn (void) +{ + // TRG LCD on is determined by LCD contrast on in the CPLD + return PortMgr.LCDOn; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZHandEra330::GetLCDBacklightOn (void) +{ + // TRG CPLD controls the backlight + return PortMgr.BacklightOn; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmRegsVZHandEra330::GetLineDriverState (EmUARTDeviceType type) +{ + if (type == kUARTSerial) + return (READ_REGISTER (portBData) & PortB_RS232_ON) != 0; + + if (type == kUARTIR) + return PortMgr.IRPortOn; + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::GetUARTDevice +// --------------------------------------------------------------------------- +// Return what sort of device is hooked up to the given UART. + +EmUARTDeviceType EmRegsVZHandEra330::GetUARTDevice (int /*uartNum*/) +{ + Bool serEnabled = this->GetLineDriverState (kUARTSerial); + Bool irEnabled = this->GetLineDriverState (kUARTIR); + + // It's probably an error to have them both enabled at the same + // time. !!! TBD: make this an error message. + + EmAssert (!(serEnabled && irEnabled)); + + // !!! Which UART are they using? + +// if (uartNum == ???) + { + if (serEnabled) + return kUARTSerial; + + if (irEnabled) + return kUARTIR; + } + + return kUARTNone; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::GetVibrateOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZHandEra330::GetVibrateOn (void) +{ + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::GetInterruptLevel +// --------------------------------------------------------------------------- + +int32 EmRegsVZHandEra330::GetInterruptLevel (void) +{ + int32 retval; + + retval = EmRegsVZ::GetInterruptLevel (); + + if (PortMgr.pendingIRQ2 && (retval < 2)) + retval = 2; + + return retval; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::GetLEDState +// --------------------------------------------------------------------------- + +uint16 EmRegsVZHandEra330::GetLEDState (void) +{ + uint16 result = kLEDOff; + uint8 portKData = READ_REGISTER (portKData); + + if ((portKData & PortK_LED_GREEN) == 0) + result |= kLEDGreen; + + if ((portKData & PortK_LED_RED) == 0) + result |= kLEDRed; + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::GetPortD +// --------------------------------------------------------------------------- + +uint8 EmRegsVZHandEra330::GetPortD (uint8 result) +{ + return result | + PortD_DOCK_BTN | + PortD_CD_IRQ | + PortD_CF_IRQ | + PortD_POWER_FAIL; +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::GetPortInputValue +// --------------------------------------------------------------------------- +// Return the GPIO values for the pins on the port. These values are used +// if the select pins are high. + +uint8 EmRegsVZHandEra330::GetPortInputValue (int port) +{ + uint8 result = EmRegsVZ::GetPortInputValue (port); + + switch (port) + { + case 'D' : + result = GetPortD (result); + break; + case 'F' : + result = PortF; + break; + case 'G' : + result = PortG; + break; + case 'J' : + result = PortJ; + break; + case 'K' : + result = PortK; + break; + case 'M' : + result = PortM; + break; + + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::GetPortInternalValue +// --------------------------------------------------------------------------- +// Return the dedicated values for the pins on the port. These values are +// used if the select pins are low. + +uint8 EmRegsVZHandEra330::GetPortInternalValue (int port) +{ + uint8 result = EmRegsVZ::GetPortInternalValue (port); + + switch (port) + { + case 'D' : + result = GetPortD(result); + break; + case 'F' : + result = PortF; + break; + case 'G' : + result = PortG; + break; + case 'J' : + result = PortJ; + break; + case 'K' : + result = PortK; + break; + case 'M' : + result = PortM; + break; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmRegsVZHandEra330::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ + *numRows = kNumButtonRows; + *numCols = kNumButtonCols; + + memcpy (keyMap, kButtonMap, sizeof (kButtonMap)); + + // Determine what row is being asked for. + rows[0] = PortMgr.Keys.Row[0]; + rows[1] = PortMgr.Keys.Row[1]; + rows[2] = PortMgr.Keys.Row[2]; + rows[3] = PortMgr.Keys.Row[3]; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::GetSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave* EmRegsVZHandEra330::GetSPISlave (void) +{ + if ((READ_REGISTER (portJData) & PortJ_AD_CS) == 0) + { + if (PortMgr.SenseCurrent) + return fSPISlaveCurrent; + else + return fSPISlaveADC; + } + + return NULL; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::GetROMSize +// --------------------------------------------------------------------------- + +int32 EmRegsVZHandEra330::GetROMSize (void) +{ + return (2 * 1024 * 1024); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::ButtonToBits +// --------------------------------------------------------------------------- + +uint16 EmRegsVZHandEra330::ButtonToBits (SkinElementType button) +{ + uint16 bitNumber = 0; + static Bool CF_button_pushed = false; + static Bool SD_button_pushed = false; + static Bool power_button_pushed = false; + + switch (button) + { + default: + bitNumber = EmRegsVZ::ButtonToBits (button); + break; + + // Borrow some skin elements from Symbol for our Thumb wheel + // NOTE: Borrowed Palm's contrast for our aux, so above case already handles it. + case kElement_TriggerLeft : + bitNumber = keyBitThumbUp; break; + case kElement_TriggerCenter : + bitNumber = keyBitThumbPush; break; + case kElement_TriggerRight : + bitNumber = keyBitThumbDown; break; + + // Borrow some additional skin elements to trigger a CF removal or insert. + case kElement_DownButtonLeft : + bitNumber = 0; + // we get called twice here, don't handle the event on the button release + if(!CF_button_pushed) + { + PortMgr.CFInserted = !PortMgr.CFInserted; + + if (PortMgr.CFInserted) + EmDlg::DoCommonDialog("The CF card has been installed.", kDlgFlags_OK); + else + EmDlg::DoCommonDialog("The CF card has been removed.", kDlgFlags_OK); + + PortMgr.pendingIRQ2 = true; + CF_button_pushed = true; + } + else + CF_button_pushed = false; + break; + + // SD + case kElement_DownButtonRight : + bitNumber = 0; + if (!SD_button_pushed) + { + PortMgr.SDInserted = !PortMgr.SDInserted; + + if (PortMgr.SDInserted) + EmDlg::DoCommonDialog("The SD card has been installed.\n\nIt will take a second for the OS to mount it.", + kDlgFlags_OK); + else + EmDlg::DoCommonDialog("The SD card has been removed.", kDlgFlags_OK); + + PortMgr.pendingIRQ2 = true; + SD_button_pushed = true; + } + else + SD_button_pushed = false; + break; + + // power + case kElement_UpButtonLeft : + bitNumber = 0; + if (!power_button_pushed) + { + if (!PortMgr.PowerConnected) + { + if (PortG & PortG_LION) + PortG &= ~PortG_LION; + else + PortG |= PortG_LION; + } + PortMgr.PowerConnected = !PortMgr.PowerConnected; + PortMgr.pendingIRQ2 = true; + ((EmSPISlave330Current *)fSPISlaveCurrent)->SetMode(PortMgr.PowerConnected); + + power_button_pushed = true; + } + else + power_button_pushed = false; + break; + } + + return bitNumber; +} + + +/********************************************************************************** + * SD support: + * HandEra 330 SD is attached to the DragonballVZ SPI1 which is otherwise unused. + **********************************************************************************/ +uint32 EmRegsVZHandEra330::spiRxDRead(emuptr /* address */, int /* size */) +{ + uint32 retval; + + // there is an 8 word fifo here, read back the first in. + + if ((rxHead == rxTail) && rxFifoEmpty) + { + // invalid read, fifo empty + return 0; + } + + retval = rxFifo[rxTail++]; + if (rxTail == 8) + rxTail = 0; + if (rxTail == rxHead) + txFifoEmpty = true; + return retval; +} + +void EmRegsVZHandEra330::spiTxDWrite(emuptr address, int size, uint32 value) +{ + // Do a standard update of the register. (so reading the last value back works) + EmRegsVZ::StdWrite (address, size, value); + + if (!txFifoEmpty && (txHead == txTail)) + { + // fifo full, do nothing + return; + } + + txFifoEmpty = false; + + // there is an 8 word fifo here. + txFifo[txHead++] = value; + if (txHead == 8) + txHead = 0; +} + +void EmRegsVZHandEra330::spiCont1Write(emuptr address, int size, uint32 value) +{ + // if we were not enabled before, flush fifos + if ((value & hwrVZ328SPIMControlEnable)==0) + { + txTail = txHead; + rxTail = rxHead; + txFifoEmpty = rxFifoEmpty = true; + } + + // Do a standard update of the register. + EmRegsVZ::StdWrite (address, size, value); + + // Get the current value. + uint16 spiCont1 = READ_REGISTER (spiCont1); + + // Check to see if data exchange and enable are enabled. + #define BIT_MASK (hwrVZ328SPIMControlExchange | hwrVZ328SPIMControlEnable) + if ((spiCont1 & BIT_MASK) == BIT_MASK) + { + // do the exchange + if (!txFifoEmpty) + { + // is SD chip selected? + if (PortMgr.SDChipSelect) + { + uint16 rxData, txData; + + do + { + txData = txFifo[txTail++]; + if (txTail == 8) + txTail = 0; + SD.ExchangeBits(txData, &rxData, (spiCont1 & 0x000f)+1); + rxFifo[rxHead++] = rxData; + if (rxHead == 8) + rxHead = 0; + } while (txTail != txHead); + txFifoEmpty = true; + rxFifoEmpty = false; + } + else + { + // nothing else is connected here, just stuff the rx fifo and flush the tx fifo + do + { + txTail++; + if (txTail == 8) + txTail = 0; + rxFifo[rxHead++] = 0xff; + if (rxHead == 8) + rxHead = 0; + } while (txTail != txHead); + rxFifoEmpty = false; + txFifoEmpty = true; + } + } + + // Clear the exchange bit. + spiCont1 &= ~hwrVZ328SPIMControlExchange; + WRITE_REGISTER (spiCont1, spiCont1); + } +} + +uint32 EmRegsVZHandEra330::spiCont1Read(emuptr /* address */, int /* size */) +{ + return 0; +} + +void EmRegsVZHandEra330::spiIntCSWrite(emuptr /* address */, int /* size */, uint32 /* value */) +{ +} + +uint32 EmRegsVZHandEra330::spiIntCSRead(emuptr /* address */, int /* size */) +{ + return 0; +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZHandEra330::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegsVZHandEra330::SetSubBankHandlers(void) +{ + //HwrM68VZ328Type regs; + + EmRegsVZ::SetSubBankHandlers(); + + // SD support + this->SetHandler((ReadFunction)&EmRegsVZHandEra330::spiRxDRead, + (WriteFunction)&EmRegsVZ::StdWrite, + addressof(spiRxD), + sizeof(UInt16)); + this->SetHandler((ReadFunction)&EmRegsVZ::StdRead, + (WriteFunction)&EmRegsVZHandEra330::spiTxDWrite, + addressof(spiTxD), + sizeof(UInt16)); + this->SetHandler((ReadFunction)&EmRegsVZ::StdRead, + (WriteFunction)&EmRegsVZHandEra330::spiCont1Write, + addressof(spiCont1), + sizeof(UInt16)); +/* + this->SetHandler((ReadFunction)&EmRegsVZHandEra330::spiIntCSRead, + (WriteFunction)&EmRegsVZHandEra330::spiIntCSWrite, + addressof(spiIntCS), + sizeof(regs.spiIntCS)); +*/ +} diff --git a/SrcShared/Hardware/EmRegsVZHandEra330.h b/SrcShared/Hardware/EmRegsVZHandEra330.h new file mode 100644 index 0000000..154ad23 --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZHandEra330.h @@ -0,0 +1,142 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsVZHandEra330_h +#define EmRegsVZHandEra330_h + +#include "EmRegsVZ.h" +#include "EmHandEra330Defs.h" +#include "EmPalmStructs.h" +#include "EmTRGSD.h" + +#define keyBitThumbDown 0x1000 +#define keyBitThumbUp 0x2000 +#define keyBitThumbPush 0x4000 + +#define PortB_CF_CS 0x0001 +#define PortB_RS232_ON 0x0040 + +#define PortD_KBD_COL0 0x0001 +#define PortD_KBD_COL1 0x0002 +#define PortD_KBD_COL2 0x0004 +#define PortD_KBD_COL3 0x0008 +#define PortD_DOCK_BTN 0x0010 +#define PortD_CD_IRQ 0x0020 +#define PortD_CF_IRQ 0x0040 +#define PortD_POWER_FAIL 0x0080 + +#define PortF_LCD_PWM 0x0001 +#define PortF_PEN_IO 0x0002 +#define PortF_CLK_OUT 0x0004 +#define PortF_A20 0x0008 +#define PortF_A21 0x0010 +#define PortF_A22 0x0020 +#define PortF_A23 0x0040 +#define PortF_CPLD_CS_F 0x0080 + +#define PortG_DTACK 0x0001 +#define PortG_A0 0x0002 +#define PortG_Unused 0x0004 +#define PortG_CPLD_TMS 0x0008 +#define PortG_LION 0x0010 +#define PortG_Unused2 0x0020 + +#define PortJ_SPI_TX 0x0001 +#define PortJ_SPI_RX 0x0002 +#define PortJ_SPI_CLK 0x0004 +#define PortJ_AD_CS 0x0008 +#define PortJ_232_RX2 0x0010 +#define PortJ_232_TX2 0x0020 +#define PortJ_232_RTS2 0x0040 +#define PortJ_232_CTS2 0x0080 + +#define PortK_VOL_PWM 0x0001 +#define PortK_GP_IN_F 0x0002 +#define PortK_LED_GREEN 0x0004 +#define PortK_LED_RED 0x0008 +#define PortK_CPLD_TDO 0x0010 +#define PortK_Unused 0x0020 +#define PortK_CPLD_TCK 0x0040 +#define PortK_Unused2 0x0020 + +#define PortM_SD_CLK 0x0001 +#define PortM_SD_CE 0x0002 +#define PortM_SD_DQMH 0x0004 +#define PortM_SD_DQML 0x0008 +#define PortM_SD_A10 0x0010 +#define PortM_CPLD_TDI 0x0020 + +class EmRegsVZHandEra330 : public EmRegsVZ +{ + public: + EmRegsVZHandEra330 (HandEra330PortManager ** fPortManager); + virtual ~EmRegsVZHandEra330 (void); + + virtual void Initialize (void); + virtual void Dispose (void); + + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLineDriverState (EmUARTDeviceType type); + virtual EmUARTDeviceType GetUARTDevice (int uartNum); + virtual Bool GetVibrateOn (void); + virtual uint16 GetLEDState (void); + int32 GetROMSize (void); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); + virtual int32 GetInterruptLevel (void); + void SetSubBankHandlers (void); + + protected: + virtual EmSPISlave* GetSPISlave (void); + virtual uint16 ButtonToBits (SkinElementType button); + + private: + uint8 GetPortD(uint8 result); + UInt16 PortD; + UInt16 PortF; + UInt16 PortG; + UInt16 PortJ; + UInt16 PortK; + UInt16 PortM; + EmSPISlave* fSPISlaveADC; + EmSPISlave* fSPISlaveCurrent; + HandEra330PortManager PortMgr; + EmTRGSD SD; + + uint16 rxFifo[8]; + bool rxFifoEmpty; + int rxHead; + int rxTail; + uint16 txFifo[8]; + bool txFifoEmpty; + int txHead; + int txTail; + + void spiRxDWrite (emuptr address, int size, uint32 value); + uint32 spiRxDRead (emuptr address, int size); + void spiTxDWrite (emuptr address, int size, uint32 value); + uint32 spiTxDRead (emuptr address, int size); + void spiCont1Write (emuptr address, int size, uint32 value); + uint32 spiCont1Read (emuptr address, int size); + void spiIntCSWrite (emuptr address, int size, uint32 value); + uint32 spiIntCSRead (emuptr address, int size); +}; + + + +#endif /* EmRegsVZTemp_h */ + diff --git a/SrcShared/Hardware/EmRegsVZPalmM500.cpp b/SrcShared/Hardware/EmRegsVZPalmM500.cpp new file mode 100644 index 0000000..420de8b --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZPalmM500.cpp @@ -0,0 +1,259 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsVZPalmM500.h" +#include "EmRegsVZPrv.h" + +#include "EmSPISlaveADS784x.h" // EmSPISlaveADS784x + +#define hwrVZPortBALARM_LED 0x40 // (L) Alarm LED + +#define hwrVZPortDSpi1Card 0x20 // (-) SPI #1, slot 0, SD/MMC Card Detect EOR Wake EOR Ready (aka IRQ2) +#define hwrVZPortDPowerFail 0x80 // (L) Power Fail interrupt (aka IRQ6) + +#define hwrVZPortGEL_ON 0x02 // (L) EL_ON +#define hwrVZPortGADC_CS_N 0x04 // (H) ADC_CS# +#define hwrVZPortG232_SHDN_N 0x08 // (L) 232_SHDN# + +#define hwrVZPortKLCDOn 0x02 // (-) LCD_DISP_ON (RW#) +#define hwrVZPortKAC_PWR_N 0x04 // (-) AC_PWR# (LDS#) +#define hwrVZPortKVibeEn 0x10 // (-) VIBE_EN +#define hwrVZPortKKbdRow0 0x20 // (H) Keyboard Row 0 +#define hwrVZPortKKbdRow1 0x40 // (H) Keyboard Row 1 +#define hwrVZPortKKbdRow2 0x80 // (H) Keyboard Row 2 + +#define hwrVZPortMIR_SD 0x20 // (L) Infrared Shut-down + + +const int kNumButtonRows = 3; +const int kNumButtonCols = 4; + +const uint16 kGenericMonoMap[kNumButtonRows][kNumButtonCols] = +{ + { keyBitHard1, keyBitHard2, keyBitHard3, keyBitHard4 }, + { keyBitPageUp, keyBitPageDown, 0, 0 }, + { keyBitPower, keyBitContrast, keyBitHard2, 0 } +}; + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM500::EmRegsVZPalmM500 +// --------------------------------------------------------------------------- + +EmRegsVZPalmM500::EmRegsVZPalmM500 (void) : + EmRegsVZ (), + fSPISlaveADC (new EmSPISlaveADS784x (kChannelSet1)) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM500::~EmRegsVZPalmM500 +// --------------------------------------------------------------------------- + +EmRegsVZPalmM500::~EmRegsVZPalmM500 (void) +{ + delete fSPISlaveADC; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM500::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZPalmM500::GetLCDScreenOn (void) +{ + return (READ_REGISTER (portKData) & hwrVZPortKLCDOn) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM500::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZPalmM500::GetLCDBacklightOn (void) +{ + return (READ_REGISTER (portGData) & hwrVZPortGEL_ON) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM500::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmRegsVZPalmM500::GetLineDriverState (EmUARTDeviceType type) +{ + if (type == kUARTSerial) + return (READ_REGISTER (portGData) & hwrVZPortG232_SHDN_N) != 0; + + if (type == kUARTIR) + return (READ_REGISTER (portMData) & hwrVZPortMIR_SD) == 0; + + if (type == kUARTMystery) + return true; + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM500::GetUARTDevice +// --------------------------------------------------------------------------- +// Return what sort of device is hooked up to the given UART. + +EmUARTDeviceType EmRegsVZPalmM500::GetUARTDevice (int uartNum) +{ + Bool serEnabled = this->GetLineDriverState (kUARTSerial); + Bool irEnabled = this->GetLineDriverState (kUARTIR); + + // It's probably an error to have them both enabled at the same + // time. !!! TBD: make this an error message. + + EmAssert (!(serEnabled && irEnabled)); + + /* + From Michael Cortopassi: + + UART 1 for IRda + UART 2 for hotsync + */ + + if (uartNum == 0) + { + if (irEnabled) + return kUARTIR; + } + else if (uartNum == 1) + { + if (serEnabled) + return kUARTSerial; + } + + return kUARTNone; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM500::GetVibrateOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZPalmM500::GetVibrateOn (void) +{ + return (READ_REGISTER (portKData) & hwrVZPortKVibeEn) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM500::GetLEDState +// --------------------------------------------------------------------------- + +uint16 EmRegsVZPalmM500::GetLEDState (void) +{ + uint16 result = kLEDOff; + UInt8 portBData = READ_REGISTER (portBData); + + if (portBData & hwrVZPortBALARM_LED) + result |= kLEDGreen; + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM500::GetPortInputValue +// --------------------------------------------------------------------------- +// Return the GPIO values for the pins on the port. These values are used +// if the select pins are high. + +uint8 EmRegsVZPalmM500::GetPortInputValue (int port) +{ + uint8 result = EmRegsVZ::GetPortInputValue (port); + + if (port == 'K') + { + // Make sure hwrVZPortKAC_PWR_N is set, or the dock-status routines + // will report that we're powered (even if we aren't docked!). + + result |= hwrVZPortKAC_PWR_N; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM500::GetPortInternalValue +// --------------------------------------------------------------------------- +// Return the dedicated values for the pins on the port. These values are +// used if the select pins are low. + +uint8 EmRegsVZPalmM500::GetPortInternalValue (int port) +{ + uint8 result = EmRegsVZ::GetPortInternalValue (port); + + if (port == 'D') + { + // Make sure that hwrVZPortDPowerFail is set. If it's clear, + // the battery code will make the device go to sleep immediately. + // + // Also make sure that hwrVZPortDSpi1Card is set. If it's clear, + // the slot driver will think there's a card installed and will try querying it. + + result |= hwrVZPortDPowerFail | hwrVZPortDSpi1Card; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM500::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmRegsVZPalmM500::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ + *numRows = kNumButtonRows; + *numCols = kNumButtonCols; + + memcpy (keyMap, kGenericMonoMap, sizeof (kGenericMonoMap)); + + // Determine what row is being asked for. + + UInt8 portKDir = READ_REGISTER (portKDir); + UInt8 portKData = READ_REGISTER (portKData); + + rows[0] = (portKDir & hwrVZPortKKbdRow0) != 0 && (portKData & hwrVZPortKKbdRow0) == 0; + rows[1] = (portKDir & hwrVZPortKKbdRow1) != 0 && (portKData & hwrVZPortKKbdRow1) == 0; + rows[2] = (portKDir & hwrVZPortKKbdRow2) != 0 && (portKData & hwrVZPortKKbdRow2) == 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM500::GetSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave* EmRegsVZPalmM500::GetSPISlave (void) +{ + if ((READ_REGISTER (portGData) & hwrVZPortGADC_CS_N) == 0) + { + return fSPISlaveADC; + } + + return NULL; +} + + diff --git a/SrcShared/Hardware/EmRegsVZPalmM500.h b/SrcShared/Hardware/EmRegsVZPalmM500.h new file mode 100644 index 0000000..81fe5b4 --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZPalmM500.h @@ -0,0 +1,44 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsVZPalmM500_h +#define EmRegsVZPalmM500_h + +#include "EmRegsVZ.h" + +class EmRegsVZPalmM500 : public EmRegsVZ +{ + public: + EmRegsVZPalmM500 (void); + virtual ~EmRegsVZPalmM500 (void); + + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLineDriverState (EmUARTDeviceType type); + virtual EmUARTDeviceType GetUARTDevice (int uartNum); + virtual Bool GetVibrateOn (void); + virtual uint16 GetLEDState (void); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); + + protected: + virtual EmSPISlave* GetSPISlave (void); + + private: + EmSPISlave* fSPISlaveADC; +}; + +#endif /* EmRegsVZPalmM500_h */ diff --git a/SrcShared/Hardware/EmRegsVZPalmM505.cpp b/SrcShared/Hardware/EmRegsVZPalmM505.cpp new file mode 100644 index 0000000..938a4e6 --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZPalmM505.cpp @@ -0,0 +1,151 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsVZPalmM505.h" +#include "EmRegsVZPrv.h" + +#include "EmBankRegs.h" // EmBankRegs::DisableSubBank +#include "EmRegsSED1376.h" // sed1376RegsAddr + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM505::EmRegsVZPalmM505 +// --------------------------------------------------------------------------- + +EmRegsVZPalmM505::EmRegsVZPalmM505 (void) : + EmRegsVZPalmM500 () +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM505::~EmRegsVZPalmM505 +// --------------------------------------------------------------------------- + +EmRegsVZPalmM505::~EmRegsVZPalmM505 (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM505::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegsVZPalmM505::SetSubBankHandlers (void) +{ + // Install base handlers. + + EmRegsVZ::SetSubBankHandlers (); + + // Now add standard/specialized handers for the defined registers. + + this->SetHandler ((ReadFunction) &EmRegsVZ::StdRead, + (WriteFunction) &EmRegsVZPalmM505::portFSelectWrite, + addressof (portFSelect), sizeof (f68VZ328Regs.portFSelect)); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZ::portFSelectWrite +// --------------------------------------------------------------------------- + +void EmRegsVZPalmM505::portFSelectWrite (emuptr address, int size, uint32 value) +{ + uint8 oldPortFSelect = READ_REGISTER (portFSelect); + + // Do a standard update of the register. + + EmRegsVZ::StdWrite (address, size, value); + + uint8 portFSelect = READ_REGISTER (portFSelect); + +#define hwrVZPortFBusClock 0x04 // (P) Bus Clock + + if (((portFSelect ^ oldPortFSelect) & hwrVZPortFBusClock) != 0) + { + if ((portFSelect & hwrVZPortFBusClock) != 0) + { + EmBankRegs::DisableSubBank (sed1376RegsAddr); + EmBankRegs::DisableSubBank (sed1376VideoMemStart); + } + else + { + EmBankRegs::EnableSubBank (sed1376RegsAddr); + EmBankRegs::EnableSubBank (sed1376VideoMemStart); + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM505::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZPalmM505::GetLCDScreenOn (void) +{ + // Override the Dragonball version and let the SED 1376 handle it. + + return EmHALHandler::GetLCDScreenOn (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM505::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZPalmM505::GetLCDBacklightOn (void) +{ + // Override the Dragonball version and let the SED 1376 handle it. + + return EmHALHandler::GetLCDBacklightOn (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM505::GetLCDHasFrame +// --------------------------------------------------------------------------- + +Bool EmRegsVZPalmM505::GetLCDHasFrame (void) +{ + // Override the Dragonball version and let the SED 1376 handle it. + + return EmHALHandler::GetLCDHasFrame (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM505::GetLCDBeginEnd +// --------------------------------------------------------------------------- + +void EmRegsVZPalmM505::GetLCDBeginEnd (emuptr& begin, emuptr& end) +{ + // Override the Dragonball version and let the SED 1376 handle it. + + EmHALHandler::GetLCDBeginEnd (begin, end); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM505::GetLCDScanlines +// --------------------------------------------------------------------------- + +void EmRegsVZPalmM505::GetLCDScanlines (EmScreenUpdateInfo& info) +{ + // Override the Dragonball version and let the SED 1376 handle it. + + EmHALHandler::GetLCDScanlines (info); +} + + + diff --git a/SrcShared/Hardware/EmRegsVZPalmM505.h b/SrcShared/Hardware/EmRegsVZPalmM505.h new file mode 100644 index 0000000..7488855 --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZPalmM505.h @@ -0,0 +1,36 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsVZPalmM505_h +#define EmRegsVZPalmM505_h + +#include "EmRegsVZPalmM500.h" + +class EmRegsVZPalmM505 : public EmRegsVZPalmM500 +{ + public: + EmRegsVZPalmM505 (void); + virtual ~EmRegsVZPalmM505 (void); + + virtual void SetSubBankHandlers (void); + + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLCDHasFrame (void); + virtual void GetLCDBeginEnd (emuptr& begin, emuptr& end); + virtual void GetLCDScanlines (EmScreenUpdateInfo& info); + + void portFSelectWrite (emuptr address, int size, uint32 value); +}; + +#endif /* EmRegsVZPalmM505_h */ diff --git a/SrcShared/Hardware/EmRegsVZPrv.h b/SrcShared/Hardware/EmRegsVZPrv.h new file mode 100644 index 0000000..02e9779 --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZPrv.h @@ -0,0 +1,45 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsVZPrv_h +#define EmRegsVZPrv_h + +#include "EmRegsPrv.h" + +// Location and range of registers + +const uint32 kMemoryStart = 0xFFFFF000; +const uint32 kMemorySize = sizeof (HwrM68VZ328Type); + + +// Macro to return the DragonballVZ address of the specified register + +#define addressof(x) (kMemoryStart + offsetof(HwrM68VZ328Type, x)) + + +// Macros for reading/writing DragonballVZ registers. + +#define READ_REGISTER(reg) \ + _get_reg (&f68VZ328Regs.reg) + +#define WRITE_REGISTER(reg, value) \ + _put_reg (&f68VZ328Regs.reg, value) + + +// Macro for installing DragonballVZ register handlers + +#define INSTALL_HANDLER(read, write, reg) \ + this->SetHandler ((ReadFunction) &EmRegsVZ::read, (WriteFunction) &EmRegsVZ::write, addressof (reg), sizeof (f68VZ328Regs.reg)) + + +#endif /* EmRegsVZPrv_h */ diff --git a/SrcShared/Hardware/EmRegsVZTemp.cpp b/SrcShared/Hardware/EmRegsVZTemp.cpp new file mode 100644 index 0000000..36a8521 --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZTemp.cpp @@ -0,0 +1,848 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsVZTemp.h" +#include "EmRegsVZPrv.h" + +#include "EmSPISlaveADS784x.h" // EmSPISlaveADS784x +#include "EmTransportSerial.h" // EmTransportSerial + + +const int kNumButtonRows = 3; +const int kNumButtonCols = 4; + +const uint16 kButtonMap[kNumButtonRows][kNumButtonCols] = +{ + { keyBitHard1, keyBitHard2, keyBitHard3, keyBitHard4 }, + { keyBitPageUp, keyBitPageDown, 0, 0 }, + { keyBitPower, keyBitContrast, keyBitHard2, 0 } +}; + + + +#pragma mark - +#define hwrVZPortBRADIO_DTR 0x40 // (L) Radio DTR +#define hwrVZPortKRADIO_DSR 0x02 // Radio DTR + +#define hwrVZPalmI705PortDTWISTIRQ 0x20 // Twister IRQ (IRQ2) +#define hwrVZPalmI705PortDPowerFail 0x80 // (L) Power Fail interrupt (aka IRQ6) + +#define hwrVZPalmI705PortGEL_ON 0x02 // (L) EL_ON +#define hwrVZPalmI705PortGLCD_DISP_ON 0x04 // (H) LCD_DISP_ON +#define hwrVZPalmI705PortG232_SHDN_N 0x08 // (L) 232_SHDN# +#define hwrVZPalmI705PortGADC_CS_N 0x20 // (H) ADC_CS# + +#define hwrVZPalmI705PortKVIB_EN 0x10 // vibarator enable/disable +#define hwrVZPalmI705PortKKbdRow0 0x20 // (H) Keyboard Row 0 +#define hwrVZPalmI705PortKKbdRow1 0x40 // (H) Keyboard Row 1 +#define hwrVZPalmI705PortKKbdRow2 0x80 // (H) Keyboard Row 2 + +#define hwrVZPalmI705PortMIR_SD 0x20 // (L) Infrared Shut-down (UART 2) + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmI705::EmRegsVZPalmI705 +// --------------------------------------------------------------------------- + +EmRegsVZPalmI705::EmRegsVZPalmI705 (void) : + EmRegsVZ (), + fSPISlaveADC (new EmSPISlaveADS784x (kChannelSet1)) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmI705::~EmRegsVZPalmI705 +// --------------------------------------------------------------------------- + +EmRegsVZPalmI705::~EmRegsVZPalmI705 (void) +{ + delete fSPISlaveADC; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmI705::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZPalmI705::GetLCDScreenOn (void) +{ + return (READ_REGISTER (portGData) & hwrVZPalmI705PortGLCD_DISP_ON) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmI705::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZPalmI705::GetLCDBacklightOn (void) +{ + return (READ_REGISTER (portGData) & hwrVZPalmI705PortGEL_ON) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmI705::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmRegsVZPalmI705::GetLineDriverState (EmUARTDeviceType type) +{ + if (type == kUARTSerial) + return (READ_REGISTER (portGData) & hwrVZPalmI705PortG232_SHDN_N) != 0; + + if (type == kUARTIR) + return (READ_REGISTER (portMData) & hwrVZPalmI705PortMIR_SD) == 0; + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmI705::GetUARTDevice +// --------------------------------------------------------------------------- +// Return what sort of device is hooked up to the given UART. + +EmUARTDeviceType EmRegsVZPalmI705::GetUARTDevice (int uartNum) +{ + Bool serEnabled = this->GetLineDriverState (kUARTSerial); + Bool irEnabled = this->GetLineDriverState (kUARTIR); + + // It's probably an error to have them both enabled at the same + // time. !!! TBD: make this an error message. + + EmAssert (!(serEnabled && irEnabled)); + + /* + From Van Oler: + + UART #2 is used for serial (rs-232) and IR. The rs-232 receiver + and the IR receiver are tristate outouts with individual enables + to control which one drives the RXD2 input. + + UART1 is not used; only the pins are used for GPIO. + + The Master SPI (on PE0,1,2) is used for data to and from the + touchscreen A/D and the radio DSP. Each has individual selects. + + The Master/Slave SPI (on PJ0,1,2) is used for the MMC/SD card slot. + + There is a separate USB chip, the same as tornado. + */ + + if (uartNum == 1) + { + if (serEnabled) + return kUARTSerial; + + if (irEnabled) + return kUARTIR; + } + + return kUARTNone; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmI705::GetVibrateOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZPalmI705::GetVibrateOn (void) +{ + return (READ_REGISTER (portKData) & hwrVZPalmI705PortKVIB_EN) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmI705::GetPortInputValue +// --------------------------------------------------------------------------- +// Return the GPIO values for the pins on the port. These values are used +// if the select pins are high. + +uint8 EmRegsVZPalmI705::GetPortInputValue (int port) +{ + uint8 result = EmRegsVZ::GetPortInputValue (port); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmI705::GetPortInternalValue +// --------------------------------------------------------------------------- +// Return the dedicated values for the pins on the port. These values are +// used if the select pins are low. + +uint8 EmRegsVZPalmI705::GetPortInternalValue (int port) +{ + uint8 result = EmRegsVZ::GetPortInternalValue (port); + + if (port == 'D') + { + // Make sure that hwrVZPortDPowerFail is set. If it's clear, + // the battery code will make the device go to sleep immediately. + // + // Also make sure that hwrVZPalmI705PortDTWISTIRQ is set. If it's clear, + // the slot driver will think there's a card installed and will try querying it. + + result |= hwrVZPalmI705PortDPowerFail | hwrVZPalmI705PortDTWISTIRQ; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmI705::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmRegsVZPalmI705::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ + *numRows = kNumButtonRows; + *numCols = kNumButtonCols; + + memcpy (keyMap, kButtonMap, sizeof (kButtonMap)); + + // Determine what row is being asked for. + + UInt8 portKDir = READ_REGISTER (portKDir); + UInt8 portKData = READ_REGISTER (portKData); + + rows[0] = (portKDir & hwrVZPalmI705PortKKbdRow0) != 0 && (portKData & hwrVZPalmI705PortKKbdRow0) == 0; + rows[1] = (portKDir & hwrVZPalmI705PortKKbdRow1) != 0 && (portKData & hwrVZPalmI705PortKKbdRow1) == 0; + rows[2] = (portKDir & hwrVZPalmI705PortKKbdRow2) != 0 && (portKData & hwrVZPalmI705PortKKbdRow2) == 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmI705::GetSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave* EmRegsVZPalmI705::GetSPISlave (void) +{ + if ((READ_REGISTER (portGData) & hwrVZPalmI705PortGADC_CS_N) == 0) + { + return fSPISlaveADC; + } + + return NULL; +} + + + + +#pragma mark - + +#define hwrVZPalmM125PortDTWISTIRQ 0x20 // Twister IRQ (IRQ2) +#define hwrVZPalmM125PortDPowerFail 0x80 // (L) Power Fail interrupt (aka IRQ6) + +#define hwrVZPalmM125PortGEL_ON 0x02 // (L) EL_ON +#define hwrVZPalmM125PortGLCD_DISP_ON 0x04 // (H) LCD_DISP_ON +#define hwrVZPalmM125PortG232_SHDN_N 0x08 // (L) 232_SHDN# +#define hwrVZPalmM125PortGADC_CS_N 0x20 // (H) ADC_CS# + +#define hwrVZPalmM125PortKIRShutdown 0x04 // (-) IR_SHDN +#define hwrVZPalmM125PortKVIB_EN 0x10 // vibarator enable/disable +#define hwrVZPalmM125PortKKbdRow0 0x20 // (H) Keyboard Row 0 +#define hwrVZPalmM125PortKKbdRow1 0x40 // (H) Keyboard Row 1 +#define hwrVZPalmM125PortKKbdRow2 0x80 // (H) Keyboard Row 2 + +const uint16 kButtonMapPalmM125[kNumButtonRows][kNumButtonCols] = +{ + { keyBitHard1, keyBitHard2, keyBitHard3, keyBitHard4 }, + { 0, keyBitPageDown, 0, 0 }, + { keyBitPower, keyBitPageUp, 0, 0 } +}; + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM125::EmRegsVZPalmM125 +// --------------------------------------------------------------------------- + +EmRegsVZPalmM125::EmRegsVZPalmM125 (void) : + EmRegsVZ (), + fSPISlaveADC (new EmSPISlaveADS784x (kChannelSet3)) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM125::~EmRegsVZPalmM125 +// --------------------------------------------------------------------------- + +EmRegsVZPalmM125::~EmRegsVZPalmM125 (void) +{ + delete fSPISlaveADC; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM125::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZPalmM125::GetLCDScreenOn (void) +{ + return (READ_REGISTER (portKData) & 0x02) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM125::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZPalmM125::GetLCDBacklightOn (void) +{ + return (READ_REGISTER (portFData) & 0x10) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM125::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmRegsVZPalmM125::GetLineDriverState (EmUARTDeviceType type) +{ + if (type == kUARTSerial) + return (READ_REGISTER (portEData) & 0x40) != 0; + + if (type == kUARTIR) + return (READ_REGISTER (portKData) & hwrVZPalmM125PortKIRShutdown) == 0; + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM125::GetUARTDevice +// --------------------------------------------------------------------------- +// Return what sort of device is hooked up to the given UART. + +EmUARTDeviceType EmRegsVZPalmM125::GetUARTDevice (int uartNum) +{ + Bool serEnabled = this->GetLineDriverState (kUARTSerial); + Bool irEnabled = this->GetLineDriverState (kUARTIR); + + // It's probably an error to have them both enabled at the same + // time. !!! TBD: make this an error message. + + EmAssert (!(serEnabled && irEnabled)); + + if (uartNum == 0) + { + if (irEnabled) + return kUARTIR; + } + else if (uartNum == 1) + { + if (serEnabled) + return kUARTSerial; + } + + return kUARTNone; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM125::GetPortInputValue +// --------------------------------------------------------------------------- +// Return the GPIO values for the pins on the port. These values are used +// if the select pins are high. + +uint8 EmRegsVZPalmM125::GetPortInputValue (int port) +{ + uint8 result = EmRegsVZ::GetPortInputValue (port); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM125::GetPortInternalValue +// --------------------------------------------------------------------------- +// Return the dedicated values for the pins on the port. These values are +// used if the select pins are low. + +uint8 EmRegsVZPalmM125::GetPortInternalValue (int port) +{ + uint8 result = EmRegsVZ::GetPortInternalValue (port); + + if (port == 'D') + { + // Make sure that hwrVZPortDPowerFail is set. If it's clear, + // the battery code will make the device go to sleep immediately. + // + // Also make sure that hwrVZPalmM125PortDTWISTIRQ is set. If it's clear, + // the slot driver will think there's a card installed and will try querying it. + + result |= hwrVZPalmM125PortDPowerFail | hwrVZPalmM125PortDTWISTIRQ; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM125::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmRegsVZPalmM125::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ + *numRows = kNumButtonRows; + *numCols = kNumButtonCols; + + memcpy (keyMap, kButtonMapPalmM125, sizeof (kButtonMapPalmM125)); + + // Determine what row is being asked for. + + UInt8 portKDir = READ_REGISTER (portKDir); + UInt8 portKData = READ_REGISTER (portKData); + + rows[0] = (portKDir & hwrVZPalmM125PortKKbdRow0) != 0 && (portKData & hwrVZPalmM125PortKKbdRow0) == 0; + rows[1] = (portKDir & hwrVZPalmM125PortKKbdRow1) != 0 && (portKData & hwrVZPalmM125PortKKbdRow1) == 0; + rows[2] = (portKDir & hwrVZPalmM125PortKKbdRow2) != 0 && (portKData & hwrVZPalmM125PortKKbdRow2) == 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM125::GetSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave* EmRegsVZPalmM125::GetSPISlave (void) +{ + if ((READ_REGISTER (portGData) & hwrVZPalmM125PortGADC_CS_N) == 0) + { + return fSPISlaveADC; + } + + return NULL; +} + + +#pragma mark - + +#define hwrVZPalmM130PortDTWISTIRQ 0x20 // Twister IRQ (IRQ2) +#define hwrVZPalmM130PortDPowerFail 0x80 // (L) Power Fail interrupt (aka IRQ6) + +#define hwrVZPalmM130PortGEL_ON 0x02 // (L) EL_ON +#define hwrVZPalmM130PortGLCD_DISP_ON 0x04 // (H) LCD_DISP_ON +#define hwrVZPalmM130PortG232_SHDN_N 0x08 // (L) 232_SHDN# +#define hwrVZPalmM130PortGADC_CS_N 0x20 // (H) ADC_CS# + +#define hwrVZPalmM130PortKIRShutdown 0x04 // (-) IR_SHDN +#define hwrVZPalmM130PortKVIB_EN 0x10 // vibarator enable/disable +#define hwrVZPalmM130PortKKbdRow0 0x20 // (H) Keyboard Row 0 +#define hwrVZPalmM130PortKKbdRow1 0x40 // (H) Keyboard Row 1 +#define hwrVZPalmM130PortKKbdRow2 0x80 // (H) Keyboard Row 2 + +const uint16 kButtonMapPalmM130[kNumButtonRows][kNumButtonCols] = +{ + { keyBitHard1, keyBitHard2, keyBitHard3, keyBitHard4 }, + { 0, keyBitPageDown, 0, 0 }, + { keyBitPower, keyBitPageUp, 0, 0 } +}; + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM130::EmRegsVZPalmM130 +// --------------------------------------------------------------------------- + +EmRegsVZPalmM130::EmRegsVZPalmM130 (void) : + EmRegsVZ (), + fSPISlaveADC (new EmSPISlaveADS784x (kChannelSet1)) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM130::~EmRegsVZPalmM130 +// --------------------------------------------------------------------------- + +EmRegsVZPalmM130::~EmRegsVZPalmM130 (void) +{ + delete fSPISlaveADC; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM130::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZPalmM130::GetLCDScreenOn (void) +{ + return (READ_REGISTER (portKData) & 0x02) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM130::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZPalmM130::GetLCDBacklightOn (void) +{ + return (READ_REGISTER (portFData) & 0x10) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM130::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmRegsVZPalmM130::GetLineDriverState (EmUARTDeviceType type) +{ + if (type == kUARTSerial) + return (READ_REGISTER (portEData) & 0x40) != 0; + + if (type == kUARTIR) + return (READ_REGISTER (portKData) & hwrVZPalmM130PortKIRShutdown) == 0; + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM130::GetUARTDevice +// --------------------------------------------------------------------------- +// Return what sort of device is hooked up to the given UART. + +EmUARTDeviceType EmRegsVZPalmM130::GetUARTDevice (int uartNum) +{ + Bool serEnabled = this->GetLineDriverState (kUARTSerial); + Bool irEnabled = this->GetLineDriverState (kUARTIR); + + // It's probably an error to have them both enabled at the same + // time. !!! TBD: make this an error message. + + EmAssert (!(serEnabled && irEnabled)); + + if (uartNum == 0) + { + if (irEnabled) + return kUARTIR; + } + else if (uartNum == 1) + { + if (serEnabled) + return kUARTSerial; + } + + return kUARTNone; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM130::GetPortInputValue +// --------------------------------------------------------------------------- +// Return the GPIO values for the pins on the port. These values are used +// if the select pins are high. + +uint8 EmRegsVZPalmM130::GetPortInputValue (int port) +{ + uint8 result = EmRegsVZ::GetPortInputValue (port); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM130::GetPortInternalValue +// --------------------------------------------------------------------------- +// Return the dedicated values for the pins on the port. These values are +// used if the select pins are low. + +uint8 EmRegsVZPalmM130::GetPortInternalValue (int port) +{ + uint8 result = EmRegsVZ::GetPortInternalValue (port); + + if (port == 'D') + { + // Make sure that hwrVZPortDPowerFail is set. If it's clear, + // the battery code will make the device go to sleep immediately. + // + // Also make sure that hwrVZPalmM130PortDTWISTIRQ is set. If it's clear, + // the slot driver will think there's a card installed and will try querying it. + + result |= hwrVZPalmM130PortDPowerFail | hwrVZPalmM130PortDTWISTIRQ; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM130::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmRegsVZPalmM130::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ + *numRows = kNumButtonRows; + *numCols = kNumButtonCols; + + memcpy (keyMap, kButtonMapPalmM130, sizeof (kButtonMapPalmM130)); + + // Determine what row is being asked for. + + UInt8 portKDir = READ_REGISTER (portKDir); + UInt8 portKData = READ_REGISTER (portKData); + + rows[0] = (portKDir & hwrVZPalmM130PortKKbdRow0) != 0 && (portKData & hwrVZPalmM130PortKKbdRow0) == 0; + rows[1] = (portKDir & hwrVZPalmM130PortKKbdRow1) != 0 && (portKData & hwrVZPalmM130PortKKbdRow1) == 0; + rows[2] = (portKDir & hwrVZPalmM130PortKKbdRow2) != 0 && (portKData & hwrVZPalmM130PortKKbdRow2) == 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZPalmM130::GetSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave* EmRegsVZPalmM130::GetSPISlave (void) +{ + if ((READ_REGISTER (portGData) & hwrVZPalmM130PortGADC_CS_N) == 0) + { + return fSPISlaveADC; + } + + return NULL; +} + + +#pragma mark - + +// Given a register (specified by its field name), return its address +// in emulated space. + +#undef addressof +#define addressof(reg) \ + (this->GetAddressStart () + fRegs.offsetof_##reg ()) + + +// Macro to help the installation of handlers for a register. + +#undef INSTALL_HANDLER +#define INSTALL_HANDLER(read, write, reg) \ + this->SetHandler ( (ReadFunction) &EmRegsPLDPalmI705::read, \ + (WriteFunction) &EmRegsPLDPalmI705::write, \ + addressof (reg), \ + fRegs.reg.GetSize ()) + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmI705::EmRegsPLDPalmI705 +// --------------------------------------------------------------------------- + +EmRegsPLDPalmI705::EmRegsPLDPalmI705 (emuptr baseAddr) : + fBaseAddr (baseAddr) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmI705::~EmRegsPLDPalmI705 +// --------------------------------------------------------------------------- + +EmRegsPLDPalmI705::~EmRegsPLDPalmI705 (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmI705::Initialize +// --------------------------------------------------------------------------- + +void EmRegsPLDPalmI705::Initialize (void) +{ + EmRegs::Initialize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmI705::Reset +// --------------------------------------------------------------------------- + +void EmRegsPLDPalmI705::Reset (Bool hardwareReset) +{ + EmRegs::Reset (hardwareReset); + + if (hardwareReset) + { + memset (fRegs.GetPtr (), 0, fRegs.GetSize ()); + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmI705::Save +// --------------------------------------------------------------------------- + +void EmRegsPLDPalmI705::Save (SessionFile& f) +{ + EmRegs::Save (f); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmI705::Load +// --------------------------------------------------------------------------- + +void EmRegsPLDPalmI705::Load (SessionFile& f) +{ + EmRegs::Load (f); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmI705::Dispose +// --------------------------------------------------------------------------- + +void EmRegsPLDPalmI705::Dispose (void) +{ + EmRegs::Dispose (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmI705::GetLEDState +// --------------------------------------------------------------------------- + +uint16 EmRegsPLDPalmI705::GetLEDState (void) +{ + uint16 result = kLEDOff; + + if (fRegs.green_led) + result |= kLEDGreen; + + if (fRegs.red_led) + result |= kLEDRed; + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmI705::SetSubBankHandlers +// --------------------------------------------------------------------------- + +void EmRegsPLDPalmI705::SetSubBankHandlers (void) +{ + // Install base handlers. + + EmRegs::SetSubBankHandlers (); + + // Now add standard/specialized handers for the defined registers. + + INSTALL_HANDLER (StdReadBE, StdWriteBE, todsln3); + INSTALL_HANDLER (StdReadBE, StdWriteBE, green_led); + INSTALL_HANDLER (StdReadBE, StdWriteBE, pin_notify_enable); + INSTALL_HANDLER (StdReadBE, StdWriteBE, red_led); + INSTALL_HANDLER (StdReadBE, StdWriteBE, acpr); + INSTALL_HANDLER (low_battRead, StdWriteBE, low_batt); + INSTALL_HANDLER (StdReadBE, StdWriteBE, dto3svc_irq); + INSTALL_HANDLER (StdReadBE, StdWriteBE, dsp_irq_enable); + INSTALL_HANDLER (StdReadBE, StdWriteBE, dsp_irq_polarity); + INSTALL_HANDLER (StdReadBE, StdWriteBE, charging_in_progress); + INSTALL_HANDLER (StdReadBE, StdWriteBE, charging_in_prog2); + INSTALL_HANDLER (StdReadBE, StdWriteBE, charging_in_prog_OE); + INSTALL_HANDLER (StdReadBE, StdWriteBE, twister_irq_wake); + INSTALL_HANDLER (StdReadBE, StdWriteBE, low_batt_mask); + INSTALL_HANDLER (StdReadBE, StdWriteBE, acpr_mask); + INSTALL_HANDLER (StdReadBE, StdWriteBE, acpr_polarity); + INSTALL_HANDLER (usb_intRead, StdWriteBE, usb_int); + INSTALL_HANDLER (StdReadBE, StdWriteBE, usb_int_mask); + INSTALL_HANDLER (bullet_detRead, StdWriteBE, bullet_det); + INSTALL_HANDLER (StdReadBE, StdWriteBE, bullet_det_mask); + INSTALL_HANDLER (StdReadBE, StdWriteBE, bullet_det_pol); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmI705::GetRealAddress +// --------------------------------------------------------------------------- + +uint8* EmRegsPLDPalmI705::GetRealAddress (emuptr address) +{ + return (uint8*) fRegs.GetPtr () + address - this->GetAddressStart (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmI705::GetAddressStart +// --------------------------------------------------------------------------- + +emuptr EmRegsPLDPalmI705::GetAddressStart (void) +{ + return fBaseAddr; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmI705::GetAddressRange +// --------------------------------------------------------------------------- + +uint32 EmRegsPLDPalmI705::GetAddressRange (void) +{ + return fRegs.GetSize (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmI705::low_battRead +// --------------------------------------------------------------------------- + +uint32 EmRegsPLDPalmI705::low_battRead (emuptr address, int size) +{ + uint32 reg = StdReadBE (address, size); + +#define hwrPLDlow_battOn 0 //this is inverted! +#define hwrPLDlow_battOff 0x80 + + // If we're reading the whole register, or if we're reading the second + // byte, then set the bit that says that the low-battery condition is off. + + if ((size == 2) || ((size == 1) && ((address & 1) == 1))) + { + reg |= hwrPLDlow_battOff; + } + + return reg; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmI705::usb_intRead +// --------------------------------------------------------------------------- + +uint32 EmRegsPLDPalmI705::usb_intRead (emuptr /*address*/, int /*size*/) +{ + // this bit is low-asserted + + return ~0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsPLDPalmI705::bullet_detRead +// --------------------------------------------------------------------------- + +uint32 EmRegsPLDPalmI705::bullet_detRead (emuptr /*address*/, int /*size*/) +{ + // 1 = undocked, 0 = docked + + return ~0; +} + + diff --git a/SrcShared/Hardware/EmRegsVZTemp.h b/SrcShared/Hardware/EmRegsVZTemp.h new file mode 100644 index 0000000..3864ca7 --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZTemp.h @@ -0,0 +1,130 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsVZTemp_h +#define EmRegsVZTemp_h + +#include "EmRegsVZ.h" + +#include "EmPalmStructs.h" // EmProxyHwrPalmI705PLDType + + + +class EmRegsVZPalmI705 : public EmRegsVZ +{ + public: + EmRegsVZPalmI705 (void); + virtual ~EmRegsVZPalmI705 (void); + + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLineDriverState (EmUARTDeviceType type); + virtual EmUARTDeviceType GetUARTDevice (int uartNum); + virtual Bool GetVibrateOn (void); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); + + protected: + virtual EmSPISlave* GetSPISlave (void); + + private: + EmSPISlave* fSPISlaveADC; +}; + + + + +class EmRegsVZPalmM125 : public EmRegsVZ +{ + public: + EmRegsVZPalmM125 (void); + virtual ~EmRegsVZPalmM125 (void); + + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLineDriverState (EmUARTDeviceType type); + virtual EmUARTDeviceType GetUARTDevice (int uartNum); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); + + protected: + virtual EmSPISlave* GetSPISlave (void); + + private: + EmSPISlave* fSPISlaveADC; +}; + + +class EmRegsVZPalmM130 : public EmRegsVZ +{ + public: + EmRegsVZPalmM130 (void); + virtual ~EmRegsVZPalmM130 (void); + + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLineDriverState (EmUARTDeviceType type); + virtual EmUARTDeviceType GetUARTDevice (int uartNum); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); + + protected: + virtual EmSPISlave* GetSPISlave (void); + + private: + EmSPISlave* fSPISlaveADC; +}; + + +class EmRegsPLDPalmI705 : public EmRegs, public EmHALHandler +{ + public: + EmRegsPLDPalmI705 (emuptr); + virtual ~EmRegsPLDPalmI705 (void); + + virtual void Initialize (void); + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + virtual void Dispose (void); + + virtual uint16 GetLEDState (void); + + virtual void SetSubBankHandlers (void); + virtual uint8* GetRealAddress (emuptr address); + virtual emuptr GetAddressStart (void); + virtual uint32 GetAddressRange (void); + + private: + uint32 low_battRead (emuptr address, int size); + uint32 usb_intRead (emuptr address, int size); + uint32 bullet_detRead (emuptr address, int size); + + emuptr fBaseAddr; + EmProxyHwrPalmI705PLDType fRegs; +}; + +typedef EmRegsPLDPalmI705 EmRegsPLDJabba; + + + +#endif /* EmRegsVZTemp_h */ diff --git a/SrcShared/Hardware/EmRegsVZVisorEdge.cpp b/SrcShared/Hardware/EmRegsVZVisorEdge.cpp new file mode 100644 index 0000000..2717990 --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZVisorEdge.cpp @@ -0,0 +1,166 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsEZVisor.h" +#include "EmRegsVZVisorEdge.h" +#include "EmRegsVZPrv.h" + + +// Implementation of register-handling for Visor Edge. Visor Edge is derived +// from Visor Platinum with the following differences: +// - key setup is identical to Visor Prism +// - "LCD Enable On" pin is in a different location +// - backlight pin is active high and in different place + + +/************************************************************************ + * Port B Bit settings + ************************************************************************/ +#define hwrVisorEdgePortBLCDVccOff 0x08 // (L) LCD Vcc +#define hwrVisorEdgePortBLCDAdjOn 0x40 // (H) LCD Contrast Voltage + + +/************************************************************************ + * Port C Bit settings + ************************************************************************/ + + +/************************************************************************ + * Port D Bit settings + ************************************************************************/ +#define hwrVisorEdgePortDKbdCol0On 0x01 // (H) Keyboard Column 0 +#define hwrVisorEdgePortDKbdCol1On 0x02 // (H) Keyboard Column 1 +#define hwrVisorEdgePortDKbdCol2On 0x04 // (H) Keyboard Column 2 + +#define hwrVisorEdgePortDExtPowerOn 0x08 // (H) External power indicator + +#define hwrVisorEdgePortDDock1IrqOff 0x10 // (L) Dock1 interrupt +#define hwrVisorEdgePortDSlotIrqOff 0x20 // (L) Slot Interrupt +#define hwrVisorEdgePortDUsbIrqOff 0x40 // (L) USB Interrupt +#define hwrVisorEdgePortDCardInstIrqOff 0x80 // (L) Card Installed Interrupt + +#define hwrVisorEdgePortDKeyBits 0x07 // (H) All Keyboard Columns + + +/************************************************************************ + * Port E Bit settings + ************************************************************************/ +#define hwrVisorEdgePortESerialTxD 0x20 // ( ) Serial transmit line +#define hwrVisorEdgePortESlotResetOff 0x40 // (L) Slot reset +#define hwrVisorEdgePortEDock2Off 0x80 // (L) Dock2 input + + +/************************************************************************ + * Port F Bit settings + ************************************************************************/ +#define hwrVisorEdgePortFContrast 0x01 // ( ) LCD Contrast PWM output +#define hwrVisorEdgePortFIREnableOff 0x04 // (L) Shutdown IR +#define hwrVisorEdgePortFUsbCsOff 0x80 // (L) USB chip select + + +/************************************************************************ + * Port G Bit settings + ************************************************************************/ +#define hwrVisorEdgePortGUnused0 0x01 // ( ) unused GPIO (after reset) +#define hwrVisorEdgePortGUsbSuspend 0x02 // (X) USB Suspend bit - Output low for active + // - Input for suspend +#define hwrVisorEdgePortGPowerFailIrqOff 0x04 // (L) Power Fail IRQ +#define hwrVisorEdgePortGKbdRow0 0x08 // (H) Keyboard Row 0 +#define hwrVisorEdgePortGKbdRow1 0x10 // (H) Keyboard Row 1 +#define hwrVisorEdgePortGAdcCsOff 0x20 // (L) A/D Select + + +/************************************************************************ + * Port J Bit settings + ************************************************************************/ +#define hwrVisorEdgePortJUnused0 0x01 // (X) unused GPIO +#define hwrVisorEdgePortJUnused1 0x02 // (X) unused GPIO +#define hwrVisorEdgePortJUnused2 0x04 // (X) unused GPIO +#define hwrVisorEdgePortJUnused3 0x08 // (X) unused GPIO +#define hwrVisorEdgePortJSerial2RxD 0x10 // ( ) Serial (UART2) recieve line +#define hwrVisorEdgePortJSerial2TxD 0x20 // ( ) Serial (UART2) transmit line +#define hwrVisorEdgePortJSerial2Rts 0x40 // ( ) Serial (UART2) RTS +#define hwrVisorEdgePortJSerial2Cts 0x80 // ( ) Serial (UART2) CTS + + +/************************************************************************ + * Port K Bit settings + ************************************************************************/ +#define hwrVisorEdgePortKUnused0 0x01 // (X) unused GPIO +#define hwrVisorEdgePortKKbdRow2 0x02 // (H) Keyboard Row 2 +#define hwrVisorEdgePortKUnused2 0x04 // (X) unused GPIO +#define hwrVisorEdgePortKUnused3 0x08 // (X) unused GPIO + +#define hwrVisorEdgePortKLedOn 0x10 // (L) Turn on LED +#define hwrVisorEdgePortKLCDEnableOn 0x20 // (L) Shutdown IR +#define hwrVisorEdgePortKBacklightOn 0x40 // (H) Backlight on/off +#define hwrVisorEdgePortKUsbResetOff 0x80 // (L) USB reset + + +/************************************************************************ + * Port M Bit settings + ************************************************************************/ + +#define hwrVisorEdgePortMChargerOff 0x01 // (L) Assert (drive low) to enable + // charger. Deassert for 1ms + // to restart charger +#define hwrVisorEdgePortMChargerOn 0x04 // (H) Assert (drive high) to enable + // charger. Deassert for 1ms + // to restart charger + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorEdge::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZVisorEdge::GetLCDScreenOn (void) +{ + return (READ_REGISTER (portKData) & hwrVisorEdgePortKLCDEnableOn) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorEdge::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZVisorEdge::GetLCDBacklightOn (void) +{ + return (READ_REGISTER (portKData) & hwrVisorEdgePortKBacklightOn) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorEdge::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmRegsVZVisorEdge::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ + *numRows = kNumButtonRows; + *numCols = kNumButtonCols; + + memcpy (keyMap, kVisorButtonMap, sizeof (kVisorButtonMap)); + + // Determine what row is being asked for. + + UInt8 portKDir = READ_REGISTER (portKDir); + UInt8 portKData = READ_REGISTER (portKData); + + UInt8 portGDir = READ_REGISTER (portGDir); + UInt8 portGData = READ_REGISTER (portGData); + + rows[0] = (portGDir & hwrVisorEdgePortGKbdRow0) != 0 && (portGData & hwrVisorEdgePortGKbdRow0) == 0; + rows[1] = (portGDir & hwrVisorEdgePortGKbdRow1) != 0 && (portGData & hwrVisorEdgePortGKbdRow1) == 0; + rows[2] = (portKDir & hwrVisorEdgePortKKbdRow2) != 0 && (portKData & hwrVisorEdgePortKKbdRow2) == 0; +} diff --git a/SrcShared/Hardware/EmRegsVZVisorEdge.h b/SrcShared/Hardware/EmRegsVZVisorEdge.h new file mode 100644 index 0000000..49cb53e --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZVisorEdge.h @@ -0,0 +1,30 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsVZVisorVisorEdge_h +#define EmRegsVZVisorVisorEdge_h + +#include "EmRegsVZ.h" +#include "EmRegsVZVisorPlatinum.h" + +class EmRegsVZVisorEdge: public EmRegsVZVisorPlatinum +{ + public: + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); + +}; + +#endif /* EmRegsVZVisorVisorEdge_h */ diff --git a/SrcShared/Hardware/EmRegsVZVisorPlatinum.cpp b/SrcShared/Hardware/EmRegsVZVisorPlatinum.cpp new file mode 100644 index 0000000..c6ebb5a --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZVisorPlatinum.cpp @@ -0,0 +1,262 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsVZVisorPlatinum.h" +#include "EmRegsEZVisor.h" +#include "EmRegsVZPrv.h" + +#include "EmSession.h" // GetDevice +#include "EmDevice.h" // HardwareID +#include "EmSPISlaveADS784x.h" // EmSPISlaveADS784x + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZVisor::EmRegsEZVisor +// --------------------------------------------------------------------------- + +EmRegsVZVisorPlatinum::EmRegsVZVisorPlatinum (void) : + EmRegsVZ (), + fSPISlaveADC (new EmSPISlaveADS784x (kChannelSet2)) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsEZVisor::~EmRegsEZVisor +// --------------------------------------------------------------------------- + +EmRegsVZVisorPlatinum::~EmRegsVZVisorPlatinum (void) +{ + delete fSPISlaveADC; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPlatinum::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZVisorPlatinum::GetLCDScreenOn (void) +{ + return (READ_REGISTER (portCData) & hwrLegoPortCLCDEnableOn) != 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPlatinum::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZVisorPlatinum::GetLCDBacklightOn (void) +{ + return (READ_REGISTER (portGData) & hwrLegoPortGBacklightOff) == 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPlatinum::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. + +Bool EmRegsVZVisorPlatinum::GetLineDriverState (EmUARTDeviceType type) +{ + if (type == kUARTSerial) + { + uint16 uControl = READ_REGISTER (uControl); + uint16 uMisc = READ_REGISTER (uMisc); + + return (uControl & hwrEZ328UControlUARTEnable) != 0 && + (uMisc & hwrEZ328UMiscIRDAEn) == 0; + } + + if (type == kUARTIR) + { + uint16 uControl = READ_REGISTER (uControl); + uint16 uMisc = READ_REGISTER (uMisc); + + return (uControl & hwrEZ328UControlUARTEnable) != 0 && + (uMisc & hwrEZ328UMiscIRDAEn) != 0; + } + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPlatinum::GetUARTDevice +// --------------------------------------------------------------------------- +// Return what sort of device is hooked up to the given UART. + +EmUARTDeviceType EmRegsVZVisorPlatinum::GetUARTDevice (int /*uartNum*/) +{ + Bool serEnabled = this->GetLineDriverState (kUARTSerial); + Bool irEnabled = this->GetLineDriverState (kUARTIR); + + // It's probably an error to have them both enabled at the same + // time. !!! TBD: make this an error message. + + EmAssert (!(serEnabled && irEnabled)); + + // !!! Which UART are they using? + +// if (uartNum == ???) + { + if (serEnabled) + return kUARTSerial; + + if (irEnabled) + return kUARTIR; + } + + return kUARTNone; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPlatinum::GetPortInputValue +// --------------------------------------------------------------------------- + +uint8 EmRegsVZVisorPlatinum::GetPortInputValue (int port) +{ + uint8 result = EmRegsVZ::GetPortInputValue (port); + + if (port == 'E') + { + /* + Support the Visor model ID. From Bob Petersen at Handspring: + + The Visor ROM only works with 1 device so far. But, the Visor does have + model detect pins so that future ROMs can work on multiple platforms. The + model input pins are connected to port E, bits 0-2 (E[0-2]). To read them, + you have to drive port G bit 2 low and enable the pullups on port E. + */ + +#define modelOutPin 0x04 // EMUIRQ (IRQ7) +#define modelInPins 0x07 // SPI pins on Visor + + UInt8 portGData = READ_REGISTER (portGData); + UInt8 portGDir = READ_REGISTER (portGDir); + UInt8 portGSelect = READ_REGISTER (portGSelect); + + if (((portGData & modelOutPin) == 0) && + ((portGDir & modelOutPin) == modelOutPin) && + ((portGSelect & modelOutPin) == modelOutPin)) + { + EmDevice device = gSession->GetDevice (); + result |= (~device.HardwareID ()) & modelInPins; // <chg 24-Apr-2000 BP> expects inverse output + } + else + { + // The pin for detecting "in cradle" is hwrLegoPortEDock2Off. It should be low + // if in the serial cradle. If it is high, we assume USB. + // -- Bob Petersen + + result &= ~hwrLegoPortEDock2Off; + } + } + else if (port == 'G') + { + // Make sure that hwrLegoPortGPowerFailIrqOff is set. If it's clear, + // the battery code will make the device go to sleep immediately. + + result |= hwrLegoPortGPowerFailIrqOff; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPlatinum::GetPortInternalValue +// --------------------------------------------------------------------------- + +uint8 EmRegsVZVisorPlatinum::GetPortInternalValue (int port) +{ + uint8 result = EmRegsVZ::GetPortInternalValue (port); + + if (port == 'D') + { + // Always set the high bit, indicating that there's no memory module + // installed. From Bob Petersen at Handspring: + // + // This is a probe into the module memory, to check for a replacement ROM on a + // card that is plugged in. The card is mapped to 0x20000000 and the card's + // ROM is at 0x28000000. If it finds the card header (FEEDBEEF) and the card + // is plugged in that has a non-zero reset vector, the chip selects are changed + // so B0 addresses 10c00000, and then we jump to the reset vector and boot off + // the card. + // + // This part of the boot code should only be called if it is detected that a + // card is currently plugged in (bit 7 of port D) and we aren't currently + // booting from the card. + + result |= hwrLegoPortDCardInstIrqOff; + + // Ensure that bit hwrLegoPortDDock1IrqOff is set. If it's clear, HotSync + // will sync via the modem instead of the serial port. + + result |= hwrLegoPortDDock1IrqOff; + } + else if (port == 'G') + { + // Make sure that hwrLegoPortGPowerFailIrqOff is set. If it's clear, + // the battery code will make the device go to sleep immediately. + + result |= hwrLegoPortGPowerFailIrqOff; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPlatinum::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmRegsVZVisorPlatinum::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ + *numRows = kNumButtonRows; + *numCols = kNumButtonCols; + + memcpy (keyMap, kVisorButtonMap, sizeof (kVisorButtonMap)); + + // Determine what row is being asked for. + + UInt8 portDDir = READ_REGISTER (portDDir); + UInt8 portDData = READ_REGISTER (portDData); + + UInt8 portGDir = READ_REGISTER (portGDir); + UInt8 portGData = READ_REGISTER (portGData); + + rows[0] = (portGDir & hwrLegoPortGKbdRow0) != 0 && (portGData & hwrLegoPortGKbdRow0) == 0; + rows[1] = (portGDir & hwrLegoPortGKbdRow1) != 0 && (portGData & hwrLegoPortGKbdRow1) == 0; + rows[2] = (portDDir & hwrLegoPortDKbdRow2) != 0 && (portDData & hwrLegoPortDKbdRow2) == 0; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPlatinum::GetSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave* EmRegsVZVisorPlatinum::GetSPISlave (void) +{ + if ((READ_REGISTER (portGData) & hwrLegoPortGAdcCsOff) == 0) + { + return fSPISlaveADC; + } + + return NULL; +} + + diff --git a/SrcShared/Hardware/EmRegsVZVisorPlatinum.h b/SrcShared/Hardware/EmRegsVZVisorPlatinum.h new file mode 100644 index 0000000..b2aafa9 --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZVisorPlatinum.h @@ -0,0 +1,43 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsVZVisorPlatinum_h +#define EmRegsVZVisorPlatinum_h + +#include "EmRegsVZ.h" + + +class EmRegsVZVisorPlatinum : public EmRegsVZ +{ + public: + EmRegsVZVisorPlatinum (); + ~EmRegsVZVisorPlatinum (); + + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLineDriverState (EmUARTDeviceType type); + virtual EmUARTDeviceType GetUARTDevice (int uartNum); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); + + protected: + virtual EmSPISlave* GetSPISlave (void); + + private: + EmSPISlave* fSPISlaveADC; +}; + +#endif /* EmRegsVZVisorPlatinum_h */ diff --git a/SrcShared/Hardware/EmRegsVZVisorPrism.cpp b/SrcShared/Hardware/EmRegsVZVisorPrism.cpp new file mode 100644 index 0000000..6c73779 --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZVisorPrism.cpp @@ -0,0 +1,393 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmRegsVZVisorPrism.h" +#include "EmRegsVZPrv.h" + +#include "EmRegsSED1376.h" // SED1376 video controller register access + +#include "EmSession.h" // GetDevice +#include "EmDevice.h" // HardwareID + + +// Prism pin definitions from Handspring. Mostly the same as a Palm V, +// but with some pins changed and moved around. + + +/************************************************************************ + * Port B Bit settings + ************************************************************************/ +#define hwrVisorPrismPortBLCDVccOff 0x08 // (L) LCD Vcc +#define hwrVisorPrismPortBLCDAdjOn 0x40 // (H) LCD Contrast Voltage + + +/************************************************************************ + * Port C Bit settings + ************************************************************************/ +#define hwrVisorPrismPortCLCDEnableOn 0x80 // (H) LCD Enable + + +/************************************************************************ + * Port D Bit settings + ************************************************************************/ +#define hwrVisorPrismPortDKbdCol0On 0x01 // (H) Keyboard Column 0 +#define hwrVisorPrismPortDKbdCol1On 0x02 // (H) Keyboard Column 1 +#define hwrVisorPrismPortDKbdCol2On 0x04 // (H) Keyboard Column 2 + +// Not here! See hwrVisorPrismPortKKbdRow2 +// #define hwrVisorPrismPortDKbdRow2 0x08 // (H) Keyboard Row 2 + +#define hwrVisorPrismPortDDock1IrqOff 0x10 // (L) Dock1 interrupt +#define hwrVisorPrismPortDSlotIrqOff 0x20 // (L) Slot Interrupt +#define hwrVisorPrismPortDUsbIrqOff 0x40 // (L) USB Interrupt +#define hwrVisorPrismPortDCardInstIrqOff 0x80 // (L) Card Installed Interrupt + +#define hwrVisorPrismPortDKeyBits 0x07 // (H) All Keyboard Columns + + + +/************************************************************************ + * Port E Bit settings + ************************************************************************/ +#define hwrVisorPrismPortESerialTxD 0x20 // ( ) Serial transmit line +#define hwrVisorPrismPortESlotResetOff 0x40 // (L) Slot reset +#define hwrVisorPrismPortEDock2Off 0x80 // (L) Dock2 input + + +/************************************************************************ + * Port F Bit settings + ************************************************************************/ +#define hwrVisorPrismPortFContrast 0x01 // ( ) LCD Contrast PWM output +#define hwrVisorPrismPortFIREnableOff 0x04 // (L) Shutdown IR +#define hwrVisorPrismPortFUsbCsOff 0x80 // (L) USB chip select + + +/************************************************************************ + * Port G Bit settings + ************************************************************************/ +#define hwrVisorPrismPortGBacklightOff 0x01 // (L) Backlight on/off +#define hwrVisorPrismPortGUSBSuspend 0x02 // (X) USB Suspend bit - Output low for active + // - Input for suspend +#define hwrVisorPrismPortGPowerFailIrqOff 0x04 // (L) Power Fail IRQ +#define hwrVisorPrismPortGKbdRow0 0x08 // (H) Keyboard Row 0 +#define hwrVisorPrismPortGKbdRow1 0x10 // (H) Keyboard Row 1 +#define hwrVisorPrismPortGAdcCsOff 0x20 // (L) A/D Select + + +/************************************************************************ + * Port J Bit settings + ************************************************************************/ +#define hwrVisorPrismPortJEepromDi 0x01 // (H) EEPROM Data in +#define hwrVisorPrismPortJEepromDo 0x02 // ( ) EEPROM Data out +#define hwrVisorPrismPortJEepromSkOn 0x04 // (H) EEPROM Clock +#define hwrVisorPrismPortJEepromCsOn 0x08 // (H) EEPROM Chip Select +#define hwrVisorPrismPortJUnused4 0x10 // (H) unused GPIO +#define hwrVisorPrismPortJUnused5 0x20 // (H) unused GPIO +#define hwrVisorPrismPortJUnused6 0x40 // (H) unused GPIO +#define hwrVisorPrismPortJUnused7 0x80 // (H) unused GPIO + + +/************************************************************************ + * Port K Bit settings + ************************************************************************/ +#define hwrVisorPrismPortKBrightnessPWMOff 0x01 // (L) Brightness PWM output +#define hwrVisorPrismPortKKbdRow2 0x02 // (H) Keyboard Row 2 +#define hwrVisorPrismPortKUnused2 0x04 // (X) unused GPIO +#define hwrVisorPrismPortKIREnableBOff 0x08 // (L) Shutdown IR on DVT and later + +#define hwrVisorPrismPortKLcdResetOff 0x10 // (L) LCD reset +#define hwrVisorPrismPortKIREnableAOff 0x20 // (L) Shutdown IR on pre-DVT +#define hwrVisorPrismPortKUnused6 0x40 // (H) unused GPIO +#define hwrVisorPrismPortKUsbResetOff 0x80 // (L) USB reset + + +/************************************************************************ + * Port M Bit settings + ************************************************************************/ + + + +/************************************************************************ + * Hard key settings + ************************************************************************/ + +const int kNumButtonRows = 3; +const int kNumButtonCols = 3; + +const uint16 kButtonMap[kNumButtonRows][kNumButtonCols] = +{ + { keyBitHard1, keyBitHard2, keyBitHard3 }, + { keyBitPageUp, keyBitPageDown, 0 }, + { keyBitPower, keyBitHard4, 0 } +}; + + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPrism::GetLCDScreenOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZVisorPrism::GetLCDScreenOn (void) +{ + // Override the Dragonball version and let the SED 1376 handle it. + + return EmHALHandler::GetLCDScreenOn (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPrism::GetLCDBacklightOn +// --------------------------------------------------------------------------- + +Bool EmRegsVZVisorPrism::GetLCDBacklightOn (void) +{ + // Override the Dragonball version and let the SED 1376 handle it. + + return EmHALHandler::GetLCDBacklightOn (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPrism::GetLCDHasFrame +// --------------------------------------------------------------------------- + +Bool EmRegsVZVisorPrism::GetLCDHasFrame (void) +{ + // Override the Dragonball version and let the SED 1376 handle it. + + return EmHALHandler::GetLCDHasFrame (); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPrism::GetLCDBeginEnd +// --------------------------------------------------------------------------- + +void EmRegsVZVisorPrism::GetLCDBeginEnd (emuptr& begin, emuptr& end) +{ + // Override the Dragonball version and let the SED 1376 handle it. + + EmHALHandler::GetLCDBeginEnd (begin, end); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPrism::GetLCDScanlines +// --------------------------------------------------------------------------- + +void EmRegsVZVisorPrism::GetLCDScanlines (EmScreenUpdateInfo& info) +{ + // Override the Dragonball version and let the SED 1376 handle it. + + EmHALHandler::GetLCDScanlines (info); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPrism::GetLineDriverState +// --------------------------------------------------------------------------- +// Return whether or not the line drivers for the given object are open or +// closed. +// +// DOLATER BP: this way of detecting SerialPortOn may be wrong. +// See PalmIIIc or PalmV. It may impact Visor emulation as well + +Bool EmRegsVZVisorPrism::GetLineDriverState (EmUARTDeviceType type) +{ + if (type == kUARTSerial) + { + uint16 uControl = READ_REGISTER (uControl); + uint16 uMisc = READ_REGISTER (uMisc); + + return (uControl & hwrEZ328UControlUARTEnable) != 0 && + (uMisc & hwrEZ328UMiscIRDAEn) == 0; + } + + if (type == kUARTIR) + { + uint16 uControl = READ_REGISTER (uControl); + uint16 uMisc = READ_REGISTER (uMisc); + + return (uControl & hwrEZ328UControlUARTEnable) != 0 && + (uMisc & hwrEZ328UMiscIRDAEn) != 0; + } + + return false; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPrism::GetUARTDevice +// --------------------------------------------------------------------------- +// Return what sort of device is hooked up to the given UART. + +EmUARTDeviceType EmRegsVZVisorPrism::GetUARTDevice (int /*uartNum*/) +{ + Bool serEnabled = this->GetLineDriverState (kUARTSerial); + Bool irEnabled = this->GetLineDriverState (kUARTIR); + + // It's probably an error to have them both enabled at the same + // time. !!! TBD: make this an error message. + + EmAssert (!(serEnabled && irEnabled)); + + // !!! Which UART are they using? + +// if (uartNum == ???) + { + if (serEnabled) + return kUARTSerial; + + if (irEnabled) + return kUARTIR; + } + + return kUARTNone; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPrism::GetPortInputValue +// +// Returns the GPIO value of the given port. +// --------------------------------------------------------------------------- + +uint8 EmRegsVZVisorPrism::GetPortInputValue (int port) +{ + uint8 result = EmRegsVZ::GetPortInputValue (port); + + if (port == 'E') + { + /* + Support the Visor model ID. From Bob Petersen at Handspring: + + The Visor ROM only works with 1 device so far. But, the Visor does have + model detect pins so that future ROMs can work on multiple platforms. The + model input pins are connected to port E, bits 0-2 (E[0-2]). To read them, + you have to drive port G bit 2 low and enable the pullups on port E. + */ + +#define modelOutPin 0x04 // EMUIRQ (IRQ7) +#define modelInPins 0x07 // SPI pins on Visor + + UInt8 portGData = READ_REGISTER (portGData); + UInt8 portGDir = READ_REGISTER (portGDir); + UInt8 portGSelect = READ_REGISTER (portGSelect); + + if (((portGData & modelOutPin) == 0) && + ((portGDir & modelOutPin) == modelOutPin) && + ((portGSelect & modelOutPin) == modelOutPin)) + { + EmDevice device = gSession->GetDevice (); + result |= (~device.HardwareID ()) & modelInPins; // <chg 24-Apr-2000 BP> expects inverse output + } + else + { + // The pin for detecting "in cradle" is hwrVisorPrismPortEDock2Off. It should be low + // if in the serial cradle. If it is high, we assume USB. + // -- Bob Petersen + + result &= ~hwrVisorPrismPortEDock2Off; + } + } + else if (port == 'G') + { + // Make sure that hwrVisorPrismPortGPowerFailIrqOff is set. If it's clear, + // the battery code will make the device go to sleep immediately. + + result |= hwrVisorPrismPortGPowerFailIrqOff; + } + + else if (port == 'J') + { + // Make sure this bit is set, which means the EEPROM has finished being read. + // Otherwise we will loop indefinitely as the OS polls this port. + + result |= hwrVisorPrismPortJEepromDo; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPrism::GetPortInternalValue +// +// Returns the "dedicated" pin value of the given port. +// --------------------------------------------------------------------------- + +uint8 EmRegsVZVisorPrism::GetPortInternalValue (int port) +{ + uint8 result = EmRegsVZ::GetPortInternalValue (port); + + if (port == 'D') + { + // Always set the high bit, indicating that there's no memory module + // installed. From Bob Petersen at Handspring: + // + // This is a probe into the module memory, to check for a replacement ROM on a + // card that is plugged in. The card is mapped to 0x20000000 and the card's + // ROM is at 0x28000000. If it finds the card header (FEEDBEEF) and the card + // is plugged in that has a non-zero reset vector, the chip selects are changed + // so B0 addresses 10c00000, and then we jump to the reset vector and boot off + // the card. + // + // This part of the boot code should only be called if it is detected that a + // card is currently plugged in (bit 7 of port D) and we aren't currently + // booting from the card. + + result |= hwrVisorPrismPortDCardInstIrqOff; + + // Ensure that bit hwrVisorPrismPortDDock1IrqOff is set. If it's clear, HotSync + // will sync via the modem instead of the serial port. + + result |= hwrVisorPrismPortDDock1IrqOff; + } + else if (port == 'G') + { + // Make sure that hwrVisorPrismPortGPowerFailIrqOff is set. If it's clear, + // the battery code will make the device go to sleep immediately. + + result |= hwrVisorPrismPortGPowerFailIrqOff; + } + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsVZVisorPrism::GetKeyInfo +// --------------------------------------------------------------------------- + +void EmRegsVZVisorPrism::GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows) +{ + *numRows = kNumButtonRows; + *numCols = kNumButtonCols; + + memcpy (keyMap, kButtonMap, sizeof (kButtonMap)); + + // Determine what row is being asked for. + + UInt8 portKDirVZ = READ_REGISTER (portKDir); + UInt8 portKDataVZ = READ_REGISTER (portKData); + + UInt8 portGDir = READ_REGISTER (portGDir); + UInt8 portGData = READ_REGISTER (portGData); + + rows[0] = (portGDir & hwrVisorPrismPortGKbdRow0) != 0 && (portGData & hwrVisorPrismPortGKbdRow0) == 0; + rows[1] = (portGDir & hwrVisorPrismPortGKbdRow1) != 0 && (portGData & hwrVisorPrismPortGKbdRow1) == 0; + rows[2] = (portKDirVZ & hwrVisorPrismPortKKbdRow2) != 0 && (portKDataVZ & hwrVisorPrismPortKKbdRow2) == 0; +} + diff --git a/SrcShared/Hardware/EmRegsVZVisorPrism.h b/SrcShared/Hardware/EmRegsVZVisorPrism.h new file mode 100644 index 0000000..4d9eaf0 --- /dev/null +++ b/SrcShared/Hardware/EmRegsVZVisorPrism.h @@ -0,0 +1,37 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmRegsVZVisorPrism_h +#define EmRegsVZVisorPrism_h + +#include "EmRegsVZ.h" + + +class EmRegsVZVisorPrism : public EmRegsVZ +{ + public: + virtual Bool GetLCDScreenOn (void); + virtual Bool GetLCDBacklightOn (void); + virtual Bool GetLCDHasFrame (void); + virtual void GetLCDBeginEnd (emuptr& begin, emuptr& end); + virtual void GetLCDScanlines (EmScreenUpdateInfo& info); + virtual Bool GetLineDriverState (EmUARTDeviceType type); + virtual EmUARTDeviceType GetUARTDevice (int uartNum); + + virtual uint8 GetPortInputValue (int); + virtual uint8 GetPortInternalValue (int); + virtual void GetKeyInfo (int* numRows, int* numCols, + uint16* keyMap, Bool* rows); +}; + +#endif /* EmRegsVZVisorPrism_h */ diff --git a/SrcShared/Hardware/EmSPISlave.cpp b/SrcShared/Hardware/EmSPISlave.cpp new file mode 100644 index 0000000..9dc7ff6 --- /dev/null +++ b/SrcShared/Hardware/EmSPISlave.cpp @@ -0,0 +1,51 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmSPISlave.h" + + +// --------------------------------------------------------------------------- +// ¥ EmSPISlave::EmSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave::EmSPISlave (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmSPISlave::~EmSPISlave +// --------------------------------------------------------------------------- + +EmSPISlave::~EmSPISlave (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmSPISlave::Enable +// --------------------------------------------------------------------------- + +void EmSPISlave::Enable (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmSPISlave::Disable +// --------------------------------------------------------------------------- + +void EmSPISlave::Disable (void) +{ +} diff --git a/SrcShared/Hardware/EmSPISlave.h b/SrcShared/Hardware/EmSPISlave.h new file mode 100644 index 0000000..1fcb2dd --- /dev/null +++ b/SrcShared/Hardware/EmSPISlave.h @@ -0,0 +1,28 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmSPISlave_h +#define EmSPISlave_h + +class EmSPISlave +{ + public: + EmSPISlave (void); + virtual ~EmSPISlave (void); + + virtual uint16 DoExchange (uint16 control, uint16 data) = 0; + virtual void Enable (void); + virtual void Disable (void); +}; + +#endif // EmSPISlave_h diff --git a/SrcShared/Hardware/EmSPISlaveADS784x.cpp b/SrcShared/Hardware/EmSPISlaveADS784x.cpp new file mode 100644 index 0000000..51960e0 --- /dev/null +++ b/SrcShared/Hardware/EmSPISlaveADS784x.cpp @@ -0,0 +1,428 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmSPISlaveADS784x.h" + +#include "EmLowMem.h" // EmLowMem_GetGlobal +#include "EmMemory.h" // CEnableFullAccess +#include "EmPalmStructs.h" // EmAliasSysBatteryDataStruct + +#include "Logging.h" +#define PRINTF if (1) ; else LogAppendMsg + +/******************************************************************** + * Single-Ended Mode Channel Constants (adcSERDFR = 1) + ********************************************************************/ +#define adcSERTemp0 0x04 // Temperature 0 +#define adcSERYPos 0x14 // Y-Position +#define adcSERBat 0x24 // Battery +#define adcSERZ1Pos 0x34 // Z1-Position +#define adcSERZ2Pos 0x44 // Z2-Position +#define adcSERXPos 0x54 // X-Position +#define adcSERAux 0x64 // Auxilliary +#define adcSERTemp1 0x74 // Temperature 1 + +/******************************************************************** + * Differential Mode Channel Constants (adcSERDFR = 0) + ********************************************************************/ +#define adcDFRYPos 0x10 // Y-Position +#define adcDFRZ1Pos 0x30 // Z1-Position +#define adcDFRZ2Pos 0x40 // Z2-Position +#define adcDFRXPos 0x50 // X-Position + +/******************************************************************** + * Conversion Mode Resolution + ********************************************************************/ +#define adcMode12Bit 0x00 // 12-bit conversion +#define adcMode8Bit 0x08 // 8-bit conversion + +/******************************************************************** + * Power Down Bit Use (for Burr-Brown ADS7846) + ********************************************************************/ +#define adcPDADCOn 0x01 // If set, turn on the ADC converter +#define adcPDReferenceOn 0x02 // If set, the internal Vref reference is turned on + +#define kChannelBits 0x70 + + +// --------------------------------------------------------------------------- +// ¥ EmSPISlaveADS784x::EmSPISlaveADS784x +// --------------------------------------------------------------------------- + +EmSPISlaveADS784x::EmSPISlaveADS784x ( EmADSChannelType ch0, + EmADSChannelType ch1, + EmADSChannelType ch2, + EmADSChannelType ch3, + EmADSChannelType ch4, + EmADSChannelType ch5, + EmADSChannelType ch6, + EmADSChannelType ch7) : + EmSPISlave (), + fBitBufferIn (0), + fBitBufferOut (0), + fNumBitsIn (0), + fPendingResult (0), + fHavePending (false), + fCommandBitsSeen (0) +{ + fChannelUse[0] = ch0; + fChannelUse[1] = ch1; + fChannelUse[2] = ch2; + fChannelUse[3] = ch3; + fChannelUse[4] = ch4; + fChannelUse[5] = ch5; + fChannelUse[6] = ch6; + fChannelUse[7] = ch7; + + // If there's a 7846-style battery, it *must* be on channel 2. + + for (int ii = 0; ii < 8; ++ii) + { + if (fChannelUse[ii] == kChannelBattery7846) + { + EmAssert (ii == 2); + } + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmSPISlaveADS784x::~EmSPISlaveADS784x +// --------------------------------------------------------------------------- + +EmSPISlaveADS784x::~EmSPISlaveADS784x (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmSPISlaveADS784x::DoExchange +// --------------------------------------------------------------------------- + +uint16 EmSPISlaveADS784x::DoExchange (uint16 control, uint16 data) +{ + PRINTF (""); + PRINTF ("EmSPISlaveADS784x::DoExchange"); + PRINTF ("control = 0x%04X, data = 0x%04X", control, data); + + // ----------------------------------------------------------------------- + // Merge the incoming bits with our current buffer. + // ----------------------------------------------------------------------- + + uint16 numBits = (control & hwrVZ328SPIMControlBitsMask) + 1; + uint32 oldBitsMask = ~0 << numBits; + uint32 newBitsMask = ~oldBitsMask; + + PRINTF ("Before merging input: fBitBufferIn = 0x%04X, fNumBitsIn = 0x%04X", fBitBufferIn, fNumBitsIn); + + fBitBufferIn = ((fBitBufferIn << numBits) & oldBitsMask) | (data & newBitsMask); + fNumBitsIn += numBits; + + PRINTF ("After merging input: fBitBufferIn = 0x%04X, fNumBitsIn = 0x%04X", fBitBufferIn, fNumBitsIn); + + // ----------------------------------------------------------------------- + // Start processing the command bits. + // ----------------------------------------------------------------------- + + EmAssert (fNumBitsIn - fCommandBitsSeen - 1 >= 0); + + uint16 result = 0; + uint32 mask = 1 << (fNumBitsIn - fCommandBitsSeen - 1); + + while (mask) + { + // Shift out a bit. + + { + result = (result << 1) | (fBitBufferOut >> 15); + fBitBufferOut <<= 1; + } + + // If we haven't seen the Start bit yet, look for it. + + if (fCommandBitsSeen == 0) + { + // If we found the Start bit, start counting the + // number of command bits as we stream through them. + + if ((mask & fBitBufferIn) != 0) + { + fCommandBitsSeen++; + } + + // Otherwise, adjust fNumBitsIn so that when we *do* + // find the Start bit, we know where it is. + + else + { + fNumBitsIn--; + } + + // If there's a pending conversion, load it into the + // output shift register after receiving the first + // bit after the last bit of the previous command. + + this->LoadPendingConversion (); + } + else + { + fCommandBitsSeen++; + + // If we've seen 8 bits, process the command, and then + // prepare for the next one. + + if (fCommandBitsSeen == 8) + { + fNumBitsIn -= 8; + fCommandBitsSeen = 0; + + uint8 command = fBitBufferIn >> fNumBitsIn; + this->ProcessCommand (command); + + PRINTF ("After ProcessCommand: fPendingResult = 0x%04X", fPendingResult); + } + } + + mask >>= 1; + } + + + // ---------------------------------------------------------------------- + // Return the result. + // ---------------------------------------------------------------------- + + PRINTF ("result = 0x%04X", result); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmSPISlaveADS784x::ProcessCommand +// --------------------------------------------------------------------------- + +void EmSPISlaveADS784x::ProcessCommand (uint8 command) +{ + uint16 result = 0; + + /* + Command format is: + + +-----+-----+-----+-----+-----+-----+-----+-----+ + | S | A2 | A1 | A0 | M | Ref | PD1 | PD0 | + +-----+-----+-----+-----+-----+-----+-----+-----+ + + S = Start Bit. Must be 1. + A2:0 = Channel select bits + M = 12/8 bit mode (1 = 8-bit) + Ref = Single-ended/Differential reference select bit + PD1:0 = Power down mode select bits. + + We care about the A2:0 bits, since they tell us what data + is being asked for. We also care about the M bit, as that + determines how many bits we load into fBitBufferOut. + */ + + int channel = (command & kChannelBits) >> 4; + + EmAssert (channel >= 0 && channel <= 7); + + switch (fChannelUse [channel]) + { + case kChannelPenX: + case kChannelPenY: + { + result = 0; + break; + } + + case kChannelBattery7843: + case kChannelBattery7846: + { + /* + The current batterly level is read with the following: + + currentLevel = PrvAverageBattery ( ); + + PrvAverageBattery() reads the ADC battery value and then + uses a 7/8 averaging method to merge the new value into + previously averaged values. + + "currentLevel" is then used to determine "batteryLevel" + as follows: + + batteryLevel = (((UInt16)currentLevel + (battDataP->sysBattVoltageStepOffset)) + * 100 + (battDataP->sysBattStepsPerVolt)/2) + / (battDataP->sysBattStepsPerVolt); + + "batteryLevel" is then used to search through the sysBattVoltageCurve + array to determine the percent charge. + + Thus, in order to determine the "currentLevel" for a desired + "batteryLevel", we solve for it, getting: + + currentLevel = (batteryLevel * battDataP->sysBattStepsPerVolt + 50) / 100 - + battDataP->sysBattVoltageStepOffset; + + We can then get the "batteryLevel" from the voltage curve + array in the battery table. For example, for a 100% charge, + read sysBattVoltageCurve[10]. + */ + + CEnableFullAccess munge; + + // Get a pointer to the system battery globals and determine + // what version table we're using. + + emuptr sysBatteryDataP = EmLowMem_GetGlobal (sysBatteryDataP); + + if (sysBatteryDataP) + { + EmAliasSysBatteryDataStructV1<PAS> sysBatteryData (sysBatteryDataP); + + UInt16 sysBattDataStructVersion = sysBatteryData.sysBattDataStructVersion; + + if (sysBattDataStructVersion <= 3) + { + UInt16 voltageCurve = 0; + UInt16 sysBattStepsPerVolt = 0; + Int16 sysBattVoltageStepOffset = 0; + + // Fill out the above variables from the system battery globals, + // sorting out table version differences. + + if (sysBattDataStructVersion == 1) + { + EmAliasSysBatteryDataStructV1<PAS> sysBatteryDataV1 (sysBatteryDataP); + + voltageCurve = sysBatteryDataV1.sysBattVoltageCurve[10]; + sysBattStepsPerVolt = sysBatteryDataV1.sysBattStepsPerVolt; + sysBattVoltageStepOffset = sysBatteryDataV1.sysBattVoltageStepOffset; + } + else if (sysBattDataStructVersion == 2) + { + EmAliasSysBatteryDataStructV2<PAS> sysBatteryDataV2 (sysBatteryDataP); + + voltageCurve = sysBatteryDataV2.sysBattVoltageCurve[10]; + sysBattStepsPerVolt = sysBatteryDataV2.sysBattStepsPerVolt; + sysBattVoltageStepOffset = sysBatteryDataV2.sysBattVoltageStepOffset; + } + else if (sysBattDataStructVersion == 3) + { + EmAliasSysBatteryDataStructV3<PAS> sysBatteryDataV3 (sysBatteryDataP); + + voltageCurve = sysBatteryDataV3.sysBattVoltageCurve[10]; + sysBattStepsPerVolt = sysBatteryDataV3.sysBattStepsPerVolt; + sysBattVoltageStepOffset = sysBatteryDataV3.sysBattVoltageStepOffset; + } + else + { + EmAssert (false); + } + + PRINTF ("voltageCurve = %d", voltageCurve); + PRINTF ("sysBattStepsPerVolt = %d", sysBattStepsPerVolt); + PRINTF ("sysBattVoltageStepOffset = %d", sysBattVoltageStepOffset); + + // Determine the result based on the formula in the comments above. + + result = (voltageCurve * + sysBattStepsPerVolt + 50) / 100 - + sysBattVoltageStepOffset; + + // Turn this into a 12 bit result. + + result <<= 4; + + if (fChannelUse [channel] == kChannelBattery7846) + { + result *= 2; // Account for the fact that the Palm OS battery + // tables assume a 5.0V reference voltage, while + // the 7846 uses 2.5V. (?) + result /= 4; // Account for 1:4 voltage divider + } + } + else + { + result = 0x0FFF; + } + } + else + { + result = 0x0FFF; + } + + PRINTF ("result = 0x%04X", result); + break; + } + + case kChannelDockSerial: + { + // Say that we're undocked. + + result = 0x0000; + break; + } + + case kChannelDockTwister: + { + // Say that we're undocked. + + result = 0x0FFF; + break; + } + + case kChannelTemp0: + { + result = 0x0FFF; // !!! Dummy value; need to determine real value + break; + } + + case kChannelTemp1: + { + result = 0x0FFF; // !!! Dummy value; need to determine real value + break; + } + + default: + EmAssert (false); + break; + } + + fPendingResult = result << 4; + fHavePending = true; +} + + +// --------------------------------------------------------------------------- +// ¥ EmSPISlaveADS784x::LoadPendingConversion +// --------------------------------------------------------------------------- + +void EmSPISlaveADS784x::LoadPendingConversion (void) +{ + // ----------------------------------------------------------------------- + // If there's a pending conversion, move it into the output shift register. + // ----------------------------------------------------------------------- + + if (fHavePending) + { + PRINTF ("Before merging pending: fBitBufferOut = 0x%04X", fBitBufferOut); + + fHavePending = false; + fBitBufferOut = fPendingResult; + + PRINTF ("After merging pending: fBitBufferOut = 0x%04X", fBitBufferOut); + } +} + diff --git a/SrcShared/Hardware/EmSPISlaveADS784x.h b/SrcShared/Hardware/EmSPISlaveADS784x.h new file mode 100644 index 0000000..318e44c --- /dev/null +++ b/SrcShared/Hardware/EmSPISlaveADS784x.h @@ -0,0 +1,97 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmSPISlaveADS784x_h +#define EmSPISlaveADS784x_h + +#include "EmSPISlave.h" // EmSPISlave + +enum EmADSChannelType +{ + kChannelUnused, + kChannelPenX, + kChannelPenY, + kChannelBattery7843, + kChannelBattery7846, + kChannelDockSerial, + kChannelDockTwister, + kChannelTemp0, + kChannelTemp1 +}; + + +#define kChannelSet1 \ + kChannelTemp0, \ + kChannelPenY, \ + kChannelBattery7846, \ + kChannelUnused, \ + kChannelUnused, \ + kChannelPenX, \ + kChannelDockTwister, \ + kChannelTemp1 + + +#define kChannelSet2 \ + kChannelUnused, \ + kChannelPenY, \ + kChannelBattery7843, \ + kChannelUnused, \ + kChannelUnused, \ + kChannelPenX, \ + kChannelDockSerial, \ + kChannelUnused + + +#define kChannelSet3 \ + kChannelUnused, \ + kChannelPenY, \ + kChannelBattery7843, \ + kChannelUnused, \ + kChannelUnused, \ + kChannelPenX, \ + kChannelDockTwister, \ + kChannelUnused + + +class EmSPISlaveADS784x : public EmSPISlave +{ + public: + EmSPISlaveADS784x (EmADSChannelType ch0, + EmADSChannelType ch1, + EmADSChannelType ch2, + EmADSChannelType ch3, + EmADSChannelType ch4, + EmADSChannelType ch5, + EmADSChannelType ch6, + EmADSChannelType ch7); + virtual ~EmSPISlaveADS784x (void); + + virtual uint16 DoExchange (uint16 control, uint16 data); + + protected: + void ProcessCommand (uint8); + void LoadPendingConversion (void); + + private: + EmADSChannelType fChannelUse[8]; + + uint32 fBitBufferIn; + uint16 fBitBufferOut; + int fNumBitsIn; + uint16 fPendingResult; + Bool fHavePending; + + int fCommandBitsSeen; +}; + +#endif // EmSPISlaveADS784x_h diff --git a/SrcShared/Hardware/EmUAEGlue.cpp b/SrcShared/Hardware/EmUAEGlue.cpp new file mode 100644 index 0000000..351fa43 --- /dev/null +++ b/SrcShared/Hardware/EmUAEGlue.cpp @@ -0,0 +1,166 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1999-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmUAEGlue.h" + +#include "EmCPU68K.h" // ProcessException, etc. +#include "EmSession.h" // gSession->Reset +#include "Platform.h" // AllocateMemory +#include "UAE.h" // MakeSR, uae_s32, etc. + + +// --------------------------------------------------------------------------- +// Glue functions to bridge from UAE-generated code to the implemenations +// we define. +// --------------------------------------------------------------------------- + +void customreset (void) +{ + EmAssert (gSession); + + gSession->ScheduleReset (kResetSoft); +} + + +void Exception (int nr, emuptr /*oldpc*/) +{ + EmAssert (gCPU68K); + + gCPU68K->ProcessException ((ExceptionNumber) nr); +} + + +unsigned long op_illg (uint32 iOpcode) +{ + EmAssert (gCPU68K); + + gCPU68K->ProcessIllegalInstruction (iOpcode); + return 0; +} + + +void Software_ProcessLINK (int32 linkSize) +{ + EmAssert (gCPU68K); + + gCPU68K->ProcessLINK (linkSize); +} + + +int Software_ProcessRTS (emuptr dest) +{ + EmAssert (gCPU68K); + + gCPU68K->CheckNewPC (dest); + return gCPU68K->ProcessRTS (dest); +} + + +int Software_ProcessRTE (emuptr dest) +{ + EmAssert (gCPU68K); + + gCPU68K->CheckNewPC (dest); + return gCPU68K->ProcessRTE (dest); +} + + +int Software_ProcessJSR (emuptr oldpc, emuptr dest) +{ + EmAssert (gCPU68K); + + gCPU68K->CheckNewPC (dest); + return gCPU68K->ProcessJSR (oldpc, dest); +} + + +int Software_ProcessJSR_Ind (emuptr oldpc, emuptr dest) +{ + EmAssert (gCPU68K); + + return gCPU68K->ProcessJSR_Ind (oldpc, dest); +} + + +void Software_CheckNewPC (emuptr dest) +{ + EmAssert (gCPU68K); + + gCPU68K->CheckNewPC (dest); +} + + +void Software_CheckStackPointerAssignment () +{ + EmAssert (gCPU68K); + + gCPU68K->CheckNewSP (kStackPointerChanged); +} + + +void Software_CheckStackPointerDecrement () +{ + EmAssert (gCPU68K); + + gCPU68K->CheckNewSP (kStackPointerDecremented); +} + + +void Software_CheckStackPointerIncrement () +{ + EmAssert (gCPU68K); + + gCPU68K->CheckNewSP (kStackPointerIncremented); +} + + +void Software_CheckKernelStack () +{ + EmAssert (gCPU68K); + + gCPU68K->CheckNewSP (kStackPointerKernelStackHack); +} + + +void MakeSR (void) +{ + EmAssert (gCPU68K); + + gCPU68K->UpdateSRFromRegisters (); +} + + +void MakeFromSR (void) +{ + EmAssert (gCPU68K); + + gCPU68K->UpdateRegistersFromSR (); +} + + +void* xmalloc (size_t size) +{ + return Platform::AllocateMemory (size); +} + +uint32 get_disp_ea_000 (uint32 base, uint32 dp) +{ + int reg = (dp >> 12) & 15; + uae_s32 regd = regs.regs[reg]; + + if ((dp & 0x800) == 0) + regd = (uae_s32)(uae_s16)regd; + + return base + (uae_s8)dp + regd; +} diff --git a/SrcShared/Hardware/EmUAEGlue.h b/SrcShared/Hardware/EmUAEGlue.h new file mode 100644 index 0000000..cef39b8 --- /dev/null +++ b/SrcShared/Hardware/EmUAEGlue.h @@ -0,0 +1,17 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1999-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmUAEGlue_h +#define EmUAEGlue_h + +#endif /* EmUAEGlue_h */ diff --git a/SrcShared/Hardware/EmUARTDragonball.cpp b/SrcShared/Hardware/EmUARTDragonball.cpp new file mode 100644 index 0000000..40d6ac3 --- /dev/null +++ b/SrcShared/Hardware/EmUARTDragonball.cpp @@ -0,0 +1,936 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1998-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmUARTDragonball.h" + +#include "EmHAL.h" // EmHAL, EmUARTDeviceType +#include "EmTransportSerial.h" // EmTransportSerial +#include "Logging.h" // LogAppendMsg +#include "Preferences.h" // gEmuPrefs +#include "ErrorHandling.h" // ReportErrCommPort + + +/* + This module contains the routines for handling serial I/O. It + is responsible for responding to changes in state enacted by + software (from either the OS or user), and for dealing with + the actual transmission and reception of serial data. + + There are four ways in which serial activity could occur: something + could write to a UART register, something could read from a UART + register, a byte could be received from the host serial port, or + a byte could be sent out the host serial port. Here is what + happens on each of those events. + + Something reads a UART register: + - If the register is the RX_DATA register, clear the DATA_READY bit + - Make sure the state is up-to-date (including interrupts) + - Return the register contents + + Something writes to a UART register: + - Update the writable parts of the register + - React to any changes + - Make sure the state is up-to-date (including interrupts) + + Data appears at the host serial port: + - Post the byte to the RX FIFO (if there is room) + - Make sure the state is up-to-date (including interrupts) + + Data needs to be sent to the host serial port: + - Send the first byte in the TX FIFO + - Make sure the state is up-to-date (including interrupts) +*/ + + +// ====================================================================== +// Private functions +// ====================================================================== + +static const int kMaxFifoSize = 64; + +static Bool PrvPinBaud (EmTransportSerial::Baud& newBaud); +static Bool PrvPinBaud (EmTransportSerial::Baud& newBaud, + EmTransportSerial::Baud testBaud); + +#define PRINTF if (!LogSerial ()) ; else LogAppendMsg + + +/*********************************************************************** + * + * FUNCTION: EmUARTDragonball::EmUARTDragonball + * + * DESCRIPTION: . + * + * PARAMETERS: type - the type of UART to emulate. The Dragonball + * and DragonballEZ UARTs are similar enough that we + * can handle them both here with just a few tests in + * the places where they differ. + * + * RETURNED: nothing + * + ***********************************************************************/ + +EmUARTDragonball::EmUARTDragonball (UART_Type type, int uartNum) : + fUARTNum (uartNum), + fState (type), + fRxFIFO (this->PrvFIFOSize (true)), + fTxFIFO (this->PrvFIFOSize (false)) +{ +} + + +/*********************************************************************** + * + * FUNCTION: EmUARTDragonball::~EmUARTDragonball + * + * DESCRIPTION: . + * + * PARAMETERS: none. + * + * RETURNED: nothing + * + ***********************************************************************/ + +EmUARTDragonball::~EmUARTDragonball (void) +{ + // All line drivers are effectively disabled, so close the transports. + + for (EmUARTDeviceType ii = kUARTBegin; ii < kUARTEnd; ++ii) + { + EmTransport* transport = gEmuPrefs->GetTransportForDevice (ii); + + if (transport) + { + transport->Close (); + } + } +} + + +/*********************************************************************** + * + * FUNCTION: EmUARTDragonball::StateChanged + * + * DESCRIPTION: . + * + * PARAMETERS: none. + * + * RETURNED: nothing + * + ***********************************************************************/ + +void EmUARTDragonball::StateChanged (State& newState, Bool sendTxData) +{ + EmAssert (fState.UART_TYPE == newState.UART_TYPE); + + // (Changing the configuration is the only place where we assume that + // the transport we're using is a serial transport.) + + EmTransportSerial::ConfigSerial config; + EmTransport* transport = this->GetTransport (); + EmTransportSerial* serTransport = dynamic_cast<EmTransportSerial*> (transport); + + if (serTransport) + { + serTransport->GetConfig (config); + } + + + // ========== RX_ENABLE ========== + // + // This bit enables the receiver block. While this bit is low, the receiver is disabled and the + // receive FIFO is flushed. This bit resets to 0. + + if (fState.RX_ENABLE != newState.RX_ENABLE) + { + if (newState.RX_ENABLE == 0) + { + fRxFIFO.Clear (); + } + } + + + // ========== TX_ENABLE ========== + // + // This bit enables the transmitter block. While this bit is low, the transmitter is disabled and + // the transmit FIFO is flushed. This bit resets to 0. + + if (fState.TX_ENABLE != newState.TX_ENABLE) + { + if (newState.TX_ENABLE == 0) + { + fTxFIFO.Clear (); + } + } + + + // ========== PARITY_EN ========== + // + // This bit controls the parity generator in the transmitter and parity checker in the receiver. + // When this bit is high, they are enabled. When it is low, they are disabled. + // + // ========== ODD_EVEN ========== + // + // This bit controls the sense of the parity generator and checker. When this bit is high, odd + // parity is generated and expected. When this bit is low, even parity is generated and + // expected. This bit has no function if PARITY EN is low. + + if (newState.PARITY_EN == 0) + { + config.fParity = EmTransportSerial::kNoParity; + } + else if (newState.ODD_EVEN) + { + config.fParity = EmTransportSerial::kOddParity; + } + else + { + config.fParity = EmTransportSerial::kEvenParity; + } + + + // ========== STOP_BITS ========= + // + // This bit controls the number of stop bits transmitted after a character. When this bit is high, + // two stop bits are sent. When this bit is low, one stop bit is sent. This bit has no effect on the + // receiver, which expects one or more stop bits. + + config.fStopBits = newState.STOP_BITS ? 2 : 1; + + + // ========== CHAR8_7 ========== + // + // This bit controls the character length. While high, the transmitter and receiver are in 8-bit + // mode. While low, they are in 7-bit mode. The transmitter then ignores B7 and the receiver + // sets B7 to 0. + + config.fDataBits = newState.CHAR8_7 ? 8 : 7; + + + // ========== DIVIDE ========== + // + // These bits control the clock frequency produced by the baud rate generator. + // + // 000 = Divide by 1. + // 001 = Divide by 2. + // 010 = Divide by 4. + // 011 = Divide by 8. + // 100 = Divide by 16. + // 101 = Divide by 32. + // 110 = Divide by 64. + // 111 = Divide by 128. + // + // ========== PRESCALER ========== + // + // These bits control the division value of the baud generator prescaler. The division value is + // determined by the following formula: + // + // Prescaler division value = 65 (decimal) - PRESCALER + + // Baud rate is sysClockFreq / preScaler / divider / 16 + // + // (Using sysClockFreq / (preScaler * divider * 16) might get closer to the + // intended baud (as would using floating point), but does it mirror what + // the hardware actually does?) + + int32 sysClockFreq = EmHAL::GetSystemClockFrequency (); + config.fBaud = sysClockFreq / (65 - newState.PRESCALER) / (1 << newState.DIVIDE) / 16; + + // "newRate" is only approximate to within 0.1%. Pin the value to an + // exact value. + // + // !!! What to do if we can't pin to a valid value? + + (void) PrvPinBaud (config.fBaud); + + + // ========== IGNORE_CTS ========== + // + // When this bit is high, it forces the CTS signal that is presented to the transmitter to always + // be asserted, which effectively ignores the external pin. + + config.fHwrHandshake = newState.IGNORE_CTS == 0; + + + // ========== RTS_CONT ========== + // + // This bit selects the function of the RTS pin. + // + // 0 = RTS pin is controlled by the RTS bit. + // 1 = RTS pin is controlled by the receiver FIFO. When the FIFO is full (one slot is + // remaining), RTS is negated. + // + // ========== RTS ========== + // + // This bit controls the RTS pin while the RTS CONT bit is 0. + // + // 0 = RTS pin is 1. + // 1 = RTS pin is 0. + + if (fState.RTS_CONT != newState.RTS_CONT || + fState.RTS != newState.RTS) + { + if (serTransport) + { + if (newState.RTS_CONT) + { + serTransport->SetRTS (EmTransportSerial::kRTSAuto); + } + else + { + if (newState.RTS) + { + serTransport->SetRTS (EmTransportSerial::kRTSOn); + } + else + { + serTransport->SetRTS (EmTransportSerial::kRTSOff); + } + } + } + } + + + // ========== UART_ENABLE ========== + // + // This bit enables the UART module. When this bit is low, the UART module is disabled and + // in low-power mode. While this bit is high, the UART module is active. This bit resets to 0. + + // ========== IRDA_ENABLE ========== + // + // This bit enables the IrDA interface. + // + // 0 = Normal NRZ operation. + // 1 = IRDA operation. + + if (fState.UART_ENABLE != newState.UART_ENABLE || + fState.IRDA_ENABLE != newState.IRDA_ENABLE) + { + // Nothing to do here. + } + + // Establish the new settings. Do this only when the UART is + // enabled, to help reduce the thrashing on the host serial port, + // and to help prevent the installation of invalid settings (which + // could appear in the UART registers as it's being configured). + + if (newState.UART_ENABLE) + { + if (serTransport) + { + serTransport->SetConfig (config); + } + } + + // ========== SEND_BREAK ========== + // + // This bit forces the transmitter to immediately send continuous zeros creating a break + // character. + + if (fState.SEND_BREAK != newState.SEND_BREAK) + { + if (serTransport) + { + serTransport->SetBreak (newState.SEND_BREAK); + } + } + + + // ========== TX_DATA ========== + // + // These bits are the parallel transmit-data inputs. In 7-bit mode, D7 is ignored and in 8-bit + // mode, all of the bits are used. Data is transmitted LSB first. A new character is transmitted + // when these bits are written and have passed through the FIFO. + + // ========== LOOP ========== + // + // This bit controls loopback for system testing purposes. When this bit is high, the receiver + // input is internally connected to the transmitter and ignores the RXD pin. The TXD pin is + // unaffected by this bit. + + if (sendTxData && newState.UART_ENABLE && newState.TX_ENABLE) + { + if (newState.LOOP == 0) + { + if (transport && transport->CanWrite ()) // The host serial port is open + { + // With or without hardware handshaking, we'll put data + // in the FIFO, and let the host's handshaking take care + // of when the data is removed from the FIFO. + + if (fTxFIFO.GetFree () > 0) // There's room in the FIFO + { + fTxFIFO.Put (newState.TX_DATA); // so add the data + + // Call TransmitTxFIFO here to send the data we + // just queued up. Doing this is important on the Mac in + // order to send out the data quickly instead of later at + // idle time. + + this->TransmitTxFIFO (transport); + } + } + else // The host serial port is NOT open + { + if (config.fHwrHandshake) // Reflects the state of the IGNORE_CTS bit. + { + // With hardware handshaking, data is sent only when CTS + // is asserted. With no host serial port, we define that + // CTS is never asserted, so the data clogs up the FIFO. + + if (fTxFIFO.GetFree () > 0) // There's room in the FIFO + { + fTxFIFO.Put (newState.TX_DATA); // so add the data + + // Serial port is closed, so don't call Platform::TransmitTxFIFO. + } + } + else + { + // With no hardware handshaking, data is sent whenever it's + // ready. With nowhere to go, we can drop it on the floor. + } + } + } + else // We're in loopback mode. + { + if (fRxFIFO.GetFree () > 0) + { + fRxFIFO.Put (newState.TX_DATA); + } + } + } + + + // Update the state in case any of the above operations have side-effects. + + UpdateState (newState, false); + + + // Remember this for next time. + + fState = newState; +} + + +/*********************************************************************** + * + * FUNCTION: EmUARTDragonball::UpdateState + * + * DESCRIPTION: Receive any data, and update the FIFO state registers. + * + * PARAMETERS: none. + * + * RETURNED: nothing + * + ***********************************************************************/ + +void EmUARTDragonball::UpdateState (State& state, Bool refreshRxData) +{ + EmAssert (fState.UART_TYPE == state.UART_TYPE); + + // Update the RxFIFO if there's been any buffered data. + + EmTransport* transport = this->GetTransport (); + if (transport) + { + this->ReceiveRxFIFO (transport); + } + + // === RX_FIFO_FULL === + // + // This read-only bit indicates that the receiver FIFO is full and may generate an overrun. This + // bit generates a maskable interrupt. + // + // Further, from the overview section of the manual: + // + // If your software has a short interrupt + // latency time, the FIFO FULL interrupt in the Receiver register can be enabled. The FIFO has + // one remaining space available when this interrupt is generated. + + state.RX_FIFO_FULL = fRxFIFO.GetFree () == 0; + + + // === RX_FIFO_HALF === + // + // This read-only bit indicates that the receiver FIFO has four or fewer slots remaining in the + // FIFO. This bit generates a maskable interrupt. + + state.RX_FIFO_HALF = fRxFIFO.GetFree () <= this->PrvLevelMarker (true); + + + // === DATA_READY === + // + // This read-only bit indicates that at least one byte is present in the receive FIFO. The + // character bits are valid only while this bit is set. This bit generates a maskable interrupt. + + state.DATA_READY = fRxFIFO.GetUsed () > 0; + + + // === OLD_DATA === // non-68328 only + // + // This read-only bit indicates that data in the FIFO is older than 30 bit times. It is useful in + // situations where the FIFO FULL or FIFO HALF interrupts are used. If there is data in the + // FIFO, but below the interrupt threshold, a maskable interrupt can be generated to alert the + // software that unread data is present. This bit clears when the character bits are read. + + // Not supported right now. + + + // === OVRUN === + // + // When this read-only bit is high, it indicates that the receiver overwrote data in the FIFO. The + // character with this bit set is valid, but at least one previous character was lost. In normal + // circumstances, this bit should never be set. It indicates that your software is not keeping up + // with the incoming data rate. This bit is updated and valid for each received character. + + // !!! TBD + + + // === FRAME_ERROR === + // + // While high, this read-only bit indicates that the current character had a framing error + // (missing stop bit), indicating the possibility of corrupted data. This bit is updated for each + // character read from the FIFO. + + // !!! TBD + + + // === BREAK === + // + // When this read-only bit is high, it indicates that the current character was detected as a + // BREAK. The data bits are all 0 and the stop bit was also 0. The FRAME ERROR bit will + // always be set when this bit is set. If odd parity is selected, PARITY ERROR will also be set + // along with this bit. This bit is updated and valid with each character read from the FIFO. + + // !!! TBD + + // === PARITY_ERROR === + // + // When this read-only bit is high, it indicates that the current character was detected with a + // parity error, indicating the possibility of corrupted data. This bit is updated and valid with + // each character read from the FIFO. While parity is disabled, this bit always reads zero. + + // !!! TBD + + // === RX_DATA === + // + // These read-only bits are the top receive character in the FIFO. They have no meaning if the + // DATA READY bit is 0. In 7-bit mode, the MSB is forced to 0 and in 8-bit mode, all bits are + // active. + + if (state.DATA_READY && state.UART_ENABLE && state.RX_ENABLE && refreshRxData) + { + state.RX_DATA = fRxFIFO.Get (); + + if (state.CHAR8_7 == 0) + { + state.RX_DATA &= 0x07F; + } + + PRINTF ("UART: Put 0x%02X into RX_DATA.", (uint32) (uint8) state.RX_DATA); + } + + + // === TX_FIFO_EMPTY === + // + // This read-only bit indicates that the transmit FIFO is empty. This bit generates a maskable + // interrupt. + + state.TX_FIFO_EMPTY = fTxFIFO.GetUsed () == 0; + + + // === TX_FIFO_HALF === + // + // This read-only bit indicates that the transmit FIFO is less than half full. This bit generates a + // maskable interrupt. + + state.TX_FIFO_HALF = fTxFIFO.GetUsed () < this->PrvLevelMarker (false); + + + // === TX_AVAIL === + // + // This read-only bit indicates that the transmit FIFO has at least one slot available for data. + // This bit generates a maskable interrupt. + + state.TX_AVAIL = fTxFIFO.GetFree () > 0; + + + // === BUSY === // non-68328 only + // + // When this bit is high, it indicates that the transmitter is busy sending a character. This signal + // is asserted while the transmitter state machine is not idle or the FIFO has data in it. + + state.BUSY = !state.TX_FIFO_EMPTY; + + + // === CTS_STATUS === + // + // This bit indicates the current status of the CTS pin. A "snapshot" of the pin is taken + // immediately before this bit is presented to the data bus. While the IGNORE CTS bit is high, + // this bit can serve as a general-purpose input. + // + // Note that this pin is ACTIVE LOW! That's why the Boolean expression is negated below. + // + // For now, say that it's clear to send if the FIFO is empty + // + // !!! TBD - could be better? + + state.CTS_STATUS = !(fTxFIFO.GetUsed () == 0); + + + // === CTS_DELTA === + // + // When this bit is high, it indicates that the CTS pin changed state and generates a maskable + // interrupt. The current state of the CTS pin is available on the CTS STATUS bit. You can + // generate an immediate interrupt by setting this bit high. The CTS interrupt is cleared by + // writing 0 to this bit. + + // Not supported right now. + + + // Remember this for next time. + + fState = state; +} + + +/*********************************************************************** + * + * FUNCTION: EmUARTDragonball::TransmitTxFIFO + * + * DESCRIPTION: Transmit any bytes in the TX FIFO out the serial port. + * Assumes that the serial port is open. + * + * PARAMETERS: None + * + * RETURNED: Nothing + * + ***********************************************************************/ + +void EmUARTDragonball::TransmitTxFIFO (EmTransport* transport) +{ + EmAssert (transport); + + if (transport->CanWrite ()) + { + // Write out any outgoing bytes. + + ErrCode err = errNone; + char buffer[kMaxFifoSize]; + long spaceInTxFIFO = fTxFIFO.GetUsed (); + + if (spaceInTxFIFO > 0) + { + for (long ii = 0; ii < spaceInTxFIFO; ++ii) + { + buffer[ii] = fTxFIFO.Get (); + } + + if (LogSerialData ()) + LogAppendData (buffer, spaceInTxFIFO, "UART: Transmitted data:"); + else + PRINTF ("UART: Transmitted %ld serial bytes.", spaceInTxFIFO); + + err = transport->Write (spaceInTxFIFO, buffer); + } + } +} + + +/*********************************************************************** + * + * FUNCTION: EmUARTDragonball::ReceiveRxFIFO + * + * DESCRIPTION: Fills up the RX FIFO with as many bytes as it can from + * the host serial port. Assumes that the serial port is + * open. + * + * PARAMETERS: None + * + * RETURNED: Nothing + * + ***********************************************************************/ + +void EmUARTDragonball::ReceiveRxFIFO (EmTransport* transport) +{ + EmAssert (transport); + + if (transport->CanRead ()) + { + // Buffer up any incoming bytes. + + ErrCode err = errNone; + char buffer[kMaxFifoSize]; + long spaceInRxFIFO = fRxFIFO.GetFree (); + + // See how many bytes are waiting. + + long bytesToBuffer = transport->BytesInBuffer (fRxFIFO.GetMaxSize ()); + + // See if we have that much room in the FIFO. If not, limit our read + // to that many bytes. + + if (bytesToBuffer > spaceInRxFIFO) + { + bytesToBuffer = spaceInRxFIFO; + } + + // If there is data waiting in the wings, and the hardware says it's + // OK to receive data, and there's room in the RxFIFO, then receive it. + // + // It's OK to receive data if RTS_CONT is 1. That means that the FIFO + // controls whether or not it's OK to receive data, and that check + // is taken care of with "bytesToBuffer > 0". + // + // If RTS_CONT is zero, then it's OK to receive data if RTS is 1. That + // mean that the /RTS pin is zero, which means OK to receive. + + if (bytesToBuffer > 0 && (fState.RTS_CONT == 1 || fState.RTS == 1)) + { + // If there are still bytes to be read, read them in and insert them + // into the RX FIFO. If the buffer was previously empty, Hardware::Cycle + // will notice that there are now bytes in there and update the + // UART registers. + // + // !!! TBD: Hardware::Cycle is called after every opcode execution. + // Since it is very rare that serial bytes are coming in, the overhead + // incurred for checking to see if there are serial bytes does not pay + // off. We may want to figure out a way to update the UART registers + // here, and take the check out of Hardware::Cycle. I'd do that here, + // but (a) Hardware::Cycle takes a "sleeping" parameter that I'd have + // to determine here, and (b) the similar solution on Windows is more + // difficult, as I'd have to stop the CPU thread, update the registers, + // and restart the thread. + + err = transport->Read (bytesToBuffer, buffer); + + if (err == errNone) + { + // not quite the correct phrase for IR over serial (over TCP) + if (LogSerialData ()) + LogAppendData (buffer, bytesToBuffer, "UART: Received data:"); + else + PRINTF ("UART: Received %ld serial bytes.", bytesToBuffer); + + for (long ii = 0; ii < bytesToBuffer; ++ii) + { + fRxFIFO.Put (buffer[ii]); + } // end loop that puts bytes into FIFO + } // end no-error-from-EmTransport::Read + } // end BytesInBuffer-returned-non-zero + } // end is-serial-port-open +} + + +/*********************************************************************** + * + * FUNCTION: EmUARTDragonball::GetTransport + * + * DESCRIPTION: . + * + * PARAMETERS: . + * + * RETURNED: . + * + ***********************************************************************/ + +EmTransport* EmUARTDragonball::GetTransport (void) +{ + EmUARTDeviceType type = EmHAL::GetUARTDevice (fUARTNum); + EmTransport* transport = gEmuPrefs->GetTransportForDevice (type); + + return transport; +} + + +/*********************************************************************** + * + * FUNCTION: EmUARTDragonball::PrvFIFOSize + * + * DESCRIPTION: . + * + * PARAMETERS: . + * + * RETURNED: . + * + ***********************************************************************/ + +int EmUARTDragonball::PrvFIFOSize (Bool forRX) +{ + int size; + + switch (fState.UART_TYPE) + { + case kUART_Dragonball: + size = 8; + break; + + case kUART_DragonballEZ: + if (forRX) + { + size = 12; + } + else + { + size = 8; + } + break; + + case kUART_DragonballVZ: + if (this->fUARTNum == 0) + { + if (forRX) + { + size = 12; + } + else + { + size = 8; + } + } + else + { + size = 64; + } + break; + + default: + EmAssert (false); + size = 8; + break; + } + + return size; +} + + +/*********************************************************************** + * + * FUNCTION: EmUARTDragonball::PrvLevelMarker + * + * DESCRIPTION: . + * + * PARAMETERS: . + * + * RETURNED: . + * + ***********************************************************************/ + +int EmUARTDragonball::PrvLevelMarker (Bool forRX) +{ + int level = (forRX ? fRxFIFO.GetMaxSize () : fTxFIFO.GetMaxSize ()) / 2; + + switch (fState.UART_TYPE) + { + case kUART_Dragonball: + break; + + case kUART_DragonballEZ: + break; + + case kUART_DragonballVZ: + if (this->fUARTNum == 1) + { + int marker = forRX ? fState.TXFIFO_LEVEL_MARKER : fState.RXFIFO_LEVEL_MARKER; + + if (marker != 0) + { + level = marker * 4; + } + } + break; + + default: + EmAssert (false); + break; + } + + return level; +} + + +/*********************************************************************** + * + * FUNCTION: PrvPinBaud + * + * DESCRIPTION: Pins the given baud value to the test baud value if the + * former is sufficiently close to the latter. + * + * PARAMETERS: newBaud - the value to possibly alter. + * + * testBaud - the value to pin to. + * + * RETURNED: newBaud is changed in place. If it is changed, the + * function returns true. Otherwise, it returns false. + * + ***********************************************************************/ + +Bool PrvPinBaud (EmTransportSerial::Baud& newBaud) +{ + Bool pinned = false; + + if (!pinned) pinned = PrvPinBaud (newBaud, 150); + if (!pinned) pinned = PrvPinBaud (newBaud, 300); + if (!pinned) pinned = PrvPinBaud (newBaud, 600); + if (!pinned) pinned = PrvPinBaud (newBaud, 1200); + if (!pinned) pinned = PrvPinBaud (newBaud, 1800); + if (!pinned) pinned = PrvPinBaud (newBaud, 2400); + if (!pinned) pinned = PrvPinBaud (newBaud, 3600); + if (!pinned) pinned = PrvPinBaud (newBaud, 4800); + if (!pinned) pinned = PrvPinBaud (newBaud, 7200); + if (!pinned) pinned = PrvPinBaud (newBaud, 9600); + if (!pinned) pinned = PrvPinBaud (newBaud, 14400); + if (!pinned) pinned = PrvPinBaud (newBaud, 19200); + if (!pinned) pinned = PrvPinBaud (newBaud, 28800); + if (!pinned) pinned = PrvPinBaud (newBaud, 38400); + if (!pinned) pinned = PrvPinBaud (newBaud, 57600); + if (!pinned) pinned = PrvPinBaud (newBaud, 115200); + if (!pinned) pinned = PrvPinBaud (newBaud, 230400); + + return pinned; +} + + +/*********************************************************************** + * + * FUNCTION: PrvPinBaud + * + * DESCRIPTION: Pins the given baud value to the test baud value if the + * former is sufficiently close to the latter. + * + * PARAMETERS: newBaud - the value to possibly alter. + * + * testBaud - the value to pin to. + * + * RETURNED: newBaud is changed in place. If it is changed, the + * function returns true. Otherwise, it returns false. + * + ***********************************************************************/ + +Bool PrvPinBaud (EmTransportSerial::Baud& newBaud, EmTransportSerial::Baud testBaud) +{ + // Pin to within 2%. The Dragonball reference says that the uBaud + // register should be accurate to within 0.1%, but let's give it + // some slop. + + if (newBaud > (testBaud - (testBaud / 50)) && + newBaud < (testBaud + (testBaud / 50))) + { + newBaud = testBaud; + return true; + } + + return false; +} diff --git a/SrcShared/Hardware/EmUARTDragonball.h b/SrcShared/Hardware/EmUARTDragonball.h new file mode 100644 index 0000000..8c777be --- /dev/null +++ b/SrcShared/Hardware/EmUARTDragonball.h @@ -0,0 +1,149 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 1998-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmUARTDragonball_h +#define EmUARTDragonball_h + +#include "EmThreadSafeQueue.h" // EmByteQueue + +class EmTransport; +class SessionFile; + + +class EmUARTDragonball +{ + public: + enum UART_Type + { + kUART_Dragonball, + kUART_DragonballEZ, + kUART_DragonballVZ, + kUART_DragonballSZ + }; + + struct State + { + State (UART_Type type) { UART_TYPE = type; } + + UART_Type UART_TYPE; + + // + = Supported + // = Unsupported + // -> = Input value + // <- = Output value + + // UART control register bits + // These are all values the user sets; we just look at them. + + /* + -> */ unsigned int UART_ENABLE:1; + /* + -> */ unsigned int RX_ENABLE:1; + /* + -> */ unsigned int TX_ENABLE:1; + /* -> */ unsigned int RX_CLK_CONT:1; + /* + -> */ unsigned int PARITY_EN:1; + /* + -> */ unsigned int ODD_EVEN:1; + /* + -> */ unsigned int STOP_BITS:1; + /* + -> */ unsigned int CHAR8_7:1; + /* -> */ unsigned int GPIO_DELTA_ENABLE:1; // 68328 only + /* -> */ unsigned int OLD_ENABLE:1; // 68EZ328 only + /* -> */ unsigned int CTS_DELTA_ENABLE:1; + /* + -> */ unsigned int RX_FULL_ENABLE:1; + /* + -> */ unsigned int RX_HALF_ENABLE:1; + /* + -> */ unsigned int RX_RDY_ENABLE:1; + /* + -> */ unsigned int TX_EMPTY_ENABLE:1; + /* + -> */ unsigned int TX_HALF_ENABLE:1; + /* + -> */ unsigned int TX_AVAIL_ENABLE:1; + + // Baud control register bits + // These are all values the user sets; we just look at them. + + /* -> */ unsigned int GPIO_DELTA:1; // 68328 only + /* -> */ unsigned int GPIO:1; // 68328 only + /* -> */ unsigned int GPIO_DIR:1; // 68328 only + /* -> */ unsigned int GPIO_SRC:1; // 68328 only + /* -> */ unsigned int UCLK_DIR:1; // 68EZ328 only + /* -> */ unsigned int BAUD_SRC:1; + /* + -> */ unsigned int DIVIDE; + /* + -> */ unsigned int PRESCALER; + + // Receive register bits + // These are all input bits; we set them, not the user. + + /* + <- */ unsigned int RX_FIFO_FULL:1; + /* + <- */ unsigned int RX_FIFO_HALF:1; + /* + <- */ unsigned int DATA_READY:1; + /* <- */ unsigned int OLD_DATA:1; // 68EZ328 only + /* <- */ unsigned int OVRUN:1; + /* <- */ unsigned int FRAME_ERROR:1; + /* <- */ unsigned int BREAK:1; + /* <- */ unsigned int PARITY_ERROR:1; + /* + <- */ unsigned int RX_DATA; + + // Transmitter register bits + // The user sets TX_DATA, IGNORE_CTS, and SEND_BREAK. + // We set the rest. + + /* + <- */ unsigned int TX_FIFO_EMPTY:1; + /* + <- */ unsigned int TX_FIFO_HALF:1; + /* + <- */ unsigned int TX_AVAIL:1; + /* -> */ unsigned int SEND_BREAK:1; + /* + -> */ unsigned int IGNORE_CTS:1; + /* + <- */ unsigned int BUSY:1; // 68EZ328 only + /* + <- */ unsigned int CTS_STATUS:1; + /* <- */ unsigned int CTS_DELTA:1; + /* + -> */ unsigned int TX_DATA; + + // Misc register bits + // These are all values the user sets; we just look at them. + + /* -> */ unsigned int BAUD_TEST:1; // 68EZ328 only + /* -> */ unsigned int CLK_SRC:1; + /* -> */ unsigned int FORCE_PERR:1; + /* + -> */ unsigned int LOOP:1; + /* -> */ unsigned int BAUD_RESET:1; // 68EZ328 only + /* -> */ unsigned int IR_TEST:1; // 68EZ328 only + /* + -> */ unsigned int RTS_CONT:1; + /* + -> */ unsigned int RTS:1; + /* + -> */ unsigned int IRDA_ENABLE:1; + /* -> */ unsigned int IRDA_LOOP:1; + /* -> */ unsigned int RX_POL:1; // 68EZ328 only + /* -> */ unsigned int TX_POL:1; // 68EZ328 only + + // Level Marker Interrupt + + /* + -> */ unsigned int TXFIFO_LEVEL_MARKER:4; // 68SZ328 only + /* + -> */ unsigned int RXFIFO_LEVEL_MARKER:4; // 68SZ328 only + }; + + EmUARTDragonball (UART_Type, int uartNum); + ~EmUARTDragonball (void); + + void StateChanged (State&, Bool sendRxData); + void UpdateState (State&, Bool refreshRxData); + + void TransmitTxFIFO (EmTransport*); + void ReceiveRxFIFO (EmTransport*); + + EmTransport* GetTransport (void); + + private: + int PrvFIFOSize (Bool forRX); + int PrvLevelMarker (Bool forRX); + + private: + int fUARTNum; + State fState; + EmByteQueue fRxFIFO; + EmByteQueue fTxFIFO; +}; + +#endif /* EmUARTDragonball_h */ diff --git a/SrcShared/Hardware/TRG/EmHandEra330Defs.h b/SrcShared/Hardware/TRG/EmHandEra330Defs.h new file mode 100644 index 0000000..4b2e3a5 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmHandEra330Defs.h @@ -0,0 +1,40 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ +#ifndef EmHandEra330Defs_h +#define EmHandEra330Defs_h + +#include "EmHandEraCFBus.h" +#include "EmHandEraSDBus.h" + +#define HE330_NUM_KEY_ROWS 4 + +typedef struct { + uint16 Row[HE330_NUM_KEY_ROWS]; +} HandEra330Keys; + +typedef struct { + HandEra330Keys Keys; + CFBusManager CFBus; + SDBusManager SDBus; + Bool LCDOn; + Bool BacklightOn; + Bool IRPortOn; + Bool SenseCurrent; + Bool pendingIRQ2; + Bool CFInserted; + Bool SDInserted; + Bool PowerConnected; + Bool SDChipSelect; +} HandEra330PortManager; + +#endif // EmHandEra330Defs_h diff --git a/SrcShared/Hardware/TRG/EmHandEraCFBus.h b/SrcShared/Hardware/TRG/EmHandEraCFBus.h new file mode 100644 index 0000000..8a1fadd --- /dev/null +++ b/SrcShared/Hardware/TRG/EmHandEraCFBus.h @@ -0,0 +1,28 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmHandEraCFBus_h +#define EmHandEraCFBus_h + +enum CFBusWidth { + kCFBusWidth8, + kCFBusWidth16 +}; + +typedef struct { + int bEnabled; + enum CFBusWidth Width; + int bSwapped; +} CFBusManager; + +#endif // EmHandEraBusDefs_h diff --git a/SrcShared/Hardware/TRG/EmHandEraSDBus.h b/SrcShared/Hardware/TRG/EmHandEraSDBus.h new file mode 100644 index 0000000..6853244 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmHandEraSDBus.h @@ -0,0 +1,22 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmHandEraSDBus_h +#define EmHandEraSDBus_h + +typedef struct { + int bEnabled; + int bSwapped; +} SDBusManager; + +#endif // EmHandEraBusDefs_h diff --git a/SrcShared/Hardware/TRG/EmRegs330CPLD.cpp b/SrcShared/Hardware/TRG/EmRegs330CPLD.cpp new file mode 100644 index 0000000..bc1ed57 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmRegs330CPLD.cpp @@ -0,0 +1,263 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ +#include "EmCommon.h" +#include "EmRegs330CPLD.h" + +#include "EmHAL.h" // EmHAL::LineDriverChanged +#include "EmHandEra330Defs.h" +#include "EmMemory.h" +#include "EmScreen.h" // EmScreenUpdateInfo + +/***************************************************************************** + * The HandEra 330 uses a CPLD for additional GPIO + * This includes: + * CF & SD bus control, keyboard row drivers, LCD control, Backlight, IRDA, + * RS232 DTR signal, current vs voltage sense, and audio control. + * + * POSE needs to know about LCD, backlight, keyboard, and current sense so these + * are stored in an external HandEra330PortManager class that the EmRegsVZHandEra330 + * class can get the values from. + ****************************************************************************/ + +// --------------------------------------------------------------------------- +// ¥ EmRegs330CPLD::EmRegs330CPLD +// --------------------------------------------------------------------------- +EmRegs330CPLD::EmRegs330CPLD (HandEra330PortManager * fPortManager) +{ + Reg0 = Cpld0Edo; + Reg2 = Cpld2CfDetect | + Cpld2NoSdDetect | + Cpld2NoExPwrDetect | + Cpld2SdUnwriteProt | + Cpld2SdPowerOff | + Cpld2Kbd3Inactive | + Cpld2Kbd2Inactive | + Cpld2Kbd1Inactive | + Cpld2Kbd0Inactive | + Cpld2NoReset | + Cpld2CfBufsOff | + Cpld2SwapOff | + Cpld2CfPowerOff | + Cpld2BusWidth16; + Reg4 = Cpld4LcdBiasOff | + Cpld4LcdVccOn | + Cpld4LcdOff | + Cpld4BlPdOff | + Cpld4DtrOff | + Cpld4MmcCsOn | + Cpld4FiltSdOff | + Cpld4Rs232Off | + Cpld4IrdaOff | + Cpld4MicOff | + Cpld4SenseVoltage; + fPortMgr = fPortManager; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs330CPLD::~EmRegs330CPLD +// --------------------------------------------------------------------------- + +EmRegs330CPLD::~EmRegs330CPLD (void) +{ +} + +void EmRegs330CPLD::Reset(Bool /*hardwareReset*/) +{ + fPortMgr->Keys.Row[0] = 1; + fPortMgr->Keys.Row[1] = 1; + fPortMgr->Keys.Row[2] = 1; + fPortMgr->Keys.Row[3] = 1; + fPortMgr->LCDOn = false; + fPortMgr->BacklightOn = false; + fPortMgr->IRPortOn = false; + fPortMgr->CFBus.bEnabled = false; + fPortMgr->CFBus.Width = kCFBusWidth16; + fPortMgr->CFBus.bSwapped = false; + fPortMgr->pendingIRQ2 = false; + fPortMgr->SDChipSelect = false; + fPortMgr->PowerConnected = false; +} + +// ------------------------------------------------------------------------- +// ¥ EmRegs330CPLD::SetSubBankHandlers +// --------------------------------------------------------------------------- +void EmRegs330CPLD::SetSubBankHandlers (void) +{ + // Install base handlers. + + EmRegs::SetSubBankHandlers(); + // Now add standard/specialized handers for the defined registers. + this->SetHandler((ReadFunction)&EmRegs330CPLD::Read, + (WriteFunction)&EmRegs330CPLD::Write, + kMemoryStartCPLD, + kMemorySizeCPLD); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegs330CPLD::GetRealAddress +// --------------------------------------------------------------------------- +uint8 * EmRegs330CPLD::GetRealAddress (emuptr address) +{ + return (address-kMemoryStartCPLD) + Buffer; +} + +// --------------------------------------------------------------------------- +// ¥ EmRegs330CPLD::GetWord +// --------------------------------------------------------------------------- +uint32 EmRegs330CPLD::GetWord (emuptr address) +{ + uint32 offset = address - kMemoryStartCPLD; + + switch (offset) + { + case CpldReg00 : + return Cpld0Edo; + + case CpldReg02 : + if (fPortMgr->CFInserted) + Reg2 &= ~Cpld2NoCfDetect; + else + Reg2 |= Cpld2NoCfDetect; + if (fPortMgr->SDInserted) + Reg2 &= ~Cpld2NoSdDetect; + else + Reg2 |= Cpld2NoSdDetect; + if (fPortMgr->PowerConnected) + Reg2 &= ~Cpld2NoExPwrDetect; + else + Reg2 |= Cpld2NoExPwrDetect; + return (Reg2); + + case CpldReg04 : + return (Reg4); + + default : + return 0; + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs330CPLD::SetWord +// --------------------------------------------------------------------------- +void EmRegs330CPLD::SetWord (emuptr address, uint32 val) +{ + uint32 offset = address - kMemoryStartCPLD; + + switch (offset) + { + case CpldReg00 : + fPortMgr->pendingIRQ2 = false; + break; + + case CpldReg02 : + Reg2 = (val & 0x0fff) | (Reg2 & 0xf000); // top 4 bits are read only. + + // keys: + fPortMgr->Keys.Row[3] = (Reg2 & Cpld2Kbd3Inactive) ? 0 : 1; + fPortMgr->Keys.Row[2] = (Reg2 & Cpld2Kbd2Inactive) ? 0 : 1; + fPortMgr->Keys.Row[1] = (Reg2 & Cpld2Kbd1Inactive) ? 0 : 1; + fPortMgr->Keys.Row[0] = (Reg2 & Cpld2Kbd0Inactive) ? 0 : 1; + + // CF: + fPortMgr->CFBus.bEnabled = (Reg2 & Cpld2CfBufsOn); + if (Reg2 & Cpld2BusWidth8) + { + fPortMgr->CFBus.Width = kCFBusWidth8; + + // HandEra330 byte swapping is not the same as the TRGpro when + // in byte mode. On the TRGpro it must be enabled to access bytes + // correctly, on the 330 it will work either way... + // Fudge it here to be the same as TRGpro so code can be shared. + fPortMgr->CFBus.bSwapped = true; + } + else + { + fPortMgr->CFBus.Width = kCFBusWidth16; + fPortMgr->CFBus.bSwapped = (Reg2 & Cpld2SwapOn); + } + + break; + + case CpldReg04 : + Bool backlightWasOn = fPortMgr->BacklightOn; + Bool lcdWasOn = fPortMgr->LCDOn; + Bool irWasOn = fPortMgr->IRPortOn; + + Reg4 = val; + + fPortMgr->LCDOn = (Reg4 & Cpld4LcdBiasOn); + fPortMgr->BacklightOn = (Reg4 & Cpld4BlPdOn); + fPortMgr->IRPortOn = (Reg4 & Cpld4IrdaOff) == 0; + fPortMgr->SenseCurrent = (Reg4 & Cpld4SenseCurrent); + fPortMgr->SDChipSelect = ((Reg4 & Cpld4MmcCsOn) == 0); + + if ((fPortMgr->LCDOn != lcdWasOn) || (fPortMgr->BacklightOn != backlightWasOn)) + EmScreen::InvalidateAll (); + + if (irWasOn != fPortMgr->IRPortOn) + EmHAL::LineDriverChanged (kUARTIR); + + break; + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegs330CPLD::GetAddressStart +// --------------------------------------------------------------------------- +emuptr EmRegs330CPLD::GetAddressStart (void) +{ + return (kMemoryStartCPLD); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegs330CPLD::GetAddressRange +// --------------------------------------------------------------------------- +uint32 EmRegs330CPLD::GetAddressRange (void) +{ + return kMemorySizeCPLD; +} + +// --------------------------------------------------------------------------- +// ¥ EmRegs330CPLD::Read +// --------------------------------------------------------------------------- +uint32 EmRegs330CPLD::Read(emuptr address, int size) +{ + switch(size) + { +// case sizeof(uint8) : +// return(GetByte(address)); + case sizeof(uint16) : + return(GetWord(address)); + } + return 0; +} + +// --------------------------------------------------------------------------- +// ¥ EmRegs330CPLD::Write +// --------------------------------------------------------------------------- +void EmRegs330CPLD::Write(emuptr address, int size, uint32 val) +{ + switch(size) + { +// case sizeof(uint8) : +// SetByte(address, val); +// break; + case sizeof(uint16) : + SetWord(address, val); + break; + } +} + diff --git a/SrcShared/Hardware/TRG/EmRegs330CPLD.h b/SrcShared/Hardware/TRG/EmRegs330CPLD.h new file mode 100644 index 0000000..08487aa --- /dev/null +++ b/SrcShared/Hardware/TRG/EmRegs330CPLD.h @@ -0,0 +1,144 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ +#ifndef EmRegs330CPLD_h +#define EmRegs330CPLD_h + +#include "EmRegs.h" +#include "EmHandEra330Defs.h" + +#define CpldReg00 0x0000 +// CPLD Register 0x0000 Bit Definitions +// ------------------------------------- + #define Cpld0Edo 0x0002 + #define Cpld0Sdram 0x0000 + +#define CpldReg02 0x0002 +// CPLD Register 0x0002 Bit Definitions +// ------------------------------------- + #define Cpld2NoCfDetect 0x8000 + #define Cpld2CfDetect 0x0000 + + #define Cpld2NoSdDetect 0x4000 + #define Cpld2SdDetect 0x0000 + + #define Cpld2NoExPwrDetect 0x2000 + #define Cpld2ExPwrDetect 0x0000 + + #define Cpld2SdUnwriteProt 0x0000 + #define Cpld2SdWriteProt 0x1000 + + #define Cpld2SdPowerOn 0x0000 + #define Cpld2SdPowerOff 0x0200 + + #define Cpld2Kbd3Active 0x0000 + #define Cpld2Kbd3Inactive 0x0100 + + #define Cpld2Kbd2Active 0x0000 + #define Cpld2Kbd2Inactive 0x0080 + + #define Cpld2Kbd1Active 0x0000 + #define Cpld2Kbd1Inactive 0x0040 + + #define Cpld2Kbd0Active 0x0000 + #define Cpld2Kbd0Inactive 0x0020 + + #define Cpld2NoReset 0x0000 + #define Cpld2Reset 0x0010 + + #define Cpld2CfBufsOff 0x0000 + #define Cpld2CfBufsOn 0x0008 + + #define Cpld2SwapOff 0x0000 + #define Cpld2SwapOn 0x0004 + + #define Cpld2CfPowerOn 0x0000 + #define Cpld2CfPowerOff 0x0002 + + #define Cpld2BusWidth16 0x0000 + #define Cpld2BusWidth8 0x0001 + +#define CpldReg04 0x0004 +// CPLD Register 0x0004 Bit Definitions +// ------------------------------------- + #define Cpld4LcdBiasOff 0x0000 + #define Cpld4LcdBiasOn 0x0400 + + #define Cpld4LcdVccOn 0x0000 + #define Cpld4LcdVccOff 0x0200 + + #define Cpld4LcdOff 0x0000 + #define Cpld4LcdON 0x0100 + + #define Cpld4BlPdOff 0x0000 + #define Cpld4BlPdOn 0x0080 + + #define Cpld4DtrOn 0x0000 + #define Cpld4DtrOff 0x0040 + + #define Cpld4MmcCsOff 0x0000 + #define Cpld4MmcCsOn 0x0020 + + #define Cpld4FiltSdOff 0x0000 + #define Cpld4FiltSdOn 0x0010 + + #define Cpld4Rs232Off 0x0000 + #define Cpld4Rs232On 0x0008 + + #define Cpld4IrdaOn 0x0000 + #define Cpld4IrdaOff 0x0004 + + #define Cpld4MicOn 0x0000 + #define Cpld4MicOff 0x0002 + + #define Cpld4SenseVoltage 0x0000 + #define Cpld4SenseCurrent 0x0001 + + +const uint32 kMemoryStartCPLD = 0x10E00000; +const uint32 kMemorySizeCPLD = 0x100; + +class EmRegs330CPLD : public EmRegs +{ + public: + EmRegs330CPLD (HandEra330PortManager * fPortManager); + virtual ~EmRegs330CPLD (void); + + virtual void Reset (Bool hardwareReset); + + uint8* GetRealAddress (emuptr address); + void SetSubBankHandlers (void); + emuptr GetAddressStart (void); + uint32 GetAddressRange (void); + + uint32 GetWord (emuptr iAddress); + void SetWord (emuptr iAddress, uint32 iWordValue); + + // only word access is allowed to the CPLD +// uint32 GetLong (emuptr iAddress) { return 0;} +// uint32 GetByte (emuptr iAddress) { return 0;} +// void SetLong (emuptr iAddress, uint32 iLongValue) {} +// void SetByte (emuptr iAddress, uint32 iByteValue) {} +private: + uint16 Reg0; + uint16 Reg2; + uint16 Reg4; + uint8 Buffer[kMemorySizeCPLD]; + uint32 Read (emuptr address, int size); + void Write (emuptr address, int size, uint32 value); +// void SetReg02(uint16 val); +// void SetReg04(uint16 val); + HandEra330PortManager * fPortMgr; +}; + +#endif // EmTRGCFDefs_h + diff --git a/SrcShared/Hardware/TRG/EmSPISlave330Current.cpp b/SrcShared/Hardware/TRG/EmSPISlave330Current.cpp new file mode 100644 index 0000000..43fd47b --- /dev/null +++ b/SrcShared/Hardware/TRG/EmSPISlave330Current.cpp @@ -0,0 +1,189 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmSPISlave330Current.h" + +#include "Logging.h" +#define PRINTF if (1) ; else LogAppendMsg + + +/***************************************************************************** + * The HandEra 330 includes a battery current sense. It is switched in and + * out of channel 2 of the ADC. + ****************************************************************************/ + +// --------------------------------------------------------------------------- +// ¥ EmSPISlave330Current::EmSPISlave330Current +// --------------------------------------------------------------------------- + +EmSPISlave330Current::EmSPISlave330Current () : + EmSPISlave (), + fBitBufferIn (0), + fBitBufferOut (0), + fNumBitsIn (0), + fPendingResult (0), + fHavePending (false), + fCommandBitsSeen (0), + fPowerConnected(false) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmSPISlave330Current::~EmSPISlave330Current +// --------------------------------------------------------------------------- + +EmSPISlave330Current::~EmSPISlave330Current (void) +{ +} + +// --------------------------------------------------------------------------- +// ¥ EmSPISlave330Current::DoExchange +// --------------------------------------------------------------------------- + +uint16 EmSPISlave330Current::DoExchange (uint16 control, uint16 data) +{ + PRINTF (""); + PRINTF ("EmSPISlave330Current::DoExchange"); + PRINTF ("control = 0x%04X, data = 0x%04X", control, data); + + // ----------------------------------------------------------------------- + // Merge the incoming bits with our current buffer. + // ----------------------------------------------------------------------- + + uint16 numBits = (control & hwrVZ328SPIMControlBitsMask) + 1; + uint32 oldBitsMask = ~0 << numBits; + uint32 newBitsMask = ~oldBitsMask; + + PRINTF ("Before merging input: fBitBufferIn = 0x%04X, fNumBitsIn = 0x%04X", fBitBufferIn, fNumBitsIn); + + fBitBufferIn = ((fBitBufferIn << numBits) & oldBitsMask) | (data & newBitsMask); + fNumBitsIn += numBits; + + PRINTF ("After merging input: fBitBufferIn = 0x%04X, fNumBitsIn = 0x%04X", fBitBufferIn, fNumBitsIn); + + // ----------------------------------------------------------------------- + // Start processing the command bits. + // ----------------------------------------------------------------------- + + EmAssert (fNumBitsIn - fCommandBitsSeen - 1 >= 0); + + uint16 result = 0; + uint32 mask = 1 << (fNumBitsIn - fCommandBitsSeen - 1); + + while (mask) + { + // Shift out a bit. + + { + result = (result << 1) | (fBitBufferOut >> 15); + fBitBufferOut <<= 1; + } + + // If we haven't seen the Start bit yet, look for it. + + if (fCommandBitsSeen == 0) + { + // If we found the Start bit, start counting the + // number of command bits as we stream through them. + + if ((mask & fBitBufferIn) != 0) + { + fCommandBitsSeen++; + } + + // Otherwise, adjust fNumBitsIn so that when we *do* + // find the Start bit, we know where it is. + + else + { + fNumBitsIn--; + } + + // If there's a pending conversion, load it into the + // output shift register after receiving the first + // bit after the last bit of the previous command. + + this->LoadPendingConversion (); + } + else + { + fCommandBitsSeen++; + + // If we've seen 8 bits, process the command, and then + // prepare for the next one. + + if (fCommandBitsSeen == 8) + { + fNumBitsIn -= 8; + fCommandBitsSeen = 0; + + uint8 command = fBitBufferIn >> fNumBitsIn; + this->ProcessCommand (command); + + PRINTF ("After ProcessCommand: fPendingResult = 0x%04X", fPendingResult); + } + } + + mask >>= 1; + } + + + // ---------------------------------------------------------------------- + // Return the result. + // ---------------------------------------------------------------------- + + PRINTF ("result = 0x%04X", result); + + return result; +} + + +// --------------------------------------------------------------------------- +// ¥ EmSPISlave330Current::ProcessCommand +// --------------------------------------------------------------------------- + +void EmSPISlave330Current::ProcessCommand (uint8 command) +{ + uint16 result = 0; + + // we should only get here for channel 2 + EmAssert (((command & kChannelBits) >> 4) == 2); + + if (fPowerConnected) + result = 0; // no battery current with ext power connected. + else + result = 0x60; // just hard code some current for now. + + fPendingResult = result << 4; + fHavePending = true; +} + + +// --------------------------------------------------------------------------- +// ¥ EmSPISlave330Current::LoadPendingConversion +// --------------------------------------------------------------------------- + +void EmSPISlave330Current::LoadPendingConversion (void) +{ + // ----------------------------------------------------------------------- + // If there's a pending conversion, move it into the output shift register. + // ----------------------------------------------------------------------- + if (fHavePending) + { + fHavePending = false; + fBitBufferOut = fPendingResult; + } +} + diff --git a/SrcShared/Hardware/TRG/EmSPISlave330Current.h b/SrcShared/Hardware/TRG/EmSPISlave330Current.h new file mode 100644 index 0000000..c514250 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmSPISlave330Current.h @@ -0,0 +1,51 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmSPISlave330Current_h +#define EmSPISlave330Current_h + +#include "EmSPISlave.h" // EmSPISlave + +#define kChannelBits 0x70 + +/*-------------------------------------------------------------------- + * HandEra 330 has an analog switch which switches between voltage and + * current sense on channel 2. Need to cobble together something so + * it can sense some battery current and not think we are always on + * external power. + *-------------------------------------------------------------------*/ +class EmSPISlave330Current : public EmSPISlave +{ + public: + EmSPISlave330Current (); + virtual ~EmSPISlave330Current (void); + + virtual uint16 DoExchange (uint16 control, uint16 data); + void SetMode (Bool powerConnected) { fPowerConnected = powerConnected; } + + protected: + void ProcessCommand (uint8); + void LoadPendingConversion (void); + + private: + uint32 fBitBufferIn; + uint16 fBitBufferOut; + int fNumBitsIn; + uint16 fPendingResult; + Bool fHavePending; + int fCommandBitsSeen; + + Bool fPowerConnected; +}; + +#endif
\ No newline at end of file diff --git a/SrcShared/Hardware/TRG/EmTRG.cpp b/SrcShared/Hardware/TRG/EmTRG.cpp new file mode 100644 index 0000000..f079538 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRG.cpp @@ -0,0 +1,57 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmTRG.h" + +#include "EmBankRegs.h" +#include "EmRegsEZTRGpro.h" +#include "EmRegs330CPLD.h" +#include "EmRegsVZHandEra330.h" +#include "EmHandEraCFBus.h" +#include "EmHandEraSDBus.h" +#include "EmTRGCF.h" +#include "EmTRGSD.h" + + +/*********************************************************************** + * + * FUNCTION: OEMCreateTRGRegObjs + * + * DESCRIPTION: This function is called by EmDevice::CreateRegs for TRG + * devices + * + * PARAMETERS: 'fHardwareSubID' specifies the device + * + * RETURNED: None + * + ***********************************************************************/ +void OEMCreateTRGRegObjs(long hardwareSubID) +{ + CFBusManager * fCFBus; + HandEra330PortManager * fPortMgr; + + switch (hardwareSubID) + { + case hwrTRGproID : + default : + EmBankRegs::AddSubBank (new EmRegsEZTRGpro(&fCFBus)); + EmBankRegs::AddSubBank (new EmRegsCFMemCard(fCFBus)); + break; + case hwrTRGproID + 1 : + EmBankRegs::AddSubBank (new EmRegsVZHandEra330(&fPortMgr)); + EmBankRegs::AddSubBank (new EmRegs330CPLD(fPortMgr)); + EmBankRegs::AddSubBank (new EmRegsCFMemCard(&fPortMgr->CFBus)); + break; + } +} diff --git a/SrcShared/Hardware/TRG/EmTRG.h b/SrcShared/Hardware/TRG/EmTRG.h new file mode 100644 index 0000000..21d14d5 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRG.h @@ -0,0 +1,23 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmTRG_h +#define EmTRG_h + +#define TRGPRO_MANUF "TRG Products" +#define hwrOEMDeviceIDTRGpro 1 +#define hwrTRGproID 0 + +void OEMCreateTRGRegObjs(long hardwareSubID); + +#endif // EmTRG_h diff --git a/SrcShared/Hardware/TRG/EmTRGATA.cpp b/SrcShared/Hardware/TRG/EmTRGATA.cpp new file mode 100644 index 0000000..fcff3e6 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRGATA.cpp @@ -0,0 +1,471 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmTRGATA.h" + +// ------------------------------------------------------------------------ +// This file emulates the ATA Registers on the CF Memory Card. +// +// Address Description +// --------------------- -------------------- +// 0x18001000-0x1800100F ATA Registers +// 0x18001010-0x180013FF Mirror of the ATA Registers +// 0x18001400-0x18001FFF Equivalent to the Data-Even/Data-Odd Registers +// ------------------------------------------------------------------------ + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::EmRegsCFAta +// --------------------------------------------------------------------------- +EmRegsCFAta::EmRegsCFAta(void) +{ +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::~EmRegsCFATA +// --------------------------------------------------------------------------- +EmRegsCFAta::~EmRegsCFAta(void) +{ +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::Initialize +// --------------------------------------------------------------------------- +void EmRegsCFAta::Initialize(EmDiskTypeID DiskTypeID) +{ + int i; + + AtaMode = MODE_DISK_IO; + DiskIO.Initialize(DiskTypeID); + for (i=0; i<NUM_IDE_REGS; i++) + RegMem[i] = i; + RegMem[6] = 0xA0; +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::Reset +// --------------------------------------------------------------------------- +void EmRegsCFAta::Reset(void) +{ + DiskIO.Reset(); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::Dispose +// --------------------------------------------------------------------------- +void EmRegsCFAta::Dispose(void) +{ + DiskIO.Dispose(); +} + +//---------------------------------------------------------------------------- +// Status and Alternate Status Registers Offsets 7h and Eh +// +// These registers return the CompactFlash Storage Card status when read by +// the host. Reading the Status register does clear a pending interrupt while +// reading the Auxiliary Status register does not. The status bits are +// described as follows: +// +// D7 D6 D5 D4 D3 D2 D1 D0 +// --- --- --- --- --- --- --- --- +// BSY RDY DWF DSC DRQ CRR 0 ERR +// +// Bit 7 (BUSY): the busy bit is set when the CompactFlash Storage Card has +// access to the command buffer and registers and the host is locked out +// from accessing the command register and buffer. No other bits in this +// register are valid when this bit is set to a 1. +// Bit 6 (RDY): RDY indicates whether the device is capable of performing +// CompactFlash Storage Card operations. This bit is cleared at power up +// and remains cleared until the CompactFlash Storage Card is ready to +// accept a command. +// Bit 5 (DWF): This bit, if set, indicates a write fault has occurred. +// Bit 4 (DSC): This bit is set when the CompactFlash Storage Card is ready. +// Bit 3 (DRQ): The Data Request is set when the CompactFlash Storage Card +// requires that information be transferred either to or from the host +// through the Data register. +// Bit 2 (CORR): This bit is set when a Correctable data error has been +// encountered and the data has been corrected. This condition does not +// terminate a multi-sector read operation. +// Bit 1 (IDX): This bit is always set to 0. +// Bit 0 (ERR): This bit is set when the previous command has ended in +// some type of error. The bits in the Error register contain additional +// information describing the error. It is recommended that media access +// commands (such as Read Sectors and Write Sectors) that end with an +// error condition should have the address of the first sector in error +// in the command block registers. +//---------------------------------------------------------------------------- +uint8 EmRegsCFAta::RegReadStatus(Boolean /*is_alt_reg*/) +{ + uint8 retVal; + DiskIOStatus status; + DiskDataStatus dataStatus; + + DiskIO.GetStatus(&status, &dataStatus); + if (status == DIO_SUCCESS) + { + retVal = (IDE_STS_RDY|IDE_STS_DSC); + if (dataStatus == DIO_MORE_DATA) + { + retVal |= IDE_STS_DRQ; + } + else + { + DiskParams.Lba += DiskParams.SectorCnt; + RegMem[IDE_REG_5_LBA_23_16] = (uint8)(DiskParams.Lba >> 16); + RegMem[IDE_REG_4_LBA_15_8] = (uint8)(DiskParams.Lba >> 8); + RegMem[IDE_REG_3_LBA_7_0] = (uint8)DiskParams.Lba; + } + } + else + { + retVal = (IDE_STS_RDY|IDE_STS_DSC|IDE_STS_ERR); + } + return(retVal); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::GetDiskIOParams +// --------------------------------------------------------------------------- +void EmRegsCFAta::GetDiskIOParams(DiskIOParams * Params) +{ + Params->DriveNum = 0; + Params->Lba = + (((uint32)RegMem[IDE_REG_6_DRV_HEAD] & 0x0F) << 24) + + ((uint32)RegMem[IDE_REG_5_LBA_23_16] << 16) + + ((uint32)RegMem[IDE_REG_4_LBA_15_8] << 8) + + (uint32)RegMem[IDE_REG_3_LBA_7_0]; + Params->SectorCnt = (uint32)RegMem[IDE_REG_2_SECTOR_CNT]; + if (Params->SectorCnt == 0) + Params->SectorCnt = 256; + + DiskParams = *Params; +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::CmdIdentifyDrive +// --------------------------------------------------------------------------- +void EmRegsCFAta::CmdIdentifyDrive(void) +{ + DiskIO.StartDriveID(); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::CmdReadSectors +// --------------------------------------------------------------------------- +void EmRegsCFAta::CmdReadSectors(void) +{ + DiskIOParams params; + + GetDiskIOParams(¶ms); + DiskIO.StartRead(¶ms); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::CmdWriteSectors +// --------------------------------------------------------------------------- +void EmRegsCFAta::CmdWriteSectors(void) +{ + DiskIOParams params; + + GetDiskIOParams(¶ms); + DiskIO.StartWrite(¶ms); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::CmdDriveDiagnostic +// --------------------------------------------------------------------------- +void EmRegsCFAta::CmdDriveDiagnostic(void) +{ + AtaMode = MODE_DRIVE_DIAGNOSTICS; +} + +//---------------------------------------------------------------------------- +// Data Register Offset 0 (8-bit) and 8-9 (16-bit) +// +// The Data Register is a 16-bit register, and it is used to transfer data +// blocks between the CompactFlash Storage Card data buffer and the Host. +// This register overlaps the Error Register. The table below describes the +// combinations of data register access and is provided to assist in +// understanding the overlapped Data Register and Error/Feature Register +// rather than to attempt to define general PCMCIA word and byte access +// modes and operations. See the PCMCIA PC Card Standard Release 2.0 for +// definitions of the Card Accessing Modes for I/O and Memory cycles. +// Note: Because of the overlapped registers, access to the 1F1h, 171h or +// offset 1 are not defined for word (-CE2 = 0 and -CE1 = 0) operations. +// These accesses are treated as accesses to the Word Data Register. +// The duplicated registers at offsets 8, 9 and Dh have no restrictions on +// the operations that can be performed by the socket. +//---------------------------------------------------------------------------- +uint8 EmRegsCFAta::Reg0ReadData(void) +{ + DiskIO.ReadNextDataByte(&RegMem[IDE_REG_0_DATA]); + return(RegMem[IDE_REG_0_DATA]); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::Reg0WriteData +// --------------------------------------------------------------------------- +void EmRegsCFAta::Reg0WriteData(void) +{ + DiskIO.WriteNextDataByte(RegMem[IDE_REG_0_DATA]); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::Reg8ReadDataEven +// --------------------------------------------------------------------------- +uint8 EmRegsCFAta::Reg8ReadDataEven(void) +{ + DiskIO.ReadNextDataByte(&RegMem[IDE_REG_8_DATA_EVEN]); + return(RegMem[IDE_REG_8_DATA_EVEN]); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::Reg8WriteDataEven +// --------------------------------------------------------------------------- +void EmRegsCFAta::Reg8WriteDataEven(void) +{ + DiskIO.WriteNextDataByte(RegMem[IDE_REG_8_DATA_EVEN]); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::Reg9ReadDataOdd +// --------------------------------------------------------------------------- +uint8 EmRegsCFAta::Reg9ReadDataOdd(void) +{ + DiskIO.ReadNextDataByte(&RegMem[IDE_REG_9_DATA_ODD]); + return(RegMem[IDE_REG_9_DATA_ODD]); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::Reg9WriteDataOdd +// --------------------------------------------------------------------------- +void EmRegsCFAta::Reg9WriteDataOdd(void) +{ + DiskIO.WriteNextDataByte(RegMem[IDE_REG_9_DATA_ODD]); +} + +//---------------------------------------------------------------------------- +// Error Register -- Offset 1h and Dh (read-only) +// +// This register contains additional information about the source of +// an error when an error is indicated in bit 0 of the Status register. +// The bits are defined as follows: +// +// Error Register +// This register is also accessed on data bits D15-D8 during a write +// operation to offset 0 with -CE2 low and -CE1 high. +// +// Bit 7 (BBK): this bit is set when a Bad Block is detected. +// Bit 6 (UNC): this bit is set when an Uncorrectable Error is encountered. +// Bit 5: this bit is 0. +// Bit 4 (IDNF): the requested sector ID is in error or cannot be found. +// Bit 3: this bit is 0. +// Bit 2 (Abort) This bit is set if the command has been aborted because of +// a CompactFlash Storage Card status condition: (Not Ready, Write Fault, +// etc.) or when an invalid command has been issued. +// Bit 1 This bit is 0. +// Bit 0 (AMNF) This bit is set in case of a general error. +//---------------------------------------------------------------------------- +uint8 EmRegsCFAta::RegReadError(Boolean /*is_alt_reg*/) +{ + if (AtaMode == MODE_DRIVE_DIAGNOSTICS) + return(IDE_DIA_01_NO_ERROR); + else + return DiskIO.GetError(); +} + + +//---------------------------------------------------------------------------- +// Sector Count Register (Offset 2h) +// +// This register contains the numbers of sectors of data requested to be +// transferred on a read or write operation between the host and the +// CompactFlash Storage Card. If the value in this register is zero, +// a count of 256 sectors is specified. If the command was successful, +// this register is zero at command completion. If not successfully completed, +// the register contains the number of sectors that need to be transferred +// in order to complete the request. +//---------------------------------------------------------------------------- +uint8 EmRegsCFAta::Reg2ReadSectorCount(void) +{ + uint32 cnt; + + cnt = DiskIO.GetSectorCount(); + if (cnt > 0xFF) + cnt = 0x0; + return(cnt); +} + +//---------------------------------------------------------------------------- +// Device Control Register -- Offset Eh +// This register is used to control the CompactFlash Storage Card interrupt +// request and to issue an ATA soft reset to the card. This register can +// be written even if the device is BUSY. The bits are defined as follows: +// +// D7 D6 D5 D4 D3 D2 D1 D0 +// --- --- --- --- --- ------ ---- --- +// X X X X 1 SW Rst -IEn 0 +// +// Bit 7: this bit is an X (don't care). +// Bit 6: this bit is an X (don't care). +// Bit 5: this bit is an X (don't care). +// Bit 4: this bit is an X (don't care). +// Bit 3: this bit is ignored by the CompactFlash Storage Card. +// Bit 2 (SW Rst): this bit is set to 1 in order to force the CompactFlash +// Storage Card to perform an AT Disk controller Soft Reset operation. +// This does not change the PCMCIA Card Configuration Registers (4.3.2 +// to 4.3.5) as a hardware Reset does. The Card remains in Reset until this +// bit is reset to 0. +// Bit 1 (-IEn): the Interrupt Enable bit enables interrupts when the bit is +// 0. When the bit is 1, interrupts from the CompactFlash Storage Card are +// disabled. This bit also controls the Int bit in the Configuration and +// Status Register. This bit is set to 0 at power on and Reset. +// Bit 0: this bit is ignored by the CompactFlash Storage Card. +//---------------------------------------------------------------------------- +void EmRegsCFAta::RegEWriteDeviceControl(void) +{ + DiskIO.Reset(); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::Reg7WriteCmd +// --------------------------------------------------------------------------- +void EmRegsCFAta::Reg7WriteCmd(void) +{ + AtaMode = MODE_DISK_IO; + DiskIO.ClearError(); + switch(RegMem[IDE_REG_7_COMMAND]) + { + case IDE_CMD_EC_IDENTIFY_DRIVE : + CmdIdentifyDrive(); + break; + + case IDE_CMD_20_READ_SECTORS : + case IDE_CMD_21_READ_SECTORS : + CmdReadSectors(); + break; + + case IDE_CMD_30_WRITE_SECTORS : + case IDE_CMD_31_WRITE_SECTORS : + CmdWriteSectors(); + break; + + case IDE_CMD_90_EXEC_DRIVE_DIAGNOSTIC : + CmdDriveDiagnostic(); + break; + + case IDE_CMD_C6_SET_MULTIPLE_MODE : + DiskIO.SetError(IDE_ERR_04_ABORT); + break; + + default : + break; + } +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::ReadByte +// --------------------------------------------------------------------------- +void EmRegsCFAta::ReadByte(uint32 offset, + uint8 * val) +{ + *val = 0; + switch(offset) + { + case IDE_REG_0_DATA : + *val = Reg0ReadData(); + break; + case IDE_REG_1_ERROR : + *val = RegReadError(IS_BASE_REG); + break; + case IDE_REG_D_ERROR : + *val = RegReadError(IS_ALT_REG); + break; + case IDE_REG_2_SECTOR_CNT : + *val = Reg2ReadSectorCount(); + break; + case IDE_REG_7_STATUS : + *val = RegReadStatus(IS_BASE_REG); + break; + case IDE_REG_E_ALT_STATUS : + *val = RegReadStatus(IS_ALT_REG); + break; + case IDE_REG_8_DATA_EVEN : + *val = Reg8ReadDataEven(); + break; + case IDE_REG_9_DATA_ODD : + *val = Reg9ReadDataOdd(); + break; + default : + if (offset < NUM_IDE_REGS) + *val = RegMem[offset]; + else + *val = 0; + break; + } +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::WriteByte +// --------------------------------------------------------------------------- +void EmRegsCFAta::WriteByte(uint32 offset, uint8 val) +{ + RegMem[offset] = val; + switch(offset) + { + case IDE_REG_0_DATA : + Reg0WriteData(); + break; + case IDE_REG_7_COMMAND : + Reg7WriteCmd(); + break; + case IDE_REG_8_DATA_EVEN : + Reg8WriteDataEven(); + break; + case IDE_REG_9_DATA_ODD : + Reg9WriteDataOdd(); + break; + case IDE_REG_E_DEVICE_CONTROL : + RegEWriteDeviceControl(); + break; + } +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::ReadWord +// --------------------------------------------------------------------------- +void EmRegsCFAta::ReadWord(uint32 offset, + _Word * val) +{ + // 16-bit reads of Register 0 are NOT equivalent to 2 8-bit reads + // of Register 0 and 1 ... instead it reads the Even & Odd Data + // bytes, so we change the register to be 8 + if (offset == IDE_REG_0_DATA) + offset = IDE_REG_8_DATA_EVEN; + ReadByte(offset, &val->Bytes[0]); + ReadByte(offset+1, &val->Bytes[1]); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFAta::WriteWord +// --------------------------------------------------------------------------- +void EmRegsCFAta::WriteWord(uint32 offset, _Word val) +{ + // 16-bit writes of Register 0 are NOT equivalent to 2 8-bit writes + // of Register 0 and 1 ... instead it writes the Even & Odd Data + // bytes, so we change the register to be 8 + if (offset == IDE_REG_0_DATA) + offset = IDE_REG_8_DATA_EVEN; + WriteByte(offset, val.Bytes[0]); + WriteByte(offset+1, val.Bytes[1]); +} diff --git a/SrcShared/Hardware/TRG/EmTRGATA.h b/SrcShared/Hardware/TRG/EmTRGATA.h new file mode 100644 index 0000000..4b743cb --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRGATA.h @@ -0,0 +1,63 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmTRGATA_h +#define EmTRGATA_h + +#include "EmRegs.h" +#include "EmTRGCFDefs.h" +#include "EmTRGCFIO.h" + +#define IS_ALT_REG true +#define IS_BASE_REG false + +typedef enum {MODE_DISK_IO=0, MODE_DRIVE_DIAGNOSTICS=1} AtaModeType; + +class EmRegsCFAta +{ + public: + EmRegsCFAta(void); + virtual ~EmRegsCFAta(void); + + void Initialize(EmDiskTypeID DiskTypeID); + void Reset (void); + void Dispose (void); + void ReadByte(uint32 offset, uint8 * val); + void WriteByte(uint32 offset, uint8 val); + void ReadWord(uint32 offset, _Word * val); + void WriteWord(uint32 offset, _Word val); + private: + uint8 RegMem[NUM_IDE_REGS]; + AtaModeType AtaMode; + DiskIOParams DiskParams; + void GetDiskIOParams(DiskIOParams * params); + uint8 Reg0ReadData(void); + uint8 RegReadError(Boolean is_alt_reg); + uint8 Reg2ReadSectorCount(void); + void Reg0WriteData(void); + void Reg7WriteCmd(void); + uint8 RegReadStatus(Boolean is_alt_reg); + uint8 Reg8ReadDataEven(void); + void Reg8WriteDataEven(void); + uint8 Reg9ReadDataOdd(void); + void Reg9WriteDataOdd(void); + void RegEWriteDeviceControl(void); + EmCFIO DiskIO; + uint8 ConvertStatus(void); + void CmdIdentifyDrive(void); + void CmdWriteSectors(void); + void CmdReadSectors(void); + void CmdDriveDiagnostic(void); +}; + +#endif // EmTRGATA_h diff --git a/SrcShared/Hardware/TRG/EmTRGCF.cpp b/SrcShared/Hardware/TRG/EmTRGCF.cpp new file mode 100644 index 0000000..3a62a17 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRGCF.cpp @@ -0,0 +1,305 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmTRGCF.h" + +#include "EmMemory.h" + + + +//------------------------------------------------------------------------- +// This file contains the class EmRegsCFMemCard, which emulates a +// CompactFlash memory card. The bulk of this class is a series of +// routines to dispatch calls to the appropriate section of a memory +// card ... either its Tuple memory, its Configuration Registers, or its +// ATA registers. This class also handles all decisions about how to +// emulate the effect of the current bus state (8-bit vs. 16-bit, swap vs. +// no swap) on the data. +//------------------------------------------------------------------------- + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::EmRegsCFMemCard +// --------------------------------------------------------------------------- + +EmRegsCFMemCard::EmRegsCFMemCard (CFBusManager * fBusManager) +{ + fBusMgr = fBusManager; +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::~EmRegsCFMemCard +// --------------------------------------------------------------------------- + +EmRegsCFMemCard::~EmRegsCFMemCard (void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::Initialize +// --------------------------------------------------------------------------- + +void EmRegsCFMemCard::Initialize (void) +{ + DiskTypeID = EM_DISK_GENERIC_8MB; + + Ata.Initialize(DiskTypeID); + Config.Initialize(DiskTypeID); + Tuple.Initialize(DiskTypeID); + CFReset.Initialize(DiskTypeID); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::Reset +// --------------------------------------------------------------------------- +void EmRegsCFMemCard::Reset (Bool /*hardwareReset*/) +{ + Ata.Reset(); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::Save +// --------------------------------------------------------------------------- +void EmRegsCFMemCard::Save (SessionFile& /*f*/) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::Load +// --------------------------------------------------------------------------- +void EmRegsCFMemCard::Load (SessionFile& /*f*/) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::Dispose +// --------------------------------------------------------------------------- +void EmRegsCFMemCard::Dispose (void) +{ + Ata.Dispose(); +} + +// ------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::SetSubBankHandlers +// --------------------------------------------------------------------------- +void EmRegsCFMemCard::SetSubBankHandlers (void) +{ + // Install base handlers. + + EmRegs::SetSubBankHandlers(); + // Now add standard/specialized handers for the defined registers. + this->SetHandler((ReadFunction)&EmRegsCFMemCard::Read, + (WriteFunction)&EmRegsCFMemCard::Write, + kMemoryStartCF, + kMemorySizeCF); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::GetRealAddress +// --------------------------------------------------------------------------- +uint8 * EmRegsCFMemCard::GetRealAddress (emuptr address) +{ + return (address-kMemoryStartCF) + Buffer; +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::GetLong +// --------------------------------------------------------------------------- +uint32 EmRegsCFMemCard::GetLong (emuptr /*address*/) +{ + return (0); +} + +#define INVALID_READ 0x3F + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::GetByte +// --------------------------------------------------------------------------- +uint32 EmRegsCFMemCard::GetByte(emuptr address) +{ + uint8 retVal = 0; + uint32 offset; + + if (!fBusMgr->bEnabled) + return(INVALID_READ); + + if ((fBusMgr->Width == kCFBusWidth8) && (!fBusMgr->bSwapped)) + return(INVALID_READ); + + offset = address-kMemoryStartCF; + if (offset < kMemoryOffsetCFConfig) + Tuple.ReadByte(offset-kMemoryOffsetCFTuple, &retVal); + else if (offset < kMemoryOffsetCFAta) + Config.ReadByte(offset-kMemoryOffsetCFConfig, &retVal); + else if (offset < kMemoryOffsetCFReset) + Ata.ReadByte(offset-kMemoryOffsetCFAta, &retVal); + else + CFReset.ReadByte(offset-kMemoryOffsetCFReset, &retVal); + + return((uint32)retVal); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::GetWord +// --------------------------------------------------------------------------- +uint32 EmRegsCFMemCard::GetWord (emuptr address) +{ + _Word val; + uint32 retval; + int msb, lsb; + uint32 offset; + + if (!fBusMgr->bEnabled) + return(INVALID_READ); + if ((fBusMgr->Width == kCFBusWidth8) && (!fBusMgr->bSwapped)) + return(INVALID_READ); + offset = address-kMemoryStartCF; + + if (offset < kMemoryOffsetCFConfig) + Tuple.ReadWord(offset-kMemoryOffsetCFTuple, &val); + else if (offset < kMemoryOffsetCFAta) + Config.ReadWord(offset-kMemoryOffsetCFConfig, &val); + else if (offset < kMemoryOffsetCFReset) + Ata.ReadWord(offset-kMemoryOffsetCFAta, &val); + else + CFReset.ReadWord(offset-kMemoryOffsetCFReset, &val); + + if (fBusMgr->bSwapped) + { + msb = 0; + lsb = 1; + } + else + { + msb = 1; + lsb = 0; + } + retval = ((uint32)(val.Bytes[msb]) << 8) | (uint32)val.Bytes[lsb]; + return (retval); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::SetLong +// --------------------------------------------------------------------------- +void EmRegsCFMemCard::SetLong (emuptr /*address*/, uint32 /*value*/) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::SetWord +// --------------------------------------------------------------------------- +void EmRegsCFMemCard::SetWord (emuptr address, uint32 val) +{ + _Word setVal; + int msb, lsb; + + if (!fBusMgr->bEnabled) + return; + + if (fBusMgr->bSwapped) + { + msb = 0; + lsb = 1; + } + else + { + msb = 1; + lsb = 0; + } + setVal.Bytes[msb] = (uint8)((val & 0xFF00) >> 8); + setVal.Bytes[lsb] = (uint8)(val & 0x00FF); + + if (address < kMemoryStartCFConfig) + Tuple.WriteWord(address-kMemoryStartCFTuple, setVal); + else if (address < kMemoryStartCFAta) + Config.WriteWord(address-kMemoryStartCFConfig, setVal); + else if (address < kMemoryStartCFReset) + Ata.WriteWord(address-kMemoryStartCFAta, setVal); + else + CFReset.WriteWord(address-kMemoryStartCFReset, setVal); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::SetByte +// --------------------------------------------------------------------------- +void EmRegsCFMemCard::SetByte (emuptr address, uint32 value) +{ + uint8 setVal = 0; + + if (!fBusMgr->bEnabled) + return; + + setVal = (uint8)value; + if (address < kMemoryStartCFConfig) + Tuple.WriteByte(address-kMemoryStartCFTuple, setVal); + else if (address < kMemoryStartCFAta) + Config.WriteByte(address-kMemoryStartCFConfig, setVal); + else if (address < kMemoryStartCFReset) + Ata.WriteByte(address-kMemoryStartCFAta, setVal); + else + CFReset.WriteByte(address-kMemoryStartCFReset, setVal); +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::GetAddressStart +// --------------------------------------------------------------------------- +emuptr EmRegsCFMemCard::GetAddressStart (void) +{ + return (kMemoryStartCF); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::GetAddressRange +// --------------------------------------------------------------------------- +uint32 EmRegsCFMemCard::GetAddressRange (void) +{ + return kMemorySizeCF; +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::Read +// --------------------------------------------------------------------------- +uint32 EmRegsCFMemCard::Read(emuptr address, int size) +{ + switch(size) + { + case sizeof(uint8) : + return(GetByte(address)); + case sizeof(uint16) : + return(GetWord(address)); + } + return 0; +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFMemCard::Write +// --------------------------------------------------------------------------- +void EmRegsCFMemCard::Write(emuptr address, int size, uint32 val) +{ + switch(size) + { + case sizeof(uint8) : + SetByte(address, val); + break; + case sizeof(uint16) : + SetWord(address, val); + break; + } +} diff --git a/SrcShared/Hardware/TRG/EmTRGCF.h b/SrcShared/Hardware/TRG/EmTRGCF.h new file mode 100644 index 0000000..a3eb969 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRGCF.h @@ -0,0 +1,58 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmTRGCF_h +#define EmTRGCF_h + +#include "EmRegs.h" +#include "EmTRGCFDefs.h" +#include "EmTRGATA.h" +#include "EmTRGCFMem.h" + +class EmRegsCFMemCard : public EmRegs +{ + public: + EmRegsCFMemCard (CFBusManager * fCFBusManager); + virtual ~EmRegsCFMemCard (void); + + // EmRegs overrides + virtual void Initialize (void); + virtual void Reset (Bool hardwareReset); + virtual void Save (SessionFile&); + virtual void Load (SessionFile&); + virtual void Dispose (void); + + uint8* GetRealAddress (emuptr address); + void SetSubBankHandlers (void); + emuptr GetAddressStart (void); + uint32 GetAddressRange (void); + + uint32 GetLong (emuptr iAddress); + uint32 GetWord (emuptr iAddress); + uint32 GetByte (emuptr iAddress); + void SetLong (emuptr iAddress, uint32 iLongValue); + void SetWord (emuptr iAddress, uint32 iWordValue); + void SetByte (emuptr iAddress, uint32 iByteValue); +private: + uint8 Buffer[kMemorySizeCF]; + uint32 Read (emuptr address, int size); + void Write (emuptr address, int size, uint32 value); + EmDiskTypeID DiskTypeID; + EmRegsCFAta Ata; + EmRegsCFTuple Tuple; + EmRegsCFConfig Config; + EmRegsCFReset CFReset; + CFBusManager * fBusMgr; +}; + +#endif /* EmTRGCF_h */ diff --git a/SrcShared/Hardware/TRG/EmTRGCFDefs.h b/SrcShared/Hardware/TRG/EmTRGCFDefs.h new file mode 100644 index 0000000..aa5274b --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRGCFDefs.h @@ -0,0 +1,187 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmTRGCFDefs_h +#define EmTRGCFDefs_h + +#define IDE_REG_0_DATA 0x0 +#define IDE_REG_1_ERROR 0x1 +#define IDE_REG_1_FEATURES 0x1 +#define IDE_REG_2_SECTOR_CNT 0x2 +#define IDE_REG_3_LBA_7_0 0x3 +#define IDE_REG_4_LBA_15_8 0x4 +#define IDE_REG_5_LBA_23_16 0x5 +#define IDE_REG_6_DRV_HEAD 0x6 +#define IDE_REG_7_STATUS 0x7 +#define IDE_REG_7_COMMAND 0x7 +#define IDE_REG_8_DATA_EVEN 0x8 +#define IDE_REG_9_DATA_ODD 0x9 +#define IDE_REG_A_UNUSED 0xA +#define IDE_REG_B_UNUSED 0xB +#define IDE_REG_C_UNUSED 0xC +#define IDE_REG_D_ERROR 0xD +#define IDE_REG_E_ALT_STATUS 0xE +#define IDE_REG_E_DEVICE_CONTROL 0xE +#define IDE_REG_F_DRIVE_ADDR 0xF + +#define NUM_IDE_REGS (IDE_REG_F_DRIVE_ADDR + 1) + +#define SECTOR_SIZE 512 + +#define IDE_CMD_03_REQUEST_SENSE 0x03 +#define IDE_CMD_10_RECALIBRATE 0x10 +#define IDE_CMD_11_RECALIBRATE 0x11 +#define IDE_CMD_12_RECALIBRATE 0x12 +#define IDE_CMD_13_RECALIBRATE 0x13 +#define IDE_CMD_14_RECALIBRATE 0x14 +#define IDE_CMD_15_RECALIBRATE 0x15 +#define IDE_CMD_16_RECALIBRATE 0x16 +#define IDE_CMD_17_RECALIBRATE 0x17 +#define IDE_CMD_18_RECALIBRATE 0x18 +#define IDE_CMD_19_RECALIBRATE 0x19 +#define IDE_CMD_1A_RECALIBRATE 0x1A +#define IDE_CMD_1B_RECALIBRATE 0x1B +#define IDE_CMD_1C_RECALIBRATE 0x1C +#define IDE_CMD_1D_RECALIBRATE 0x1D +#define IDE_CMD_1E_RECALIBRATE 0x1E +#define IDE_CMD_1F_RECALIBRATE 0x1F +#define IDE_CMD_20_READ_SECTORS 0x20 +#define IDE_CMD_21_READ_SECTORS 0x21 +#define IDE_CMD_22_READ_LONG_SECTOR 0x22 +#define IDE_CMD_23_READ_LONG_SECTOR 0x23 +#define IDE_CMD_30_WRITE_SECTORS 0x30 +#define IDE_CMD_31_WRITE_SECTORS 0x31 +#define IDE_CMD_32_WRITE_LONG_SECTOR 0x32 +#define IDE_CMD_33_WRITE_LONG_SECTOR 0x33 +#define IDE_CMD_38_WRITE_SECTORS_WO_ERASE 0x38 +#define IDE_CMD_3C_WRITE_VERIFY 0x3C +#define IDE_CMD_40_READ_VERIFY_SECTORS 0x40 +#define IDE_CMD_41_READ_VERIFY_SECTORS 0x41 +#define IDE_CMD_50_FORMAT_TRACK 0x50 +#define IDE_CMD_70_SEEK 0x70 +#define IDE_CMD_71_SEEK 0x71 +#define IDE_CMD_72_SEEK 0x72 +#define IDE_CMD_73_SEEK 0x73 +#define IDE_CMD_74_SEEK 0x74 +#define IDE_CMD_75_SEEK 0x75 +#define IDE_CMD_76_SEEK 0x76 +#define IDE_CMD_77_SEEK 0x77 +#define IDE_CMD_78_SEEK 0x78 +#define IDE_CMD_79_SEEK 0x79 +#define IDE_CMD_7A_SEEK 0x7A +#define IDE_CMD_7B_SEEK 0x7B +#define IDE_CMD_7C_SEEK 0x7C +#define IDE_CMD_7D_SEEK 0x7D +#define IDE_CMD_7E_SEEK 0x7E +#define IDE_CMD_7F_SEEK 0x7F +#define IDE_CMD_87_TRANSLATE_SECTOR 0x87 +#define IDE_CMD_90_EXEC_DRIVE_DIAGNOSTIC 0x90 +#define IDE_CMD_91_INIT_DRIVE_PARAMS 0x91 +#define IDE_CMD_94_STANDBY_IMMEDIATE 0x94 +#define IDE_CMD_95_IDLE_IMMEDIATE 0x95 +#define IDE_CMD_96_STANDBY 0x96 +#define IDE_CMD_97_IDLE 0x97 +#define IDE_CMD_98_CHECK_POWER_MODE 0x98 +#define IDE_CMD_99_SET_SLEEP_MODE 0x99 +#define IDE_CMD_C0_ERASE_SECTOR 0xC0 +#define IDE_CMD_C4_READ_MULTIPLE 0xC4 +#define IDE_CMD_C6_SET_MULTIPLE_MODE 0xC6 +#define IDE_CMD_CD_WRITE_MULT_WO_ERASE 0xCD +#define IDE_CMD_E0_STANDBY_IMMEDIATE 0xE0 +#define IDE_CMD_E1_IDLE_IMMEDIATE 0xE1 +#define IDE_CMD_E2_STANDBY 0xE2 +#define IDE_CMD_E3_IDLE 0xE3 +#define IDE_CMD_E4_READ_BUFFER 0xE4 +#define IDE_CMD_E5_CHECK_POWER_MODE 0xE5 +#define IDE_CMD_E6_SET_SLEEP_MODE 0xE6 +#define IDE_CMD_E8_WRITE_BUFFER 0xE8 +#define IDE_CMD_EC_IDENTIFY_DRIVE 0xEC +#define IDE_CMD_EF_SET_FEATURES 0xEF +#define IDE_CMD_F1_SECUR_SET_PASSWORD 0xF1 +#define IDE_CMD_F2_SECUR_UNLOCK 0xF2 +#define IDE_CMD_F3_SECUR_ERASE_PREPARE 0xF3 +#define IDE_CMD_F4_SECUR_ERASE_UNIT 0xF4 +#define IDE_CMD_F5_SECUR_FREEZE_LOCK 0xF5 +#define IDE_CMD_F6_SECUR_DISABLE_PASSWORD 0xF6 + +#define IDE_STS_BUSY 0x80 +#define IDE_STS_RDY 0x40 +#define IDE_STS_DWF 0x20 +#define IDE_STS_DSC 0x10 +#define IDE_STS_DRQ 0x08 +#define IDE_STS_CORR 0x04 +#define IDE_STS_IDX 0x02 +#define IDE_STS_ERR 0x01 + +#define IDE_ERR_10_SECTOR_NOT_FOUND 0x10 +#define IDE_ERR_04_ABORT 0x04 +#define IDE_ERR_01_GENERAL_ERROR 0x01 +#define IDE_ERR_00_NONE 0x00 + +#define IDE_DIA_80_SLAVE_ERR 0x80 +#define IDE_DIA_05_CPU_ERR 0x05 +#define IDE_DIA_04_ECC_CIRCUITRY_ERR 0x04 +#define IDE_DIA_03_SECTOR_BUFFER_ERR 0x03 +#define IDE_DIA_02_FORMAT_ERR 0x02 +#define IDE_DIA_01_NO_ERROR 0x01 + +typedef struct { + uint8 Bytes[SECTOR_SIZE]; +} EmSector; + +typedef uint8 DiskStatus; +typedef uint32 LogicalBlockAddr; + +typedef enum { + EM_DISK_GENERIC_8MB +} EmDiskTypeID; + +class SessionFile; + +typedef struct { + uint8 Bytes[2]; +} _Word; + +typedef enum { + CF_MEM_TUPLE, + CF_MEM_CONFIG, + CF_MEM_ATA, + CF_MEM_RESET +} CFMemSection; + + +const uint32 kMemoryStartCF = 0x18000000; + +const uint32 kMemoryOffsetCFTuple = 0; +const uint32 kMemoryStartCFTuple = kMemoryStartCF + kMemoryOffsetCFTuple; +const uint32 kMemorySizeCFTuple = 0x200; + +const uint32 kMemoryOffsetCFConfig = kMemoryOffsetCFTuple + kMemorySizeCFTuple; +const uint32 kMemoryStartCFConfig = kMemoryStartCF + kMemoryOffsetCFConfig; +const uint32 kMemorySizeCFConfig = 0xE00; + +const uint32 kMemoryOffsetCFAta = kMemoryOffsetCFConfig + kMemorySizeCFConfig; +const uint32 kMemoryStartCFAta = kMemoryStartCF + kMemoryOffsetCFAta; +const uint32 kMemorySizeCFAta = 0x1000; + +const uint32 kMemoryOffsetCFReset = kMemoryOffsetCFAta + kMemorySizeCFAta; +const uint32 kMemoryStartCFReset = kMemoryStartCF + kMemoryOffsetCFReset; +const uint32 kMemorySizeCFReset = 0x200; + +const uint32 kMemorySizeCF = kMemoryOffsetCFReset + kMemorySizeCFReset; + +#include "EmRegs.h" +#include "EmHandEraCFBus.h" + + +#endif // EmTRGCFDefs_h diff --git a/SrcShared/Hardware/TRG/EmTRGCFIO.cpp b/SrcShared/Hardware/TRG/EmTRGCFIO.cpp new file mode 100644 index 0000000..d1ec47e --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRGCFIO.cpp @@ -0,0 +1,236 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmTRGCFIO.h" + + +//------------------------------------------------------------------------- +// This file implements card I/O emulation by performing read and write +// operations on a file on the PC. Note that this file doesn't know +// anything about ATA registers ... it's more of a state machine for +// a continuous series of reads and writes +// +// These functions will create a disk file on the PC ... if one doesn't +// exist, it will create it in a formatted state. +// +// The code should work even if the disk file is replaced by an image +// from a real card ... there is no additional info stored with the card +// however, the tuple info won't agree with the card +//--------------------------------------------------------------------------- + +// --------------------------------------------------------------------------- +// ¥ EmCFIO::EmCFIO +// --------------------------------------------------------------------------- +EmCFIO::EmCFIO (void) +{ +} + +// --------------------------------------------------------------------------- +// ¥ EmCFIO::~EmCFIO +// --------------------------------------------------------------------------- +EmCFIO::~EmCFIO (void) +{ +} + +// --------------------------------------------------------------------------- +// ¥ EmCFIO::~EmCFIO +// --------------------------------------------------------------------------- +void EmCFIO::Reset(void) +{ + State.NumSectorsRequested = 0; + State.NumSectorsCompleted = 0; + State.SectorIndex = 0; + State.Status = DIO_SUCCESS; + State.Error = 0; +} + +// --------------------------------------------------------------------------- +// ¥ EmCFIO::Initialize +// --------------------------------------------------------------------------- +void EmCFIO::Initialize (EmDiskTypeID ID) +{ + DiskTypeID = ID; + DiskIO.Initialize(ID, CF_DRIVE); + Reset(); +} + +// --------------------------------------------------------------------------- +// ¥ EmCFIO::Dispose +// --------------------------------------------------------------------------- +void EmCFIO::Dispose (void) +{ + DiskIO.Dispose(); +} + + +// --------------------------------------------------------------------------- +// ¥ EmCFIO::ReadSector +// --------------------------------------------------------------------------- +DiskIOStatus EmCFIO::ReadSector(void) +{ + if ((DiskIO.ReadSector(State.Lba, (char *)State.Sector.Bytes)) != 0) + return DIO_ERROR; + + return DIO_SUCCESS; +} + +// --------------------------------------------------------------------------- +// ¥ EmCFIO::WriteSector +// --------------------------------------------------------------------------- +DiskIOStatus EmCFIO::WriteSector(void) +{ + if ((DiskIO.WriteSector(State.Lba, (char *)State.Sector.Bytes)) != 0) + return DIO_ERROR; + + return DIO_SUCCESS; +} + +// --------------------------------------------------------------------------- +// ¥ EmCFIO::ReadNextDataByte +// --------------------------------------------------------------------------- +void EmCFIO::ReadNextDataByte(uint8 * val) +{ + // this first statement will likely not be called except when someone's + // dumping memory at our address range + if (State.NumSectorsCompleted >= State.NumSectorsRequested) + *val = 0; + else + { + *val = State.Sector.Bytes[State.SectorIndex++]; + if (State.SectorIndex >= SECTOR_SIZE) + { + if (++State.NumSectorsCompleted < State.NumSectorsRequested) + { + State.Lba++; + State.SectorIndex = 0; + State.Status = ReadSector(); + } + } + } + if (State.Status != DIO_SUCCESS) + State.Error = IDE_ERR_01_GENERAL_ERROR; +} + +// --------------------------------------------------------------------------- +// ¥ EmCFIO::WriteNextDataByte +// --------------------------------------------------------------------------- +void EmCFIO::WriteNextDataByte(uint8 val) +{ + State.Status = DIO_SUCCESS; + if (State.NumSectorsCompleted < State.NumSectorsRequested) + { + State.Sector.Bytes[State.SectorIndex++] = val; + if (State.SectorIndex >= SECTOR_SIZE) + { + if (WriteSector() == DIO_ERROR) + State.Status = DIO_ERROR; + else if (++State.NumSectorsCompleted < State.NumSectorsRequested) + { + State.Status = DIO_SUCCESS; + State.Lba++; + State.SectorIndex = 0; + } + } + } + if (State.Status != DIO_SUCCESS) + State.Error = IDE_ERR_01_GENERAL_ERROR; +} + +// --------------------------------------------------------------------------- +// ¥ EmCFIO::GetSectorCount +// --------------------------------------------------------------------------- +uint32 EmCFIO::GetSectorCount(void) +{ + return State.NumSectorsCompleted; +} + +// --------------------------------------------------------------------------- +// ¥ EmCFIO::StartDriveID +// --------------------------------------------------------------------------- +void EmCFIO::StartDriveID(void) +{ + CurrDisk.GetDriveID(DiskTypeID, + &State.Sector); + State.NumSectorsRequested = 1; + State.NumSectorsCompleted = 0; + State.SectorIndex = 0; + State.Status = DIO_SUCCESS; + State.Error = 0; +} + +// --------------------------------------------------------------------------- +// ¥ EmCFIO::StartRead +// --------------------------------------------------------------------------- +void EmCFIO::StartRead(DiskIOParams * params) +{ + State.Lba = params->Lba; + State.NumSectorsRequested = params->SectorCnt; + State.NumSectorsCompleted = 0; + State.SectorIndex = 0; + State.Error = 0; + State.Status = ReadSector(); +} + +// --------------------------------------------------------------------------- +// ¥ EmCFIO::StartWrite +// --------------------------------------------------------------------------- +void EmCFIO::StartWrite(DiskIOParams * params) +{ + State.Lba = params->Lba; + State.NumSectorsRequested = params->SectorCnt; + State.NumSectorsCompleted = 0; + State.SectorIndex = 0; + State.Status = DIO_SUCCESS; + State.Error = 0; +} + +// --------------------------------------------------------------------------- +// ¥ EmCFIO::GetStatus +// --------------------------------------------------------------------------- +void EmCFIO::GetStatus(DiskIOStatus * status, + DiskDataStatus * dataStatus) +{ + *status = State.Status; + if (State.NumSectorsCompleted == State.NumSectorsRequested) + *dataStatus = DIO_DATA_COMPLETE; + else + *dataStatus = DIO_MORE_DATA; +} + +// --------------------------------------------------------------------------- +// ¥ EmCFIO::GetError +// --------------------------------------------------------------------------- +DiskIOError EmCFIO::GetError(void) +{ + if (State.Status == DIO_SUCCESS) + return(0); + else + // at this point, all errors are pretty much the same ... we can't + // create our emulation file ... we probably will need to include + // some more refined error codes at some point + return(State.Error); +} + + +void EmCFIO::SetError(DiskIOError error) +{ + State.Status = DIO_ERROR; + State.Error = error; +} + +void EmCFIO::ClearError(void) +{ + State.Status = DIO_SUCCESS; + State.Error = 0; +} diff --git a/SrcShared/Hardware/TRG/EmTRGCFIO.h b/SrcShared/Hardware/TRG/EmTRGCFIO.h new file mode 100644 index 0000000..5ce0974 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRGCFIO.h @@ -0,0 +1,90 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmTRGCFIO_h +#define EmTRGCFIO_h + +#include "EmTRGCFDefs.h" +#include "EmTRGDiskType.h" +#include "EmTRGDiskIO.h" + +#include <stdio.h> // FILE + +#define DISKFILE_NAME "trgdrv.dat" + +typedef struct { + uint32 DriveNum; + LogicalBlockAddr Lba; + uint32 SectorCnt; +} DiskIOParams; + +typedef enum { + DIO_SUCCESS = 0, + DIO_ERROR = 1 +} DiskIOStatus; + +typedef enum { + DIO_DATA_COMPLETE = 0, + DIO_MORE_DATA = 1 +} DiskDataStatus; + +//typedef enum { +// DIO_ERR_NONE = 0, +// DIO_ERR_GENERIC = 1 +//} DiskIOError; +typedef uint8 DiskIOError; + +typedef struct { + LogicalBlockAddr Lba; + uint32 NumSectorsRequested; + uint32 NumSectorsCompleted; + EmSector Sector; + int SectorIndex; + DiskIOStatus Status; + DiskIOError Error; +} DiskIOState; + +class EmCFIO +{ +public: + EmCFIO (void); + virtual ~EmCFIO (void); + + // EmRegs overrides + void Initialize(EmDiskTypeID DiskTypeID); + void Dispose(void); + void Reset(void); + void StartDriveID(void); + void ReadNextDataByte(uint8 * val); + void WriteNextDataByte(uint8 val); + uint32 GetSectorCount(void); + void StartRead(DiskIOParams * params); + void StartWrite(DiskIOParams * params); + void GetStatus(DiskIOStatus * status, + DiskDataStatus * dataStatus); + DiskIOError GetError(void); + void SetError(DiskIOError error); + void ClearError(void); + +private: + EmDiskTypeID DiskTypeID; + EmCurrDiskType CurrDisk; + DiskIOStatus WriteSector(void); + DiskIOStatus ReadSector(void); + void CloseFile(void); + DiskIOState State; + + EmTRGDiskIO DiskIO; +}; + +#endif /* EmTRGCFIO_h */ diff --git a/SrcShared/Hardware/TRG/EmTRGCFMem.cpp b/SrcShared/Hardware/TRG/EmTRGCFMem.cpp new file mode 100644 index 0000000..3d9a169 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRGCFMem.cpp @@ -0,0 +1,349 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmTRGCFMem.h" + +// ------------------------------------------------------------------------ +// This file emulates the Registers on the CF Memory Card aside from the +// ATA registers (they are handled in a different source file). +// +// Address Description Class +// --------------------- -------------------- --------------------- +// 0x18000000-0x180001FF Card Tuple EmRegsCFTuple +// 0x18000200-0x18000FFF Configuration Regs EmRegsCFConfig +// 0x18001000-0x18001FFF ATA Registers +// 0x18002000 CF Reset EmRegsCFReset +// ------------------------------------------------------------------------ + +//---------------------------------------------------------------------------- +// Configuration Option Register (Base + 00h in Attribute Memory) +// +// The Configuration Option Register is used to configure the cards interface, +// address decoding and interrupt and to issue a soft reset to the CompactFlash +// Storage Card or CF+ Card. +// +// D7 D6 D5 D4 D3 D2 D1 D0 +// R/W SRESET LevlREQ Conf5 Conf4 Conf3 Conf2 Conf1 Conf0 +// +// SRESET - Soft Reset: setting this bit to one (1), waiting the minimum reset +// width time and returning to zero (0) places the CompactFlash Storage Card +// or CF+ Card in the Reset state. Setting this bit to one (1) is equivalent +// to assertion of the +RESET signal except that the SRESET bit is not cleared. +// Returning this bit to zero (0) leaves the CompactFlash Storage +// Card or CF+ Card in the same un-configured, Reset state as following +// power-up and hardware reset. This bit is set to zero (0) by power-up and +// hardware reset. For CompactFlash Storage Cards, using the PCMCIA Soft +// Reset is considered a hard Reset by the ATA Commands. Contrast with Soft +// Reset in the Device Control Register. +// +// LevlREQ: this bit is set to one (1) when Level Mode Interrupt is selected, +// and zero (0) when Pulse Mode is selected. Set to zero (0) by Reset. +// +// Conf5 - Conf0 - Configuration Index: set to zero (0) by reset. It is used +// to select operation mode of the CompactFlash Storage Card or CF+ Card +// as shown below. +/// Note: Conf5 and Conf4 are reserved for CompactFlash Storage cards and +// must be written as zero (0) These bits are vendor defined for CF+ Cards. +// +// CompactFlash Storage Card Configurations +// Conf5 Conf4 Conf3 Conf2 Conf1 Conf0 Disk Card Mode +// 0 0 0 0 0 0 Memory Mapped +// 0 0 0 0 0 1 I/O Mapped, Any 16 byte system +// decoded boundary +// 0 0 0 0 1 0 I/O Mapped, 1F0h-1F7h/3F6h-3F7h +// 0 0 0 0 1 1 I/O Mapped, 170h-177h/376h-377h +// +// CF+ Card Configurations +// Conf5 Conf4 Conf3 Conf2 Conf1 Conf0 CF+ Card Mode +// 0 0 0 0 0 0 Memory Mapped, I/O cycles are ignored +// X X X X X X Any non-zero value, vendor defined +// +// On Multiple Function CF+ Cards, bits in this field enable the following +// functionality: +// +// Bit 0 Enable Function - If this bit is reset to zero (0), the function is +// disabled. If this bit is set to one (1), the function is enabled. +// +// Bit 1 Enable Base and Limit Registers - If this bit is reset to zero (0) +// and Bit 0 is set to one (1), all I/O addresses on the host system are +// passed to the function. If this is set to one (1) and Bit 0 is set to one +// (1), only I/O addresses that are qualified by the Base and Limit registers +// are passed to the function. If Bit 0 is reset to zero (0), this bit is +// undefined. +// +// Bit 2 Enable IREQ# Routing - If this bit is reset to zero (0) and Bit 0 +// is set to one (1), this function shall not generate interrupt requests +// on the CF+ Card's IREQ# line. If this is set to one (1) and +// Bit 0 is set to one (1), this function shall generate interrupt requests +// on the CF+ Card's IREQ# line. If Bit 0 is reset to zero (0), this bit is +// undefined. +// +// Bit 3..5 Reserved for vendor implementation. +//---------------------------------------------------------------------------- + +//---------------------------------------------------------------------------- +// Card Configuration and Status Register (Base + 02h in Attribute Memory) +// The Card Configuration and Status Register contains information about the +// Card's condition. +// +// Operation D7 D6 D5 D4 D3 D2 D1 D0 +// ---------- ------- ------ ------- ------- ------- ------ ------ ------ +// Read Changed SigChg IOis8 -XE Audio PwrDwn Int 0 +// Write 0 SigChg IOis8 -XE Audio PwrDwn 0 0 +// +// Changed: indicates that one or both of the Pin Replacement register CRdy, +// or CWProt bits are set to one (1). When the Changed bit is set, +// -STSCHG Pin 46 is held low if the SigChg bit is a One (1) and the +// CompactFlash Storage Card or CF+ Card is configured for the I/O interface. +// +// SigChg: this bit is set and reset by the host to enable and disable a +// state-change signal from the Status Register, the Changed bit control +// pin 46 the Changed Status signal. If no state change signal is desired, +// this bit should be set to zero (0) and pin 46 (-STSCHG) signal will +// be held high while the CompactFlash Storage Card or CF+ Card is configured +// for I/O. +// +// IOis8: the host sets this bit to a one (1) if the CompactFlash Storage +// Card or CF+ Card is to be configured in an 8 bit I/O Mode. The +// CompactFlash Storage Card is always configured for both 8- and 16-bit I/O, +// so this bit is ignored. Some CF+ cards can be configured for either 8- +// bit I/O mode or 16-bit I/O mode, so CF+ cards may respond to this bit. +// +// -XE: this bit is set and reset by the host to disable and enable Power +// Level 1 commands in CF+ cards. If the value is 0, Power Level 1 commands +// are enabled; if it is 1, Power Level 1 commands are disabled. Default +// value at power on or after reset is 0. The host may read the value of +// this bit to determine whether Power Level 1 commands are currently enabled. +// For CompactFlash Storage cards (which must not support Power Level 1), +// this bit has value 0 and is not writeable. +// +// Audio: this bit is set and reset by the host to enable and disable +// audio information on SPKR# when the CF+ card is configured. This bit +// should always be zero for CompactFlash Storage cards. +// +// PwrDwn: this bit indicates whether the host requests the CompactFlash +// Storage Card or CF+ Card to be in the power saving or active mode. When +// the bit is one (1), the CompactFlash Storage Card or CF+ Card enters a +// power down mode. When zero (0), the host is requesting the CompactFlash +// Storage Card or CF+ Card to enter the active mode. The PCMCIA Rdy/-Bsy +// value becomes BUSY when this bit is changed. Rdy/-Bsy will not become +// Ready until the power state requested has been entered. The CompactFlash +// Storage Card automatically powers down when it is idle and powers back up +// when it receives a command. +// +// Int: this bit represents the internal state of the interrupt request. +// This value is available whether or not I/O interface has been configured. +// This signal remains true until the condition which caused the interrupt +// request has been serviced. If interrupts are disabled by the -IEN bit in +// the Device Control Register, this bit is a zero (0). +//---------------------------------------------------------------------------- + +//---------------------------------------------------------------------------- +// Pin Replacement Register (Base + 04h in Attribute Memory) +// +// Operation D7 D6 D5 D4 D3 D2 D1 D0 +// --------- ------ ------ --------- ------ ------ ------ -------- ------ +// Read 0 0 CRdy/-Bsy CWProt 1 1 Rdy/-Bsy WProt +// Write 0 0 CRdy/-Bsy CWProt 0 0 MRdy/-Bsy MWProt +// +// CRdy/-Bsy: this bit is set to one (1) when the bit RRdy/-Bsy changes state. +// This bit can also be written by the host. +// +// CWProt: this bit is set to one (1) when the RWprot changes state. +// This bit may also be written by the host. +// +// Rdy/-Bsy: this bit is used to determine the internal state of the Rdy/-Bsy +// signal. This bit may be used to determine the state of the Ready/-Busy as +// this pin has been reallocated for use as Interrupt Request on an I/O card. +// When written, this bit acts as a mask for writing the corresponding bit +// CRdy/-Bsy. +// +// Wprot: this bit is always zero (0) since the CompactFlash Storage Card or +// CF+ Card does not have a Write Protect switch. When written, this bit acts +// as a mask for writing the corresponding bit CWProt. +// +// MRdy/-Bsy: this bit acts as a mask for writing the corresponding bit +// CRdy/-Bsy. +// +// MWProt: this bit when written acts as a mask for writing the corresponding +// bit CWProt. +// +// Pin Replacement Changed Bit/Mask Bit Values +// +// Initial Value | Written by Host | Final | Comments +// of (C) Status | C-Bit M-Bit | C-Bit | +// ------------- | --------------- | ----- | ---------- +// 0 | X 0 | 0 | Unchanged +// 1 | X 0 | 1 | Unchanged +// X | 0 1 | 0 | Cleared by Host +// X | 1 1 | 1 | Set by Host +//---------------------------------------------------------------------------- + +//---------------------------------------------------------------------------- +// Socket and Copy Register (Base + 06h in Attribute Memory) +// +// This register contains additional configuration information. This register +// is always written by the system before writing the card's Configuration +// Index Register. This register is not required for CF+ Cards. +// +// Operation D7 D6 D5 D4 D3 D2 D1 D0 +// --------- ------ ------ ------ ------ ------ ------ ------ ------ +// Read Resrvd 0 0 Drive# 0 0 0 0 +// Write 0 0 0 Drive# X X X X +// +// Reserved: this bit is reserved for future standardization. This bit must +// be set to zero (0) by the software when the register is written. +// +// Drive #: this bit indicates the drive number of the card for twin card +// configuration. +// +// X: the socket number is ignored by the CompactFlash Storage Card. +//---------------------------------------------------------------------------- +static uint8 CFRegMem[] = { + 0x00, 0x00, 0x00, 0x80, 0x00, 0x2E, 0x00, 0x00, +}; + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFConfig::InRange +// --------------------------------------------------------------------------- +Boolean EmRegsCFConfig::InRange(uint32 offset) +{ + if (offset < sizeof(CFRegMem)) + return(true); + else + return(false); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFConfig::Initialize +// --------------------------------------------------------------------------- +void EmRegsCFConfig::Initialize(EmDiskTypeID /*ID*/) +{ +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFConfig::ReadByte +// --------------------------------------------------------------------------- +void EmRegsCFConfig::ReadByte(uint32 offset, uint8 * val) +{ + if (InRange(offset)) + *val = CFRegMem[offset]; + else + *val = 0; +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFConfig::WriteByte +// --------------------------------------------------------------------------- +void EmRegsCFConfig::WriteByte(uint32 /*offset*/, uint8 /*val*/) +{ +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFConfig::ReadWord +// --------------------------------------------------------------------------- +void EmRegsCFConfig::ReadWord(uint32 offset, _Word * val) +{ + ReadByte(offset, &val->Bytes[0]); + ReadByte(offset+1, &val->Bytes[1]); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFConfig::WriteWord +// --------------------------------------------------------------------------- +void EmRegsCFConfig::WriteWord(uint32 /*offset*/, _Word /*val*/) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFReset::Initialize +// --------------------------------------------------------------------------- +void EmRegsCFReset::Initialize(EmDiskTypeID /*ID*/) +{ +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFReset::ReadByte +// --------------------------------------------------------------------------- +void EmRegsCFReset::ReadByte(uint32 /*offset*/, uint8 * val) +{ + *val = 0; +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFReset::WriteByte +// --------------------------------------------------------------------------- +void EmRegsCFReset::WriteByte(uint32 /*offset*/, uint8 /*val*/) +{ +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFReset::ReadWord +// --------------------------------------------------------------------------- +void EmRegsCFReset::ReadWord(uint32 /*offset*/, _Word * val) +{ + val->Bytes[0] = val->Bytes[1] = 0; +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFReset::WriteWord +// --------------------------------------------------------------------------- +void EmRegsCFReset::WriteWord(uint32 /*offset*/, _Word /*val*/) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFTuple::Initialize +// --------------------------------------------------------------------------- +void EmRegsCFTuple::Initialize(EmDiskTypeID DiskTypeID) +{ + CurrDisk.GetTuple(DiskTypeID, + &tuple); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFTuple::ReadByte +// --------------------------------------------------------------------------- +void EmRegsCFTuple::ReadByte(uint32 offset, uint8 * val) +{ + if (offset < sizeof(EmSector)) + *val = tuple.Bytes[offset]; + else + *val = 0; +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFTuple::WriteByte +// --------------------------------------------------------------------------- +void EmRegsCFTuple::WriteByte(uint32 /*offset*/, uint8 /*val*/) +{ +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFTuple::ReadWord +// --------------------------------------------------------------------------- +void EmRegsCFTuple::ReadWord(uint32 offset, _Word * val) +{ + ReadByte(offset, &val->Bytes[0]); + ReadByte(offset+1, &val->Bytes[1]); +} + +// --------------------------------------------------------------------------- +// ¥ EmRegsCFTuple::WriteWord +// --------------------------------------------------------------------------- +void EmRegsCFTuple::WriteWord(uint32 /*offset*/, _Word /*val*/) +{ +} diff --git a/SrcShared/Hardware/TRG/EmTRGCFMem.h b/SrcShared/Hardware/TRG/EmTRGCFMem.h new file mode 100644 index 0000000..699daf1 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRGCFMem.h @@ -0,0 +1,66 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +/**************************************************************************************** +** File: Bank_CF_Config.h +** Date: 6/14/00 +** Project: POSE +** Author: Dan Kolz +** Notes: This class is an emulation of the config area on a CF card. +** It takes its information from a hardcoded array in the source code. +****************************************************************************************/ + +#ifndef EmTRGCFMem_h +#define EmTRGCFMem_h + +#include "EmRegs.h" +#include "EmTRGCFDefs.h" +#include "EmTRGDiskType.h" + +class EmRegsCFConfig +{ + public: + void Initialize(EmDiskTypeID ID); + void ReadByte(uint32 offset, uint8 * val); + void WriteByte(uint32 offset, uint8 val); + void ReadWord(uint32 offset, _Word * val); + void WriteWord(uint32 offset, _Word val); + private: + Boolean InRange(uint32 offset); +}; + +class EmRegsCFReset +{ + public: + void Initialize(EmDiskTypeID ID); + void ReadByte(uint32 offset, uint8 * val); + void WriteByte(uint32 offset, uint8 val); + void ReadWord(uint32 offset, _Word * val); + void WriteWord(uint32 offset, _Word val); + private: +}; + +class EmRegsCFTuple +{ + public: + void Initialize(EmDiskTypeID DiskTypeID); + void ReadByte(uint32 offset, uint8 * val); + void WriteByte(uint32 offset, uint8 val); + void ReadWord(uint32 offset, _Word * val); + void WriteWord(uint32 offset, _Word val); + private: + EmCurrDiskType CurrDisk; + EmSector tuple; +}; + +#endif // EmTRGCFMem_h diff --git a/SrcShared/Hardware/TRG/EmTRGDiskIO.cpp b/SrcShared/Hardware/TRG/EmTRGDiskIO.cpp new file mode 100644 index 0000000..9b43582 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRGDiskIO.cpp @@ -0,0 +1,174 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmTRGDiskIO.h" + +/************************************************************************ + * This class handles the generic low level disk access. + ************************************************************************/ +#include <stdio.h> + +#include "EmCommon.h" +#include "EmTRGDiskIO.h" + +#define CFFILE_NAME "trgdrv.dat" +#define SDFILE_NAME "trgdrvsd.dat" + +#define SECTOR_SIZE 512 + + +EmTRGDiskIO::EmTRGDiskIO() +{ + m_driveNo = UNKNOWN_DRIVE; +} + + +EmTRGDiskIO::~EmTRGDiskIO() +{ +} + + +char * EmTRGDiskIO::GetFilePath(int driveNo) +{ +#if PLATFORM_WINDOWS + static char tmp[MAX_PATH]; + + if (driveNo == CF_DRIVE) + _snprintf(tmp, sizeof(tmp), "%s\\%s", getenv("WINDIR"), CFFILE_NAME); + else + _snprintf(tmp, sizeof(tmp), "%s\\%s", getenv("WINDIR"), SDFILE_NAME); + return(tmp); +#else + if (driveNo == CF_DRIVE) + return CFFILE_NAME; + else + return SDFILE_NAME; +#endif +} + +int EmTRGDiskIO::Format(void) +{ + EmSector *buffer; + uint32 num, lba; + FILE *fp; + + fp = fopen(GetFilePath(m_driveNo), "wb"); + if (fp == NULL) + return -1; + + buffer = new EmSector; + num = m_currDisk.GetNumSectors(m_diskTypeID); + for (lba=0; lba<num; lba++) + { + m_currDisk.GetSector(m_diskTypeID, lba, buffer); + + // The most probable error condition is + // attempting to write to a full drive ... it could also + // be write-protected, or on a disconnected network drive. + if (fwrite(buffer, SECTOR_SIZE, 1, fp) == 0) + { + delete buffer; + fclose(fp); + return -1; + } + } + delete buffer; + + return 0; +} + +int EmTRGDiskIO::Read(uint32 sectorNum, void *buffer) +{ + FILE *fp; + + if ((fp = fopen(GetFilePath(m_driveNo), "rb")) == NULL) + return -1; + + if (fseek(fp, sectorNum * SECTOR_SIZE, SEEK_SET) == -1) + { + fclose(fp); + return -1; + } + + if (fread(buffer, SECTOR_SIZE, 1, fp) != 1) + { + fclose(fp); + return -1; + } + fclose(fp); + + return 0; +} + +int EmTRGDiskIO::Write(uint32 sectorNum, void *buffer) +{ + FILE *fp; + + if ((fp = fopen(GetFilePath(m_driveNo), "r+b")) == NULL) + return -1; + + if (fseek(fp, sectorNum * SECTOR_SIZE, SEEK_SET) == -1) + { + fclose(fp); + return -1; + } + + if (fwrite(buffer, SECTOR_SIZE, 1, fp) != 1) + { + fclose(fp); + return -1; + } + fclose(fp); + + return 0; +} + + +void EmTRGDiskIO::Initialize(EmDiskTypeID DiskTypeID, int driveNo) +{ + m_diskTypeID = DiskTypeID; + m_driveNo = driveNo; +} + +void EmTRGDiskIO::Dispose(void) +{ +} + +int EmTRGDiskIO::ReadSector(uint32 sectorNum, void *buffer) +{ + int retval; + + if ((retval = Read(sectorNum, buffer)) != 0) + { + Format(); + retval = Read(sectorNum, buffer); + } + + return retval; +} + + + +int EmTRGDiskIO::WriteSector(uint32 sectorNum, void *buffer) +{ + int retval; + + if ((retval = Write(sectorNum, buffer)) != 0) + { + Format(); + retval = Write(sectorNum, buffer); + } + + return retval; +} diff --git a/SrcShared/Hardware/TRG/EmTRGDiskIO.h b/SrcShared/Hardware/TRG/EmTRGDiskIO.h new file mode 100644 index 0000000..74bca58 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRGDiskIO.h @@ -0,0 +1,53 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmTRGDiskIO_h +#define EmTRGDiskIO_h + +/************************************************************************ + * This class handles the generic low level disk access. + ************************************************************************/ +#include "EmTRGCFDefs.h" +#include "EmTRGDiskType.h" + +#define UNKNOWN_DRIVE 0 +#define CF_DRIVE 1 +#define SD_DRIVE 2 + +#define SECTOR_SIZE 512 + +class EmTRGDiskIO +{ +private: + int m_driveNo; + EmDiskTypeID m_diskTypeID; + EmCurrDiskType m_currDisk; + + int Format(void); + char *GetFilePath(int driveNo); + + int Read(uint32 sectorNum, void *buffer); + int Write(uint32 sectorNum, void *buffer); + +public: + EmTRGDiskIO(void); + ~EmTRGDiskIO(); + + void Initialize(EmDiskTypeID DiskTypeID, int driveNo); + void Dispose(void); + + int ReadSector(uint32 sectorNum, void *buffer); + int WriteSector(uint32 sectorNum, void *buffer); +}; + +#endif /* EmTRGDiskIO_h */ diff --git a/SrcShared/Hardware/TRG/EmTRGDiskType.cpp b/SrcShared/Hardware/TRG/EmTRGDiskType.cpp new file mode 100644 index 0000000..571571f --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRGDiskType.cpp @@ -0,0 +1,511 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmTRGDiskType.h" + + +//--------------------------------------------------------------------------- +// This file is used to determine what sort of memory card is being +// emulated ... so far, the only supported type is a generic 8MB card. +// Card emulation requires having a copy of the Tuple, Drive ID, and +// format sectors for a particular card +//--------------------------------------------------------------------------- + +#define B(x) x, 0 + +static const EmSector _8MBTuple = {{ + B(0x01), B(0x04), B(0xdf), B(0x4a), B(0x01), B(0xff), B(0x1c), B(0x04), + B(0x02), B(0xd9), B(0x01), B(0xff), B(0x18), B(0x02), B(0xdf), B(0x01), + B(0x20), B(0x04), B(0x07), B(0x00), B(0x00), B(0x00), B(0x15), B(0x15), + B(0x04), B(0x01), B(0x55), B(0x4e), B(0x49), B(0x54), B(0x59), B(0x20), + B(0x44), B(0x49), B(0x47), B(0x49), B(0x54), B(0x41), B(0x4c), B(0x00), + B(0x33), B(0x2e), B(0x30), B(0x00), B(0xff), B(0x21), B(0x02), B(0x04), + B(0x01), B(0x22), B(0x02), B(0x01), B(0x01), B(0x22), B(0x03), B(0x02), + B(0x0c), B(0x0f), B(0x1a), B(0x05), B(0x01), B(0x03), B(0x00), B(0x02), + B(0x0f), B(0x1b), B(0x08), B(0xc0), B(0xc0), B(0xa1), B(0x01), B(0x55), + B(0x08), B(0x00), B(0x20), B(0x1b), B(0x06), B(0x00), B(0x01), B(0x21), + B(0xb5), B(0x1e), B(0x4d), B(0x1b), B(0x0a), B(0xc1), B(0x41), B(0x99), + B(0x01), B(0x55), B(0x64), B(0xf0), B(0xff), B(0xff), B(0x20), B(0x1b), + B(0x06), B(0x01), B(0x01), B(0x21), B(0xb5), B(0x1e), B(0x4d), B(0x1b), + B(0x0f), B(0xc2), B(0x41), B(0x99), B(0x01), B(0x55), B(0xea), B(0x61), + B(0xf0), B(0x01), B(0x07), B(0xf6), B(0x03), B(0x01), B(0xee), B(0x20), + B(0x1b), B(0x06), B(0x02), B(0x01), B(0x21), B(0xb5), B(0x1e), B(0x4d), + B(0x1b), B(0x0f), B(0xc3), B(0x41), B(0x99), B(0x01), B(0x55), B(0xea), + B(0x61), B(0x70), B(0x01), B(0x07), B(0x76), B(0x03), B(0x01), B(0xee), + B(0x20), B(0x1b), B(0x06), B(0x03), B(0x01), B(0x21), B(0xb5), B(0x1e), + B(0x4d), B(0x14), B(0x00), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), + B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), + B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), + B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), + B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), + B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), + B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), + B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), + B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), + B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), + B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), + B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), + B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), B(0xff), +}}; + +static const uint8 _8MBSD_CID[] = { + 0x00, 0x00, 0x02, 0x53, 0x44, 0x4D, 0x42, 0x2D, + 0x38, 0x00, 0x20, 0x06, 0x3A, 0x12, 0x32, 0x35 +}; + +static const uint8 _8MBSD_CSD[] = { + 0x44, 0x26, 0x00, 0x2A, 0x1F, 0xF9, 0x81, 0xE9, + 0xE4, 0xB4, 0x83, 0xFF, 0x92, 0x40, 0x40, 0x81 +}; + +#define W(x, y) x, y + +static const EmSector _8MBDriveID = +{{ + W(0x8A, 0x84), W(0xF6, 0x00), W(0x00, 0x00), W(0x02, 0x00), W(0x00, 0x00), W(0x00, 0x02), W(0x20, 0x00), W(0x00, 0x00), + W(0x80, 0x3D), W(0x00, 0x00), W(0x20, 0x20), W(0x20, 0x20), W(0x20, 0x20), W(0x20, 0x20), W(0x20, 0x20), W(0x20, 0x20), + W(0x20, 0x20), W(0x20, 0x20), W(0x20, 0x20), W(0x20, 0x20), W(0x02, 0x00), W(0x02, 0x00), W(0x04, 0x00), W(0x65, 0x52), + W(0x20, 0x76), W(0x2E, 0x31), W(0x32, 0x30), W(0x69, 0x48), W(0x61, 0x74), W(0x68, 0x63), W(0x20, 0x69), W(0x56, 0x43), + W(0x36, 0x20), W(0x31, 0x2E), W(0x32, 0x2E), W(0x20, 0x20), W(0x20, 0x20), W(0x20, 0x20), W(0x20, 0x20), W(0x20, 0x20), + W(0x20, 0x20), W(0x20, 0x20), W(0x20, 0x20), W(0x20, 0x20), W(0x20, 0x20), W(0x20, 0x20), W(0x20, 0x20), W(0x01, 0x00), + W(0x00, 0x00), W(0x00, 0x02), W(0x00, 0x00), W(0x00, 0x01), W(0x00, 0x00), W(0x01, 0x00), W(0xF6, 0x00), W(0x02, 0x00), + W(0x20, 0x00), W(0x80, 0x3D), W(0x00, 0x00), W(0x00, 0x01), W(0x80, 0x3D), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x20, 0x00), W(0x80, 0x3D), W(0x00, 0x00), W(0x00, 0x01), W(0x80, 0x3D), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), + W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00), W(0x00, 0x00) +}}; + +static const EmSector _8MBMasterBootRecord = +{{ +0xFA, 0x33, 0xC0, 0x8E, 0xD0, 0xBC, 0x00, 0x7C, 0x8B, 0xF4, 0x50, 0x07, 0x50, 0x1F, 0xFB, 0xFC, +0xBF, 0x00, 0x06, 0xB9, 0x00, 0x01, 0xF2, 0xA5, 0xEA, 0x1D, 0x06, 0x00, 0x00, 0xBE, 0xBE, 0x07, +0xB3, 0x04, 0x80, 0x3C, 0x80, 0x74, 0x0E, 0x80, 0x3C, 0x00, 0x75, 0x1C, 0x83, 0xC6, 0x10, 0xFE, +0xCB, 0x75, 0xEF, 0xCD, 0x18, 0x8B, 0x14, 0x8B, 0x4C, 0x02, 0x8B, 0xEE, 0x83, 0xC6, 0x10, 0xFE, +0xCB, 0x74, 0x1A, 0x80, 0x3C, 0x00, 0x74, 0xF4, 0xBE, 0x8B, 0x06, 0xAC, 0x3C, 0x00, 0x74, 0x0B, +0x56, 0xBB, 0x07, 0x00, 0xB4, 0x0E, 0xCD, 0x10, 0x5E, 0xEB, 0xF0, 0xEB, 0xFE, 0xBF, 0x05, 0x00, +0x4F, 0x75, 0xED, 0xBE, 0xA3, 0x06, 0xEB, 0xD3, 0xBE, 0xC2, 0x06, 0xBF, 0xFE, 0x7D, 0x81, 0x3D, +0x55, 0xAA, 0x75, 0xC7, 0x8B, 0xF5, 0xEA, 0x00, 0x7C, 0x00, 0x00, 0x49, 0x6E, 0x76, 0x61, 0x6C, +0x69, 0x64, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x74, 0x61, 0x62, +0x6C, 0x65, 0x00, 0x45, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x6C, 0x6F, 0x61, 0x64, 0x69, 0x6E, 0x67, +0x20, 0x6F, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, +0x6D, 0x00, 0x4D, 0x69, 0x73, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x70, 0x65, 0x72, 0x61, 0x74, +0x69, 0x6E, 0x67, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x89, 0x70, 0x61, 0x72, 0x74, 0x5F, +0x62, 0x6F, 0x6F, 0x74, 0x00, 0x00, 0xEB, 0x3C, 0x90, 0x4D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, +0x01, 0x00, 0x01, 0x01, 0x20, 0xF4, 0x20, 0x00, 0x00, 0x00, 0x20, 0x3D, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0xAA +}}; + +static const EmSector _8MBBootRecord = +{{ +0xEB, 0x3C, 0x90, 0x4D, 0x53, 0x44, 0x4F, 0x53, 0x35, 0x2E, 0x30, 0x00, 0x02, 0x08, 0x01, 0x00, +0x02, 0x00, 0x02, 0x20, 0x3D, 0xF8, 0x06, 0x00, 0x20, 0x00, 0x02, 0x00, 0x20, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x29, 0x0D, 0x0B, 0x00, 0x00, 0x53, 0x41, 0x4E, 0x56, 0x4F, +0x4C, 0x20, 0x20, 0x20, 0x20, 0x20, 0x46, 0x41, 0x54, 0x31, 0x32, 0x20, 0x20, 0x20, 0x00, 0x8E, +0xC0, 0x8E, 0xD8, 0xFB, 0xFC, 0xBE, 0x6A, 0x00, 0x81, 0xC6, 0x00, 0x7C, 0xAC, 0x0A, 0xC0, 0x74, +0x0A, 0xB4, 0x0E, 0xB7, 0x00, 0xB3, 0x07, 0xCD, 0x10, 0xEB, 0xF1, 0x33, 0xC0, 0xCD, 0x16, 0xCD, +0x19, 0xBE, 0xB3, 0x00, 0x81, 0xC6, 0x00, 0x7C, 0xEB, 0xE2, 0x0D, 0x0A, 0x4E, 0x6F, 0x6E, 0x2D, +0x53, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x20, 0x64, 0x69, 0x73, 0x6B, 0x20, 0x6F, 0x72, 0x20, 0x64, +0x69, 0x73, 0x6B, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x0D, 0x0A, 0x52, 0x65, 0x70, 0x6C, 0x61, +0x63, 0x65, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6B, 0x65, 0x20, 0x61, 0x6E, +0x79, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x72, 0x65, 0x61, 0x64, 0x79, +0x0D, 0x0A, 0x00, 0x0D, 0x0A, 0x44, 0x69, 0x73, 0x6B, 0x20, 0x42, 0x6F, 0x6F, 0x74, 0x20, 0x66, +0x61, 0x69, 0x6C, 0x75, 0x72, 0x65, 0x0D, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0xAA +}}; + +static const EmSector _8MBFat = +{{ +0xF8, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}}; + +static const EmSector _8MBRootDir = +{{ +0xE5, 0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87, 'V', '?', 0x28, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x83, 0x86, 0x54, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + '8', 'M', 'B', '_', 'C', 'A', 'R', 'D', ' ', ' ', 0x20, 0x28, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x83, 0x86, 0x54, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}}; + + +// --------------------------------------------------------------------------- +// ¥ EmGeneric8MB::EmGeneric8MB +// --------------------------------------------------------------------------- +EmGeneric8MB::EmGeneric8MB(void) +{ +} + +// --------------------------------------------------------------------------- +// ¥ EmGeneric8MB::~EmGeneric8MB +// --------------------------------------------------------------------------- +EmGeneric8MB::~EmGeneric8MB(void) +{ +} + +// --------------------------------------------------------------------------- +// ¥ EmGeneric8MB::GetTuple +// --------------------------------------------------------------------------- +EmSector * EmGeneric8MB::GetTuple(void) +{ + return((EmSector *)&_8MBTuple); +} + +uint8 * EmGeneric8MB::GetSD_CSD(void) +{ + return ((uint8 *)&_8MBSD_CSD); +} + +uint8 * EmGeneric8MB::GetSD_CID(void) +{ + return ((uint8 *)&_8MBSD_CID); +} + +// --------------------------------------------------------------------------- +// ¥ EmGeneric8MB::GetDriveID +// --------------------------------------------------------------------------- +EmSector * EmGeneric8MB::GetDriveID(void) +{ + return((EmSector *)&_8MBDriveID); +} + +#define _8MB_NUM_SECTORS 16384 + +// --------------------------------------------------------------------------- +// ¥ EmGeneric8MB::GetNumSectors +// --------------------------------------------------------------------------- +uint32 EmGeneric8MB::GetNumSectors(void) +{ + return _8MB_NUM_SECTORS; +} + +// --------------------------------------------------------------------------- +// ¥ EmGeneric8MB::GetSector +// --------------------------------------------------------------------------- +EmSector * EmGeneric8MB::GetSector(LogicalBlockAddr lba) +{ + switch(lba) + { + case 0 : + return((EmSector *)&_8MBMasterBootRecord); + case 32 : + return((EmSector *)&_8MBBootRecord); + case 33 : + case 39 : + return((EmSector *)&_8MBFat); + case 45 : + return((EmSector *)&_8MBRootDir); + default : + return(EmDiskType::GetEmptySector()); + } +} + +static const EmSector DummySector = +{{ +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}}; + +// --------------------------------------------------------------------------- +// ¥ EmDiskType::EmDiskType +// --------------------------------------------------------------------------- +EmDiskType::EmDiskType(void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmDiskType::~EmDiskType +// --------------------------------------------------------------------------- +EmDiskType::~EmDiskType(void) +{ +} + +// --------------------------------------------------------------------------- +// ¥ EmDiskType::GetTuple +// --------------------------------------------------------------------------- +EmSector * EmDiskType::GetTuple(void) +{ + return (EmSector *)&DummySector; +} + +uint8 * EmDiskType::GetSD_CSD(void) +{ + return ((uint8 *)&DummySector); +} + +uint8 * EmDiskType::GetSD_CID(void) +{ + return ((uint8 *)&DummySector); +} + +// --------------------------------------------------------------------------- +// ¥ EmDiskType::GetDriveID +// --------------------------------------------------------------------------- +EmSector * EmDiskType::GetDriveID(void) +{ + return (EmSector *)&DummySector; +} + +// --------------------------------------------------------------------------- +// ¥ EmDiskType::GetEmptySector +// --------------------------------------------------------------------------- +EmSector * EmDiskType::GetEmptySector(void) +{ + return (EmSector *)&DummySector; +} + +// --------------------------------------------------------------------------- +// ¥ EmCurrDiskType::EmCurrDiskType +// --------------------------------------------------------------------------- +EmCurrDiskType::EmCurrDiskType (void) +{ +} + +// --------------------------------------------------------------------------- +// ¥ EmCurrDiskType::~EmCurrDiskType +// --------------------------------------------------------------------------- +EmCurrDiskType::~EmCurrDiskType(void) +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmCurrDiskType::GetTuple +// --------------------------------------------------------------------------- +void EmCurrDiskType::GetTuple(EmDiskTypeID ID, + EmSector * s) +{ + switch(ID) + { + case EM_DISK_GENERIC_8MB : + *s = *Generic8MB.GetTuple(); + break; + default : + *s = *UnknownDisk.GetTuple(); + break; + } +} + +uint8 *EmCurrDiskType::GetSD_CSD(EmDiskTypeID ID) +{ + switch(ID) + { + case EM_DISK_GENERIC_8MB : + return Generic8MB.GetSD_CSD(); + break; + default : + return UnknownDisk.GetSD_CSD(); + break; + } +} + +uint8 *EmCurrDiskType::GetSD_CID(EmDiskTypeID ID) +{ + switch(ID) + { + case EM_DISK_GENERIC_8MB : + return Generic8MB.GetSD_CID(); + break; + default : + return UnknownDisk.GetSD_CID(); + break; + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmCurrDiskType::GetDriveID +// --------------------------------------------------------------------------- +void EmCurrDiskType::GetDriveID(EmDiskTypeID ID, + EmSector * s) +{ + switch(ID) + { + case EM_DISK_GENERIC_8MB : + *s = *Generic8MB.GetDriveID(); + break; + default : + *s = *UnknownDisk.GetDriveID(); + break; + } +} + +// --------------------------------------------------------------------------- +// ¥ EmCurrDiskType::GetNumSectors +// --------------------------------------------------------------------------- +uint32 EmCurrDiskType::GetNumSectors(EmDiskTypeID ID) +{ + switch(ID) + { + case EM_DISK_GENERIC_8MB : + return Generic8MB.GetNumSectors(); + default : + return 0; + } +} + +// --------------------------------------------------------------------------- +// ¥ EmCurrDiskType::GetSector +// --------------------------------------------------------------------------- +void EmCurrDiskType::GetSector(EmDiskTypeID ID, + LogicalBlockAddr lba, + EmSector * s) +{ + switch(ID) + { + case EM_DISK_GENERIC_8MB : + *s = *Generic8MB.GetSector(lba); + break; + default : + *s = *UnknownDisk.GetEmptySector(); + break; + } +} diff --git a/SrcShared/Hardware/TRG/EmTRGDiskType.h b/SrcShared/Hardware/TRG/EmTRGDiskType.h new file mode 100644 index 0000000..ac88a4d --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRGDiskType.h @@ -0,0 +1,65 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#ifndef EmTRGDiskType_h +#define EmTRGDiskType_h + +#include "EmTRGCFDefs.h" + +class EmDiskType +{ +public: + EmDiskType (void); + virtual ~EmDiskType (void); + + EmSector * GetTuple(void); + uint8 * GetSD_CSD(void); + uint8 * GetSD_CID(void); + EmSector * GetDriveID(void); + EmSector * GetEmptySector(void); + +}; + +class EmGeneric8MB : public EmDiskType +{ +public: + EmGeneric8MB(void); + virtual ~EmGeneric8MB(void); + + EmSector * GetTuple(void); + uint8 * GetSD_CSD(void); + uint8 * GetSD_CID(void); + EmSector * GetDriveID(void); + uint32 GetNumSectors(void); + EmSector * GetSector(LogicalBlockAddr lba); +}; + +class EmCurrDiskType +{ +private: + EmDiskType UnknownDisk; + EmGeneric8MB Generic8MB; + +public: + EmCurrDiskType (void); + virtual ~EmCurrDiskType (void); + + void GetTuple(EmDiskTypeID ID, EmSector * s); + uint8 * GetSD_CSD(EmDiskTypeID ID); + uint8 * GetSD_CID(EmDiskTypeID ID); + void GetDriveID(EmDiskTypeID ID, EmSector * s); + uint32 GetNumSectors(EmDiskTypeID ID); + void GetSector(EmDiskTypeID ID, LogicalBlockAddr lba, EmSector * s); +}; + +#endif /* EmTRGDiskType_h */ diff --git a/SrcShared/Hardware/TRG/EmTRGSD.cpp b/SrcShared/Hardware/TRG/EmTRGSD.cpp new file mode 100644 index 0000000..ad84526 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRGSD.cpp @@ -0,0 +1,321 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ + +#include "EmCommon.h" +#include "EmTRGSD.h" + +/************************************************************************ + * This class handles the SPI SD controller interface used in the + * HandEra 330. + ************************************************************************/ + +// SPI SD commands +#define SD_CMD0_GO_IDLE 0 +#define SD_CMD1_GO_OPERATIONAL 1 +#define SD_CMD9_SEND_CSD 9 +#define SD_CMD10_SEND_CID 10 +#define SD_CMD12_STOP_TRANS 12 // not supported +#define SD_CMD13_SEND_STATUS 13 +#define SD_CMD16_SET_BLOCKLEN 16 // not supported +#define SD_CMD17_READ_SECTOR 17 +#define SD_CMD18_READ_MULTI 18 // not supported +#define SD_CMD24_WRITE_SECTOR 24 +#define SD_CMD25_WRITE_MULTI 25 // not supported +#define SD_CMD27_PROGRAM_CSD 27 // not supported +#define SD_CMD28_SET_WRITE_PROT 28 // not supported +#define SD_CMD29_CLR_WRITE_PROT 29 // not supported +#define SD_CMD30_SEND_WRITE_PROT 30 // not supported +#define SD_CMD32_ERASE_WR_BLK_START 32 // not supported +#define SD_CMD33_ERASE_WR_BLK_END 33 // not supported +#define SD_CMD38_ERASE 38 // not supported +#define SD_CMD42_LOCK_UNLOCK 42 // not supported +#define SD_CMD55_APP_CMD 55 // not supported +#define SD_CMD56_GEN_CMD 56 // not supported +#define SD_CMD58_READ_OCR 58 // not supported +#define SD_CMD59_CRC_ON_OFF 59 // not supported + +#define SD_CMD_SIZE 6 // in bytes +#define SD_CSD_SIZE 16 +#define SD_CID_SIZE 16 + +#define SD_R1_OP_STATE 0x00 +#define SD_R1_IDLE_STATE 0x01 +#define SD_R1_ILLEGAL_CMD 0x04 + +#define SD_STATUS_OK 0x00 +#define SD_DATA_START 0xFE + +#define SD_DATA_OK 0xE5 + +// --------------------------------------------------------------------------- +// ¥ EmTRGSD::EmTRGSD +// --------------------------------------------------------------------------- +EmTRGSD::EmTRGSD() +{ + cmdIndex = 0; + sdBusState = sdBusGetCmdState; +} + + +// --------------------------------------------------------------------------- +// ¥ EmTRGSD::~EmTRGSD +// --------------------------------------------------------------------------- +EmTRGSD::~EmTRGSD() +{ +} + + +// --------------------------------------------------------------------------- +// ¥ EmTRGSD::Initialize +// --------------------------------------------------------------------------- +void EmTRGSD::Initialize(void) +{ + DiskIO.Initialize(EM_DISK_GENERIC_8MB, SD_DRIVE); +} + +// --------------------------------------------------------------------------- +// ¥ EmTRGSD::Dispose +// --------------------------------------------------------------------------- +void EmTRGSD::Dispose(void) +{ + DiskIO.Dispose(); +} + + +// --------------------------------------------------------------------------- +// ¥ EmTRGSD::CompleteCommand +// complete command processing now that we have the data for it too +// --------------------------------------------------------------------------- +void EmTRGSD::CompleteCommand(void) +{ + cmdIndex = 0; + dataIndex = 0; + sdBusState = sdBusSendResponseState; + sdBusNextState = sdBusGetCmdState; + responseIndex = 0; + + switch (cmdBuffer[0] & 0x3f) + { + case SD_CMD24_WRITE_SECTOR : + DiskIO.WriteSector(sectorNum, &dataBuffer[1]); + + // send data OK response + responseBuffer[0] = SD_DATA_OK; + responseSize = 1; + break; + + default : + // unimplemented, should never get here + EmAssert(false); + sdBusState = sdBusGetCmdState; + break; + } +} + +// --------------------------------------------------------------------------- +// ¥ EmTRGSD::ProcessCommand +// process the command we just received +// --------------------------------------------------------------------------- +void EmTRGSD::ProcessCommand(void) +{ + // clear command buffer + cmdIndex = 0; + sdBusState = sdBusSendResponseState; + sdBusNextState = sdBusGetCmdState; + responseIndex = 0; + dataIndex = 0; + dataSize = 0; + + switch (cmdBuffer[0] & 0x3f) + { + case SD_CMD0_GO_IDLE : + responseBuffer[0] = SD_R1_IDLE_STATE; + responseSize = 1; + break; + + case SD_CMD1_GO_OPERATIONAL : + responseBuffer[0] = SD_R1_OP_STATE; + responseSize = 1; + break; + + case SD_CMD9_SEND_CSD : + responseBuffer[0] = SD_R1_OP_STATE; + responseSize = 1; + + sdBusNextState = sdBusSendDataState; + dataBuffer[0] = SD_DATA_START; + memcpy(&dataBuffer[1], m_currDisk.GetSD_CSD(EM_DISK_GENERIC_8MB), SD_CSD_SIZE); + dataBuffer[SD_CSD_SIZE+2] = 0x00; // 16bit crc (unused) + dataBuffer[SD_CSD_SIZE+3] = 0x00; + dataSize = SD_CSD_SIZE+4; + break; + + case SD_CMD10_SEND_CID : + responseBuffer[0] = SD_R1_OP_STATE; + responseSize = 1; + + sdBusNextState = sdBusSendDataState; + dataBuffer[0] = SD_DATA_START; + memcpy(&dataBuffer[1], m_currDisk.GetSD_CID(EM_DISK_GENERIC_8MB), SD_CID_SIZE); + dataBuffer[SD_CID_SIZE+1] = 0x00; // 16bit crc (unused) + dataBuffer[SD_CID_SIZE+2] = 0x00; + dataSize = SD_CID_SIZE+3; + break; + + case SD_CMD13_SEND_STATUS : + responseBuffer[0] = SD_R1_OP_STATE; + responseBuffer[1] = SD_STATUS_OK; + responseSize = 2; + break; + + case SD_CMD17_READ_SECTOR : + responseBuffer[0] = SD_R1_OP_STATE; + responseSize = 1; + + sdBusNextState = sdBusSendDataState; + dataBuffer[0] = SD_DATA_START; + sectorNum = ((cmdBuffer[1] << 24) | (cmdBuffer[2] << 16) | (cmdBuffer[3] << 8) | cmdBuffer[4]); + // SD sector number is really a byte address... + sectorNum /= SECTOR_SIZE; + DiskIO.ReadSector(sectorNum, &dataBuffer[1]); + dataBuffer[SECTOR_SIZE+1] = 0x00; // 16 bit crc (unused) + dataBuffer[SECTOR_SIZE+2] = 0x00; + dataSize = SECTOR_SIZE+3; + break; + + case SD_CMD24_WRITE_SECTOR : + responseBuffer[0] = SD_R1_OP_STATE; + responseSize = 1; + sectorNum = ((cmdBuffer[1] << 24) | (cmdBuffer[2] << 16) | (cmdBuffer[3] << 8) | cmdBuffer[4]); + // SD sector number is really a byte address... + sectorNum /= SECTOR_SIZE; + + sdBusNextState = sdBusGetDataState; + dataSize = SECTOR_SIZE+3; + break; + + default: // unimplemented + responseBuffer[0] = SD_R1_ILLEGAL_CMD; + responseSize = 1; + break; + } +} + + +// --------------------------------------------------------------------------- +// ¥ EmTRGSD::ExchangeBits +// --------------------------------------------------------------------------- +void EmTRGSD::ExchangeBits(uint16 txData, uint16 *rxData, uint16 bits) +{ + switch (bits) + { + case 8 : + switch (sdBusState) + { + case sdBusGetCmdState : + // all SPI commands start first two bits 0, 1 + if ((cmdIndex != 0) || ((txData & 0xC0) == 0x40)) + { + cmdBuffer[cmdIndex] = txData; + cmdIndex++; + if (cmdIndex == SD_CMD_SIZE) + ProcessCommand(); + } + *rxData = 0xffff; + break; + + case sdBusSendResponseState : + *rxData = responseBuffer[responseIndex++]; + if (responseIndex == responseSize) + sdBusState = sdBusNextState; + break; + + case sdBusGetDataState : + // all data blocks start with SD_DATA_START + if ((dataIndex != 0) || (txData == SD_DATA_START)) + { + dataBuffer[dataIndex++] = txData; + if (dataIndex == dataSize) + { + // finish processing command waiting for this data... + CompleteCommand(); + } + } + *rxData = 0xffff; + break; + + case sdBusSendDataState : + *rxData = dataBuffer[dataIndex++]; + if (dataIndex == dataSize) + sdBusState = sdBusGetCmdState; + break; + + default : + break; + } + break; + + case 16 : + switch (sdBusState) + { + case sdBusGetCmdState : + // all SPI commands start first two bits 0, 1 + if ((cmdIndex != 0) || ((txData & 0xC000) == 0x4000)) + { + cmdBuffer[cmdIndex++] = (txData & 0xff00) >> 8; + cmdBuffer[cmdIndex++] = (txData & 0x00ff); + if (cmdIndex >= SD_CMD_SIZE) + ProcessCommand(); + } + *rxData = 0xffff; + break; + + case sdBusSendResponseState : + *rxData = responseBuffer[responseIndex++] << 8; + *rxData |= responseBuffer[responseIndex++]; + if (responseIndex >= responseSize) + sdBusState = sdBusNextState; + break; + + case sdBusGetDataState : + dataBuffer[dataIndex++] = (txData & 0xff00) >> 8; + dataBuffer[dataIndex++] = (txData & 0x00ff); + if (dataIndex >= dataSize) + { + // finish processing command waiting for this data... + CompleteCommand(); + + sdBusState = sdBusGetCmdState; + } + *rxData = 0xffff; + break; + + case sdBusSendDataState : + *rxData = dataBuffer[dataIndex++] << 8; + *rxData |= dataBuffer[dataIndex++]; + if (dataIndex >= dataSize) + sdBusState = sdBusGetCmdState; + break; + + default : + break; + } + break; + + default : + // not supported... + EmAssert(false); + break; + } +} + diff --git a/SrcShared/Hardware/TRG/EmTRGSD.h b/SrcShared/Hardware/TRG/EmTRGSD.h new file mode 100644 index 0000000..bc5afd4 --- /dev/null +++ b/SrcShared/Hardware/TRG/EmTRGSD.h @@ -0,0 +1,64 @@ +/* -*- mode: C++; tab-width: 4 -*- */ +/* ===================================================================== *\ + Copyright (c) 2000-2001 Palm, Inc. or its subsidiaries. + All rights reserved. + + This file is part of the Palm OS Emulator. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +\* ===================================================================== */ +#ifndef _EmTRGSD_h_ +#define _EmTRGSD_h_ + +#include "EmTRGDiskIO.h" + +/************************************************************************ + * This class handles the SPI SD controller interface used in the + * HandEra 330. + ************************************************************************/ + + +typedef enum +{ + sdBusGetCmdState, + sdBusSendResponseState, + sdBusGetDataState, + sdBusSendDataState +} sdBusStateType; + + +class EmTRGSD +{ + private: + uint8 cmdBuffer[6]; + int cmdIndex; + uint8 responseBuffer[2]; + int responseIndex; + int responseSize; + uint8 dataBuffer[520]; + int dataIndex; + int dataSize; + uint32 sectorNum; + sdBusStateType sdBusState; + sdBusStateType sdBusNextState; // next state after sending response + + EmTRGDiskIO DiskIO; + EmCurrDiskType m_currDisk; + + void ProcessCommand(void); + void CompleteCommand(void); + + public : + EmTRGSD(); + ~EmTRGSD(); + + void Initialize(void); + void Dispose(void); + + void ExchangeBits(uint16 txData, uint16 *rxData, uint16 Bits); +}; + +#endif
\ No newline at end of file |