path: root/SrcShared/Hardware/EmRegsVZTemp.cpp

/* -*- 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;
}