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

Diff for /np2/i386c/ia32/paging.h between versions 1.27 and 1.28

version 1.27, 2011/12/29 13:32:12 version 1.28, 2012/01/08 18:26:10
Line 120  extern "C" { Line 120  extern "C" {
 #define CPU_PTE_WRITABLE        (1 << 1)  #define CPU_PTE_WRITABLE        (1 << 1)
 #define CPU_PTE_PRESENT         (1 << 0)  #define CPU_PTE_PRESENT         (1 << 0)
   
   #define PAGE_SIZE       0x1000
 /*  #define PAGE_MASK       (PAGE_SIZE - 1)
  * linear address memory access function  
  */  
 void MEMCALL cpu_memory_access_la_region(UINT32 address, UINT length, const int ucrw, UINT8 *data);  
 UINT32 MEMCALL laddr2paddr(const UINT32 laddr, const int ucrw);  
 #define laddr_to_paddr(laddr, ucrw) \  
         (!CPU_STAT_PAGING) ? (laddr) : (laddr2paddr((laddr), (ucrw)))  
   
   
 /* ucrw */  /* ucrw */
 #define CPU_PAGE_WRITE          (1 << 0)  #define CPU_PAGE_WRITE          (1 << 0)
Line 142  UINT32 MEMCALL laddr2paddr(const UINT32  Line 135  UINT32 MEMCALL laddr2paddr(const UINT32 
 UINT8 MEMCALL cpu_memory_access_la_RMW_b(UINT32 laddr, UINT32 (CPUCALL *func)(UINT32, void *), void *arg);  UINT8 MEMCALL cpu_memory_access_la_RMW_b(UINT32 laddr, UINT32 (CPUCALL *func)(UINT32, void *), void *arg);
 UINT16 MEMCALL cpu_memory_access_la_RMW_w(UINT32 laddr, UINT32 (CPUCALL *func)(UINT32, void *), void *arg);  UINT16 MEMCALL cpu_memory_access_la_RMW_w(UINT32 laddr, UINT32 (CPUCALL *func)(UINT32, void *), void *arg);
 UINT32 MEMCALL cpu_memory_access_la_RMW_d(UINT32 laddr, UINT32 (CPUCALL *func)(UINT32, void *), void *arg);  UINT32 MEMCALL cpu_memory_access_la_RMW_d(UINT32 laddr, UINT32 (CPUCALL *func)(UINT32, void *), void *arg);
 UINT8 MEMCALL cpu_linear_memory_read_b(UINT32 laddr, const int ucrw);  UINT8 MEMCALL cpu_linear_memory_read_b(UINT32 laddr, int ucrw);
 UINT16 MEMCALL cpu_linear_memory_read_w(UINT32 laddr, const int ucrw);  UINT16 MEMCALL cpu_linear_memory_read_w(UINT32 laddr, int ucrw);
 UINT32 MEMCALL cpu_linear_memory_read_d(UINT32 laddr, const int ucrw);  UINT32 MEMCALL cpu_linear_memory_read_d(UINT32 laddr, int ucrw);
 UINT64 MEMCALL cpu_linear_memory_read_q(UINT32 laddr, const int ucrw);  UINT64 MEMCALL cpu_linear_memory_read_q(UINT32 laddr, int ucrw);
 REG80 MEMCALL cpu_linear_memory_read_f(UINT32 laddr, const int ucrw);  REG80 MEMCALL cpu_linear_memory_read_f(UINT32 laddr, int ucrw);
 void MEMCALL cpu_linear_memory_write_b(UINT32 laddr, UINT8 value, const int user_mode);  void MEMCALL cpu_linear_memory_write_b(UINT32 laddr, UINT8 value, int ucrw);
 void MEMCALL cpu_linear_memory_write_w(UINT32 laddr, UINT16 value, const int user_mode);  void MEMCALL cpu_linear_memory_write_w(UINT32 laddr, UINT16 value, int ucrw);
 void MEMCALL cpu_linear_memory_write_d(UINT32 laddr, UINT32 value, const int user_mode);  void MEMCALL cpu_linear_memory_write_d(UINT32 laddr, UINT32 value, int ucrw);
 void MEMCALL cpu_linear_memory_write_q(UINT32 laddr, UINT64 value, const int user_mode);  void MEMCALL cpu_linear_memory_write_q(UINT32 laddr, UINT64 value, int ucrw);
 void MEMCALL cpu_linear_memory_write_f(UINT32 laddr, const REG80 *value, const int user_mode);  void MEMCALL cpu_linear_memory_write_f(UINT32 laddr, const REG80 *value, int ucrw);
   
 #define cpu_lmemoryread(a,pl) \  
         (!CPU_STAT_PAGING) ? \  
          cpu_memoryread(a) : \  
          cpu_linear_memory_read_b(a,CPU_PAGE_READ_DATA | (pl))  
 #define cpu_lmemoryread_b(a,pl) cpu_lmemoryread(a,pl)  
 #define cpu_lmemoryread_w(a,pl) \  
         (!CPU_STAT_PAGING) ? \  
          cpu_memoryread_w(a) : \  
          cpu_linear_memory_read_w(a,CPU_PAGE_READ_DATA | (pl))  
 #define cpu_lmemoryread_d(a,pl) \  
         (!CPU_STAT_PAGING) ? \  
          cpu_memoryread_d(a) : \  
          cpu_linear_memory_read_d(a,CPU_PAGE_READ_DATA | (pl))  
 #define cpu_lmemoryread_q(a,pl) \  
         (!CPU_STAT_PAGING) ? \  
          cpu_memoryread_q(a) : \  
          cpu_linear_memory_read_q(a,CPU_PAGE_READ_DATA | (pl))  
   
 #define cpu_lmemorywrite(a,v,pl) \  
         (!CPU_STAT_PAGING) ? \  
          cpu_memorywrite(a,v) : cpu_linear_memory_write_b(a,v,pl)  
 #define cpu_lmemorywrite_b(a,v,pl) cpu_lmemorywrite(a,v,pl)  
 #define cpu_lmemorywrite_w(a,v,pl) \  
         (!CPU_STAT_PAGING) ? \  
          cpu_memorywrite_w(a,v) : cpu_linear_memory_write_w(a,v,pl)  
 #define cpu_lmemorywrite_d(a,v,pl) \  
         (!CPU_STAT_PAGING) ? \  
          cpu_memorywrite_d(a,v) : cpu_linear_memory_write_d(a,v,pl)  
 #define cpu_lmemorywrite_q(a,v,pl) \  
         (!CPU_STAT_PAGING) ? \  
          cpu_memorywrite_q(a,v) : cpu_linear_memory_write_q(a,v,pl)  
   
 /*  /*
  * linear address memory access with superviser mode   * linear address memory access function with TLB
  */   */
 #define cpu_kmemoryread(a)      cpu_lmemoryread(a,CPU_MODE_SUPERVISER)  /* RMW */
 #define cpu_kmemoryread_w(a)    cpu_lmemoryread_w(a,CPU_MODE_SUPERVISER)  STATIC_INLINE UINT8 MEMCALL
 #define cpu_kmemoryread_d(a)    cpu_lmemoryread_d(a,CPU_MODE_SUPERVISER)  cpu_lmemory_RMW_b(UINT32 laddr, UINT32 (CPUCALL *func)(UINT32, void *), void *arg)
 #define cpu_kmemorywrite(a,v)   cpu_lmemorywrite(a,v,CPU_MODE_SUPERVISER)  {
 #define cpu_kmemorywrite_w(a,v) cpu_lmemorywrite_w(a,v,CPU_MODE_SUPERVISER)          UINT32 result;
 #define cpu_kmemorywrite_d(a,v) cpu_lmemorywrite_d(a,v,CPU_MODE_SUPERVISER)          UINT8 value;
   
           if (!CPU_STAT_PAGING) {
                   value = cpu_memoryread_b(laddr);
                   result = (*func)(value, arg);
                   cpu_memorywrite_b(laddr, result);
                   return value;
           }
           return cpu_memory_access_la_RMW_b(laddr, func, arg);
   }
   
   STATIC_INLINE UINT16 MEMCALL
   cpu_lmemory_RMW_w(UINT32 laddr, UINT32 (CPUCALL *func)(UINT32, void *), void *arg)
   {
           UINT32 result;
           UINT16 value;
   
           if (!CPU_STAT_PAGING) {
                   value = cpu_memoryread_w(laddr);
                   result = (*func)(value, arg);
                   cpu_memorywrite_w(laddr, result);
                   return value;
           }
           return cpu_memory_access_la_RMW_w(laddr, func, arg);
   }
   
   STATIC_INLINE UINT32 MEMCALL
   cpu_lmemory_RMW_d(UINT32 laddr, UINT32 (CPUCALL *func)(UINT32, void *), void *arg)
   {
           UINT32 result;
           UINT32 value;
   
           if (!CPU_STAT_PAGING) {
                   value = cpu_memoryread_d(laddr);
                   result = (*func)(value, arg);
                   cpu_memorywrite_d(laddr, result);
                   return value;
           }
           return cpu_memory_access_la_RMW_d(laddr, func, arg);
   }
   
   /* read */
   STATIC_INLINE UINT8 MEMCALL
   cpu_lmemoryread_b(UINT32 laddr, int ucrw)
   {
   
           if (!CPU_STAT_PAGING)
                   return cpu_memoryread_b(laddr);
           return cpu_linear_memory_read_b(laddr, ucrw);
   }
   #define cpu_lmemoryread(a,ucrw) cpu_lmemoryread_b((a),(ucrw))
   
   STATIC_INLINE UINT16 MEMCALL
   cpu_lmemoryread_w(UINT32 laddr, int ucrw)
   {
   
           if (!CPU_STAT_PAGING)
                   return cpu_memoryread_w(laddr);
           return cpu_linear_memory_read_w(laddr, ucrw);
   }
   
   STATIC_INLINE UINT32 MEMCALL
   cpu_lmemoryread_d(UINT32 laddr, int ucrw)
   {
   
           if (!CPU_STAT_PAGING)
                   return cpu_memoryread_d(laddr);
           return cpu_linear_memory_read_d(laddr, ucrw);
   }
   
   STATIC_INLINE UINT64
   cpu_lmemoryread_q(UINT32 laddr, int ucrw)
   {
   
           if (!CPU_STAT_PAGING)
                   return cpu_memoryread_q(laddr);
           return cpu_linear_memory_read_q(laddr, ucrw);
   }
   
   STATIC_INLINE REG80
   cpu_lmemoryread_f(UINT32 laddr, int ucrw)
   {
   
           if (!CPU_STAT_PAGING)
                   return cpu_memoryread_f(laddr);
           return cpu_linear_memory_read_f(laddr, ucrw);
   }
   
   /* write */
   STATIC_INLINE void MEMCALL
   cpu_lmemorywrite_b(UINT32 laddr, UINT8 value, int ucrw)
   {
   
           if (!CPU_STAT_PAGING) {
                   cpu_memorywrite_b(laddr, value);
                   return;
           }
           cpu_linear_memory_write_b(laddr, value, ucrw);
   }
   #define cpu_lmemorywrite(a,v,ucrw) cpu_lmemorywrite_b((a),(v),(ucrw))
   
   STATIC_INLINE void MEMCALL
   cpu_lmemorywrite_w(UINT32 laddr, UINT16 value, int ucrw)
   {
   
           if (!CPU_STAT_PAGING) {
                   cpu_memorywrite_w(laddr, value);
                   return;
           }
           cpu_linear_memory_write_w(laddr, value, ucrw);
   }
   
   STATIC_INLINE void MEMCALL
   cpu_lmemorywrite_d(UINT32 laddr, UINT32 value, int ucrw)
   {
   
           if (!CPU_STAT_PAGING) {
                   cpu_memorywrite_d(laddr, value);
                   return;
           }
           cpu_linear_memory_write_d(laddr, value, ucrw);
   }
   
   STATIC_INLINE void MEMCALL
   cpu_lmemorywrite_q(UINT32 laddr, UINT64 value, int ucrw)
   {
   
           if (!CPU_STAT_PAGING) {
                   cpu_memorywrite_q(laddr, value);
                   return;
           }
           cpu_linear_memory_write_q(laddr, value, ucrw);
   }
   
   STATIC_INLINE void MEMCALL
   cpu_lmemorywrite_f(UINT32 laddr, const REG80 *value, int ucrw)
   {
   
           if (!CPU_STAT_PAGING) {
                   cpu_memorywrite_f(laddr, value);
                   return;
           }
           cpu_linear_memory_write_f(laddr, value, ucrw);
   }
   
   
 /*  /*
  * TLB function   * linear address memory access with superviser mode
  */   */
 typedef struct {  #define cpu_kmemoryread(a) \
         UINT32  tag;    /* linear address */          cpu_lmemoryread((a),CPU_PAGE_READ_DATA|CPU_MODE_SUPERVISER)
 #define TLB_ENTRY_TAG_VALID             (1 << 0)  #define cpu_kmemoryread_w(a) \
 /*      pde & pte & CPU_PTE_WRITABLE    (1 << 1)        */          cpu_lmemoryread_w((a),CPU_PAGE_READ_DATA|CPU_MODE_SUPERVISER)
 /*      pde & pte & CPU_PTE_USER_MODE   (1 << 2)        */  #define cpu_kmemoryread_d(a) \
 #define TLB_ENTRY_TAG_DIRTY             CPU_PTE_DIRTY           /* (1 << 6) */          cpu_lmemoryread_d((a),CPU_PAGE_READ_DATA|CPU_MODE_SUPERVISER)
 #define TLB_ENTRY_TAG_GLOBAL            CPU_PTE_GLOBAL_PAGE     /* (1 << 8) */  #define cpu_kmemorywrite(a,v) \
 #define TLB_ENTRY_TAG_MAX_SHIFT         12          cpu_lmemorywrite((a),(v),CPU_PAGE_WRITE_DATA|CPU_MODE_SUPERVISER)
   #define cpu_kmemorywrite_w(a,v) \
           cpu_lmemorywrite_w((a),(v),CPU_PAGE_WRITE_DATA|CPU_MODE_SUPERVISER)
   #define cpu_kmemorywrite_d(a,v) \
           cpu_lmemorywrite_d((a),(v),CPU_PAGE_WRITE_DATA|CPU_MODE_SUPERVISER)
   
         UINT32  paddr;  /* physical address */  /*
    * linear address memory access function
    */
   void MEMCALL cpu_memory_access_la_region(UINT32 address, UINT length, int ucrw, UINT8 *data);
   UINT32 MEMCALL laddr2paddr(UINT32 laddr, int ucrw);
   
         UINT8   *memp;  /* shortcut for pre-fetch queue */  STATIC_INLINE UINT32 MEMCALL
 } TLB_ENTRY_T;  laddr_to_paddr(UINT32 laddr, int ucrw)
   {
   
           if (!CPU_STAT_PAGING)
                   return laddr;
           return laddr2paddr(laddr, ucrw);
   }
   
   /*
    * TLB function
    */
   struct tlb_entry;
 void tlb_init(void);  void tlb_init(void);
 void MEMCALL tlb_flush(BOOL allflush);  void MEMCALL tlb_flush(BOOL allflush);
 void MEMCALL tlb_flush_page(UINT32 laddr);  void MEMCALL tlb_flush_page(UINT32 laddr);
 TLB_ENTRY_T* MEMCALL tlb_lookup(const UINT32 laddr, const int ucrw);  struct tlb_entry *MEMCALL tlb_lookup(UINT32 laddr, int ucrw);
   
 #ifdef __cplusplus  #ifdef __cplusplus
 }  }
Removed from v.1.27  
changed lines
  Added in v.1.28

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