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