source/src/vm/fm7/fm7_mainmem.cpp

   1 /*
   2  * Main memory without MMR for FM-7 [FM7_MAINMEM]
   3  *  Author: K.Ohta
   4  *  Date  : 2015.01.01-
   5  *
   6  */
   7
   8 #include "fm7_mainmem.h"
   9
  10
  11 int FM7_MAINMEM::getbank(uint32 addr, uint32 *realaddr)
  12 {
  13         if(realaddr == NULL) return -1; // Not effect.
  14         addr = addr & 0xffff;
  15         if(addr < 0x8000) {
  16                 *realaddr = addr - 0;
  17                 return FM7_MAINMEM_OMOTE;
  18         }
  19
  20         if(addr < 0xfc00) {
  21                 *realaddr = addr - 0x8000;
  22                 if(mainio->get_rommode_fd0f() == true) return FM7_MAINMEM_BASICROM;
  23                 return FM7_MAINMEM_URA;
  24         }
  25         if(addr < 0xfc80) {
  26                 *realaddr = addr - 0xfc00;
  27                 return FM7_MAINMEM_BIOSWORK;
  28         }
  29         if(addr < 0xfd00) {
  30                 *realaddr = addr - 0xfc80;
  31                 return FM7_MAINMEM_SHAREDRAM;
  32         }
  33         if(addr < 0xfe00) {
  34                 mainio->wait();
  35                 *realaddr = addr - 0xfd00;
  36                 return FM7_MAINMEM_MMIO;
  37         }
  38         if(addr < 0xfff0) {
  39                 if(addr < 0xffe0) mainio->wait();
  40                 *realaddr = addr - 0xfe00;
  41                 //if(mainio->get_boot_romram() != true) return FM7_MAINMEM_BOOTROM_RAM;
  42                 switch(dipsw->get_boot_mode()) {
  43                         case FM7_BOOTMODE_BASIC:
  44                                 return FM7_MAIMEM_BOOTROM_BAS;
  45                                 break;
  46                         case FM7_BOOTMODE_DOS:
  47                                 return FM7_MAIMEM_BOOTROM_DOS;
  48                                 break;
  49                         case FM7_BOOTMODE_ROM3:
  50                                 return FM7_MAIMEM_BOOTROM_ROM3;
  51                                 break;
  52                         default:
  53                                 return FM7_MAINMEM_BOOTROM_BAS; // Really?
  54                                 break;
  55                 }
  56         }
  57         if(addr < 0xfffe) {
  58                 *realaddr = addr - 0xfff0;
  59                 return FM7_MAINMEM_VECTOR;
  60         }
  61         if(addr < 0x10000) {
  62                 mainio->wait();
  63                 *realaddr = addr - 0xfffe;
  64                 return FM7_MAINMEM_VECTOR_RESET;
  65         }
  66      // Over
  67         realaddr = addr;
  68         return -1;
  69 }
  70
  71 uint32 FM7_MAINMEM::read_data8(uint32 addr)
  72 {
  73         uint32 ret;
  74         uint32 realaddr;
  75         int bank;
  76
  77         bank = getbank(addr, &realaddr);
  78         if(bank < 0) return 0xff; // Illegal
  79
  80         if(read_table[bank].dev != NULL) {
  81                 return read_table[bank].dev->read_memory_mapped_io8(realaddr);
  82         } else {
  83                 if(read_table[bank].memory != NULL) {
  84                         return read_table[bank].memory[realaddr];
  85                 }
  86                 return 0xff; // Dummy
  87         }
  88 }
  89
  90 void FM7_MAINMEM::write_data8(uint32 addr, uint32 data)
  91 {
  92         uint32 ret;
  93         uint32 realaddr;
  94         int bank;
  95
  96         bank = getbank(addr, &realaddr);
  97         if(bank < 0) return; // Illegal
  98
  99         if(write_table[bank].dev != NULL) {
 100                 write_table[bank].dev->write_memory_mapped_io8(realaddr, data);
 101         } else {
 102                 if(write_table[bank].memory != NULL) {
 103                   write_table[bank].memory[realaddr] = (uint8)(data & 0x000000ff);
 104                 }
 105         }
 106 }
 107
 108 // Read / Write data(s) as big endian.
 109 uint32 FM7_MAINMEM::read_data16(uint32 addr)
 110 {
 111         uint32 hi, lo;
 112         uint32 val;
 113
 114         hi = read_data8(addr) & 0xff;
 115         lo = read_data8(addr + 1) & 0xff;
 116
 117         val = hi * 256 + lo;
 118         return val;
 119 }
 120
 121 uint32 FM7_MAINMEM::read_data32(uint32 addr)
 122 {
 123         uint32 ah, a2, a3, al;
 124         uint32 val;
 125
 126         ah = read_data8(addr) & 0xff;
 127         a2 = read_data8(addr + 1) & 0xff;
 128         a3 = read_data8(addr + 2) & 0xff;
 129         al = read_data8(addr + 3) & 0xff;
 130
 131         val = ah * (65536 * 256) + a2 * 65536 + a3 * 256 + al;
 132         return val;
 133 }
 134
 135 void FM7_MAINMEM::write_data16(uint32 addr, uint32 data)
 136 {
 137         uint32 d = data;
 138
 139         write_data8(addr + 1, d & 0xff);
 140         d = d / 256;
 141         write_data8(addr + 0, d & 0xff);
 142 }
 143
 144 void FM7_MAINMEM::write_data32(uint32 addr, uint32 data)
 145 {
 146         uint32 d = data;
 147
 148         write_data8(addr + 3, d & 0xff);
 149         d = d / 256;
 150         write_data8(addr + 2, d & 0xff);
 151         d = d / 256;
 152         write_data8(addr + 1, d & 0xff);
 153         d = d / 256;
 154         write_data8(addr + 0, d & 0xff);
 155 }
 156
 157
 158 bool FM7_MAINMEM::get_loadstat_basicrom(void)
 159 {
 160         return diag_load_basicrom;
 161 }
 162
 163 bool FM7_MAINMEM::get_loadstat_bootrom_bas(void)
 164 {
 165         return diag_load_bootrom_bas;
 166 }
 167
 168 bool FM7_MAINMEM::get_loadstat_bootrom_dos(void)
 169 {
 170         return diag_load_bootrom_dos;
 171 }
 172
 173 uint32 FM7_MAINMEM::read_bios(const char *name, uint8 *ptr, uint32 size)
 174 {
 175         FILEIO fio;
 176         uint32 blocks;
 177         _TCHAR *s;
 178
 179         if((name == NULL) || (ptr == NULL))  return 0;
 180         s = bios_path(name);
 181         if(s == NULL) return 0;
 182
 183         if(!fio.Fopen(s, FILEIO_READ_BINARY)) return 0;
 184         blocks = fio.Fread(s, size, 1);
 185         fio.Fclose();
 186
 187         return blocks * size;
 188 }
 189
 190 FM7_MAINMEM::FM7_MAINMEM(VM* parent_vm, EMU* parent_emu) : MEMORY(parent_vm, parent_emu)
 191 {
 192         int i;
 193         p_vm = parent_vm;
 194         p_emu = parent_emu;
 195         for(i = 0; i < 4; i++) fm7_bootroms[i - FM7_MAINMEM_BOOTROM_BAS] = malloc(0x200);
 196 }
 197
 198 FM7_MAINMEM::~FM7_MAINMEM()
 199 {
 200         int i;
 201         for(i = 0; i < 4; i++) {
 202                 if(fm7_bootroms[i] != NULL) free(fm7_bootroms[i]);
 203                 fm7_bootroms[i] = NULL;
 204         }
 205 }
 206
 207 void FM7_MAINMEM::initialize()
 208 {
 209         int i;
 210         // Initialize table
 211         // $0000-$7FFF
 212         i = FM7_MAINMEM_OMOTE;
 213         memset(fm7_maimem_omote, 0x00, 0x8000 * sizeof(uint8));
 214         read_table[i].dev = NULL;
 215         read_table[i].memory = fm7_mainmem_omote;
 216         write_table[i].dev = NULL;
 217         write_table[i].memory = fm7_mainmem_omote;
 218
 219
 220         // $8000-$FBFF
 221         i = FM7_MAINMEM_URA
 222         memset(fm7_maimem_ura, 0x00, 0x7c00 * sizeof(uint8));
 223         read_table[i].dev = NULL;
 224         read_table[i].memory = fm7_mainmem_ura;
 225         write_table[i].dev = NULL;
 226         write_table[i].memory = fm7_mainmem_ura;
 227
 228
 229         i = FM7_MAINMEM_BASICROM;
 230         memset(fm7_maimem_basicrom, 0xff, 0x7c00 * sizeof(uint8));
 231         read_table[i].dev = NULL;
 232         read_table[i].memory = fm7_mainmem_basicrom;
 233         write_table[i].dev = NULL;
 234         write_table[i].memory = write_dummy;
 235         if(read_bios("FBASIC30.ROM", read_table[i].memory, 0x7c00) == 0x7c00) diag_load_basicrom = true;
 236
 237         i = FM7_MAINMEM_BIOSWORK;
 238         memset(fm7_maimem_bioswork, 0x00, 0x80 * sizeof(uint8));
 239         read_table[i].dev = NULL;
 240         read_table[i].memory = fm7_mainmem_bioswork;
 241         write_table[i].dev = NULL;
 242         write_table[i].memory = fm7_mainmem_bioswork;
 243
 244         i = FM7_MAINMEM_SHAREDRAM;
 245         read_table[i].dev = sharedram;
 246         read_table[i].memory = NULL;
 247         write_table[i].dev = sharedram;
 248         write_table[i].memory = NULL;
 249
 250         i = FM7_MAINMEM_MMIO;
 251         read_table[i].dev = fm7_io_main;
 252         read_table[i].memory = NULL;
 253         write_table[i].dev = fm7_io_main;
 254         write_table[i].memory = NULL;
 255
 256         for(i = FM7_MAINMEM_BOOTROM_BAS; i <= FM7_MAINMEM_BOOTROM_RAM; i++) {
 257             memset(fm7_bootroms[i - FM7_MAINMEM_BOOTROM_BAS], 0x00, 0x200);
 258             read_table[i].dev = NULL;
 259             read_table[i].memory = fm7_bootroms[i - FM7_MAINMEM_BOOTROM_BAS];
 260             write_table[i].dev = NULL;
 261             write_table[i].memory = write_dummy;
 262         }
 263         if(read_bios("BOOT_BAS.ROM", read_table[FM7_MAINMEM_BOOTROM_BAS].memory, 0x200) == 0x200) diag_load_bootrom_bas = true;
 264         if(read_bios("BOOT_DOS.ROM", read_table[FM7_MAINMEM_BOOTROM_DOS].memory, 0x200) == 0x200) diag_load_bootrom_dos = true;
 265         write_table[FM7_BAINMEM_BOOTROM_RAM].memory = read_table[FM7_BAINMEM_BOOTROM_RAM].memory; // Write enabled on BOOTRAM.
 266
 267         i = FM7_MAINMEM_VECTOR;
 268         memset(fm7_mainmem_bootrom_vector, 0x00, 0x0e);
 269         read_table[i].dev = NULL;
 270         read_table[i].memory = fm7_mainmem_bootrom_vector;
 271         write_table[i].dev = NULL;
 272         write_table[i].memory = fm7_mainmem_bootrom_vector;
 273
 274         i = FM7_MAINMEM_VECTOR_RESET;
 275         read_table[i].dev = NULL;
 276         read_table[i].memory = fm7_mainmem_resetvector;
 277         write_table[i].dev = NULL;
 278         write_table[i].memory = write_dummy;
 279 }