source/src/vm/fmtowns/vram.h

   1 /*
   2         Skelton for retropc emulator
   3
   4         Author : Kyuma Ohta <whatisthis.sowhat _at_ gmail.com>
   5         Date   : 2016.12.28 -
   6
   7         [ FM-Towns VRAM ]
   8         History: 2016.12.28 Initial.
   9 */
  10
  11 #ifndef _TOWNS_VRAM_H_
  12 #define _TOWNS_VRAM_H_
  13
  14 #include "device.h"
  15 #include "../../common.h"
  16 #include "towns_common.h"
  17
  18 #if defined(_USE_QT)
  19 #include <QMutex>
  20 #endif
  21
  22 // Older Towns.
  23 #define TOWNS_VRAM_ADDR_MASK 0x7ffff
  24 // VRAM DIRECT ACCESS: For Sprite. You should access with 16bit
  25 // You can write raw data, drawing with colorkey is automatically.
  26 #define SIG_TOWNS_TRANSFER_SPRITE_DATA   0x100000
  27 #define SIG_TOWNS_SET_SPRITE_BANK        0x140000
  28 #define SIG_TOWNS_CLEAR_SPRITE_BUFFER    0x140001
  29 // Do render with any mode. You should set vline to arg.
  30 #define SIG_TOWNS_RENDER_RASTER          0x01
  31 #define SIG_TOWNS_RENDER_FULL            0x02
  32 #define SIG_TOWNS_VRAM_VSTART            0x03
  33 #define SIG_TOWNS_VRAM_VBLANK            0x04
  34 #define SIG_TOWNS_VRAM_VSYNC             0x05
  35 #define SIG_TOWNS_VRAM_HSYNC             0x06
  36 #define SIG_TOWNS_VRAM_SET_VLINE         0x07
  37 #define SIG_TOWNS_RENDER_FLAG            0x08
  38 #define SIG_TOWNS_VRAM_FRAMEBUFFER_READY 0x10
  39 #define SIG_TOWNS_VRAM_SWAP_FRAMEBUFFER  0x11
  40
  41 namespace FMTOWNS {
  42 class TOWNS_VRAM : public DEVICE
  43 {
  44 protected:
  45         DEVICE* d_sprite;
  46         DEVICE* d_crtc;
  47
  48 #if defined(_USE_QT)
  49         // If you use other framework, place mutex lock.
  50         QMutex vram_lock[2][2]; // [bank][layer];
  51 #endif
  52
  53         bool access_page1;
  54
  55         bool dirty_flag[0x80000 >> 3]; // Per 8bytes : 16pixels(16colors) / 8pixels(256) / 4pixels(32768)
  56
  57         // FMR50 Compatible registers. They are mostly dummy.
  58         // Digital paletts. I/O FD98H - FD9FH.
  59         bool layer_display_flags[2]; // I/O FDA0H (WO) : bit3-2 (Layer1) or bit1-0 (Layer0).Not 0 is true.
  60
  61
  62         bool sprite_busy;            // I/O 044CH (RO) : bit1. Must update from write_signal().
  63         bool sprite_disp_page;       // I/O 044CH (RO) : bit0. Must update from write_signal().
  64         // Accessing VRAM. Will be separated.
  65         // Memory description:
  66         // All of accessing must be little endian.
  67         // 000C:00000 - 000C:07fff : Plane accessing window(->FM-R50 features?). Access to Layer #0 (8000:00000).
  68         // 000C:08000 - 000C:0ffff : I/O CVRAM
  69         // 000D:00000 - 000E:0ffff : Reserved (Window for KANJI, DIC etc).
  70         // 8000:00000 - 8000:3ffff : Plane accessing Layer #0.
  71         // 8000:40000 - 8000:7ffff : Plane accessing Layer #1.
  72         // 8010:00000 - 8010:7ffff : Plane accessing with one layer.
  73         // 8100:00000 - 8100:1ffff : Sprite (and text vram).
  74         // I/O 0458H (RW) : VRAM ACCESS CONTROLLER reg address.
  75         // I/O 045AH (RW) : VRAM ACCESS CONTROLLER reg data (LOW).
  76         // I/O 045BH (RW) : VRAM ACCESS CONTROLLER reg data (HIGH).
  77         uint8_t vram_access_reg_addr;
  78         pair32_t packed_pixel_mask_reg; // '1' = Write. I/O 0458H - 045BH.
  79         uint8_t vram[0x80000]; // Related by machine.
  80         // End.
  81
  82         // Flags related by host renderer. Not saved.
  83         bool has_hardware_rendering;
  84         bool has_hardware_blending;
  85         // End.
  86
  87         uint8_t cpu_id;
  88         uint16_t machine_id;
  89 public:
  90         TOWNS_VRAM(VM_TEMPLATE* parent_vm, EMU_TEMPLATE* parent_emu) : DEVICE(parent_vm, parent_emu)
  91         {
  92                 memset(vram, 0x00, sizeof(vram));
  93                 d_sprite = NULL;
  94                 d_crtc = NULL;
  95                 cpu_id = 0x01; // for 05EEh
  96                 machine_id = 0x0100;
  97                 set_device_name(_T("FM-Towns VRAM"));
  98         }
  99         ~TOWNS_VRAM() {}
 100
 101         virtual void initialize();
 102         virtual void reset();
 103
 104         virtual uint32_t __FASTCALL read_memory_mapped_io8(uint32_t addr);
 105         virtual uint32_t __FASTCALL read_memory_mapped_io16(uint32_t addr);
 106         virtual uint32_t __FASTCALL read_memory_mapped_io32(uint32_t addr);
 107         virtual void __FASTCALL write_memory_mapped_io8(uint32_t addr, uint32_t data);
 108         virtual void __FASTCALL write_memory_mapped_io16(uint32_t addr, uint32_t data);
 109         virtual void __FASTCALL write_memory_mapped_io32(uint32_t addr, uint32_t data);
 110
 111         virtual void __FASTCALL write_io8(uint32_t address, uint32_t data);
 112         virtual void __FASTCALL write_io16(uint32_t address, uint32_t data);
 113
 114         virtual uint32_t __FASTCALL read_io8(uint32_t address);
 115         virtual uint32_t __FASTCALL read_io16(uint32_t address);
 116
 117         void __FASTCALL write_signal(int id, uint32_t data, uint32_t mask); // Do render
 118         virtual bool process_state(FILEIO* state_fio, bool loading);
 119
 120         // Unique Functions
 121         virtual uint8_t* __FASTCALL get_vram_address(uint32_t offset)
 122         {
 123                 if(offset >= 0x80000) return NULL; // ToDo
 124                 return &(vram[offset]);
 125         }
 126         virtual bool __FASTCALL set_buffer_to_vram(uint32_t offset, uint8_t *buf, int words)
 127         {
 128                 offset &= 0x7ffff;
 129 //              if(words > 16) return false;
 130                 if(words <= 0) return false;
 131                 uint8_t* p = &(vram[offset]);
 132                 if((offset + (words << 1)) <= 0x80000) {
 133                         memcpy(p, buf, words << 1);
 134                 } else {
 135                         int nb = 0x80000 - offset;
 136                         memcpy(p, buf, nb);
 137                         int nnb = (words << 1) - nb;
 138                         if(nnb > 0) {
 139                                 memcpy(vram, &(buf[nb]), nnb);
 140                         }
 141                 }
 142                 return true;
 143         }
 144         virtual bool __FASTCALL get_vram_to_buffer(uint32_t offset, uint8_t *buf, int words)
 145         {
 146                 offset &= 0x7ffff;
 147 //              if(words > 16) return false;
 148                 if(words <= 0) return false;
 149                 uint8_t* p = &(vram[offset]);
 150                 if((offset + (words << 1)) <= 0x80000) {
 151                         memcpy(buf, p, words << 1);
 152                 } else {
 153                         uint32_t nb = 0x80000 - offset;
 154                         memcpy(buf, p, nb);
 155                         int nnb = (words << 1) - nb;
 156                         if(nnb > 0) {
 157                                 memcpy(&(buf[nb]), vram, nnb);
 158                         }
 159                 }
 160                 return true;
 161         }
 162         virtual void __FASTCALL make_dirty_vram(uint32_t addr, int bytes);
 163         virtual uint32_t __FASTCALL get_vram_size()
 164         {
 165                 return 0x80000; // ToDo
 166         }
 167         virtual void __FASTCALL lock_framebuffer(int layer, int bank)
 168         {
 169 #if defined(_USE_QT)
 170                 vram_lock[bank][layer].lock();
 171 #endif
 172         }
 173         virtual void __FASTCALL unlock_framebuffer(int layer, int bank)
 174         {
 175 #if defined(_USE_QT)
 176                 vram_lock[bank][layer].unlock();
 177 #endif
 178         }
 179         void set_context_sprite(DEVICE *dev)
 180         {
 181                 d_sprite = dev;
 182         }
 183         void set_context_crtc(DEVICE *dev)
 184         {
 185                 d_crtc = dev;
 186         }
 187         void set_cpu_id(uint16_t val)
 188         {
 189                 cpu_id = val & 0x07;
 190         }
 191         void set_machine_id(uint16_t val)
 192         {
 193                 machine_id = val & 0xfff8;
 194         }
 195         // New APIs?
 196         // End.
 197 };
 198
 199 }
 200 #endif