source/src/vm/fm7/mainmem_utils.cpp

   1 /*
   2  * Main memory for FM-7 [FM7_MAINMEM/MAINMEM_UTIL]
   3  *  Author: K.Ohta
   4  *  Date  : 2017.04.01-
   5  *  License: GPLv2
   6  *
   7  */
   8 #include "vm.h"
   9 #include "emu.h"
  10 #include "fm7_mainmem.h"
  11
  12 namespace FM7 {
  13
  14
  15 void FM7_MAINMEM::initialize(void)
  16 {
  17         int i;
  18         diag_load_basicrom = false;
  19         diag_load_bootrom_bas = false;
  20         diag_load_bootrom_dos = false;
  21         diag_load_bootrom_mmr = false;
  22         diag_load_bootrom_bubble = false;
  23         diag_load_bootrom_bubble_128k = false;
  24         diag_load_bootrom_sfd8 = false;
  25         diag_load_bootrom_2hd = false;
  26
  27 #if defined(_FM77AV_VARIANTS)
  28         dictrom_connected = false;
  29 #endif
  30 #ifdef HAS_MMR
  31         for(i = 0x00; i < 0x80; i++) {
  32                 mmr_map_data[i] = 0;
  33         }
  34         mmr_segment = 0;
  35         window_offset = 0;
  36         mmr_enabled = false;
  37         mmr_fast = false;
  38         window_enabled = false;
  39 #endif
  40 #ifdef _FM77AV_VARIANTS
  41         extcard_bank = 0;
  42         extrom_bank = false;
  43         dictrom_enabled = false;
  44         dictram_enabled = false;
  45
  46         initiator_enabled = true;
  47         boot_ram_write = true;
  48 #endif
  49 #if defined(_FM7) || defined(_FM77AV_VARIANTS)
  50         bootmode = config.boot_mode & 3;
  51 #else
  52         bootmode = config.boot_mode & 7;
  53 #endif
  54         basicrom_fd0f = false;
  55         is_basicrom = ((bootmode & 0x03) == 0) ? true : false;
  56
  57         // $0000-$7FFF
  58         i = FM7_MAINMEM_OMOTE;
  59         memset(fm7_mainmem_omote, 0x00, 0x8000 * sizeof(uint8_t));
  60
  61         // $8000-$FBFF
  62         i = FM7_MAINMEM_URA;
  63         memset(fm7_mainmem_ura, 0x00, 0x7c00 * sizeof(uint8_t));
  64
  65         i = FM7_MAINMEM_VECTOR;
  66         memset(fm7_mainmem_bootrom_vector, 0x00, 0x1e);
  67
  68 #if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX) || \
  69     defined(_FM77_VARIANTS)
  70         extram_pages = FM77_EXRAM_BANKS;
  71 #if defined(_FM77_VARIANTS)
  72         if(extram_pages > 3) extram_pages = 3;
  73 #else
  74         if(extram_pages > 12) extram_pages = 12;
  75 #endif
  76         extram_size = extram_pages * 0x10000;
  77         if(extram_pages > 0) {
  78                 i = FM7_MAINMEM_EXTRAM;
  79                 fm7_mainmem_extram = (uint8_t *)malloc(extram_size);
  80                 if(fm7_mainmem_extram != NULL) {
  81                         memset(fm7_mainmem_extram, 0x00, extram_size);
  82                 }
  83         }
  84 #endif
  85
  86 #if defined(_FM77_VARIANTS)
  87         memset(fm77_shadowram, 0x00, 0x200);
  88 #endif
  89 #if defined(_FM77_VARIANTS) || defined(_FM8)
  90         for(i = 0; i < 8; i++) memset(fm7_bootroms[i], 0xff, 0x200);
  91 #elif defined(_FM7) || defined(_FMNEW7)
  92         for(i = 0; i < 4; i++) memset(fm7_bootroms[i], 0xff, 0x200);
  93 #endif
  94 #if defined(_FM8)
  95
  96         // FM-8 HAS TWO TYPE of BOOTROM.
  97         // See http://www.mindspring.com/~thasegaw/rpcg/fm8_boot.html .
  98         {
  99                 uint8_t *tmpp;
 100                 bool tmpb = false;
 101                 tmpp = malloc(0x800);
 102                 // SM11-14
 103                 diag_load_sm11_14 = false;
 104                 diag_load_sm11_15 = false;
 105                 if(tmpp != NULL) {
 106                         tmpb = (read_bios(_T(ROM_FM8_SM11_14), tmpp, 0x800) >= 0x800);
 107                 }
 108                 if(tmpb) {
 109                         memcpy(fm7_bootroms[0], &(tmpp[0x000]), 0x200); // BASIC
 110                         memcpy(fm7_bootroms[2], &(tmpp[0x200]), 0x200); // BUBBLE
 111                         memcpy(fm7_bootroms[1], &(tmpp[0x400]), 0x200); // DOS 320K
 112                         memcpy(fm7_bootroms[3], &(tmpp[0x600]), 0x200); // DEBUG
 113                         this->out_debug_log(_T("NOTE: LOADING BULK BOOTROM SM11-14 OK."));
 114                         diag_load_sm11_14 = true;
 115                 } else {
 116                         if(read_bios(_T(ROM_FM8_BOOT_BASIC), fm7_bootroms[0], 0x200) >= 0x1e0) {
 117                                 diag_load_bootrom_bas = true;
 118                         }
 119                         if(read_bios(_T(ROM_FM8_BOOT_DOS), fm7_bootroms[1], 0x200) >= 0x1e0) {
 120                                 diag_load_bootrom_dos = true;
 121                         }
 122                         if(read_bios(_T(ROM_FM8_BOOT_BUBBLE_128K), fm7_bootroms[2], 0x200) >= 0x1e0) {
 123                                 diag_load_bootrom_bubble_128k = true;
 124                         } else if(read_bios(_T(ROM_FM8_BOOT_BUBBLE), fm7_bootroms[2], 0x200) >= 0x1e0) {
 125                                 diag_load_bootrom_bubble = true;
 126                         }
 127                         if(read_bios(_T(ROM_FM8_BOOT_DEBUG), fm7_bootroms[3], 0x200) >= 0x1e0) {
 128                                 //diag_load_bootrom_debug = true;
 129                         }
 130                 }
 131                 tmpb = false;
 132                 // SM11-15
 133                 if(tmpp != NULL) {
 134                         tmpb = (read_bios(_T(ROM_FM8_SM11_15), tmpp, 0x800) >= 0x800);
 135                 }
 136                 if(tmpb) {
 137                         memcpy(fm7_bootroms[4], &(tmpp[0x000]), 0x200); // Basic
 138                         memcpy(fm7_bootroms[6], &(tmpp[0x200]), 0x200); // BUBBLE
 139                         memcpy(fm7_bootroms[5], &(tmpp[0x400]), 0x200); // DOS 320K
 140                         memcpy(fm7_bootroms[7], &(tmpp[0x600]), 0x200); // DOS 8INCH
 141                         this->out_debug_log(_T("NOTE: LOADING BULK BOOTROM SM11-15 OK."));
 142                         diag_load_sm11_15 = true;
 143                 } else {
 144                         memcpy(fm7_bootroms[4], fm7_bootroms[0], 0x200); // Basic
 145                         memcpy(fm7_bootroms[5], fm7_bootroms[1], 0x200); // DOS 5Inch
 146                         memcpy(fm7_bootroms[6], fm7_bootroms[2], 0x200); // BUBBLE
 147                         if(read_bios(_T(ROM_FM8_BOOT_DOS_FD8), fm7_bootroms[7], 0x200) >= 0x1e0) {
 148                                 diag_load_bootrom_sfd8 = true;
 149                         }
 150                 }
 151                 if(tmpp != NULL) free(tmpp);
 152         }
 153
 154 #elif defined(_FM7) || defined(_FMNEW7)
 155         // FM-7 HAS TWO TYPE ROM.
 156         // See, http://www.mindspring.com/~thasegaw/rpcg/fm7rom.html .
 157         diag_load_tl11_11 = false;
 158         diag_load_tl11_12 = false;
 159         {
 160                 uint8_t *tmpp;
 161                 bool tmpb = false;
 162                 tmpp = malloc(0x800);
 163                 if(tmpp != NULL) memset(tmpp, 0xff, 0x800);
 164 # if defined(_FMNEW7)
 165                 // For FM-NEW7, If you have TL11-12, load first.
 166                 if(tmpp != NULL) {
 167                         diag_load_tl11_12 = (read_bios(_T(ROM_FM7_BOOT_TL11_12), tmpp, 0x800) >= 0x800);
 168                 }
 169                 if(diag_load_tl11_12) {
 170                         memcpy(fm7_bootroms[0], &(tmpp[0x000]), 0x200);
 171                         memcpy(fm7_bootroms[2], &(tmpp[0x200]), 0x200);
 172                         memcpy(fm7_bootroms[1], &(tmpp[0x400]), 0x200);
 173                         memcpy(fm7_bootroms[3], &(tmpp[0x600]), 0x200);
 174                         diag_load_bootrom_bas = true;
 175                         diag_load_bootrom_dos = true;
 176                         diag_load_bootrom_bubble = true;
 177                         this->out_debug_log(_T("NOTE: LOADING BULK BOOTROM TL11-12 OK"));
 178                 }
 179 # endif
 180                 if(!diag_load_tl11_12) {
 181                         // TL11-11
 182                         if(tmpp != NULL) {
 183                                 tmpb = (read_bios(_T(ROM_FM7_BOOT_TL11_11), tmpp, 0x800) >= 0x800);
 184                         }
 185                         if(tmpb) {
 186 # if defined(_FMNEW7)
 187                                 this->out_debug_log(_T("NOTE: LOADING BULK BOOTROM TL11-11 (FALLBACK) OK"));
 188 # else
 189                                 this->out_debug_log(_T("NOTE: LOADING BULK BOOTROM TL11-11 OK"));
 190 # endif
 191                                 memcpy(fm7_bootroms[0], &(tmpp[0x000]), 0x200);
 192                                 memcpy(fm7_bootroms[2], &(tmpp[0x200]), 0x200);
 193                                 memcpy(fm7_bootroms[1], &(tmpp[0x400]), 0x200);
 194                                 memcpy(fm7_bootroms[3], &(tmpp[0x600]), 0x200);
 195                                 diag_load_bootrom_bas = true;
 196                                 diag_load_bootrom_dos = true;
 197                                 diag_load_bootrom_bubble = true;
 198                                 diag_load_tl11_11 = true;
 199                         } else {
 200                                 if(read_bios(_T(ROM_FM7_BOOT_BASIC), fm7_bootroms[0], 0x200) >= 0x1e0) {
 201                                         diag_load_bootrom_bas = true;
 202                                 }
 203                                 if(read_bios(_T(ROM_FM7_BOOT_DOS), fm7_bootroms[1], 0x200) >= 0x1e0) {
 204                                         diag_load_bootrom_dos = true;
 205                                 }
 206                                 if(read_bios(_T(ROM_FM7_BOOT_BUBBLE_7), fm7_bootroms[2], 0x200) >= 0x1e0) {
 207                                         diag_load_bootrom_bubble = true;
 208                                 }
 209                         }
 210                         if(tmpp != NULL) free(tmpp);
 211                 }
 212         }
 213 #elif defined(_FM77_VARIANTS)
 214         // FM-77 HAS ONE TYPE ROM.
 215         // See, http://www.mindspring.com/~thasegaw/rpcg/fm7rom.html .
 216         {
 217                 uint8_t *tmpp;
 218                 bool tmpb = false;
 219                 tmpp = malloc(0x1000);
 220                 // WB11-12
 221                 diag_load_wb11_12 = false;
 222                 if(tmpp != NULL) {
 223                         tmpb = (read_bios(_T(ROM_FM77_BOOT_WB11_12), tmpp, 0x1000) >= 0x1000);
 224                 }
 225                 if(tmpb) {
 226                         diag_load_wb11_12 = true;
 227                         this->out_debug_log(_T("NOTE: LOADING BULK BOOTROM WB11-12 OK."));
 228                         memcpy(fm7_bootroms[2], &(tmpp[0x000]), 0x200); // Basic (MMR)
 229                         memcpy(fm7_bootroms[5], &(tmpp[0x200]), 0x200); // Bubble (128K)
 230                         memcpy(fm7_bootroms[6], &(tmpp[0x400]), 0x200); // Bubble (32K)
 231                         memcpy(fm7_bootroms[4], &(tmpp[0x600]), 0x200); // Reserve
 232                         memcpy(fm7_bootroms[0], &(tmpp[0x800]), 0x200); // Basic
 233                         memcpy(fm7_bootroms[1], &(tmpp[0xa00]), 0x200); // DOS (320K)
 234                         memcpy(fm7_bootroms[3], &(tmpp[0xc00]), 0x200); // DOS (1M)
 235                         memcpy(fm7_bootroms[7], &(tmpp[0xe00]), 0x200); // Reserve 2
 236                         diag_load_bootrom_bas = true;
 237                         diag_load_bootrom_dos = true;
 238                         diag_load_bootrom_mmr = true;
 239                         diag_load_bootrom_2hd = true;
 240                 } else {
 241                         if(read_bios(_T(ROM_FM7_BOOT_BASIC), fm7_bootroms[0], 0x200) >= 0x1e0) {
 242                                 diag_load_bootrom_bas = true;
 243                         }
 244
 245                         if(read_bios(_T(ROM_FM7_BOOT_DOS), fm7_bootroms[1], 0x200) >= 0x1e0) {
 246                                 diag_load_bootrom_dos = true;
 247                         }
 248                         if(read_bios(_T(ROM_FM7_BOOT_MMR), fm7_bootroms[2], 0x200) >= 0x1e0) {
 249                                 diag_load_bootrom_mmr = true;
 250                         } else {
 251                                 memcpy(fm7_bootroms[2], fm7_bootroms[0], 0x200); // Copy Fallback
 252                                 diag_load_bootrom_mmr = false;
 253                         }
 254                         if(read_bios(_T(ROM_FM7_BOOT_2HD), fm7_bootroms[3], 0x200) >= 0x1e0) {
 255                                 diag_load_bootrom_2hd = true;
 256                         }
 257
 258                         if(read_bios(_T(ROM_FM77_BOOT_BUBBLE_128K), fm7_bootroms[5], 0x200) >= 0x1e0) { // Bubble 128K
 259                                 //diag_load_bootrom_dos = true;
 260                         }
 261                         if(read_bios(_T(ROM_FM7_BOOT_BUBBLE_7), fm7_bootroms[6], 0x200) >= 0x1e0) { // Bubble 32K
 262                                 //diag_load_bootrom_dos = true;
 263                         }
 264                 }
 265                 if(tmpp != NULL) free(tmpp);
 266         }
 267         i = FM7_MAINMEM_BOOTROM_RAM;
 268         memset(fm7_bootram, 0x00, 0x200 * sizeof(uint8_t)); // RAM
 269 # elif defined(_FM77AV_VARIANTS)
 270         i = FM7_MAINMEM_AV_PAGE0;
 271         memset(fm7_mainmem_mmrbank_0, 0x00, 0x10000 * sizeof(uint8_t));
 272
 273         i = FM7_MAINMEM_AV_PAGE2;
 274         memset(fm7_mainmem_mmrbank_2, 0x00, 0x10000 * sizeof(uint8_t));
 275
 276         i = FM7_MAINMEM_INITROM;
 277         diag_load_initrom = false;
 278         memset(fm7_mainmem_initrom, 0xff, 0x2000 * sizeof(uint8_t));
 279
 280         if(read_bios(_T(ROM_FM77AV_INITIATOR), fm7_mainmem_initrom, 0x2000) >= 0x2000) diag_load_initrom = true;
 281         this->out_debug_log(_T("77AV INITIATOR ROM READING : %s"), diag_load_initrom ? "OK" : "NG");
 282
 283         if(read_bios(_T(ROM_FM7_BOOT_MMR), fm77av_hidden_bootmmr, 0x200) < 0x1e0) {
 284                 memcpy(fm77av_hidden_bootmmr, &fm7_mainmem_initrom[0x1a00], 0x200);
 285                 diag_load_bootrom_mmr = true;
 286         }
 287         fm77av_hidden_bootmmr[0x1fe] = 0xfe;
 288         fm77av_hidden_bootmmr[0x1fe] = 0x00;
 289
 290         i = FM7_MAINMEM_BOOTROM_RAM;
 291         memset(fm7_bootram, 0x00, 0x200 * sizeof(uint8_t)); // RAM
 292
 293         if(diag_load_initrom) diag_load_bootrom_bas = true;
 294         if(diag_load_initrom) diag_load_bootrom_dos = true;
 295
 296         if((config.boot_mode & 0x03) == 0) {
 297                 memcpy(fm7_bootram, &fm7_mainmem_initrom[0x1800], 0x1e0 * sizeof(uint8_t));
 298         } else {
 299                 memcpy(fm7_bootram, &fm7_mainmem_initrom[0x1a00], 0x1e0 * sizeof(uint8_t));
 300         }
 301         fm7_bootram[0x1fe] = 0xfe; // Set reset vector.
 302         fm7_bootram[0x1ff] = 0x00; //
 303         // FM-7
 304 #endif
 305         this->out_debug_log(_T("BOOT ROM (basic mode) READING : %s"), diag_load_bootrom_bas ? "OK" : "NG");
 306         this->out_debug_log(_T("BOOT ROM (DOS   mode) READING : %s"), diag_load_bootrom_dos ? "OK" : "NG");
 307
 308 #if defined(_FM77_VARIANTS)
 309         this->out_debug_log(_T("BOOT ROM (MMR   mode) READING : %s"), diag_load_bootrom_mmr ? "OK" : "NG");
 310         this->out_debug_log(_T("BOOT ROM (2HD   mode) READING : %s"), diag_load_bootrom_2hd ? "OK" : "NG");
 311 #elif defined(_FM8)
 312         if(diag_load_bootrom_bubble_128k) {
 313                 this->out_debug_log(_T("BOOT ROM (BUBBLE 128K) READING : %s"), "OK");
 314         } else if(diag_load_bootrom_bubble) {
 315                 this->out_debug_log(_T("BOOT ROM (BUBBLE  32K) READING : %s"), "OK");
 316         } else {
 317                 this->out_debug_log(_T("BOOT ROM (BUBBLE  32K) READING : %s"), "NG");
 318         }
 319         this->out_debug_log(_T("BOOT ROM (2HD   mode) READING : %s"), diag_load_bootrom_2hd ? "OK" : "NG");
 320 #elif defined(_FM7) || defined(_FM7)
 321         if(diag_load_bootrom_bubble) {
 322                 this->out_debug_log(_T("BOOT ROM (BUBBLE mode) READING : %s"), "OK");
 323         } else {
 324                 this->out_debug_log(_T("BOOT ROM (BUBBLE mode) READING : %s"), "NG");
 325         }
 326 #else // FM77AV*
 327         this->out_debug_log(_T("BOOT ROM (MMR   mode) READING : %s"), diag_load_bootrom_mmr ? "OK" : "NG");
 328 #endif
 329
 330
 331 #if !defined(_FM77AV_VARIANTS)
 332         for(i = 0; i <= 3; i++) {
 333                 uint8_t *p = fm7_bootroms[i];
 334                 p[0x1fe] = 0xfe; // Set reset vector.
 335                 p[0x1ff] = 0x00; //
 336         }
 337
 338 #endif
 339         i = FM7_MAINMEM_RESET_VECTOR;
 340         fm7_mainmem_reset_vector[0] = 0xfe;
 341         fm7_mainmem_reset_vector[1] = 0x00;
 342
 343         i = FM7_MAINMEM_BASICROM;
 344         memset(fm7_mainmem_basicrom, 0xff, 0x7c00 * sizeof(uint8_t));
 345
 346 #if !defined(_FM8)
 347         if(read_bios(_T(ROM_FM7_FBASICV30L20), fm7_mainmem_basicrom, 0x7c00) == 0x7c00) {
 348                 diag_load_basicrom = true;
 349         } else if(read_bios(_T(ROM_FM7_FBASICV30L10), fm7_mainmem_basicrom, 0x7c00) == 0x7c00) {
 350                 diag_load_basicrom = true;
 351         } else if(read_bios(_T(ROM_FM7_FBASICV30L00), fm7_mainmem_basicrom, 0x7c00) == 0x7c00) {
 352                 diag_load_basicrom = true;
 353         } else if(read_bios(_T(ROM_FM7_FBASICV30), fm7_mainmem_basicrom, 0x7c00) == 0x7c00) {
 354                 diag_load_basicrom = true;
 355         }
 356
 357 #else // FM8
 358         if(read_bios(_T(ROM_FM8_FBASICV10), fm7_mainmem_basicrom, 0x7c00) == 0x7c00) diag_load_basicrom = true;
 359 #endif
 360         this->out_debug_log(_T("BASIC ROM READING : %s"), diag_load_basicrom ? "OK" : "NG");
 361
 362         i = FM7_MAINMEM_BIOSWORK;
 363         memset(fm7_mainmem_bioswork, 0x00, 0x80 * sizeof(uint8_t));
 364 #if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 365         config.dipswitch = config.dipswitch | FM7_DIPSW_DICTROM_AV;
 366 #endif
 367 #if defined(CAPABLE_DICTROM)
 368         diag_load_dictrom = false;
 369         i = FM7_MAINMEM_DICTROM;
 370         memset(fm7_mainmem_dictrom, 0xff, 0x40000 * sizeof(uint8_t));
 371         memset(fm7_mainmem_learndata, 0x00, 0x2000 * sizeof(uint8_t));
 372         if((config.dipswitch & FM7_DIPSW_DICTROM_AV) != 0) {
 373                 if(read_bios(_T(ROM_FM77AV_DICTIONARY), fm7_mainmem_dictrom, 0x40000) == 0x40000) diag_load_dictrom = true;
 374                 this->out_debug_log(_T("DICTIONARY ROM READING : %s"), diag_load_dictrom ? "OK" : "NG");
 375                 dictrom_connected = diag_load_dictrom;
 376
 377                 i = FM7_MAINMEM_BACKUPED_RAM;
 378                 diag_load_learndata = false;
 379                 if(read_bios(_T(RAM_FM77AV_DIC_BACKUP), fm7_mainmem_learndata, 0x2000) == 0x2000) diag_load_learndata = true;
 380                 this->out_debug_log(_T("DICTIONARY BACKUPED RAM READING : %s"), diag_load_learndata ? "OK" : "NG");
 381                 if(!diag_load_learndata) write_bios(_T("USERDIC.DAT"), fm7_mainmem_learndata, 0x2000);
 382         } else {
 383                 this->out_debug_log(_T("LOADING FROM DICTIONARY CARD IS CANCELLED."));
 384                 dictrom_connected = false;
 385                 diag_load_dictrom = false;
 386                 diag_load_learndata = false;
 387         }
 388 #endif
 389
 390         i = FM7_MAINMEM_77AV40_EXTRAROM;
 391 #if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 392         diag_load_extrarom = false;
 393         memset(fm7_mainmem_extrarom, 0xff, sizeof(fm7_mainmem_extrarom));
 394         if(read_bios(_T(ROM_FM77AV40EX_EXTSUB), fm7_mainmem_extrarom, 0xc000) == 0xc000) diag_load_extrarom = true;
 395         this->out_debug_log(_T("AV40SX/EX EXTRA ROM READING : %s"), diag_load_extrarom ? "OK" : "NG");
 396         //register_event(this, EVENT_FM7_MAINMEM_DRAM_REFRESH, 13.02, true, &event_refresh); // OK?
 397 #endif
 398         init_data_table();
 399         update_all_mmr_jumptable();
 400 }
 401
 402 void FM7_MAINMEM::release()
 403 {
 404 # if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX) || \
 405          defined(_FM77_VARIANTS)
 406         if(fm7_mainmem_extram != NULL) free(fm7_mainmem_extram);
 407 #endif
 408 #if !defined(_FM77AV_VARIANTS)
 409         int i;
 410         for(i = 0; i < 4; i++) {
 411                 if(fm7_bootroms[i] != NULL) free(fm7_bootroms[i]);
 412                 fm7_bootroms[i] = NULL;
 413         }
 414 #endif
 415 #if defined(CAPABLE_DICTROM)
 416         write_bios(_T("USERDIC.DAT"), fm7_mainmem_learndata, 0x2000);
 417 #endif
 418 //      MEMORY::release();
 419 }
 420
 421 void FM7_MAINMEM::init_data_table(void)
 422 {
 423         uint32_t addr;
 424         uint32_t paddr;
 425         uint32_t main_begin;
 426         data_func_table_t *p;
 427         memset(data_table, 0x00, sizeof(data_table));
 428 #if defined(HAS_MMR)
 429         main_begin = 0x30000;
 430 #else
 431         main_begin = 0x00000;
 432 #endif
 433         for(addr = main_begin; addr < (main_begin + 0x8000); addr += 0x80) {
 434                 paddr = addr >> 7;
 435                 data_table[paddr].read_data  = &fm7_mainmem_omote[addr & 0x7fff];
 436                 data_table[paddr].write_data = &fm7_mainmem_omote[addr & 0x7fff];
 437         }
 438         for(addr = main_begin + 0x8000; addr < (main_begin + 0xfc00); addr += 0x80) {
 439                 paddr = addr >> 7;
 440                 data_table[paddr].read_func  = &FM7_MAINMEM::read_ura_basicrom;
 441                 data_table[paddr].write_func = &FM7_MAINMEM::write_ura_basicrom;
 442         }
 443         {
 444                 addr = main_begin + 0xfc00;
 445                 paddr = addr >> 7;
 446                 data_table[paddr].read_data  = fm7_mainmem_bioswork;
 447                 data_table[paddr].write_data = fm7_mainmem_bioswork;
 448         }
 449         {
 450                 addr = main_begin + 0xfc80;
 451                 paddr = addr >> 7;
 452                 data_table[paddr].read_func  = &FM7_MAINMEM::read_shared_ram;
 453                 data_table[paddr].write_func = &FM7_MAINMEM::write_shared_ram;
 454         }
 455         for(addr = main_begin + 0xfd00; addr < (main_begin + 0xfe00); addr += 0x80) {
 456                 paddr = addr >> 7;
 457                 data_table[paddr].read_func  = &FM7_MAINMEM::read_mmio;
 458                 data_table[paddr].write_func = &FM7_MAINMEM::write_mmio;
 459         }
 460         for(addr = main_begin + 0xfe00; addr < (main_begin + 0x10000); addr += 0x80) {
 461                 paddr = addr >> 7;
 462                 data_table[paddr].read_func  = &FM7_MAINMEM::read_bootrom;
 463                 data_table[paddr].write_func = &FM7_MAINMEM::write_bootrom;
 464         }
 465
 466 #if defined(_FM77AV_VARIANTS)
 467         for(addr = 0x00000; addr < 0x10000; addr += 0x80) {
 468                 paddr = addr >> 7;
 469                 data_table[paddr].read_data  = &fm7_mainmem_mmrbank_0[addr & 0xffff];
 470                 data_table[paddr].write_data = &fm7_mainmem_mmrbank_0[addr & 0xffff];
 471         }
 472         for(addr = 0x10000; addr < 0x20000; addr += 0x80) {
 473                 paddr = addr >> 7;
 474                 data_table[paddr].read_func = &FM7_MAINMEM::read_direct_access;
 475                 data_table[paddr].write_func = &FM7_MAINMEM::write_direct_access;
 476         }
 477 # if defined(CAPABLE_DICTROM)
 478         for(addr = 0x20000; addr < 0x30000; addr += 0x80) {
 479                 paddr = addr >> 7;
 480                 data_table[paddr].read_func = &FM7_MAINMEM::read_page2;
 481                 data_table[paddr].write_func = &FM7_MAINMEM::write_page2;
 482         }
 483 # else
 484         for(addr = 0x20000; addr < 0x30000; addr += 0x80) {
 485                 paddr = addr >> 7;
 486                 data_table[paddr].read_data  = &fm7_mainmem_mmrbank_2[addr & 0xffff];
 487                 data_table[paddr].write_data = &fm7_mainmem_mmrbank_2[addr & 0xffff];
 488         }
 489 # endif
 490 # if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX)
 491         int pages = extram_pages;
 492         if((pages > 0) && (pages < 12) && (fm7_mainmem_extram != NULL)) {
 493                 for(addr = 0x40000; addr < (0x40000 + extram_pages * 0x10000) ; addr += 0x80) {
 494                         paddr = addr >> 7;
 495                         data_table[paddr].read_data  = &fm7_mainmem_extram[addr - 0x40000];
 496                         data_table[paddr].write_data = &fm7_mainmem_extram[addr - 0x40000];
 497                         data_table[paddr].read_func  = NULL;
 498                         data_table[paddr].write_func = NULL;
 499                 }
 500                 for(addr = 0x40000 + extram_pages * 0x10000; addr < 0x100000; addr += 0x80) {
 501                         paddr = addr >> 7;
 502                         data_table[paddr].read_data  = NULL;
 503                         data_table[paddr].write_data = NULL;
 504                         data_table[paddr].read_func  = NULL;
 505                         data_table[paddr].write_func = NULL;
 506                 }
 507         }
 508 # endif
 509 #elif defined(_FM77_VARIANTS)
 510         int pages = extram_pages;
 511         if((pages > 0) && (pages < 4) && (fm7_mainmem_extram != NULL)) {
 512                 for(addr = 0x00000; addr < (extram_pages * 0x10000) ; addr += 0x80) { // Thanks to Ryu Takegami
 513                         paddr = addr >> 7;
 514                         data_table[paddr].read_data  = &fm7_mainmem_extram[addr];
 515                         data_table[paddr].write_data = &fm7_mainmem_extram[addr];
 516                         data_table[paddr].read_func  = NULL;
 517                         data_table[paddr].write_func = NULL;
 518                 }
 519                 if(extram_pages < 3) {
 520                         for(addr = extram_pages * 0x10000; addr < 0x30000; addr += 0x80) {
 521                                 paddr = addr >> 7;
 522                                 data_table[paddr].read_data  = NULL;
 523                                 data_table[paddr].write_data = NULL;
 524                                 data_table[paddr].read_func  = NULL;
 525                                 data_table[paddr].write_func = NULL;
 526                         }
 527                 }
 528         }
 529 #endif
 530 }
 531
 532 bool FM7_MAINMEM::get_loadstat_basicrom(void)
 533 {
 534         return diag_load_basicrom;
 535 }
 536
 537 bool FM7_MAINMEM::get_loadstat_bootrom_bas(void)
 538 {
 539         return diag_load_bootrom_bas;
 540 }
 541
 542 bool FM7_MAINMEM::get_loadstat_bootrom_dos(void)
 543 {
 544         return diag_load_bootrom_dos;
 545 }
 546
 547 uint32_t FM7_MAINMEM::read_bios(const _TCHAR *name, uint8_t *ptr, uint32_t size)
 548 {
 549         FILEIO fio;
 550         uint32_t blocks;
 551         const _TCHAR *s;
 552
 553         if((name == NULL) || (ptr == NULL))  return 0;
 554         s = create_local_path(name);
 555         if(s == NULL) return 0;
 556
 557         if(!fio.Fopen(s, FILEIO_READ_BINARY)) return 0;
 558         blocks = fio.Fread(ptr, size, 1);
 559         fio.Fclose();
 560
 561         return blocks * size;
 562 }
 563
 564 uint32_t FM7_MAINMEM::write_bios(const _TCHAR *name, uint8_t *ptr, uint32_t size)
 565 {
 566         FILEIO fio;
 567         uint32_t blocks;
 568         const _TCHAR *s;
 569
 570         if((name == NULL) || (ptr == NULL))  return 0;
 571         s = create_local_path(name);
 572         if(s == NULL) return 0;
 573
 574         fio.Fopen(s, FILEIO_WRITE_BINARY);
 575         blocks = fio.Fwrite(ptr, size, 1);
 576         fio.Fclose();
 577
 578         return blocks * size;
 579 }
 580
 581 }