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

Diff for /np2/i386c/memory.c between versions 1.36 and 1.37

version 1.36, 2012/01/23 05:18:09 version 1.37, 2012/01/23 10:23:54
Line 582  void MEMCALL memp_writes(UINT32 address, Line 582  void MEMCALL memp_writes(UINT32 address,
   
 // ---- Logical Space (BIOS)  // ---- Logical Space (BIOS)
   
 static UINT32 physicaladdr(UINT32 addr, BOOL wr) {  
   
         UINT32  a;  
         UINT32  pde;  
         UINT32  pte;  
   
         a = CPU_STAT_PDE_BASE + ((addr >> 20) & 0xffc);  
         pde = memp_read32(a);  
         if (!(pde & CPU_PDE_PRESENT)) {  
                 goto retdummy;  
         }  
         if (!(pde & CPU_PDE_ACCESS)) {  
                 memp_write8(a, (UINT8)(pde | CPU_PDE_ACCESS));  
         }  
         a = (pde & CPU_PDE_BASEADDR_MASK) + ((addr >> 10) & 0xffc);  
         pte = cpu_memoryread_d(a);  
         if (!(pte & CPU_PTE_PRESENT)) {  
                 goto retdummy;  
         }  
         if (!(pte & CPU_PTE_ACCESS)) {  
                 memp_write8(a, (UINT8)(pte | CPU_PTE_ACCESS));  
         }  
         if ((wr) && (!(pte & CPU_PTE_DIRTY))) {  
                 memp_write8(a, (UINT8)(pte | CPU_PTE_DIRTY));  
         }  
         addr = (pte & CPU_PTE_BASEADDR_MASK) + (addr & 0x00000fff);  
         return(addr);  
   
 retdummy:  
         return(0x01000000);             // てきとーにメモリが存在しない場所  
 }  
   
   
 void MEMCALL meml_reads(UINT32 address, void *dat, UINT leng) {  void MEMCALL meml_reads(UINT32 address, void *dat, UINT leng) {
   
         UINT    size;          if (!CPU_STAT_PM) {
   
         if (!CPU_STAT_PAGING) {  
                 memp_reads(address, dat, leng);                  memp_reads(address, dat, leng);
         }          }
           else if (CPU_STAT_VM86) {
                   cpu_memory_access_la_region(address, leng,
                     CPU_PAGE_READ_DATA | CPU_PAGE_USER_MODE, dat);
           }
         else {          else {
                 while(leng) {                  ia32_panic("%s: call from BIOS, but protected mode", __func__);
                         size = 0x1000 - (address & 0xfff);  
                         size = min(size, leng);  
                         memp_reads(physicaladdr(address, FALSE), dat, size);  
                         address += size;  
                         dat = ((UINT8 *)dat) + size;  
                         leng -= size;  
                 }  
         }          }
 }  }
   
 void MEMCALL meml_writes(UINT32 address, const void *dat, UINT leng) {  void MEMCALL meml_writes(UINT32 address, const void *dat, UINT leng) {
   
         const UINT8     *out = dat;          if (!CPU_STAT_PM) {
         UINT            size;                  memp_writes(address, dat, leng);
           }
         if (!CPU_STAT_PAGING) {          else if (CPU_STAT_VM86) {
                 memp_writes(address, out, leng);                  cpu_memory_access_la_region(address, leng,
                     CPU_PAGE_WRITE_DATA | CPU_PAGE_USER_MODE, (UINT8 *)dat);
         }          }
         else {          else {
                 while(leng) {                  ia32_panic("%s: call from BIOS, but protected mode", __func__);
                         size = 0x1000 - (address & 0xfff);  
                         size = min(size, leng);  
                         memp_writes(physicaladdr(address, TRUE), out, size);  
                         address += size;  
                         out += size;  
                         leng -= size;  
                 }  
         }          }
 }  }
   
Line 660  REG8 MEMCALL memr_read8(UINT seg, UINT o Line 616  REG8 MEMCALL memr_read8(UINT seg, UINT o
         UINT32  addr;          UINT32  addr;
   
         addr = (seg << 4) + LOW16(off);          addr = (seg << 4) + LOW16(off);
         if (CPU_STAT_PAGING) {          if (!CPU_STAT_PM) {
                 addr = physicaladdr(addr, FALSE);                  return(memp_read8(addr));
           }
           else if (CPU_STAT_VM86) {
                   return(cpu_linear_memory_read_b(addr,
                     CPU_PAGE_READ_DATA | CPU_PAGE_USER_MODE));
           }
           else {
                   ia32_panic("%s: call from BIOS, but protected mode", __func__);
                   return(0xff);
         }          }
         return(memp_read8(addr));  
 }  }
   
 REG16 MEMCALL memr_read16(UINT seg, UINT off) {  REG16 MEMCALL memr_read16(UINT seg, UINT off) {
Line 671  REG16 MEMCALL memr_read16(UINT seg, UINT Line 634  REG16 MEMCALL memr_read16(UINT seg, UINT
         UINT32  addr;          UINT32  addr;
   
         addr = (seg << 4) + LOW16(off);          addr = (seg << 4) + LOW16(off);
         if (!CPU_STAT_PAGING) {          if (!CPU_STAT_PM) {
                 return(memp_read16(addr));                  return(memp_read16(addr));
         }          }
         else if ((addr + 1) & 0xfff) {          else if (CPU_STAT_VM86) {
                 return(memp_read16(physicaladdr(addr, FALSE)));                  return(cpu_linear_memory_read_w(addr,
                     CPU_PAGE_READ_DATA | CPU_PAGE_USER_MODE));
           }
           else {
                   ia32_panic("%s: call from BIOS, but protected mode", __func__);
                   return(0xffff);
         }          }
         return(memr_read8(seg, off) + (memr_read8(seg, off + 1) << 8));  
 }  }
   
 void MEMCALL memr_write8(UINT seg, UINT off, REG8 dat) {  void MEMCALL memr_write8(UINT seg, UINT off, REG8 dat) {
Line 685  void MEMCALL memr_write8(UINT seg, UINT  Line 652  void MEMCALL memr_write8(UINT seg, UINT 
         UINT32  addr;          UINT32  addr;
   
         addr = (seg << 4) + LOW16(off);          addr = (seg << 4) + LOW16(off);
         if (CPU_STAT_PAGING) {          if (!CPU_STAT_PM) {
                 addr = physicaladdr(addr, TRUE);                  memp_write8(addr, dat);
           }
           else if (CPU_STAT_VM86) {
                   cpu_linear_memory_write_b(addr, dat,
                     CPU_PAGE_WRITE_DATA | CPU_PAGE_USER_MODE);
           }
           else {
                   ia32_panic("%s: call from BIOS, but protected mode", __func__);
         }          }
         memp_write8(addr, dat);  
 }  }
   
 void MEMCALL memr_write16(UINT seg, UINT off, REG16 dat) {  void MEMCALL memr_write16(UINT seg, UINT off, REG16 dat) {
Line 696  void MEMCALL memr_write16(UINT seg, UINT Line 669  void MEMCALL memr_write16(UINT seg, UINT
         UINT32  addr;          UINT32  addr;
   
         addr = (seg << 4) + LOW16(off);          addr = (seg << 4) + LOW16(off);
         if (!CPU_STAT_PAGING) {          if (!CPU_STAT_PM) {
                 memp_write16(addr, dat);                  memp_write16(addr, dat);
         }          }
         else if ((addr + 1) & 0xfff) {          else if (CPU_STAT_VM86) {
                 memp_write16(physicaladdr(addr, TRUE), dat);                  cpu_linear_memory_write_w(addr, dat,
                     CPU_PAGE_WRITE_DATA | CPU_PAGE_USER_MODE);
         }          }
         else {          else {
                 memr_write8(seg, off, (REG8)dat);                  ia32_panic("%s: call from BIOS, but protected mode", __func__);
                 memr_write8(seg, off + 1, (REG8)(dat >> 8));  
         }          }
 }  }
   
 void MEMCALL memr_reads(UINT seg, UINT off, void *dat, UINT leng) {  void MEMCALL memr_reads(UINT seg, UINT off, void *dat, UINT leng) {
   
           UINT8   *in = dat;
         UINT32  addr;          UINT32  addr;
         UINT    rem;          UINT    rem;
         UINT    size;          UINT    size;
   
           if (CPU_STAT_PM && !CPU_STAT_VM86) {
                   ia32_panic("%s: call from BIOS, but protected mode", __func__);
                   return;
           }
   
         while(leng) {          while(leng) {
                 off = LOW16(off);                  off = LOW16(off);
                 addr = (seg << 4) + off;                  addr = (seg << 4) + off;
                 rem = 0x10000 - off;                  rem = 0x10000 - off;
                 size = min(leng, rem);                  size = min(leng, rem);
                 if (CPU_STAT_PAGING) {                  if (!CPU_STAT_PM) {
                         rem = 0x1000 - (addr & 0xfff);                          memp_reads(addr, in, size);
                   }
                   else {
                           /* VM86 */
                           rem = CPU_PAGE_SIZE - (addr & CPU_PAGE_MASK);
                         size = min(size, rem);                          size = min(size, rem);
                         addr = physicaladdr(addr, FALSE);                          cpu_memory_access_la_region(addr, size,
                             CPU_PAGE_READ_DATA | CPU_PAGE_USER_MODE, in);
                 }                  }
                 memp_reads(addr, dat, size);  
                 off += size;                  off += size;
                 dat = ((UINT8 *)dat) + size;                  in += size;
                 leng -= size;                  leng -= size;
         }          }
 }  }
Line 738  void MEMCALL memr_writes(UINT seg, UINT  Line 721  void MEMCALL memr_writes(UINT seg, UINT 
         UINT            rem;          UINT            rem;
         UINT            size;          UINT            size;
   
           if (CPU_STAT_PM && !CPU_STAT_VM86) {
                   ia32_panic("%s: call from BIOS, but protected mode", __func__);
                   return;
           }
   
         while(leng) {          while(leng) {
                 off = LOW16(off);                  off = LOW16(off);
                 addr = (seg << 4) + off;                  addr = (seg << 4) + off;
                 rem = 0x10000 - off;                  rem = 0x10000 - off;
                 size = min(leng, rem);                  size = min(leng, rem);
                 if (CPU_STAT_PAGING) {                  if (!CPU_STAT_PM) {
                           memp_writes(addr, out, size);
                   }
                   else {
                           /* VM86 */
                         rem = 0x1000 - (addr & 0xfff);                          rem = 0x1000 - (addr & 0xfff);
                         size = min(size, rem);                          size = min(size, rem);
                         addr = physicaladdr(addr, TRUE);                          cpu_memory_access_la_region(addr, size,
                             CPU_PAGE_WRITE_DATA | CPU_PAGE_USER_MODE, (UINT8 *)out);
                 }                  }
                 memp_writes(addr, out, size);  
                 off += size;                  off += size;
                 out += size;                  out += size;
                 leng -= size;                  leng -= size;
Line 756  void MEMCALL memr_writes(UINT seg, UINT  Line 748  void MEMCALL memr_writes(UINT seg, UINT 
 }  }
   
 #endif  #endif
   
Removed from v.1.36  
changed lines
  Added in v.1.37

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