sys/boot/sparc64/loader/main.c

   1 /*-
   2  * Initial implementation:
   3  * Copyright (c) 2001 Robert Drehmel
   4  * All rights reserved.
   5  *
   6  * As long as the above copyright statement and this notice remain
   7  * unchanged, you can do what ever you want with this file.
   8  */
   9 /*-
  10  * Copyright (c) 2008 Marius Strobl <marius@FreeBSD.org>
  11  * All rights reserved.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include <sys/cdefs.h>
  36 __FBSDID("$FreeBSD$");
  37
  38 /*
  39  * FreeBSD/sparc64 kernel loader - machine dependent part
  40  *
  41  *  - implements copyin and readin functions that map kernel
  42  *    pages on demand.  The machine independent code does not
  43  *    know the size of the kernel early enough to pre-enter
  44  *    TTEs and install just one 4MB mapping seemed to limiting
  45  *    to me.
  46  */
  47
  48 #include <stand.h>
  49 #include <sys/param.h>
  50 #include <sys/exec.h>
  51 #include <sys/linker.h>
  52 #include <sys/queue.h>
  53 #include <sys/types.h>
  54 #ifdef LOADER_ZFS_SUPPORT
  55 #include <sys/vtoc.h>
  56 #endif
  57
  58 #include <vm/vm.h>
  59 #include <machine/asi.h>
  60 #include <machine/cmt.h>
  61 #include <machine/cpufunc.h>
  62 #include <machine/elf.h>
  63 #include <machine/fireplane.h>
  64 #include <machine/jbus.h>
  65 #include <machine/lsu.h>
  66 #include <machine/metadata.h>
  67 #include <machine/tte.h>
  68 #include <machine/tlb.h>
  69 #include <machine/upa.h>
  70 #include <machine/ver.h>
  71 #include <machine/vmparam.h>
  72
  73 #include "bootstrap.h"
  74 #include "libofw.h"
  75 #include "dev_net.h"
  76
  77 extern char bootprog_name[], bootprog_rev[], bootprog_date[], bootprog_maker[];
  78
  79 enum {
  80         HEAPVA          = 0x800000,
  81         HEAPSZ          = 0x1000000,
  82         LOADSZ          = 0x1000000     /* for kernel and modules */
  83 };
  84
  85 /* At least Sun Fire V1280 require page sized allocations to be claimed. */
  86 CTASSERT(HEAPSZ % PAGE_SIZE == 0);
  87
  88 static struct mmu_ops {
  89         void (*tlb_init)(void);
  90         int (*mmu_mapin)(vm_offset_t va, vm_size_t len);
  91 } *mmu_ops;
  92
  93 typedef void kernel_entry_t(vm_offset_t mdp, u_long o1, u_long o2, u_long o3,
  94     void *openfirmware);
  95
  96 static inline u_long dtlb_get_data_sun4u(u_int, u_int);
  97 static int dtlb_enter_sun4u(u_int, u_long data, vm_offset_t);
  98 static vm_offset_t dtlb_va_to_pa_sun4u(vm_offset_t);
  99 static inline u_long itlb_get_data_sun4u(u_int, u_int);
 100 static int itlb_enter_sun4u(u_int, u_long data, vm_offset_t);
 101 static vm_offset_t itlb_va_to_pa_sun4u(vm_offset_t);
 102 static void itlb_relocate_locked0_sun4u(void);
 103 extern vm_offset_t md_load(char *, vm_offset_t *);
 104 static int sparc64_autoload(void);
 105 static ssize_t sparc64_readin(const int, vm_offset_t, const size_t);
 106 static ssize_t sparc64_copyin(const void *, vm_offset_t, size_t);
 107 static void sparc64_maphint(vm_offset_t, size_t);
 108 static vm_offset_t claim_virt(vm_offset_t, size_t, int);
 109 static vm_offset_t alloc_phys(size_t, int);
 110 static int map_phys(int, size_t, vm_offset_t, vm_offset_t);
 111 static void release_phys(vm_offset_t, u_int);
 112 static int __elfN(exec)(struct preloaded_file *);
 113 static int mmu_mapin_sun4u(vm_offset_t, vm_size_t);
 114 static int mmu_mapin_sun4v(vm_offset_t, vm_size_t);
 115 static vm_offset_t init_heap(void);
 116 static phandle_t find_bsp_sun4u(phandle_t, uint32_t);
 117 const char *cpu_cpuid_prop_sun4u(void);
 118 uint32_t cpu_get_mid_sun4u(void);
 119 static void tlb_init_sun4u(void);
 120 static void tlb_init_sun4v(void);
 121
 122 #ifdef LOADER_DEBUG
 123 typedef u_int64_t tte_t;
 124
 125 static void pmap_print_tlb_sun4u(void);
 126 static void pmap_print_tte_sun4u(tte_t, tte_t);
 127 #endif
 128
 129 static struct mmu_ops mmu_ops_sun4u = { tlb_init_sun4u, mmu_mapin_sun4u };
 130 static struct mmu_ops mmu_ops_sun4v = { tlb_init_sun4v, mmu_mapin_sun4v };
 131
 132 /* sun4u */
 133 struct tlb_entry *dtlb_store;
 134 struct tlb_entry *itlb_store;
 135 u_int dtlb_slot;
 136 u_int itlb_slot;
 137 static int cpu_impl;
 138 static u_int dtlb_slot_max;
 139 static u_int itlb_slot_max;
 140 static u_int tlb_locked;
 141
 142 /* sun4v */
 143 static struct tlb_entry *tlb_store;
 144 static int is_sun4v = 0;
 145 /*
 146  * no direct TLB access on sun4v
 147  * we somewhat arbitrarily declare enough
 148  * slots to cover a 4GB AS with 4MB pages
 149  */
 150 #define SUN4V_TLB_SLOT_MAX      (1 << 10)
 151
 152 static vm_offset_t curkva = 0;
 153 static vm_offset_t heapva;
 154
 155 static phandle_t root;
 156
 157 #ifdef LOADER_ZFS_SUPPORT
 158 static int zfs_dev_init(void);
 159 #include "zfs.c"
 160 #endif
 161
 162 /*
 163  * Machine dependent structures that the machine independent
 164  * loader part uses.
 165  */
 166 struct devsw *devsw[] = {
 167 #ifdef LOADER_DISK_SUPPORT
 168         &ofwdisk,
 169 #endif
 170 #ifdef LOADER_NET_SUPPORT
 171         &netdev,
 172 #endif
 173 #ifdef LOADER_ZFS_SUPPORT
 174         &zfs_dev,
 175 #endif
 176         0
 177 };
 178 struct arch_switch archsw;
 179
 180 static struct file_format sparc64_elf = {
 181         __elfN(loadfile),
 182         __elfN(exec)
 183 };
 184 struct file_format *file_formats[] = {
 185         &sparc64_elf,
 186         0
 187 };
 188
 189 struct fs_ops *file_system[] = {
 190 #ifdef LOADER_UFS_SUPPORT
 191         &ufs_fsops,
 192 #endif
 193 #ifdef LOADER_CD9660_SUPPORT
 194         &cd9660_fsops,
 195 #endif
 196 #ifdef LOADER_ZFS_SUPPORT
 197         &zfs_fsops,
 198 #endif
 199 #ifdef LOADER_ZIP_SUPPORT
 200         &zipfs_fsops,
 201 #endif
 202 #ifdef LOADER_GZIP_SUPPORT
 203         &gzipfs_fsops,
 204 #endif
 205 #ifdef LOADER_BZIP2_SUPPORT
 206         &bzipfs_fsops,
 207 #endif
 208 #ifdef LOADER_NFS_SUPPORT
 209         &nfs_fsops,
 210 #endif
 211 #ifdef LOADER_TFTP_SUPPORT
 212         &tftp_fsops,
 213 #endif
 214         0
 215 };
 216 struct netif_driver *netif_drivers[] = {
 217 #ifdef LOADER_NET_SUPPORT
 218         &ofwnet,
 219 #endif
 220         0
 221 };
 222
 223 extern struct console ofwconsole;
 224 struct console *consoles[] = {
 225         &ofwconsole,
 226         0
 227 };
 228
 229 #ifdef LOADER_DEBUG
 230 static int
 231 watch_phys_set_mask(vm_offset_t pa, u_long mask)
 232 {
 233         u_long lsucr;
 234
 235         stxa(AA_DMMU_PWPR, ASI_DMMU, pa & (((2UL << 38) - 1) << 3));
 236         lsucr = ldxa(0, ASI_LSU_CTL_REG);
 237         lsucr = ((lsucr | LSU_PW) & ~LSU_PM_MASK) |
 238             (mask << LSU_PM_SHIFT);
 239         stxa(0, ASI_LSU_CTL_REG, lsucr);
 240         return (0);
 241 }
 242
 243 static int
 244 watch_phys_set(vm_offset_t pa, int sz)
 245 {
 246         u_long off;
 247
 248         off = (u_long)pa & 7;
 249         /* Test for misaligned watch points. */
 250         if (off + sz > 8)
 251                 return (-1);
 252         return (watch_phys_set_mask(pa, ((1 << sz) - 1) << off));
 253 }
 254
 255
 256 static int
 257 watch_virt_set_mask(vm_offset_t va, u_long mask)
 258 {
 259         u_long lsucr;
 260
 261         stxa(AA_DMMU_VWPR, ASI_DMMU, va & (((2UL << 41) - 1) << 3));
 262         lsucr = ldxa(0, ASI_LSU_CTL_REG);
 263         lsucr = ((lsucr | LSU_VW) & ~LSU_VM_MASK) |
 264             (mask << LSU_VM_SHIFT);
 265         stxa(0, ASI_LSU_CTL_REG, lsucr);
 266         return (0);
 267 }
 268
 269 static int
 270 watch_virt_set(vm_offset_t va, int sz)
 271 {
 272         u_long off;
 273
 274         off = (u_long)va & 7;
 275         /* Test for misaligned watch points. */
 276         if (off + sz > 8)
 277                 return (-1);
 278         return (watch_virt_set_mask(va, ((1 << sz) - 1) << off));
 279 }
 280 #endif
 281
 282 /*
 283  * archsw functions
 284  */
 285 static int
 286 sparc64_autoload(void)
 287 {
 288
 289         return (0);
 290 }
 291
 292 static ssize_t
 293 sparc64_readin(const int fd, vm_offset_t va, const size_t len)
 294 {
 295
 296         mmu_ops->mmu_mapin(va, len);
 297         return (read(fd, (void *)va, len));
 298 }
 299
 300 static ssize_t
 301 sparc64_copyin(const void *src, vm_offset_t dest, size_t len)
 302 {
 303
 304         mmu_ops->mmu_mapin(dest, len);
 305         memcpy((void *)dest, src, len);
 306         return (len);
 307 }
 308
 309 static void
 310 sparc64_maphint(vm_offset_t va, size_t len)
 311 {
 312         vm_paddr_t pa;
 313         vm_offset_t mva;
 314         size_t size;
 315         int i, free_excess = 0;
 316
 317         if (!is_sun4v)
 318                 return;
 319
 320         if (tlb_store[va >> 22].te_pa != -1)
 321                 return;
 322
 323         /* round up to nearest 4MB page */
 324         size = (len + PAGE_MASK_4M) & ~PAGE_MASK_4M;
 325 #if 0
 326         pa = alloc_phys(PAGE_SIZE_256M, PAGE_SIZE_256M);
 327
 328         if (pa != -1)
 329                 free_excess = 1;
 330         else
 331 #endif
 332                 pa = alloc_phys(size, PAGE_SIZE_256M);
 333         if (pa == -1)
 334                 pa = alloc_phys(size, PAGE_SIZE_4M);
 335         if (pa == -1)
 336                 panic("%s: out of memory", __func__);
 337
 338         for (i = 0; i < size; i += PAGE_SIZE_4M) {
 339                 mva = claim_virt(va + i, PAGE_SIZE_4M, 0);
 340                 if (mva != (va + i))
 341                         panic("%s: can't claim virtual page "
 342                             "(wanted %#lx, got %#lx)",
 343                             __func__, va, mva);
 344
 345                 tlb_store[mva >> 22].te_pa = pa + i;
 346                 if (map_phys(-1, PAGE_SIZE_4M, mva, pa + i) != 0)
 347                         printf("%s: can't map physical page\n", __func__);
 348         }
 349         if (free_excess)
 350                 release_phys(pa, PAGE_SIZE_256M);
 351 }
 352
 353 /*
 354  * other MD functions
 355  */
 356 static vm_offset_t
 357 claim_virt(vm_offset_t virt, size_t size, int align)
 358 {
 359         vm_offset_t mva;
 360
 361         if (OF_call_method("claim", mmu, 3, 1, virt, size, align, &mva) == -1)
 362                 return ((vm_offset_t)-1);
 363         return (mva);
 364 }
 365
 366 static vm_offset_t
 367 alloc_phys(size_t size, int align)
 368 {
 369         cell_t phys_hi, phys_low;
 370
 371         if (OF_call_method("claim", memory, 2, 2, size, align, &phys_low,
 372             &phys_hi) == -1)
 373                 return ((vm_offset_t)-1);
 374         return ((vm_offset_t)phys_hi << 32 | phys_low);
 375 }
 376
 377 static int
 378 map_phys(int mode, size_t size, vm_offset_t virt, vm_offset_t phys)
 379 {
 380
 381         return (OF_call_method("map", mmu, 5, 0, (uint32_t)phys,
 382             (uint32_t)(phys >> 32), virt, size, mode));
 383 }
 384
 385 static void
 386 release_phys(vm_offset_t phys, u_int size)
 387 {
 388
 389         (void)OF_call_method("release", memory, 3, 0, (uint32_t)phys,
 390             (uint32_t)(phys >> 32), size);
 391 }
 392
 393 static int
 394 __elfN(exec)(struct preloaded_file *fp)
 395 {
 396         struct file_metadata *fmp;
 397         vm_offset_t mdp;
 398         Elf_Addr entry;
 399         Elf_Ehdr *e;
 400         int error;
 401
 402         if ((fmp = file_findmetadata(fp, MODINFOMD_ELFHDR)) == 0)
 403                 return (EFTYPE);
 404         e = (Elf_Ehdr *)&fmp->md_data;
 405
 406         if ((error = md_load(fp->f_args, &mdp)) != 0)
 407                 return (error);
 408
 409         printf("jumping to kernel entry at %#lx.\n", e->e_entry);
 410 #ifdef LOADER_DEBUG
 411         pmap_print_tlb_sun4u();
 412 #endif
 413
 414         dev_cleanup();
 415
 416         entry = e->e_entry;
 417
 418         OF_release((void *)heapva, HEAPSZ);
 419
 420         ((kernel_entry_t *)entry)(mdp, 0, 0, 0, openfirmware);
 421
 422         panic("%s: exec returned", __func__);
 423 }
 424
 425 static inline u_long
 426 dtlb_get_data_sun4u(u_int tlb, u_int slot)
 427 {
 428         u_long data, pstate;
 429
 430         slot = TLB_DAR_SLOT(tlb, slot);
 431         /*
 432          * We read ASI_DTLB_DATA_ACCESS_REG twice back-to-back in order to
 433          * work around errata of USIII and beyond.
 434          */
 435         pstate = rdpr(pstate);
 436         wrpr(pstate, pstate & ~PSTATE_IE, 0);
 437         (void)ldxa(slot, ASI_DTLB_DATA_ACCESS_REG);
 438         data = ldxa(slot, ASI_DTLB_DATA_ACCESS_REG);
 439         wrpr(pstate, pstate, 0);
 440         return (data);
 441 }
 442
 443 static inline u_long
 444 itlb_get_data_sun4u(u_int tlb, u_int slot)
 445 {
 446         u_long data, pstate;
 447
 448         slot = TLB_DAR_SLOT(tlb, slot);
 449         /*
 450          * We read ASI_DTLB_DATA_ACCESS_REG twice back-to-back in order to
 451          * work around errata of USIII and beyond.
 452          */
 453         pstate = rdpr(pstate);
 454         wrpr(pstate, pstate & ~PSTATE_IE, 0);
 455         (void)ldxa(slot, ASI_ITLB_DATA_ACCESS_REG);
 456         data = ldxa(slot, ASI_ITLB_DATA_ACCESS_REG);
 457         wrpr(pstate, pstate, 0);
 458         return (data);
 459 }
 460
 461 static vm_offset_t
 462 dtlb_va_to_pa_sun4u(vm_offset_t va)
 463 {
 464         u_long pstate, reg;
 465         u_int i, tlb;
 466
 467         pstate = rdpr(pstate);
 468         wrpr(pstate, pstate & ~PSTATE_IE, 0);
 469         for (i = 0; i < dtlb_slot_max; i++) {
 470                 reg = ldxa(TLB_DAR_SLOT(tlb_locked, i),
 471                     ASI_DTLB_TAG_READ_REG);
 472                 if (TLB_TAR_VA(reg) != va)
 473                         continue;
 474                 reg = dtlb_get_data_sun4u(tlb_locked, i);
 475                 wrpr(pstate, pstate, 0);
 476                 reg >>= TD_PA_SHIFT;
 477                 if (cpu_impl == CPU_IMPL_SPARC64V ||
 478                     cpu_impl >= CPU_IMPL_ULTRASPARCIII)
 479                         return (reg & TD_PA_CH_MASK);
 480                 return (reg & TD_PA_SF_MASK);
 481         }
 482         wrpr(pstate, pstate, 0);
 483         return (-1);
 484 }
 485
 486 static vm_offset_t
 487 itlb_va_to_pa_sun4u(vm_offset_t va)
 488 {
 489         u_long pstate, reg;
 490         int i;
 491
 492         pstate = rdpr(pstate);
 493         wrpr(pstate, pstate & ~PSTATE_IE, 0);
 494         for (i = 0; i < itlb_slot_max; i++) {
 495                 reg = ldxa(TLB_DAR_SLOT(tlb_locked, i),
 496                     ASI_ITLB_TAG_READ_REG);
 497                 if (TLB_TAR_VA(reg) != va)
 498                         continue;
 499                 reg = itlb_get_data_sun4u(tlb_locked, i);
 500                 wrpr(pstate, pstate, 0);
 501                 reg >>= TD_PA_SHIFT;
 502                 if (cpu_impl == CPU_IMPL_SPARC64V ||
 503                     cpu_impl >= CPU_IMPL_ULTRASPARCIII)
 504                         return (reg & TD_PA_CH_MASK);
 505                 return (reg & TD_PA_SF_MASK);
 506         }
 507         wrpr(pstate, pstate, 0);
 508         return (-1);
 509 }
 510
 511 static int
 512 dtlb_enter_sun4u(u_int index, u_long data, vm_offset_t virt)
 513 {
 514
 515         return (OF_call_method("SUNW,dtlb-load", mmu, 3, 0, index, data,
 516             virt));
 517 }
 518
 519 static int
 520 itlb_enter_sun4u(u_int index, u_long data, vm_offset_t virt)
 521 {
 522
 523         if (cpu_impl == CPU_IMPL_ULTRASPARCIIIp && index == 0 &&
 524             (data & TD_L) != 0)
 525                 panic("%s: won't enter locked TLB entry at index 0 on USIII+",
 526                     __func__);
 527         return (OF_call_method("SUNW,itlb-load", mmu, 3, 0, index, data,
 528             virt));
 529 }
 530
 531 static void
 532 itlb_relocate_locked0_sun4u(void)
 533 {
 534         u_long data, pstate, tag;
 535         int i;
 536
 537         if (cpu_impl != CPU_IMPL_ULTRASPARCIIIp)
 538                 return;
 539
 540         pstate = rdpr(pstate);
 541         wrpr(pstate, pstate & ~PSTATE_IE, 0);
 542
 543         data = itlb_get_data_sun4u(tlb_locked, 0);
 544         if ((data & (TD_V | TD_L)) != (TD_V | TD_L)) {
 545                 wrpr(pstate, pstate, 0);
 546                 return;
 547         }
 548
 549         /* Flush the mapping of slot 0. */
 550         tag = ldxa(TLB_DAR_SLOT(tlb_locked, 0), ASI_ITLB_TAG_READ_REG);
 551         stxa(TLB_DEMAP_VA(TLB_TAR_VA(tag)) | TLB_DEMAP_PRIMARY |
 552             TLB_DEMAP_PAGE, ASI_IMMU_DEMAP, 0);
 553         flush(0);       /* The USIII-family ignores the address. */
 554
 555         /*
 556          * Search a replacement slot != 0 and enter the data and tag
 557          * that formerly were in slot 0.
 558          */
 559         for (i = 1; i < itlb_slot_max; i++) {
 560                 if ((itlb_get_data_sun4u(tlb_locked, i) & TD_V) != 0)
 561                         continue;
 562
 563                 stxa(AA_IMMU_TAR, ASI_IMMU, tag);
 564                 stxa(TLB_DAR_SLOT(tlb_locked, i), ASI_ITLB_DATA_ACCESS_REG,
 565                     data);
 566                 flush(0);       /* The USIII-family ignores the address. */
 567                 break;
 568         }
 569         wrpr(pstate, pstate, 0);
 570         if (i == itlb_slot_max)
 571                 panic("%s: could not find a replacement slot", __func__);
 572 }
 573
 574 static int
 575 mmu_mapin_sun4u(vm_offset_t va, vm_size_t len)
 576 {
 577         vm_offset_t pa, mva;
 578         u_long data;
 579         u_int index;
 580
 581         if (va + len > curkva)
 582                 curkva = va + len;
 583
 584         pa = (vm_offset_t)-1;
 585         len += va & PAGE_MASK_4M;
 586         va &= ~PAGE_MASK_4M;
 587         while (len) {
 588                 if (dtlb_va_to_pa_sun4u(va) == (vm_offset_t)-1 ||
 589                     itlb_va_to_pa_sun4u(va) == (vm_offset_t)-1) {
 590                         /* Allocate a physical page, claim the virtual area. */
 591                         if (pa == (vm_offset_t)-1) {
 592                                 pa = alloc_phys(PAGE_SIZE_4M, PAGE_SIZE_4M);
 593                                 if (pa == (vm_offset_t)-1)
 594                                         panic("%s: out of memory", __func__);
 595                                 mva = claim_virt(va, PAGE_SIZE_4M, 0);
 596                                 if (mva != va)
 597                                         panic("%s: can't claim virtual page "
 598                                             "(wanted %#lx, got %#lx)",
 599                                             __func__, va, mva);
 600                                 /*
 601                                  * The mappings may have changed, be paranoid.
 602                                  */
 603                                 continue;
 604                         }
 605                         /*
 606                          * Actually, we can only allocate two pages less at
 607                          * most (depending on the kernel TSB size).
 608                          */
 609                         if (dtlb_slot >= dtlb_slot_max)
 610                                 panic("%s: out of dtlb_slots", __func__);
 611                         if (itlb_slot >= itlb_slot_max)
 612                                 panic("%s: out of itlb_slots", __func__);
 613                         data = TD_V | TD_4M | TD_PA(pa) | TD_L | TD_CP |
 614                             TD_CV | TD_P | TD_W;
 615                         dtlb_store[dtlb_slot].te_pa = pa;
 616                         dtlb_store[dtlb_slot].te_va = va;
 617                         index = dtlb_slot_max - dtlb_slot - 1;
 618                         if (dtlb_enter_sun4u(index, data, va) < 0)
 619                                 panic("%s: can't enter dTLB slot %d data "
 620                                     "%#lx va %#lx", __func__, index, data,
 621                                     va);
 622                         dtlb_slot++;
 623                         itlb_store[itlb_slot].te_pa = pa;
 624                         itlb_store[itlb_slot].te_va = va;
 625                         index = itlb_slot_max - itlb_slot - 1;
 626                         if (itlb_enter_sun4u(index, data, va) < 0)
 627                                 panic("%s: can't enter iTLB slot %d data "
 628                                     "%#lx va %#lxd", __func__, index, data,
 629                                     va);
 630                         itlb_slot++;
 631                         pa = (vm_offset_t)-1;
 632                 }
 633                 len -= len > PAGE_SIZE_4M ? PAGE_SIZE_4M : len;
 634                 va += PAGE_SIZE_4M;
 635         }
 636         if (pa != (vm_offset_t)-1)
 637                 release_phys(pa, PAGE_SIZE_4M);
 638         return (0);
 639 }
 640
 641 static int
 642 mmu_mapin_sun4v(vm_offset_t va, vm_size_t len)
 643 {
 644         vm_offset_t pa, mva;
 645
 646         if (va + len > curkva)
 647                 curkva = va + len;
 648
 649         pa = (vm_offset_t)-1;
 650         len += va & PAGE_MASK_4M;
 651         va &= ~PAGE_MASK_4M;
 652         while (len) {
 653                 if ((va >> 22) > SUN4V_TLB_SLOT_MAX)
 654                         panic("%s: trying to map more than 4GB", __func__);
 655                 if (tlb_store[va >> 22].te_pa == -1) {
 656                         /* Allocate a physical page, claim the virtual area */
 657                         if (pa == (vm_offset_t)-1) {
 658                                 pa = alloc_phys(PAGE_SIZE_4M, PAGE_SIZE_4M);
 659                                 if (pa == (vm_offset_t)-1)
 660                                     panic("%s: out of memory", __func__);
 661                                 mva = claim_virt(va, PAGE_SIZE_4M, 0);
 662                                 if (mva != va)
 663                                         panic("%s: can't claim virtual page "
 664                                             "(wanted %#lx, got %#lx)",
 665                                             __func__, va, mva);
 666                         }
 667
 668                         tlb_store[va >> 22].te_pa = pa;
 669                         if (map_phys(-1, PAGE_SIZE_4M, va, pa) == -1)
 670                                 printf("%s: can't map physical page\n",
 671                                     __func__);
 672                         pa = (vm_offset_t)-1;
 673                 }
 674                 len -= len > PAGE_SIZE_4M ? PAGE_SIZE_4M : len;
 675                 va += PAGE_SIZE_4M;
 676         }
 677         if (pa != (vm_offset_t)-1)
 678                 release_phys(pa, PAGE_SIZE_4M);
 679         return (0);
 680 }
 681
 682 static vm_offset_t
 683 init_heap(void)
 684 {
 685
 686         /* There is no need for continuous physical heap memory. */
 687         heapva = (vm_offset_t)OF_claim((void *)HEAPVA, HEAPSZ, 32);
 688         return (heapva);
 689 }
 690
 691 static phandle_t
 692 find_bsp_sun4u(phandle_t node, uint32_t bspid)
 693 {
 694         char type[sizeof("cpu")];
 695         phandle_t child;
 696         uint32_t cpuid;
 697
 698         for (; node > 0; node = OF_peer(node)) {
 699                 child = OF_child(node);
 700                 if (child > 0) {
 701                         child = find_bsp_sun4u(child, bspid);
 702                         if (child > 0)
 703                                 return (child);
 704                 } else {
 705                         if (OF_getprop(node, "device_type", type,
 706                             sizeof(type)) <= 0)
 707                                 continue;
 708                         if (strcmp(type, "cpu") != 0)
 709                                 continue;
 710                         if (OF_getprop(node, cpu_cpuid_prop_sun4u(), &cpuid,
 711                             sizeof(cpuid)) <= 0)
 712                                 continue;
 713                         if (cpuid == bspid)
 714                                 return (node);
 715                 }
 716         }
 717         return (0);
 718 }
 719
 720 const char *
 721 cpu_cpuid_prop_sun4u(void)
 722 {
 723
 724         switch (cpu_impl) {
 725         case CPU_IMPL_SPARC64:
 726         case CPU_IMPL_SPARC64V:
 727         case CPU_IMPL_ULTRASPARCI:
 728         case CPU_IMPL_ULTRASPARCII:
 729         case CPU_IMPL_ULTRASPARCIIi:
 730         case CPU_IMPL_ULTRASPARCIIe:
 731                 return ("upa-portid");
 732         case CPU_IMPL_ULTRASPARCIII:
 733         case CPU_IMPL_ULTRASPARCIIIp:
 734         case CPU_IMPL_ULTRASPARCIIIi:
 735         case CPU_IMPL_ULTRASPARCIIIip:
 736                 return ("portid");
 737         case CPU_IMPL_ULTRASPARCIV:
 738         case CPU_IMPL_ULTRASPARCIVp:
 739                 return ("cpuid");
 740         default:
 741                 return ("");
 742         }
 743 }
 744
 745 uint32_t
 746 cpu_get_mid_sun4u(void)
 747 {
 748
 749         switch (cpu_impl) {
 750         case CPU_IMPL_SPARC64:
 751         case CPU_IMPL_SPARC64V:
 752         case CPU_IMPL_ULTRASPARCI:
 753         case CPU_IMPL_ULTRASPARCII:
 754         case CPU_IMPL_ULTRASPARCIIi:
 755         case CPU_IMPL_ULTRASPARCIIe:
 756                 return (UPA_CR_GET_MID(ldxa(0, ASI_UPA_CONFIG_REG)));
 757         case CPU_IMPL_ULTRASPARCIII:
 758         case CPU_IMPL_ULTRASPARCIIIp:
 759                 return (FIREPLANE_CR_GET_AID(ldxa(AA_FIREPLANE_CONFIG,
 760                     ASI_FIREPLANE_CONFIG_REG)));
 761         case CPU_IMPL_ULTRASPARCIIIi:
 762         case CPU_IMPL_ULTRASPARCIIIip:
 763                 return (JBUS_CR_GET_JID(ldxa(0, ASI_JBUS_CONFIG_REG)));
 764         case CPU_IMPL_ULTRASPARCIV:
 765         case CPU_IMPL_ULTRASPARCIVp:
 766                 return (INTR_ID_GET_ID(ldxa(AA_INTR_ID, ASI_INTR_ID)));
 767         default:
 768                 return (0);
 769         }
 770 }
 771
 772 static void
 773 tlb_init_sun4u(void)
 774 {
 775         phandle_t bsp;
 776
 777         cpu_impl = VER_IMPL(rdpr(ver));
 778         switch (cpu_impl) {
 779         case CPU_IMPL_SPARC64:
 780         case CPU_IMPL_ULTRASPARCI:
 781         case CPU_IMPL_ULTRASPARCII:
 782         case CPU_IMPL_ULTRASPARCIIi:
 783         case CPU_IMPL_ULTRASPARCIIe:
 784                 tlb_locked = TLB_DAR_T32;
 785                 break;
 786         case CPU_IMPL_ULTRASPARCIII:
 787         case CPU_IMPL_ULTRASPARCIIIp:
 788         case CPU_IMPL_ULTRASPARCIIIi:
 789         case CPU_IMPL_ULTRASPARCIIIip:
 790         case CPU_IMPL_ULTRASPARCIV:
 791         case CPU_IMPL_ULTRASPARCIVp:
 792                 tlb_locked = TLB_DAR_T16;
 793                 break;
 794         case CPU_IMPL_SPARC64V:
 795                 tlb_locked = TLB_DAR_FTLB;
 796                 break;
 797         }
 798         bsp = find_bsp_sun4u(OF_child(root), cpu_get_mid_sun4u());
 799         if (bsp == 0)
 800                 panic("%s: no node for bootcpu?!?!", __func__);
 801
 802         if (OF_getprop(bsp, "#dtlb-entries", &dtlb_slot_max,
 803             sizeof(dtlb_slot_max)) == -1 ||
 804             OF_getprop(bsp, "#itlb-entries", &itlb_slot_max,
 805             sizeof(itlb_slot_max)) == -1)
 806                 panic("%s: can't get TLB slot max.", __func__);
 807
 808         if (cpu_impl == CPU_IMPL_ULTRASPARCIIIp) {
 809 #ifdef LOADER_DEBUG
 810                 printf("pre fixup:\n");
 811                 pmap_print_tlb_sun4u();
 812 #endif
 813
 814                 /*
 815                  * Relocate the locked entry in it16 slot 0 (if existent)
 816                  * as part of working around Cheetah+ erratum 34.
 817                  */
 818                 itlb_relocate_locked0_sun4u();
 819
 820 #ifdef LOADER_DEBUG
 821                 printf("post fixup:\n");
 822                 pmap_print_tlb_sun4u();
 823 #endif
 824         }
 825
 826         dtlb_store = malloc(dtlb_slot_max * sizeof(*dtlb_store));
 827         itlb_store = malloc(itlb_slot_max * sizeof(*itlb_store));
 828         if (dtlb_store == NULL || itlb_store == NULL)
 829                 panic("%s: can't allocate TLB store", __func__);
 830 }
 831
 832 static void
 833 tlb_init_sun4v(void)
 834 {
 835
 836         tlb_store = malloc(SUN4V_TLB_SLOT_MAX * sizeof(*tlb_store));
 837         memset(tlb_store, 0xFF, SUN4V_TLB_SLOT_MAX * sizeof(*tlb_store));
 838 }
 839
 840 #ifdef LOADER_ZFS_SUPPORT
 841
 842 static int
 843 zfs_dev_init(void)
 844 {
 845         struct vtoc8 vtoc;
 846         char devname[512];
 847         spa_t *spa;
 848         vdev_t *vdev;
 849         uint64_t guid;
 850         int fd, part, unit;
 851
 852         zfs_init();
 853
 854         guid = 0;
 855         /* Get the GUID of the ZFS pool on the boot device. */
 856         fd = open(getenv("currdev"), O_RDONLY);
 857         if (fd != -1) {
 858                 if (vdev_probe(vdev_read, (void *)(uintptr_t) fd, &spa) == 0)
 859                         guid = spa->spa_guid;
 860                 close(fd);
 861         }
 862
 863         /* Clean up the environment to let ZFS work. */
 864         while ((vdev = STAILQ_FIRST(&zfs_vdevs)) != NULL) {
 865                 STAILQ_REMOVE_HEAD(&zfs_vdevs, v_alllink);
 866                 free(vdev);
 867         }
 868         while ((spa = STAILQ_FIRST(&zfs_pools)) != NULL) {
 869                 STAILQ_REMOVE_HEAD(&zfs_pools, spa_link);
 870                 free(spa);
 871         }
 872
 873         for (unit = 0; unit < MAXBDDEV; unit++) {
 874                 /* Find freebsd-zfs slices in the VTOC. */
 875                 sprintf(devname, "disk%d:", unit);
 876                 fd = open(devname, O_RDONLY);
 877                 if (fd == -1)
 878                         continue;
 879                 lseek(fd, 0, SEEK_SET);
 880                 if (read(fd, &vtoc, sizeof(vtoc)) != sizeof(vtoc)) {
 881                         close(fd);
 882                         continue;
 883                 }
 884                 close(fd);
 885
 886                 for (part = 0; part < 8; part++) {
 887                         if (part == 2 || vtoc.part[part].tag !=
 888                              VTOC_TAG_FREEBSD_ZFS)
 889                                 continue;
 890                         sprintf(devname, "disk%d:%c", unit, part + 'a');
 891                         fd = open(devname, O_RDONLY);
 892                         if (fd == -1)
 893                                 break;
 894
 895                         if (vdev_probe(vdev_read, (void*)(uintptr_t) fd, 0))
 896                                 close(fd);
 897                 }
 898         }
 899
 900         if (guid != 0) {
 901                 unit = zfs_guid_to_unit(guid);
 902                 if (unit >= 0) {
 903                         /* Update the environment for ZFS. */
 904                         sprintf(devname, "zfs%d", unit);
 905                         env_setenv("currdev", EV_VOLATILE, devname,
 906                            ofw_setcurrdev, env_nounset);
 907                         env_setenv("loaddev", EV_VOLATILE, devname,
 908                            env_noset, env_nounset);
 909                 }
 910         }
 911         return (0);
 912 }
 913
 914 #endif /* LOADER_ZFS_SUPPORT */
 915
 916 int
 917 main(int (*openfirm)(void *))
 918 {
 919         char bootpath[64];
 920         char compatible[32];
 921         struct devsw **dp;
 922
 923         /*
 924          * Tell the Open Firmware functions where they find the OFW gate.
 925          */
 926         OF_init(openfirm);
 927
 928         archsw.arch_getdev = ofw_getdev;
 929         archsw.arch_copyin = sparc64_copyin;
 930         archsw.arch_copyout = ofw_copyout;
 931         archsw.arch_readin = sparc64_readin;
 932         archsw.arch_autoload = sparc64_autoload;
 933         archsw.arch_maphint = sparc64_maphint;
 934
 935         if (init_heap() == (vm_offset_t)-1)
 936                 OF_exit();
 937         setheap((void *)heapva, (void *)(heapva + HEAPSZ));
 938
 939         /*
 940          * Probe for a console.
 941          */
 942         cons_probe();
 943
 944         if ((root = OF_peer(0)) == -1)
 945                 panic("%s: can't get root phandle", __func__);
 946         OF_getprop(root, "compatible", compatible, sizeof(compatible));
 947         if (!strcmp(compatible, "sun4v")) {
 948                 printf("\nBooting with sun4v support.\n");
 949                 mmu_ops = &mmu_ops_sun4v;
 950                 is_sun4v = 1;
 951         } else {
 952                 printf("\nBooting with sun4u support.\n");
 953                 mmu_ops = &mmu_ops_sun4u;
 954         }
 955
 956         mmu_ops->tlb_init();
 957
 958         /*
 959          * Set up the current device.
 960          */
 961         OF_getprop(chosen, "bootpath", bootpath, sizeof(bootpath));
 962
 963         /*
 964          * Sun compatible bootable CD-ROMs have a disk label placed
 965          * before the cd9660 data, with the actual filesystem being
 966          * in the first partition, while the other partitions contain
 967          * pseudo disk labels with embedded boot blocks for different
 968          * architectures, which may be followed by UFS filesystems.
 969          * The firmware will set the boot path to the partition it
 970          * boots from ('f' in the sun4u case), but we want the kernel
 971          * to be loaded from the cd9660 fs ('a'), so the boot path
 972          * needs to be altered.
 973          */
 974         if (bootpath[strlen(bootpath) - 2] == ':' &&
 975             bootpath[strlen(bootpath) - 1] == 'f' &&
 976             strstr(bootpath, "cdrom")) {
 977                 bootpath[strlen(bootpath) - 1] = 'a';
 978                 printf("Boot path set to %s\n", bootpath);
 979         }
 980
 981         env_setenv("currdev", EV_VOLATILE, bootpath,
 982             ofw_setcurrdev, env_nounset);
 983         env_setenv("loaddev", EV_VOLATILE, bootpath,
 984             env_noset, env_nounset);
 985
 986         /*
 987          * Initialize devices.
 988          */
 989         for (dp = devsw; *dp != 0; dp++)
 990                 if ((*dp)->dv_init != 0)
 991                         (*dp)->dv_init();
 992
 993         printf("\n");
 994         printf("%s, Revision %s\n", bootprog_name, bootprog_rev);
 995         printf("(%s, %s)\n", bootprog_maker, bootprog_date);
 996         printf("bootpath=\"%s\"\n", bootpath);
 997
 998         /* Give control to the machine independent loader code. */
 999         interact();
1000         return (1);
1001 }
1002
1003 COMMAND_SET(heap, "heap", "show heap usage", command_heap);
1004
1005 static int
1006 command_heap(int argc, char *argv[])
1007 {
1008
1009         mallocstats();
1010         printf("heap base at %p, top at %p, upper limit at %p\n", heapva,
1011             sbrk(0), heapva + HEAPSZ);
1012         return(CMD_OK);
1013 }
1014
1015 COMMAND_SET(reboot, "reboot", "reboot the system", command_reboot);
1016
1017 static int
1018 command_reboot(int argc, char *argv[])
1019 {
1020         int i;
1021
1022         for (i = 0; devsw[i] != NULL; ++i)
1023                 if (devsw[i]->dv_cleanup != NULL)
1024                         (devsw[i]->dv_cleanup)();
1025
1026         printf("Rebooting...\n");
1027         OF_exit();
1028 }
1029
1030 /* provide this for panic, as it's not in the startup code */
1031 void
1032 exit(int code)
1033 {
1034
1035         OF_exit();
1036 }
1037
1038 #ifdef LOADER_DEBUG
1039 static const char *const page_sizes[] = {
1040         "  8k", " 64k", "512k", "  4m"
1041 };
1042
1043 static void
1044 pmap_print_tte_sun4u(tte_t tag, tte_t tte)
1045 {
1046
1047         printf("%s %s ",
1048             page_sizes[(tte >> TD_SIZE_SHIFT) & TD_SIZE_MASK],
1049             tag & TD_G ? "G" : " ");
1050         printf(tte & TD_W ? "W " : "  ");
1051         printf(tte & TD_P ? "\e[33mP\e[0m " : "  ");
1052         printf(tte & TD_E ? "E " : "  ");
1053         printf(tte & TD_CV ? "CV " : "   ");
1054         printf(tte & TD_CP ? "CP " : "   ");
1055         printf(tte & TD_L ? "\e[32mL\e[0m " : "  ");
1056         printf(tte & TD_IE ? "IE " : "   ");
1057         printf(tte & TD_NFO ? "NFO " : "    ");
1058         printf("pa=0x%lx va=0x%lx ctx=%ld\n",
1059             TD_PA(tte), TLB_TAR_VA(tag), TLB_TAR_CTX(tag));
1060 }
1061
1062 static void
1063 pmap_print_tlb_sun4u(void)
1064 {
1065         tte_t tag, tte;
1066         u_long pstate;
1067         int i;
1068
1069         pstate = rdpr(pstate);
1070         for (i = 0; i < itlb_slot_max; i++) {
1071                 wrpr(pstate, pstate & ~PSTATE_IE, 0);
1072                 tte = itlb_get_data_sun4u(tlb_locked, i);
1073                 wrpr(pstate, pstate, 0);
1074                 if (!(tte & TD_V))
1075                         continue;
1076                 tag = ldxa(TLB_DAR_SLOT(tlb_locked, i),
1077                     ASI_ITLB_TAG_READ_REG);
1078                 printf("iTLB-%2u: ", i);
1079                 pmap_print_tte_sun4u(tag, tte);
1080         }
1081         for (i = 0; i < dtlb_slot_max; i++) {
1082                 wrpr(pstate, pstate & ~PSTATE_IE, 0);
1083                 tte = dtlb_get_data_sun4u(tlb_locked, i);
1084                 wrpr(pstate, pstate, 0);
1085                 if (!(tte & TD_V))
1086                         continue;
1087                 tag = ldxa(TLB_DAR_SLOT(tlb_locked, i),
1088                     ASI_DTLB_TAG_READ_REG);
1089                 printf("dTLB-%2u: ", i);
1090                 pmap_print_tte_sun4u(tag, tte);
1091         }
1092 }
1093 #endif