pexpert/gen/pe_gen.c

   1 /*
   2  * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_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. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /*
  29  * @OSF_FREE_COPYRIGHT@
  30  */
  31
  32 #include <pexpert/pexpert.h>
  33 #include <pexpert/protos.h>
  34 #include <pexpert/device_tree.h>
  35 #include <kern/debug.h>
  36
  37 #if CONFIG_EMBEDDED
  38 #include <libkern/section_keywords.h>
  39 #endif
  40
  41 static int DEBUGFlag;
  42
  43 #if CONFIG_EMBEDDED
  44 SECURITY_READ_ONLY_LATE(static uint32_t) gPEKernelConfigurationBitmask;
  45 #else
  46 static uint32_t gPEKernelConfigurationBitmask;
  47 #endif
  48
  49 int32_t gPESerialBaud = -1;
  50
  51 int debug_cpu_performance_degradation_factor = 1;
  52
  53 void
  54 pe_init_debug(void)
  55 {
  56         boolean_t boot_arg_value;
  57
  58         if (!PE_parse_boot_argn("debug", &DEBUGFlag, sizeof(DEBUGFlag))) {
  59                 DEBUGFlag = 0;
  60         }
  61
  62         gPEKernelConfigurationBitmask = 0;
  63
  64         if (!PE_parse_boot_argn("assertions", &boot_arg_value, sizeof(boot_arg_value))) {
  65 #if MACH_ASSERT
  66                 boot_arg_value = TRUE;
  67 #else
  68                 boot_arg_value = FALSE;
  69 #endif
  70         }
  71         gPEKernelConfigurationBitmask |= (boot_arg_value ? kPEICanHasAssertions : 0);
  72
  73         if (!PE_parse_boot_argn("statistics", &boot_arg_value, sizeof(boot_arg_value))) {
  74 #if DEVELOPMENT || DEBUG
  75                 boot_arg_value = TRUE;
  76 #else
  77                 boot_arg_value = FALSE;
  78 #endif
  79         }
  80         gPEKernelConfigurationBitmask |= (boot_arg_value ? kPEICanHasStatistics : 0);
  81
  82 #if SECURE_KERNEL
  83         boot_arg_value = FALSE;
  84 #else
  85         if (!PE_i_can_has_debugger(NULL)) {
  86                 boot_arg_value = FALSE;
  87         } else if (!PE_parse_boot_argn("diagnostic_api", &boot_arg_value, sizeof(boot_arg_value))) {
  88                 boot_arg_value = TRUE;
  89         }
  90 #endif
  91         gPEKernelConfigurationBitmask |= (boot_arg_value ? kPEICanHasDiagnosticAPI : 0);
  92
  93
  94         int factor = 1;
  95         boolean_t have_bootarg = PE_parse_boot_argn("cpu-factor", &factor, sizeof(factor));
  96         if (have_bootarg) {
  97                 debug_cpu_performance_degradation_factor = factor;
  98         } else {
  99                 DTEntry         root;
 100                 if (DTLookupEntry(NULL, "/", &root) == kSuccess) {
 101                         void *prop = NULL;
 102                         uint32_t size = 0;
 103                         if (DTGetProperty(root, "target-is-fpga", &prop, &size) == kSuccess) {
 104                                 debug_cpu_performance_degradation_factor = 10;
 105                         }
 106                 }
 107         }
 108 }
 109
 110 void
 111 PE_enter_debugger(const char *cause)
 112 {
 113         if (DEBUGFlag & DB_NMI) {
 114                 Debugger(cause);
 115         }
 116 }
 117
 118 uint32_t
 119 PE_i_can_has_kernel_configuration(void)
 120 {
 121         return gPEKernelConfigurationBitmask;
 122 }
 123
 124 /* extern references */
 125 extern void vcattach(void);
 126
 127 /* Globals */
 128 void (*PE_putc)(char c);
 129
 130 void
 131 PE_init_printf(boolean_t vm_initialized)
 132 {
 133         if (!vm_initialized) {
 134                 PE_putc = cnputc;
 135         } else {
 136                 vcattach();
 137         }
 138 }
 139
 140 uint32_t
 141 PE_get_random_seed(unsigned char *dst_random_seed, uint32_t request_size)
 142 {
 143         DTEntry         entryP;
 144         uint32_t        size = 0;
 145         void            *dt_random_seed;
 146
 147         if ((DTLookupEntry(NULL, "/chosen", &entryP) == kSuccess)
 148             && (DTGetProperty(entryP, "random-seed",
 149             (void **)&dt_random_seed, &size) == kSuccess)) {
 150                 unsigned char *src_random_seed;
 151                 unsigned int i;
 152                 unsigned int null_count = 0;
 153
 154                 src_random_seed = (unsigned char *)dt_random_seed;
 155
 156                 if (size > request_size) {
 157                         size = request_size;
 158                 }
 159
 160                 /*
 161                  * Copy from the device tree into the destination buffer,
 162                  * count the number of null bytes and null out the device tree.
 163                  */
 164                 for (i = 0; i < size; i++, src_random_seed++, dst_random_seed++) {
 165                         *dst_random_seed = *src_random_seed;
 166                         null_count += *src_random_seed == (unsigned char)0;
 167                         *src_random_seed = (unsigned char)0;
 168                 }
 169                 if (null_count == size) {
 170                         /* All nulls is no seed - return 0 */
 171                         size = 0;
 172                 }
 173         }
 174
 175         return size;
 176 }
 177
 178 unsigned char appleClut8[256 * 3] = {
 179 // 00
 180         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xCC, 0xFF, 0xFF, 0x99, 0xFF, 0xFF, 0x66,
 181         0xFF, 0xFF, 0x33, 0xFF, 0xFF, 0x00, 0xFF, 0xCC, 0xFF, 0xFF, 0xCC, 0xCC,
 182         0xFF, 0xCC, 0x99, 0xFF, 0xCC, 0x66, 0xFF, 0xCC, 0x33, 0xFF, 0xCC, 0x00,
 183         0xFF, 0x99, 0xFF, 0xFF, 0x99, 0xCC, 0xFF, 0x99, 0x99, 0xFF, 0x99, 0x66,
 184 // 10
 185         0xFF, 0x99, 0x33, 0xFF, 0x99, 0x00, 0xFF, 0x66, 0xFF, 0xFF, 0x66, 0xCC,
 186         0xFF, 0x66, 0x99, 0xFF, 0x66, 0x66, 0xFF, 0x66, 0x33, 0xFF, 0x66, 0x00,
 187         0xFF, 0x33, 0xFF, 0xFF, 0x33, 0xCC, 0xFF, 0x33, 0x99, 0xFF, 0x33, 0x66,
 188         0xFF, 0x33, 0x33, 0xFF, 0x33, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xCC,
 189 // 20
 190         0xFF, 0x00, 0x99, 0xFF, 0x00, 0x66, 0xFF, 0x00, 0x33, 0xFF, 0x00, 0x00,
 191         0xCC, 0xFF, 0xFF, 0xCC, 0xFF, 0xCC, 0xCC, 0xFF, 0x99, 0xCC, 0xFF, 0x66,
 192         0xCC, 0xFF, 0x33, 0xCC, 0xFF, 0x00, 0xCC, 0xCC, 0xFF, 0xCC, 0xCC, 0xCC,
 193         0xCC, 0xCC, 0x99, 0xCC, 0xCC, 0x66, 0xCC, 0xCC, 0x33, 0xCC, 0xCC, 0x00,
 194 // 30
 195         0xCC, 0x99, 0xFF, 0xCC, 0x99, 0xCC, 0xCC, 0x99, 0x99, 0xCC, 0x99, 0x66,
 196         0xCC, 0x99, 0x33, 0xCC, 0x99, 0x00, 0xCC, 0x66, 0xFF, 0xCC, 0x66, 0xCC,
 197         0xCC, 0x66, 0x99, 0xCC, 0x66, 0x66, 0xCC, 0x66, 0x33, 0xCC, 0x66, 0x00,
 198         0xCC, 0x33, 0xFF, 0xCC, 0x33, 0xCC, 0xCC, 0x33, 0x99, 0xCC, 0x33, 0x66,
 199 // 40
 200         0xCC, 0x33, 0x33, 0xCC, 0x33, 0x00, 0xCC, 0x00, 0xFF, 0xCC, 0x00, 0xCC,
 201         0xCC, 0x00, 0x99, 0xCC, 0x00, 0x66, 0xCC, 0x00, 0x33, 0xCC, 0x00, 0x00,
 202         0x99, 0xFF, 0xFF, 0x99, 0xFF, 0xCC, 0x99, 0xFF, 0x99, 0x99, 0xFF, 0x66,
 203         0x99, 0xFF, 0x33, 0x99, 0xFF, 0x00, 0x99, 0xCC, 0xFF, 0x99, 0xCC, 0xCC,
 204 // 50
 205         0x99, 0xCC, 0x99, 0x99, 0xCC, 0x66, 0x99, 0xCC, 0x33, 0x99, 0xCC, 0x00,
 206         0x99, 0x99, 0xFF, 0x99, 0x99, 0xCC, 0x99, 0x99, 0x99, 0x99, 0x99, 0x66,
 207         0x99, 0x99, 0x33, 0x99, 0x99, 0x00, 0x99, 0x66, 0xFF, 0x99, 0x66, 0xCC,
 208         0x99, 0x66, 0x99, 0x99, 0x66, 0x66, 0x99, 0x66, 0x33, 0x99, 0x66, 0x00,
 209 // 60
 210         0x99, 0x33, 0xFF, 0x99, 0x33, 0xCC, 0x99, 0x33, 0x99, 0x99, 0x33, 0x66,
 211         0x99, 0x33, 0x33, 0x99, 0x33, 0x00, 0x99, 0x00, 0xFF, 0x99, 0x00, 0xCC,
 212         0x99, 0x00, 0x99, 0x99, 0x00, 0x66, 0x99, 0x00, 0x33, 0x99, 0x00, 0x00,
 213         0x66, 0xFF, 0xFF, 0x66, 0xFF, 0xCC, 0x66, 0xFF, 0x99, 0x66, 0xFF, 0x66,
 214 // 70
 215         0x66, 0xFF, 0x33, 0x66, 0xFF, 0x00, 0x66, 0xCC, 0xFF, 0x66, 0xCC, 0xCC,
 216         0x66, 0xCC, 0x99, 0x66, 0xCC, 0x66, 0x66, 0xCC, 0x33, 0x66, 0xCC, 0x00,
 217         0x66, 0x99, 0xFF, 0x66, 0x99, 0xCC, 0x66, 0x99, 0x99, 0x66, 0x99, 0x66,
 218         0x66, 0x99, 0x33, 0x66, 0x99, 0x00, 0x66, 0x66, 0xFF, 0x66, 0x66, 0xCC,
 219 // 80
 220         0x66, 0x66, 0x99, 0x66, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x66, 0x00,
 221         0x66, 0x33, 0xFF, 0x66, 0x33, 0xCC, 0x66, 0x33, 0x99, 0x66, 0x33, 0x66,
 222         0x66, 0x33, 0x33, 0x66, 0x33, 0x00, 0x66, 0x00, 0xFF, 0x66, 0x00, 0xCC,
 223         0x66, 0x00, 0x99, 0x66, 0x00, 0x66, 0x66, 0x00, 0x33, 0x66, 0x00, 0x00,
 224 // 90
 225         0x33, 0xFF, 0xFF, 0x33, 0xFF, 0xCC, 0x33, 0xFF, 0x99, 0x33, 0xFF, 0x66,
 226         0x33, 0xFF, 0x33, 0x33, 0xFF, 0x00, 0x33, 0xCC, 0xFF, 0x33, 0xCC, 0xCC,
 227         0x33, 0xCC, 0x99, 0x33, 0xCC, 0x66, 0x33, 0xCC, 0x33, 0x33, 0xCC, 0x00,
 228         0x33, 0x99, 0xFF, 0x33, 0x99, 0xCC, 0x33, 0x99, 0x99, 0x33, 0x99, 0x66,
 229 // a0
 230         0x33, 0x99, 0x33, 0x33, 0x99, 0x00, 0x33, 0x66, 0xFF, 0x33, 0x66, 0xCC,
 231         0x33, 0x66, 0x99, 0x33, 0x66, 0x66, 0x33, 0x66, 0x33, 0x33, 0x66, 0x00,
 232         0x33, 0x33, 0xFF, 0x33, 0x33, 0xCC, 0x33, 0x33, 0x99, 0x33, 0x33, 0x66,
 233         0x33, 0x33, 0x33, 0x33, 0x33, 0x00, 0x33, 0x00, 0xFF, 0x33, 0x00, 0xCC,
 234 // b0
 235         0x33, 0x00, 0x99, 0x33, 0x00, 0x66, 0x33, 0x00, 0x33, 0x33, 0x00, 0x00,
 236         0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xCC, 0x00, 0xFF, 0x99, 0x00, 0xFF, 0x66,
 237         0x00, 0xFF, 0x33, 0x00, 0xFF, 0x00, 0x00, 0xCC, 0xFF, 0x00, 0xCC, 0xCC,
 238         0x00, 0xCC, 0x99, 0x00, 0xCC, 0x66, 0x00, 0xCC, 0x33, 0x00, 0xCC, 0x00,
 239 // c0
 240         0x00, 0x99, 0xFF, 0x00, 0x99, 0xCC, 0x00, 0x99, 0x99, 0x00, 0x99, 0x66,
 241         0x00, 0x99, 0x33, 0x00, 0x99, 0x00, 0x00, 0x66, 0xFF, 0x00, 0x66, 0xCC,
 242         0x00, 0x66, 0x99, 0x00, 0x66, 0x66, 0x00, 0x66, 0x33, 0x00, 0x66, 0x00,
 243         0x00, 0x33, 0xFF, 0x00, 0x33, 0xCC, 0x00, 0x33, 0x99, 0x00, 0x33, 0x66,
 244 // d0
 245         0x00, 0x33, 0x33, 0x00, 0x33, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xCC,
 246         0x00, 0x00, 0x99, 0x00, 0x00, 0x66, 0x00, 0x00, 0x33, 0xEE, 0x00, 0x00,
 247         0xDD, 0x00, 0x00, 0xBB, 0x00, 0x00, 0xAA, 0x00, 0x00, 0x88, 0x00, 0x00,
 248         0x77, 0x00, 0x00, 0x55, 0x00, 0x00, 0x44, 0x00, 0x00, 0x22, 0x00, 0x00,
 249 // e0
 250         0x11, 0x00, 0x00, 0x00, 0xEE, 0x00, 0x00, 0xDD, 0x00, 0x00, 0xBB, 0x00,
 251         0x00, 0xAA, 0x00, 0x00, 0x88, 0x00, 0x00, 0x77, 0x00, 0x00, 0x55, 0x00,
 252         0x00, 0x44, 0x00, 0x00, 0x22, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xEE,
 253         0x00, 0x00, 0xDD, 0x00, 0x00, 0xBB, 0x00, 0x00, 0xAA, 0x00, 0x00, 0x88,
 254 // f0
 255         0x00, 0x00, 0x77, 0x00, 0x00, 0x55, 0x00, 0x00, 0x44, 0x00, 0x00, 0x22,
 256         0x00, 0x00, 0x11, 0xEE, 0xEE, 0xEE, 0xDD, 0xDD, 0xDD, 0xBB, 0xBB, 0xBB,
 257         0xAA, 0xAA, 0xAA, 0x88, 0x88, 0x88, 0x77, 0x77, 0x77, 0x55, 0x55, 0x55,
 258         0x44, 0x44, 0x44, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x00, 0x00, 0x00
 259 };