[BACK]Return to pmap.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / arch / arm / arm32

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/arch/arm/arm32/pmap.c between version 1.261 and 1.262

version 1.261, 2013/07/03 15:30:24 version 1.262, 2013/07/03 21:37:35
Line 1496  static int
Line 1496  static int
 pmap_l2ptp_ctor(void *arg, void *v, int flags)  pmap_l2ptp_ctor(void *arg, void *v, int flags)
 {  {
 #ifndef PMAP_INCLUDE_PTE_SYNC  #ifndef PMAP_INCLUDE_PTE_SYNC
         struct l2_bucket *l2b;  
         pt_entry_t *ptep, pte;  
         vaddr_t va = (vaddr_t)v & ~PGOFSET;          vaddr_t va = (vaddr_t)v & ~PGOFSET;
   
         /*          /*
Line 1508  pmap_l2ptp_ctor(void *arg, void *v, int 
Line 1506  pmap_l2ptp_ctor(void *arg, void *v, int 
          * page tables, we simply fix up the cache-mode here if it's not           * page tables, we simply fix up the cache-mode here if it's not
          * correct.           * correct.
          */           */
         l2b = pmap_get_l2_bucket(pmap_kernel(), va);          struct l2_bucket * const l2b = pmap_get_l2_bucket(pmap_kernel(), va);
         KDASSERT(l2b != NULL);          KDASSERT(l2b != NULL);
         ptep = &l2b->l2b_kva[l2pte_index(va)];          pt_entry_t *ptep = &l2b->l2b_kva[l2pte_index(va)];
         pte = *ptep;          pt_entry_t opte = *ptep;
   
         if ((pte & L2_S_CACHE_MASK) != pte_l2_s_cache_mode_pt) {          if ((opte & L2_S_CACHE_MASK) != pte_l2_s_cache_mode_pt) {
                 /*                  /*
                  * Page tables must have the cache-mode set to Write-Thru.                   * Page tables must have the cache-mode set to Write-Thru.
                  */                   */
                 *ptep = (pte & ~L2_S_CACHE_MASK) | pte_l2_s_cache_mode_pt;                  const pt_entry_t npte = (pte & ~L2_S_CACHE_MASK)
                       | pte_l2_s_cache_mode_pt;
                   l2pte_set(ptep, npte, opte);
                 PTE_SYNC(ptep);                  PTE_SYNC(ptep);
                 cpu_tlb_flushD_SE(va);                  cpu_tlb_flushD_SE(va);
                 cpu_cpwait();                  cpu_cpwait();
Line 1556  pmap_pinit(pmap_t pm)
Line 1556  pmap_pinit(pmap_t pm)
                  * Map the vector page.                   * Map the vector page.
                  */                   */
                 pmap_enter(pm, vector_page, systempage.pv_pa,                  pmap_enter(pm, vector_page, systempage.pv_pa,
                     VM_PROT_READ, VM_PROT_READ | PMAP_WIRED);                      VM_PROT_READ | VM_PROT_EXECUTE,
                       VM_PROT_READ | VM_PROT_EXECUTE | PMAP_WIRED);
                 pmap_update(pm);                  pmap_update(pm);
   
                 pm->pm_pl1vec = pmap_l1_kva(pm) + L1_IDX(vector_page);                  pm->pm_pl1vec = pmap_l1_kva(pm) + L1_IDX(vector_page);
Line 1730  pmap_vac_me_user(struct vm_page_md *md, 
Line 1731  pmap_vac_me_user(struct vm_page_md *md, 
 {  {
         pmap_t kpmap = pmap_kernel();          pmap_t kpmap = pmap_kernel();
         struct pv_entry *pv, *npv = NULL;          struct pv_entry *pv, *npv = NULL;
         struct l2_bucket *l2b;  
         pt_entry_t *ptep, pte;  
         u_int entries = 0;          u_int entries = 0;
         u_int writable = 0;          u_int writable = 0;
         u_int cacheable_entries = 0;          u_int cacheable_entries = 0;
Line 1783  pmap_vac_me_user(struct vm_page_md *md, 
Line 1782  pmap_vac_me_user(struct vm_page_md *md, 
   
                         pv->pv_flags |= PVF_NC;                          pv->pv_flags |= PVF_NC;
   
                         l2b = pmap_get_l2_bucket(pv->pv_pmap, pv->pv_va);                          struct l2_bucket * const l2b
                               = pmap_get_l2_bucket(pv->pv_pmap, pv->pv_va);
                         KDASSERT(l2b != NULL);                          KDASSERT(l2b != NULL);
                         ptep = &l2b->l2b_kva[l2pte_index(pv->pv_va)];                          pt_entry_t * const ptep
                         pte = *ptep & ~L2_S_CACHE_MASK;                              = &l2b->l2b_kva[l2pte_index(pv->pv_va)];
                           const pt_entry_t opte = *ptep;
                           pt_entry_t npte = opte & ~L2_S_CACHE_MASK;
   
                         if ((va != pv->pv_va || pm != pv->pv_pmap)                          if ((va != pv->pv_va || pm != pv->pv_pmap)
                             && l2pte_valid(pte)) {                              && l2pte_valid(npte)) {
 #ifdef PMAP_CACHE_VIVT  #ifdef PMAP_CACHE_VIVT
                                 pmap_cache_wbinv_page(pv->pv_pmap, pv->pv_va,                                  pmap_cache_wbinv_page(pv->pv_pmap, pv->pv_va,
                                     true, pv->pv_flags);                                      true, pv->pv_flags);
Line 1798  pmap_vac_me_user(struct vm_page_md *md, 
Line 1800  pmap_vac_me_user(struct vm_page_md *md, 
                                     pv->pv_flags);                                      pv->pv_flags);
                         }                          }
   
                         *ptep = pte;                          l2pte_set(ptep, npte, opte);
                         PTE_SYNC_CURRENT(pv->pv_pmap, ptep);                          PTE_SYNC_CURRENT(pv->pv_pmap, ptep);
                 }                  }
                 cpu_cpwait();                  cpu_cpwait();
Line 1815  pmap_vac_me_user(struct vm_page_md *md, 
Line 1817  pmap_vac_me_user(struct vm_page_md *md, 
   
                         pv->pv_flags &= ~PVF_NC;                          pv->pv_flags &= ~PVF_NC;
   
                         l2b = pmap_get_l2_bucket(pv->pv_pmap, pv->pv_va);                          struct l2_bucket * const l2b
                               = pmap_get_l2_bucket(pv->pv_pmap, pv->pv_va);
                         KDASSERT(l2b != NULL);                          KDASSERT(l2b != NULL);
                         ptep = &l2b->l2b_kva[l2pte_index(pv->pv_va)];                          pt_entry_t * const ptep
                         pte = (*ptep & ~L2_S_CACHE_MASK) | pte_l2_s_cache_mode;                              = &l2b->l2b_kva[l2pte_index(pv->pv_va)];
                           const pt_entry_t opte = *ptep;
                           pt_entry_t npte = (opte & ~L2_S_CACHE_MASK)
                               | pte_l2_s_cache_mode;
   
                         if (l2pte_valid(pte)) {                          if (l2pte_valid(opte)) {
                                 pmap_tlb_flush_SE(pv->pv_pmap, pv->pv_va,                                  pmap_tlb_flush_SE(pv->pv_pmap, pv->pv_va,
                                     pv->pv_flags);                                      pv->pv_flags);
                         }                          }
   
                         *ptep = pte;                          l2pte_set(ptep, npte, opte);
                         PTE_SYNC_CURRENT(pv->pv_pmap, ptep);                          PTE_SYNC_CURRENT(pv->pv_pmap, ptep);
                 }                  }
         }          }
Line 1839  pmap_vac_me_harder(struct vm_page_md *md
Line 1845  pmap_vac_me_harder(struct vm_page_md *md
         struct pv_entry *pv;          struct pv_entry *pv;
         vaddr_t tst_mask;          vaddr_t tst_mask;
         bool bad_alias;          bool bad_alias;
         struct l2_bucket *l2b;  
         pt_entry_t *ptep, pte, opte;  
         const u_int          const u_int
             rw_mappings = md->urw_mappings + md->krw_mappings,              rw_mappings = md->urw_mappings + md->krw_mappings,
             ro_mappings = md->uro_mappings + md->kro_mappings;              ro_mappings = md->uro_mappings + md->kro_mappings;
Line 2098  pmap_vac_me_harder(struct vm_page_md *md
Line 2102  pmap_vac_me_harder(struct vm_page_md *md
          * Turn cacheing on/off for all pages.           * Turn cacheing on/off for all pages.
          */           */
         SLIST_FOREACH(pv, &md->pvh_list, pv_link) {          SLIST_FOREACH(pv, &md->pvh_list, pv_link) {
                 l2b = pmap_get_l2_bucket(pv->pv_pmap, pv->pv_va);                  struct l2_bucket * const l2b = pmap_get_l2_bucket(pv->pv_pmap,
                       pv->pv_va);
                 KDASSERT(l2b != NULL);                  KDASSERT(l2b != NULL);
                 ptep = &l2b->l2b_kva[l2pte_index(pv->pv_va)];                  pt_entry_t * const ptep = &l2b->l2b_kva[l2pte_index(pv->pv_va)];
                 opte = *ptep;                  const pt_entry_t opte = *ptep;
                 pte = opte & ~L2_S_CACHE_MASK;                  pt_entry_t npte = opte & ~L2_S_CACHE_MASK;
                 if (bad_alias) {                  if (bad_alias) {
                         pv->pv_flags |= PVF_NC;                          pv->pv_flags |= PVF_NC;
                 } else {                  } else {
                         pv->pv_flags &= ~PVF_NC;                          pv->pv_flags &= ~PVF_NC;
                         pte |= pte_l2_s_cache_mode;                          npte |= pte_l2_s_cache_mode;
                 }                  }
   
                 if (opte == pte)        /* only update is there's a change */                  if (opte == npte)       /* only update is there's a change */
                         continue;                          continue;
   
                 if (l2pte_valid(pte)) {                  if (l2pte_valid(npte)) {
                         pmap_tlb_flush_SE(pv->pv_pmap, pv->pv_va,                          pmap_tlb_flush_SE(pv->pv_pmap, pv->pv_va, pv->pv_flags);
                             pv->pv_flags);  
                 }                  }
   
                 *ptep = pte;                  l2pte_set(ptep, npte, opte);
                 PTE_SYNC_CURRENT(pv->pv_pmap, ptep);                  PTE_SYNC_CURRENT(pv->pv_pmap, ptep);
         }          }
 }  }
Line 2133  pmap_vac_me_harder(struct vm_page_md *md
Line 2137  pmap_vac_me_harder(struct vm_page_md *md
 static void  static void
 pmap_clearbit(struct vm_page_md *md, paddr_t pa, u_int maskbits)  pmap_clearbit(struct vm_page_md *md, paddr_t pa, u_int maskbits)
 {  {
         struct l2_bucket *l2b;  
         struct pv_entry *pv;          struct pv_entry *pv;
         pt_entry_t *ptep, npte, opte;  
         pmap_t pm;          pmap_t pm;
         vaddr_t va;          vaddr_t va;
         u_int oflags;          u_int oflags;
 #ifdef PMAP_CACHE_VIPT  #ifdef PMAP_CACHE_VIPT
         const bool want_syncicache = PV_IS_EXEC_P(md->pvh_attrs);          const bool want_syncicache = PV_IS_EXEC_P(md->pvh_attrs);
         bool need_syncicache = false;  
         bool did_syncicache = false;  
         bool need_vac_me_harder = false;          bool need_vac_me_harder = false;
           bool need_syncicache = false;
 #endif  #endif
   
         NPDEBUG(PDB_BITS,          NPDEBUG(PDB_BITS,
Line 2155  pmap_clearbit(struct vm_page_md *md, pad
Line 2156  pmap_clearbit(struct vm_page_md *md, pad
          * If we might want to sync the I-cache and we've modified it,           * If we might want to sync the I-cache and we've modified it,
          * then we know we definitely need to sync or discard it.           * then we know we definitely need to sync or discard it.
          */           */
         if (want_syncicache)          if (want_syncicache) {
                 need_syncicache = md->pvh_attrs & PVF_MOD;                  need_syncicache = md->pvh_attrs & PVF_MOD;
           }
 #endif  #endif
         /*          /*
          * Clear saved attributes (modify, reference)           * Clear saved attributes (modify, reference)
Line 2164  pmap_clearbit(struct vm_page_md *md, pad
Line 2166  pmap_clearbit(struct vm_page_md *md, pad
         md->pvh_attrs &= ~(maskbits & (PVF_MOD | PVF_REF));          md->pvh_attrs &= ~(maskbits & (PVF_MOD | PVF_REF));
   
         if (SLIST_EMPTY(&md->pvh_list)) {          if (SLIST_EMPTY(&md->pvh_list)) {
 #ifdef PMAP_CACHE_VIPT  #if defined(PMAP_CACHE_VIPT)
                 if (need_syncicache) {                  if (need_syncicache) {
                         /*                          /*
                          * No one has it mapped, so just discard it.  The next                           * No one has it mapped, so just discard it.  The next
Line 2193  pmap_clearbit(struct vm_page_md *md, pad
Line 2195  pmap_clearbit(struct vm_page_md *md, pad
   
                 pmap_acquire_pmap_lock(pm);                  pmap_acquire_pmap_lock(pm);
   
                 l2b = pmap_get_l2_bucket(pm, va);                  struct l2_bucket * const l2b = pmap_get_l2_bucket(pm, va);
                 KDASSERT(l2b != NULL);                  KDASSERT(l2b != NULL);
   
                 ptep = &l2b->l2b_kva[l2pte_index(va)];                  pt_entry_t * const ptep = &l2b->l2b_kva[l2pte_index(va)];
                 npte = opte = *ptep;                  const pt_entry_t opte = *ptep;
                   pt_entry_t npte = opte;
   
                 NPDEBUG(PDB_BITS,                  NPDEBUG(PDB_BITS,
                     printf(                      printf(
Line 2292  pmap_clearbit(struct vm_page_md *md, pad
Line 2295  pmap_clearbit(struct vm_page_md *md, pad
                 }                  }
   
                 if (npte != opte) {                  if (npte != opte) {
                         *ptep = npte;                          l2pte_set(ptep, npte, opte);
                         PTE_SYNC(ptep);                          PTE_SYNC(ptep);
   
                         /* Flush the TLB entry if a current pmap. */                          /* Flush the TLB entry if a current pmap. */
                         pmap_tlb_flush_SE(pm, pv->pv_va, oflags);                          pmap_tlb_flush_SE(pm, pv->pv_va, oflags);
                 }                  }
Line 2309  pmap_clearbit(struct vm_page_md *md, pad
Line 2313  pmap_clearbit(struct vm_page_md *md, pad
         /*          /*
          * If we need to sync the I-cache and we haven't done it yet, do it.           * If we need to sync the I-cache and we haven't done it yet, do it.
          */           */
         if (need_syncicache && !did_syncicache) {          if (need_syncicache) {
                 pmap_syncicache_page(md, pa);                  pmap_syncicache_page(md, pa);
                 PMAPCOUNT(exec_synced_clearbit);                  PMAPCOUNT(exec_synced_clearbit);
         }          }
   
         /*          /*
          * If we are changing this to read-only, we need to call vac_me_harder           * If we are changing this to read-only, we need to call vac_me_harder
          * so we can change all the read-only pages to cacheable.  We pretend           * so we can change all the read-only pages to cacheable.  We pretend
Line 2430  pmap_syncicache_page(struct vm_page_md *
Line 2435  pmap_syncicache_page(struct vm_page_md *
         /*          /*
          * Set up a PTE with the right coloring to flush existing cache lines.           * Set up a PTE with the right coloring to flush existing cache lines.
          */           */
         *ptep = L2_S_PROTO |          const pt_entry_t npte = L2_S_PROTO |
             pa              pa
             | L2_S_PROT(PTE_KERNEL, VM_PROT_READ|VM_PROT_WRITE)              | L2_S_PROT(PTE_KERNEL, VM_PROT_READ|VM_PROT_WRITE)
             | pte_l2_s_cache_mode;              | pte_l2_s_cache_mode;
           l2pte_set(ptep, npte, 0);
         PTE_SYNC(ptep);          PTE_SYNC(ptep);
   
         /*          /*
Line 2443  pmap_syncicache_page(struct vm_page_md *
Line 2449  pmap_syncicache_page(struct vm_page_md *
         /*          /*
          * Unmap the page.           * Unmap the page.
          */           */
         *ptep = 0;          l2pte_reset(ptep);
         PTE_SYNC(ptep);          PTE_SYNC(ptep);
         pmap_tlb_flush_SE(pmap_kernel(), cdstp + va_offset, PVF_REF | PVF_EXEC);          pmap_tlb_flush_SE(pmap_kernel(), cdstp + va_offset, PVF_REF | PVF_EXEC);
   
Line 2510  pmap_flush_page(struct vm_page_md *md, p
Line 2516  pmap_flush_page(struct vm_page_md *md, p
         for (; va_offset <= end_va; va_offset += PAGE_SIZE) {          for (; va_offset <= end_va; va_offset += PAGE_SIZE) {
                 const size_t pte_offset = va_offset >> PGSHIFT;                  const size_t pte_offset = va_offset >> PGSHIFT;
                 pt_entry_t * const ptep = &cdst_pte[pte_offset];                  pt_entry_t * const ptep = &cdst_pte[pte_offset];
                 const pt_entry_t oldpte = *ptep;                  const pt_entry_t opte = *ptep;
   
                 if (flush == PMAP_FLUSH_SECONDARY                  if (flush == PMAP_FLUSH_SECONDARY
                     && va_offset == (md->pvh_attrs & arm_cache_prefer_mask))                      && va_offset == (md->pvh_attrs & arm_cache_prefer_mask))
Line 2522  pmap_flush_page(struct vm_page_md *md, p
Line 2528  pmap_flush_page(struct vm_page_md *md, p
                  * Set up a PTE with the right coloring to flush                   * Set up a PTE with the right coloring to flush
                  * existing cache entries.                   * existing cache entries.
                  */                   */
                 *ptep = L2_S_PROTO                  const pt_entry_t npte = L2_S_PROTO
                     | pa                      | pa
                     | L2_S_PROT(PTE_KERNEL, VM_PROT_READ|VM_PROT_WRITE)                      | L2_S_PROT(PTE_KERNEL, VM_PROT_READ|VM_PROT_WRITE)
                     | pte_l2_s_cache_mode;                      | pte_l2_s_cache_mode;
                   l2pte_set(ptep, npte, opte);
                 PTE_SYNC(ptep);                  PTE_SYNC(ptep);
   
                 /*                  /*
                  * Flush it.                   * Flush it.  Make sure to flush secondary cache too since
                    * bus_dma will ignore uncached pages.
                  */                   */
                 vaddr_t va = cdstp + va_offset;                  vaddr_t va = cdstp + va_offset;
                 if (scache_line_size != 0) {                  if (scache_line_size != 0) {
Line 2553  pmap_flush_page(struct vm_page_md *md, p
Line 2561  pmap_flush_page(struct vm_page_md *md, p
                  * pmap_zero_page or pmap_copy_page which was already using                   * pmap_zero_page or pmap_copy_page which was already using
                  * this pte.                   * this pte.
                  */                   */
                 *ptep = oldpte;                  l2pte_set(ptep, opte, npte);
                 PTE_SYNC(ptep);                  PTE_SYNC(ptep);
                 pmap_tlb_flush_SE(pmap_kernel(), cdstp + va_offset,                  pmap_tlb_flush_SE(pmap_kernel(), cdstp + va_offset,
                     PVF_REF | PVF_EXEC);                      PVF_REF | PVF_EXEC);
Line 2665  pmap_page_remove(struct vm_page_md *md, 
Line 2673  pmap_page_remove(struct vm_page_md *md, 
                 /*                  /*
                  * Invalidate the PTEs.                   * Invalidate the PTEs.
                  */                   */
                 *ptep = 0;                  l2pte_reset(ptep);
                 PTE_SYNC_CURRENT(pm, ptep);                  PTE_SYNC_CURRENT(pm, ptep);
                 pmap_free_l2_bucket(pm, l2b, 1);                  pmap_free_l2_bucket(pm, l2b, 1);
   
Line 2775  pmap_enter(pmap_t pm, vaddr_t va, paddr_
Line 2783  pmap_enter(pmap_t pm, vaddr_t va, paddr_
         struct l2_bucket *l2b;          struct l2_bucket *l2b;
         struct vm_page *pg, *opg;          struct vm_page *pg, *opg;
         struct pv_entry *pv;          struct pv_entry *pv;
         pt_entry_t *ptep, npte, opte;  
         u_int nflags;          u_int nflags;
         u_int oflags;          u_int oflags;
 #ifdef ARM_HAS_VBAR  #ifdef ARM_HAS_VBAR
Line 2820  pmap_enter(pmap_t pm, vaddr_t va, paddr_
Line 2827  pmap_enter(pmap_t pm, vaddr_t va, paddr_
                 }                  }
                 panic("pmap_enter: failed to allocate L2 bucket");                  panic("pmap_enter: failed to allocate L2 bucket");
         }          }
         ptep = &l2b->l2b_kva[l2pte_index(va)];          pt_entry_t *ptep = &l2b->l2b_kva[l2pte_index(va)];
         opte = *ptep;          const pt_entry_t opte = *ptep;
         npte = pa;          pt_entry_t npte = pa;
         oflags = 0;          oflags = 0;
   
         if (opte) {          if (opte) {
Line 3021  pmap_enter(pmap_t pm, vaddr_t va, paddr_
Line 3028  pmap_enter(pmap_t pm, vaddr_t va, paddr_
         if (npte != opte) {          if (npte != opte) {
                 bool is_cached = pmap_is_cached(pm);                  bool is_cached = pmap_is_cached(pm);
   
                 *ptep = npte;                  l2pte_set(ptep, npte, opte);
                 PTE_SYNC(ptep);                  PTE_SYNC(ptep);
                 if (is_cached) {                  if (is_cached) {
                         /*                          /*
Line 3104  pmap_enter(pmap_t pm, vaddr_t va, paddr_
Line 3111  pmap_enter(pmap_t pm, vaddr_t va, paddr_
 void  void
 pmap_remove(pmap_t pm, vaddr_t sva, vaddr_t eva)  pmap_remove(pmap_t pm, vaddr_t sva, vaddr_t eva)
 {  {
         struct l2_bucket *l2b;  
         vaddr_t next_bucket;          vaddr_t next_bucket;
         pt_entry_t *ptep;  
         u_int cleanlist_idx, total, cnt;          u_int cleanlist_idx, total, cnt;
         struct {          struct {
                 vaddr_t va;                  vaddr_t va;
Line 3139  pmap_remove(pmap_t pm, vaddr_t sva, vadd
Line 3144  pmap_remove(pmap_t pm, vaddr_t sva, vadd
                 if (next_bucket > eva)                  if (next_bucket > eva)
                         next_bucket = eva;                          next_bucket = eva;
   
                 l2b = pmap_get_l2_bucket(pm, sva);                  struct l2_bucket * const l2b = pmap_get_l2_bucket(pm, sva);
                 if (l2b == NULL) {                  if (l2b == NULL) {
                         sva = next_bucket;                          sva = next_bucket;
                         continue;                          continue;
                 }                  }
   
                 ptep = &l2b->l2b_kva[l2pte_index(sva)];                  pt_entry_t *ptep = &l2b->l2b_kva[l2pte_index(sva)];
   
                 for (mappings = 0; sva < next_bucket; sva += PAGE_SIZE, ptep++){  
                         struct vm_page *pg;  
                         pt_entry_t pte;  
                         paddr_t pa;  
   
                         pte = *ptep;                  for (mappings = 0;
                        sva < next_bucket;
                        sva += PAGE_SIZE, ptep += PAGE_SIZE / L2_S_SIZE) {
                           pt_entry_t opte = *ptep;
   
                         if (pte == 0) {                          if (opte == 0) {
                                 /* Nothing here, move along */                                  /* Nothing here, move along */
                                 continue;                                  continue;
                         }                          }
   
                         pa = l2pte_pa(pte);  
                         u_int flags = PVF_REF;                          u_int flags = PVF_REF;
                           paddr_t pa = l2pte_pa(opte);
                           struct vm_page * const pg = PHYS_TO_VM_PAGE(pa);
   
                         /*                          /*
                          * Update flags. In a number of circumstances,                           * Update flags. In a number of circumstances,
                          * we could cluster a lot of these and do a                           * we could cluster a lot of these and do a
                          * number of sequential pages in one go.                           * number of sequential pages in one go.
                          */                           */
                         if ((pg = PHYS_TO_VM_PAGE(pa)) != NULL) {                          if (pg != NULL) {
                                 struct vm_page_md *md = VM_PAGE_TO_MD(pg);                                  struct vm_page_md *md = VM_PAGE_TO_MD(pg);
                                 struct pv_entry *pv;                                  struct pv_entry *pv;
   
Line 3185  pmap_remove(pmap_t pm, vaddr_t sva, vadd
Line 3189  pmap_remove(pmap_t pm, vaddr_t sva, vadd
                         }                          }
                         mappings++;                          mappings++;
   
                         if (!l2pte_valid(pte)) {                          if (!l2pte_valid(opte)) {
                                 /*                                  /*
                                  * Ref/Mod emulation is still active for this                                   * Ref/Mod emulation is still active for this
                                  * mapping, therefore it is has not yet been                                   * mapping, therefore it is has not yet been
                                  * accessed. No need to frob the cache/tlb.                                   * accessed. No need to frob the cache/tlb.
                                  */                                   */
                                 *ptep = 0;                                  l2pte_reset(ptep);
                                 PTE_SYNC_CURRENT(pm, ptep);                                  PTE_SYNC_CURRENT(pm, ptep);
                                 continue;                                  continue;
                         }                          }
Line 3216  pmap_remove(pmap_t pm, vaddr_t sva, vadd
Line 3220  pmap_remove(pmap_t pm, vaddr_t sva, vadd
                                  */                                   */
                                 for (cnt = 0;                                  for (cnt = 0;
                                      cnt < PMAP_REMOVE_CLEAN_LIST_SIZE; cnt++) {                                       cnt < PMAP_REMOVE_CLEAN_LIST_SIZE; cnt++) {
                                         *cleanlist[cnt].ptep = 0;                                          l2pte_reset(cleanlist[cnt].ptep);
                                         PTE_SYNC(cleanlist[cnt].ptep);                                          PTE_SYNC(cleanlist[cnt].ptep);
                                 }                                  }
                                 *ptep = 0;                                  l2pte_reset(ptep);
                                 PTE_SYNC(ptep);                                  PTE_SYNC(ptep);
                                 cleanlist_idx++;                                  cleanlist_idx++;
                                 pm->pm_remove_all = true;                                  pm->pm_remove_all = true;
                         } else {                          } else {
                                 *ptep = 0;                                  l2pte_reset(ptep);
                                 PTE_SYNC(ptep);                                  PTE_SYNC(ptep);
                                 if (pm->pm_remove_all == false) {                                  if (pm->pm_remove_all == false) {
                                         pmap_tlb_flush_SE(pm, sva, flags);                                          pmap_tlb_flush_SE(pm, sva, flags);
Line 3249  pmap_remove(pmap_t pm, vaddr_t sva, vadd
Line 3253  pmap_remove(pmap_t pm, vaddr_t sva, vadd
                                         pmap_tlb_flush_SE(pm, clva,                                          pmap_tlb_flush_SE(pm, clva,
                                             PVF_REF | flags);                                              PVF_REF | flags);
                                 }                                  }
                                 *cleanlist[cnt].ptep = 0;                                  l2pte_reset(cleanlist[cnt].ptep);
                                 PTE_SYNC_CURRENT(pm, cleanlist[cnt].ptep);                                  PTE_SYNC_CURRENT(pm, cleanlist[cnt].ptep);
                         }                          }
   
Line 3323  pmap_kremove_pg(struct vm_page *pg, vadd
Line 3327  pmap_kremove_pg(struct vm_page *pg, vadd
 void  void
 pmap_kenter_pa(vaddr_t va, paddr_t pa, vm_prot_t prot, u_int flags)  pmap_kenter_pa(vaddr_t va, paddr_t pa, vm_prot_t prot, u_int flags)
 {  {
         struct l2_bucket *l2b;  
         pt_entry_t *ptep, opte;  
 #ifdef PMAP_CACHE_VIVT  #ifdef PMAP_CACHE_VIVT
         struct vm_page *pg = (flags & PMAP_KMPAGE) ? PHYS_TO_VM_PAGE(pa) : NULL;          struct vm_page *pg = (flags & PMAP_KMPAGE) ? PHYS_TO_VM_PAGE(pa) : NULL;
 #endif  #endif
Line 3339  pmap_kenter_pa(vaddr_t va, paddr_t pa, v
Line 3341  pmap_kenter_pa(vaddr_t va, paddr_t pa, v
             printf("pmap_kenter_pa: va 0x%08lx, pa 0x%08lx, prot 0x%x\n",              printf("pmap_kenter_pa: va 0x%08lx, pa 0x%08lx, prot 0x%x\n",
             va, pa, prot));              va, pa, prot));
   
         l2b = pmap_get_l2_bucket(pmap_kernel(), va);          struct l2_bucket * const l2b = pmap_get_l2_bucket(pmap_kernel(), va);
         KDASSERT(l2b != NULL);          KDASSERT(l2b != NULL);
   
         ptep = &l2b->l2b_kva[l2pte_index(va)];          pt_entry_t * const ptep = &l2b->l2b_kva[l2pte_index(va)];
         opte = *ptep;          const pt_entry_t opte = *ptep;
   
         if (opte == 0) {          if (opte == 0) {
                 PMAPCOUNT(kenter_mappings);                  PMAPCOUNT(kenter_mappings);
Line 3371  pmap_kenter_pa(vaddr_t va, paddr_t pa, v
Line 3373  pmap_kenter_pa(vaddr_t va, paddr_t pa, v
                 }                  }
         }          }
   
         *ptep = L2_S_PROTO | pa | L2_S_PROT(PTE_KERNEL, prot)          const pt_entry_t npte = L2_S_PROTO | pa | L2_S_PROT(PTE_KERNEL, prot)
             | ((flags & PMAP_NOCACHE) ? 0 : pte_l2_s_cache_mode);              | ((flags & PMAP_NOCACHE) ? 0 : pte_l2_s_cache_mode);
           l2pte_set(ptep, npte, opte);
         PTE_SYNC(ptep);          PTE_SYNC(ptep);
   
         if (pg) {          if (pg) {
Line 3437  pmap_kenter_pa(vaddr_t va, paddr_t pa, v
Line 3440  pmap_kenter_pa(vaddr_t va, paddr_t pa, v
 void  void
 pmap_kremove(vaddr_t va, vsize_t len)  pmap_kremove(vaddr_t va, vsize_t len)
 {  {
         struct l2_bucket *l2b;  
         pt_entry_t *ptep, *sptep, opte;  
         vaddr_t next_bucket, eva;          vaddr_t next_bucket, eva;
         u_int mappings;          u_int mappings;
         struct vm_page *opg;  
   
         PMAPCOUNT(kenter_unmappings);          PMAPCOUNT(kenter_unmappings);
   
Line 3455  pmap_kremove(vaddr_t va, vsize_t len)
Line 3455  pmap_kremove(vaddr_t va, vsize_t len)
                 if (next_bucket > eva)                  if (next_bucket > eva)
                         next_bucket = eva;                          next_bucket = eva;
   
                 l2b = pmap_get_l2_bucket(pmap_kernel(), va);                  struct l2_bucket * const l2b = pmap_get_l2_bucket(pmap_kernel(), va);
                 KDASSERT(l2b != NULL);                  KDASSERT(l2b != NULL);
   
                 sptep = ptep = &l2b->l2b_kva[l2pte_index(va)];                  pt_entry_t * const sptep = &l2b->l2b_kva[l2pte_index(va)];
                   pt_entry_t *ptep = sptep;
                 mappings = 0;                  mappings = 0;
   
                 while (va < next_bucket) {                  while (va < next_bucket) {
                         opte = *ptep;                          const pt_entry_t opte = *ptep;
                         opg = PHYS_TO_VM_PAGE(l2pte_pa(opte));                          struct vm_page *opg = PHYS_TO_VM_PAGE(l2pte_pa(opte));
                         if (opg) {                          if (opg != NULL) {
                                 struct vm_page_md *omd = VM_PAGE_TO_MD(opg);                                  struct vm_page_md *omd = VM_PAGE_TO_MD(opg);
   
                                 if (omd->pvh_attrs & PVF_KMPAGE) {                                  if (omd->pvh_attrs & PVF_KMPAGE) {
Line 3493  pmap_kremove(vaddr_t va, vsize_t len)
Line 3494  pmap_kremove(vaddr_t va, vsize_t len)
                                 cpu_tlb_flushD_SE(va);                                  cpu_tlb_flushD_SE(va);
                         }                          }
                         if (opte) {                          if (opte) {
                                 *ptep = 0;                                  l2pte_reset(ptep);
                                 mappings++;                                  mappings++;
                         }                          }
                         va += PAGE_SIZE;                          va += PAGE_SIZE;
                         ptep++;                          ptep += PAGE_SIZE / L2_S_SIZE;
                 }                  }
                 KDASSERT(mappings <= l2b->l2b_occupancy);                  KDASSERT(mappings <= l2b->l2b_occupancy);
                 l2b->l2b_occupancy -= mappings;                  l2b->l2b_occupancy -= mappings;
Line 3577  pmap_protect(pmap_t pm, vaddr_t sva, vad
Line 3578  pmap_protect(pmap_t pm, vaddr_t sva, vad
         struct l2_bucket *l2b;          struct l2_bucket *l2b;
         pt_entry_t *ptep, pte;          pt_entry_t *ptep, pte;
         vaddr_t next_bucket;          vaddr_t next_bucket;
         u_int flags;  
         u_int clr_mask;  
         int flush;  
   
         NPDEBUG(PDB_PROTECT,          NPDEBUG(PDB_PROTECT,
             printf("pmap_protect: pm %p sva 0x%lx eva 0x%lx prot 0x%x\n",              printf("pmap_protect: pm %p sva 0x%lx eva 0x%lx prot 0x%x\n",
Line 3600  pmap_protect(pmap_t pm, vaddr_t sva, vad
Line 3598  pmap_protect(pmap_t pm, vaddr_t sva, vad
   
         pmap_acquire_pmap_lock(pm);          pmap_acquire_pmap_lock(pm);
   
         flush = ((eva - sva) >= (PAGE_SIZE * 4)) ? 0 : -1;          const bool flush = eva - sva >= PAGE_SIZE * 4;
         flags = 0;          u_int clr_mask = PVF_WRITE | ((prot & VM_PROT_EXECUTE) ? 0 : PVF_EXEC);
         clr_mask = PVF_WRITE | ((prot & VM_PROT_EXECUTE) ? 0 : PVF_EXEC);          u_int flags = 0;
   
         while (sva < eva) {          while (sva < eva) {
                 next_bucket = L2_NEXT_BUCKET(sva);                  next_bucket = L2_NEXT_BUCKET(sva);
Line 3651  pmap_protect(pmap_t pm, vaddr_t sva, vad
Line 3649  pmap_protect(pmap_t pm, vaddr_t sva, vad
                                         f = PVF_REF | PVF_EXEC;                                          f = PVF_REF | PVF_EXEC;
                                 }                                  }
   
                                 if (flush >= 0) {                                  if (flush) {
                                         flush++;  
                                         flags |= f;                                          flags |= f;
                                 } else {                                  } else {
                                         pmap_tlb_flush_SE(pm, sva, f);                                          pmap_tlb_flush_SE(pm, sva, f);
Line 3664  pmap_protect(pmap_t pm, vaddr_t sva, vad
Line 3661  pmap_protect(pmap_t pm, vaddr_t sva, vad
                 }                  }
         }          }
   
         pmap_release_pmap_lock(pm);  
   
         if (flush) {          if (flush) {
                 if (PV_BEEN_EXECD(flags))                  if (PV_BEEN_EXECD(flags)) {
                         pmap_tlb_flushID(pm);                          pmap_tlb_flushID(pm);
                 else                  } else if (PV_BEEN_REFD(flags)) {
                 if (PV_BEEN_REFD(flags))  
                         pmap_tlb_flushD(pm);                          pmap_tlb_flushD(pm);
                   }
         }          }
   
           pmap_release_pmap_lock(pm);
 }  }
   
 void  void
Line 5699  pmap_map_section(vaddr_t l1pt, vaddr_t v
Line 5696  pmap_map_section(vaddr_t l1pt, vaddr_t v
                 break;                  break;
         }          }
   
         pde[va >> L1_S_SHIFT] = L1_S_PROTO | pa |          pde[L1_IDX(va)] = L1_S_PROTO | pa |
             L1_S_PROT(PTE_KERNEL, prot) | fl | L1_S_DOM(PMAP_DOMAIN_KERNEL);              L1_S_PROT(PTE_KERNEL, prot) | fl | L1_S_DOM(PMAP_DOMAIN_KERNEL);
         PTE_SYNC(&pde[va >> L1_S_SHIFT]);          PTE_SYNC(&pde[L1_IDX(va)]);
 }  }
   
 /*  /*
Line 5713  void
Line 5710  void
 pmap_map_entry(vaddr_t l1pt, vaddr_t va, paddr_t pa, int prot, int cache)  pmap_map_entry(vaddr_t l1pt, vaddr_t va, paddr_t pa, int prot, int cache)
 {  {
         pd_entry_t *pde = (pd_entry_t *) l1pt;          pd_entry_t *pde = (pd_entry_t *) l1pt;
         pt_entry_t fl;          pt_entry_t npte;
         pt_entry_t *pte;          pt_entry_t *ptep;
   
         KASSERT(((va | pa) & PGOFSET) == 0);          KASSERT(((va | pa) & PGOFSET) == 0);
   
         switch (cache) {          switch (cache) {
         case PTE_NOCACHE:          case PTE_NOCACHE:
         default:          default:
                 fl = 0;                  npte = 0;
                 break;                  break;
   
         case PTE_CACHE:          case PTE_CACHE:
                 fl = pte_l2_s_cache_mode;                  npte = pte_l2_s_cache_mode;
                 break;                  break;
   
         case PTE_PAGETABLE:          case PTE_PAGETABLE:
                 fl = pte_l2_s_cache_mode_pt;                  npte = pte_l2_s_cache_mode_pt;
                 break;                  break;
         }          }
   
         if ((pde[va >> L1_S_SHIFT] & L1_TYPE_MASK) != L1_TYPE_C)          if ((pde[L1_IDX(va)] & L1_TYPE_MASK) != L1_TYPE_C)
                 panic("pmap_map_entry: no L2 table for VA 0x%08lx", va);                  panic("pmap_map_entry: no L2 table for VA 0x%08lx", va);
   
 #ifndef ARM32_NEW_VM_LAYOUT  #ifndef ARM32_NEW_VM_LAYOUT
         pte = (pt_entry_t *)          ptep = (pt_entry_t *)
             kernel_pt_lookup(pde[va >> L1_S_SHIFT] & L2_S_FRAME);              kernel_pt_lookup(pde[L1_IDX(va)] & L2_S_FRAME);
 #else  #else
         pte = (pt_entry_t *) kernel_pt_lookup(pde[L1_IDX(va)] & L1_C_ADDR_MASK);          ptep = (pt_entry_t *) kernel_pt_lookup(pde[L1_IDX(va)] & L1_C_ADDR_MASK);
 #endif  #endif
         if (pte == NULL)          if (ptep == NULL)
                 panic("pmap_map_entry: can't find L2 table for VA 0x%08lx", va);                  panic("pmap_map_entry: can't find L2 table for VA 0x%08lx", va);
   
         fl |= L2_S_PROTO | pa | L2_S_PROT(PTE_KERNEL, prot);          npte |= L2_S_PROTO | pa | L2_S_PROT(PTE_KERNEL, prot);
 #ifndef ARM32_NEW_VM_LAYOUT  #ifndef ARM32_NEW_VM_LAYOUT
         pte += (va >> PGSHIFT) & 0x3ff;          ptep += (va >> PGSHIFT) & 0x3ff;
 #else  #else
         pte += l2pte_index(va);          ptep += l2pte_index(va);
             L2_S_PROTO | pa | L2_S_PROT(PTE_KERNEL, prot) | fl;  
 #endif  #endif
         *pte = fl;          l2pte_set(ptep, npte, 0);
         PTE_SYNC(pte);          PTE_SYNC(ptep);
 }  }
   
 /*  /*
Line 5766  void
Line 5762  void
 pmap_link_l2pt(vaddr_t l1pt, vaddr_t va, pv_addr_t *l2pv)  pmap_link_l2pt(vaddr_t l1pt, vaddr_t va, pv_addr_t *l2pv)
 {  {
         pd_entry_t *pde = (pd_entry_t *) l1pt, proto;          pd_entry_t *pde = (pd_entry_t *) l1pt, proto;
         u_int slot = va >> L1_S_SHIFT;          u_int slot = L1_IDX(va);
   
 #ifndef ARM32_NEW_VM_LAYOUT  #ifndef ARM32_NEW_VM_LAYOUT
         KASSERT((va & ((L1_S_SIZE * 4) - 1)) == 0);          KASSERT((va & ((L1_S_SIZE * 4) - 1)) == 0);
Line 5779  pmap_link_l2pt(vaddr_t l1pt, vaddr_t va,
Line 5775  pmap_link_l2pt(vaddr_t l1pt, vaddr_t va,
 #ifdef ARM32_NEW_VM_LAYOUT  #ifdef ARM32_NEW_VM_LAYOUT
         PTE_SYNC(&pde[slot]);          PTE_SYNC(&pde[slot]);
 #else  #else
         pde[slot + 1] = proto | (l2pv->pv_pa + 0x400);          for (u_int off = 0, i = 0; off < PAGE_SIZE; off += L2_T_SIZE, i++) {
         pde[slot + 2] = proto | (l2pv->pv_pa + 0x800);                  pde[slot + i] = proto | (l2pv->pv_pa + off);
         pde[slot + 3] = proto | (l2pv->pv_pa + 0xc00);          }
         PTE_SYNC_RANGE(&pde[slot + 0], 4);          PTE_SYNC_RANGE(&pde[slot + 0], PAGE_SIZE / L2_T_SIZE);
 #endif  #endif
   
         SLIST_INSERT_HEAD(&kernel_pt_list, l2pv, pv_list);          SLIST_INSERT_HEAD(&kernel_pt_list, l2pv, pv_list);
Line 5838  pmap_map_chunk(vaddr_t l1pt, vaddr_t va,
Line 5834  pmap_map_chunk(vaddr_t l1pt, vaddr_t va,
         size = resid;          size = resid;
   
         while (resid > 0) {          while (resid > 0) {
                   size_t l1idx = L1_IDX(va);
 #if (ARM_MMU_V6 + ARM_MMU_V7) > 0  #if (ARM_MMU_V6 + ARM_MMU_V7) > 0
                 /* See if we can use a supersection mapping. */                  /* See if we can use a supersection mapping. */
                 if (L1_SS_PROTO && L1_SS_MAPPABLE_P(va, pa, resid)) {                  if (L1_SS_PROTO && L1_SS_MAPPABLE_P(va, pa, resid)) {
Line 5847  pmap_map_chunk(vaddr_t l1pt, vaddr_t va,
Line 5844  pmap_map_chunk(vaddr_t l1pt, vaddr_t va,
 #ifdef VERBOSE_INIT_ARM  #ifdef VERBOSE_INIT_ARM
                         printf("sS");                          printf("sS");
 #endif  #endif
                         for (size_t s = va >> L1_S_SHIFT,                          for (size_t s = l1idx,
                              e = s + L1_SS_SIZE / L1_S_SIZE;                               e = s + L1_SS_SIZE / L1_S_SIZE;
                              s < e;                               s < e;
                              s++) {                               s++) {
Line 5865  pmap_map_chunk(vaddr_t l1pt, vaddr_t va,
Line 5862  pmap_map_chunk(vaddr_t l1pt, vaddr_t va,
 #ifdef VERBOSE_INIT_ARM  #ifdef VERBOSE_INIT_ARM
                         printf("S");                          printf("S");
 #endif  #endif
                         pdep[va >> L1_S_SHIFT] = L1_S_PROTO | pa |                          pdep[l1idx] = L1_S_PROTO | pa |
                             L1_S_PROT(PTE_KERNEL, prot) | f1 |                              L1_S_PROT(PTE_KERNEL, prot) | f1 |
                             L1_S_DOM(PMAP_DOMAIN_KERNEL);                              L1_S_DOM(PMAP_DOMAIN_KERNEL);
                         PTE_SYNC(&pdep[va >> L1_S_SHIFT]);                          PTE_SYNC(&pdep[l1idx]);
                         va += L1_S_SIZE;                          va += L1_S_SIZE;
                         pa += L1_S_SIZE;                          pa += L1_S_SIZE;
                         resid -= L1_S_SIZE;                          resid -= L1_S_SIZE;
Line 5880  pmap_map_chunk(vaddr_t l1pt, vaddr_t va,
Line 5877  pmap_map_chunk(vaddr_t l1pt, vaddr_t va,
                  * one is actually in the corresponding L1 slot                   * one is actually in the corresponding L1 slot
                  * for the current VA.                   * for the current VA.
                  */                   */
                 if ((pdep[va >> L1_S_SHIFT] & L1_TYPE_MASK) != L1_TYPE_C)                  if ((pdep[l1idx] & L1_TYPE_MASK) != L1_TYPE_C)
                         panic("pmap_map_chunk: no L2 table for VA 0x%08lx", va);                          panic("pmap_map_chunk: no L2 table for VA 0x%08lx", va);
   
 #ifndef ARM32_NEW_VM_LAYOUT  #ifndef ARM32_NEW_VM_LAYOUT
                 pte = (pt_entry_t *)                  pte = (pt_entry_t *)
                     kernel_pt_lookup(pdep[va >> L1_S_SHIFT] & L2_S_FRAME);                      kernel_pt_lookup(pdep[l1idx] & L2_S_FRAME);
 #else  #else
                 pte = (pt_entry_t *) kernel_pt_lookup(                  pte = (pt_entry_t *) kernel_pt_lookup(
                     pdep[L1_IDX(va)] & L1_C_ADDR_MASK);                      pdep[l1idx] & L1_C_ADDR_MASK);
 #endif  #endif
                 if (pte == NULL)                  if (pte == NULL)
                         panic("pmap_map_chunk: can't find L2 table for VA"                          panic("pmap_map_chunk: can't find L2 table for VA"
Line 5922  pmap_map_chunk(vaddr_t l1pt, vaddr_t va,
Line 5919  pmap_map_chunk(vaddr_t l1pt, vaddr_t va,
 #ifdef VERBOSE_INIT_ARM  #ifdef VERBOSE_INIT_ARM
                 printf("P");                  printf("P");
 #endif  #endif
 #ifndef ARM32_NEW_VM_LAYOUT                  pt_entry_t npte =
                 pte[(va >> PGSHIFT) & 0x3ff] =  
                     L2_S_PROTO | pa | L2_S_PROT(PTE_KERNEL, prot) | f2s;                      L2_S_PROTO | pa | L2_S_PROT(PTE_KERNEL, prot) | f2s;
                 PTE_SYNC(&pte[(va >> PGSHIFT) & 0x3ff]);  #ifndef ARM32_NEW_VM_LAYOUT
                   pt_entry_t *ptep = &pte[(va >> PGSHIFT) & 0x3ff];
 #else  #else
                 pte[l2pte_index(va)] =                  pt_entry_t *ptep = &pte[l2pte_index(va)];
                     L2_S_PROTO | pa | L2_S_PROT(PTE_KERNEL, prot) | f2s;  
                 PTE_SYNC(&pte[l2pte_index(va)]);  
 #endif  #endif
                   l2pte_set(ptep, npte, 0);
                   PTE_SYNC(ptep);
                 va += PAGE_SIZE;                  va += PAGE_SIZE;
                 pa += PAGE_SIZE;                  pa += PAGE_SIZE;
                 resid -= PAGE_SIZE;                  resid -= PAGE_SIZE;
Line 6381  xscale_setup_minidata(vaddr_t l1pt, vadd
Line 6378  xscale_setup_minidata(vaddr_t l1pt, vadd
         extern vaddr_t xscale_minidata_clean_addr;          extern vaddr_t xscale_minidata_clean_addr;
         extern vsize_t xscale_minidata_clean_size; /* already initialized */          extern vsize_t xscale_minidata_clean_size; /* already initialized */
         pd_entry_t *pde = (pd_entry_t *) l1pt;          pd_entry_t *pde = (pd_entry_t *) l1pt;
         pt_entry_t *pte;  
         vsize_t size;          vsize_t size;
         uint32_t auxctl;          uint32_t auxctl;
   
Line 6392  xscale_setup_minidata(vaddr_t l1pt, vadd
Line 6388  xscale_setup_minidata(vaddr_t l1pt, vadd
   
         for (; size != 0;          for (; size != 0;
              va += L2_S_SIZE, pa += L2_S_SIZE, size -= L2_S_SIZE) {               va += L2_S_SIZE, pa += L2_S_SIZE, size -= L2_S_SIZE) {
                   const size_t l1idx = L1_IDX(va);
 #ifndef ARM32_NEW_VM_LAYOUT  #ifndef ARM32_NEW_VM_LAYOUT
                 pte = (pt_entry_t *)                  pt_entry_t *ptep = (pt_entry_t *)
                     kernel_pt_lookup(pde[va >> L1_S_SHIFT] & L2_S_FRAME);                      kernel_pt_lookup(pde[l1idx] & L2_S_FRAME);
 #else  #else
                 pte = (pt_entry_t *) kernel_pt_lookup(                  pt_entry_t *ptep = (pt_entry_t *) kernel_pt_lookup(
                     pde[L1_IDX(va)] & L1_C_ADDR_MASK);                      pde[l1idx] & L1_C_ADDR_MASK);
 #endif  #endif
                 if (pte == NULL)                  if (ptep == NULL)
                         panic("xscale_setup_minidata: can't find L2 table for "                          panic("xscale_setup_minidata: can't find L2 table for "
                             "VA 0x%08lx", va);                              "VA 0x%08lx", va);
   
 #ifndef ARM32_NEW_VM_LAYOUT  #ifndef ARM32_NEW_VM_LAYOUT
                 pte[(va >> PGSHIFT) & 0x3ff] =                  ptep += (va >> PGSHIFT) & 0x3ff;
 #else  #else
                 pte[l2pte_index(va)] =                  ptep += l2pte_index(va);
 #endif  #endif
                     L2_S_PROTO | pa | L2_S_PROT(PTE_KERNEL, VM_PROT_READ) |                  pt_entry_t opte = *ptep;
                     L2_C | L2_XS_T_TEX(TEX_XSCALE_X);                  l2pte_set(ptep,
                       L2_S_PROTO | pa | L2_S_PROT(PTE_KERNEL, VM_PROT_READ)
                       | L2_C | L2_XS_T_TEX(TEX_XSCALE_X), opte);
         }          }
   
         /*          /*
Line 6437  xscale_setup_minidata(vaddr_t l1pt, vadd
Line 6437  xscale_setup_minidata(vaddr_t l1pt, vadd
 void  void
 pmap_uarea(vaddr_t va)  pmap_uarea(vaddr_t va)
 {  {
         struct l2_bucket *l2b;  
         pt_entry_t *ptep, *sptep, pte;  
         vaddr_t next_bucket, eva;          vaddr_t next_bucket, eva;
   
 #if (ARM_NMMUS > 1)  #if (ARM_NMMUS > 1)
Line 6453  pmap_uarea(vaddr_t va)
Line 6451  pmap_uarea(vaddr_t va)
                 if (next_bucket > eva)                  if (next_bucket > eva)
                         next_bucket = eva;                          next_bucket = eva;
   
                 l2b = pmap_get_l2_bucket(pmap_kernel(), va);                  struct l2_bucket *l2b = pmap_get_l2_bucket(pmap_kernel(), va);
                 KDASSERT(l2b != NULL);                  KDASSERT(l2b != NULL);
   
                 sptep = ptep = &l2b->l2b_kva[l2pte_index(va)];                  pt_entry_t * const sptep = &l2b->l2b_kva[l2pte_index(va)];
                   pt_entry_t *ptep = sptep;
   
                 while (va < next_bucket) {                  while (va < next_bucket) {
                         pte = *ptep;                          const pt_entry_t opte = *ptep;
                         if (!l2pte_minidata(pte)) {                          if (!l2pte_minidata(opte)) {
                                 cpu_dcache_wbinv_range(va, PAGE_SIZE);                                  cpu_dcache_wbinv_range(va, PAGE_SIZE);
                                 cpu_tlb_flushD_SE(va);                                  cpu_tlb_flushD_SE(va);
                                 *ptep = pte & ~L2_B;                                  l2pte_set(ptep, opte & ~L2_B, opte);
                         }                          }
                         ptep++;                          ptep += PAGE_SIZE / L2_S_SIZE;
                         va += PAGE_SIZE;                          va += PAGE_SIZE;
                 }                  }
                 PTE_SYNC_RANGE(sptep, (u_int)(ptep - sptep));                  PTE_SYNC_RANGE(sptep, (u_int)(ptep - sptep));

Legend:
Removed from v.1.261  
changed lines
  Added in v.1.262

CVSweb <webmaster@jp.NetBSD.org>