spc7110.cpp 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672
  1. #include <../base.hpp>
  2. #include <../cart/cart.hpp>
  3. #define SPC7110_CPP
  4. #include "spc7110.hpp"
  5. #include "decomp.cpp"
  6. const unsigned SPC7110::months[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
  7. void SPC7110::init() {}
  8. void SPC7110::enable() {
  9. uint16_t limit = (cartridge.has_spc7110rtc() ? 0x4842 : 0x483f);
  10. for(uint16_t i = 0x4800; i <= limit; i++) memory::mmio.map(i, *this);
  11. }
  12. void SPC7110::power() {
  13. reset();
  14. }
  15. void SPC7110::reset() {
  16. r4801 = 0x00;
  17. r4802 = 0x00;
  18. r4803 = 0x00;
  19. r4804 = 0x00;
  20. r4805 = 0x00;
  21. r4806 = 0x00;
  22. r4807 = 0x00;
  23. r4808 = 0x00;
  24. r4809 = 0x00;
  25. r480a = 0x00;
  26. r480b = 0x00;
  27. r480c = 0x00;
  28. decomp.reset();
  29. r4811 = 0x00;
  30. r4812 = 0x00;
  31. r4813 = 0x00;
  32. r4814 = 0x00;
  33. r4815 = 0x00;
  34. r4816 = 0x00;
  35. r4817 = 0x00;
  36. r4818 = 0x00;
  37. r481x = 0x00;
  38. r4814_latch = false;
  39. r4815_latch = false;
  40. r4820 = 0x00;
  41. r4821 = 0x00;
  42. r4822 = 0x00;
  43. r4823 = 0x00;
  44. r4824 = 0x00;
  45. r4825 = 0x00;
  46. r4826 = 0x00;
  47. r4827 = 0x00;
  48. r4828 = 0x00;
  49. r4829 = 0x00;
  50. r482a = 0x00;
  51. r482b = 0x00;
  52. r482c = 0x00;
  53. r482d = 0x00;
  54. r482e = 0x00;
  55. r482f = 0x00;
  56. r4830 = 0x00;
  57. mmio_write(0x4831, 0);
  58. mmio_write(0x4832, 1);
  59. mmio_write(0x4833, 2);
  60. r4834 = 0x00;
  61. r4840 = 0x00;
  62. r4841 = 0x00;
  63. r4842 = 0x00;
  64. if(cartridge.has_spc7110rtc()) {
  65. rtc_state = RTCS_Inactive;
  66. rtc_mode = RTCM_Linear;
  67. rtc_index = 0;
  68. }
  69. }
  70. unsigned SPC7110::datarom_addr(unsigned addr) {
  71. unsigned size = memory::cartrom.size() - 0x100000;
  72. while(addr >= size) addr -= size;
  73. return addr + 0x100000;
  74. }
  75. unsigned SPC7110::data_pointer() { return r4811 + (r4812 << 8) + (r4813 << 16); }
  76. unsigned SPC7110::data_adjust() { return r4814 + (r4815 << 8); }
  77. unsigned SPC7110::data_increment() { return r4816 + (r4817 << 8); }
  78. void SPC7110::set_data_pointer(unsigned addr) { r4811 = addr; r4812 = addr >> 8; r4813 = addr >> 16; }
  79. void SPC7110::set_data_adjust(unsigned addr) { r4814 = addr; r4815 = addr >> 8; }
  80. void SPC7110::update_time(int offset) {
  81. time_t rtc_time
  82. = (memory::cartrtc.read(16) << 0)
  83. | (memory::cartrtc.read(17) << 8)
  84. | (memory::cartrtc.read(18) << 16)
  85. | (memory::cartrtc.read(19) << 24);
  86. time_t current_time = time(0) - offset;
  87. //sizeof(time_t) is platform-dependent; though memory::cartrtc needs to be platform-agnostic.
  88. //yet platforms with 32-bit signed time_t will overflow every ~68 years. handle this by
  89. //accounting for overflow at the cost of 1-bit precision (to catch underflow). this will allow
  90. //memory::cartrtc timestamp to remain valid for up to ~34 years from the last update, even if
  91. //time_t overflows. calculation should be valid regardless of number representation, time_t size,
  92. //or whether time_t is signed or unsigned.
  93. time_t diff
  94. = (current_time >= rtc_time)
  95. ? (current_time - rtc_time)
  96. : (std::numeric_limits<time_t>::max() - rtc_time + current_time + 1); //compensate for overflow
  97. if(diff > std::numeric_limits<time_t>::max() / 2) diff = 0; //compensate for underflow
  98. bool update = true;
  99. if(memory::cartrtc.read(13) & 1) update = false; //do not update if CR0 timer disable flag is set
  100. if(memory::cartrtc.read(15) & 3) update = false; //do not update if CR2 timer disable flags are set
  101. if(diff > 0 && update == true) {
  102. unsigned second = memory::cartrtc.read( 0) + memory::cartrtc.read( 1) * 10;
  103. unsigned minute = memory::cartrtc.read( 2) + memory::cartrtc.read( 3) * 10;
  104. unsigned hour = memory::cartrtc.read( 4) + memory::cartrtc.read( 5) * 10;
  105. unsigned day = memory::cartrtc.read( 6) + memory::cartrtc.read( 7) * 10;
  106. unsigned month = memory::cartrtc.read( 8) + memory::cartrtc.read( 9) * 10;
  107. unsigned year = memory::cartrtc.read(10) + memory::cartrtc.read(11) * 10;
  108. unsigned weekday = memory::cartrtc.read(12);
  109. day--;
  110. month--;
  111. year += (year >= 90) ? 1900 : 2000; //range = 1990-2089
  112. second += diff;
  113. while(second >= 60) {
  114. second -= 60;
  115. minute++;
  116. if(minute < 60) continue;
  117. minute = 0;
  118. hour++;
  119. if(hour < 24) continue;
  120. hour = 0;
  121. day++;
  122. weekday = (weekday + 1) % 7;
  123. unsigned days = months[month % 12];
  124. if(days == 28) {
  125. bool leapyear = false;
  126. if((year % 4) == 0) {
  127. leapyear = true;
  128. if((year % 100) == 0 && (year % 400) != 0) leapyear = false;
  129. }
  130. if(leapyear) days++;
  131. }
  132. if(day < days) continue;
  133. day = 0;
  134. month++;
  135. if(month < 12) continue;
  136. month = 0;
  137. year++;
  138. }
  139. day++;
  140. month++;
  141. year %= 100;
  142. memory::cartrtc.write( 0, second % 10);
  143. memory::cartrtc.write( 1, second / 10);
  144. memory::cartrtc.write( 2, minute % 10);
  145. memory::cartrtc.write( 3, minute / 10);
  146. memory::cartrtc.write( 4, hour % 10);
  147. memory::cartrtc.write( 5, hour / 10);
  148. memory::cartrtc.write( 6, day % 10);
  149. memory::cartrtc.write( 7, day / 10);
  150. memory::cartrtc.write( 8, month % 10);
  151. memory::cartrtc.write( 9, month / 10);
  152. memory::cartrtc.write(10, year % 10);
  153. memory::cartrtc.write(11, (year / 10) % 10);
  154. memory::cartrtc.write(12, weekday % 7);
  155. }
  156. memory::cartrtc.write(16, current_time >> 0);
  157. memory::cartrtc.write(17, current_time >> 8);
  158. memory::cartrtc.write(18, current_time >> 16);
  159. memory::cartrtc.write(19, current_time >> 24);
  160. }
  161. uint8 SPC7110::mmio_read(unsigned addr) {
  162. addr &= 0xffff;
  163. switch(addr) {
  164. //==================
  165. //decompression unit
  166. //==================
  167. case 0x4800: {
  168. uint16 counter = (r4809 + (r480a << 8));
  169. counter--;
  170. r4809 = counter;
  171. r480a = counter >> 8;
  172. return decomp.read();
  173. }
  174. case 0x4801: return r4801;
  175. case 0x4802: return r4802;
  176. case 0x4803: return r4803;
  177. case 0x4804: return r4804;
  178. case 0x4805: return r4805;
  179. case 0x4806: return r4806;
  180. case 0x4807: return r4807;
  181. case 0x4808: return r4808;
  182. case 0x4809: return r4809;
  183. case 0x480a: return r480a;
  184. case 0x480b: return r480b;
  185. case 0x480c: {
  186. uint8 status = r480c;
  187. r480c &= 0x7f;
  188. return status;
  189. }
  190. //==============
  191. //data port unit
  192. //==============
  193. case 0x4810: {
  194. if(r481x != 0x07) return 0x00;
  195. unsigned addr = data_pointer();
  196. unsigned adjust = data_adjust();
  197. if(r4818 & 8) adjust = (int16)adjust; //16-bit sign extend
  198. unsigned adjustaddr = addr;
  199. if(r4818 & 2) {
  200. adjustaddr += adjust;
  201. set_data_adjust(adjust + 1);
  202. }
  203. uint8 data = memory::cartrom.read(datarom_addr(adjustaddr));
  204. if(!(r4818 & 2)) {
  205. unsigned increment = (r4818 & 1) ? data_increment() : 1;
  206. if(r4818 & 4) increment = (int16)increment; //16-bit sign extend
  207. if((r4818 & 16) == 0) {
  208. set_data_pointer(addr + increment);
  209. } else {
  210. set_data_adjust(adjust + increment);
  211. }
  212. }
  213. return data;
  214. }
  215. case 0x4811: return r4811;
  216. case 0x4812: return r4812;
  217. case 0x4813: return r4813;
  218. case 0x4814: return r4814;
  219. case 0x4815: return r4815;
  220. case 0x4816: return r4816;
  221. case 0x4817: return r4817;
  222. case 0x4818: return r4818;
  223. case 0x481a: {
  224. if(r481x != 0x07) return 0x00;
  225. unsigned addr = data_pointer();
  226. unsigned adjust = data_adjust();
  227. if(r4818 & 8) adjust = (int16)adjust; //16-bit sign extend
  228. uint8 data = memory::cartrom.read(datarom_addr(addr + adjust));
  229. if((r4818 & 0x60) == 0x60) {
  230. if((r4818 & 16) == 0) {
  231. set_data_pointer(addr + adjust);
  232. } else {
  233. set_data_adjust(adjust + adjust);
  234. }
  235. }
  236. return data;
  237. }
  238. //=========
  239. //math unit
  240. //=========
  241. case 0x4820: return r4820;
  242. case 0x4821: return r4821;
  243. case 0x4822: return r4822;
  244. case 0x4823: return r4823;
  245. case 0x4824: return r4824;
  246. case 0x4825: return r4825;
  247. case 0x4826: return r4826;
  248. case 0x4827: return r4827;
  249. case 0x4828: return r4828;
  250. case 0x4829: return r4829;
  251. case 0x482a: return r482a;
  252. case 0x482b: return r482b;
  253. case 0x482c: return r482c;
  254. case 0x482d: return r482d;
  255. case 0x482e: return r482e;
  256. case 0x482f: {
  257. uint8 status = r482f;
  258. r482f &= 0x7f;
  259. return status;
  260. }
  261. //===================
  262. //memory mapping unit
  263. //===================
  264. case 0x4830: return r4830;
  265. case 0x4831: return r4831;
  266. case 0x4832: return r4832;
  267. case 0x4833: return r4833;
  268. case 0x4834: return r4834;
  269. //====================
  270. //real-time clock unit
  271. //====================
  272. case 0x4840: return r4840;
  273. case 0x4841: {
  274. if(rtc_state == RTCS_Inactive || rtc_state == RTCS_ModeSelect) return 0x00;
  275. r4842 = 0x80;
  276. uint8 data = memory::cartrtc.read(rtc_index);
  277. rtc_index = (rtc_index + 1) & 15;
  278. return data;
  279. }
  280. case 0x4842: {
  281. uint8 status = r4842;
  282. r4842 &= 0x7f;
  283. return status;
  284. }
  285. }
  286. return cpu.regs.mdr;
  287. }
  288. void SPC7110::mmio_write(unsigned addr, uint8 data) {
  289. addr &= 0xffff;
  290. switch(addr) {
  291. //==================
  292. //decompression unit
  293. //==================
  294. case 0x4801: r4801 = data; break;
  295. case 0x4802: r4802 = data; break;
  296. case 0x4803: r4803 = data; break;
  297. case 0x4804: r4804 = data; break;
  298. case 0x4805: r4805 = data; break;
  299. case 0x4806: {
  300. r4806 = data;
  301. unsigned table = (r4801 + (r4802 << 8) + (r4803 << 16));
  302. unsigned index = (r4804 << 2);
  303. unsigned length = (r4809 + (r480a << 8));
  304. unsigned addr = datarom_addr(table + index);
  305. unsigned mode = (memory::cartrom.read(addr + 0));
  306. unsigned offset = (memory::cartrom.read(addr + 1) << 16)
  307. + (memory::cartrom.read(addr + 2) << 8)
  308. + (memory::cartrom.read(addr + 3) << 0);
  309. decomp.init(mode, offset, (r4805 + (r4806 << 8)) << mode);
  310. r480c = 0x80;
  311. } break;
  312. case 0x4807: r4807 = data; break;
  313. case 0x4808: r4808 = data; break;
  314. case 0x4809: r4809 = data; break;
  315. case 0x480a: r480a = data; break;
  316. case 0x480b: r480b = data; break;
  317. //==============
  318. //data port unit
  319. //==============
  320. case 0x4811: r4811 = data; r481x |= 0x01; break;
  321. case 0x4812: r4812 = data; r481x |= 0x02; break;
  322. case 0x4813: r4813 = data; r481x |= 0x04; break;
  323. case 0x4814: {
  324. r4814 = data;
  325. r4814_latch = true;
  326. if(!r4815_latch) break;
  327. if(!(r4818 & 2)) break;
  328. if(r4818 & 0x10) break;
  329. if((r4818 & 0x60) == 0x20) {
  330. unsigned increment = data_adjust() & 0xff;
  331. if(r4818 & 8) increment = (int8)increment; //8-bit sign extend
  332. set_data_pointer(data_pointer() + increment);
  333. } else if((r4818 & 0x60) == 0x40) {
  334. unsigned increment = data_adjust();
  335. if(r4818 & 8) increment = (int16)increment; //16-bit sign extend
  336. set_data_pointer(data_pointer() + increment);
  337. }
  338. } break;
  339. case 0x4815: {
  340. r4815 = data;
  341. r4815_latch = true;
  342. if(!r4814_latch) break;
  343. if(!(r4818 & 2)) break;
  344. if(r4818 & 0x10) break;
  345. if((r4818 & 0x60) == 0x20) {
  346. unsigned increment = data_adjust() & 0xff;
  347. if(r4818 & 8) increment = (int8)increment; //8-bit sign extend
  348. set_data_pointer(data_pointer() + increment);
  349. } else if((r4818 & 0x60) == 0x40) {
  350. unsigned increment = data_adjust();
  351. if(r4818 & 8) increment = (int16)increment; //16-bit sign extend
  352. set_data_pointer(data_pointer() + increment);
  353. }
  354. } break;
  355. case 0x4816: r4816 = data; break;
  356. case 0x4817: r4817 = data; break;
  357. case 0x4818: {
  358. if(r481x != 0x07) break;
  359. r4818 = data;
  360. r4814_latch = r4815_latch = false;
  361. } break;
  362. //=========
  363. //math unit
  364. //=========
  365. case 0x4820: r4820 = data; break;
  366. case 0x4821: r4821 = data; break;
  367. case 0x4822: r4822 = data; break;
  368. case 0x4823: r4823 = data; break;
  369. case 0x4824: r4824 = data; break;
  370. case 0x4825: {
  371. r4825 = data;
  372. if(r482e & 1) {
  373. //signed 16-bit x 16-bit multiplication
  374. int16 r0 = (int16)(r4824 + (r4825 << 8));
  375. int16 r1 = (int16)(r4820 + (r4821 << 8));
  376. signed result = r0 * r1;
  377. r4828 = result;
  378. r4829 = result >> 8;
  379. r482a = result >> 16;
  380. r482b = result >> 24;
  381. } else {
  382. //unsigned 16-bit x 16-bit multiplication
  383. uint16 r0 = (uint16)(r4824 + (r4825 << 8));
  384. uint16 r1 = (uint16)(r4820 + (r4821 << 8));
  385. unsigned result = r0 * r1;
  386. r4828 = result;
  387. r4829 = result >> 8;
  388. r482a = result >> 16;
  389. r482b = result >> 24;
  390. }
  391. r482f = 0x80;
  392. } break;
  393. case 0x4826: r4826 = data; break;
  394. case 0x4827: {
  395. r4827 = data;
  396. if(r482e & 1) {
  397. //signed 32-bit x 16-bit division
  398. int32 dividend = (int32)(r4820 + (r4821 << 8) + (r4822 << 16) + (r4823 << 24));
  399. int16 divisor = (int16)(r4826 + (r4827 << 8));
  400. int32 quotient;
  401. int16 remainder;
  402. if(divisor) {
  403. quotient = (int32)(dividend / divisor);
  404. remainder = (int32)(dividend % divisor);
  405. } else {
  406. //illegal division by zero
  407. quotient = 0;
  408. remainder = dividend & 0xffff;
  409. }
  410. r4828 = quotient;
  411. r4829 = quotient >> 8;
  412. r482a = quotient >> 16;
  413. r482b = quotient >> 24;
  414. r482c = remainder;
  415. r482d = remainder >> 8;
  416. } else {
  417. //unsigned 32-bit x 16-bit division
  418. uint32 dividend = (uint32)(r4820 + (r4821 << 8) + (r4822 << 16) + (r4823 << 24));
  419. uint16 divisor = (uint16)(r4826 + (r4827 << 8));
  420. uint32 quotient;
  421. uint16 remainder;
  422. if(divisor) {
  423. quotient = (uint32)(dividend / divisor);
  424. remainder = (uint16)(dividend % divisor);
  425. } else {
  426. //illegal division by zero
  427. quotient = 0;
  428. remainder = dividend & 0xffff;
  429. }
  430. r4828 = quotient;
  431. r4829 = quotient >> 8;
  432. r482a = quotient >> 16;
  433. r482b = quotient >> 24;
  434. r482c = remainder;
  435. r482d = remainder >> 8;
  436. }
  437. r482f = 0x80;
  438. } break;
  439. case 0x482e: {
  440. //reset math unit
  441. r4820 = r4821 = r4822 = r4823 = 0;
  442. r4824 = r4825 = r4826 = r4827 = 0;
  443. r4828 = r4829 = r482a = r482b = 0;
  444. r482c = r482d = 0;
  445. r482e = data;
  446. } break;
  447. //===================
  448. //memory mapping unit
  449. //===================
  450. case 0x4830: r4830 = data; break;
  451. case 0x4831: {
  452. r4831 = data;
  453. dx_offset = datarom_addr((data & 7) * 0x100000);
  454. } break;
  455. case 0x4832: {
  456. r4832 = data;
  457. ex_offset = datarom_addr((data & 7) * 0x100000);
  458. } break;
  459. case 0x4833: {
  460. r4833 = data;
  461. fx_offset = datarom_addr((data & 7) * 0x100000);
  462. } break;
  463. case 0x4834: r4834 = data; break;
  464. //====================
  465. //real-time clock unit
  466. //====================
  467. case 0x4840: {
  468. r4840 = data;
  469. if(!(r4840 & 1)) {
  470. //disable RTC
  471. rtc_state = RTCS_Inactive;
  472. update_time();
  473. } else {
  474. //enable RTC
  475. r4842 = 0x80;
  476. rtc_state = RTCS_ModeSelect;
  477. }
  478. } break;
  479. case 0x4841: {
  480. r4841 = data;
  481. switch(rtc_state) {
  482. case RTCS_ModeSelect: {
  483. if(data == RTCM_Linear || data == RTCM_Indexed) {
  484. r4842 = 0x80;
  485. rtc_state = RTCS_IndexSelect;
  486. rtc_mode = (RTC_Mode)data;
  487. rtc_index = 0;
  488. }
  489. } break;
  490. case RTCS_IndexSelect: {
  491. r4842 = 0x80;
  492. rtc_index = data & 15;
  493. if(rtc_mode == RTCM_Linear) rtc_state = RTCS_Write;
  494. } break;
  495. case RTCS_Write: {
  496. r4842 = 0x80;
  497. //control register 0
  498. if(rtc_index == 13) {
  499. //increment second counter
  500. if(data & 2) update_time(+1);
  501. //round minute counter
  502. if(data & 8) {
  503. update_time();
  504. unsigned second = memory::cartrtc.read( 0) + memory::cartrtc.read( 1) * 10;
  505. //clear seconds
  506. memory::cartrtc.write(0, 0);
  507. memory::cartrtc.write(1, 0);
  508. if(second >= 30) update_time(+60);
  509. }
  510. }
  511. //control register 2
  512. if(rtc_index == 15) {
  513. //disable timer and clear second counter
  514. if((data & 1) && !(memory::cartrtc.read(15) & 1)) {
  515. update_time();
  516. //clear seconds
  517. memory::cartrtc.write(0, 0);
  518. memory::cartrtc.write(1, 0);
  519. }
  520. //disable timer
  521. if((data & 2) && !(memory::cartrtc.read(15) & 2)) {
  522. update_time();
  523. }
  524. }
  525. memory::cartrtc.write(rtc_index, data & 15);
  526. rtc_index = (rtc_index + 1) & 15;
  527. } break;
  528. } //switch(rtc_state)
  529. } break;
  530. }
  531. }
  532. uint8 SPC7110::read(unsigned addr) {
  533. //$[00-0f|80-8f]:[8000-ffff], $[c0-cf]:[0000-ffff] mapped directly to memory::cartrom
  534. if((addr & 0xffe000) == 0x006000 || (addr & 0xffe000) == 0x306000) {
  535. //$[00|30]:[6000-7fff]
  536. return memory::cartram.read(addr & 0x1fff);
  537. }
  538. if((addr & 0xff0000) == 0x500000) {
  539. //$[50]:[0000-ffff]
  540. return mmio_read(0x4800);
  541. }
  542. if((addr & 0xf00000) == 0xd00000) {
  543. //$[d0-df]:[0000-ffff]
  544. return memory::cartrom.read(dx_offset + (addr & 0x0fffff));
  545. }
  546. if((addr & 0xf00000) == 0xe00000) {
  547. //$[e0-ef]:[0000-ffff]
  548. return memory::cartrom.read(ex_offset + (addr & 0x0fffff));
  549. }
  550. if((addr & 0xf00000) == 0xf00000) {
  551. //$[f0-ff]:[0000-ffff]
  552. return memory::cartrom.read(fx_offset + (addr & 0x0fffff));
  553. }
  554. return cpu.regs.mdr;
  555. }
  556. void SPC7110::write(unsigned addr, uint8 data) {
  557. if((addr & 0xffe000) == 0x006000 || (addr & 0xffe000) == 0x306000) {
  558. //$[00|30]:[6000-7fff]
  559. if(r4830 & 0x80) memory::cartram.write(addr & 0x1fff, data);
  560. return;
  561. }
  562. }
  563. SPC7110::SPC7110() {
  564. }