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
 132 int cold = 1;
 133 #ifdef __powerpc64__
 134 int cacheline_size = 128;
 135 #else
 136 int cacheline_size = 32;
 137 #endif
 138 int hw_direct_map = 1;
 139
 140 extern void *ap_pcpu;
 141
 142 struct pcpu __pcpu[MAXCPU];
 143
 144 static struct trapframe frame0;
 145
 146 char            machine[] = "powerpc";
 147 SYSCTL_STRING(_hw, HW_MACHINE, machine, CTLFLAG_RD, machine, 0, "");
 148
 149 static void     cpu_startup(void *);
 150 SYSINIT(cpu, SI_SUB_CPU, SI_ORDER_FIRST, cpu_startup, NULL);
 151
 152 SYSCTL_INT(_machdep, CPU_CACHELINE, cacheline_size,
 153            CTLFLAG_RD, &cacheline_size, 0, "");
 154
 155 uintptr_t       powerpc_init(vm_offset_t, vm_offset_t, vm_offset_t, void *);
 156
 157 long            Maxmem = 0;
 158 long            realmem = 0;
 159
 160 struct kva_md_info kmi;
 161
 162 static void
 163 cpu_startup(void *dummy)
 164 {
 165
 166         /*
 167          * Initialise the decrementer-based clock.
 168          */
 169         decr_init();
 170
 171         /*
 172          * Good {morning,afternoon,evening,night}.
 173          */
 174         cpu_setup(PCPU_GET(cpuid));
 175
 176 #ifdef PERFMON
 177         perfmon_init();
 178 #endif
 179         printf("real memory  = %ju (%ju MB)\n", ptoa((uintmax_t)physmem),
 180             ptoa((uintmax_t)physmem) / 1048576);
 181         realmem = physmem;
 182
 183         if (bootverbose)
 184                 printf("available KVA = %zu (%zu MB)\n",
 185                     virtual_end - virtual_avail,
 186                     (virtual_end - virtual_avail) / 1048576);
 187
 188         /*
 189          * Display any holes after the first chunk of extended memory.
 190          */
 191         if (bootverbose) {
 192                 int indx;
 193
 194                 printf("Physical memory chunk(s):\n");
 195                 for (indx = 0; phys_avail[indx + 1] != 0; indx += 2) {
 196                         vm_paddr_t size1 =
 197                             phys_avail[indx + 1] - phys_avail[indx];
 198
 199                         #ifdef __powerpc64__
 200                         printf("0x%016jx - 0x%016jx, %jd bytes (%jd pages)\n",
 201                         #else
 202                         printf("0x%09jx - 0x%09jx, %ju bytes (%ju pages)\n",
 203                         #endif
 204                             (uintmax_t)phys_avail[indx],
 205                             (uintmax_t)phys_avail[indx + 1] - 1,
 206                             (uintmax_t)size1, (uintmax_t)size1 / PAGE_SIZE);
 207                 }
 208         }
 209
 210         vm_ksubmap_init(&kmi);
 211
 212         printf("avail memory = %ju (%ju MB)\n",
 213             ptoa((uintmax_t)vm_cnt.v_free_count),
 214             ptoa((uintmax_t)vm_cnt.v_free_count) / 1048576);
 215
 216         /*
 217          * Set up buffers, so they can be used to read disk labels.
 218          */
 219         bufinit();
 220         vm_pager_bufferinit();
 221 }
 222
 223 extern vm_offset_t      __startkernel, __endkernel;
 224 extern unsigned char    __bss_start[];
 225 extern unsigned char    __sbss_start[];
 226 extern unsigned char    __sbss_end[];
 227 extern unsigned char    _end[];
 228
 229 void aim_cpu_init(vm_offset_t toc);
 230 void booke_cpu_init(void);
 231
 232 uintptr_t
 233 powerpc_init(vm_offset_t fdt, vm_offset_t toc, vm_offset_t ofentry, void *mdp)
 234 {
 235         struct          pcpu *pc;
 236         vm_offset_t     startkernel, endkernel;
 237         void            *kmdp;
 238         char            *env;
 239 #ifdef DDB
 240         vm_offset_t ksym_start;
 241         vm_offset_t ksym_end;
 242 #endif
 243
 244         kmdp = NULL;
 245
 246         /* First guess at start/end kernel positions */
 247         startkernel = __startkernel;
 248         endkernel = __endkernel;
 249
 250         /* Check for ePAPR loader, which puts a magic value into r6 */
 251         if (mdp == (void *)0x65504150)
 252                 mdp = NULL;
 253
 254 #ifdef AIM
 255         /*
 256          * If running from an FDT, make sure we are in real mode to avoid
 257          * tromping on firmware page tables. Everything in the kernel assumes
 258          * 1:1 mappings out of firmware, so this won't break anything not
 259          * already broken. This doesn't work if there is live OF, since OF
 260          * may internally use non-1:1 mappings.
 261          */
 262         if (ofentry == 0)
 263                 mtmsr(mfmsr() & ~(PSL_IR | PSL_DR));
 264 #endif
 265
 266         /*
 267          * Parse metadata if present and fetch parameters.  Must be done
 268          * before console is inited so cninit gets the right value of
 269          * boothowto.
 270          */
 271         if (mdp != NULL) {
 272                 preload_metadata = mdp;
 273                 kmdp = preload_search_by_type("elf kernel");
 274                 if (kmdp != NULL) {
 275                         boothowto = MD_FETCH(kmdp, MODINFOMD_HOWTO, int);
 276                         init_static_kenv(MD_FETCH(kmdp, MODINFOMD_ENVP, char *),
 277                             0);
 278                         endkernel = ulmax(endkernel, MD_FETCH(kmdp,
 279                             MODINFOMD_KERNEND, vm_offset_t));
 280 #ifdef DDB
 281                         ksym_start = MD_FETCH(kmdp, MODINFOMD_SSYM, uintptr_t);
 282                         ksym_end = MD_FETCH(kmdp, MODINFOMD_ESYM, uintptr_t);
 283                         db_fetch_ksymtab(ksym_start, ksym_end);
 284 #endif
 285                 }
 286         } else {
 287                 bzero(__sbss_start, __sbss_end - __sbss_start);
 288                 bzero(__bss_start, _end - __bss_start);
 289                 init_static_kenv(NULL, 0);
 290         }
 291 #ifdef BOOKE
 292         tlb1_init();
 293 #endif
 294
 295         /* Store boot environment state */
 296         OF_initial_setup((void *)fdt, NULL, (int (*)(void *))ofentry);
 297
 298         /*
 299          * Init params/tunables that can be overridden by the loader
 300          */
 301         init_param1();
 302
 303         /*
 304          * Start initializing proc0 and thread0.
 305          */
 306         proc_linkup0(&proc0, &thread0);
 307         thread0.td_frame = &frame0;
 308
 309         /*
 310          * Set up per-cpu data.
 311          */
 312         pc = __pcpu;
 313         pcpu_init(pc, 0, sizeof(struct pcpu));
 314         pc->pc_curthread = &thread0;
 315 #ifdef __powerpc64__
 316         __asm __volatile("mr 13,%0" :: "r"(pc->pc_curthread));
 317 #else
 318         __asm __volatile("mr 2,%0" :: "r"(pc->pc_curthread));
 319 #endif
 320         pc->pc_cpuid = 0;
 321
 322         __asm __volatile("mtsprg 0, %0" :: "r"(pc));
 323
 324         /*
 325          * Init mutexes, which we use heavily in PMAP
 326          */
 327
 328         mutex_init();
 329
 330         /*
 331          * Install the OF client interface
 332          */
 333
 334         OF_bootstrap();
 335
 336         /*
 337          * Initialize the console before printing anything.
 338          */
 339         cninit();
 340
 341         /*
 342          * Complain if there is no metadata.
 343          */
 344         if (mdp == NULL || kmdp == NULL) {
 345                 printf("powerpc_init: no loader metadata.\n");
 346         }
 347
 348         /*
 349          * Init KDB
 350          */
 351
 352         kdb_init();
 353
 354 #ifdef AIM
 355         aim_cpu_init(toc);
 356 #else /* BOOKE */
 357         booke_cpu_init();
 358
 359         /* Make sure the kernel icache is valid before we go too much further */
 360         __syncicache((caddr_t)startkernel, endkernel - startkernel);
 361 #endif
 362
 363         /*
 364          * Choose a platform module so we can get the physical memory map.
 365          */
 366
 367         platform_probe_and_attach();
 368
 369         /*
 370          * Bring up MMU
 371          */
 372         pmap_bootstrap(startkernel, endkernel);
 373         mtmsr(PSL_KERNSET & ~PSL_EE);
 374
 375         /*
 376          * Initialize params/tunables that are derived from memsize
 377          */
 378         init_param2(physmem);
 379
 380         /*
 381          * Grab booted kernel's name
 382          */
 383         env = kern_getenv("kernelname");
 384         if (env != NULL) {
 385                 strlcpy(kernelname, env, sizeof(kernelname));
 386                 freeenv(env);
 387         }
 388
 389         /*
 390          * Finish setting up thread0.
 391          */
 392         thread0.td_pcb = (struct pcb *)
 393             ((thread0.td_kstack + thread0.td_kstack_pages * PAGE_SIZE -
 394             sizeof(struct pcb)) & ~15UL);
 395         bzero((void *)thread0.td_pcb, sizeof(struct pcb));
 396         pc->pc_curpcb = thread0.td_pcb;
 397
 398         /* Initialise the message buffer. */
 399         msgbufinit(msgbufp, msgbufsize);
 400
 401 #ifdef KDB
 402         if (boothowto & RB_KDB)
 403                 kdb_enter(KDB_WHY_BOOTFLAGS,
 404                     "Boot flags requested debugger");
 405 #endif
 406
 407         return (((uintptr_t)thread0.td_pcb -
 408             (sizeof(struct callframe) - 3*sizeof(register_t))) & ~15UL);
 409 }
 410
 411 void
 412 bzero(void *buf, size_t len)
 413 {
 414         caddr_t p;
 415
 416         p = buf;
 417
 418         while (((vm_offset_t) p & (sizeof(u_long) - 1)) && len) {
 419                 *p++ = 0;
 420                 len--;
 421         }
 422
 423         while (len >= sizeof(u_long) * 8) {
 424                 *(u_long*) p = 0;
 425                 *((u_long*) p + 1) = 0;
 426                 *((u_long*) p + 2) = 0;
 427                 *((u_long*) p + 3) = 0;
 428                 len -= sizeof(u_long) * 8;
 429                 *((u_long*) p + 4) = 0;
 430                 *((u_long*) p + 5) = 0;
 431                 *((u_long*) p + 6) = 0;
 432                 *((u_long*) p + 7) = 0;
 433                 p += sizeof(u_long) * 8;
 434         }
 435
 436         while (len >= sizeof(u_long)) {
 437                 *(u_long*) p = 0;
 438                 len -= sizeof(u_long);
 439                 p += sizeof(u_long);
 440         }
 441
 442         while (len) {
 443                 *p++ = 0;
 444                 len--;
 445         }
 446 }
 447
 448 /*
 449  * Flush the D-cache for non-DMA I/O so that the I-cache can
 450  * be made coherent later.
 451  */
 452 void
 453 cpu_flush_dcache(void *ptr, size_t len)
 454 {
 455         register_t addr, off;
 456
 457         /*
 458          * Align the address to a cacheline and adjust the length
 459          * accordingly. Then round the length to a multiple of the
 460          * cacheline for easy looping.
 461          */
 462         addr = (uintptr_t)ptr;
 463         off = addr & (cacheline_size - 1);
 464         addr -= off;
 465         len = roundup2(len + off, cacheline_size);
 466
 467         while (len > 0) {
 468                 __asm __volatile ("dcbf 0,%0" :: "r"(addr));
 469                 __asm __volatile ("sync");
 470                 addr += cacheline_size;
 471                 len -= cacheline_size;
 472         }
 473 }
 474
 475 int
 476 ptrace_set_pc(struct thread *td, unsigned long addr)
 477 {
 478         struct trapframe *tf;
 479
 480         tf = td->td_frame;
 481         tf->srr0 = (register_t)addr;
 482
 483         return (0);
 484 }
 485
 486 void
 487 spinlock_enter(void)
 488 {
 489         struct thread *td;
 490         register_t msr;
 491
 492         td = curthread;
 493         if (td->td_md.md_spinlock_count == 0) {
 494                 __asm __volatile("or 2,2,2"); /* Set high thread priority */
 495                 msr = intr_disable();
 496                 td->td_md.md_spinlock_count = 1;
 497                 td->td_md.md_saved_msr = msr;
 498         } else
 499                 td->td_md.md_spinlock_count++;
 500         critical_enter();
 501 }
 502
 503 void
 504 spinlock_exit(void)
 505 {
 506         struct thread *td;
 507         register_t msr;
 508
 509         td = curthread;
 510         critical_exit();
 511         msr = td->td_md.md_saved_msr;
 512         td->td_md.md_spinlock_count--;
 513         if (td->td_md.md_spinlock_count == 0) {
 514                 intr_restore(msr);
 515                 __asm __volatile("or 6,6,6"); /* Set normal thread priority */
 516         }
 517 }
 518