mirror of
https://github.com/dborth/vbagx.git
synced 2024-11-22 18:49:18 +01:00
303 lines
8.3 KiB
C++
303 lines
8.3 KiB
C++
#include "../System.h"
|
|
#include "GBA.h"
|
|
#include "Globals.h"
|
|
#include "../common/Port.h"
|
|
#include "../Util.h"
|
|
#include "../NLS.h"
|
|
#include "vmmem.h"
|
|
|
|
#include <time.h>
|
|
#include <string.h>
|
|
|
|
// Defined in VGA-GX input.cpp
|
|
void systemCartridgeRumble(bool);
|
|
|
|
enum RTCSTATE
|
|
{
|
|
IDLE = 0,
|
|
COMMAND,
|
|
DATA,
|
|
READDATA
|
|
};
|
|
|
|
u8 systemGetSensorDarkness();
|
|
int systemGetSensorZ();
|
|
|
|
typedef struct {
|
|
u8 byte0;
|
|
u8 byte1;
|
|
u8 byte2;
|
|
u8 command;
|
|
int dataLen;
|
|
int bits;
|
|
RTCSTATE state;
|
|
u8 data[12];
|
|
// reserved variables for future
|
|
u8 reserved[12];
|
|
bool reserved2;
|
|
u32 reserved3;
|
|
} RTCCLOCKDATA;
|
|
|
|
static RTCCLOCKDATA rtcClockData;
|
|
static bool rtcEnabled = false;
|
|
static bool rtcWarioRumbleEnabled = false;
|
|
|
|
void rtcEnable(bool e)
|
|
{
|
|
rtcEnabled = e;
|
|
}
|
|
|
|
bool rtcIsEnabled()
|
|
{
|
|
return rtcEnabled;
|
|
}
|
|
|
|
void rtcEnableWarioRumble(bool e)
|
|
{
|
|
if (e) rtcEnable(true);
|
|
rtcWarioRumbleEnabled = e;
|
|
}
|
|
|
|
u16 rtcRead(u32 address)
|
|
{
|
|
if(rtcEnabled) {
|
|
switch(address){
|
|
case 0x80000c8:
|
|
return rtcClockData.byte2;
|
|
break;
|
|
case 0x80000c6:
|
|
return rtcClockData.byte1;
|
|
break;
|
|
case 0x80000c4:
|
|
|
|
// Boktai Solar Sensor
|
|
if (rtcClockData.byte1 == 7) {
|
|
if (rtcClockData.reserved[11] >= systemGetSensorDarkness()) {
|
|
rtcClockData.reserved[10] = 0;
|
|
rtcClockData.reserved[11] = 0;
|
|
return 8;
|
|
} else return 0;
|
|
|
|
// WarioWare Twisted Tilt Sensor
|
|
} else if (rtcClockData.byte1 == 0x0b) {
|
|
//sprintf(DebugStr, "Reading Twisted Sensor bit %d", rtcClockData.reserved[11]);
|
|
u16 v = systemGetSensorZ();
|
|
return ((v >> rtcClockData.reserved[11]) & 1) << 2;
|
|
|
|
// Real Time Clock
|
|
} else {
|
|
//sprintf(DebugStr, "Reading RTC %02x, %02x, %02x", rtcClockData.byte0, rtcClockData.byte1, rtcClockData.byte2);
|
|
return rtcClockData.byte0;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
#ifdef USE_VM
|
|
return VMRead16( address & 0x1FFFFFE );
|
|
#else
|
|
return READ16LE((&rom[address & 0x1FFFFFE]));
|
|
#endif
|
|
}
|
|
|
|
static u8 toBCD(u8 value)
|
|
{
|
|
value = value % 100;
|
|
int l = value % 10;
|
|
int h = value / 10;
|
|
return h * 16 + l;
|
|
}
|
|
|
|
bool rtcWrite(u32 address, u16 value)
|
|
{
|
|
if(!rtcEnabled)
|
|
return false;
|
|
|
|
if(address == 0x80000c8) {
|
|
rtcClockData.byte2 = (u8)value; // bit 0 = enable reading from 0x80000c4 c6 and c8
|
|
} else if(address == 0x80000c6) {
|
|
rtcClockData.byte1 = (u8)value; // 0=read/1=write (for each of 4 low bits)
|
|
// rumble is off when not writing to that pin
|
|
if (rtcWarioRumbleEnabled && !(value & 8)) systemCartridgeRumble(false);
|
|
} else if(address == 0x80000c4) { // 4 bits of I/O Port Data (upper bits not used)
|
|
|
|
// WarioWare Twisted rumble
|
|
if(rtcWarioRumbleEnabled && (rtcClockData.byte1 & 8)) {
|
|
systemCartridgeRumble(value & 8);
|
|
}
|
|
|
|
// Boktai solar sensor
|
|
if (rtcClockData.byte1 == 7) {
|
|
if (value & 2) {
|
|
// reset counter to 0
|
|
rtcClockData.reserved[11]=0;
|
|
rtcClockData.reserved[10]=0;
|
|
}
|
|
if ((value & 1) && (!(rtcClockData.reserved[10] & 1))) {
|
|
// increase counter, ready to do another read
|
|
if (rtcClockData.reserved[11]<255) rtcClockData.reserved[11]++;
|
|
}
|
|
rtcClockData.reserved[10] = value & rtcClockData.byte1;
|
|
}
|
|
|
|
// WarioWare Twisted rotation sensor
|
|
if (rtcClockData.byte1 == 0xb) {
|
|
if (value & 2) {
|
|
// clock goes high in preperation for reading a bit
|
|
rtcClockData.reserved[11]--;
|
|
}
|
|
if (value & 1) {
|
|
// start ADC conversion
|
|
rtcClockData.reserved[11] = 15;
|
|
}
|
|
|
|
rtcClockData.byte0 = value & rtcClockData.byte1;
|
|
|
|
// Real Time Clock
|
|
}
|
|
/**/
|
|
|
|
if(rtcClockData.byte2 & 1) { // if reading is enabled
|
|
if(rtcClockData.state == IDLE && rtcClockData.byte0 == 1 && value == 5) {
|
|
rtcClockData.state = COMMAND;
|
|
rtcClockData.bits = 0;
|
|
rtcClockData.command = 0;
|
|
} else if(!(rtcClockData.byte0 & 1) && (value & 1)) { // bit transfer
|
|
rtcClockData.byte0 = (u8)value;
|
|
switch(rtcClockData.state) {
|
|
case COMMAND:
|
|
rtcClockData.command |= ((value & 2) >> 1) << (7-rtcClockData.bits);
|
|
rtcClockData.bits++;
|
|
if(rtcClockData.bits == 8) {
|
|
rtcClockData.bits = 0;
|
|
switch(rtcClockData.command) {
|
|
case 0x60:
|
|
// not sure what this command does but it doesn't take parameters
|
|
// maybe it is a reset or stop
|
|
rtcClockData.state = IDLE;
|
|
rtcClockData.bits = 0;
|
|
break;
|
|
case 0x62:
|
|
// this sets the control state but not sure what those values are
|
|
rtcClockData.state = READDATA;
|
|
rtcClockData.dataLen = 1;
|
|
break;
|
|
case 0x63:
|
|
rtcClockData.dataLen = 1;
|
|
rtcClockData.data[0] = 0x40;
|
|
rtcClockData.state = DATA;
|
|
break;
|
|
case 0x64:
|
|
break;
|
|
case 0x65:
|
|
{
|
|
struct tm *newtime;
|
|
time_t long_time;
|
|
|
|
time( &long_time ); /* Get time as long integer. */
|
|
newtime = localtime( &long_time ); /* Convert to local time. */
|
|
|
|
rtcClockData.dataLen = 7;
|
|
rtcClockData.data[0] = toBCD(newtime->tm_year);
|
|
rtcClockData.data[1] = toBCD(newtime->tm_mon+1);
|
|
rtcClockData.data[2] = toBCD(newtime->tm_mday);
|
|
rtcClockData.data[3] = toBCD(newtime->tm_wday);
|
|
rtcClockData.data[4] = toBCD(newtime->tm_hour);
|
|
rtcClockData.data[5] = toBCD(newtime->tm_min);
|
|
rtcClockData.data[6] = toBCD(newtime->tm_sec);
|
|
rtcClockData.state = DATA;
|
|
}
|
|
break;
|
|
case 0x67:
|
|
{
|
|
struct tm *newtime;
|
|
time_t long_time;
|
|
|
|
time( &long_time ); /* Get time as long integer. */
|
|
newtime = localtime( &long_time ); /* Convert to local time. */
|
|
|
|
rtcClockData.dataLen = 3;
|
|
rtcClockData.data[0] = toBCD(newtime->tm_hour);
|
|
rtcClockData.data[1] = toBCD(newtime->tm_min);
|
|
rtcClockData.data[2] = toBCD(newtime->tm_sec);
|
|
rtcClockData.state = DATA;
|
|
}
|
|
break;
|
|
default:
|
|
systemMessage(0, N_("Unknown RTC command %02x"), rtcClockData.command);
|
|
rtcClockData.state = IDLE;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case DATA:
|
|
if(rtcClockData.byte1 & 2) {
|
|
} else {
|
|
rtcClockData.byte0 = (rtcClockData.byte0 & ~2) |
|
|
((rtcClockData.data[rtcClockData.bits >> 3] >>
|
|
(rtcClockData.bits & 7)) & 1)*2;
|
|
rtcClockData.bits++;
|
|
if(rtcClockData.bits == 8*rtcClockData.dataLen) {
|
|
rtcClockData.bits = 0;
|
|
rtcClockData.state = IDLE;
|
|
}
|
|
}
|
|
break;
|
|
case READDATA:
|
|
if(!(rtcClockData.byte1 & 2)) {
|
|
} else {
|
|
rtcClockData.data[rtcClockData.bits >> 3] =
|
|
(rtcClockData.data[rtcClockData.bits >> 3] >> 1) |
|
|
((value << 6) & 128);
|
|
rtcClockData.bits++;
|
|
if(rtcClockData.bits == 8*rtcClockData.dataLen) {
|
|
rtcClockData.bits = 0;
|
|
rtcClockData.state = IDLE;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} else
|
|
rtcClockData.byte0 = (u8)value;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void rtcReset()
|
|
{
|
|
memset(&rtcClockData, 0, sizeof(rtcClockData));
|
|
|
|
rtcClockData.byte0 = 0;
|
|
rtcClockData.byte1 = 0;
|
|
rtcClockData.byte2 = 0;
|
|
rtcClockData.command = 0;
|
|
rtcClockData.dataLen = 0;
|
|
rtcClockData.bits = 0;
|
|
rtcClockData.state = IDLE;
|
|
rtcClockData.reserved[11] = 0;
|
|
}
|
|
|
|
#ifdef __LIBRETRO__
|
|
void rtcSaveGame(u8 *&data)
|
|
{
|
|
utilWriteMem(data, &rtcClockData, sizeof(rtcClockData));
|
|
}
|
|
|
|
void rtcReadGame(const u8 *&data)
|
|
{
|
|
utilReadMem(&rtcClockData, data, sizeof(rtcClockData));
|
|
}
|
|
#else
|
|
void rtcSaveGame(gzFile gzFile)
|
|
{
|
|
utilGzWrite(gzFile, &rtcClockData, sizeof(rtcClockData));
|
|
}
|
|
|
|
void rtcReadGame(gzFile gzFile)
|
|
{
|
|
utilGzRead(gzFile, &rtcClockData, sizeof(rtcClockData));
|
|
}
|
|
#endif
|