vdp.cpp

   1 // DGen v1.13+
   2 // Megadrive's VDP C++ module
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include "md.h"
   8
   9 int md_vdp::get_screen_info(struct dgen_sinfo *si)
  10 {
  11   // Release the pointers to vdp Data to an external function
  12   si->vram=vram; si->cram=cram; si->vsram=vsram;
  13   si->vdp_reg=reg;
  14   // NB - if you change anything, remember to set 'dirt' accordingly
  15   return 0;
  16 }
  17
  18 int md_vdp::reset()
  19 {
  20   if (!ok) return 1;
  21
  22   rw_mode=0x00; rw_addr=0; rw_dma=0;
  23   memset(mem,0,0x10100);
  24   memset(reg,0,0x20);
  25   memset(dirt,0xff,0x35); // mark everything as changed
  26   return 0;
  27 }
  28
  29 md_vdp::md_vdp()
  30 {
  31   ok=0;
  32   belongs=0; // Don't know which megadrive vdp belongs to yet
  33
  34   mem=vram=cram=vsram=NULL;
  35   mem=new unsigned char[0x10100+0x35]; //0x20+0x10+0x4+1 for dirt
  36   if (mem==0) return;
  37   vram=mem+0x00000; cram=mem+0x10000; vsram=mem+0x10080;
  38   dirt=mem+0x10100; // VRAM/CRAM/Reg dirty buffer bitfield
  39   // Also in 0x34 are global dirt flags (inclduing VSRAM this time)
  40
  41   highpal=new unsigned int[64]; if (highpal==0) return;
  42
  43   Bpp = Bpp_times8 = 0;
  44
  45   ok=1;
  46   reset();
  47
  48 }
  49
  50 md_vdp::~md_vdp()
  51 {
  52   free(mem);
  53   mem=vram=cram=vsram=NULL;
  54   ok=0;
  55 }
  56
  57 int md_vdp::dma_len()
  58 { return (reg[0x14]<<8)+reg[0x13]; }
  59
  60 int md_vdp::dma_addr()
  61 {
  62   int addr=0;
  63   addr=(reg[0x17]&0x7f)<<17;
  64   addr+=reg[0x16]<<9;
  65   addr+=reg[0x15]<<1;
  66   return addr;
  67 }
  68
  69
  70 // DMA can read from anywhere
  71 unsigned char md_vdp::dma_mem_read(int addr)
  72 {
  73   return belongs->misc_readbyte(addr);
  74 }
  75
  76 // Must go through these calls to update the dirty flags
  77 int md_vdp::poke_vram(int addr,unsigned char d)
  78 {
  79 // Keeping GCC happy over unused vars. [PKH]
  80 //  int diff=0;
  81   addr&=0xffff;
  82   if (vram[addr]!=d)
  83   {
  84     // Store dirty information down to 256 byte level in bits
  85     int byt,bit;
  86     byt=addr>>8; bit=byt&7; byt>>=3; byt&=0x1f;
  87     dirt[0x00+byt]|=(1<<bit); dirt[0x34]|=1;
  88     vram[addr]=d;
  89   }
  90   return 0;
  91 }
  92 int md_vdp::poke_cram(int addr,unsigned char d)
  93 {
  94 //  int diff=0;
  95   addr&=0x007f;
  96   if (cram[addr]!=d)
  97   {
  98     // Store dirty information down to 1byte level in bits
  99     int byt,bit;
 100     byt=addr; bit=byt&7; byt>>=3; byt&=0x0f;
 101     dirt[0x20+byt]|=(1<<bit); dirt[0x34]|=2;
 102     cram[addr]=d;
 103   }
 104
 105   return 0;
 106 }
 107 int md_vdp::poke_vsram(int addr,unsigned char d)
 108 {
 109 //  int diff=0;
 110   addr&=0x007f;
 111   if (vsram[addr]!=d)
 112   { dirt[0x34]|=4; vsram[addr]=d; }
 113   return 0;
 114 }
 115
 116 int md_vdp::putword(unsigned short d)
 117 {
 118 //  int diff=0;
 119   // Called by dma or a straight write
 120   switch(rw_mode)
 121   {
 122     case 0x04: poke_vram (rw_addr+0,d>>8); poke_vram (rw_addr+1,d&0xff); break;
 123     case 0x0c: poke_cram (rw_addr+0,d>>8); poke_cram (rw_addr+1,d&0xff); break;
 124     case 0x14: poke_vsram(rw_addr+0,d>>8); poke_vsram(rw_addr+1,d&0xff); break;
 125   }
 126   rw_addr+=reg[15];
 127   return 0;
 128 }
 129
 130 int md_vdp::putbyte(unsigned char d)
 131 {
 132 //  int diff=0;
 133   // Called by dma or a straight write
 134   switch(rw_mode)
 135   {
 136     case 0x04: poke_vram (rw_addr,d>>8); break;
 137     case 0x0c: poke_cram (rw_addr,d>>8); break;
 138     case 0x14: poke_vsram(rw_addr,d>>8); break;
 139   }
 140   rw_addr+=reg[15];
 141   return 0;
 142 }
 143
 144 #undef MAYCHANGE
 145
 146 unsigned short md_vdp::readword()
 147 {
 148   // Called by a straight read only
 149   unsigned short result=0x0000;
 150   switch(rw_mode)
 151   {
 152     case 0x00: result=( vram[(rw_addr+0)&0xffff]<<8)+
 153                         vram[(rw_addr+1)&0xffff]; break;
 154     case 0x20: result=( cram[(rw_addr+0)&0x007f]<<8)+
 155                         cram[(rw_addr+1)&0x007f]; break;
 156     case 0x10: result=(vsram[(rw_addr+0)&0x007f]<<8)+
 157                        vsram[(rw_addr+1)&0x007f]; break;
 158   }
 159   rw_addr+=reg[15];
 160   return result;
 161 }
 162
 163 unsigned char md_vdp::readbyte()
 164 {
 165   // Called by a straight read only
 166   unsigned char result=0x00;
 167   switch(rw_mode)
 168   {
 169     case 0x00: result= vram[(rw_addr+0)&0xffff]; break;
 170     case 0x20: result= cram[(rw_addr+0)&0x007f]; break;
 171     case 0x10: result=vsram[(rw_addr+0)&0x007f]; break;
 172   }
 173   rw_addr+=reg[15];
 174   return result;
 175 }
 176
 177
 178 int md_vdp::command(unsigned int cmd)
 179 {
 180 // Decode 32-bit VDP command
 181   rw_dma=((cmd&0x80)==0x80);
 182   rw_mode= cmd&0x00000070;
 183   rw_mode|=(cmd&0xc0000000)>>28;
 184 // mode writes: 04=VRAM 0C=CRAM 14=VSRAM
 185 // mode reads:  00=VRAM 20=CRAM 10=VSRAM
 186   rw_addr= (cmd&0x00000003)<<14;
 187   rw_addr|=(cmd&0x3fff0000)>>16;
 188   // If not dma (or we need a fill),
 189   // we are set up to write any data sent to vdp data reg
 190
 191   // if it's a dma request do it straight away
 192   if (rw_dma)
 193   {
 194     int mode=(reg[0x17]>>6)&3;
 195     int s=0,d=0,i=0,len=0;
 196     s=dma_addr(); d=rw_addr; len=dma_len();
 197     switch (mode)
 198     {
 199       case 0: case 1:
 200         for (i=0;i<len;i++)
 201         {
 202           unsigned short val;
 203           val= dma_mem_read(s++); val<<=8;
 204           val|=dma_mem_read(s++); putword(val);
 205         }
 206       break;
 207       case 2:
 208         // Done later on
 209       break;
 210       case 3:
 211         for (i=0;i<len;i++)
 212         {
 213           unsigned short val;
 214           val= vram[(s++)&0xffff]; val<<=8;
 215           val|=vram[(s++)&0xffff]; putword(val);
 216         }
 217       break;
 218     }
 219   }
 220
 221   return 0;
 222 }
 223
 224 int md_vdp::writeword(unsigned short d)
 225 {
 226   if (rw_dma)
 227   {
 228     // This is the 'done later on' bit for words
 229     // Do a dma fill if it's set up:
 230     if (((reg[0x17]>>6)&3)==2)
 231     {
 232       int i,len;
 233       len=dma_len();
 234       for (i=0;i<len;i++)
 235         putword(d);
 236       return 0;
 237     }
 238   }
 239   else
 240   {
 241     putword(d);
 242     return 0;
 243   }
 244   return 0;
 245 }
 246
 247 int md_vdp::writebyte(unsigned char d)
 248 {
 249   if (rw_dma)
 250   {
 251     // This is the 'done later on' bit for bytes
 252     // Do a dma fill if it's set up:
 253     if (((reg[0x17]>>6)&3)==2)
 254     {
 255       int i,len;
 256       len=dma_len();
 257       for (i=0;i<len;i++)
 258         putbyte(d);
 259       return 0;
 260     }
 261   }
 262   else
 263   {
 264     putbyte(d);
 265     return 0;
 266   }
 267
 268   return 0;
 269 }
 270