diff options
Diffstat (limited to 'SrcShared/Hardware/EmHAL.cpp')
| -rw-r--r-- | SrcShared/Hardware/EmHAL.cpp | 939 |
1 files changed, 939 insertions, 0 deletions
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; + } +} |