sys/powerpc/powerpc/machdep.c

   1 /*-
   2  * Copyright (C) 1995, 1996 Wolfgang Solfrank.
   3  * Copyright (C) 1995, 1996 TooLs GmbH.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the following acknowledgement:
  16  *      This product includes software developed by TooLs GmbH.
  17  * 4. The name of TooLs GmbH may not be used to endorse or promote products
  18  *    derived from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
  21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  23  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  26  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  27  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  28  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  29  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31 /*-
  32  * Copyright (C) 2001 Benno Rice
  33  * All rights reserved.
  34  *
  35  * Redistribution and use in source and binary forms, with or without
  36  * modification, are permitted provided that the following conditions
  37  * are met:
  38  * 1. Redistributions of source code must retain the above copyright
  39  *    notice, this list of conditions and the following disclaimer.
  40  * 2. Redistributions in binary form must reproduce the above copyright
  41  *    notice, this list of conditions and the following disclaimer in the
  42  *    documentation and/or other materials provided with the distribution.
  43  *
  44  * THIS SOFTWARE IS PROVIDED BY Benno Rice ``AS IS'' AND ANY EXPRESS OR
  45  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  46  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  47  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  48  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  49  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  50  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  51  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  52  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  53  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  54  *      $NetBSD: machdep.c,v 1.74.2.1 2000/11/01 16:13:48 tv Exp $
  55  */
  56
  57 #include <sys/cdefs.h>
  58 __FBSDID("$FreeBSD$");
  59
  60 #include "opt_compat.h"
  61 #include "opt_ddb.h"
  62 #include "opt_kstack_pages.h"
  63 #include "opt_platform.h"
  64
  65 #include <sys/param.h>
  66 #include <sys/proc.h>
  67 #include <sys/systm.h>
  68 #include <sys/bio.h>
  69 #include <sys/buf.h>
  70 #include <sys/bus.h>
  71 #include <sys/cons.h>
  72 #include <sys/cpu.h>
  73 #include <sys/eventhandler.h>
  74 #include <sys/exec.h>
  75 #include <sys/imgact.h>
  76 #include <sys/kdb.h>
  77 #include <sys/kernel.h>
  78 #include <sys/ktr.h>
  79 #include <sys/linker.h>
  80 #include <sys/lock.h>
  81 #include <sys/malloc.h>
  82 #include <sys/mbuf.h>
  83 #include <sys/msgbuf.h>
  84 #include <sys/mutex.h>
  85 #include <sys/ptrace.h>
  86 #include <sys/reboot.h>
  87 #include <sys/rwlock.h>
  88 #include <sys/signalvar.h>
  89 #include <sys/syscallsubr.h>
  90 #include <sys/sysctl.h>
  91 #include <sys/sysent.h>
  92 #include <sys/sysproto.h>
  93 #include <sys/ucontext.h>
  94 #include <sys/uio.h>
  95 #include <sys/vmmeter.h>
  96 #include <sys/vnode.h>
  97
  98 #include <net/netisr.h>
  99
 100 #include <vm/vm.h>
 101 #include <vm/vm_extern.h>
 102 #include <vm/vm_kern.h>
 103 #include <vm/vm_page.h>
 104 #include <vm/vm_map.h>
 105 #include <vm/vm_object.h>
 106 #include <vm/vm_pager.h>
 107
 108 #include <machine/altivec.h>
 109 #ifndef __powerpc64__
 110 #include <machine/bat.h>
 111 #endif
 112 #include <machine/cpu.h>
 113 #include <machine/elf.h>
 114 #include <machine/fpu.h>
 115 #include <machine/hid.h>
 116 #include <machine/kdb.h>
 117 #include <machine/md_var.h>
 118 #include <machine/metadata.h>
 119 #include <machine/mmuvar.h>
 120 #include <machine/pcb.h>
 121 #include <machine/reg.h>
 122 #include <machine/sigframe.h>
 123 #include <machine/spr.h>
 124 #include <machine/trap.h>
 125 #include <machine/vmparam.h>
 126 #include <machine/ofw_machdep.h>
 127
 128 #include <ddb/ddb.h>
 129
 130 #include <dev/ofw/openfirm.h>
 131 #include <dev/ofw/ofw_subr.h>
 132
 133 int cold = 1;
 134 #ifdef __powerpc64__
 135 int cacheline_size = 128;
 136 #else
 137 int cacheline_size = 32;
 138 #endif
 139 int hw_direct_map = 1;
 140
 141 extern void *ap_pcpu;
 142
 143 struct pcpu __pcpu[MAXCPU];
 144 static char init_kenv[2048];
 145
 146 static struct trapframe frame0;
 147
 148 char            machine[] = "powerpc";
 149 SYSCTL_STRING(_hw, HW_MACHINE, machine, CTLFLAG_RD, machine, 0, "");
 150
 151 static void     cpu_startup(void *);
 152 SYSINIT(cpu, SI_SUB_CPU, SI_ORDER_FIRST, cpu_startup, NULL);
 153
 154 SYSCTL_INT(_machdep, CPU_CACHELINE, cacheline_size,
 155            CTLFLAG_RD, &cacheline_size, 0, "");
 156
 157 uintptr_t       powerpc_init(vm_offset_t, vm_offset_t, vm_offset_t, void *);
 158
 159 long            Maxmem = 0;
 160 long            realmem = 0;
 161
 162 struct kva_md_info kmi;
 163
 164 static void
 165 cpu_startup(void *dummy)
 166 {
 167
 168         /*
 169          * Initialise the decrementer-based clock.
 170          */
 171         decr_init();
 172
 173         /*
 174          * Good {morning,afternoon,evening,night}.
 175          */
 176         cpu_setup(PCPU_GET(cpuid));
 177
 178 #ifdef PERFMON
 179         perfmon_init();
 180 #endif
 181         printf("real memory  = %ju (%ju MB)\n", ptoa((uintmax_t)physmem),
 182             ptoa((uintmax_t)physmem) / 1048576);
 183         realmem = physmem;
 184
 185         if (bootverbose)
 186                 printf("available KVA = %zu (%zu MB)\n",
 187                     virtual_end - virtual_avail,
 188                     (virtual_end - virtual_avail) / 1048576);
 189
 190         /*
 191          * Display any holes after the first chunk of extended memory.
 192          */
 193         if (bootverbose) {
 194                 int indx;
 195
 196                 printf("Physical memory chunk(s):\n");
 197                 for (indx = 0; phys_avail[indx + 1] != 0; indx += 2) {
 198                         vm_paddr_t size1 =
 199                             phys_avail[indx + 1] - phys_avail[indx];
 200
 201                         #ifdef __powerpc64__
 202                         printf("0x%016jx - 0x%016jx, %ju bytes (%ju pages)\n",
 203                         #else
 204                         printf("0x%09jx - 0x%09jx, %ju bytes (%ju pages)\n",
 205                         #endif
 206                             (uintmax_t)phys_avail[indx],
 207                             (uintmax_t)phys_avail[indx + 1] - 1,
 208                             (uintmax_t)size1, (uintmax_t)size1 / PAGE_SIZE);
 209                 }
 210         }
 211
 212         vm_ksubmap_init(&kmi);
 213
 214         printf("avail memory = %ju (%ju MB)\n",
 215             ptoa((uintmax_t)vm_cnt.v_free_count),
 216             ptoa((uintmax_t)vm_cnt.v_free_count) / 1048576);
 217
 218         /*
 219          * Set up buffers, so they can be used to read disk labels.
 220          */
 221         bufinit();
 222         vm_pager_bufferinit();
 223 }
 224
 225 extern vm_offset_t      __startkernel, __endkernel;
 226 extern unsigned char    __bss_start[];
 227 extern unsigned char    __sbss_start[];
 228 extern unsigned char    __sbss_end[];
 229 extern unsigned char    _end[];
 230
 231 void aim_cpu_init(vm_offset_t toc);
 232 void booke_cpu_init(void);
 233
 234 uintptr_t
 235 powerpc_init(vm_offset_t fdt, vm_offset_t toc, vm_offset_t ofentry, void *mdp)
 236 {
 237         struct          pcpu *pc;
 238         vm_offset_t     startkernel, endkernel;
 239         void            *kmdp;
 240         char            *env;
 241         bool            ofw_bootargs = false;
 242 #ifdef DDB
 243         vm_offset_t ksym_start;
 244         vm_offset_t ksym_end;
 245 #endif
 246
 247         kmdp = NULL;
 248
 249         /* First guess at start/end kernel positions */
 250         startkernel = __startkernel;
 251         endkernel = __endkernel;
 252
 253         /* Check for ePAPR loader, which puts a magic value into r6 */
 254         if (mdp == (void *)0x65504150)
 255                 mdp = NULL;
 256
 257 #ifdef AIM
 258         /*
 259          * If running from an FDT, make sure we are in real mode to avoid
 260          * tromping on firmware page tables. Everything in the kernel assumes
 261          * 1:1 mappings out of firmware, so this won't break anything not
 262          * already broken. This doesn't work if there is live OF, since OF
 263          * may internally use non-1:1 mappings.
 264          */
 265         if (ofentry == 0)
 266                 mtmsr(mfmsr() & ~(PSL_IR | PSL_DR));
 267 #endif
 268
 269         /*
 270          * Parse metadata if present and fetch parameters.  Must be done
 271          * before console is inited so cninit gets the right value of
 272          * boothowto.
 273          */
 274         if (mdp != NULL) {
 275                 preload_metadata = mdp;
 276                 kmdp = preload_search_by_type("elf kernel");
 277                 if (kmdp != NULL) {
 278                         boothowto = MD_FETCH(kmdp, MODINFOMD_HOWTO, int);
 279                         init_static_kenv(MD_FETCH(kmdp, MODINFOMD_ENVP, char *),
 280                             0);
 281                         endkernel = ulmax(endkernel, MD_FETCH(kmdp,
 282                             MODINFOMD_KERNEND, vm_offset_t));
 283 #ifdef DDB
 284                         ksym_start = MD_FETCH(kmdp, MODINFOMD_SSYM, uintptr_t);
 285                         ksym_end = MD_FETCH(kmdp, MODINFOMD_ESYM, uintptr_t);
 286                         db_fetch_ksymtab(ksym_start, ksym_end);
 287 #endif
 288                 }
 289         } else {
 290 #if !defined(BOOKE)
 291                 /*
 292                  * On BOOKE the BSS is already cleared and some variables
 293                  * initialized.  Do not wipe them out.
 294                  */
 295                 bzero(__sbss_start, __sbss_end - __sbss_start);
 296                 bzero(__bss_start, _end - __bss_start);
 297 #endif
 298                 init_static_kenv(init_kenv, sizeof(init_kenv));
 299                 ofw_bootargs = true;
 300         }
 301         /* Store boot environment state */
 302         OF_initial_setup((void *)fdt, NULL, (int (*)(void *))ofentry);
 303
 304         /*
 305          * Init params/tunables that can be overridden by the loader
 306          */
 307         init_param1();
 308
 309         /*
 310          * Start initializing proc0 and thread0.
 311          */
 312         proc_linkup0(&proc0, &thread0);
 313         thread0.td_frame = &frame0;
 314
 315         /*
 316          * Set up per-cpu data.
 317          */
 318         pc = __pcpu;
 319         pcpu_init(pc, 0, sizeof(struct pcpu));
 320         pc->pc_curthread = &thread0;
 321 #ifdef __powerpc64__
 322         __asm __volatile("mr 13,%0" :: "r"(pc->pc_curthread));
 323 #else
 324         __asm __volatile("mr 2,%0" :: "r"(pc->pc_curthread));
 325 #endif
 326         pc->pc_cpuid = 0;
 327
 328         __asm __volatile("mtsprg 0, %0" :: "r"(pc));
 329
 330         /*
 331          * Init mutexes, which we use heavily in PMAP
 332          */
 333
 334         mutex_init();
 335
 336         /*
 337          * Install the OF client interface
 338          */
 339
 340         OF_bootstrap();
 341
 342         if (ofw_bootargs)
 343                 ofw_parse_bootargs();
 344
 345         /*
 346          * Initialize the console before printing anything.
 347          */
 348         cninit();
 349
 350         /*
 351          * Complain if there is no metadata.
 352          */
 353         if (mdp == NULL || kmdp == NULL) {
 354                 printf("powerpc_init: no loader metadata.\n");
 355         }
 356
 357         /*
 358          * Init KDB
 359          */
 360
 361         kdb_init();
 362
 363 #ifdef AIM
 364         aim_cpu_init(toc);
 365 #else /* BOOKE */
 366         booke_cpu_init();
 367
 368         /* Make sure the kernel icache is valid before we go too much further */
 369         __syncicache((caddr_t)startkernel, endkernel - startkernel);
 370 #endif
 371
 372         /*
 373          * Choose a platform module so we can get the physical memory map.
 374          */
 375
 376         platform_probe_and_attach();
 377
 378         /*
 379          * Bring up MMU
 380          */
 381         pmap_bootstrap(startkernel, endkernel);
 382         mtmsr(PSL_KERNSET & ~PSL_EE);
 383
 384         /*
 385          * Initialize params/tunables that are derived from memsize
 386          */
 387         init_param2(physmem);
 388
 389         /*
 390          * Grab booted kernel's name
 391          */
 392         env = kern_getenv("kernelname");
 393         if (env != NULL) {
 394                 strlcpy(kernelname, env, sizeof(kernelname));
 395                 freeenv(env);
 396         }
 397
 398         /*
 399          * Finish setting up thread0.
 400          */
 401         thread0.td_pcb = (struct pcb *)
 402             ((thread0.td_kstack + thread0.td_kstack_pages * PAGE_SIZE -
 403             sizeof(struct pcb)) & ~15UL);
 404         bzero((void *)thread0.td_pcb, sizeof(struct pcb));
 405         pc->pc_curpcb = thread0.td_pcb;
 406
 407         /* Initialise the message buffer. */
 408         msgbufinit(msgbufp, msgbufsize);
 409
 410 #ifdef KDB
 411         if (boothowto & RB_KDB)
 412                 kdb_enter(KDB_WHY_BOOTFLAGS,
 413                     "Boot flags requested debugger");
 414 #endif
 415
 416         return (((uintptr_t)thread0.td_pcb -
 417             (sizeof(struct callframe) - 3*sizeof(register_t))) & ~15UL);
 418 }
 419
 420 void
 421 bzero(void *buf, size_t len)
 422 {
 423         caddr_t p;
 424
 425         p = buf;
 426
 427         while (((vm_offset_t) p & (sizeof(u_long) - 1)) && len) {
 428                 *p++ = 0;
 429                 len--;
 430         }
 431
 432         while (len >= sizeof(u_long) * 8) {
 433                 *(u_long*) p = 0;
 434                 *((u_long*) p + 1) = 0;
 435                 *((u_long*) p + 2) = 0;
 436                 *((u_long*) p + 3) = 0;
 437                 len -= sizeof(u_long) * 8;
 438                 *((u_long*) p + 4) = 0;
 439                 *((u_long*) p + 5) = 0;
 440                 *((u_long*) p + 6) = 0;
 441                 *((u_long*) p + 7) = 0;
 442                 p += sizeof(u_long) * 8;
 443         }
 444
 445         while (len >= sizeof(u_long)) {
 446                 *(u_long*) p = 0;
 447                 len -= sizeof(u_long);
 448                 p += sizeof(u_long);
 449         }
 450
 451         while (len) {
 452                 *p++ = 0;
 453                 len--;
 454         }
 455 }
 456
 457 /*
 458  * Flush the D-cache for non-DMA I/O so that the I-cache can
 459  * be made coherent later.
 460  */
 461 void
 462 cpu_flush_dcache(void *ptr, size_t len)
 463 {
 464         register_t addr, off;
 465
 466         /*
 467          * Align the address to a cacheline and adjust the length
 468          * accordingly. Then round the length to a multiple of the
 469          * cacheline for easy looping.
 470          */
 471         addr = (uintptr_t)ptr;
 472         off = addr & (cacheline_size - 1);
 473         addr -= off;
 474         len = roundup2(len + off, cacheline_size);
 475
 476         while (len > 0) {
 477                 __asm __volatile ("dcbf 0,%0" :: "r"(addr));
 478                 __asm __volatile ("sync");
 479                 addr += cacheline_size;
 480                 len -= cacheline_size;
 481         }
 482 }
 483
 484 int
 485 ptrace_set_pc(struct thread *td, unsigned long addr)
 486 {
 487         struct trapframe *tf;
 488
 489         tf = td->td_frame;
 490         tf->srr0 = (register_t)addr;
 491
 492         return (0);
 493 }
 494
 495 void
 496 spinlock_enter(void)
 497 {
 498         struct thread *td;
 499         register_t msr;
 500
 501         td = curthread;
 502         if (td->td_md.md_spinlock_count == 0) {
 503                 __asm __volatile("or 2,2,2"); /* Set high thread priority */
 504                 msr = intr_disable();
 505                 td->td_md.md_spinlock_count = 1;
 506                 td->td_md.md_saved_msr = msr;
 507         } else
 508                 td->td_md.md_spinlock_count++;
 509         critical_enter();
 510 }
 511
 512 void
 513 spinlock_exit(void)
 514 {
 515         struct thread *td;
 516         register_t msr;
 517
 518         td = curthread;
 519         critical_exit();
 520         msr = td->td_md.md_saved_msr;
 521         td->td_md.md_spinlock_count--;
 522         if (td->td_md.md_spinlock_count == 0) {
 523                 intr_restore(msr);
 524                 __asm __volatile("or 6,6,6"); /* Set normal thread priority */
 525         }
 526 }
 527
 528 /*
 529  * Simple ddb(4) command/hack to view any SPR on the running CPU.
 530  * Uses a trivial asm function to perform the mfspr, and rewrites the mfspr
 531  * instruction each time.
 532  * XXX: Since it uses code modification, it won't work if the kernel code pages
 533  * are marked RO.
 534  */
 535 extern register_t get_spr(int);
 536
 537 #ifdef DDB
 538 DB_SHOW_COMMAND(spr, db_show_spr)
 539 {
 540         register_t spr;
 541         volatile uint32_t *p;
 542         int sprno, saved_sprno;
 543
 544         if (!have_addr)
 545                 return;
 546
 547         saved_sprno = sprno = (intptr_t) addr;
 548         sprno = ((sprno & 0x3e0) >> 5) | ((sprno & 0x1f) << 5);
 549         p = (uint32_t *)(void *)&get_spr;
 550         *p = (*p & ~0x001ff800) | (sprno << 11);
 551         __syncicache(get_spr, cacheline_size);
 552         spr = get_spr(sprno);
 553
 554         db_printf("SPR %d(%x): %lx\n", saved_sprno, saved_sprno,
 555             (unsigned long)spr);
 556 }
 557 #endif