osfmk/ppc/ppc_init.c

   1 /*
   2  * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23 /*
  24  * @OSF_COPYRIGHT@
  25  */
  26
  27 #include <debug.h>
  28 #include <mach_ldebug.h>
  29 #include <mach_kdb.h>
  30 #include <mach_kdp.h>
  31
  32 #include <kern/misc_protos.h>
  33 #include <kern/thread.h>
  34 #include <kern/processor.h>
  35 #include <kern/startup.h>
  36 #include <machine/machine_routines.h>
  37 #include <ppc/boot.h>
  38 #include <ppc/proc_reg.h>
  39 #include <ppc/misc_protos.h>
  40 #include <ppc/pmap.h>
  41 #include <ppc/new_screen.h>
  42 #include <ppc/exception.h>
  43 #include <ppc/asm.h>
  44 #include <ppc/Firmware.h>
  45 #include <ppc/savearea.h>
  46 #include <ppc/low_trace.h>
  47 #include <ppc/Diagnostics.h>
  48 #include <ppc/cpu_internal.h>
  49 #include <ppc/mem.h>
  50 #include <ppc/mappings.h>
  51 #include <ppc/locks.h>
  52 #include <ppc/pms.h>
  53 #include <ppc/rtclock.h>
  54
  55 #include <pexpert/pexpert.h>
  56
  57 extern unsigned int mckFlags;
  58 extern vm_offset_t      intstack;
  59 extern vm_offset_t      debstack;
  60
  61 int pc_trace_buf[1024] = {0};
  62 int pc_trace_cnt = 1024;
  63
  64 extern unsigned int extPatchMCK;
  65 extern unsigned int extPatch32;
  66 extern unsigned int hwulckPatch_isync;
  67 extern unsigned int hwulckPatch_eieio;
  68 extern unsigned int hwulckbPatch_isync;
  69 extern unsigned int hwulckbPatch_eieio;
  70 extern unsigned int mulckPatch_isync;
  71 extern unsigned int mulckPatch_eieio;
  72 extern unsigned int mulckePatch_isync;
  73 extern unsigned int mulckePatch_eieio;
  74 extern unsigned int sulckPatch_isync;
  75 extern unsigned int sulckPatch_eieio;
  76 extern unsigned int rwlesPatch_isync;
  77 extern unsigned int rwlesPatch_eieio;
  78 extern unsigned int rwldPatch_isync;
  79 extern unsigned int rwldPatch_eieio;
  80 extern unsigned int retfsectPatch_eieio;
  81 extern unsigned int retfsectPatch_isync;
  82 extern unsigned int bcopy_nop_if_32bit;
  83 extern unsigned int bcopy_nc_nop_if_32bit;
  84 extern unsigned int memcpy_nop_if_32bit;
  85 extern unsigned int xsum_nop_if_32bit;
  86 extern unsigned int uft_nop_if_32bit;
  87 extern unsigned int uft_uaw_nop_if_32bit;
  88 extern unsigned int uft_cuttrace;
  89
  90 int forcenap = 0;
  91 int wcte = 0;                           /* Non-cache gather timer disabled */
  92
  93 patch_entry_t patch_table[] = {
  94         {&extPatch32,                   0x60000000, PATCH_FEATURE,              PatchExt32},
  95         {&extPatchMCK,                  0x60000000, PATCH_PROCESSOR,    CPU_SUBTYPE_POWERPC_970},
  96         {&hwulckPatch_isync,    0x60000000, PATCH_FEATURE,              PatchLwsync},
  97         {&hwulckPatch_eieio,    0x7c2004ac, PATCH_FEATURE,              PatchLwsync},
  98         {&hwulckbPatch_isync,   0x60000000, PATCH_FEATURE,              PatchLwsync},
  99         {&hwulckbPatch_eieio,   0x7c2004ac, PATCH_FEATURE,              PatchLwsync},
 100         {&mulckPatch_isync,             0x60000000, PATCH_FEATURE,              PatchLwsync},
 101         {&mulckPatch_eieio,             0x7c2004ac, PATCH_FEATURE,              PatchLwsync},
 102         {&mulckePatch_isync,    0x60000000, PATCH_FEATURE,              PatchLwsync},
 103         {&mulckePatch_eieio,    0x7c2004ac, PATCH_FEATURE,              PatchLwsync},
 104         {&sulckPatch_isync,             0x60000000, PATCH_FEATURE,              PatchLwsync},
 105         {&sulckPatch_eieio,             0x7c2004ac, PATCH_FEATURE,              PatchLwsync},
 106         {&rwlesPatch_isync,             0x60000000, PATCH_FEATURE,              PatchLwsync},
 107         {&rwlesPatch_eieio,             0x7c2004ac, PATCH_FEATURE,              PatchLwsync},
 108         {&rwldPatch_isync,              0x60000000, PATCH_FEATURE,              PatchLwsync},
 109         {&rwldPatch_eieio,              0x7c2004ac, PATCH_FEATURE,              PatchLwsync},
 110         {&bcopy_nop_if_32bit,   0x60000000, PATCH_FEATURE,              PatchExt32},
 111         {&bcopy_nc_nop_if_32bit,0x60000000, PATCH_FEATURE,              PatchExt32},
 112         {&memcpy_nop_if_32bit,  0x60000000, PATCH_FEATURE,              PatchExt32},
 113 #if     !MACH_LDEBUG
 114         {&retfsectPatch_isync,  0x60000000, PATCH_FEATURE,              PatchLwsync},
 115         {&retfsectPatch_eieio,  0x7c2004ac, PATCH_FEATURE,              PatchLwsync},
 116 #endif
 117         {&xsum_nop_if_32bit,    0x60000000,     PATCH_FEATURE,          PatchExt32},
 118         {&uft_nop_if_32bit,             0x60000000,     PATCH_FEATURE,          PatchExt32},
 119         {&uft_uaw_nop_if_32bit, 0x60000000,     PATCH_FEATURE,          PatchExt32},
 120         {&uft_cuttrace,                 0x60000000,     PATCH_FEATURE,          PatchExt32},
 121     {NULL,                  0x00000000, PATCH_END_OF_TABLE, 0}
 122         };
 123
 124
 125 /*
 126  * Forward definition
 127  */
 128 void    ppc_init(
 129                         boot_args       *args);
 130
 131 void    ppc_init_cpu(
 132                         struct per_proc_info *proc_info);
 133
 134 /*
 135  *              Routine:                ppc_init
 136  *              Function:
 137  */
 138 void
 139 ppc_init(
 140                 boot_args *args)
 141 {
 142         unsigned int            maxmem;
 143         uint64_t                        xmaxmem;
 144         uint64_t                        newhid;
 145         unsigned int            cputrace;
 146         unsigned int            novmx;
 147         unsigned int            mcksoft;
 148         thread_t                        thread;
 149         mapping_t                       *mp;
 150         uint64_t                        scdata;
 151
 152
 153
 154         /*
 155          * Setup per_proc info for first cpu.
 156          */
 157
 158         BootProcInfo.cpu_number = 0;
 159         BootProcInfo.cpu_flags = 0;
 160         BootProcInfo.istackptr = 0;                                                     /* we're on the interrupt stack */
 161         BootProcInfo.intstack_top_ss = (vm_offset_t)&intstack + INTSTACK_SIZE - FM_SIZE;
 162         BootProcInfo.debstack_top_ss = (vm_offset_t)&debstack + KERNEL_STACK_SIZE - FM_SIZE;
 163         BootProcInfo.debstackptr = BootProcInfo.debstack_top_ss;
 164         BootProcInfo.interrupts_enabled = 0;
 165         BootProcInfo.pending_ast = AST_NONE;
 166         BootProcInfo.FPU_owner = 0;
 167         BootProcInfo.VMX_owner = 0;
 168         BootProcInfo.pp_cbfr = console_per_proc_alloc(TRUE);
 169         BootProcInfo.rtcPop = EndOfAllTime;
 170         BootProcInfo.pp2ndPage = (addr64_t)&BootProcInfo;       /* Initial physical address of the second page */
 171
 172         BootProcInfo.pms.pmsStamp = 0;                                          /* Dummy transition time */
 173         BootProcInfo.pms.pmsPop = EndOfAllTime;                         /* Set the pop way into the future */
 174
 175         BootProcInfo.pms.pmsState = pmsParked;                          /* Park the power stepper */
 176         BootProcInfo.pms.pmsCSetCmd = pmsCInit;                         /* Set dummy initial hardware state */
 177
 178         mp = (mapping_t *)BootProcInfo.ppUMWmp;
 179         mp->mpFlags = 0x01000000 | mpLinkage | mpPerm | 1;
 180         mp->mpSpace = invalSpace;
 181
 182         pmsInit();                                                                                      /* Initialize the stepper */
 183
 184         thread_bootstrap();
 185
 186         thread = current_thread();
 187         thread->machine.curctx = &thread->machine.facctx;
 188         thread->machine.facctx.facAct = thread;
 189         thread->machine.umwSpace = invalSpace;                          /* Initialize user memory window space to invalid */
 190         thread->machine.preemption_count = 1;
 191
 192         cpu_bootstrap();
 193         cpu_init();
 194
 195         master_cpu = 0;
 196         processor_bootstrap();
 197
 198         timer_switch((uint32_t)mach_absolute_time(), &thread->system_timer);
 199
 200         static_memory_end = round_page(args->topOfKernelData);;
 201
 202         PE_init_platform(FALSE, args);                                          /* Get platform expert set up */
 203
 204         if (!PE_parse_boot_arg("novmx", &novmx)) novmx=0;       /* Special run without VMX? */
 205         if(novmx) {                                                                                     /* Yeah, turn it off */
 206                 BootProcInfo.pf.Available &= ~pfAltivec;                /* Turn off Altivec available */
 207                 __asm__ volatile("mtsprg 2,%0" : : "r" (BootProcInfo.pf.Available));    /* Set live value */
 208         }
 209
 210         if (!PE_parse_boot_arg("fn", &forcenap)) forcenap = 0;  /* If force nap not set, make 0 */
 211         else {
 212                 if(forcenap < 2) forcenap = forcenap + 1;               /* Else set 1 for off, 2 for on */
 213                 else forcenap = 0;                                                              /* Clear for error case */
 214         }
 215
 216         if (!PE_parse_boot_arg("pmsx", &pmsExperimental)) pmsExperimental = 0;  /* Check if we should start in experimental power management stepper mode */
 217         if (!PE_parse_boot_arg("lcks", &LcksOpts)) LcksOpts = 0;        /* Set lcks options */
 218         if (!PE_parse_boot_arg("diag", &dgWork.dgFlags)) dgWork.dgFlags = 0;    /* Set diagnostic flags */
 219         if(dgWork.dgFlags & enaExpTrace) trcWork.traceMask = 0xFFFFFFFF;        /* If tracing requested, enable it */
 220
 221         if(PE_parse_boot_arg("ctrc", &cputrace)) {                      /* See if tracing is limited to a specific cpu */
 222                 trcWork.traceMask = (trcWork.traceMask & 0xFFFFFFF0) | (cputrace & 0xF);        /* Limit to 4 */
 223         }
 224
 225         if(!PE_parse_boot_arg("tb", &trcWork.traceSize)) {      /* See if non-default trace buffer size */
 226 #if DEBUG
 227                 trcWork.traceSize = 32;                                                 /* Default 32 page trace table for DEBUG */
 228 #else
 229                 trcWork.traceSize = 8;                                                  /* Default 8 page trace table for RELEASE */
 230 #endif
 231         }
 232
 233         if(trcWork.traceSize < 1) trcWork.traceSize = 1;        /* Minimum size of 1 page */
 234         if(trcWork.traceSize > 256) trcWork.traceSize = 256;    /* Maximum size of 256 pages */
 235         trcWork.traceSize = trcWork.traceSize * 4096;           /* Change page count to size */
 236
 237         if (!PE_parse_boot_arg("maxmem", &maxmem))
 238                 xmaxmem=0;
 239         else
 240                 xmaxmem = (uint64_t)maxmem * (1024 * 1024);
 241
 242         if (!PE_parse_boot_arg("wcte", &wcte)) wcte = 0;        /* If write combine timer enable not supplied, make 1 */
 243         else wcte = (wcte != 0);                                                        /* Force to 0 or 1 */
 244
 245         if (!PE_parse_boot_arg("mcklog", &mckFlags)) mckFlags = 0;      /* If machine check flags not specified, clear */
 246         else if(mckFlags > 1) mckFlags = 0;                                     /* If bogus, clear */
 247
 248     if (!PE_parse_boot_arg("ht_shift", &hash_table_shift))  /* should we use a non-default hash table size? */
 249         hash_table_shift = 0;                           /* no, use default size */
 250
 251         /*
 252          * VM initialization, after this we're using page tables...
 253          */
 254
 255         ppc_vm_init(xmaxmem, args);
 256
 257         if(BootProcInfo.pf.Available & pf64Bit) {                       /* Are we on a 64-bit machine */
 258
 259                 if(!wcte) {
 260                         (void)ml_scom_read(GUSModeReg << 8, &scdata);   /* Get GUS mode register */
 261                         scdata = scdata | GUSMstgttoff;                                 /* Disable the NCU store gather timer */
 262                         (void)ml_scom_write(GUSModeReg << 8, scdata);   /* Get GUS mode register */
 263                 }
 264
 265                 if(PE_parse_boot_arg("mcksoft", &mcksoft)) {    /* Have they supplied "machine check software recovery? */
 266                         newhid = BootProcInfo.pf.pfHID5;                        /* Get the old HID5 */
 267                         if(mcksoft < 2) {
 268                                 newhid &= 0xFFFFFFFFFFFFDFFFULL;                /* Clear the old one */
 269                                 newhid |= (mcksoft & 1) << 13;                  /* Set new value to enable machine check recovery */
 270                                 BootProcInfo.pf.pfHID5 = newhid;                /* Set the new one */
 271                                 hid5set64(newhid);                                              /* Set the hid for this processir */
 272                         }
 273                 }
 274         }
 275
 276         machine_startup(args);
 277 }
 278
 279 /*
 280  *              Routine:                ppc_init_cpu
 281  *              Function:
 282  */
 283 void
 284 ppc_init_cpu(
 285                 struct per_proc_info    *proc_info)
 286 {
 287         uint64_t scdata;
 288
 289         proc_info->cpu_flags &= ~SleepState;
 290
 291         if((BootProcInfo.pf.Available & pf64Bit) && !wcte) {    /* Should we disable the store gather timer? */
 292                 (void)ml_scom_read(GUSModeReg << 8, &scdata);   /* Get GUS mode register */
 293                 scdata = scdata | GUSMstgttoff;                                 /* Disable the NCU store gather timer */
 294                 (void)ml_scom_write(GUSModeReg << 8, scdata);   /* Get GUS mode register */
 295         }
 296
 297         cpu_init();
 298
 299         slave_main();
 300 }