[BACK]Return to memory.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / i286c

Diff for /np2/i286c/memory.c between versions 1.1.1.1 and 1.4

version 1.1.1.1, 2003/10/16 17:57:47 version 1.4, 2003/11/28 08:01:32
Line 19  static void MEMCALL i286_wt(UINT32 addre Line 19  static void MEMCALL i286_wt(UINT32 addre
   
 static void MEMCALL tram_wt(UINT32 address, BYTE value) {  static void MEMCALL tram_wt(UINT32 address, BYTE value) {
   
         nevent.remainclock -= vramop.tramwait;          I286_REMCLOCK -= vramop.tramwait;
         if (address < 0xa2000) {          if (address < 0xa2000) {
                 mem[address] = value;                  mem[address] = value;
                 tramupdate[(address >> 1) & 0x0fff] = 1;                  tramupdate[LOW12(address >> 1)] = 1;
                 gdcs.textdisp |= 1;                  gdcs.textdisp |= 1;
         }          }
         else if (address < 0xa3fe0) {          else if (address < 0xa3fe0) {
                 if (!(address & 1)) {                  if (!(address & 1)) {
                         mem[address] = value;                          mem[address] = value;
                         tramupdate[(address >> 1) & 0x0fff] = 1;                          tramupdate[LOW12(address >> 1)] = 1;
                         gdcs.textdisp |= 1;                          gdcs.textdisp |= 1;
                 }                  }
         }          }
Line 36  static void MEMCALL tram_wt(UINT32 addre Line 36  static void MEMCALL tram_wt(UINT32 addre
                 if (!(address & 1)) {                  if (!(address & 1)) {
                         if ((!(address & 2)) || (gdcs.msw_accessable)) {                          if ((!(address & 2)) || (gdcs.msw_accessable)) {
                                 mem[address] = value;                                  mem[address] = value;
                                 tramupdate[(address >> 1) & 0x0fff] = 1;                                  tramupdate[LOW12(address >> 1)] = 1;
                                 gdcs.textdisp |= 1;                                  gdcs.textdisp |= 1;
                         }                          }
                 }                  }
Line 44  static void MEMCALL tram_wt(UINT32 addre Line 44  static void MEMCALL tram_wt(UINT32 addre
         else if (address < 0xa5000) {          else if (address < 0xa5000) {
                 if ((address & 1) && (cgwindow.writable & 1)) {                  if ((address & 1) && (cgwindow.writable & 1)) {
                         cgwindow.writable |= 0x80;                          cgwindow.writable |= 0x80;
                         font[cgwindow.high + ((address >> 1) & 0x0f)] = value;                          fontrom[cgwindow.high + ((address >> 1) & 0x0f)] = value;
                 }                  }
         }          }
 }  }
   
 static void MEMCALL vram_w0(UINT32 address, BYTE value) {  static void MEMCALL vram_w0(UINT32 address, BYTE value) {
   
         nevent.remainclock -= vramop.vramwait;          I286_REMCLOCK -= vramop.vramwait;
         mem[address] = value;          mem[address] = value;
         vramupdate[address & 0x7fff] |= 1;          vramupdate[LOW15(address)] |= 1;
         gdcs.grphdisp |= 1;          gdcs.grphdisp |= 1;
 }  }
   
 static void MEMCALL vram_w1(UINT32 address, BYTE value) {  static void MEMCALL vram_w1(UINT32 address, BYTE value) {
   
         nevent.remainclock -= vramop.vramwait;          I286_REMCLOCK -= vramop.vramwait;
         mem[address + VRAM_STEP] = value;          mem[address + VRAM_STEP] = value;
         vramupdate[address & 0x7fff] |= 2;          vramupdate[LOW15(address)] |= 2;
         gdcs.grphdisp |= 2;          gdcs.grphdisp |= 2;
 }  }
   
Line 70  static void MEMCALL grcg_rmw0(UINT32 add Line 70  static void MEMCALL grcg_rmw0(UINT32 add
         BYTE    mask;          BYTE    mask;
         BYTE    *vram;          BYTE    *vram;
   
         nevent.remainclock -= vramop.grcgwait;          I286_REMCLOCK -= vramop.grcgwait;
         mask = ~value;          mask = ~value;
         address &= 0x7fff;          address = LOW15(address);
         vramupdate[address] |= 1;          vramupdate[address] |= 1;
         gdcs.grphdisp |= 1;          gdcs.grphdisp |= 1;
         vram = mem + address;          vram = mem + address;
Line 99  static void MEMCALL grcg_rmw1(UINT32 add Line 99  static void MEMCALL grcg_rmw1(UINT32 add
         BYTE    mask;          BYTE    mask;
         BYTE    *vram;          BYTE    *vram;
   
         nevent.remainclock -= vramop.grcgwait;          I286_REMCLOCK -= vramop.grcgwait;
         mask = ~value;          mask = ~value;
         address &= 0x7fff;          address = LOW15(address);
         vramupdate[address] |= 2;          vramupdate[address] |= 2;
         gdcs.grphdisp |= 2;          gdcs.grphdisp |= 2;
         vram = mem + address;          vram = mem + address;
Line 127  static void MEMCALL grcg_tdw0(UINT32 add Line 127  static void MEMCALL grcg_tdw0(UINT32 add
   
         BYTE    *vram;          BYTE    *vram;
   
         nevent.remainclock -= vramop.grcgwait;          I286_REMCLOCK -= vramop.grcgwait;
         address &= 0x7fff;          address = LOW15(address);
         vramupdate[address] |= 1;          vramupdate[address] |= 1;
         gdcs.grphdisp |= 1;          gdcs.grphdisp |= 1;
         vram = mem + address;          vram = mem + address;
Line 151  static void MEMCALL grcg_tdw1(UINT32 add Line 151  static void MEMCALL grcg_tdw1(UINT32 add
   
         BYTE    *vram;          BYTE    *vram;
   
         nevent.remainclock -= vramop.grcgwait;          I286_REMCLOCK -= vramop.grcgwait;
         address &= 0x7fff;          address = LOW15(address);
         vramupdate[address] |= 2;          vramupdate[address] |= 2;
         gdcs.grphdisp |= 2;          gdcs.grphdisp |= 2;
         vram = mem + address;          vram = mem + address;
Line 178  static void MEMCALL egc_wt(UINT32 addres Line 178  static void MEMCALL egc_wt(UINT32 addres
   
 static void MEMCALL emmc_wt(UINT32 address, BYTE value) {  static void MEMCALL emmc_wt(UINT32 address, BYTE value) {
   
         extmem.pageptr[(address >> 14) & 3][address & 0x3fff] = value;          extmem.pageptr[(address >> 14) & 3][LOW14(address)] = value;
 }  }
   
 static void MEMCALL i286_wn(UINT32 address, BYTE value) {  static void MEMCALL i286_wn(UINT32 address, BYTE value) {
Line 197  static BYTE MEMCALL i286_rd(UINT32 addre Line 197  static BYTE MEMCALL i286_rd(UINT32 addre
   
 static BYTE MEMCALL tram_rd(UINT32 address) {  static BYTE MEMCALL tram_rd(UINT32 address) {
   
         nevent.remainclock -= vramop.tramwait;          I286_REMCLOCK -= vramop.tramwait;
         if (address < 0xa4000) {          if (address < 0xa4000) {
                 return(mem[address]);                  return(mem[address]);
         }          }
         else if (address < 0xa5000) {          else if (address < 0xa5000) {
                 if (address & 1) {                  if (address & 1) {
                         return(font[cgwindow.high + ((address >> 1) & 0x0f)]);                          return(fontrom[cgwindow.high + ((address >> 1) & 0x0f)]);
                 }                  }
                 else {                  else {
                         return(font[cgwindow.low + ((address >> 1) & 0x0f)]);                          return(fontrom[cgwindow.low + ((address >> 1) & 0x0f)]);
                 }                  }
         }          }
         return(mem[address]);          return(mem[address]);
Line 214  static BYTE MEMCALL tram_rd(UINT32 addre Line 214  static BYTE MEMCALL tram_rd(UINT32 addre
   
 static BYTE MEMCALL vram_r0(UINT32 address) {  static BYTE MEMCALL vram_r0(UINT32 address) {
   
         nevent.remainclock -= vramop.vramwait;          I286_REMCLOCK -= vramop.vramwait;
         return(mem[address]);          return(mem[address]);
 }  }
   
 static BYTE MEMCALL vram_r1(UINT32 address) {  static BYTE MEMCALL vram_r1(UINT32 address) {
   
         nevent.remainclock -= vramop.vramwait;          I286_REMCLOCK -= vramop.vramwait;
         return(mem[address + VRAM_STEP]);          return(mem[address + VRAM_STEP]);
 }  }
   
Line 229  static BYTE MEMCALL grcg_tcr0(UINT32 add Line 229  static BYTE MEMCALL grcg_tcr0(UINT32 add
 const BYTE      *vram;  const BYTE      *vram;
         BYTE    ret;          BYTE    ret;
   
         nevent.remainclock -= vramop.grcgwait;          I286_REMCLOCK -= vramop.grcgwait;
         vram = mem + (address & 0x7fff);          vram = mem + LOW15(address);
         ret = 0;          ret = 0;
         if (!(grcg.modereg & 1)) {          if (!(grcg.modereg & 1)) {
                 ret |= vram[VRAM0_B] ^ grcg.tile[0].b[0];                  ret |= vram[VRAM0_B] ^ grcg.tile[0].b[0];
Line 252  static BYTE MEMCALL grcg_tcr1(UINT32 add Line 252  static BYTE MEMCALL grcg_tcr1(UINT32 add
         BYTE    *vram;          BYTE    *vram;
         BYTE    ret;          BYTE    ret;
   
         nevent.remainclock -= vramop.grcgwait;          I286_REMCLOCK -= vramop.grcgwait;
         ret = 0;          ret = 0;
         vram = mem + (address & 0x7fff);          vram = mem + LOW15(address);
         if (!(grcg.modereg & 1)) {          if (!(grcg.modereg & 1)) {
                 ret |= vram[VRAM1_B] ^ grcg.tile[0].b[0];                  ret |= vram[VRAM1_B] ^ grcg.tile[0].b[0];
         }          }
Line 277  static BYTE MEMCALL egc_rd(UINT32 addres Line 277  static BYTE MEMCALL egc_rd(UINT32 addres
   
 static BYTE MEMCALL emmc_rd(UINT32 address) {  static BYTE MEMCALL emmc_rd(UINT32 address) {
   
         return(extmem.pageptr[(address >> 14) & 3][address & 0x3fff]);          return(extmem.pageptr[(address >> 14) & 3][LOW14(address)]);
 }  }
   
 static BYTE MEMCALL i286_itf(UINT32 address) {  static BYTE MEMCALL i286_itf(UINT32 address) {
   
         if (itf.bank) {          if (itf.bank) {
                 address = ITF_ADRS + (address & 0x7fff);                  address = ITF_ADRS + LOW15(address);
         }          }
         return(mem[address]);          return(mem[address]);
 }  }
Line 303  static void MEMCALL tramw_wt(UINT32 addr Line 303  static void MEMCALL tramw_wt(UINT32 addr
   
         if (address < 0xa1fff) {          if (address < 0xa1fff) {
                 STOREINTELWORD(mem + address, value);                  STOREINTELWORD(mem + address, value);
                 tramupdate[(address >> 1) & 0x0fff] = 1;                  tramupdate[LOW12(address >> 1)] = 1;
                 tramupdate[((address + 1) >> 1) & 0x0fff] = 1;                  tramupdate[LOW12((address + 1) >> 1)] = 1;
                 gdcs.textdisp |= 1;                  gdcs.textdisp |= 1;
         }          }
         else if (address == 0xa1fff) {          else if (address == 0xa1fff) {
Line 319  static void MEMCALL tramw_wt(UINT32 addr Line 319  static void MEMCALL tramw_wt(UINT32 addr
                         value >>= 8;                          value >>= 8;
                 }                  }
                 mem[address] = (BYTE)value;                  mem[address] = (BYTE)value;
                 tramupdate[(address >> 1) & 0x0fff] = 1;                  tramupdate[LOW12(address >> 1)] = 1;
                 gdcs.textdisp |= 1;                  gdcs.textdisp |= 1;
         }          }
         else if (address < 0xa3fff) {          else if (address < 0xa3fff) {
Line 329  static void MEMCALL tramw_wt(UINT32 addr Line 329  static void MEMCALL tramw_wt(UINT32 addr
                 }                  }
                 if ((!(address & 2)) || (gdcs.msw_accessable)) {                  if ((!(address & 2)) || (gdcs.msw_accessable)) {
                         mem[address] = (BYTE)value;                          mem[address] = (BYTE)value;
                         tramupdate[(address >> 1) & 0x0fff] = 1;                          tramupdate[LOW12(address >> 1)] = 1;
                         gdcs.textdisp |= 1;                          gdcs.textdisp |= 1;
                 }                  }
         }          }
Line 339  static void MEMCALL tramw_wt(UINT32 addr Line 339  static void MEMCALL tramw_wt(UINT32 addr
                 }                  }
                 if (cgwindow.writable & 1) {                  if (cgwindow.writable & 1) {
                         cgwindow.writable |= 0x80;                          cgwindow.writable |= 0x80;
                         font[cgwindow.high + ((address >> 1) & 0x0f)] = (BYTE)value;                          fontrom[cgwindow.high + ((address >> 1) & 0x0f)] = (BYTE)value;
                 }                  }
         }          }
 }  }
   
   
 #define GRCGW_NON(page) {                                                                                       \  #define GRCGW_NON(page) {                                                                                       \
         nevent.remainclock -= vramop.vramwait;                                                  \          I286_REMCLOCK -= vramop.vramwait;                                                               \
         STOREINTELWORD(mem + address + VRAM_STEP*(page), value);                \          STOREINTELWORD(mem + address + VRAM_STEP*(page), value);                \
         vramupdate[address & 0x7fff] |= (1 << page);                                    \          vramupdate[LOW15(address)] |= (1 << page);                                              \
         vramupdate[(address + 1) & 0x7fff] |= (1 << page);                              \          vramupdate[LOW15(address + 1)] |= (1 << page);                                  \
         gdcs.grphdisp |= (1 << page);                                                                   \          gdcs.grphdisp |= (1 << page);                                                                   \
 }  }
   
 #define GRCGW_RMW(page) {                                                                                       \  #define GRCGW_RMW(page) {                                                                                       \
         BYTE    *vram;                                                                                                  \          BYTE    *vram;                                                                                                  \
         nevent.remainclock -= vramop.grcgwait;                                                  \          I286_REMCLOCK -= vramop.grcgwait;                                                               \
         address &= 0x7fff;                                                                                              \          address = LOW15(address);                                                                               \
         vramupdate[address] |= (1 << page);                                                             \          vramupdate[address] |= (1 << page);                                                             \
         vramupdate[address + 1] |= (1 << page);                                                 \          vramupdate[address + 1] |= (1 << page);                                                 \
         gdcs.grphdisp |= (1 << page);                                                                   \          gdcs.grphdisp |= (1 << page);                                                                   \
Line 401  static void MEMCALL tramw_wt(UINT32 addr Line 401  static void MEMCALL tramw_wt(UINT32 addr
   
 #define GRCGW_TDW(page) {                                                                                       \  #define GRCGW_TDW(page) {                                                                                       \
         BYTE    *vram;                                                                                                  \          BYTE    *vram;                                                                                                  \
         nevent.remainclock -= vramop.grcgwait;                                                  \          I286_REMCLOCK -= vramop.grcgwait;                                                               \
         address &= 0x7fff;                                                                                              \          address = LOW15(address);                                                                               \
         vramupdate[address] |= (1 << page);                                                             \          vramupdate[address] |= (1 << page);                                                             \
         vramupdate[address + 1] |= (1 << page);                                                 \          vramupdate[address + 1] |= (1 << page);                                                 \
         gdcs.grphdisp |= (1 << page);                                                                   \          gdcs.grphdisp |= (1 << page);                                                                   \
Line 455  static void MEMCALL emmcw_wt(UINT32 addr Line 455  static void MEMCALL emmcw_wt(UINT32 addr
         BYTE    *ptr;          BYTE    *ptr;
   
         if ((address & 0x3fff) != 0x3fff) {          if ((address & 0x3fff) != 0x3fff) {
                 ptr = extmem.pageptr[(address >> 14) & 3] + (address & 0x3fff);                  ptr = extmem.pageptr[(address >> 14) & 3] + LOW14(address);
                 STOREINTELWORD(ptr, value);                  STOREINTELWORD(ptr, value);
         }          }
         else {          else {
Line 483  static UINT16 MEMCALL i286w_rd(UINT32 ad Line 483  static UINT16 MEMCALL i286w_rd(UINT32 ad
   
 static UINT16 MEMCALL tramw_rd(UINT32 address) {  static UINT16 MEMCALL tramw_rd(UINT32 address) {
   
         nevent.remainclock -= vramop.tramwait;          I286_REMCLOCK -= vramop.tramwait;
         if (address < (0xa4000 - 1)) {          if (address < (0xa4000 - 1)) {
                 return(LOADINTELWORD(mem + address));                  return(LOADINTELWORD(mem + address));
         }          }
         else if (address == 0xa3fff) {          else if (address == 0xa3fff) {
                 return(mem[address] + (font[cgwindow.low] << 8));                  return(mem[address] + (fontrom[cgwindow.low] << 8));
         }          }
         else if (address < 0xa4fff) {          else if (address < 0xa4fff) {
                 if (address & 1) {                  if (address & 1) {
                         UINT16 ret;                          UINT16 ret;
                         ret = font[cgwindow.high + ((address >> 1) & 0x0f)];                          ret = fontrom[cgwindow.high + ((address >> 1) & 0x0f)];
                         ret += font[cgwindow.low + (((address + 1) >> 1) & 0x0f)] << 8;                          ret += fontrom[cgwindow.low + (((address + 1) >> 1) & 0x0f)] << 8;
                         return(ret);                          return(ret);
                 }                  }
                 else {                  else {
                         UINT16 ret;                          UINT16 ret;
                         ret = font[cgwindow.low + ((address >> 1) & 0x0f)];                          ret = fontrom[cgwindow.low + ((address >> 1) & 0x0f)];
                         ret += font[cgwindow.high + ((address >> 1) & 0x0f)] << 8;                          ret += fontrom[cgwindow.high + ((address >> 1) & 0x0f)] << 8;
                         return(ret);                          return(ret);
                 }                  }
         }          }
         else if (address == 0xa4fff) {          else if (address == 0xa4fff) {
                 return((mem[0xa5000] << 8) | font[cgwindow.high + 15]);                  return((mem[0xa5000] << 8) | fontrom[cgwindow.high + 15]);
         }          }
         return(LOADINTELWORD(mem + address));          return(LOADINTELWORD(mem + address));
 }  }
   
 static UINT16 MEMCALL vramw_r0(UINT32 address) {  static UINT16 MEMCALL vramw_r0(UINT32 address) {
   
         nevent.remainclock -= vramop.vramwait;          I286_REMCLOCK -= vramop.vramwait;
         return(LOADINTELWORD(mem + address));          return(LOADINTELWORD(mem + address));
 }  }
   
 static UINT16 MEMCALL vramw_r1(UINT32 address) {  static UINT16 MEMCALL vramw_r1(UINT32 address) {
   
         nevent.remainclock -= vramop.vramwait;          I286_REMCLOCK -= vramop.vramwait;
         return(LOADINTELWORD(mem + address + VRAM_STEP));          return(LOADINTELWORD(mem + address + VRAM_STEP));
 }  }
   
Line 527  static UINT16 MEMCALL grcgw_tcr0(UINT32  Line 527  static UINT16 MEMCALL grcgw_tcr0(UINT32 
         BYTE    *vram;          BYTE    *vram;
         UINT16  ret;          UINT16  ret;
   
         nevent.remainclock -= vramop.grcgwait;          I286_REMCLOCK -= vramop.grcgwait;
         ret = 0;          ret = 0;
         vram = mem + (address & 0x7fff);          vram = mem + LOW15(address);
         if (!(grcg.modereg & 1)) {          if (!(grcg.modereg & 1)) {
                 ret |= LOADINTELWORD(vram + VRAM0_B) ^ grcg.tile[0].w;                  ret |= LOADINTELWORD(vram + VRAM0_B) ^ grcg.tile[0].w;
         }          }
Line 550  static UINT16 MEMCALL grcgw_tcr1(UINT32  Line 550  static UINT16 MEMCALL grcgw_tcr1(UINT32 
         BYTE    *vram;          BYTE    *vram;
         UINT16  ret;          UINT16  ret;
   
         nevent.remainclock -= vramop.grcgwait;          I286_REMCLOCK -= vramop.grcgwait;
         ret = 0;          ret = 0;
         vram = mem + (address & 0x7fff);          vram = mem + LOW15(address);
         if (!(grcg.modereg & 1)) {          if (!(grcg.modereg & 1)) {
                 ret |= LOADINTELWORD(vram + VRAM1_B) ^ grcg.tile[0].w;                  ret |= LOADINTELWORD(vram + VRAM1_B) ^ grcg.tile[0].w;
         }          }
Line 594  static UINT16 MEMCALL emmcw_rd(UINT32 ad Line 594  static UINT16 MEMCALL emmcw_rd(UINT32 ad
   
         BYTE    *ptr;          BYTE    *ptr;
   
         ptr = extmem.pageptr[(address >> 14) & 3] + (address & 0x3fff);          ptr = extmem.pageptr[(address >> 14) & 3] + LOW14(address);
         return(LOADINTELWORD(ptr));          return(LOADINTELWORD(ptr));
 }  }
   
 static UINT16 MEMCALL i286w_itf(UINT32 address) {  static UINT16 MEMCALL i286w_itf(UINT32 address) {
   
         if (itf.bank) {          if (itf.bank) {
                 address = ITF_ADRS + (address & 0x7fff);                  address = ITF_ADRS + LOW15(address);
         }          }
         return(LOADINTELWORD(mem + address));          return(LOADINTELWORD(mem + address));
 }  }
Line 917  void MEMCALL i286_memstr_read(UINT seg,  Line 917  void MEMCALL i286_memstr_read(UINT seg, 
         else {          else {
                 while(leng--) {                  while(leng--) {
                         *out++ = i286_memoryread(adrs + off);                          *out++ = i286_memoryread(adrs + off);
                         off = (off + 1) & 0xffff;                          off = LOW16(off + 1);
                 }                  }
         }          }
 }  }
Line 955  void MEMCALL i286_memstr_write(UINT seg, Line 955  void MEMCALL i286_memstr_write(UINT seg,
         else {          else {
                 while(leng--) {                  while(leng--) {
                         i286_memorywrite(adrs + off, *out++);                          i286_memorywrite(adrs + off, *out++);
                         off = (off + 1) & 0xffff;                          off = LOW16(off + 1);
                 }                  }
         }          }
 }  }
Removed from v.1.1.1.1  
changed lines
  Added in v.1.4

RetroPC.NET-CVS <cvs@retropc.net>