1 // VisualBoyAdvance - Nintendo Gameboy/GameboyAdvance (TM) emulator.
2 // Copyright (C) 1999-2003 Forgotten
3 // Copyright (C) 2004 Forgotten and the VBA development team
4
5 // This program is free software; you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation; either version 2, or(at your option)
8 // any later version.
9 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software Foundation,
17 // Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18
19 #include "System.h"
20 #include "GBA.h"
21 #include "Globals.h"
22 #include "Port.h"
23 #include "Util.h"
24 #include "NLS.h"
25
26 #include <time.h>
27 #include <memory.h>
28
29 enum RTCSTATE { IDLE, COMMAND, DATA, READDATA };
30
31 typedef struct {
32 u8 byte0;
33 u8 byte1;
34 u8 byte2;
35 u8 command;
36 int dataLen;
37 int bits;
38 RTCSTATE state;
39 u8 data[12];
40 // reserved variables for future
41 u8 reserved[12];
42 bool reserved2;
43 u32 reserved3;
44 } RTCCLOCKDATA;
45
46 static RTCCLOCKDATA rtcClockData;
47 static bool rtcEnabled = false;
48
rtcEnable(bool e)49 void rtcEnable(bool e)
50 {
51 rtcEnabled = e;
52 }
53
rtcIsEnabled()54 bool rtcIsEnabled()
55 {
56 return rtcEnabled;
57 }
58
rtcRead(u32 address)59 u16 rtcRead(u32 address)
60 {
61 if(rtcEnabled) {
62 if(address == 0x80000c8)
63 return rtcClockData.byte2;
64 else if(address == 0x80000c6)
65 return rtcClockData.byte1;
66 else if(address == 0x80000c4) {
67 return rtcClockData.byte0;
68 }
69 }
70
71 return READ16LE((&rom[address & 0x1FFFFFE]));
72 }
73
toBCD(u8 value)74 static u8 toBCD(u8 value)
75 {
76 value = value % 100;
77 int l = value % 10;
78 int h = value / 10;
79 return h * 16 + l;
80 }
81
rtcWrite(u32 address,u16 value)82 bool rtcWrite(u32 address, u16 value)
83 {
84 if(!rtcEnabled)
85 return false;
86
87 if(address == 0x80000c8) {
88 rtcClockData.byte2 = (u8)value; // enable ?
89 } else if(address == 0x80000c6) {
90 rtcClockData.byte1 = (u8)value; // read/write
91 } else if(address == 0x80000c4) {
92 if(rtcClockData.byte2 & 1) {
93 if(rtcClockData.state == IDLE && rtcClockData.byte0 == 1 && value == 5) {
94 rtcClockData.state = COMMAND;
95 rtcClockData.bits = 0;
96 rtcClockData.command = 0;
97 } else if(!(rtcClockData.byte0 & 1) && (value & 1)) { // bit transfer
98 rtcClockData.byte0 = (u8)value;
99 switch(rtcClockData.state) {
100 case COMMAND:
101 rtcClockData.command |= ((value & 2) >> 1) << (7-rtcClockData.bits);
102 rtcClockData.bits++;
103 if(rtcClockData.bits == 8) {
104 rtcClockData.bits = 0;
105 switch(rtcClockData.command) {
106 case 0x60:
107 // not sure what this command does but it doesn't take parameters
108 // maybe it is a reset or stop
109 rtcClockData.state = IDLE;
110 rtcClockData.bits = 0;
111 break;
112 case 0x62:
113 // this sets the control state but not sure what those values are
114 rtcClockData.state = READDATA;
115 rtcClockData.dataLen = 1;
116 break;
117 case 0x63:
118 rtcClockData.dataLen = 1;
119 rtcClockData.data[0] = 0x40;
120 rtcClockData.state = DATA;
121 break;
122 case 0x65:
123 {
124 struct tm *newtime;
125 time_t long_time;
126
127 time( &long_time ); /* Get time as long integer. */
128 newtime = localtime( &long_time ); /* Convert to local time. */
129
130 rtcClockData.dataLen = 7;
131 rtcClockData.data[0] = toBCD(newtime->tm_year);
132 rtcClockData.data[1] = toBCD(newtime->tm_mon+1);
133 rtcClockData.data[2] = toBCD(newtime->tm_mday);
134 rtcClockData.data[3] = 0;
135 rtcClockData.data[4] = toBCD(newtime->tm_hour);
136 rtcClockData.data[5] = toBCD(newtime->tm_min);
137 rtcClockData.data[6] = toBCD(newtime->tm_sec);
138 rtcClockData.state = DATA;
139 }
140 break;
141 case 0x67:
142 {
143 struct tm *newtime;
144 time_t long_time;
145
146 time( &long_time ); /* Get time as long integer. */
147 newtime = localtime( &long_time ); /* Convert to local time. */
148
149 rtcClockData.dataLen = 3;
150 rtcClockData.data[0] = toBCD(newtime->tm_hour);
151 rtcClockData.data[1] = toBCD(newtime->tm_min);
152 rtcClockData.data[2] = toBCD(newtime->tm_sec);
153 rtcClockData.state = DATA;
154 }
155 break;
156 default:
157 systemMessage(0, N_("Unknown RTC command %02x"), rtcClockData.command);
158 rtcClockData.state = IDLE;
159 break;
160 }
161 }
162 break;
163 case DATA:
164 if(rtcClockData.byte1 & 2) {
165 } else {
166 rtcClockData.byte0 = (rtcClockData.byte0 & ~2) |
167 ((rtcClockData.data[rtcClockData.bits >> 3] >>
168 (rtcClockData.bits & 7)) & 1)*2;
169 rtcClockData.bits++;
170 if(rtcClockData.bits == 8*rtcClockData.dataLen) {
171 rtcClockData.bits = 0;
172 rtcClockData.state = IDLE;
173 }
174 }
175 break;
176 case READDATA:
177 if(!(rtcClockData.byte1 & 2)) {
178 } else {
179 rtcClockData.data[rtcClockData.bits >> 3] =
180 (rtcClockData.data[rtcClockData.bits >> 3] >> 1) |
181 ((value << 6) & 128);
182 rtcClockData.bits++;
183 if(rtcClockData.bits == 8*rtcClockData.dataLen) {
184 rtcClockData.bits = 0;
185 rtcClockData.state = IDLE;
186 }
187 }
188 break;
189 default:
190 break;
191 }
192 } else
193 rtcClockData.byte0 = (u8)value;
194 }
195 }
196 return true;
197 }
198
rtcReset()199 void rtcReset()
200 {
201 memset(&rtcClockData, 0, sizeof(rtcClockData));
202
203 rtcClockData.byte0 = 0;
204 rtcClockData.byte1 = 0;
205 rtcClockData.byte2 = 0;
206 rtcClockData.command = 0;
207 rtcClockData.dataLen = 0;
208 rtcClockData.bits = 0;
209 rtcClockData.state = IDLE;
210 }
211
rtcSaveGame(gzFile gzFile)212 void rtcSaveGame(gzFile gzFile)
213 {
214 utilGzWrite(gzFile, &rtcClockData, sizeof(rtcClockData));
215 }
216
rtcReadGame(gzFile gzFile)217 void rtcReadGame(gzFile gzFile)
218 {
219 utilGzRead(gzFile, &rtcClockData, sizeof(rtcClockData));
220 }
221