[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.8 and 1.10

version 1.8, 2004/02/03 14:27:07 version 1.10, 2004/02/04 13:24:35
Line 192  static void tlb_update(DWORD paddr, DWOR Line 192  static void tlb_update(DWORD paddr, DWOR
   
   
 DWORD MEMCALL  DWORD MEMCALL
 cpu_linear_memory_read(DWORD laddr, DWORD length, int code)  cpu_linear_memory_read(DWORD laddr, DWORD length, int crw, int user_mode)
 {  {
         DWORD paddr;          DWORD paddr;
         DWORD remain;   /* page remain */          DWORD remain;   /* page remain */
         DWORD r;          DWORD r;
         DWORD shift = 0;          DWORD shift = 0;
         DWORD value = 0;          DWORD value = 0;
         int crw;  
         int pl;  
   
         crw = CPU_PAGING_PAGE_READ;  
         crw |= code ? CPU_PAGING_PAGE_CODE : CPU_PAGING_PAGE_DATA;  
         pl = (CPU_STAT_CPL == 3);  
   
         /* XXX: 4MB pages... */          /* XXX: 4MB pages... */
         remain = 0x1000 - (laddr & 0x00000fff);          remain = 0x1000 - (laddr & 0x00000fff);
         for (;;) {          for (;;) {
                 paddr = paging(laddr, crw, pl);                  paddr = paging(laddr, crw, user_mode);
   
                 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;
Line 255  cpu_linear_memory_read(DWORD laddr, DWOR Line 247  cpu_linear_memory_read(DWORD laddr, DWOR
 }  }
   
 void MEMCALL  void MEMCALL
 cpu_linear_memory_write(DWORD laddr, DWORD length, DWORD value)  cpu_linear_memory_write(DWORD laddr, DWORD value, DWORD length, int user_mode)
 {  {
         DWORD paddr;          DWORD paddr;
         DWORD remain;   /* page remain */          DWORD remain;   /* page remain */
         DWORD r;          DWORD r;
         int crw;          int crw = (CPU_PAGE_WRITE|CPU_PAGE_DATA);
         int pl;  
   
         crw = CPU_PAGING_PAGE_WRITE;  
         crw |= CPU_PAGING_PAGE_DATA;  
         pl = (CPU_STAT_CPL == 3);  
   
         /* XXX: 4MB pages... */          /* XXX: 4MB pages... */
         remain = 0x1000 - (laddr & 0x00000fff);          remain = 0x1000 - (laddr & 0x00000fff);
         for (;;) {          for (;;) {
                 paddr = paging(laddr, crw, pl);                  paddr = paging(laddr, crw, user_mode);
   
                 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);                          cpu_memorywrite(paddr, value & 0xff);
                         value >>= 16;  
                         cpu_memorywrite(paddr + 2, 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;
Line 314  cpu_linear_memory_write(DWORD laddr, DWO Line 299  cpu_linear_memory_write(DWORD laddr, DWO
 }  }
   
 void MEMCALL  void MEMCALL
 paging_check(DWORD laddr, DWORD length, int rw)  paging_check(DWORD laddr, DWORD length, int crw, int user_mode)
 {  {
         DWORD paddr;          DWORD paddr;
         DWORD remain;   /* page remain */          DWORD remain;   /* page remain */
         DWORD r;          DWORD r;
         int crw;  
         int pl;  
   
         crw = rw;  
         pl = (CPU_STAT_CPL == 3);  
   
         /* XXX: 4MB pages... */          /* XXX: 4MB pages... */
         remain = 0x1000 - (laddr & 0x00000fff);          remain = 0x1000 - (laddr & 0x00000fff);
         for (;;) {          for (;;) {
                 paddr = paging(laddr, crw, pl);                  paddr = paging(laddr, crw, user_mode);
   
                 r = (remain > length) ? length : remain;                  r = (remain > length) ? length : remain;
   
Line 361  paging(DWORD laddr, int crw, int user_mo Line 341  paging(DWORD laddr, int crw, int user_mo
                 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 410  paging(DWORD laddr, int crw, int user_mo Line 390  paging(DWORD laddr, int crw, int user_mo
                 paddr = (pte & CPU_PTE_BASEADDR_MASK) | (laddr & 0x00000fff);                  paddr = (pte & CPU_PTE_BASEADDR_MASK) | (laddr & 0x00000fff);
         }          }
   
         bit  = crw & CPU_PAGING_PAGE_WRITE;          bit  = crw & CPU_PAGE_WRITE;
         bit |= (pde & pte & (CPU_PTE_WRITABLE|CPU_PTE_USER_MODE));          bit |= (pde & pte & (CPU_PTE_WRITABLE|CPU_PTE_USER_MODE));
         bit |= (user_mode << 3);          bit |= (user_mode << 3);
         bit |= (CPU_CR0 & CPU_CR0_WP) >> 12;          bit |= (CPU_CR0 & CPU_CR0_WP) >> 12;
Line 429  paging(DWORD laddr, int crw, int user_mo Line 409  paging(DWORD laddr, int crw, int user_mo
                 goto pf_exception;                  goto pf_exception;
         }          }
   
         if ((crw & CPU_PAGING_PAGE_WRITE) && !(pte & CPU_PTE_DIRTY)) {          if ((crw & CPU_PAGE_WRITE) && !(pte & CPU_PTE_DIRTY)) {
                 pte |= CPU_PTE_DIRTY;                  pte |= CPU_PTE_DIRTY;
                 cpu_memorywrite_d(pte_addr, pte);                  cpu_memorywrite_d(pte_addr, pte);
         }          }
Line 442  paging(DWORD laddr, int crw, int user_mo Line 422  paging(DWORD laddr, int crw, int user_mo
   
 pf_exception:  pf_exception:
         CPU_CR2 = laddr;          CPU_CR2 = laddr;
         err |= ((crw & CPU_PAGING_PAGE_WRITE) << 1) | (user_mode << 2);          err |= ((crw & CPU_PAGE_WRITE) << 1) | (user_mode << 2);
         EXCEPTION(PF_EXCEPTION, err);          EXCEPTION(PF_EXCEPTION, err);
         return 0;       /* compiler happy */          return 0;       /* compiler happy */
 }  }
Line 522  tlb_init() Line 502  tlb_init()
         tlb_entry_flushes = 0;          tlb_entry_flushes = 0;
 #endif  /* IA32_PROFILE_TLB */  #endif  /* IA32_PROFILE_TLB */
   
         /* XXX プロセッサ種別にしたがって TLB 構成を構築する */  #if CPU_FAMILY == 4
   
         /* とりあえず i486 形式で… */          /* とりあえず i486 形式で… */
         /* combine (I/D) TLB: 4KB Pages, 4-way set associative 32 entries */          /* combine (I/D) TLB: 4KB Pages, 4-way set associative 32 entries */
         ntlb = 1;          ntlb = 1;
         tlb[0].kind = TLB_KIND_COMBINE | TLB_KIND_SMALL;          tlb[0].kind = TLB_KIND_COMBINE | TLB_KIND_SMALL;
         tlb[0].num = 32;          tlb[0].num = 32;
         tlb[0].way = 4;          tlb[0].way = 4;
         tlb[0].idx = tlb[0].num / tlb[0].way;  #endif
   
         for (i = 0; i < ntlb; i++) {          for (i = 0; i < ntlb; i++) {
                   tlb[i].idx = tlb[i].num / tlb[i].way;
   
                 tlb[i].entry = (TLB_ENTRY_T*)calloc(sizeof(TLB_ENTRY_T), tlb[i].num);                  tlb[i].entry = (TLB_ENTRY_T*)calloc(sizeof(TLB_ENTRY_T), tlb[i].num);
                 if (tlb[i].entry == 0) {                  if (tlb[i].entry == 0) {
                         ia32_panic("tlb_init(): can't alloc TLB entry\n");                          ia32_panic("tlb_init(): can't alloc TLB entry\n");
Line 605  tlb_lookup(DWORD laddr, int crw, DWORD*  Line 586  tlb_lookup(DWORD laddr, int crw, DWORD* 
   
         PROFILE_INC(tlb_lookups);          PROFILE_INC(tlb_lookups);
   
         crw &= CPU_PAGING_PAGE_CODE | CPU_PAGING_PAGE_DATA;          crw &= CPU_PAGE_CODE | CPU_PAGE_DATA;
         for (i = 0; i < ntlb; i++) {          for (i = 0; i < ntlb; i++) {
                 if (tlb[i].kind & crw) {                  if (tlb[i].kind & crw) {
                         if (tlb[i].idx == 1) {                          if (tlb[i].idx == 1) {
Line 649  tlb_update(DWORD paddr, DWORD entry, int Line 630  tlb_update(DWORD paddr, DWORD entry, int
   
         PROFILE_INC(tlb_updates);          PROFILE_INC(tlb_updates);
   
         crw &= CPU_PAGING_PAGE_CODE | CPU_PAGING_PAGE_DATA;          crw &= CPU_PAGE_CODE | CPU_PAGE_DATA;
         for (i = 0; i < ntlb; i++) {          for (i = 0; i < ntlb; i++) {
                 if (tlb[i].kind & crw) {                  if (tlb[i].kind & crw) {
                         if (tlb[i].idx == 1) {                          if (tlb[i].idx == 1) {
Line 696  tlb_update(DWORD paddr, DWORD entry, int Line 677  tlb_update(DWORD paddr, DWORD entry, int
         }          }
         __ASSERT(i != ntlb);          __ASSERT(i != ntlb);
 }  }
 #else   /* !IA32_SUPPORT_TLB */  
 void  
 tlb_init()  
 {  
   
         /* nothing to do */  
 }  
   
 void  
 tlb_flush(BOOL allflush)  
 {  
   
         (void)allflush;  
 }  
   
 void  
 tlb_flush_page(DWORD laddr)  
 {  
   
         (void)laddr;  
 }  
 #endif  /* IA32_SUPPORT_TLB */  #endif  /* IA32_SUPPORT_TLB */
Removed from v.1.8  
changed lines
  Added in v.1.10

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