Chameleon

Chameleon Svn Source Tree

Root/branches/ErmaC/Enoch/i386/libsaio/fake_efi.c

1
2/*
3 * Copyright 2007 David F. Elliott. All rights reserved.
4 */
5#include "saio_types.h"
6#include "libsaio.h"
7#include "boot.h"
8#include "bootstruct.h"
9#include "efi.h"
10#include "acpi.h"
11#include "fake_efi.h"
12#include "efi_tables.h"
13#include "platform.h"
14#include "acpi_patcher.h"
15#include "smbios.h"
16#include "device_inject.h"
17#include "convert.h"
18#include "pci.h"
19#include "sl.h"
20
21extern void setup_pci_devs(pci_dt_t *pci_dt);
22
23/*
24 * Modern Darwin kernels require some amount of EFI because Apple machines all
25 * have EFI. Modifying the kernel source to not require EFI is of course
26 * possible but would have to be maintained as a separate patch because it is
27 * unlikely that Apple wishes to add legacy support to their kernel.
28 *
29 * As you can see from the Apple-supplied code in bootstruct.c, it seems that
30 * the intention was clearly to modify this booter to provide EFI-like structures
31 * to the kernel rather than modifying the kernel to handle non-EFI stuff. This
32 * makes a lot of sense from an engineering point of view as it means the kernel
33 * for the as yet unreleased EFI-only Macs could still be booted by the non-EFI
34 * DTK systems so long as the kernel checked to ensure the boot tables were
35 * filled in appropriately.Modern xnu requires a system table and a runtime
36 * services table and performs no checks whatsoever to ensure the pointers to
37 * these tables are non-NULL. Therefore, any modern xnu kernel will page fault
38 * early on in the boot process if the system table pointer is zero.
39 *
40 * Even before that happens, the tsc_init function in modern xnu requires the FSB
41 * Frequency to be a property in the /efi/platform node of the device tree or else
42 * it panics the bootstrap process very early on.
43 *
44 * As of this writing, the current implementation found here is good enough
45 * to make the currently available xnu kernel boot without modification on a
46 * system with an appropriate processor. With a minor source modification to
47 * the tsc_init function to remove the explicit check for Core or Core 2
48 * processors the kernel can be made to boot on other processors so long as
49 * the code can be executed by the processor and the machine contains the
50 * necessary hardware.
51 */
52
53/*==========================================================================
54 * Utility function to make a device tree string from an EFI_GUID
55 */
56static inline char * mallocStringForGuid(EFI_GUID const *pGuid)
57{
58char *string = malloc(37);
59efi_guid_unparse_upper(pGuid, string);
60return string;
61}
62
63/*==========================================================================
64 * Function to map 32 bit physical address to 64 bit virtual address
65 */
66static uint64_t ptov64(uint32_t addr)
67{
68return ((uint64_t)addr | 0xFFFFFF8000000000ULL);
69}
70
71/*==========================================================================
72 * Fake EFI implementation
73 */
74
75/* Identify ourselves as the EFI firmware vendor */
76static EFI_CHAR16 const FIRMWARE_VENDOR[] = { 'E', 'n', 'o', 'c', 'h', '\0' };
77static EFI_UINT32 const FIRMWARE_REVISION = 132; /* FIXME: Find a constant for this. */
78
79// Bungo
80/* Default platform system_id (fix by IntVar)
81 static EFI_CHAR8 const SYSTEM_ID[] = "0123456789ABCDEF"; //random value gen by uuidgen
82 */
83
84/* Just a ret instruction */
85static uint8_t const VOIDRET_INSTRUCTIONS[] = {0xc3};
86
87/* movl $0x80000003,%eax; ret */
88static uint8_t const UNSUPPORTEDRET_INSTRUCTIONS_32[] = {0xb8, 0x03, 0x00, 0x00, 0x80, 0xc3};
89static uint8_t const UNSUPPORTEDRET_INSTRUCTIONS_64[] = {0x48, 0xb8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc3};
90
91EFI_SYSTEM_TABLE_32 *gST32 = NULL;
92EFI_SYSTEM_TABLE_64 *gST64 = NULL;
93Node *gEfiConfigurationTableNode = NULL;
94
95extern EFI_STATUS addConfigurationTable(EFI_GUID const *pGuid, void *table, char const *alias)
96{
97EFI_UINTN i = 0;
98
99//Azi: as is, cpu's with em64t will use EFI64 on pre 10.6 systems,
100// wich seems to cause no problem. In case it does, force i386 arch.
101if (archCpuType == CPU_TYPE_I386)
102{
103i = gST32->NumberOfTableEntries;
104}
105else
106{
107i = gST64->NumberOfTableEntries;
108}
109
110// We only do adds, not modifications and deletes like InstallConfigurationTable
111if (i >= MAX_CONFIGURATION_TABLE_ENTRIES)
112{
113stop("Ran out of space for configuration tables. Increase the reserved size in the code.\n");
114}
115
116if (pGuid == NULL)
117{
118return EFI_INVALID_PARAMETER;
119}
120
121if (table != NULL)
122{
123// FIXME
124//((EFI_CONFIGURATION_TABLE_64 *)gST->ConfigurationTable)[i].VendorGuid = *pGuid;
125//((EFI_CONFIGURATION_TABLE_64 *)gST->ConfigurationTable)[i].VendorTable = (EFI_PTR64)table;
126
127//++gST->NumberOfTableEntries;
128
129Node *tableNode = DT__AddChild(gEfiConfigurationTableNode, mallocStringForGuid(pGuid));
130
131// Use the pointer to the GUID we just stuffed into the system table
132DT__AddProperty(tableNode, "guid", sizeof(EFI_GUID), (void*)pGuid);
133
134// The "table" property is the 32-bit (in our implementation) physical address of the table
135DT__AddProperty(tableNode, "table", sizeof(void*) * 2, table);
136
137// Assume the alias pointer is a global or static piece of data
138if (alias != NULL)
139{
140DT__AddProperty(tableNode, "alias", strlen(alias)+1, (char*)alias);
141}
142
143return EFI_SUCCESS;
144}
145return EFI_UNSUPPORTED;
146}
147
148//Azi: crc32 done in place, on the cases were it wasn't.
149/*static inline void fixupEfiSystemTableCRC32(EFI_SYSTEM_TABLE_64 *efiSystemTable)
150{
151efiSystemTable->Hdr.CRC32 = 0;
152efiSystemTable->Hdr.CRC32 = crc32(0L, efiSystemTable, efiSystemTable->Hdr.HeaderSize);
153}*/
154
155/*
156 * What we do here is simply allocate a fake EFI system table and a fake EFI
157 * runtime services table.
158 *
159 * Because we build against modern headers with kBootArgsRevision 4 we
160 * also take care to set efiMode = 32.
161 */
162void setupEfiTables32(void)
163{
164// We use the fake_efi_pages struct so that we only need to do one kernel
165// memory allocation for all needed EFI data. Otherwise, small allocations
166// like the FIRMWARE_VENDOR string would take up an entire page.
167// NOTE WELL: Do NOT assume this struct has any particular layout within itself.
168// It is absolutely not intended to be publicly exposed anywhere
169// We say pages (plural) although right now we are well within the 1 page size
170// and probably will stay that way.
171struct fake_efi_pages
172{
173EFI_SYSTEM_TABLE_32 efiSystemTable;
174EFI_RUNTIME_SERVICES_32 efiRuntimeServices;
175EFI_CONFIGURATION_TABLE_32 efiConfigurationTable[MAX_CONFIGURATION_TABLE_ENTRIES];
176EFI_CHAR16 firmwareVendor[sizeof(FIRMWARE_VENDOR)/sizeof(EFI_CHAR16)];
177uint8_t voidret_instructions[sizeof(VOIDRET_INSTRUCTIONS)/sizeof(uint8_t)];
178uint8_t unsupportedret_instructions[sizeof(UNSUPPORTEDRET_INSTRUCTIONS_32)/sizeof(uint8_t)];
179};
180
181struct fake_efi_pages *fakeEfiPages = (struct fake_efi_pages*)AllocateKernelMemory(sizeof(struct fake_efi_pages));
182
183// Zero out all the tables in case fields are added later
184//bzero(fakeEfiPages, sizeof(struct fake_efi_pages));
185
186// --------------------------------------------------------------------
187// Initialize some machine code that will return EFI_UNSUPPORTED for
188// functions returning int and simply return for void functions.
189memcpy(fakeEfiPages->voidret_instructions, VOIDRET_INSTRUCTIONS, sizeof(VOIDRET_INSTRUCTIONS));
190memcpy(fakeEfiPages->unsupportedret_instructions, UNSUPPORTEDRET_INSTRUCTIONS_32, sizeof(UNSUPPORTEDRET_INSTRUCTIONS_32));
191
192// --------------------------------------------------------------------
193// System table
194EFI_SYSTEM_TABLE_32 *efiSystemTable = gST32 = &fakeEfiPages->efiSystemTable;
195efiSystemTable->Hdr.Signature = EFI_SYSTEM_TABLE_SIGNATURE;
196efiSystemTable->Hdr.Revision = EFI_SYSTEM_TABLE_REVISION;
197efiSystemTable->Hdr.HeaderSize = sizeof(EFI_SYSTEM_TABLE_32);
198efiSystemTable->Hdr.CRC32 = 0; // Initialize to zero and then do CRC32
199efiSystemTable->Hdr.Reserved = 0;
200
201efiSystemTable->FirmwareVendor = (EFI_PTR32)&fakeEfiPages->firmwareVendor;
202memcpy(fakeEfiPages->firmwareVendor, FIRMWARE_VENDOR, sizeof(FIRMWARE_VENDOR));
203efiSystemTable->FirmwareRevision = FIRMWARE_REVISION;
204
205// XXX: We may need to have basic implementations of ConIn/ConOut/StdErr
206// The EFI spec states that all handles are invalid after boot services have been
207// exited so we can probably get by with leaving the handles as zero.
208efiSystemTable->ConsoleInHandle = 0;
209efiSystemTable->ConIn = 0;
210
211efiSystemTable->ConsoleOutHandle = 0;
212efiSystemTable->ConOut = 0;
213
214efiSystemTable->StandardErrorHandle = 0;
215efiSystemTable->StdErr = 0;
216
217efiSystemTable->RuntimeServices = (EFI_PTR32)&fakeEfiPages->efiRuntimeServices;
218
219// According to the EFI spec, BootServices aren't valid after the
220// boot process is exited so we can probably do without it.
221// Apple didn't provide a definition for it in pexpert/i386/efi.h
222// so I'm guessing they don't use it.
223efiSystemTable->BootServices = 0;
224
225efiSystemTable->NumberOfTableEntries = 0;
226efiSystemTable->ConfigurationTable = (EFI_PTR32)fakeEfiPages->efiConfigurationTable;
227
228// We're done. Now CRC32 the thing so the kernel will accept it.
229// Must be initialized to zero before CRC32, done above.
230gST32->Hdr.CRC32 = crc32(0L, gST32, gST32->Hdr.HeaderSize);
231
232// --------------------------------------------------------------------
233// Runtime services
234EFI_RUNTIME_SERVICES_32 *efiRuntimeServices = &fakeEfiPages->efiRuntimeServices;
235efiRuntimeServices->Hdr.Signature = EFI_RUNTIME_SERVICES_SIGNATURE;
236efiRuntimeServices->Hdr.Revision = EFI_RUNTIME_SERVICES_REVISION;
237efiRuntimeServices->Hdr.HeaderSize = sizeof(EFI_RUNTIME_SERVICES_32);
238efiRuntimeServices->Hdr.CRC32 = 0;
239efiRuntimeServices->Hdr.Reserved = 0;
240
241// There are a number of function pointers in the efiRuntimeServices table.
242// These are the Foundation (e.g. core) services and are expected to be present on
243// all EFI-compliant machines.Some kernel extensions (notably AppleEFIRuntime)
244// will call these without checking to see if they are null.
245//
246// We don't really feel like doing an EFI implementation in the bootloader
247// but it is nice if we can at least prevent a complete crash by
248// at least providing some sort of implementation until one can be provided
249// nicely in a kext.
250void (*voidret_fp)() = (void*)fakeEfiPages->voidret_instructions;
251void (*unsupportedret_fp)() = (void*)fakeEfiPages->unsupportedret_instructions;
252efiRuntimeServices->GetTime = (EFI_PTR32)unsupportedret_fp;
253efiRuntimeServices->SetTime = (EFI_PTR32)unsupportedret_fp;
254efiRuntimeServices->GetWakeupTime = (EFI_PTR32)unsupportedret_fp;
255efiRuntimeServices->SetWakeupTime = (EFI_PTR32)unsupportedret_fp;
256efiRuntimeServices->SetVirtualAddressMap = (EFI_PTR32)unsupportedret_fp;
257efiRuntimeServices->ConvertPointer = (EFI_PTR32)unsupportedret_fp;
258efiRuntimeServices->GetVariable = (EFI_PTR32)unsupportedret_fp;
259efiRuntimeServices->GetNextVariableName = (EFI_PTR32)unsupportedret_fp;
260efiRuntimeServices->SetVariable = (EFI_PTR32)unsupportedret_fp;
261efiRuntimeServices->GetNextHighMonotonicCount = (EFI_PTR32)unsupportedret_fp;
262efiRuntimeServices->ResetSystem = (EFI_PTR32)voidret_fp;
263
264// We're done.Now CRC32 the thing so the kernel will accept it
265efiRuntimeServices->Hdr.CRC32 = crc32(0L, efiRuntimeServices, efiRuntimeServices->Hdr.HeaderSize);
266
267// --------------------------------------------------------------------
268// Finish filling in the rest of the boot args that we need.
269bootArgs->efiSystemTable = (uint32_t)efiSystemTable;
270bootArgs->efiMode = kBootArgsEfiMode32;
271
272// The bootArgs structure as a whole is bzero'd so we don't need to fill in
273// things like efiRuntimeServices* and what not.
274//
275// In fact, the only code that seems to use that is the hibernate code so it
276// knows not to save the pages. It even checks to make sure its nonzero.
277}
278
279void setupEfiTables64(void)
280{
281struct fake_efi_pages
282{
283EFI_SYSTEM_TABLE_64 efiSystemTable;
284EFI_RUNTIME_SERVICES_64 efiRuntimeServices;
285EFI_CONFIGURATION_TABLE_64 efiConfigurationTable[MAX_CONFIGURATION_TABLE_ENTRIES];
286EFI_CHAR16 firmwareVendor[sizeof(FIRMWARE_VENDOR)/sizeof(EFI_CHAR16)];
287uint8_t voidret_instructions[sizeof(VOIDRET_INSTRUCTIONS)/sizeof(uint8_t)];
288uint8_t unsupportedret_instructions[sizeof(UNSUPPORTEDRET_INSTRUCTIONS_64)/sizeof(uint8_t)];
289};
290
291struct fake_efi_pages *fakeEfiPages = (struct fake_efi_pages*)AllocateKernelMemory(sizeof(struct fake_efi_pages));
292
293// Zero out all the tables in case fields are added later
294//bzero(fakeEfiPages, sizeof(struct fake_efi_pages));
295
296// --------------------------------------------------------------------
297// Initialize some machine code that will return EFI_UNSUPPORTED for
298// functions returning int and simply return for void functions.
299memcpy(fakeEfiPages->voidret_instructions, VOIDRET_INSTRUCTIONS, sizeof(VOIDRET_INSTRUCTIONS));
300memcpy(fakeEfiPages->unsupportedret_instructions, UNSUPPORTEDRET_INSTRUCTIONS_64, sizeof(UNSUPPORTEDRET_INSTRUCTIONS_64));
301
302// --------------------------------------------------------------------
303// System table
304EFI_SYSTEM_TABLE_64 *efiSystemTable = gST64 = &fakeEfiPages->efiSystemTable;
305efiSystemTable->Hdr.Signature = EFI_SYSTEM_TABLE_SIGNATURE;
306efiSystemTable->Hdr.Revision = EFI_SYSTEM_TABLE_REVISION;
307efiSystemTable->Hdr.HeaderSize = sizeof(EFI_SYSTEM_TABLE_64);
308efiSystemTable->Hdr.CRC32 = 0; // Initialize to zero and then do CRC32
309efiSystemTable->Hdr.Reserved = 0;
310
311efiSystemTable->FirmwareVendor = ptov64((EFI_PTR32)&fakeEfiPages->firmwareVendor);
312memcpy(fakeEfiPages->firmwareVendor, FIRMWARE_VENDOR, sizeof(FIRMWARE_VENDOR));
313efiSystemTable->FirmwareRevision = FIRMWARE_REVISION;
314
315// XXX: We may need to have basic implementations of ConIn/ConOut/StdErr
316// The EFI spec states that all handles are invalid after boot services have been
317// exited so we can probably get by with leaving the handles as zero.
318efiSystemTable->ConsoleInHandle = 0;
319efiSystemTable->ConIn = 0;
320
321efiSystemTable->ConsoleOutHandle = 0;
322efiSystemTable->ConOut = 0;
323
324efiSystemTable->StandardErrorHandle = 0;
325efiSystemTable->StdErr = 0;
326
327efiSystemTable->RuntimeServices = ptov64((EFI_PTR32)&fakeEfiPages->efiRuntimeServices);
328// According to the EFI spec, BootServices aren't valid after the
329// boot process is exited so we can probably do without it.
330// Apple didn't provide a definition for it in pexpert/i386/efi.h
331// so I'm guessing they don't use it.
332efiSystemTable->BootServices = 0;
333
334efiSystemTable->NumberOfTableEntries = 0;
335efiSystemTable->ConfigurationTable = ptov64((EFI_PTR32)fakeEfiPages->efiConfigurationTable);
336
337// We're done.Now CRC32 the thing so the kernel will accept it
338gST64->Hdr.CRC32 = crc32(0L, gST64, gST64->Hdr.HeaderSize);
339
340// --------------------------------------------------------------------
341// Runtime services
342EFI_RUNTIME_SERVICES_64 *efiRuntimeServices = &fakeEfiPages->efiRuntimeServices;
343efiRuntimeServices->Hdr.Signature = EFI_RUNTIME_SERVICES_SIGNATURE;
344efiRuntimeServices->Hdr.Revision = EFI_RUNTIME_SERVICES_REVISION;
345efiRuntimeServices->Hdr.HeaderSize = sizeof(EFI_RUNTIME_SERVICES_64);
346efiRuntimeServices->Hdr.CRC32 = 0;
347efiRuntimeServices->Hdr.Reserved = 0;
348
349// There are a number of function pointers in the efiRuntimeServices table.
350// These are the Foundation (e.g. core) services and are expected to be present on
351// all EFI-compliant machines.Some kernel extensions (notably AppleEFIRuntime)
352// will call these without checking to see if they are null.
353//
354// We don't really feel like doing an EFI implementation in the bootloader
355// but it is nice if we can at least prevent a complete crash by
356// at least providing some sort of implementation until one can be provided
357// nicely in a kext.
358
359void (*voidret_fp)() = (void*)fakeEfiPages->voidret_instructions;
360void (*unsupportedret_fp)() = (void*)fakeEfiPages->unsupportedret_instructions;
361efiRuntimeServices->GetTime = ptov64((EFI_PTR32)unsupportedret_fp);
362efiRuntimeServices->SetTime = ptov64((EFI_PTR32)unsupportedret_fp);
363efiRuntimeServices->GetWakeupTime = ptov64((EFI_PTR32)unsupportedret_fp);
364efiRuntimeServices->SetWakeupTime = ptov64((EFI_PTR32)unsupportedret_fp);
365efiRuntimeServices->SetVirtualAddressMap = ptov64((EFI_PTR32)unsupportedret_fp);
366efiRuntimeServices->ConvertPointer = ptov64((EFI_PTR32)unsupportedret_fp);
367efiRuntimeServices->GetVariable = ptov64((EFI_PTR32)unsupportedret_fp);
368efiRuntimeServices->GetNextVariableName = ptov64((EFI_PTR32)unsupportedret_fp);
369efiRuntimeServices->SetVariable = ptov64((EFI_PTR32)unsupportedret_fp);
370efiRuntimeServices->GetNextHighMonotonicCount = ptov64((EFI_PTR32)unsupportedret_fp);
371efiRuntimeServices->ResetSystem = ptov64((EFI_PTR32)voidret_fp);
372
373// We're done.Now CRC32 the thing so the kernel will accept it
374efiRuntimeServices->Hdr.CRC32 = crc32(0L, efiRuntimeServices, efiRuntimeServices->Hdr.HeaderSize);
375
376// --------------------------------------------------------------------
377// Finish filling in the rest of the boot args that we need.
378bootArgs->efiSystemTable = (uint32_t)efiSystemTable;
379bootArgs->efiMode = kBootArgsEfiMode64;
380
381// The bootArgs structure as a whole is bzero'd so we don't need to fill in
382// things like efiRuntimeServices* and what not.
383//
384// In fact, the only code that seems to use that is the hibernate code so it
385// knows not to save the pages. It even checks to make sure its nonzero.
386}
387
388/*
389 * In addition to the EFI tables there is also the EFI device tree node.
390 * In particular, we need /efi/platform to have an FSBFrequency key. Without it,
391 * the tsc_init function will panic very early on in kernel startup, before
392 * the console is available.
393 */
394
395/*==========================================================================
396 * FSB Frequency detection
397 */
398
399/* These should be const but DT__AddProperty takes char* */
400static const char TSC_Frequency_prop[] = "TSCFrequency";
401static const char FSB_Frequency_prop[] = "FSBFrequency";
402static const char CPU_Frequency_prop[] = "CPUFrequency";
403
404/*==========================================================================
405 * SMBIOS
406 */
407
408/* From Foundation/Efi/Guid/Smbios/SmBios.c */
409EFI_GUID constgEfiSmbiosTableGuid = EFI_SMBIOS_TABLE_GUID;
410
411#define SMBIOS_RANGE_START0x000F0000
412#define SMBIOS_RANGE_END0x000FFFFF
413
414/* '_SM_' in little endian: */
415#define SMBIOS_ANCHOR_UINT32_LE 0x5f4d535f
416
417#define EFI_ACPI_TABLE_GUID \
418{ \
4190xeb9d2d30, 0x2d88, 0x11d3, { 0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
420}
421
422#define EFI_ACPI_20_TABLE_GUID \
423{ \
4240x8868e871, 0xe4f1, 0x11d3, { 0xbc, 0x22, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
425}
426
427EFI_GUID gEfiAcpiTableGuid = EFI_ACPI_TABLE_GUID;
428EFI_GUID gEfiAcpi20TableGuid = EFI_ACPI_20_TABLE_GUID;
429
430
431/*==========================================================================
432 * Fake EFI implementation
433 */
434
435/* These should be const but DT__AddProperty takes char* */
436static const char FIRMWARE_REVISION_PROP[] = "firmware-revision";
437static const char FIRMWARE_ABI_PROP[] = "firmware-abi";
438static const char FIRMWARE_VENDOR_PROP[] = "firmware-vendor";
439static const char FIRMWARE_ABI_32_PROP_VALUE[] = "EFI32";
440static const char FIRMWARE_ABI_64_PROP_VALUE[] = "EFI64";
441static const char SYSTEM_ID_PROP[] = "system-id";
442static const char SYSTEM_SERIAL_PROP[] = "SystemSerialNumber";
443static const char SYSTEM_TYPE_PROP[] = "system-type";
444static const char MODEL_PROP[] = "Model";
445static const char BOARDID_PROP[] = "board-id";
446
447/*
448 * Get an smbios option string option to convert to EFI_CHAR16 string
449 */
450static EFI_CHAR16* getSmbiosChar16(const char * key, size_t* len)
451{
452const char*src = getStringForKey(key, &bootInfo->smbiosConfig);
453EFI_CHAR16* dst = 0;
454size_t i = 0;
455
456if (!key || !(*key) || !len || !src)
457{
458return 0;
459}
460
461*len = strlen(src);
462dst = (EFI_CHAR16*) malloc( ((*len)+1) * 2 );
463for (; i < (*len); i++)
464{
465dst[i] = src[i];
466}
467dst[(*len)] = '\0';
468*len = ((*len)+1)*2; // return the CHAR16 bufsize including zero terminated CHAR16
469return dst;
470}
471
472// Bungo
473/*
474 * Get the SystemID from the bios dmi info
475
476staticEFI_CHAR8* getSmbiosUUID()
477{
478static EFI_CHAR8 uuid[UUID_LEN];
479int i, isZero, isOnes;
480SMBByte*p;
481
482p = (SMBByte*)Platform.UUID;
483
484for (i=0, isZero=1, isOnes=1; i<UUID_LEN; i++)
485{
486if (p[i] != 0x00)
487{
488isZero = 0;
489}
490
491if (p[i] != 0xff)
492{
493isOnes = 0;
494}
495}
496
497if (isZero || isOnes) // empty or setable means: no uuid present
498{
499verbose("No UUID present in SMBIOS System Information Table\n");
500return 0;
501}
502
503memcpy(uuid, p, UUID_LEN);
504return uuid;
505}
506
507
508// return a binary UUID value from the overriden SystemID and SMUUID if found,
509// or from the bios if not, or from a fixed value if no bios value is found
510
511static EFI_CHAR8* getSystemID()
512{
513// unable to determine UUID for host. Error: 35 fix
514// Rek: new SMsystemid option conforming to smbios notation standards, this option should
515// belong to smbios config only ...
516const char *sysId = getStringForKey(kSystemID, &bootInfo->chameleonConfig);
517EFI_CHAR8*ret = getUUIDFromString(sysId);
518
519if (!sysId || !ret) // try bios dmi info UUID extraction
520{
521ret = getSmbiosUUID();
522sysId = 0;
523}
524
525if (!ret)
526{
527// no bios dmi UUID available, set a fixed value for system-id
528ret=getUUIDFromString((sysId = (const char*) SYSTEM_ID));
529}
530verbose("Customizing SystemID with : %s\n", getStringFromUUID(ret)); // apply a nice formatting to the displayed output
531return ret;
532}
533 */
534
535/*
536 * Must be called AFTER setup Acpi because we need to take care of correct
537 * facp content to reflect in ioregs
538 */
539void setupSystemType()
540{
541Node *node = DT__FindNode("/", false);
542if (node == 0)
543{
544stop("Couldn't get root node");
545}
546// we need to write this property after facp parsing
547// Export system-type only if it has been overrriden by the SystemType option
548DT__AddProperty(node, SYSTEM_TYPE_PROP, sizeof(Platform.Type), &Platform.Type);
549}
550
551void setupEfiDeviceTree(void)
552{
553// EFI_CHAR8* ret = 0; Bungo: not used
554EFI_CHAR16* ret16 = 0;
555size_t len = 0;
556Node*node;
557
558node = DT__FindNode("/", false);
559
560if (node == 0)
561{
562stop("Couldn't get root node");
563}
564
565// We could also just do DT__FindNode("/efi/platform", true)
566// But I think eventually we want to fill stuff in the efi node
567// too so we might as well create it so we have a pointer for it too.
568node = DT__AddChild(node, "efi");
569
570if (archCpuType == CPU_TYPE_I386)
571{
572DT__AddProperty(node, FIRMWARE_ABI_PROP, sizeof(FIRMWARE_ABI_32_PROP_VALUE), (char*)FIRMWARE_ABI_32_PROP_VALUE);
573}
574else
575{
576DT__AddProperty(node, FIRMWARE_ABI_PROP, sizeof(FIRMWARE_ABI_64_PROP_VALUE), (char*)FIRMWARE_ABI_64_PROP_VALUE);
577}
578
579DT__AddProperty(node, FIRMWARE_REVISION_PROP, sizeof(FIRMWARE_REVISION), (EFI_UINT32*)&FIRMWARE_REVISION);
580DT__AddProperty(node, FIRMWARE_VENDOR_PROP, sizeof(FIRMWARE_VENDOR), (EFI_CHAR16*)FIRMWARE_VENDOR);
581
582// TODO: Fill in other efi properties if necessary
583
584// Set up the /efi/runtime-services table node similar to the way a child node of configuration-table
585// is set up. That is, name and table properties
586Node *runtimeServicesNode = DT__AddChild(node, "runtime-services");
587
588if (archCpuType == CPU_TYPE_I386)
589{
590// The value of the table property is the 32-bit physical address for the RuntimeServices table.
591// Since the EFI system table already has a pointer to it, we simply use the address of that pointer
592// for the pointer to the property data. Warning.. DT finalization calls free on that but we're not
593// the only thing to use a non-malloc'd pointer for something in the DT
594
595DT__AddProperty(runtimeServicesNode, "table", sizeof(uint64_t), &gST32->RuntimeServices);
596}
597else
598{
599DT__AddProperty(runtimeServicesNode, "table", sizeof(uint64_t), &gST64->RuntimeServices);
600}
601
602// Set up the /efi/configuration-table node which will eventually have several child nodes for
603// all of the configuration tables needed by various kernel extensions.
604gEfiConfigurationTableNode = DT__AddChild(node, "configuration-table");
605
606// Now fill in the /efi/platform Node
607Node *efiPlatformNode = DT__AddChild(node, "platform");
608
609// NOTE WELL: If you do add FSB Frequency detection, make sure to store
610// the value in the fsbFrequency global and not an malloc'd pointer
611// because the DT_AddProperty function does not copy its args.
612
613if (Platform.CPU.FSBFrequency != 0)
614{
615DT__AddProperty(efiPlatformNode, FSB_Frequency_prop, sizeof(uint64_t), &Platform.CPU.FSBFrequency);
616}
617
618// Export TSC and CPU frequencies for use by the kernel or KEXTs
619if (Platform.CPU.TSCFrequency != 0)
620{
621DT__AddProperty(efiPlatformNode, TSC_Frequency_prop, sizeof(uint64_t), &Platform.CPU.TSCFrequency);
622}
623
624if (Platform.CPU.CPUFrequency != 0)
625{
626DT__AddProperty(efiPlatformNode, CPU_Frequency_prop, sizeof(uint64_t), &Platform.CPU.CPUFrequency);
627}
628
629// Bungo
630/* Export system-id. Can be disabled with SystemId=No in com.apple.Boot.plist
631if ((ret=getSystemID()))
632{
633DT__AddProperty(efiPlatformNode, SYSTEM_ID_PROP, UUID_LEN, (EFI_UINT32*) ret);
634}
635*/
636DT__AddProperty(efiPlatformNode, SYSTEM_ID_PROP, UUID_LEN, Platform.UUID);
637//
638
639// Export SystemSerialNumber if present
640if ((ret16=getSmbiosChar16("SMserial", &len)))
641{
642DT__AddProperty(efiPlatformNode, SYSTEM_SERIAL_PROP, len, ret16);
643}
644
645// Export Model if present
646if ((ret16=getSmbiosChar16("SMproductname", &len)))
647{
648DT__AddProperty(efiPlatformNode, MODEL_PROP, len, ret16);
649}
650
651// Fill /efi/device-properties node.
652setupDeviceProperties(node);
653}
654
655/*
656 * Must be called AFTER getSmbios
657 */
658void setupBoardId()
659{
660Node *node;
661node = DT__FindNode("/", false);
662if (node == 0)
663{
664stop("Couldn't get root node");
665}
666const char *boardid = getStringForKey("SMboardproduct", &bootInfo->smbiosConfig);
667if (boardid)
668{
669DT__AddProperty(node, BOARDID_PROP, strlen(boardid)+1, (EFI_CHAR16*)boardid);
670}
671}
672
673/*
674 * Populate the chosen node
675 */
676
677void setupChosenNode()
678{
679Node *chosenNode;
680chosenNode = DT__FindNode("/chosen", false);
681if (chosenNode == 0)
682{
683stop("Couldn't get chosen node");
684}
685
686int bootUUIDLength = strlen(gBootUUIDString);
687if (bootUUIDLength)
688{
689DT__AddProperty(chosenNode, "boot-uuid", bootUUIDLength + 1, gBootUUIDString);
690}
691}
692
693/*
694 * Load the smbios.plist override config file if any
695 */
696static void setupSmbiosConfigFile(const char *filename)
697{
698chardirSpecSMBIOS[128];
699const char*override_pathname = NULL;
700intlen = 0, err = 0;
701extern void scan_mem();
702
703// Take in account user overriding
704if (getValueForKey(kSMBIOSKey, &override_pathname, &len, &bootInfo->chameleonConfig) && len > 0)
705{
706// Specify a path to a file, e.g. SMBIOS=/Extra/macProXY.plist
707sprintf(dirSpecSMBIOS, override_pathname);
708err = loadConfigFile(dirSpecSMBIOS, &bootInfo->smbiosConfig);
709}
710else
711{
712// Check selected volume's Extra.
713sprintf(dirSpecSMBIOS, "/Extra/%s", filename);
714if ( (err = loadConfigFile(dirSpecSMBIOS, &bootInfo->smbiosConfig)) )
715{
716// Check booter volume/rdbt Extra.
717sprintf(dirSpecSMBIOS, "bt(0,0)/Extra/%s", filename);
718err = loadConfigFile(dirSpecSMBIOS, &bootInfo->smbiosConfig);
719}
720}
721
722if (err)
723{
724verbose("No SMBIOS replacement found.\n");
725}
726
727// get a chance to scan mem dynamically if user asks for it while having the config options
728// loaded as well, as opposed to when it was in scan_platform(); also load the orig. smbios
729// so that we can access dmi info, without patching the smbios yet.
730scan_mem();
731}
732
733/*
734 * Installs all the needed configuration table entries
735 */
736static void setupEfiConfigurationTable()
737{
738smbios_p = (EFI_PTR32)getSmbios(SMBIOS_PATCHED);
739addConfigurationTable(&gEfiSmbiosTableGuid, &smbios_p, NULL);
740
741setupBoardId(); //need to be called after getSmbios
742
743// Setup ACPI with DSDT overrides (mackerintel's patch)
744setupAcpi();
745
746// We've obviously changed the count.. so fix up the CRC32
747if (archCpuType == CPU_TYPE_I386)
748{
749gST32->Hdr.CRC32 = 0;
750gST32->Hdr.CRC32 = crc32(0L, gST32, gST32->Hdr.HeaderSize);
751}
752else
753{
754gST64->Hdr.CRC32 = 0;
755gST64->Hdr.CRC32 = crc32(0L, gST64, gST64->Hdr.HeaderSize);
756}
757
758// Setup the chosen node
759setupChosenNode();
760}
761
762void saveOriginalSMBIOS(void)
763{
764Node *node;
765SMBEntryPoint *origeps;
766void *tableAddress;
767
768node = DT__FindNode("/efi/platform", false);
769if (!node)
770{
771verbose("/efi/platform node not found\n");
772return;
773}
774
775origeps = getSmbios(SMBIOS_ORIGINAL);
776if (!origeps)
777{
778return;
779}
780
781tableAddress = (void *)AllocateKernelMemory(origeps->dmi.tableLength);
782if (!tableAddress)
783{
784return;
785}
786
787memcpy(tableAddress, (void *)origeps->dmi.tableAddress, origeps->dmi.tableLength);
788DT__AddProperty(node, "SMBIOS-ORIG", origeps->dmi.tableLength, tableAddress); // Bungo: changed from SMBIOS to SMBIOS-ORIG to differentiate
789}
790
791/*
792 * Entrypoint from boot.c
793 */
794void setupFakeEfi(void)
795{
796// Generate efi device strings
797setup_pci_devs(root_pci_dev);
798
799readSMBIOSInfo(getSmbios(SMBIOS_ORIGINAL));
800
801// load smbios.plist file if any
802setupSmbiosConfigFile("smbios.plist");
803
804setupSMBIOSTable();
805
806// Initialize the base table
807if (archCpuType == CPU_TYPE_I386)
808{
809setupEfiTables32();
810}
811else
812{
813setupEfiTables64();
814}
815
816// Initialize the device tree
817setupEfiDeviceTree();
818
819saveOriginalSMBIOS();
820
821// Add configuration table entries to both the services table and the device tree
822setupEfiConfigurationTable();
823}
824

Archive Download this file

Revision: 2323