source/src/vm/msx/memory_ex.h

   1 /*
   2         Common Source Code Project
   3         MSX Series (experimental)
   4
   5         Origin : src/vm/msx/memory.h
   6
   7         modified by umaiboux
   8         Date   : 2016.03.xx-
   9
  10         [ memory ]
  11 */
  12
  13 #ifndef _MEMORY_EX_H_
  14 #define _MEMORY_EX_H_
  15
  16 #define USE_MEGAROM
  17
  18 #include "../vm.h"
  19 #include "../../emu.h"
  20 #include "../device.h"
  21
  22 #ifdef USE_MEGAROM
  23 #include "sound_cart.h"
  24 #endif
  25
  26 #define SIG_LDC_EXV     0
  27 #define SIG_LDC_ACK     1
  28 #define SIG_LDC_MUTE    2
  29
  30 #define SIG_MEMORY_SEL  0
  31
  32 #if defined(FDD_PATCH_SLOT)
  33 class DISK;
  34 #endif
  35
  36 // MAIN ROM 32K
  37 // or MAIN ROM 32K + MAIN RAM 32K
  38
  39 class SLOT_MAINROM : public DEVICE
  40 {
  41 private:
  42         uint8_t wdmy[0x2000];
  43         uint8_t rdmy[0x2000];
  44         uint8_t* wbank[8];
  45         uint8_t* rbank[8];
  46         uint8_t rom[0x8000];
  47 #ifdef MAINROM_PLUS_RAM_32K
  48         uint8_t ram[0x8000];
  49 #endif
  50 public:
  51         SLOT_MAINROM(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
  52         {
  53                 set_device_name(_T("Main ROM"));
  54         }
  55         ~SLOT_MAINROM() {}
  56
  57         // common functions
  58         void initialize();
  59         void write_data8(uint32_t addr, uint32_t data);
  60         uint32_t read_data8(uint32_t addr);
  61         bool process_state(FILEIO* state_fio, bool loading);
  62 };
  63
  64 // Cart
  65
  66 class SLOT_CART : public DEVICE
  67 {
  68 private:
  69         uint8_t wdmy[0x2000];
  70         uint8_t rdmy[0x2000];
  71         uint8_t* wbank[8];
  72         uint8_t* rbank[8];
  73 #ifdef USE_MEGAROM
  74         uint8_t rom[1024*1024*4];
  75         int32_t type;
  76         SOUND_CART *d_sound;
  77         bool bank_scc;
  78
  79         int tmp_rbank_ptr[8];
  80 #else
  81         uint8_t rom[0x10000];
  82 #endif
  83         bool inserted;
  84
  85 public:
  86         SLOT_CART(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
  87         {
  88 #ifdef USE_MEGAROM
  89         event_register_id = -1;
  90 #endif
  91                 set_device_name(_T("ROM Cartridge"));
  92         }
  93         ~SLOT_CART() {}
  94
  95         // common functions
  96         void initialize();
  97         void write_data8(uint32_t addr, uint32_t data);
  98         uint32_t read_data8(uint32_t addr);
  99         bool process_state(FILEIO* state_fio, bool loading);
 100 #ifdef USE_MEGAROM
 101         void event_callback(int event_id, int err);
 102         int event_register_id;
 103 #endif
 104
 105         // unique functions
 106         void open_cart(const _TCHAR *file_path);
 107         void close_cart();
 108         bool is_cart_inserted()
 109         {
 110                 return inserted;
 111         }
 112 #ifdef USE_MEGAROM
 113         void set_context_sound(SOUND_CART *device)
 114         {
 115                 d_sound = device;
 116         }
 117 #endif
 118         bool load_cart(const _TCHAR *file_path/*, uint8_t *rom*/);
 119 };
 120
 121 // MSXDOS2
 122
 123 #if defined(MSXDOS2_SLOT)
 124 class SLOT_MSXDOS2 : public DEVICE
 125 {
 126 private:
 127         uint8_t wdmy[0x2000];
 128         uint8_t rdmy[0x2000];
 129         uint8_t* wbank[8];
 130         uint8_t* rbank[8];
 131         uint8_t rom[0x10000];
 132         uint8_t mapper[2];
 133
 134 public:
 135         SLOT_MSXDOS2(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 136         {
 137                 set_device_name(_T("MSX-DOS2"));
 138         }
 139         ~SLOT_MSXDOS2() {}
 140
 141         // common functions
 142         void initialize();
 143         void write_data8(uint32_t addr, uint32_t data);
 144         uint32_t read_data8(uint32_t addr);
 145         bool process_state(FILEIO* state_fio, bool loading);
 146 };
 147 #endif
 148
 149 // LD Control
 150
 151 #if defined(LDC_SLOT)
 152 class SLOT_LDC : public DEVICE
 153 {
 154 private:
 155         DEVICE *d_cpu, *d_ldp, *d_vdp;
 156
 157         uint8_t wdmy[0x2000];
 158         uint8_t rdmy[0x2000];
 159         uint8_t* wbank[8];
 160         uint8_t* rbank[8];
 161         uint8_t rom[0x2000];
 162
 163         bool clock;
 164         bool exv, ack;
 165         bool super_impose;
 166         bool req_intr;
 167         bool pc4, mute_l, mute_r;
 168
 169 public:
 170         SLOT_LDC(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 171         {
 172                 set_device_name(_T("LDC Control"));
 173         }
 174         ~SLOT_LDC() {}
 175
 176         // common functions
 177         void initialize();
 178         void reset();
 179         void write_data8(uint32_t addr, uint32_t data);
 180         uint32_t read_data8(uint32_t addr);
 181         void write_signal(int id, uint32_t data, uint32_t mask);
 182         void event_callback(int event_id, int err);
 183         bool process_state(FILEIO* state_fio, bool loading);
 184
 185         // unique functions
 186         void set_context_cpu(DEVICE* device)
 187         {
 188                 d_cpu = device;
 189         }
 190         void set_context_ldp(DEVICE* device)
 191         {
 192                 d_ldp = device;
 193         }
 194         void set_context_vdp(DEVICE* device)
 195         {
 196                 d_vdp = device;
 197         }
 198 };
 199 #endif
 200
 201 // SUBROM
 202
 203 #if defined(SUBROM_SLOT)
 204 class SLOT_SUBROM : public DEVICE
 205 {
 206 private:
 207         uint8_t wdmy[0x2000];
 208         uint8_t rdmy[0x2000];
 209         uint8_t* wbank[8];
 210         uint8_t* rbank[8];
 211 #if defined(_MSX2_VARIANTS)
 212         uint8_t rom[0x4000];
 213 #else
 214         uint8_t rom[0xc000];
 215 #endif
 216
 217 public:
 218         SLOT_SUBROM(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 219         {
 220                 set_device_name(_T("Sub ROM"));
 221         }
 222         ~SLOT_SUBROM() {}
 223
 224         // common functions
 225         void initialize();
 226         void write_data8(uint32_t addr, uint32_t data);
 227         uint32_t read_data8(uint32_t addr);
 228 };
 229 #endif
 230
 231 // FDD with ROM-PATCH
 232
 233 #if defined(FDD_PATCH_SLOT)
 234 class SLOT_FDD_PATCH : public DEVICE
 235 {
 236 private:
 237         uint8_t wdmy[0x2000];
 238         uint8_t rdmy[0x2000];
 239         uint8_t* wbank[8];
 240         uint8_t* rbank[8];
 241         uint8_t rom[0x4000];
 242
 243 public:
 244         SLOT_FDD_PATCH(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 245         {
 246                 set_device_name(_T("FDD I/F"));
 247         }
 248         ~SLOT_FDD_PATCH() {}
 249
 250         // common functions
 251         void initialize();
 252         void write_data8(uint32_t addr, uint32_t data);
 253         uint32_t read_data8(uint32_t addr);
 254 };
 255 #endif
 256
 257 // MAPPER RAM
 258
 259 #if defined(MAPPERRAM_SLOT)
 260 class SLOT_MAPPERRAM : public DEVICE
 261 {
 262 private:
 263         uint8_t wdmy[0x2000];
 264         uint8_t rdmy[0x2000];
 265         uint8_t* wbank[8];
 266         uint8_t* rbank[8];
 267         uint8_t ram[MAPPERRAM_SIZE];
 268         uint8_t mapper[4];
 269
 270 public:
 271         SLOT_MAPPERRAM(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 272         {
 273                 set_device_name(_T("Mapper RAM"));
 274         }
 275         ~SLOT_MAPPERRAM() {}
 276
 277         // common functions
 278         void initialize();
 279         void write_data8(uint32_t addr, uint32_t data);
 280         uint32_t read_data8(uint32_t addr);
 281         void write_io8(uint32_t addr, uint32_t data);
 282         bool process_state(FILEIO* state_fio, bool loading);
 283 };
 284 #endif
 285
 286 // NORMAL RAM 64K
 287
 288 #if defined(RAM64K_SLOT)
 289 class SLOT_RAM64K : public DEVICE
 290 {
 291 private:
 292         uint8_t ram[0x10000];
 293
 294 public:
 295         SLOT_RAM64K(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 296         {
 297                 set_device_name(_T("RAM 64KB"));
 298         }
 299         ~SLOT_RAM64K() {}
 300
 301         // common functions
 302         void initialize();
 303         void write_data8(uint32_t addr, uint32_t data);
 304         uint32_t read_data8(uint32_t addr);
 305         bool process_state(FILEIO* state_fio, bool loading);
 306 };
 307 #endif
 308
 309 // FIRMWARE 32K
 310
 311 #if defined(FIRMWARE32K1_SLOT)
 312 class SLOT_FIRMWARE32K : public DEVICE
 313 {
 314 private:
 315         uint8_t wdmy[0x2000];
 316         uint8_t rdmy[0x2000];
 317         uint8_t* wbank[8];
 318         uint8_t* rbank[8];
 319         uint8_t rom[0x8000];
 320         const _TCHAR* m_filename;
 321
 322 public:
 323         SLOT_FIRMWARE32K(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 324         {
 325                 set_device_name(_T("Firmware 32KB"));
 326         }
 327         ~SLOT_FIRMWARE32K() {}
 328
 329         // common functions
 330         void initialize();
 331         void write_data8(uint32_t addr, uint32_t data);
 332         uint32_t read_data8(uint32_t addr);
 333
 334         // unique function
 335         void set_context_filename(const _TCHAR* filename)
 336         {
 337                 m_filename = filename;
 338         }
 339 };
 340 #endif
 341
 342 // MSX-MUSIC
 343
 344 #if defined(MSXMUSIC_SLOT)
 345 class SLOT_MSXMUSIC : public DEVICE
 346 {
 347 private:
 348         uint8_t wdmy[0x2000];
 349         uint8_t rdmy[0x2000];
 350         uint8_t* wbank[8];
 351         uint8_t* rbank[8];
 352         uint8_t rom[0x4000];
 353
 354 public:
 355         SLOT_MSXMUSIC(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 356         {
 357                 set_device_name(_T("MSX-MUSIC"));
 358         }
 359         ~SLOT_MSXMUSIC() {}
 360
 361         // common functions
 362         void initialize();
 363         void write_data8(uint32_t addr, uint32_t data);
 364         uint32_t read_data8(uint32_t addr);
 365 };
 366 #endif
 367
 368 // memory bus
 369
 370 class MEMORY_EX : public DEVICE
 371 {
 372 private:
 373         DEVICE *d_slot[4*4];
 374         DEVICE *d_map[4];
 375 #if defined(FDD_PATCH_SLOT)
 376         DISK* disk[MAX_DRIVE];
 377         DEVICE *d_fdpat;
 378         bool access[MAX_DRIVE];
 379 #endif
 380 #if defined(FDD_PATCH_SLOT) && defined(_MSX_VDP_MESS)
 381         DEVICE *d_vdp;
 382 #endif
 383 #if defined(MAPPERRAM_SLOT)
 384         DEVICE *d_mapper;
 385 #endif
 386         bool expanded[4];
 387         uint8_t psl;
 388         uint8_t ssl[4];
 389         //uint32_t slot_select;
 390         void update_map(uint32_t val);
 391
 392 public:
 393         MEMORY_EX(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 394         {
 395                 ssl[0] = ssl[1] = ssl[2] = ssl[3] = 0;
 396                 expanded[0] = expanded[1] = expanded[2] = expanded[3] = false;
 397                 set_device_name(_T("Memory Bus (ex)"));
 398         }
 399         ~MEMORY_EX() {}
 400
 401         // common functions
 402 #if defined(FDD_PATCH_SLOT)
 403         void initialize();
 404         void release();
 405 #endif
 406         void reset();
 407         void write_data8(uint32_t addr, uint32_t data);
 408         uint32_t read_data8(uint32_t addr);
 409         uint32_t fetch_op(uint32_t addr, int* wait);
 410         void write_io8(uint32_t addr, uint32_t data);
 411         void write_signal(int id, uint32_t data, uint32_t mask);
 412 #if defined(FDD_PATCH_SLOT)
 413         uint32_t read_signal(int id);
 414         bool bios_ret_z80(uint16_t PC, pair_t* af, pair_t* bc, pair_t* de, pair_t* hl, pair_t* ix, pair_t* iy, uint8_t* iff1);
 415 #endif
 416         bool process_state(FILEIO* state_fio, bool loading);
 417
 418         // unique functions
 419         void set_context_slot_dummy(DEVICE *device)
 420         {
 421                 int i;
 422                 for(i=0; i<16; i++) d_slot[i] = device;
 423         }
 424         void set_context_slot(int drv, DEVICE *device)
 425         {
 426                 d_slot[drv & 0x0f] = device;
 427                 if (drv & 0x80) expanded[drv & 0x03] = true;
 428         }
 429 #if defined(FDD_PATCH_SLOT)
 430         void set_context_fdd_patch(DEVICE *device)
 431         {
 432                 d_fdpat = device;
 433         }
 434         void open_disk(int drv, const _TCHAR* file_path, int bank);
 435         void close_disk(int drv);
 436         bool is_disk_inserted(int drv);
 437         void is_disk_protected(int drv, bool value);
 438         bool is_disk_protected(int drv);
 439 #endif
 440 #if defined(MAPPERRAM_SLOT)
 441         void set_context_mapper(DEVICE *device)
 442         {
 443                 d_mapper = device;
 444         }
 445 #endif
 446 #if defined(FDD_PATCH_SLOT) && defined(_MSX_VDP_MESS)
 447         void set_context_vdp(DEVICE *device)
 448         {
 449                 d_vdp = device;
 450         }
 451 #endif
 452 };
 453
 454 #endif
 455