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

Diff for /np2/i386c/ia32/paging.c between versions 1.5 and 1.9

version 1.5, 2004/01/23 16:17:51 version 1.9, 2004/02/03 14:49:39
Line 112 Line 112
  * +-----+-----------+-----+-----+---+   * +-----+-----------+-----+-----+---+
  */   */
 #if !defined(USE_PAGE_ACCESS_TABLE)  #if !defined(USE_PAGE_ACCESS_TABLE)
 static const DWORD page_access = 0xd0cdd0ff;  #define page_access     0xd0ddd0ff
 #else   /* USE_PAGE_ACCESS_TABLE */  #else   /* USE_PAGE_ACCESS_TABLE */
 static const BYTE page_access_bit[32] = {  static const BYTE page_access_bit[32] = {
         1,      /* CR0: n, CPL: s, PTE: s, PTE: r, ope: r */          1,      /* CR0: n, CPL: s, PTE: s, PTE: r, ope: r */
Line 143  static const BYTE page_access_bit[32] =  Line 143  static const BYTE page_access_bit[32] = 
         1,      /* CR0: p, CPL: s, PTE: u, PTE: r, ope: r */          1,      /* CR0: p, CPL: s, PTE: u, PTE: r, ope: r */
         0,      /* CR0: p, CPL: s, PTE: u, PTE: r, ope: w */          0,      /* CR0: p, CPL: s, PTE: u, PTE: r, ope: w */
         1,      /* CR0: p, CPL: s, PTE: u, PTE: w, ope: r */          1,      /* CR0: p, CPL: s, PTE: u, PTE: w, ope: r */
         0,      /* CR0: p, CPL: s, PTE: u, PTE: w, ope: w */          1,      /* CR0: p, CPL: s, PTE: u, PTE: w, ope: w */
   
         0,      /* CR0: p, CPL: u, PTE: s, PTE: r, ope: r */          0,      /* CR0: p, CPL: u, PTE: s, PTE: r, ope: r */
         0,      /* CR0: p, CPL: u, PTE: s, PTE: r, ope: w */          0,      /* CR0: p, CPL: u, PTE: s, PTE: r, ope: w */
Line 213  cpu_linear_memory_read(DWORD laddr, DWOR Line 213  cpu_linear_memory_read(DWORD laddr, DWOR
   
                 r = (remain > length) ? length : remain;                  r = (remain > length) ? length : remain;
                 switch (r) {                  switch (r) {
                 case 1:                  case 4:
                         value |= (DWORD)cpu_memoryread(paddr) << shift;                          value = cpu_memoryread_d(paddr);
                         shift += 8;  
                         break;                          break;
   
                   case 3:
                           value |= (DWORD)cpu_memoryread(paddr) << shift;
                           shift += 8;
                           paddr++;
                           /*FALLTHROUGH*/
                 case 2:                  case 2:
                         value |= (DWORD)cpu_memoryread_w(paddr) << shift;                          value |= (DWORD)cpu_memoryread_w(paddr) << shift;
                         shift += 16;                          shift += 16;
                         break;                          break;
   
                 case 3:                  case 1:
                         value |= (DWORD)cpu_memoryread_w(paddr) << shift;                          value |= (DWORD)cpu_memoryread(paddr) << shift;
                         shift += 16;  
                         value |= (DWORD)cpu_memoryread(paddr + 2) << shift;  
                         shift += 8;                          shift += 8;
                         break;                          break;
   
                 case 4:  
                         value = cpu_memoryread_d(paddr);  
                         break;  
   
                 default:                  default:
                         ia32_panic("cpu_linear_memory_read(): out of range (r = %d)\n", r);                          ia32_panic("cpu_linear_memory_read(): out of range (r = %d)\n", r);
                         break;                          break;
                 }                  }
   
                 if (length == r)                  length -= r;
                   if (length == 0)
                         break;                          break;
   
                 laddr += r;                  laddr += r;
                 length -= r;  
                 remain -= r;                  remain -= r;
                 if (remain <= 0)                  if (remain <= 0) {
                           /* next page */
                         remain += 0x1000;                          remain += 0x1000;
                   }
         }          }
   
         return value;          return value;
 }  }
   
 void MEMCALL  void MEMCALL
 cpu_linear_memory_write(DWORD laddr, DWORD length, DWORD value)  cpu_linear_memory_write(DWORD laddr, DWORD value, DWORD length)
 {  {
         DWORD paddr;          DWORD paddr;
         DWORD remain;   /* page remain */          DWORD remain;   /* page remain */
Line 272  cpu_linear_memory_write(DWORD laddr, DWO Line 272  cpu_linear_memory_write(DWORD laddr, DWO
   
                 r = (remain > length) ? length : remain;                  r = (remain > length) ? length : remain;
                 switch (r) {                  switch (r) {
                 case 1:                  case 4:
                         cpu_memorywrite(paddr, value & 0xff);                          cpu_memorywrite_d(paddr, value);
                         value >>= 8;  
                         break;                          break;
   
                   case 3:
                           cpu_memorywrite(paddr, value & 0xff);
                           value >>= 8;
                           paddr++;
                           /*FALLTHROUGH*/
                 case 2:                  case 2:
                         cpu_memorywrite_w(paddr, value & 0xffff);                          cpu_memorywrite_w(paddr, value & 0xffff);
                         value >>= 16;                          value >>= 16;
                         break;                          break;
   
                 case 3:                  case 1:
                         cpu_memorywrite_w(paddr, value & 0xffff);  
                         value >>= 16;  
                         cpu_memorywrite(paddr, value & 0xff);                          cpu_memorywrite(paddr, value & 0xff);
                         value >>= 8;                          value >>= 8;
                         break;                          break;
   
                 case 4:  
                         cpu_memorywrite_d(paddr, value);  
                         break;  
   
                 default:                  default:
                         ia32_panic("cpu_linear_memory_write(): out of range (r = %d)\n", r);                          ia32_panic("cpu_linear_memory_write(): out of range (r = %d)\n", r);
                         break;                          break;
                 }                  }
   
                 if (length == r)                  length -= r;
                   if (length == 0)
                         break;                          break;
   
                 laddr += r;                  laddr += r;
                 length -= r;  
                 remain -= r;                  remain -= r;
                 if (remain <= 0)                  if (remain <= 0) {
                           /* next page */
                         remain += 0x1000;                          remain += 0x1000;
                   }
         }          }
 }  }
   
