source/src/vm/fmtowns/towns_memory.h

   1 /*
   2         FUJITSU FM Towns Emulator 'eFMTowns'
   3
   4         Author : Kyuma.Ohta <whatisthis.sowhat _at_ gmail.com>
   5         Date   : 2017.01.07 -
   6
   7         [ memory ]
   8 */
   9
  10 #ifndef _TOWNS_MEMORY_H_
  11 #define _TOWNS_MEMORY_H_
  12
  13 #include "device.h"
  14 #include "../../common.h"
  15 #include "../memory.h"
  16 #include "./towns_common.h"
  17
  18 #define SIG_FMTOWNS_MACHINE_ID  1
  19 #define SIG_MEMORY_EXTNMI       2
  20
  21 // MAP:
  22 // 00000000 - 000fffff : SYSTEM RAM PAGE 0 (Similar to FMR-50).
  23 // 00100000 - 3fffffff : EXTRA RAM (for i386 native mode.Page size is 1MB.)
  24 // 40000000 - 7fffffff : External I/O BOX.Not accessible.
  25 // 80000000 - bfffffff : VRAM (Reserved 01020000H bytes with earlier Towns.)
  26 // c0000000 - c21fffff : ROM card and dictionaly/font/DOS ROMs.
  27 // c2200000 - c2200fff : PCM RAM (Banked).
  28 // c2201000 - fffbffff : Reserved.
  29 // FFFC0000 - FFFFFFFF : Towns System ROM.
  30
  31 namespace FMTOWNS {
  32 enum {
  33         TOWNS_MEMORY_NORMAL = 0,
  34         TOWNS_MEMORY_FMR_VRAM,
  35         TOWNS_MEMORY_FMR_TEXT,
  36         TOWNS_MEMORY_FMR_VRAM_RESERVE,
  37         TOWNS_MEMORY_SPRITE_ANKCG1,
  38         TOWNS_MEMORY_ANKCG2,
  39
  40         TOWNS_MEMORY_MMIO_0CC,
  41
  42         TOWNS_MEMORY_TYPE_EXT_MMIO,
  43         TOWNS_MEMORY_TYPE_LEARN_RAM,
  44         TOWNS_MEMORY_TYPE_WAVERAM,
  45 };
  46 }
  47 // Please set from config
  48 #define TOWNS_EXTRAM_PAGES 6
  49
  50 class BEEP;
  51 class I386;
  52
  53 namespace FMTOWNS {
  54         class TOWNS_VRAM;
  55         class TOWNS_SPRITE;
  56         class TOWNS_ROM_CARD;
  57 }
  58
  59 namespace FMTOWNS {
  60 class TOWNS_MEMORY : public MEMORY
  61 {
  62 protected:
  63         DEVICE* d_vram;
  64         DEVICE* d_sprite;       // 0x81000000 - 0x8101ffff ?
  65         DEVICE* d_romcard[2]; // 0xc0000000 - 0xc0ffffff / 0xc1000000 - 0xc1ffffff
  66         DEVICE* d_pcm;             // 0xc2200000 - 0xc2200fff
  67         DEVICE* d_timer;
  68         DEVICE* d_dmac;
  69         DEVICE* d_crtc;
  70         DEVICE* d_planevram;
  71         I386*   d_cpu;
  72
  73         DEVICE* d_dictionary;
  74         DEVICE* d_sysrom;
  75         DEVICE* d_msdos;
  76         DEVICE* d_serialrom;
  77         DEVICE* d_font;
  78         DEVICE* d_font_20pix;
  79
  80         DEVICE* d_iccard[2];
  81
  82         outputs_t outputs_ram_wait;
  83         outputs_t outputs_rom_wait;
  84
  85         bool bankc0_vram;
  86         bool ankcg_enabled;
  87         bool select_d0_rom;
  88         bool select_d0_dict;
  89
  90         uint16_t machine_id;
  91         uint8_t cpu_id;
  92         bool is_compatible;
  93         bool dma_is_vram;
  94
  95         // RAM
  96         uint8_t ram_page0[0xc0000];       // 0x00000000 - 0x000bffff : RAM
  97         uint8_t ram_pagec[0x10000];       // 0x000c0000 - 0x000cffff : URA? RAM
  98         uint8_t ram_paged[0x20000];       // 0x000d0000 - 0x000effff : RAM
  99         uint8_t ram_pagef[0x10000];       // 0x000f0000 - 0x000fffff : RAM
 100
 101         uint8_t *extra_ram;                  // 0x00100000 - (0x3fffffff) : Size is defined by extram_size;
 102         uint32_t extram_size;
 103         uint32_t cpu_clock_val;
 104         uint32_t vram_wait_val;
 105         uint32_t mem_wait_val;
 106
 107         uint8_t wait_register;
 108
 109         bool extra_nmi_mask;
 110         bool extra_nmi_val;
 111         bool nmi_mask;
 112         bool software_reset;
 113         bool nmi_vector_protect;
 114         bool poff_status;
 115         bool reset_happened;
 116
 117         // misc
 118         uint32_t vram_size; // Normally 512KB.
 119         bool initialized;
 120
 121         // MISC1-MISC4
 122         uint8_t reg_misc3; // 0024
 123         uint8_t reg_misc4; // 0025
 124         virtual void set_wait_values();
 125         virtual void config_page_c0();
 126         virtual void config_page_d0_e0();
 127         virtual void config_page_f8_rom();
 128         virtual void config_page00();
 129         virtual void update_machine_features();
 130
 131         virtual void     __FASTCALL write_fmr_ports8(uint32_t addr, uint32_t data);
 132         virtual uint8_t  __FASTCALL read_fmr_ports8(uint32_t addr);
 133         virtual void     __FASTCALL write_sys_ports8(uint32_t addr, uint32_t data);
 134         virtual uint8_t __FASTCALL read_sys_ports8(uint32_t addr);
 135
 136 public:
 137         TOWNS_MEMORY(VM_TEMPLATE* parent_vm, EMU_TEMPLATE* parent_emu) : MEMORY(parent_vm, parent_emu) {
 138                 set_device_name(_T("FMTOWNS_MEMORY"));
 139
 140                 extram_size = 0x00200000; // Basically 2MB
 141
 142                 d_cpu = NULL;
 143
 144                 d_vram = NULL;
 145                 d_sprite = NULL;
 146                 d_romcard[0] = d_romcard[1] = NULL;
 147                 d_pcm = NULL;
 148                 d_timer = NULL;
 149                 d_dmac = NULL;
 150                 d_crtc = NULL;
 151                 d_planevram = NULL;
 152                 d_iccard[0] = NULL;
 153                 d_iccard[1] = NULL;
 154
 155                 d_dictionary = NULL;
 156                 d_sysrom = NULL;
 157                 d_msdos = NULL;
 158                 d_serialrom = NULL;
 159                 d_font = NULL;
 160                 d_font_20pix = NULL;
 161                 initialized = false;
 162
 163                 initialize_output_signals(&outputs_ram_wait);
 164                 initialize_output_signals(&outputs_rom_wait);
 165                 // Note: machine id must set before initialize() from set_context_machine_id() by VM::VM().
 166                 // machine_id = 0x0100;   // FM-Towns 1,2
 167                 // machine_id = 0x0200 // FM-Towns  1F/2F/1H/2H
 168                 // machine_id = 0x0300 // FM-Towns  UX10/UX20/UX40
 169                 // machine_id = 0x0400 // FM-Towns  10F/20F/40H/80H
 170                 // machine_id = 0x0500 // FM-Towns2 CX10/CX20/CX40/CX100
 171                 // machine_id = 0x0600 // FM-Towns2 UG10/UG20/UG40/UG80
 172                 // machine_id = 0x0700 // FM-Towns2 HR20/HR100/HR200
 173                 // machine_id = 0x0800 // FM-Towns2 HG20/HG40/HG100
 174                 // machine_id = 0x0900 // FM-Towns2 UR20/UR40/UR80
 175                 // machine_id = 0x0b00 // FM-Towns2 MA20/MA170/MA340
 176                 // machine_id = 0x0c00 // FM-Towns2 MX20/MX170/MX340
 177                 // machine_id = 0x0d00 // FM-Towns2 ME20/ME170
 178                 // machine_id = 0x0f00 // FM-Towns2 MF20/MF170/Fresh
 179                 machine_id = 0x0100;   // FM-Towns 1,2
 180
 181                 // Note: cpu id must set before initialize() from set_context_cpu_id() by VM::VM().
 182                 // cpu_id = 0x00; // 80286.
 183                 // cpu_id = 0x01; // 80386DX.
 184                 // cpu_id = 0x02; // 80486SX/DX.
 185                 // cpu_id = 0x03; // 80386SX.
 186                 cpu_id = 0x01; // 80386DX.
 187                 extra_ram = NULL;
 188         }
 189         ~TOWNS_MEMORY() {}
 190
 191         // common functions
 192         void initialize();
 193         void release();
 194         void reset();
 195
 196         virtual void     __FASTCALL write_io8(uint32_t addr, uint32_t data);
 197         virtual void     __FASTCALL write_io8w(uint32_t addr, uint32_t data, int *wait);
 198
 199         virtual uint32_t __FASTCALL read_io8(uint32_t addr);
 200         virtual uint32_t __FASTCALL read_io8w(uint32_t addr, int *wait);
 201
 202         virtual void __FASTCALL write_memory_mapped_io8(uint32_t addr, uint32_t data);
 203         virtual uint32_t __FASTCALL read_memory_mapped_io8(uint32_t addr);
 204         virtual void __FASTCALL write_memory_mapped_io8w(uint32_t addr, uint32_t data, int *wait);
 205         virtual uint32_t __FASTCALL read_memory_mapped_io8w(uint32_t addr, int *wait);
 206         virtual void __FASTCALL write_memory_mapped_io16(uint32_t addr, uint32_t data);
 207         virtual uint32_t __FASTCALL read_memory_mapped_io16(uint32_t addr);
 208         virtual void __FASTCALL write_memory_mapped_io16w(uint32_t addr, uint32_t data, int *wait);
 209         virtual uint32_t __FASTCALL read_memory_mapped_io16w(uint32_t addr, int *wait);
 210
 211         virtual void __FASTCALL write_signal(int id, uint32_t data, uint32_t mask);
 212         virtual uint32_t __FASTCALL read_signal(int ch);
 213
 214         //void event_frame();
 215         virtual void __FASTCALL set_intr_line(bool line, bool pending, uint32_t bit);
 216
 217         bool process_state(FILEIO* state_fio, bool loading);
 218
 219         // unique functions
 220         void set_extra_ram_size(uint32_t megabytes)
 221         {
 222                 uint32_t limit = 5;
 223                 uint32_t minimum = 2;
 224                 switch(machine_id & 0xff00) {
 225                 case 0x0000: // ???
 226                 case 0x0100: // Towns Model 1/2
 227                         minimum = 1;
 228                         break;
 229                 case 0x0200: // TOWNS 2F/2H
 230                 case 0x0400: // TOWNS 10F/10H/20F/20H
 231                         limit = 8; // 2MB + 2MB x 3
 232                         break;
 233                 case 0x0300: // TOWNS2 UX
 234                 case 0x0600: // TOWNS2 UG
 235                         limit = 9; // 2MB + 4MB x 2? - 1MB
 236                         break;
 237                 case 0x0500: // TOWNS2 CX
 238                 case 0x0800: // TOWNS2 HG
 239                         limit = 15; // 8MB x 2 - 1MB?
 240                         break;
 241                 case 0x0700: // TOWNS2 HR
 242                 case 0x0900: // TOWNS2 UR
 243                 case 0x0B00: // TOWNS2 MA
 244                 case 0x0C00: // TOWNS2 MX
 245                 case 0x0D00: // TOWNS2 ME
 246                 case 0x0F00: // TOWNS2 MF/Fresh
 247                         limit = 31; // 16MB x 2 - 1MB?
 248                         break;
 249                 }
 250                 if(megabytes > limit) megabytes = limit;
 251                 if(megabytes < minimum) megabytes = minimum;
 252                 extram_size = megabytes << 20;
 253         }
 254         void set_context_cpu(I386* device)
 255         {
 256                 d_cpu = device;
 257         }
 258         void set_context_dmac(DEVICE* device)
 259         {
 260                 d_dmac = device;
 261         }
 262         void set_context_vram(DEVICE* device)
 263         {
 264                 d_vram = device;
 265         }
 266         void set_context_system_rom(DEVICE* device)
 267         {
 268                 d_sysrom = device;
 269         }
 270         void set_context_font_rom(DEVICE* device)
 271         {
 272                 d_font = device;
 273         }
 274         void set_context_font_20pix_rom(DEVICE* device)
 275         {
 276                 d_font_20pix = device;
 277         }
 278         void set_context_dictionary(DEVICE* device)
 279         {
 280                 d_dictionary = device;
 281         }
 282         void set_context_msdos(DEVICE* device)
 283         {
 284                 d_msdos = device;
 285         }
 286         void set_context_timer(DEVICE* device)
 287         {
 288                 d_timer = device;
 289         }
 290         void set_context_sprite(DEVICE* device)
 291         {
 292                 d_sprite = device;
 293         }
 294         void set_context_crtc(DEVICE* device)
 295         {
 296                 d_crtc = device;
 297         }
 298         void set_context_romcard(DEVICE* device, int num)
 299         {
 300                 d_romcard[num & 1] = device;
 301         }
 302         void set_context_pcm(DEVICE* device)
 303         {
 304                 d_pcm = device;
 305         }
 306         void set_context_serial_rom(DEVICE* device)
 307         {
 308                 d_serialrom = device;
 309         }
 310         void set_context_planevram(DEVICE *dev)
 311         {
 312                 d_planevram = dev;
 313         }
 314         void set_context_iccard(DEVICE* device, int num)
 315         {
 316                 if((num >= 0) && (num < 2)) {
 317                         d_iccard[num] = device;
 318                 }
 319         }
 320         void set_machine_id(uint16_t val)
 321         {
 322                 machine_id = val & 0xfff8;
 323         }
 324         void set_cpu_id(uint16_t val)
 325         {
 326                 cpu_id = val & 0x07;
 327         }
 328 };
 329
 330 }
 331 #endif