sys/powerpc/aim/mmu_oea64.c

   1 /*-
   2  * Copyright (c) 2001 The NetBSD Foundation, Inc.
   3  * All rights reserved.
   4  *
   5  * This code is derived from software contributed to The NetBSD Foundation
   6  * by Matt Thomas <matt@3am-software.com> of Allegro Networks, Inc.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *        This product includes software developed by the NetBSD
  19  *        Foundation, Inc. and its contributors.
  20  * 4. Neither the name of The NetBSD Foundation nor the names of its
  21  *    contributors may be used to endorse or promote products derived
  22  *    from this software without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  25  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  26  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  27  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  28  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34  * POSSIBILITY OF SUCH DAMAGE.
  35  */
  36 /*-
  37  * Copyright (C) 1995, 1996 Wolfgang Solfrank.
  38  * Copyright (C) 1995, 1996 TooLs GmbH.
  39  * All rights reserved.
  40  *
  41  * Redistribution and use in source and binary forms, with or without
  42  * modification, are permitted provided that the following conditions
  43  * are met:
  44  * 1. Redistributions of source code must retain the above copyright
  45  *    notice, this list of conditions and the following disclaimer.
  46  * 2. Redistributions in binary form must reproduce the above copyright
  47  *    notice, this list of conditions and the following disclaimer in the
  48  *    documentation and/or other materials provided with the distribution.
  49  * 3. All advertising materials mentioning features or use of this software
  50  *    must display the following acknowledgement:
  51  *      This product includes software developed by TooLs GmbH.
  52  * 4. The name of TooLs GmbH may not be used to endorse or promote products
  53  *    derived from this software without specific prior written permission.
  54  *
  55  * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
  56  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  57  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  58  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  59  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  60  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  61  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  62  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  63  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  64  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  65  *
  66  * $NetBSD: pmap.c,v 1.28 2000/03/26 20:42:36 kleink Exp $
  67  */
  68 /*-
  69  * Copyright (C) 2001 Benno Rice.
  70  * All rights reserved.
  71  *
  72  * Redistribution and use in source and binary forms, with or without
  73  * modification, are permitted provided that the following conditions
  74  * are met:
  75  * 1. Redistributions of source code must retain the above copyright
  76  *    notice, this list of conditions and the following disclaimer.
  77  * 2. Redistributions in binary form must reproduce the above copyright
  78  *    notice, this list of conditions and the following disclaimer in the
  79  *    documentation and/or other materials provided with the distribution.
  80  *
  81  * THIS SOFTWARE IS PROVIDED BY Benno Rice ``AS IS'' AND ANY EXPRESS OR
  82  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  83  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  84  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  85  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  86  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  87  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  88  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  89  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  90  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  91  */
  92
  93 #include <sys/cdefs.h>
  94 __FBSDID("$FreeBSD$");
  95
  96 /*
  97  * Manages physical address maps.
  98  *
  99  * In addition to hardware address maps, this module is called upon to
 100  * provide software-use-only maps which may or may not be stored in the
 101  * same form as hardware maps.  These pseudo-maps are used to store
 102  * intermediate results from copy operations to and from address spaces.
 103  *
 104  * Since the information managed by this module is also stored by the
 105  * logical address mapping module, this module may throw away valid virtual
 106  * to physical mappings at almost any time.  However, invalidations of
 107  * mappings must be done as requested.
 108  *
 109  * In order to cope with hardware architectures which make virtual to
 110  * physical map invalidates expensive, this module may delay invalidate
 111  * reduced protection operations until such time as they are actually
 112  * necessary.  This module is given full information as to which processors
 113  * are currently using which maps, and to when physical maps must be made
 114  * correct.
 115  */
 116
 117 #include "opt_kstack_pages.h"
 118
 119 #include <sys/param.h>
 120 #include <sys/kernel.h>
 121 #include <sys/queue.h>
 122 #include <sys/cpuset.h>
 123 #include <sys/ktr.h>
 124 #include <sys/lock.h>
 125 #include <sys/msgbuf.h>
 126 #include <sys/mutex.h>
 127 #include <sys/proc.h>
 128 #include <sys/sched.h>
 129 #include <sys/sysctl.h>
 130 #include <sys/systm.h>
 131 #include <sys/vmmeter.h>
 132
 133 #include <sys/kdb.h>
 134
 135 #include <dev/ofw/openfirm.h>
 136
 137 #include <vm/vm.h>
 138 #include <vm/vm_param.h>
 139 #include <vm/vm_kern.h>
 140 #include <vm/vm_page.h>
 141 #include <vm/vm_map.h>
 142 #include <vm/vm_object.h>
 143 #include <vm/vm_extern.h>
 144 #include <vm/vm_pageout.h>
 145 #include <vm/vm_pager.h>
 146 #include <vm/uma.h>
 147
 148 #include <machine/_inttypes.h>
 149 #include <machine/cpu.h>
 150 #include <machine/platform.h>
 151 #include <machine/frame.h>
 152 #include <machine/md_var.h>
 153 #include <machine/psl.h>
 154 #include <machine/bat.h>
 155 #include <machine/hid.h>
 156 #include <machine/pte.h>
 157 #include <machine/sr.h>
 158 #include <machine/trap.h>
 159 #include <machine/mmuvar.h>
 160
 161 #include "mmu_oea64.h"
 162 #include "mmu_if.h"
 163 #include "moea64_if.h"
 164
 165 void moea64_release_vsid(uint64_t vsid);
 166 uintptr_t moea64_get_unique_vsid(void);
 167
 168 #define DISABLE_TRANS(msr)      msr = mfmsr(); mtmsr(msr & ~PSL_DR)
 169 #define ENABLE_TRANS(msr)       mtmsr(msr)
 170
 171 #define VSID_MAKE(sr, hash)     ((sr) | (((hash) & 0xfffff) << 4))
 172 #define VSID_TO_HASH(vsid)      (((vsid) >> 4) & 0xfffff)
 173 #define VSID_HASH_MASK          0x0000007fffffffffULL
 174
 175 #define LOCK_TABLE() mtx_lock(&moea64_table_mutex)
 176 #define UNLOCK_TABLE() mtx_unlock(&moea64_table_mutex);
 177 #define ASSERT_TABLE_LOCK() mtx_assert(&moea64_table_mutex, MA_OWNED)
 178
 179 struct ofw_map {
 180         cell_t  om_va;
 181         cell_t  om_len;
 182         cell_t  om_pa_hi;
 183         cell_t  om_pa_lo;
 184         cell_t  om_mode;
 185 };
 186
 187 /*
 188  * Map of physical memory regions.
 189  */
 190 static struct   mem_region *regions;
 191 static struct   mem_region *pregions;
 192 static u_int    phys_avail_count;
 193 static int      regions_sz, pregions_sz;
 194
 195 extern void bs_remap_earlyboot(void);
 196
 197 /*
 198  * Lock for the pteg and pvo tables.
 199  */
 200 struct mtx      moea64_table_mutex;
 201 struct mtx      moea64_slb_mutex;
 202
 203 /*
 204  * PTEG data.
 205  */
 206 u_int           moea64_pteg_count;
 207 u_int           moea64_pteg_mask;
 208
 209 /*
 210  * PVO data.
 211  */
 212 struct  pvo_head *moea64_pvo_table;             /* pvo entries by pteg index */
 213 struct  pvo_head moea64_pvo_kunmanaged =        /* list of unmanaged pages */
 214     LIST_HEAD_INITIALIZER(moea64_pvo_kunmanaged);
 215
 216 uma_zone_t      moea64_upvo_zone; /* zone for pvo entries for unmanaged pages */
 217 uma_zone_t      moea64_mpvo_zone; /* zone for pvo entries for managed pages */
 218
 219 #define BPVO_POOL_SIZE  327680
 220 static struct   pvo_entry *moea64_bpvo_pool;
 221 static int      moea64_bpvo_pool_index = 0;
 222
 223 #define VSID_NBPW       (sizeof(u_int32_t) * 8)
 224 #ifdef __powerpc64__
 225 #define NVSIDS          (NPMAPS * 16)
 226 #define VSID_HASHMASK   0xffffffffUL
 227 #else
 228 #define NVSIDS          NPMAPS
 229 #define VSID_HASHMASK   0xfffffUL
 230 #endif
 231 static u_int    moea64_vsid_bitmap[NVSIDS / VSID_NBPW];
 232
 233 static boolean_t moea64_initialized = FALSE;
 234
 235 /*
 236  * Statistics.
 237  */
 238 u_int   moea64_pte_valid = 0;
 239 u_int   moea64_pte_overflow = 0;
 240 u_int   moea64_pvo_entries = 0;
 241 u_int   moea64_pvo_enter_calls = 0;
 242 u_int   moea64_pvo_remove_calls = 0;
 243 SYSCTL_INT(_machdep, OID_AUTO, moea64_pte_valid, CTLFLAG_RD,
 244     &moea64_pte_valid, 0, "");
 245 SYSCTL_INT(_machdep, OID_AUTO, moea64_pte_overflow, CTLFLAG_RD,
 246     &moea64_pte_overflow, 0, "");
 247 SYSCTL_INT(_machdep, OID_AUTO, moea64_pvo_entries, CTLFLAG_RD,
 248     &moea64_pvo_entries, 0, "");
 249 SYSCTL_INT(_machdep, OID_AUTO, moea64_pvo_enter_calls, CTLFLAG_RD,
 250     &moea64_pvo_enter_calls, 0, "");
 251 SYSCTL_INT(_machdep, OID_AUTO, moea64_pvo_remove_calls, CTLFLAG_RD,
 252     &moea64_pvo_remove_calls, 0, "");
 253
 254 vm_offset_t     moea64_scratchpage_va[2];
 255 struct pvo_entry *moea64_scratchpage_pvo[2];
 256 uintptr_t       moea64_scratchpage_pte[2];
 257 struct  mtx     moea64_scratchpage_mtx;
 258
 259 uint64_t        moea64_large_page_mask = 0;
 260 int             moea64_large_page_size = 0;
 261 int             moea64_large_page_shift = 0;
 262
 263 /*
 264  * PVO calls.
 265  */
 266 static int      moea64_pvo_enter(mmu_t, pmap_t, uma_zone_t, struct pvo_head *,
 267                     vm_offset_t, vm_offset_t, uint64_t, int);
 268 static void     moea64_pvo_remove(mmu_t, struct pvo_entry *);
 269 static struct   pvo_entry *moea64_pvo_find_va(pmap_t, vm_offset_t);
 270
 271 /*
 272  * Utility routines.
 273  */
 274 static void             moea64_enter_locked(mmu_t, pmap_t, vm_offset_t,
 275                             vm_page_t, vm_prot_t, boolean_t);
 276 static boolean_t        moea64_query_bit(mmu_t, vm_page_t, u_int64_t);
 277 static u_int            moea64_clear_bit(mmu_t, vm_page_t, u_int64_t);
 278 static void             moea64_kremove(mmu_t, vm_offset_t);
 279 static void             moea64_syncicache(mmu_t, pmap_t pmap, vm_offset_t va,
 280                             vm_offset_t pa, vm_size_t sz);
 281
 282 /*
 283  * Kernel MMU interface
 284  */
 285 void moea64_change_wiring(mmu_t, pmap_t, vm_offset_t, boolean_t);
 286 void moea64_clear_modify(mmu_t, vm_page_t);
 287 void moea64_clear_reference(mmu_t, vm_page_t);
 288 void moea64_copy_page(mmu_t, vm_page_t, vm_page_t);
 289 void moea64_enter(mmu_t, pmap_t, vm_offset_t, vm_page_t, vm_prot_t, boolean_t);
 290 void moea64_enter_object(mmu_t, pmap_t, vm_offset_t, vm_offset_t, vm_page_t,
 291     vm_prot_t);
 292 void moea64_enter_quick(mmu_t, pmap_t, vm_offset_t, vm_page_t, vm_prot_t);
 293 vm_paddr_t moea64_extract(mmu_t, pmap_t, vm_offset_t);
 294 vm_page_t moea64_extract_and_hold(mmu_t, pmap_t, vm_offset_t, vm_prot_t);
 295 void moea64_init(mmu_t);
 296 boolean_t moea64_is_modified(mmu_t, vm_page_t);
 297 boolean_t moea64_is_prefaultable(mmu_t, pmap_t, vm_offset_t);
 298 boolean_t moea64_is_referenced(mmu_t, vm_page_t);
 299 boolean_t moea64_ts_referenced(mmu_t, vm_page_t);
 300 vm_offset_t moea64_map(mmu_t, vm_offset_t *, vm_offset_t, vm_offset_t, int);
 301 boolean_t moea64_page_exists_quick(mmu_t, pmap_t, vm_page_t);
 302 int moea64_page_wired_mappings(mmu_t, vm_page_t);
 303 void moea64_pinit(mmu_t, pmap_t);
 304 void moea64_pinit0(mmu_t, pmap_t);
 305 void moea64_protect(mmu_t, pmap_t, vm_offset_t, vm_offset_t, vm_prot_t);
 306 void moea64_qenter(mmu_t, vm_offset_t, vm_page_t *, int);
 307 void moea64_qremove(mmu_t, vm_offset_t, int);
 308 void moea64_release(mmu_t, pmap_t);
 309 void moea64_remove(mmu_t, pmap_t, vm_offset_t, vm_offset_t);
 310 void moea64_remove_all(mmu_t, vm_page_t);
 311 void moea64_remove_write(mmu_t, vm_page_t);
 312 void moea64_zero_page(mmu_t, vm_page_t);
 313 void moea64_zero_page_area(mmu_t, vm_page_t, int, int);
 314 void moea64_zero_page_idle(mmu_t, vm_page_t);
 315 void moea64_activate(mmu_t, struct thread *);
 316 void moea64_deactivate(mmu_t, struct thread *);
 317 void *moea64_mapdev(mmu_t, vm_offset_t, vm_size_t);
 318 void *moea64_mapdev_attr(mmu_t, vm_offset_t, vm_size_t, vm_memattr_t);
 319 void moea64_unmapdev(mmu_t, vm_offset_t, vm_size_t);
 320 vm_offset_t moea64_kextract(mmu_t, vm_offset_t);
 321 void moea64_page_set_memattr(mmu_t, vm_page_t m, vm_memattr_t ma);
 322 void moea64_kenter_attr(mmu_t, vm_offset_t, vm_offset_t, vm_memattr_t ma);
 323 void moea64_kenter(mmu_t, vm_offset_t, vm_offset_t);
 324 boolean_t moea64_dev_direct_mapped(mmu_t, vm_offset_t, vm_size_t);
 325 static void moea64_sync_icache(mmu_t, pmap_t, vm_offset_t, vm_size_t);
 326
 327 static mmu_method_t moea64_methods[] = {
 328         MMUMETHOD(mmu_change_wiring,    moea64_change_wiring),
 329         MMUMETHOD(mmu_clear_modify,     moea64_clear_modify),
 330         MMUMETHOD(mmu_clear_reference,  moea64_clear_reference),
 331         MMUMETHOD(mmu_copy_page,        moea64_copy_page),
 332         MMUMETHOD(mmu_enter,            moea64_enter),
 333         MMUMETHOD(mmu_enter_object,     moea64_enter_object),
 334         MMUMETHOD(mmu_enter_quick,      moea64_enter_quick),
 335         MMUMETHOD(mmu_extract,          moea64_extract),
 336         MMUMETHOD(mmu_extract_and_hold, moea64_extract_and_hold),
 337         MMUMETHOD(mmu_init,             moea64_init),
 338         MMUMETHOD(mmu_is_modified,      moea64_is_modified),
 339         MMUMETHOD(mmu_is_prefaultable,  moea64_is_prefaultable),
 340         MMUMETHOD(mmu_is_referenced,    moea64_is_referenced),
 341         MMUMETHOD(mmu_ts_referenced,    moea64_ts_referenced),
 342         MMUMETHOD(mmu_map,              moea64_map),
 343         MMUMETHOD(mmu_page_exists_quick,moea64_page_exists_quick),
 344         MMUMETHOD(mmu_page_wired_mappings,moea64_page_wired_mappings),
 345         MMUMETHOD(mmu_pinit,            moea64_pinit),
 346         MMUMETHOD(mmu_pinit0,           moea64_pinit0),
 347         MMUMETHOD(mmu_protect,          moea64_protect),
 348         MMUMETHOD(mmu_qenter,           moea64_qenter),
 349         MMUMETHOD(mmu_qremove,          moea64_qremove),
 350         MMUMETHOD(mmu_release,          moea64_release),
 351         MMUMETHOD(mmu_remove,           moea64_remove),
 352         MMUMETHOD(mmu_remove_all,       moea64_remove_all),
 353         MMUMETHOD(mmu_remove_write,     moea64_remove_write),
 354         MMUMETHOD(mmu_sync_icache,      moea64_sync_icache),
 355         MMUMETHOD(mmu_zero_page,        moea64_zero_page),
 356         MMUMETHOD(mmu_zero_page_area,   moea64_zero_page_area),
 357         MMUMETHOD(mmu_zero_page_idle,   moea64_zero_page_idle),
 358         MMUMETHOD(mmu_activate,         moea64_activate),
 359         MMUMETHOD(mmu_deactivate,       moea64_deactivate),
 360         MMUMETHOD(mmu_page_set_memattr, moea64_page_set_memattr),
 361
 362         /* Internal interfaces */
 363         MMUMETHOD(mmu_mapdev,           moea64_mapdev),
 364         MMUMETHOD(mmu_mapdev_attr,      moea64_mapdev_attr),
 365         MMUMETHOD(mmu_unmapdev,         moea64_unmapdev),
 366         MMUMETHOD(mmu_kextract,         moea64_kextract),
 367         MMUMETHOD(mmu_kenter,           moea64_kenter),
 368         MMUMETHOD(mmu_kenter_attr,      moea64_kenter_attr),
 369         MMUMETHOD(mmu_dev_direct_mapped,moea64_dev_direct_mapped),
 370
 371         { 0, 0 }
 372 };
 373
 374 MMU_DEF(oea64_mmu, "mmu_oea64_base", moea64_methods, 0);
 375
 376 static __inline u_int
 377 va_to_pteg(uint64_t vsid, vm_offset_t addr, int large)
 378 {
 379         uint64_t hash;
 380         int shift;
 381
 382         shift = large ? moea64_large_page_shift : ADDR_PIDX_SHFT;
 383         hash = (vsid & VSID_HASH_MASK) ^ (((uint64_t)addr & ADDR_PIDX) >>
 384             shift);
 385         return (hash & moea64_pteg_mask);
 386 }
 387
 388 static __inline struct pvo_head *
 389 vm_page_to_pvoh(vm_page_t m)
 390 {
 391
 392         return (&m->md.mdpg_pvoh);
 393 }
 394
 395 static __inline void
 396 moea64_attr_clear(vm_page_t m, u_int64_t ptebit)
 397 {
 398
 399         mtx_assert(&vm_page_queue_mtx, MA_OWNED);
 400         m->md.mdpg_attrs &= ~ptebit;
 401 }
 402
 403 static __inline u_int64_t
 404 moea64_attr_fetch(vm_page_t m)
 405 {
 406
 407         return (m->md.mdpg_attrs);
 408 }
 409
 410 static __inline void
 411 moea64_attr_save(vm_page_t m, u_int64_t ptebit)
 412 {
 413
 414         mtx_assert(&vm_page_queue_mtx, MA_OWNED);
 415         m->md.mdpg_attrs |= ptebit;
 416 }
 417
 418 static __inline void
 419 moea64_pte_create(struct lpte *pt, uint64_t vsid, vm_offset_t va,
 420     uint64_t pte_lo, int flags)
 421 {
 422
 423         ASSERT_TABLE_LOCK();
 424
 425         /*
 426          * Construct a PTE.  Default to IMB initially.  Valid bit only gets
 427          * set when the real pte is set in memory.
 428          *
 429          * Note: Don't set the valid bit for correct operation of tlb update.
 430          */
 431         pt->pte_hi = (vsid << LPTE_VSID_SHIFT) |
 432             (((uint64_t)(va & ADDR_PIDX) >> ADDR_API_SHFT64) & LPTE_API);
 433
 434         if (flags & PVO_LARGE)
 435                 pt->pte_hi |= LPTE_BIG;
 436
 437         pt->pte_lo = pte_lo;
 438 }
 439
 440 static __inline uint64_t
 441 moea64_calc_wimg(vm_offset_t pa, vm_memattr_t ma)
 442 {
 443         uint64_t pte_lo;
 444         int i;
 445
 446         if (ma != VM_MEMATTR_DEFAULT) {
 447                 switch (ma) {
 448                 case VM_MEMATTR_UNCACHEABLE:
 449                         return (LPTE_I | LPTE_G);
 450                 case VM_MEMATTR_WRITE_COMBINING:
 451                 case VM_MEMATTR_WRITE_BACK:
 452                 case VM_MEMATTR_PREFETCHABLE:
 453                         return (LPTE_I);
 454                 case VM_MEMATTR_WRITE_THROUGH:
 455                         return (LPTE_W | LPTE_M);
 456                 }
 457         }
 458
 459         /*
 460          * Assume the page is cache inhibited and access is guarded unless
 461          * it's in our available memory array.
 462          */
 463         pte_lo = LPTE_I | LPTE_G;
 464         for (i = 0; i < pregions_sz; i++) {
 465                 if ((pa >= pregions[i].mr_start) &&
 466                     (pa < (pregions[i].mr_start + pregions[i].mr_size))) {
 467                         pte_lo &= ~(LPTE_I | LPTE_G);
 468                         pte_lo |= LPTE_M;
 469                         break;
 470                 }
 471         }
 472
 473         return pte_lo;
 474 }
 475
 476 /*
 477  * Quick sort callout for comparing memory regions.
 478  */
 479 static int      om_cmp(const void *a, const void *b);
 480
 481 static int
 482 om_cmp(const void *a, const void *b)
 483 {
 484         const struct    ofw_map *mapa;
 485         const struct    ofw_map *mapb;
 486
 487         mapa = a;
 488         mapb = b;
 489         if (mapa->om_pa_hi < mapb->om_pa_hi)
 490                 return (-1);
 491         else if (mapa->om_pa_hi > mapb->om_pa_hi)
 492                 return (1);
 493         else if (mapa->om_pa_lo < mapb->om_pa_lo)
 494                 return (-1);
 495         else if (mapa->om_pa_lo > mapb->om_pa_lo)
 496                 return (1);
 497         else
 498                 return (0);
 499 }
 500
 501 static void
 502 moea64_add_ofw_mappings(mmu_t mmup, phandle_t mmu, size_t sz)
 503 {
 504         struct ofw_map  translations[sz/sizeof(struct ofw_map)];
 505         register_t      msr;
 506         vm_offset_t     off;
 507         vm_paddr_t      pa_base;
 508         int             i;
 509
 510         bzero(translations, sz);
 511         if (OF_getprop(mmu, "translations", translations, sz) == -1)
 512                 panic("moea64_bootstrap: can't get ofw translations");
 513
 514         CTR0(KTR_PMAP, "moea64_add_ofw_mappings: translations");
 515         sz /= sizeof(*translations);
 516         qsort(translations, sz, sizeof (*translations), om_cmp);
 517
 518         for (i = 0; i < sz; i++) {
 519                 CTR3(KTR_PMAP, "translation: pa=%#x va=%#x len=%#x",
 520                     (uint32_t)(translations[i].om_pa_lo), translations[i].om_va,
 521                     translations[i].om_len);
 522
 523                 if (translations[i].om_pa_lo % PAGE_SIZE)
 524                         panic("OFW translation not page-aligned!");
 525
 526                 pa_base = translations[i].om_pa_lo;
 527
 528               #ifdef __powerpc64__
 529                 pa_base += (vm_offset_t)translations[i].om_pa_hi << 32;
 530               #else
 531                 if (translations[i].om_pa_hi)
 532                         panic("OFW translations above 32-bit boundary!");
 533               #endif
 534
 535                 /* Now enter the pages for this mapping */
 536
 537                 DISABLE_TRANS(msr);
 538                 for (off = 0; off < translations[i].om_len; off += PAGE_SIZE) {
 539                         if (moea64_pvo_find_va(kernel_pmap,
 540                             translations[i].om_va + off) != NULL)
 541                                 continue;
 542
 543                         moea64_kenter(mmup, translations[i].om_va + off,
 544                             pa_base + off);
 545                 }
 546                 ENABLE_TRANS(msr);
 547         }
 548 }
 549
 550 #ifdef __powerpc64__
 551 static void
 552 moea64_probe_large_page(void)
 553 {
 554         uint16_t pvr = mfpvr() >> 16;
 555
 556         switch (pvr) {
 557         case IBM970:
 558         case IBM970FX:
 559         case IBM970MP:
 560                 powerpc_sync(); isync();
 561                 mtspr(SPR_HID4, mfspr(SPR_HID4) & ~HID4_970_DISABLE_LG_PG);
 562                 powerpc_sync(); isync();
 563
 564                 /* FALLTHROUGH */
 565         case IBMCELLBE:
 566                 moea64_large_page_size = 0x1000000; /* 16 MB */
 567                 moea64_large_page_shift = 24;
 568                 break;
 569         default:
 570                 moea64_large_page_size = 0;
 571         }
 572
 573         moea64_large_page_mask = moea64_large_page_size - 1;
 574 }
 575
 576 static void
 577 moea64_bootstrap_slb_prefault(vm_offset_t va, int large)
 578 {
 579         struct slb *cache;
 580         struct slb entry;
 581         uint64_t esid, slbe;
 582         uint64_t i;
 583
 584         cache = PCPU_GET(slb);
 585         esid = va >> ADDR_SR_SHFT;
 586         slbe = (esid << SLBE_ESID_SHIFT) | SLBE_VALID;
 587
 588         for (i = 0; i < 64; i++) {
 589                 if (cache[i].slbe == (slbe | i))
 590                         return;
 591         }
 592
 593         entry.slbe = slbe;
 594         entry.slbv = KERNEL_VSID(esid) << SLBV_VSID_SHIFT;
 595         if (large)
 596                 entry.slbv |= SLBV_L;
 597
 598         slb_insert_kernel(entry.slbe, entry.slbv);
 599 }
 600 #endif
 601
 602 static void
 603 moea64_setup_direct_map(mmu_t mmup, vm_offset_t kernelstart,
 604     vm_offset_t kernelend)
 605 {
 606         register_t msr;
 607         vm_paddr_t pa;
 608         vm_offset_t size, off;
 609         uint64_t pte_lo;
 610         int i;
 611
 612         if (moea64_large_page_size == 0)
 613                 hw_direct_map = 0;
 614
 615         DISABLE_TRANS(msr);
 616         if (hw_direct_map) {
 617                 PMAP_LOCK(kernel_pmap);
 618                 for (i = 0; i < pregions_sz; i++) {
 619                   for (pa = pregions[i].mr_start; pa < pregions[i].mr_start +
 620                      pregions[i].mr_size; pa += moea64_large_page_size) {
 621                         pte_lo = LPTE_M;
 622
 623                         /*
 624                          * Set memory access as guarded if prefetch within
 625                          * the page could exit the available physmem area.
 626                          */
 627                         if (pa & moea64_large_page_mask) {
 628                                 pa &= moea64_large_page_mask;
 629                                 pte_lo |= LPTE_G;
 630                         }
 631                         if (pa + moea64_large_page_size >
 632                             pregions[i].mr_start + pregions[i].mr_size)
 633                                 pte_lo |= LPTE_G;
 634
 635                         moea64_pvo_enter(mmup, kernel_pmap, moea64_upvo_zone,
 636                                     &moea64_pvo_kunmanaged, pa, pa,
 637                                     pte_lo, PVO_WIRED | PVO_LARGE);
 638                   }
 639                 }
 640                 PMAP_UNLOCK(kernel_pmap);
 641         } else {
 642                 size = sizeof(struct pvo_head) * moea64_pteg_count;
 643                 off = (vm_offset_t)(moea64_pvo_table);
 644                 for (pa = off; pa < off + size; pa += PAGE_SIZE)
 645                         moea64_kenter(mmup, pa, pa);
 646                 size = BPVO_POOL_SIZE*sizeof(struct pvo_entry);
 647                 off = (vm_offset_t)(moea64_bpvo_pool);
 648                 for (pa = off; pa < off + size; pa += PAGE_SIZE)
 649                 moea64_kenter(mmup, pa, pa);
 650
 651                 /*
 652                  * Map certain important things, like ourselves.
 653                  *
 654                  * NOTE: We do not map the exception vector space. That code is
 655                  * used only in real mode, and leaving it unmapped allows us to
 656                  * catch NULL pointer deferences, instead of making NULL a valid
 657                  * address.
 658                  */
 659
 660                 for (pa = kernelstart & ~PAGE_MASK; pa < kernelend;
 661                     pa += PAGE_SIZE)
 662                         moea64_kenter(mmup, pa, pa);
 663         }
 664         ENABLE_TRANS(msr);
 665 }
 666
 667 void
 668 moea64_early_bootstrap(mmu_t mmup, vm_offset_t kernelstart, vm_offset_t kernelend)
 669 {
 670         int             i, j;
 671         vm_size_t       physsz, hwphyssz;
 672
 673 #ifndef __powerpc64__
 674         /* We don't have a direct map since there is no BAT */
 675         hw_direct_map = 0;
 676
 677         /* Make sure battable is zero, since we have no BAT */
 678         for (i = 0; i < 16; i++) {
 679                 battable[i].batu = 0;
 680                 battable[i].batl = 0;
 681         }
 682 #else
 683         moea64_probe_large_page();
 684
 685         /* Use a direct map if we have large page support */
 686         if (moea64_large_page_size > 0)
 687                 hw_direct_map = 1;
 688         else
 689                 hw_direct_map = 0;
 690 #endif
 691
 692         /* Get physical memory regions from firmware */
 693         mem_regions(&pregions, &pregions_sz, &regions, &regions_sz);
 694         CTR0(KTR_PMAP, "moea64_bootstrap: physical memory");
 695
 696         if (sizeof(phys_avail)/sizeof(phys_avail[0]) < regions_sz)
 697                 panic("moea64_bootstrap: phys_avail too small");
 698
 699         phys_avail_count = 0;
 700         physsz = 0;
 701         hwphyssz = 0;
 702         TUNABLE_ULONG_FETCH("hw.physmem", (u_long *) &hwphyssz);
 703         for (i = 0, j = 0; i < regions_sz; i++, j += 2) {
 704                 CTR3(KTR_PMAP, "region: %#x - %#x (%#x)", regions[i].mr_start,
 705                     regions[i].mr_start + regions[i].mr_size,
 706                     regions[i].mr_size);
 707                 if (hwphyssz != 0 &&
 708                     (physsz + regions[i].mr_size) >= hwphyssz) {
 709                         if (physsz < hwphyssz) {
 710                                 phys_avail[j] = regions[i].mr_start;
 711                                 phys_avail[j + 1] = regions[i].mr_start +
 712                                     hwphyssz - physsz;
 713                                 physsz = hwphyssz;
 714                                 phys_avail_count++;
 715                         }
 716                         break;
 717                 }
 718                 phys_avail[j] = regions[i].mr_start;
 719                 phys_avail[j + 1] = regions[i].mr_start + regions[i].mr_size;
 720                 phys_avail_count++;
 721                 physsz += regions[i].mr_size;
 722         }
 723
 724         /* Check for overlap with the kernel and exception vectors */
 725         for (j = 0; j < 2*phys_avail_count; j+=2) {
 726                 if (phys_avail[j] < EXC_LAST)
 727                         phys_avail[j] += EXC_LAST;
 728
 729                 if (kernelstart >= phys_avail[j] &&
 730                     kernelstart < phys_avail[j+1]) {
 731                         if (kernelend < phys_avail[j+1]) {
 732                                 phys_avail[2*phys_avail_count] =
 733                                     (kernelend & ~PAGE_MASK) + PAGE_SIZE;
 734                                 phys_avail[2*phys_avail_count + 1] =
 735                                     phys_avail[j+1];
 736                                 phys_avail_count++;
 737                         }
 738
 739                         phys_avail[j+1] = kernelstart & ~PAGE_MASK;
 740                 }
 741
 742                 if (kernelend >= phys_avail[j] &&
 743                     kernelend < phys_avail[j+1]) {
 744                         if (kernelstart > phys_avail[j]) {
 745                                 phys_avail[2*phys_avail_count] = phys_avail[j];
 746                                 phys_avail[2*phys_avail_count + 1] =
 747                                     kernelstart & ~PAGE_MASK;
 748                                 phys_avail_count++;
 749                         }
 750
 751                         phys_avail[j] = (kernelend & ~PAGE_MASK) + PAGE_SIZE;
 752                 }
 753         }
 754
 755         physmem = btoc(physsz);
 756
 757 #ifdef PTEGCOUNT
 758         moea64_pteg_count = PTEGCOUNT;
 759 #else
 760         moea64_pteg_count = 0x1000;
 761
 762         while (moea64_pteg_count < physmem)
 763                 moea64_pteg_count <<= 1;
 764
 765         moea64_pteg_count >>= 1;
 766 #endif /* PTEGCOUNT */
 767 }
 768
 769 void
 770 moea64_mid_bootstrap(mmu_t mmup, vm_offset_t kernelstart, vm_offset_t kernelend)
 771 {
 772         vm_size_t       size;
 773         register_t      msr;
 774         int             i;
 775
 776         /*
 777          * Set PTEG mask
 778          */
 779         moea64_pteg_mask = moea64_pteg_count - 1;
 780
 781         /*
 782          * Allocate pv/overflow lists.
 783          */
 784         size = sizeof(struct pvo_head) * moea64_pteg_count;
 785
 786         moea64_pvo_table = (struct pvo_head *)moea64_bootstrap_alloc(size,
 787             PAGE_SIZE);
 788         CTR1(KTR_PMAP, "moea64_bootstrap: PVO table at %p", moea64_pvo_table);
 789
 790         DISABLE_TRANS(msr);
 791         for (i = 0; i < moea64_pteg_count; i++)
 792                 LIST_INIT(&moea64_pvo_table[i]);
 793         ENABLE_TRANS(msr);
 794
 795         /*
 796          * Initialize the lock that synchronizes access to the pteg and pvo
 797          * tables.
 798          */
 799         mtx_init(&moea64_table_mutex, "pmap table", NULL, MTX_DEF |
 800             MTX_RECURSE);
 801         mtx_init(&moea64_slb_mutex, "SLB table", NULL, MTX_DEF);
 802
 803         /*
 804          * Initialise the unmanaged pvo pool.
 805          */
 806         moea64_bpvo_pool = (struct pvo_entry *)moea64_bootstrap_alloc(
 807                 BPVO_POOL_SIZE*sizeof(struct pvo_entry), 0);
 808         moea64_bpvo_pool_index = 0;
 809
 810         /*
 811          * Make sure kernel vsid is allocated as well as VSID 0.
 812          */
 813         #ifndef __powerpc64__
 814         moea64_vsid_bitmap[(KERNEL_VSIDBITS & (NVSIDS - 1)) / VSID_NBPW]
 815                 |= 1 << (KERNEL_VSIDBITS % VSID_NBPW);
 816         moea64_vsid_bitmap[0] |= 1;
 817         #endif
 818
 819         /*
 820          * Initialize the kernel pmap (which is statically allocated).
 821          */
 822         #ifdef __powerpc64__
 823         for (i = 0; i < 64; i++) {
 824                 pcpup->pc_slb[i].slbv = 0;
 825                 pcpup->pc_slb[i].slbe = 0;
 826         }
 827         #else
 828         for (i = 0; i < 16; i++)
 829                 kernel_pmap->pm_sr[i] = EMPTY_SEGMENT + i;
 830         #endif
 831
 832         kernel_pmap->pmap_phys = kernel_pmap;
 833         CPU_FILL(&kernel_pmap->pm_active);
 834
 835         PMAP_LOCK_INIT(kernel_pmap);
 836
 837         /*
 838          * Now map in all the other buffers we allocated earlier
 839          */
 840
 841         moea64_setup_direct_map(mmup, kernelstart, kernelend);
 842 }
 843
 844 void
 845 moea64_late_bootstrap(mmu_t mmup, vm_offset_t kernelstart, vm_offset_t kernelend)
 846 {
 847         ihandle_t       mmui;
 848         phandle_t       chosen;
 849         phandle_t       mmu;
 850         size_t          sz;
 851         int             i;
 852         vm_offset_t     pa, va;
 853         void            *dpcpu;
 854
 855         /*
 856          * Set up the Open Firmware pmap and add its mappings if not in real
 857          * mode.
 858          */
 859
 860         chosen = OF_finddevice("/chosen");
 861         if (chosen != -1 && OF_getprop(chosen, "mmu", &mmui, 4) != -1) {
 862             mmu = OF_instance_to_package(mmui);
 863             if (mmu == -1 || (sz = OF_getproplen(mmu, "translations")) == -1)
 864                 sz = 0;
 865             if (sz > 6144 /* tmpstksz - 2 KB headroom */)
 866                 panic("moea64_bootstrap: too many ofw translations");
 867
 868             if (sz > 0)
 869                 moea64_add_ofw_mappings(mmup, mmu, sz);
 870         }
 871
 872         /*
 873          * Calculate the last available physical address.
 874          */
 875         for (i = 0; phys_avail[i + 2] != 0; i += 2)
 876                 ;
 877         Maxmem = powerpc_btop(phys_avail[i + 1]);
 878
 879         /*
 880          * Initialize MMU and remap early physical mappings
 881          */
 882         MMU_CPU_BOOTSTRAP(mmup,0);
 883         mtmsr(mfmsr() | PSL_DR | PSL_IR);
 884         pmap_bootstrapped++;
 885         bs_remap_earlyboot();
 886
 887         /*
 888          * Set the start and end of kva.
 889          */
 890         virtual_avail = VM_MIN_KERNEL_ADDRESS;
 891         virtual_end = VM_MAX_SAFE_KERNEL_ADDRESS;
 892
 893         /*
 894          * Map the entire KVA range into the SLB. We must not fault there.
 895          */
 896         #ifdef __powerpc64__
 897         for (va = virtual_avail; va < virtual_end; va += SEGMENT_LENGTH)
 898                 moea64_bootstrap_slb_prefault(va, 0);
 899         #endif
 900
 901         /*
 902          * Figure out how far we can extend virtual_end into segment 16
 903          * without running into existing mappings. Segment 16 is guaranteed
 904          * to contain neither RAM nor devices (at least on Apple hardware),
 905          * but will generally contain some OFW mappings we should not
 906          * step on.
 907          */
 908
 909         #ifndef __powerpc64__   /* KVA is in high memory on PPC64 */
 910         PMAP_LOCK(kernel_pmap);
 911         while (virtual_end < VM_MAX_KERNEL_ADDRESS &&
 912             moea64_pvo_find_va(kernel_pmap, virtual_end+1) == NULL)
 913                 virtual_end += PAGE_SIZE;
 914         PMAP_UNLOCK(kernel_pmap);
 915         #endif
 916
 917         /*
 918          * Allocate a kernel stack with a guard page for thread0 and map it
 919          * into the kernel page map.
 920          */
 921         pa = moea64_bootstrap_alloc(KSTACK_PAGES * PAGE_SIZE, PAGE_SIZE);
 922         va = virtual_avail + KSTACK_GUARD_PAGES * PAGE_SIZE;
 923         virtual_avail = va + KSTACK_PAGES * PAGE_SIZE;
 924         CTR2(KTR_PMAP, "moea64_bootstrap: kstack0 at %#x (%#x)", pa, va);
 925         thread0.td_kstack = va;
 926         thread0.td_kstack_pages = KSTACK_PAGES;
 927         for (i = 0; i < KSTACK_PAGES; i++) {
 928                 moea64_kenter(mmup, va, pa);
 929                 pa += PAGE_SIZE;
 930                 va += PAGE_SIZE;
 931         }
 932
 933         /*
 934          * Allocate virtual address space for the message buffer.
 935          */
 936         pa = msgbuf_phys = moea64_bootstrap_alloc(msgbufsize, PAGE_SIZE);
 937         msgbufp = (struct msgbuf *)virtual_avail;
 938         va = virtual_avail;
 939         virtual_avail += round_page(msgbufsize);
 940         while (va < virtual_avail) {
 941                 moea64_kenter(mmup, va, pa);
 942                 pa += PAGE_SIZE;
 943                 va += PAGE_SIZE;
 944         }
 945
 946         /*
 947          * Allocate virtual address space for the dynamic percpu area.
 948          */
 949         pa = moea64_bootstrap_alloc(DPCPU_SIZE, PAGE_SIZE);
 950         dpcpu = (void *)virtual_avail;
 951         va = virtual_avail;
 952         virtual_avail += DPCPU_SIZE;
 953         while (va < virtual_avail) {
 954                 moea64_kenter(mmup, va, pa);
 955                 pa += PAGE_SIZE;
 956                 va += PAGE_SIZE;
 957         }
 958         dpcpu_init(dpcpu, 0);
 959
 960         /*
 961          * Allocate some things for page zeroing. We put this directly
 962          * in the page table, marked with LPTE_LOCKED, to avoid any
 963          * of the PVO book-keeping or other parts of the VM system
 964          * from even knowing that this hack exists.
 965          */
 966
 967         if (!hw_direct_map) {
 968                 mtx_init(&moea64_scratchpage_mtx, "pvo zero page", NULL,
 969                     MTX_DEF);
 970                 for (i = 0; i < 2; i++) {
 971                         moea64_scratchpage_va[i] = (virtual_end+1) - PAGE_SIZE;
 972                         virtual_end -= PAGE_SIZE;
 973
 974                         moea64_kenter(mmup, moea64_scratchpage_va[i], 0);
 975
 976                         moea64_scratchpage_pvo[i] = moea64_pvo_find_va(
 977                             kernel_pmap, (vm_offset_t)moea64_scratchpage_va[i]);
 978                         LOCK_TABLE();
 979                         moea64_scratchpage_pte[i] = MOEA64_PVO_TO_PTE(
 980                             mmup, moea64_scratchpage_pvo[i]);
 981                         moea64_scratchpage_pvo[i]->pvo_pte.lpte.pte_hi
 982                             |= LPTE_LOCKED;
 983                         MOEA64_PTE_CHANGE(mmup, moea64_scratchpage_pte[i],
 984                             &moea64_scratchpage_pvo[i]->pvo_pte.lpte,
 985                             moea64_scratchpage_pvo[i]->pvo_vpn);
 986                         UNLOCK_TABLE();
 987                 }
 988         }
 989 }
 990
 991 /*
 992  * Activate a user pmap.  The pmap must be activated before its address
 993  * space can be accessed in any way.
 994  */
 995 void
 996 moea64_activate(mmu_t mmu, struct thread *td)
 997 {
 998         pmap_t  pm;
 999
1000         pm = &td->td_proc->p_vmspace->vm_pmap;
1001         CPU_SET(PCPU_GET(cpuid), &pm->pm_active);
1002
1003         #ifdef __powerpc64__
1004         PCPU_SET(userslb, pm->pm_slb);
1005         #else
1006         PCPU_SET(curpmap, pm->pmap_phys);
1007         #endif
1008 }
1009
1010 void
1011 moea64_deactivate(mmu_t mmu, struct thread *td)
1012 {
1013         pmap_t  pm;
1014
1015         pm = &td->td_proc->p_vmspace->vm_pmap;
1016         CPU_CLR(PCPU_GET(cpuid), &pm->pm_active);
1017         #ifdef __powerpc64__
1018         PCPU_SET(userslb, NULL);
1019         #else
1020         PCPU_SET(curpmap, NULL);
1021         #endif
1022 }
1023
1024 void
1025 moea64_change_wiring(mmu_t mmu, pmap_t pm, vm_offset_t va, boolean_t wired)
1026 {
1027         struct  pvo_entry *pvo;
1028         uintptr_t pt;
1029         uint64_t vsid;
1030         int     i, ptegidx;
1031
1032         PMAP_LOCK(pm);
1033         pvo = moea64_pvo_find_va(pm, va & ~ADDR_POFF);
1034
1035         if (pvo != NULL) {
1036                 LOCK_TABLE();
1037                 pt = MOEA64_PVO_TO_PTE(mmu, pvo);
1038
1039                 if (wired) {
1040                         if ((pvo->pvo_vaddr & PVO_WIRED) == 0)
1041                                 pm->pm_stats.wired_count++;
1042                         pvo->pvo_vaddr |= PVO_WIRED;
1043                         pvo->pvo_pte.lpte.pte_hi |= LPTE_WIRED;
1044                 } else {
1045                         if ((pvo->pvo_vaddr & PVO_WIRED) != 0)
1046                                 pm->pm_stats.wired_count--;
1047                         pvo->pvo_vaddr &= ~PVO_WIRED;
1048                         pvo->pvo_pte.lpte.pte_hi &= ~LPTE_WIRED;
1049                 }
1050
1051                 if (pt != -1) {
1052                         /* Update wiring flag in page table. */
1053                         MOEA64_PTE_CHANGE(mmu, pt, &pvo->pvo_pte.lpte,
1054                             pvo->pvo_vpn);
1055                 } else if (wired) {
1056                         /*
1057                          * If we are wiring the page, and it wasn't in the
1058                          * page table before, add it.
1059                          */
1060                         vsid = PVO_VSID(pvo);
1061                         ptegidx = va_to_pteg(vsid, PVO_VADDR(pvo),
1062                             pvo->pvo_vaddr & PVO_LARGE);
1063
1064                         i = MOEA64_PTE_INSERT(mmu, ptegidx, &pvo->pvo_pte.lpte);
1065
1066                         if (i >= 0) {
1067                                 PVO_PTEGIDX_CLR(pvo);
1068                                 PVO_PTEGIDX_SET(pvo, i);
1069                         }
1070                 }
1071
1072                 UNLOCK_TABLE();
1073         }
1074         PMAP_UNLOCK(pm);
1075 }
1076
1077 /*
1078  * This goes through and sets the physical address of our
1079  * special scratch PTE to the PA we want to zero or copy. Because
1080  * of locking issues (this can get called in pvo_enter() by
1081  * the UMA allocator), we can't use most other utility functions here
1082  */
1083
1084 static __inline
1085 void moea64_set_scratchpage_pa(mmu_t mmup, int which, vm_offset_t pa) {
1086
1087         KASSERT(!hw_direct_map, ("Using OEA64 scratchpage with a direct map!"));
1088         mtx_assert(&moea64_scratchpage_mtx, MA_OWNED);
1089
1090         moea64_scratchpage_pvo[which]->pvo_pte.lpte.pte_lo &=
1091             ~(LPTE_WIMG | LPTE_RPGN);
1092         moea64_scratchpage_pvo[which]->pvo_pte.lpte.pte_lo |=
1093             moea64_calc_wimg(pa, VM_MEMATTR_DEFAULT) | (uint64_t)pa;
1094         MOEA64_PTE_CHANGE(mmup, moea64_scratchpage_pte[which],
1095             &moea64_scratchpage_pvo[which]->pvo_pte.lpte,
1096             moea64_scratchpage_pvo[which]->pvo_vpn);
1097         isync();
1098 }
1099
1100 void
1101 moea64_copy_page(mmu_t mmu, vm_page_t msrc, vm_page_t mdst)
1102 {
1103         vm_offset_t     dst;
1104         vm_offset_t     src;
1105
1106         dst = VM_PAGE_TO_PHYS(mdst);
1107         src = VM_PAGE_TO_PHYS(msrc);
1108
1109         if (hw_direct_map) {
1110                 kcopy((void *)src, (void *)dst, PAGE_SIZE);
1111         } else {
1112                 mtx_lock(&moea64_scratchpage_mtx);
1113
1114                 moea64_set_scratchpage_pa(mmu, 0, src);
1115                 moea64_set_scratchpage_pa(mmu, 1, dst);
1116
1117                 kcopy((void *)moea64_scratchpage_va[0],
1118                     (void *)moea64_scratchpage_va[1], PAGE_SIZE);
1119
1120                 mtx_unlock(&moea64_scratchpage_mtx);
1121         }
1122 }
1123
1124 void
1125 moea64_zero_page_area(mmu_t mmu, vm_page_t m, int off, int size)
1126 {
1127         vm_offset_t pa = VM_PAGE_TO_PHYS(m);
1128
1129         if (size + off > PAGE_SIZE)
1130                 panic("moea64_zero_page: size + off > PAGE_SIZE");
1131
1132         if (hw_direct_map) {
1133                 bzero((caddr_t)pa + off, size);
1134         } else {
1135                 mtx_lock(&moea64_scratchpage_mtx);
1136                 moea64_set_scratchpage_pa(mmu, 0, pa);
1137                 bzero((caddr_t)moea64_scratchpage_va[0] + off, size);
1138                 mtx_unlock(&moea64_scratchpage_mtx);
1139         }
1140 }
1141
1142 /*
1143  * Zero a page of physical memory by temporarily mapping it
1144  */
1145 void
1146 moea64_zero_page(mmu_t mmu, vm_page_t m)
1147 {
1148         vm_offset_t pa = VM_PAGE_TO_PHYS(m);
1149         vm_offset_t va, off;
1150
1151         if (!hw_direct_map) {
1152                 mtx_lock(&moea64_scratchpage_mtx);
1153
1154                 moea64_set_scratchpage_pa(mmu, 0, pa);
1155                 va = moea64_scratchpage_va[0];
1156         } else {
1157                 va = pa;
1158         }
1159
1160         for (off = 0; off < PAGE_SIZE; off += cacheline_size)
1161                 __asm __volatile("dcbz 0,%0" :: "r"(va + off));
1162
1163         if (!hw_direct_map)
1164                 mtx_unlock(&moea64_scratchpage_mtx);
1165 }
1166
1167 void
1168 moea64_zero_page_idle(mmu_t mmu, vm_page_t m)
1169 {
1170
1171         moea64_zero_page(mmu, m);
1172 }
1173
1174 /*
1175  * Map the given physical page at the specified virtual address in the
1176  * target pmap with the protection requested.  If specified the page
1177  * will be wired down.
1178  */
1179 void
1180 moea64_enter(mmu_t mmu, pmap_t pmap, vm_offset_t va, vm_page_t m,
1181     vm_prot_t prot, boolean_t wired)
1182 {
1183
1184         vm_page_lock_queues();
1185         PMAP_LOCK(pmap);
1186         moea64_enter_locked(mmu, pmap, va, m, prot, wired);
1187         vm_page_unlock_queues();
1188         PMAP_UNLOCK(pmap);
1189 }
1190
1191 /*
1192  * Map the given physical page at the specified virtual address in the
1193  * target pmap with the protection requested.  If specified the page
1194  * will be wired down.
1195  *
1196  * The page queues and pmap must be locked.
1197  */
1198
1199 static void
1200 moea64_enter_locked(mmu_t mmu, pmap_t pmap, vm_offset_t va, vm_page_t m,
1201     vm_prot_t prot, boolean_t wired)
1202 {
1203         struct          pvo_head *pvo_head;
1204         uma_zone_t      zone;
1205         vm_page_t       pg;
1206         uint64_t        pte_lo;
1207         u_int           pvo_flags;
1208         int             error;
1209
1210         if (!moea64_initialized) {
1211                 pvo_head = &moea64_pvo_kunmanaged;
1212                 pg = NULL;
1213                 zone = moea64_upvo_zone;
1214                 pvo_flags = 0;
1215         } else {
1216                 pvo_head = vm_page_to_pvoh(m);
1217                 pg = m;
1218                 zone = moea64_mpvo_zone;
1219                 pvo_flags = PVO_MANAGED;
1220         }
1221
1222         if (pmap_bootstrapped)
1223                 mtx_assert(&vm_page_queue_mtx, MA_OWNED);
1224         PMAP_LOCK_ASSERT(pmap, MA_OWNED);
1225         KASSERT((m->oflags & (VPO_UNMANAGED | VPO_BUSY)) != 0 ||
1226             VM_OBJECT_LOCKED(m->object),
1227             ("moea64_enter_locked: page %p is not busy", m));
1228
1229         /* XXX change the pvo head for fake pages */
1230         if ((m->oflags & VPO_UNMANAGED) != 0) {
1231                 pvo_flags &= ~PVO_MANAGED;
1232                 pvo_head = &moea64_pvo_kunmanaged;
1233                 zone = moea64_upvo_zone;
1234         }
1235
1236         pte_lo = moea64_calc_wimg(VM_PAGE_TO_PHYS(m), pmap_page_get_memattr(m));
1237
1238         if (prot & VM_PROT_WRITE) {
1239                 pte_lo |= LPTE_BW;
1240                 if (pmap_bootstrapped &&
1241                     (m->oflags & VPO_UNMANAGED) == 0)
1242                         vm_page_aflag_set(m, PGA_WRITEABLE);
1243         } else
1244                 pte_lo |= LPTE_BR;
1245
1246         if ((prot & VM_PROT_EXECUTE) == 0)
1247                 pte_lo |= LPTE_NOEXEC;
1248
1249         if (wired)
1250                 pvo_flags |= PVO_WIRED;
1251
1252         error = moea64_pvo_enter(mmu, pmap, zone, pvo_head, va,
1253             VM_PAGE_TO_PHYS(m), pte_lo, pvo_flags);
1254
1255         /*
1256          * Flush the page from the instruction cache if this page is
1257          * mapped executable and cacheable.
1258          */
1259         if ((pte_lo & (LPTE_I | LPTE_G | LPTE_NOEXEC)) == 0)
1260                 moea64_syncicache(mmu, pmap, va, VM_PAGE_TO_PHYS(m), PAGE_SIZE);
1261 }
1262
1263 static void
1264 moea64_syncicache(mmu_t mmu, pmap_t pmap, vm_offset_t va, vm_offset_t pa,
1265     vm_size_t sz)
1266 {
1267
1268         /*
1269          * This is much trickier than on older systems because
1270          * we can't sync the icache on physical addresses directly
1271          * without a direct map. Instead we check a couple of cases
1272          * where the memory is already mapped in and, failing that,
1273          * use the same trick we use for page zeroing to create
1274          * a temporary mapping for this physical address.
1275          */
1276
1277         if (!pmap_bootstrapped) {
1278                 /*
1279                  * If PMAP is not bootstrapped, we are likely to be
1280                  * in real mode.
1281                  */
1282                 __syncicache((void *)pa, sz);
1283         } else if (pmap == kernel_pmap) {
1284                 __syncicache((void *)va, sz);
1285         } else if (hw_direct_map) {
1286                 __syncicache((void *)pa, sz);
1287         } else {
1288                 /* Use the scratch page to set up a temp mapping */
1289
1290                 mtx_lock(&moea64_scratchpage_mtx);
1291
1292                 moea64_set_scratchpage_pa(mmu, 1, pa & ~ADDR_POFF);
1293                 __syncicache((void *)(moea64_scratchpage_va[1] +
1294                     (va & ADDR_POFF)), sz);
1295
1296                 mtx_unlock(&moea64_scratchpage_mtx);
1297         }
1298 }
1299
1300 /*
1301  * Maps a sequence of resident pages belonging to the same object.
1302  * The sequence begins with the given page m_start.  This page is
1303  * mapped at the given virtual address start.  Each subsequent page is
1304  * mapped at a virtual address that is offset from start by the same
1305  * amount as the page is offset from m_start within the object.  The
1306  * last page in the sequence is the page with the largest offset from
1307  * m_start that can be mapped at a virtual address less than the given
1308  * virtual address end.  Not every virtual page between start and end
1309  * is mapped; only those for which a resident page exists with the
1310  * corresponding offset from m_start are mapped.
1311  */
1312 void
1313 moea64_enter_object(mmu_t mmu, pmap_t pm, vm_offset_t start, vm_offset_t end,
1314     vm_page_t m_start, vm_prot_t prot)
1315 {
1316         vm_page_t m;
1317         vm_pindex_t diff, psize;
1318
1319         psize = atop(end - start);
1320         m = m_start;
1321         vm_page_lock_queues();
1322         PMAP_LOCK(pm);
1323         while (m != NULL && (diff = m->pindex - m_start->pindex) < psize) {
1324                 moea64_enter_locked(mmu, pm, start + ptoa(diff), m, prot &
1325                     (VM_PROT_READ | VM_PROT_EXECUTE), FALSE);
1326                 m = TAILQ_NEXT(m, listq);
1327         }
1328         vm_page_unlock_queues();
1329         PMAP_UNLOCK(pm);
1330 }
1331
1332 void
1333 moea64_enter_quick(mmu_t mmu, pmap_t pm, vm_offset_t va, vm_page_t m,
1334     vm_prot_t prot)
1335 {
1336
1337         vm_page_lock_queues();
1338         PMAP_LOCK(pm);
1339         moea64_enter_locked(mmu, pm, va, m,
1340             prot & (VM_PROT_READ | VM_PROT_EXECUTE), FALSE);
1341         vm_page_unlock_queues();
1342         PMAP_UNLOCK(pm);
1343 }
1344
1345 vm_paddr_t
1346 moea64_extract(mmu_t mmu, pmap_t pm, vm_offset_t va)
1347 {
1348         struct  pvo_entry *pvo;
1349         vm_paddr_t pa;
1350
1351         PMAP_LOCK(pm);
1352         pvo = moea64_pvo_find_va(pm, va);
1353         if (pvo == NULL)
1354                 pa = 0;
1355         else
1356                 pa = (pvo->pvo_pte.lpte.pte_lo & LPTE_RPGN) |
1357                     (va - PVO_VADDR(pvo));
1358         PMAP_UNLOCK(pm);
1359         return (pa);
1360 }
1361
1362 /*
1363  * Atomically extract and hold the physical page with the given
1364  * pmap and virtual address pair if that mapping permits the given
1365  * protection.
1366  */
1367 vm_page_t
1368 moea64_extract_and_hold(mmu_t mmu, pmap_t pmap, vm_offset_t va, vm_prot_t prot)
1369 {
1370         struct  pvo_entry *pvo;
1371         vm_page_t m;
1372         vm_paddr_t pa;
1373
1374         m = NULL;
1375         pa = 0;
1376         PMAP_LOCK(pmap);
1377 retry:
1378         pvo = moea64_pvo_find_va(pmap, va & ~ADDR_POFF);
1379         if (pvo != NULL && (pvo->pvo_pte.lpte.pte_hi & LPTE_VALID) &&
1380             ((pvo->pvo_pte.lpte.pte_lo & LPTE_PP) == LPTE_RW ||
1381              (prot & VM_PROT_WRITE) == 0)) {
1382                 if (vm_page_pa_tryrelock(pmap,
1383                         pvo->pvo_pte.lpte.pte_lo & LPTE_RPGN, &pa))
1384                         goto retry;
1385                 m = PHYS_TO_VM_PAGE(pvo->pvo_pte.lpte.pte_lo & LPTE_RPGN);
1386                 vm_page_hold(m);
1387         }
1388         PA_UNLOCK_COND(pa);
1389         PMAP_UNLOCK(pmap);
1390         return (m);
1391 }
1392
1393 static mmu_t installed_mmu;
1394
1395 static void *
1396 moea64_uma_page_alloc(uma_zone_t zone, int bytes, u_int8_t *flags, int wait)
1397 {
1398         /*
1399          * This entire routine is a horrible hack to avoid bothering kmem
1400          * for new KVA addresses. Because this can get called from inside
1401          * kmem allocation routines, calling kmem for a new address here
1402          * can lead to multiply locking non-recursive mutexes.
1403          */
1404         static vm_pindex_t color;
1405         vm_offset_t va;
1406
1407         vm_page_t m;
1408         int pflags, needed_lock;
1409
1410         *flags = UMA_SLAB_PRIV;
1411         needed_lock = !PMAP_LOCKED(kernel_pmap);
1412
1413         if (needed_lock)
1414                 PMAP_LOCK(kernel_pmap);
1415
1416         if ((wait & (M_NOWAIT|M_USE_RESERVE)) == M_NOWAIT)
1417                 pflags = VM_ALLOC_INTERRUPT | VM_ALLOC_WIRED;
1418         else
1419                 pflags = VM_ALLOC_SYSTEM | VM_ALLOC_WIRED;
1420         if (wait & M_ZERO)
1421                 pflags |= VM_ALLOC_ZERO;
1422
1423         for (;;) {
1424                 m = vm_page_alloc(NULL, color++, pflags | VM_ALLOC_NOOBJ);
1425                 if (m == NULL) {
1426                         if (wait & M_NOWAIT)
1427                                 return (NULL);
1428                         VM_WAIT;
1429                 } else
1430                         break;
1431         }
1432
1433         va = VM_PAGE_TO_PHYS(m);
1434
1435         moea64_pvo_enter(installed_mmu, kernel_pmap, moea64_upvo_zone,
1436             &moea64_pvo_kunmanaged, va, VM_PAGE_TO_PHYS(m), LPTE_M,
1437             PVO_WIRED | PVO_BOOTSTRAP);
1438
1439         if (needed_lock)
1440                 PMAP_UNLOCK(kernel_pmap);
1441
1442         if ((wait & M_ZERO) && (m->flags & PG_ZERO) == 0)
1443                 bzero((void *)va, PAGE_SIZE);
1444
1445         return (void *)va;
1446 }
1447
1448 void
1449 moea64_init(mmu_t mmu)
1450 {
1451
1452         CTR0(KTR_PMAP, "moea64_init");
1453
1454         moea64_upvo_zone = uma_zcreate("UPVO entry", sizeof (struct pvo_entry),
1455             NULL, NULL, NULL, NULL, UMA_ALIGN_PTR,
1456             UMA_ZONE_VM | UMA_ZONE_NOFREE);
1457         moea64_mpvo_zone = uma_zcreate("MPVO entry", sizeof(struct pvo_entry),
1458             NULL, NULL, NULL, NULL, UMA_ALIGN_PTR,
1459             UMA_ZONE_VM | UMA_ZONE_NOFREE);
1460
1461         if (!hw_direct_map) {
1462                 installed_mmu = mmu;
1463                 uma_zone_set_allocf(moea64_upvo_zone,moea64_uma_page_alloc);
1464                 uma_zone_set_allocf(moea64_mpvo_zone,moea64_uma_page_alloc);
1465         }
1466
1467         moea64_initialized = TRUE;
1468 }
1469
1470 boolean_t
1471 moea64_is_referenced(mmu_t mmu, vm_page_t m)
1472 {
1473
1474         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
1475             ("moea64_is_referenced: page %p is not managed", m));
1476         return (moea64_query_bit(mmu, m, PTE_REF));
1477 }
1478
1479 boolean_t
1480 moea64_is_modified(mmu_t mmu, vm_page_t m)
1481 {
1482
1483         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
1484             ("moea64_is_modified: page %p is not managed", m));
1485
1486         /*
1487          * If the page is not VPO_BUSY, then PGA_WRITEABLE cannot be
1488          * concurrently set while the object is locked.  Thus, if PGA_WRITEABLE
1489          * is clear, no PTEs can have LPTE_CHG set.
1490          */
1491         VM_OBJECT_LOCK_ASSERT(m->object, MA_OWNED);
1492         if ((m->oflags & VPO_BUSY) == 0 &&
1493             (m->aflags & PGA_WRITEABLE) == 0)
1494                 return (FALSE);
1495         return (moea64_query_bit(mmu, m, LPTE_CHG));
1496 }
1497
1498 boolean_t
1499 moea64_is_prefaultable(mmu_t mmu, pmap_t pmap, vm_offset_t va)
1500 {
1501         struct pvo_entry *pvo;
1502         boolean_t rv;
1503
1504         PMAP_LOCK(pmap);
1505         pvo = moea64_pvo_find_va(pmap, va & ~ADDR_POFF);
1506         rv = pvo == NULL || (pvo->pvo_pte.lpte.pte_hi & LPTE_VALID) == 0;
1507         PMAP_UNLOCK(pmap);
1508         return (rv);
1509 }
1510
1511 void
1512 moea64_clear_reference(mmu_t mmu, vm_page_t m)
1513 {
1514
1515         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
1516             ("moea64_clear_reference: page %p is not managed", m));
1517         moea64_clear_bit(mmu, m, LPTE_REF);
1518 }
1519
1520 void
1521 moea64_clear_modify(mmu_t mmu, vm_page_t m)
1522 {
1523
1524         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
1525             ("moea64_clear_modify: page %p is not managed", m));
1526         VM_OBJECT_LOCK_ASSERT(m->object, MA_OWNED);
1527         KASSERT((m->oflags & VPO_BUSY) == 0,
1528             ("moea64_clear_modify: page %p is busy", m));
1529
1530         /*
1531          * If the page is not PGA_WRITEABLE, then no PTEs can have LPTE_CHG
1532          * set.  If the object containing the page is locked and the page is
1533          * not VPO_BUSY, then PGA_WRITEABLE cannot be concurrently set.
1534          */
1535         if ((m->aflags & PGA_WRITEABLE) == 0)
1536                 return;
1537         moea64_clear_bit(mmu, m, LPTE_CHG);
1538 }
1539
1540 /*
1541  * Clear the write and modified bits in each of the given page's mappings.
1542  */
1543 void
1544 moea64_remove_write(mmu_t mmu, vm_page_t m)
1545 {
1546         struct  pvo_entry *pvo;
1547         uintptr_t pt;
1548         pmap_t  pmap;
1549         uint64_t lo;
1550
1551         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
1552             ("moea64_remove_write: page %p is not managed", m));
1553
1554         /*
1555          * If the page is not VPO_BUSY, then PGA_WRITEABLE cannot be set by
1556          * another thread while the object is locked.  Thus, if PGA_WRITEABLE
1557          * is clear, no page table entries need updating.
1558          */
1559         VM_OBJECT_LOCK_ASSERT(m->object, MA_OWNED);
1560         if ((m->oflags & VPO_BUSY) == 0 &&
1561             (m->aflags & PGA_WRITEABLE) == 0)
1562                 return;
1563         vm_page_lock_queues();
1564         lo = moea64_attr_fetch(m);
1565         powerpc_sync();
1566         LIST_FOREACH(pvo, vm_page_to_pvoh(m), pvo_vlink) {
1567                 pmap = pvo->pvo_pmap;
1568                 PMAP_LOCK(pmap);
1569                 LOCK_TABLE();
1570                 if ((pvo->pvo_pte.lpte.pte_lo & LPTE_PP) != LPTE_BR) {
1571                         pt = MOEA64_PVO_TO_PTE(mmu, pvo);
1572                         pvo->pvo_pte.lpte.pte_lo &= ~LPTE_PP;
1573                         pvo->pvo_pte.lpte.pte_lo |= LPTE_BR;
1574                         if (pt != -1) {
1575                                 MOEA64_PTE_SYNCH(mmu, pt, &pvo->pvo_pte.lpte);
1576                                 lo |= pvo->pvo_pte.lpte.pte_lo;
1577                                 pvo->pvo_pte.lpte.pte_lo &= ~LPTE_CHG;
1578                                 MOEA64_PTE_CHANGE(mmu, pt,
1579                                     &pvo->pvo_pte.lpte, pvo->pvo_vpn);
1580                                 if (pvo->pvo_pmap == kernel_pmap)
1581                                         isync();
1582                         }
1583                 }
1584                 UNLOCK_TABLE();
1585                 PMAP_UNLOCK(pmap);
1586         }
1587         if ((lo & LPTE_CHG) != 0) {
1588                 moea64_attr_clear(m, LPTE_CHG);
1589                 vm_page_dirty(m);
1590         }
1591         vm_page_aflag_clear(m, PGA_WRITEABLE);
1592         vm_page_unlock_queues();
1593 }
1594
1595 /*
1596  *      moea64_ts_referenced:
1597  *
1598  *      Return a count of reference bits for a page, clearing those bits.
1599  *      It is not necessary for every reference bit to be cleared, but it
1600  *      is necessary that 0 only be returned when there are truly no
1601  *      reference bits set.
1602  *
1603  *      XXX: The exact number of bits to check and clear is a matter that
1604  *      should be tested and standardized at some point in the future for
1605  *      optimal aging of shared pages.
1606  */
1607 boolean_t
1608 moea64_ts_referenced(mmu_t mmu, vm_page_t m)
1609 {
1610
1611         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
1612             ("moea64_ts_referenced: page %p is not managed", m));
1613         return (moea64_clear_bit(mmu, m, LPTE_REF));
1614 }
1615
1616 /*
1617  * Modify the WIMG settings of all mappings for a page.
1618  */
1619 void
1620 moea64_page_set_memattr(mmu_t mmu, vm_page_t m, vm_memattr_t ma)
1621 {
1622         struct  pvo_entry *pvo;
1623         struct  pvo_head *pvo_head;
1624         uintptr_t pt;
1625         pmap_t  pmap;
1626         uint64_t lo;
1627
1628         if ((m->oflags & VPO_UNMANAGED) != 0) {
1629                 m->md.mdpg_cache_attrs = ma;
1630                 return;
1631         }
1632
1633         vm_page_lock_queues();
1634         pvo_head = vm_page_to_pvoh(m);
1635         lo = moea64_calc_wimg(VM_PAGE_TO_PHYS(m), ma);
1636         LIST_FOREACH(pvo, pvo_head, pvo_vlink) {
1637                 pmap = pvo->pvo_pmap;
1638                 PMAP_LOCK(pmap);
1639                 LOCK_TABLE();
1640                 pt = MOEA64_PVO_TO_PTE(mmu, pvo);
1641                 pvo->pvo_pte.lpte.pte_lo &= ~LPTE_WIMG;
1642                 pvo->pvo_pte.lpte.pte_lo |= lo;
1643                 if (pt != -1) {
1644                         MOEA64_PTE_CHANGE(mmu, pt, &pvo->pvo_pte.lpte,
1645                             pvo->pvo_vpn);
1646                         if (pvo->pvo_pmap == kernel_pmap)
1647                                 isync();
1648                 }
1649                 UNLOCK_TABLE();
1650                 PMAP_UNLOCK(pmap);
1651         }
1652         m->md.mdpg_cache_attrs = ma;
1653         vm_page_unlock_queues();
1654 }
1655
1656 /*
1657  * Map a wired page into kernel virtual address space.
1658  */
1659 void
1660 moea64_kenter_attr(mmu_t mmu, vm_offset_t va, vm_offset_t pa, vm_memattr_t ma)
1661 {
1662         uint64_t        pte_lo;
1663         int             error;
1664
1665         pte_lo = moea64_calc_wimg(pa, ma);
1666
1667         PMAP_LOCK(kernel_pmap);
1668         error = moea64_pvo_enter(mmu, kernel_pmap, moea64_upvo_zone,
1669             &moea64_pvo_kunmanaged, va, pa, pte_lo, PVO_WIRED);
1670
1671         if (error != 0 && error != ENOENT)
1672                 panic("moea64_kenter: failed to enter va %#zx pa %#zx: %d", va,
1673                     pa, error);
1674
1675         /*
1676          * Flush the memory from the instruction cache.
1677          */
1678         if ((pte_lo & (LPTE_I | LPTE_G)) == 0)
1679                 __syncicache((void *)va, PAGE_SIZE);
1680         PMAP_UNLOCK(kernel_pmap);
1681 }
1682
1683 void
1684 moea64_kenter(mmu_t mmu, vm_offset_t va, vm_offset_t pa)
1685 {
1686
1687         moea64_kenter_attr(mmu, va, pa, VM_MEMATTR_DEFAULT);
1688 }
1689
1690 /*
1691  * Extract the physical page address associated with the given kernel virtual
1692  * address.
1693  */
1694 vm_offset_t
1695 moea64_kextract(mmu_t mmu, vm_offset_t va)
1696 {
1697         struct          pvo_entry *pvo;
1698         vm_paddr_t pa;
1699
1700         /*
1701          * Shortcut the direct-mapped case when applicable.  We never put
1702          * anything but 1:1 mappings below VM_MIN_KERNEL_ADDRESS.
1703          */
1704         if (va < VM_MIN_KERNEL_ADDRESS)
1705                 return (va);
1706
1707         PMAP_LOCK(kernel_pmap);
1708         pvo = moea64_pvo_find_va(kernel_pmap, va);
1709         KASSERT(pvo != NULL, ("moea64_kextract: no addr found for %#" PRIxPTR,
1710             va));
1711         pa = (pvo->pvo_pte.lpte.pte_lo & LPTE_RPGN) | (va - PVO_VADDR(pvo));
1712         PMAP_UNLOCK(kernel_pmap);
1713         return (pa);
1714 }
1715
1716 /*
1717  * Remove a wired page from kernel virtual address space.
1718  */
1719 void
1720 moea64_kremove(mmu_t mmu, vm_offset_t va)
1721 {
1722         moea64_remove(mmu, kernel_pmap, va, va + PAGE_SIZE);
1723 }
1724
1725 /*
1726  * Map a range of physical addresses into kernel virtual address space.
1727  *
1728  * The value passed in *virt is a suggested virtual address for the mapping.
1729  * Architectures which can support a direct-mapped physical to virtual region
1730  * can return the appropriate address within that region, leaving '*virt'
1731  * unchanged.  We cannot and therefore do not; *virt is updated with the
1732  * first usable address after the mapped region.
1733  */
1734 vm_offset_t
1735 moea64_map(mmu_t mmu, vm_offset_t *virt, vm_offset_t pa_start,
1736     vm_offset_t pa_end, int prot)
1737 {
1738         vm_offset_t     sva, va;
1739
1740         sva = *virt;
1741         va = sva;
1742         for (; pa_start < pa_end; pa_start += PAGE_SIZE, va += PAGE_SIZE)
1743                 moea64_kenter(mmu, va, pa_start);
1744         *virt = va;
1745
1746         return (sva);
1747 }
1748
1749 /*
1750  * Returns true if the pmap's pv is one of the first
1751  * 16 pvs linked to from this page.  This count may
1752  * be changed upwards or downwards in the future; it
1753  * is only necessary that true be returned for a small
1754  * subset of pmaps for proper page aging.
1755  */
1756 boolean_t
1757 moea64_page_exists_quick(mmu_t mmu, pmap_t pmap, vm_page_t m)
1758 {
1759         int loops;
1760         struct pvo_entry *pvo;
1761         boolean_t rv;
1762
1763         KASSERT((m->oflags & VPO_UNMANAGED) == 0,
1764             ("moea64_page_exists_quick: page %p is not managed", m));
1765         loops = 0;
1766         rv = FALSE;
1767         vm_page_lock_queues();
1768         LIST_FOREACH(pvo, vm_page_to_pvoh(m), pvo_vlink) {
1769                 if (pvo->pvo_pmap == pmap) {
1770                         rv = TRUE;
1771                         break;
1772                 }
1773                 if (++loops >= 16)
1774                         break;
1775         }
1776         vm_page_unlock_queues();
1777         return (rv);
1778 }
1779
1780 /*
1781  * Return the number of managed mappings to the given physical page
1782  * that are wired.
1783  */
1784 int
1785 moea64_page_wired_mappings(mmu_t mmu, vm_page_t m)
1786 {
1787         struct pvo_entry *pvo;
1788         int count;
1789
1790         count = 0;
1791         if ((m->oflags & VPO_UNMANAGED) != 0)
1792                 return (count);
1793         vm_page_lock_queues();
1794         LIST_FOREACH(pvo, vm_page_to_pvoh(m), pvo_vlink)
1795                 if ((pvo->pvo_vaddr & PVO_WIRED) != 0)
1796                         count++;
1797         vm_page_unlock_queues();
1798         return (count);
1799 }
1800
1801 static uintptr_t        moea64_vsidcontext;
1802
1803 uintptr_t
1804 moea64_get_unique_vsid(void) {
1805         u_int entropy;
1806         register_t hash;
1807         uint32_t mask;
1808         int i;
1809
1810         entropy = 0;
1811         __asm __volatile("mftb %0" : "=r"(entropy));
1812
1813         mtx_lock(&moea64_slb_mutex);
1814         for (i = 0; i < NVSIDS; i += VSID_NBPW) {
1815                 u_int   n;
1816
1817                 /*
1818                  * Create a new value by mutiplying by a prime and adding in
1819                  * entropy from the timebase register.  This is to make the
1820                  * VSID more random so that the PT hash function collides
1821                  * less often.  (Note that the prime casues gcc to do shifts
1822                  * instead of a multiply.)
1823                  */
1824                 moea64_vsidcontext = (moea64_vsidcontext * 0x1105) + entropy;
1825                 hash = moea64_vsidcontext & (NVSIDS - 1);
1826                 if (hash == 0)          /* 0 is special, avoid it */
1827                         continue;
1828                 n = hash >> 5;
1829                 mask = 1 << (hash & (VSID_NBPW - 1));
1830                 hash = (moea64_vsidcontext & VSID_HASHMASK);
1831                 if (moea64_vsid_bitmap[n] & mask) {     /* collision? */
1832                         /* anything free in this bucket? */
1833                         if (moea64_vsid_bitmap[n] == 0xffffffff) {
1834                                 entropy = (moea64_vsidcontext >> 20);
1835                                 continue;
1836                         }
1837                         i = ffs(~moea64_vsid_bitmap[n]) - 1;
1838                         mask = 1 << i;
1839                         hash &= VSID_HASHMASK & ~(VSID_NBPW - 1);
1840                         hash |= i;
1841                 }
1842                 KASSERT(!(moea64_vsid_bitmap[n] & mask),
1843                     ("Allocating in-use VSID %#zx\n", hash));
1844                 moea64_vsid_bitmap[n] |= mask;
1845                 mtx_unlock(&moea64_slb_mutex);
1846                 return (hash);
1847         }
1848
1849         mtx_unlock(&moea64_slb_mutex);
1850         panic("%s: out of segments",__func__);
1851 }
1852
1853 #ifdef __powerpc64__
1854 void
1855 moea64_pinit(mmu_t mmu, pmap_t pmap)
1856 {
1857         PMAP_LOCK_INIT(pmap);
1858
1859         pmap->pm_slb_tree_root = slb_alloc_tree();
1860         pmap->pm_slb = slb_alloc_user_cache();
1861         pmap->pm_slb_len = 0;
1862 }
1863 #else
1864 void
1865 moea64_pinit(mmu_t mmu, pmap_t pmap)
1866 {
1867         int     i;
1868         uint32_t hash;
1869
1870         PMAP_LOCK_INIT(pmap);
1871
1872         if (pmap_bootstrapped)
1873                 pmap->pmap_phys = (pmap_t)moea64_kextract(mmu,
1874                     (vm_offset_t)pmap);
1875         else
1876                 pmap->pmap_phys = pmap;
1877
1878         /*
1879          * Allocate some segment registers for this pmap.
1880          */
1881         hash = moea64_get_unique_vsid();
1882
1883         for (i = 0; i < 16; i++)
1884                 pmap->pm_sr[i] = VSID_MAKE(i, hash);
1885
1886         KASSERT(pmap->pm_sr[0] != 0, ("moea64_pinit: pm_sr[0] = 0"));
1887 }
1888 #endif
1889
1890 /*
1891  * Initialize the pmap associated with process 0.
1892  */
1893 void
1894 moea64_pinit0(mmu_t mmu, pmap_t pm)
1895 {
1896         moea64_pinit(mmu, pm);
1897         bzero(&pm->pm_stats, sizeof(pm->pm_stats));
1898 }
1899
1900 /*
1901  * Set the physical protection on the specified range of this map as requested.
1902  */
1903 void
1904 moea64_protect(mmu_t mmu, pmap_t pm, vm_offset_t sva, vm_offset_t eva,
1905     vm_prot_t prot)
1906 {
1907         struct  pvo_entry *pvo;
1908         uintptr_t pt;
1909
1910         CTR4(KTR_PMAP, "moea64_protect: pm=%p sva=%#x eva=%#x prot=%#x", pm, sva,
1911             eva, prot);
1912
1913
1914         KASSERT(pm == &curproc->p_vmspace->vm_pmap || pm == kernel_pmap,
1915             ("moea64_protect: non current pmap"));
1916
1917         if ((prot & VM_PROT_READ) == VM_PROT_NONE) {
1918                 moea64_remove(mmu, pm, sva, eva);
1919                 return;
1920         }
1921
1922         vm_page_lock_queues();
1923         PMAP_LOCK(pm);
1924         for (; sva < eva; sva += PAGE_SIZE) {
1925                 pvo = moea64_pvo_find_va(pm, sva);
1926                 if (pvo == NULL)
1927                         continue;
1928
1929                 /*
1930                  * Grab the PTE pointer before we diddle with the cached PTE
1931                  * copy.
1932                  */
1933                 LOCK_TABLE();
1934                 pt = MOEA64_PVO_TO_PTE(mmu, pvo);
1935
1936                 /*
1937                  * Change the protection of the page.
1938                  */
1939                 pvo->pvo_pte.lpte.pte_lo &= ~LPTE_PP;
1940                 pvo->pvo_pte.lpte.pte_lo |= LPTE_BR;
1941                 pvo->pvo_pte.lpte.pte_lo &= ~LPTE_NOEXEC;
1942                 if ((prot & VM_PROT_EXECUTE) == 0)
1943                         pvo->pvo_pte.lpte.pte_lo |= LPTE_NOEXEC;
1944
1945                 /*
1946                  * If the PVO is in the page table, update that pte as well.
1947                  */
1948                 if (pt != -1) {
1949                         MOEA64_PTE_CHANGE(mmu, pt, &pvo->pvo_pte.lpte,
1950                             pvo->pvo_vpn);
1951                         if ((pvo->pvo_pte.lpte.pte_lo &
1952                             (LPTE_I | LPTE_G | LPTE_NOEXEC)) == 0) {
1953                                 moea64_syncicache(mmu, pm, sva,
1954                                     pvo->pvo_pte.lpte.pte_lo & LPTE_RPGN,
1955                                     PAGE_SIZE);
1956                         }
1957                 }
1958                 UNLOCK_TABLE();
1959         }
1960         vm_page_unlock_queues();
1961         PMAP_UNLOCK(pm);
1962 }
1963
1964 /*
1965  * Map a list of wired pages into kernel virtual address space.  This is
1966  * intended for temporary mappings which do not need page modification or
1967  * references recorded.  Existing mappings in the region are overwritten.
1968  */
1969 void
1970 moea64_qenter(mmu_t mmu, vm_offset_t va, vm_page_t *m, int count)
1971 {
1972         while (count-- > 0) {
1973                 moea64_kenter(mmu, va, VM_PAGE_TO_PHYS(*m));
1974                 va += PAGE_SIZE;
1975                 m++;
1976         }
1977 }
1978
1979 /*
1980  * Remove page mappings from kernel virtual address space.  Intended for
1981  * temporary mappings entered by moea64_qenter.
1982  */
1983 void
1984 moea64_qremove(mmu_t mmu, vm_offset_t va, int count)
1985 {
1986         while (count-- > 0) {
1987                 moea64_kremove(mmu, va);
1988                 va += PAGE_SIZE;
1989         }
1990 }
1991
1992 void
1993 moea64_release_vsid(uint64_t vsid)
1994 {
1995         int idx, mask;
1996
1997         mtx_lock(&moea64_slb_mutex);
1998         idx = vsid & (NVSIDS-1);
1999         mask = 1 << (idx % VSID_NBPW);
2000         idx /= VSID_NBPW;
2001         KASSERT(moea64_vsid_bitmap[idx] & mask,
2002             ("Freeing unallocated VSID %#jx", vsid));
2003         moea64_vsid_bitmap[idx] &= ~mask;
2004         mtx_unlock(&moea64_slb_mutex);
2005 }
2006
2007
2008 void
2009 moea64_release(mmu_t mmu, pmap_t pmap)
2010 {
2011
2012         /*
2013          * Free segment registers' VSIDs
2014          */
2015     #ifdef __powerpc64__
2016         slb_free_tree(pmap);
2017         slb_free_user_cache(pmap->pm_slb);
2018     #else
2019         KASSERT(pmap->pm_sr[0] != 0, ("moea64_release: pm_sr[0] = 0"));
2020
2021         moea64_release_vsid(VSID_TO_HASH(pmap->pm_sr[0]));
2022     #endif
2023
2024         PMAP_LOCK_DESTROY(pmap);
2025 }
2026
2027 /*
2028  * Remove the given range of addresses from the specified map.
2029  */
2030 void
2031 moea64_remove(mmu_t mmu, pmap_t pm, vm_offset_t sva, vm_offset_t eva)
2032 {
2033         struct  pvo_entry *pvo;
2034
2035         vm_page_lock_queues();
2036         PMAP_LOCK(pm);
2037         for (; sva < eva; sva += PAGE_SIZE) {
2038                 pvo = moea64_pvo_find_va(pm, sva);
2039                 if (pvo != NULL)
2040                         moea64_pvo_remove(mmu, pvo);
2041         }
2042         vm_page_unlock_queues();
2043         PMAP_UNLOCK(pm);
2044 }
2045
2046 /*
2047  * Remove physical page from all pmaps in which it resides. moea64_pvo_remove()
2048  * will reflect changes in pte's back to the vm_page.
2049  */
2050 void
2051 moea64_remove_all(mmu_t mmu, vm_page_t m)
2052 {
2053         struct  pvo_head *pvo_head;
2054         struct  pvo_entry *pvo, *next_pvo;
2055         pmap_t  pmap;
2056
2057         vm_page_lock_queues();
2058         pvo_head = vm_page_to_pvoh(m);
2059         for (pvo = LIST_FIRST(pvo_head); pvo != NULL; pvo = next_pvo) {
2060                 next_pvo = LIST_NEXT(pvo, pvo_vlink);
2061
2062                 pmap = pvo->pvo_pmap;
2063                 PMAP_LOCK(pmap);
2064                 moea64_pvo_remove(mmu, pvo);
2065                 PMAP_UNLOCK(pmap);
2066         }
2067         if ((m->aflags & PGA_WRITEABLE) && moea64_is_modified(mmu, m)) {
2068                 moea64_attr_clear(m, LPTE_CHG);
2069                 vm_page_dirty(m);
2070         }
2071         vm_page_aflag_clear(m, PGA_WRITEABLE);
2072         vm_page_unlock_queues();
2073 }
2074
2075 /*
2076  * Allocate a physical page of memory directly from the phys_avail map.
2077  * Can only be called from moea64_bootstrap before avail start and end are
2078  * calculated.
2079  */
2080 vm_offset_t
2081 moea64_bootstrap_alloc(vm_size_t size, u_int align)
2082 {
2083         vm_offset_t     s, e;
2084         int             i, j;
2085
2086         size = round_page(size);
2087         for (i = 0; phys_avail[i + 1] != 0; i += 2) {
2088                 if (align != 0)
2089                         s = (phys_avail[i] + align - 1) & ~(align - 1);
2090                 else
2091                         s = phys_avail[i];
2092                 e = s + size;
2093
2094                 if (s < phys_avail[i] || e > phys_avail[i + 1])
2095                         continue;
2096
2097                 if (s + size > platform_real_maxaddr())
2098                         continue;
2099
2100                 if (s == phys_avail[i]) {
2101                         phys_avail[i] += size;
2102                 } else if (e == phys_avail[i + 1]) {
2103                         phys_avail[i + 1] -= size;
2104                 } else {
2105                         for (j = phys_avail_count * 2; j > i; j -= 2) {
2106                                 phys_avail[j] = phys_avail[j - 2];
2107                                 phys_avail[j + 1] = phys_avail[j - 1];
2108                         }
2109
2110                         phys_avail[i + 3] = phys_avail[i + 1];
2111                         phys_avail[i + 1] = s;
2112                         phys_avail[i + 2] = e;
2113                         phys_avail_count++;
2114                 }
2115
2116                 return (s);
2117         }
2118         panic("moea64_bootstrap_alloc: could not allocate memory");
2119 }
2120
2121 static int
2122 moea64_pvo_enter(mmu_t mmu, pmap_t pm, uma_zone_t zone,
2123     struct pvo_head *pvo_head, vm_offset_t va, vm_offset_t pa,
2124     uint64_t pte_lo, int flags)
2125 {
2126         struct   pvo_entry *pvo;
2127         uint64_t vsid;
2128         int      first;
2129         u_int    ptegidx;
2130         int      i;
2131         int      bootstrap;
2132
2133         /*
2134          * One nasty thing that can happen here is that the UMA calls to
2135          * allocate new PVOs need to map more memory, which calls pvo_enter(),
2136          * which calls UMA...
2137          *
2138          * We break the loop by detecting recursion and allocating out of
2139          * the bootstrap pool.
2140          */
2141
2142         first = 0;
2143         bootstrap = (flags & PVO_BOOTSTRAP);
2144
2145         if (!moea64_initialized)
2146                 bootstrap = 1;
2147
2148         /*
2149          * Compute the PTE Group index.
2150          */
2151         va &= ~ADDR_POFF;
2152         vsid = va_to_vsid(pm, va);
2153         ptegidx = va_to_pteg(vsid, va, flags & PVO_LARGE);
2154
2155         /*
2156          * Remove any existing mapping for this page.  Reuse the pvo entry if
2157          * there is a mapping.
2158          */
2159         LOCK_TABLE();
2160
2161         moea64_pvo_enter_calls++;
2162
2163         LIST_FOREACH(pvo, &moea64_pvo_table[ptegidx], pvo_olink) {
2164                 if (pvo->pvo_pmap == pm && PVO_VADDR(pvo) == va) {
2165                         if ((pvo->pvo_pte.lpte.pte_lo & LPTE_RPGN) == pa &&
2166                             (pvo->pvo_pte.lpte.pte_lo & (LPTE_NOEXEC | LPTE_PP))
2167                             == (pte_lo & (LPTE_NOEXEC | LPTE_PP))) {
2168                                 if (!(pvo->pvo_pte.lpte.pte_hi & LPTE_VALID)) {
2169                                         /* Re-insert if spilled */
2170                                         i = MOEA64_PTE_INSERT(mmu, ptegidx,
2171                                             &pvo->pvo_pte.lpte);
2172                                         if (i >= 0)
2173                                                 PVO_PTEGIDX_SET(pvo, i);
2174                                         moea64_pte_overflow--;
2175                                 }
2176                                 UNLOCK_TABLE();
2177                                 return (0);
2178                         }
2179                         moea64_pvo_remove(mmu, pvo);
2180                         break;
2181                 }
2182         }
2183
2184         /*
2185          * If we aren't overwriting a mapping, try to allocate.
2186          */
2187         if (bootstrap) {
2188                 if (moea64_bpvo_pool_index >= BPVO_POOL_SIZE) {
2189                         panic("moea64_enter: bpvo pool exhausted, %d, %d, %zd",
2190                               moea64_bpvo_pool_index, BPVO_POOL_SIZE,
2191                               BPVO_POOL_SIZE * sizeof(struct pvo_entry));
2192                 }
2193                 pvo = &moea64_bpvo_pool[moea64_bpvo_pool_index];
2194                 moea64_bpvo_pool_index++;
2195                 bootstrap = 1;
2196         } else {
2197                 /*
2198                  * Note: drop the table lock around the UMA allocation in
2199                  * case the UMA allocator needs to manipulate the page
2200                  * table. The mapping we are working with is already
2201                  * protected by the PMAP lock.
2202                  */
2203                 UNLOCK_TABLE();
2204                 pvo = uma_zalloc(zone, M_NOWAIT);
2205                 LOCK_TABLE();
2206         }
2207
2208         if (pvo == NULL) {
2209                 UNLOCK_TABLE();
2210                 return (ENOMEM);
2211         }
2212
2213         moea64_pvo_entries++;
2214         pvo->pvo_vaddr = va;
2215         pvo->pvo_vpn = (uint64_t)((va & ADDR_PIDX) >> ADDR_PIDX_SHFT)
2216             | (vsid << 16);
2217         pvo->pvo_pmap = pm;
2218         LIST_INSERT_HEAD(&moea64_pvo_table[ptegidx], pvo, pvo_olink);
2219         pvo->pvo_vaddr &= ~ADDR_POFF;
2220
2221         if (flags & PVO_WIRED)
2222                 pvo->pvo_vaddr |= PVO_WIRED;
2223         if (pvo_head != &moea64_pvo_kunmanaged)
2224                 pvo->pvo_vaddr |= PVO_MANAGED;
2225         if (bootstrap)
2226                 pvo->pvo_vaddr |= PVO_BOOTSTRAP;
2227         if (flags & PVO_LARGE)
2228                 pvo->pvo_vaddr |= PVO_LARGE;
2229
2230         moea64_pte_create(&pvo->pvo_pte.lpte, vsid, va,
2231             (uint64_t)(pa) | pte_lo, flags);
2232
2233         /*
2234          * Remember if the list was empty and therefore will be the first
2235          * item.
2236          */
2237         if (LIST_FIRST(pvo_head) == NULL)
2238                 first = 1;
2239         LIST_INSERT_HEAD(pvo_head, pvo, pvo_vlink);
2240
2241         if (pvo->pvo_vaddr & PVO_WIRED) {
2242                 pvo->pvo_pte.lpte.pte_hi |= LPTE_WIRED;
2243                 pm->pm_stats.wired_count++;
2244         }
2245         pm->pm_stats.resident_count++;
2246
2247         /*
2248          * We hope this succeeds but it isn't required.
2249          */
2250         i = MOEA64_PTE_INSERT(mmu, ptegidx, &pvo->pvo_pte.lpte);
2251         if (i >= 0) {
2252                 PVO_PTEGIDX_SET(pvo, i);
2253         } else {
2254                 panic("moea64_pvo_enter: overflow");
2255                 moea64_pte_overflow++;
2256         }
2257
2258         if (pm == kernel_pmap)
2259                 isync();
2260
2261         UNLOCK_TABLE();
2262
2263 #ifdef __powerpc64__
2264         /*
2265          * Make sure all our bootstrap mappings are in the SLB as soon
2266          * as virtual memory is switched on.
2267          */
2268         if (!pmap_bootstrapped)
2269                 moea64_bootstrap_slb_prefault(va, flags & PVO_LARGE);
2270 #endif
2271
2272         return (first ? ENOENT : 0);
2273 }
2274
2275 static void
2276 moea64_pvo_remove(mmu_t mmu, struct pvo_entry *pvo)
2277 {
2278         uintptr_t pt;
2279
2280         /*
2281          * If there is an active pte entry, we need to deactivate it (and
2282          * save the ref & cfg bits).
2283          */
2284         LOCK_TABLE();
2285         pt = MOEA64_PVO_TO_PTE(mmu, pvo);
2286         if (pt != -1) {
2287                 MOEA64_PTE_UNSET(mmu, pt, &pvo->pvo_pte.lpte, pvo->pvo_vpn);
2288                 PVO_PTEGIDX_CLR(pvo);
2289         } else {
2290                 moea64_pte_overflow--;
2291         }
2292
2293         /*
2294          * Update our statistics.
2295          */
2296         pvo->pvo_pmap->pm_stats.resident_count--;
2297         if (pvo->pvo_vaddr & PVO_WIRED)
2298                 pvo->pvo_pmap->pm_stats.wired_count--;
2299
2300         /*
2301          * Save the REF/CHG bits into their cache if the page is managed.
2302          */
2303         if ((pvo->pvo_vaddr & PVO_MANAGED) == PVO_MANAGED) {
2304                 struct  vm_page *pg;
2305
2306                 pg = PHYS_TO_VM_PAGE(pvo->pvo_pte.lpte.pte_lo & LPTE_RPGN);
2307                 if (pg != NULL) {
2308                         moea64_attr_save(pg, pvo->pvo_pte.lpte.pte_lo &
2309                             (LPTE_REF | LPTE_CHG));
2310                 }
2311         }
2312
2313         /*
2314          * Remove this PVO from the PV list.
2315          */
2316         LIST_REMOVE(pvo, pvo_vlink);
2317
2318         /*
2319          * Remove this from the overflow list and return it to the pool
2320          * if we aren't going to reuse it.
2321          */
2322         LIST_REMOVE(pvo, pvo_olink);
2323
2324         moea64_pvo_entries--;
2325         moea64_pvo_remove_calls++;
2326
2327         UNLOCK_TABLE();
2328
2329         if (!(pvo->pvo_vaddr & PVO_BOOTSTRAP))
2330                 uma_zfree((pvo->pvo_vaddr & PVO_MANAGED) ? moea64_mpvo_zone :
2331                     moea64_upvo_zone, pvo);
2332 }
2333
2334 static struct pvo_entry *
2335 moea64_pvo_find_va(pmap_t pm, vm_offset_t va)
2336 {
2337         struct          pvo_entry *pvo;
2338         int             ptegidx;
2339         uint64_t        vsid;
2340         #ifdef __powerpc64__
2341         uint64_t        slbv;
2342
2343         if (pm == kernel_pmap) {
2344                 slbv = kernel_va_to_slbv(va);
2345         } else {
2346                 struct slb *slb;
2347                 slb = user_va_to_slb_entry(pm, va);
2348                 /* The page is not mapped if the segment isn't */
2349                 if (slb == NULL)
2350                         return NULL;
2351                 slbv = slb->slbv;
2352         }
2353
2354         vsid = (slbv & SLBV_VSID_MASK) >> SLBV_VSID_SHIFT;
2355         if (slbv & SLBV_L)
2356                 va &= ~moea64_large_page_mask;
2357         else
2358                 va &= ~ADDR_POFF;
2359         ptegidx = va_to_pteg(vsid, va, slbv & SLBV_L);
2360         #else
2361         va &= ~ADDR_POFF;
2362         vsid = va_to_vsid(pm, va);
2363         ptegidx = va_to_pteg(vsid, va, 0);
2364         #endif
2365
2366         LOCK_TABLE();
2367         LIST_FOREACH(pvo, &moea64_pvo_table[ptegidx], pvo_olink) {
2368                 if (pvo->pvo_pmap == pm && PVO_VADDR(pvo) == va)
2369                         break;
2370         }
2371         UNLOCK_TABLE();
2372
2373         return (pvo);
2374 }
2375
2376 static boolean_t
2377 moea64_query_bit(mmu_t mmu, vm_page_t m, u_int64_t ptebit)
2378 {
2379         struct  pvo_entry *pvo;
2380         uintptr_t pt;
2381
2382         if (moea64_attr_fetch(m) & ptebit)
2383                 return (TRUE);
2384
2385         vm_page_lock_queues();
2386
2387         LIST_FOREACH(pvo, vm_page_to_pvoh(m), pvo_vlink) {
2388
2389                 /*
2390                  * See if we saved the bit off.  If so, cache it and return
2391                  * success.
2392                  */
2393                 if (pvo->pvo_pte.lpte.pte_lo & ptebit) {
2394                         moea64_attr_save(m, ptebit);
2395                         vm_page_unlock_queues();
2396                         return (TRUE);
2397                 }
2398         }
2399
2400         /*
2401          * No luck, now go through the hard part of looking at the PTEs
2402          * themselves.  Sync so that any pending REF/CHG bits are flushed to
2403          * the PTEs.
2404          */
2405         powerpc_sync();
2406         LIST_FOREACH(pvo, vm_page_to_pvoh(m), pvo_vlink) {
2407
2408                 /*
2409                  * See if this pvo has a valid PTE.  if so, fetch the
2410                  * REF/CHG bits from the valid PTE.  If the appropriate
2411                  * ptebit is set, cache it and return success.
2412                  */
2413                 LOCK_TABLE();
2414                 pt = MOEA64_PVO_TO_PTE(mmu, pvo);
2415                 if (pt != -1) {
2416                         MOEA64_PTE_SYNCH(mmu, pt, &pvo->pvo_pte.lpte);
2417                         if (pvo->pvo_pte.lpte.pte_lo & ptebit) {
2418                                 UNLOCK_TABLE();
2419
2420                                 moea64_attr_save(m, ptebit);
2421                                 vm_page_unlock_queues();
2422                                 return (TRUE);
2423                         }
2424                 }
2425                 UNLOCK_TABLE();
2426         }
2427
2428         vm_page_unlock_queues();
2429         return (FALSE);
2430 }
2431
2432 static u_int
2433 moea64_clear_bit(mmu_t mmu, vm_page_t m, u_int64_t ptebit)
2434 {
2435         u_int   count;
2436         struct  pvo_entry *pvo;
2437         uintptr_t pt;
2438
2439         vm_page_lock_queues();
2440
2441         /*
2442          * Clear the cached value.
2443          */
2444         moea64_attr_clear(m, ptebit);
2445
2446         /*
2447          * Sync so that any pending REF/CHG bits are flushed to the PTEs (so
2448          * we can reset the right ones).  note that since the pvo entries and
2449          * list heads are accessed via BAT0 and are never placed in the page
2450          * table, we don't have to worry about further accesses setting the
2451          * REF/CHG bits.
2452          */
2453         powerpc_sync();
2454
2455         /*
2456          * For each pvo entry, clear the pvo's ptebit.  If this pvo has a
2457          * valid pte clear the ptebit from the valid pte.
2458          */
2459         count = 0;
2460         LIST_FOREACH(pvo, vm_page_to_pvoh(m), pvo_vlink) {
2461
2462                 LOCK_TABLE();
2463                 pt = MOEA64_PVO_TO_PTE(mmu, pvo);
2464                 if (pt != -1) {
2465                         MOEA64_PTE_SYNCH(mmu, pt, &pvo->pvo_pte.lpte);
2466                         if (pvo->pvo_pte.lpte.pte_lo & ptebit) {
2467                                 count++;
2468                                 MOEA64_PTE_CLEAR(mmu, pt, &pvo->pvo_pte.lpte,
2469                                     pvo->pvo_vpn, ptebit);
2470                         }
2471                 }
2472                 pvo->pvo_pte.lpte.pte_lo &= ~ptebit;
2473                 UNLOCK_TABLE();
2474         }
2475
2476         vm_page_unlock_queues();
2477         return (count);
2478 }
2479
2480 boolean_t
2481 moea64_dev_direct_mapped(mmu_t mmu, vm_offset_t pa, vm_size_t size)
2482 {
2483         struct pvo_entry *pvo;
2484         vm_offset_t ppa;
2485         int error = 0;
2486
2487         PMAP_LOCK(kernel_pmap);
2488         for (ppa = pa & ~ADDR_POFF; ppa < pa + size; ppa += PAGE_SIZE) {
2489                 pvo = moea64_pvo_find_va(kernel_pmap, ppa);
2490                 if (pvo == NULL ||
2491                     (pvo->pvo_pte.lpte.pte_lo & LPTE_RPGN) != ppa) {
2492                         error = EFAULT;
2493                         break;
2494                 }
2495         }
2496         PMAP_UNLOCK(kernel_pmap);
2497
2498         return (error);
2499 }
2500
2501 /*
2502  * Map a set of physical memory pages into the kernel virtual
2503  * address space. Return a pointer to where it is mapped. This
2504  * routine is intended to be used for mapping device memory,
2505  * NOT real memory.
2506  */
2507 void *
2508 moea64_mapdev_attr(mmu_t mmu, vm_offset_t pa, vm_size_t size, vm_memattr_t ma)
2509 {
2510         vm_offset_t va, tmpva, ppa, offset;
2511
2512         ppa = trunc_page(pa);
2513         offset = pa & PAGE_MASK;
2514         size = roundup(offset + size, PAGE_SIZE);
2515
2516         va = kmem_alloc_nofault(kernel_map, size);
2517
2518         if (!va)
2519                 panic("moea64_mapdev: Couldn't alloc kernel virtual memory");
2520
2521         for (tmpva = va; size > 0;) {
2522                 moea64_kenter_attr(mmu, tmpva, ppa, ma);
2523                 size -= PAGE_SIZE;
2524                 tmpva += PAGE_SIZE;
2525                 ppa += PAGE_SIZE;
2526         }
2527
2528         return ((void *)(va + offset));
2529 }
2530
2531 void *
2532 moea64_mapdev(mmu_t mmu, vm_offset_t pa, vm_size_t size)
2533 {
2534
2535         return moea64_mapdev_attr(mmu, pa, size, VM_MEMATTR_DEFAULT);
2536 }
2537
2538 void
2539 moea64_unmapdev(mmu_t mmu, vm_offset_t va, vm_size_t size)
2540 {
2541         vm_offset_t base, offset;
2542
2543         base = trunc_page(va);
2544         offset = va & PAGE_MASK;
2545         size = roundup(offset + size, PAGE_SIZE);
2546
2547         kmem_free(kernel_map, base, size);
2548 }
2549
2550 void
2551 moea64_sync_icache(mmu_t mmu, pmap_t pm, vm_offset_t va, vm_size_t sz)
2552 {
2553         struct pvo_entry *pvo;
2554         vm_offset_t lim;
2555         vm_paddr_t pa;
2556         vm_size_t len;
2557
2558         PMAP_LOCK(pm);
2559         while (sz > 0) {
2560                 lim = round_page(va);
2561                 len = MIN(lim - va, sz);
2562                 pvo = moea64_pvo_find_va(pm, va & ~ADDR_POFF);
2563                 if (pvo != NULL && !(pvo->pvo_pte.lpte.pte_lo & LPTE_I)) {
2564                         pa = (pvo->pvo_pte.lpte.pte_lo & LPTE_RPGN) |
2565                             (va & ADDR_POFF);
2566                         moea64_syncicache(mmu, pm, va, pa, len);
2567                 }
2568                 va += len;
2569                 sz -= len;
2570         }
2571         PMAP_UNLOCK(pm);
2572 }