Line 327  paging_check(DWORD laddr, DWORD length,  Line 327  paging_check(DWORD laddr, DWORD length, 
                 paddr = paging(laddr, crw, pl);                  paddr = paging(laddr, crw, pl);
   
                 r = (remain > length) ? length : remain;                  r = (remain > length) ? length : remain;
                 if (length == r)  
                   length -= r;
                   if (length == 0)
                         break;                          break;
   
                 laddr += r;                  laddr += r;
                 length -= r;  
                 remain -= r;                  remain -= r;
                 if (remain <= 0)                  if (remain <= 0) {
                           /* next page */
                         remain += 0x1000;                          remain += 0x1000;
                   }
         }          }
 }  }
   
Line 347  paging(DWORD laddr, int crw, int user_mo Line 350  paging(DWORD laddr, int crw, int user_mo
         DWORD pte_addr; /* page table entry address */          DWORD pte_addr; /* page table entry address */
         DWORD pte;      /* page table entry */          DWORD pte;      /* page table entry */
         DWORD bit;          DWORD bit;
         DWORD err = 0;          DWORD err;
   
 #if defined(IA32_SUPPORT_TLB)  #if defined(IA32_SUPPORT_TLB)
         if (tlb_lookup(laddr, crw, &paddr))          if (tlb_lookup(laddr, crw, &paddr))
                 return paddr;                  return paddr;
 #endif  /* IA32_SUPPORT_TLB */  #endif  /* IA32_SUPPORT_TLB */
   
         pde_addr = (CPU_CR3 & CPU_CR3_PD_MASK) | ((laddr >> 20) & 0xffc);          pde_addr = CPU_STAT_PDE_BASE | ((laddr >> 20) & 0xffc);
         pde = cpu_memoryread_d(pde_addr);          pde = cpu_memoryread_d(pde_addr);
         if (!(pde & CPU_PDE_PRESENT)) {          if (!(pde & CPU_PDE_PRESENT)) {
                 VERBOSE(("paging: PDE is not present"));                  VERBOSE(("paging: PDE is not present"));
Line 368  paging(DWORD laddr, int crw, int user_mo Line 371  paging(DWORD laddr, int crw, int user_mo
                 cpu_memorywrite_d(pde_addr, pde);                  cpu_memorywrite_d(pde_addr, pde);
         }          }
   
   #if CPU_FAMILY >= 5
         /* no support PAE */          /* no support PAE */
         __ASSERT(!(CPU_CR4 & CPU_CR4_PAE));          __ASSERT(!(CPU_CR4 & CPU_CR4_PAE));
   
Line 380  paging(DWORD laddr, int crw, int user_mo Line 384  paging(DWORD laddr, int crw, int user_mo
   
                 /* make physical address */                  /* make physical address */
                 paddr = (pde & CPU_PDE_4M_BASEADDR_MASK) | (laddr & 0x003fffff);                  paddr = (pde & CPU_PDE_4M_BASEADDR_MASK) | (laddr & 0x003fffff);
         } else {          } else
   #endif  /* CPU_FAMILY >= 5 */
           {
                 /* 4KB page size */                  /* 4KB page size */
                 pte_addr = (pde & CPU_PDE_BASEADDR_MASK) | ((laddr >> 10) & 0xffc);                  pte_addr = (pde & CPU_PDE_BASEADDR_MASK) | ((laddr >> 10) & 0xffc);
                 pte = cpu_memoryread_d(pte_addr);                  pte = cpu_memoryread_d(pte_addr);
Removed from v.1.5  
changed lines
  Added in v.1.9

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