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 * file: pe_init.c
30 * i386 platform expert initialization.
31 */
32
33 #include <console/video_console.h>
34 #include <sys/types.h>
35 #include <mach/vm_param.h>
36 #include <machine/machine_routines.h>
37 #include <pexpert/protos.h>
38 #include <pexpert/pexpert.h>
39 #include <pexpert/boot.h>
40 #include <pexpert/device_tree.h>
41 #include <pexpert/pe_images.h>
42 #include <kern/sched_prim.h>
43 #include <kern/debug.h>
44
45 #if CONFIG_CSR
46 #include <sys/csr.h>
47 #endif
48
49 #include "boot_images.h"
50
51 /* extern references */
52 extern void pe_identify_machine(void * args);
53 extern int kdb_printf(const char *format, ...) __printflike(1, 2);
54 /* private globals */
55 PE_state_t PE_state;
56 SECURITY_READ_ONLY_LATE(uint32_t) PE_srd_fused = 0;
57
58 /* Clock Frequency Info */
59 clock_frequency_info_t gPEClockFrequencyInfo;
60
61 void *gPEEFISystemTable;
62 void *gPEEFIRuntimeServices;
63
64 static boot_icon_element* norootIcon_lzss;
65 static const uint8_t* norootClut_lzss;
66
67 int
PE_initialize_console(PE_Video * info,int op)68 PE_initialize_console( PE_Video * info, int op )
69 {
70 static int last_console = -1;
71
72 if (info) {
73 info->v_offset = 0;
74 info->v_length = 0;
75 info->v_display = GRAPHICS_MODE;
76 }
77
78 switch (op) {
79 case kPEDisableScreen:
80 initialize_screen(info, op);
81 kprintf("kPEDisableScreen %d\n", last_console);
82 if (!console_is_serial()) {
83 last_console = switch_to_serial_console();
84 }
85 break;
86
87 case kPEEnableScreen:
88 initialize_screen(info, op);
89 if (info) {
90 PE_state.video = *info;
91 }
92 kprintf("kPEEnableScreen %d\n", last_console);
93 if (last_console != -1) {
94 switch_to_old_console( last_console);
95 }
96 break;
97
98 case kPEBaseAddressChange:
99 if (info) {
100 PE_state.video = *info;
101 }
102 OS_FALLTHROUGH;
103
104 default:
105 initialize_screen(info, op);
106 break;
107 }
108
109 return 0;
110 }
111
112 void
PE_init_iokit(void)113 PE_init_iokit(void)
114 {
115 enum { kMaxBootVar = 128 };
116
117 boolean_t bootClutInitialized = FALSE;
118 boolean_t noroot_rle_Initialized = FALSE;
119
120 DTEntry entry;
121 unsigned int size;
122 uint32_t const *map;
123 boot_progress_element *bootPict;
124
125 norootIcon_lzss = NULL;
126 norootClut_lzss = NULL;
127
128 PE_init_printf(TRUE);
129
130 kprintf("Kernel boot args: '%s'\n", PE_boot_args());
131
132 /*
133 * Fetch the CLUT and the noroot image.
134 */
135
136 if (kSuccess == SecureDTLookupEntry(NULL, "/chosen/memory-map", &entry)) {
137 if (kSuccess == SecureDTGetProperty(entry, "BootCLUT", (void const **) &map, &size)) {
138 if (sizeof(appleClut8) <= map[1]) {
139 bcopy((void *)ml_static_ptovirt(map[0]), appleClut8, sizeof(appleClut8));
140 bootClutInitialized = TRUE;
141 }
142 }
143
144 if (kSuccess == SecureDTGetProperty(entry, "Pict-FailedBoot", (void const **) &map, &size)) {
145 bootPict = (boot_progress_element *) ml_static_ptovirt(map[0]);
146 default_noroot.width = bootPict->width;
147 default_noroot.height = bootPict->height;
148 default_noroot.dx = 0;
149 default_noroot.dy = bootPict->yOffset;
150 default_noroot_data = &bootPict->data[0];
151 noroot_rle_Initialized = TRUE;
152 }
153
154 if (kSuccess == SecureDTGetProperty(entry, "FailedCLUT", (void const **) &map, &size)) {
155 norootClut_lzss = (uint8_t*) ml_static_ptovirt(map[0]);
156 }
157
158 if (kSuccess == SecureDTGetProperty(entry, "FailedImage", (void const **) &map, &size)) {
159 norootIcon_lzss = (boot_icon_element *) ml_static_ptovirt(map[0]);
160 if (norootClut_lzss == NULL) {
161 printf("ERROR: No FailedCLUT provided for noroot icon!\n");
162 }
163 }
164 }
165
166 if (!bootClutInitialized) {
167 bcopy((void *) (uintptr_t) bootClut, (void *) appleClut8, sizeof(appleClut8));
168 }
169
170 if (!noroot_rle_Initialized) {
171 default_noroot.width = kFailedBootWidth;
172 default_noroot.height = kFailedBootHeight;
173 default_noroot.dx = 0;
174 default_noroot.dy = kFailedBootOffset;
175 default_noroot_data = failedBootPict;
176 }
177
178 /*
179 * Initialize the spinning wheel (progress indicator).
180 */
181 vc_progress_initialize(&default_progress,
182 default_progress_data1x,
183 default_progress_data2x,
184 default_progress_data3x,
185 (unsigned char *) appleClut8);
186
187 /*
188 * x86 only minimally enforces lockdown in hardware. Additionally, some pre-lockdown functionality
189 * such as commpage initialization requires IOKit enumeration of CPUs, which is heavily entangled
190 * with the ACPI stack. Therefore, we start the IOKit matching process immediately on x86.
191 */
192 InitIOKit(PE_state.deviceTreeHead);
193 zalloc_iokit_lockdown();
194 StartIOKitMatching();
195 }
196
197 void
PE_lockdown_iokit(void)198 PE_lockdown_iokit(void)
199 {
200 /* Ensure that at least the CPUs have been enumerated before moving forward. */
201 ml_wait_max_cpus();
202 }
203
204 void
PE_init_platform(boolean_t vm_initialized,void * _args)205 PE_init_platform(boolean_t vm_initialized, void * _args)
206 {
207 boot_args *args = (boot_args *)_args;
208
209 if (PE_state.initialized == FALSE) {
210 PE_state.initialized = TRUE;
211
212 // New EFI-style
213 PE_state.bootArgs = _args;
214 PE_state.deviceTreeHead = (void *) ml_static_ptovirt(args->deviceTreeP);
215 PE_state.deviceTreeSize = args->deviceTreeLength;
216 if (args->Video.v_baseAddr) {
217 PE_state.video.v_baseAddr = args->Video.v_baseAddr;// remains physical address
218 PE_state.video.v_rowBytes = args->Video.v_rowBytes;
219 PE_state.video.v_depth = args->Video.v_depth;
220 PE_state.video.v_display = args->Video.v_display;
221 PE_state.video.v_rotate = args->Video.v_rotate;
222
223 /* EFI doesn't have a good way of describing rotation internally,
224 * so it flips width and height in portrait mode. We flip it back. */
225 if (PE_state.video.v_rotate == kDataRotate90 ||
226 PE_state.video.v_rotate == kDataRotate270) {
227 PE_state.video.v_width = args->Video.v_height;
228 PE_state.video.v_height = args->Video.v_width;
229 } else {
230 PE_state.video.v_width = args->Video.v_width;
231 PE_state.video.v_height = args->Video.v_height;
232 }
233
234 strlcpy(PE_state.video.v_pixelFormat, "PPPPPPPP",
235 sizeof(PE_state.video.v_pixelFormat));
236 } else {
237 PE_state.video.v_baseAddr = args->VideoV1.v_baseAddr;// remains physical address
238 PE_state.video.v_rowBytes = args->VideoV1.v_rowBytes;
239 PE_state.video.v_width = args->VideoV1.v_width;
240 PE_state.video.v_height = args->VideoV1.v_height;
241 PE_state.video.v_depth = args->VideoV1.v_depth;
242 PE_state.video.v_display = args->VideoV1.v_display;
243 PE_state.video.v_rotate = kDataRotate0; /* no room for rotation info */
244 strlcpy(PE_state.video.v_pixelFormat, "PPPPPPPP",
245 sizeof(PE_state.video.v_pixelFormat));
246 }
247
248 #ifdef kBootArgsFlagHiDPI
249 if (args->flags & kBootArgsFlagHiDPI) {
250 PE_state.video.v_scale = kPEScaleFactor2x;
251 } else {
252 PE_state.video.v_scale = kPEScaleFactor1x;
253 }
254 #else
255 PE_state.video.v_scale = kPEScaleFactor1x;
256 #endif
257 }
258
259 if (!vm_initialized) {
260 if (PE_state.deviceTreeHead) {
261 SecureDTInit(PE_state.deviceTreeHead, PE_state.deviceTreeSize);
262 }
263
264 pe_identify_machine(args);
265 pe_init_debug();
266 }
267 }
268
269 void
PE_create_console(void)270 PE_create_console( void )
271 {
272 if (PE_state.video.v_display == GRAPHICS_MODE) {
273 PE_initialize_console( &PE_state.video, kPEGraphicsMode );
274 } else {
275 PE_initialize_console( &PE_state.video, kPETextMode );
276 }
277 }
278
279 int
PE_current_console(PE_Video * info)280 PE_current_console( PE_Video * info )
281 {
282 *info = PE_state.video;
283
284 return 0;
285 }
286
287 void
PE_display_icon(__unused unsigned int flags,__unused const char * name)288 PE_display_icon( __unused unsigned int flags, __unused const char * name )
289 {
290 if (norootIcon_lzss && norootClut_lzss) {
291 uint32_t width = norootIcon_lzss->width;
292 uint32_t height = norootIcon_lzss->height;
293 uint32_t x = ((PE_state.video.v_width - width) / 2);
294 uint32_t y = ((PE_state.video.v_height - height) / 2) + norootIcon_lzss->y_offset_from_center;
295
296 vc_display_lzss_icon(x, y, width, height,
297 &norootIcon_lzss->data[0],
298 norootIcon_lzss->data_size,
299 norootClut_lzss);
300 } else if (default_noroot_data) {
301 vc_display_icon( &default_noroot, default_noroot_data );
302 } else {
303 printf("ERROR: No data found for noroot icon!\n");
304 }
305 }
306
307 boolean_t
PE_get_hotkey(__unused unsigned char key)308 PE_get_hotkey(__unused unsigned char key)
309 {
310 return FALSE;
311 }
312
313 static timebase_callback_func gTimebaseCallback;
314
315 void
PE_register_timebase_callback(timebase_callback_func callback)316 PE_register_timebase_callback(timebase_callback_func callback)
317 {
318 gTimebaseCallback = callback;
319
320 PE_call_timebase_callback();
321 }
322
323 void
PE_call_timebase_callback(void)324 PE_call_timebase_callback(void)
325 {
326 struct timebase_freq_t timebase_freq;
327 unsigned long num, den, cnt;
328
329 num = gPEClockFrequencyInfo.bus_clock_rate_num * gPEClockFrequencyInfo.bus_to_dec_rate_num;
330 den = gPEClockFrequencyInfo.bus_clock_rate_den * gPEClockFrequencyInfo.bus_to_dec_rate_den;
331
332 cnt = 2;
333 while (cnt <= den) {
334 if ((num % cnt) || (den % cnt)) {
335 cnt++;
336 continue;
337 }
338
339 num /= cnt;
340 den /= cnt;
341 }
342
343 timebase_freq.timebase_num = num;
344 timebase_freq.timebase_den = den;
345
346 if (gTimebaseCallback) {
347 gTimebaseCallback(&timebase_freq);
348 }
349 }
350
351 /*
352 * The default (non-functional) PE_poll_input handler.
353 */
354 int
PE_stub_poll_input(__unused unsigned int options,char * c)355 PE_stub_poll_input(__unused unsigned int options, char * c)
356 {
357 *c = 0xff;
358 return 1; /* 0 for success, 1 for unsupported */
359 }
360
361 boolean_t
PE_reboot_on_panic(void)362 PE_reboot_on_panic(void)
363 {
364 boot_args *args = (boot_args *)PE_state.bootArgs;
365
366 if (args->flags & kBootArgsFlagRebootOnPanic) {
367 return TRUE;
368 } else {
369 return FALSE;
370 }
371 }
372
373 void
PE_sync_panic_buffers(void)374 PE_sync_panic_buffers(void)
375 {
376 }
377
378 /* rdar://problem/21244753 */
379 uint32_t
PE_i_can_has_debugger(uint32_t * debug_flags)380 PE_i_can_has_debugger(uint32_t *debug_flags)
381 {
382 #if DEVELOPMENT || DEBUG
383 if (debug_flags) {
384 assert(startup_phase >= STARTUP_SUB_TUNABLES);
385 }
386 #endif
387
388 #if CONFIG_CSR
389 if (csr_check(CSR_ALLOW_KERNEL_DEBUGGER) != 0) {
390 if (debug_flags) {
391 *debug_flags = 0;
392 }
393 return FALSE;
394 }
395 #endif
396 if (debug_flags) {
397 *debug_flags = debug_boot_arg;
398 }
399 return TRUE;
400 }
401
402 uint32_t
PE_get_offset_into_panic_region(char * location)403 PE_get_offset_into_panic_region(char *location)
404 {
405 assert(panic_info != NULL);
406 assert(location > (char *) panic_info);
407
408 return (uint32_t) (location - (char *) panic_info);
409 }
410
411 void
PE_init_panicheader()412 PE_init_panicheader()
413 {
414 bzero(panic_info, offsetof(struct macos_panic_header, mph_data));
415 panic_info->mph_panic_log_offset = PE_get_offset_into_panic_region(debug_buf_base);
416
417 panic_info->mph_magic = MACOS_PANIC_MAGIC;
418 panic_info->mph_version = MACOS_PANIC_HEADER_CURRENT_VERSION;
419
420 return;
421 }
422
423 /*
424 * Tries to update the panic header to keep it consistent on nested panics.
425 *
426 * NOTE: The purpose of this function is NOT to detect/correct corruption in the panic region,
427 * it is to update the panic header to make it consistent when we nest panics.
428 *
429 * We try to avoid nested panics/asserts on x86 because they are difficult to debug, so log any
430 * inconsistencies we find.
431 */
432 void
PE_update_panicheader_nestedpanic()433 PE_update_panicheader_nestedpanic()
434 {
435 /*
436 * if the panic header pointer is bogus (e.g. someone stomped on it) then bail.
437 */
438 if (!panic_info) {
439 /* if this happens in development then blow up bigly */
440 assert(panic_info);
441 return;
442 }
443
444 /* If the panic log offset is not set, re-init the panic header */
445 if (panic_info->mph_panic_log_offset == 0) {
446 PE_init_panicheader();
447 panic_info->mph_panic_flags |= MACOS_PANIC_HEADER_FLAG_NESTED_PANIC;
448 return;
449 }
450
451 panic_info->mph_panic_flags |= MACOS_PANIC_HEADER_FLAG_NESTED_PANIC;
452
453 /* Usually indicative of corruption in the panic region */
454 if (!(((panic_info->mph_stackshot_offset == 0) && (panic_info->mph_stackshot_len == 0)) ||
455 ((panic_info->mph_stackshot_offset != 0) && (panic_info->mph_stackshot_len != 0)))) {
456 kdb_printf("panic_info contains invalid stackshot metadata: mph_stackshot_offset 0x%x mph_stackshot_len 0x%x\n",
457 panic_info->mph_stackshot_offset, panic_info->mph_stackshot_len);
458
459 panic_info->mph_panic_flags |= MACOS_PANIC_HEADER_FLAG_INCOHERENT_PANICLOG;
460 }
461
462 /*
463 * macOS panic logs contain nested panic data, if we've already closed the panic log,
464 * begin the other log.
465 */
466 if ((panic_info->mph_panic_log_len != 0) && (panic_info->mph_other_log_offset == 0)) {
467 panic_info->mph_other_log_offset = PE_get_offset_into_panic_region(debug_buf_ptr);
468
469 /* Usually indicative of corruption in the panic region */
470 if (panic_info->mph_other_log_len != 0) {
471 kdb_printf("panic_info contains invalid other log metadata (zero offset but non-zero length), length was 0x%x, zeroing value\n",
472 panic_info->mph_other_log_len);
473
474 panic_info->mph_other_log_len = 0;
475
476 panic_info->mph_panic_flags |= MACOS_PANIC_HEADER_FLAG_INCOHERENT_PANICLOG;
477 }
478 }
479
480 return;
481 }
482
483 vm_size_t
PE_init_socd_client(void)484 PE_init_socd_client(void)
485 {
486 /* not implemented */
487 return 0;
488 }
489
490 void
PE_write_socd_client_buffer(__unused vm_offset_t offset,__unused const void * buff,__unused vm_size_t size)491 PE_write_socd_client_buffer(__unused vm_offset_t offset, __unused const void *buff, __unused vm_size_t size)
492 {
493 /* not implemented */
494 }
495