Upstream/CloverBootloader
1
0
Fork 0
mirror of https://github.com/CloverHackyColor/CloverBootloader.git synced 2024-11-30 12:43:41 +01:00
Code Issues Packages Projects Releases Wiki Activity
d139fa4536
CloverBootloader/CloverPackage/utils/clover-genconfig/clover-genconfig.c
Sergey Isakov 7c0aa811ec initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 
Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 12:58:42 +03:00

901 lines
38 KiB
C
Raw Blame History

/*
This is secret service for Clover to obtain temporary setting that user made in Options menu.
It will work with Clover rev 1680+.
It will not work for other bootloaders.
(c) Slice 2013
Code portion from Apple's project nvram
*/
/*
* Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* The contents of this file constitute Original Code as defined in and
* are subject to the Apple Public Source License Version 1.1 (the
* "License"). You may not use this file except in compliance with the
* License. Please obtain a copy of the License at
* http://www.apple.com/publicsource and read it before using this file.
*
* This Original Code and all software distributed under the License are
* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
* License for the specific language governing rights and limitations
* under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
/*
cc -o genconfig clover-genconfig.c gfxutil.c -framework CoreFoundation -framework IOKit -Wall -Wno-unused-function
*/
// EDK2 includes
//#include <base.h>
#define __DEBUG_LIB_H__
#define _STRUCT_X86_THREAD_STATE32
#define _STRUCT_X86_THREAD_STATE64
#include "../../../rEFIt_UEFI/Platform/Platform.h"
#include <IOKit/IOKitLib.h>
#include <CoreFoundation/CoreFoundation.h>
#include <err.h>
#include <mach/mach_error.h>
#define GFX 1
#if GFX
#include "gfxutil.h"
#endif
/* from efidevp.c */
extern CHAR8 *ConvertDevicePathToAscii (const struct _EFI_DEVICE_PATH_P_TAG *DeviceNode, BOOLEAN DisplayOnly, BOOLEAN AllowShortcuts);
/*
#define offsetof(st, m) \
((UINTN) ( (UINT8 *)&((st *)(0))->m - (UINT8 *)0 ))
*/
// Prototypes
//static kern_return_t GetOFVariable(const char *name, CFTypeRef *valueRef);
// Global Variables
static io_registry_entry_t gEFI;
static io_registry_entry_t gPlatform;
static mach_port_t masterPort;
#if 0
static CFMutableDictionaryRef patchDict[100];
#endif
CFMutableDictionaryRef addDict(CFMutableDictionaryRef dest, CFStringRef key)
{
assert(dest);
CFMutableDictionaryRef dict = CFDictionaryCreateMutable (
kCFAllocatorDefault,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks
);
if (!dict)
errx(1,"Error can't allocate dictionnary for key '%s'",
CFStringGetCStringPtr( key, kCFStringEncodingMacRoman ));
CFDictionaryAddValue( dest, key, dict );
return dict;
}
CFMutableArrayRef addArray(CFMutableDictionaryRef dest, CFStringRef key)
{
assert(dest);
CFMutableArrayRef array = CFArrayCreateMutable (
kCFAllocatorDefault,
0,
&kCFTypeArrayCallBacks
);
if (!array) {
errx(1,"Error can't allocate array for key '%s'",
CFStringGetCStringPtr( key, kCFStringEncodingMacRoman ));
}
CFDictionaryAddValue(dest, key, array );
return array;
}
CFMutableDictionaryRef addDictToArray(CFMutableArrayRef dest)
{
assert(dest);
CFMutableDictionaryRef dict = CFDictionaryCreateMutable (
kCFAllocatorDefault,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks
);
if (!dict) {
errx(1,"Error can't allocate dictionnary for array");
}
CFArrayAppendValue(dest, dict);
return dict;
}
void addStringToArray(CFMutableArrayRef dest, const char* value)
{
assert(dest);
CFStringRef strValue = CFStringCreateWithCString(kCFAllocatorDefault,
value,
kCFStringEncodingMacRoman);
assert(strValue);
CFArrayAppendValue(dest, strValue);
CFRelease(strValue);
}
void addString(CFMutableDictionaryRef dest, CFStringRef key, const char* value)
{
assert(dest);
CFStringRef strValue = CFStringCreateWithCString(kCFAllocatorDefault,
value,
kCFStringEncodingMacRoman);
assert(strValue);
CFDictionaryAddValue( dest, key, strValue );
CFRelease(strValue);
}
void addUString(CFMutableDictionaryRef dest, CFStringRef key, const UniChar* value)
{
if (!value) {
return;
}
assert(dest);
CFStringRef strValue = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%S"), value);
assert(strValue);
CFDictionaryAddValue( dest, key, strValue );
CFRelease(strValue);
}
void addHex(CFMutableDictionaryRef dest, CFStringRef key, UInt64 value)
{
CFStringRef strValue = NULL;
assert(dest);
if (value > 0xFFFF) {
strValue = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("0x%08llx"), value);
} else {
strValue = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("0x%04llx"), value);
}
assert(strValue);
CFDictionaryAddValue( dest, key, strValue );
CFRelease(strValue);
}
void addBoolean(CFMutableDictionaryRef dest, CFStringRef key, Boolean value) {
assert(dest);
CFBooleanRef boolValue = value ? kCFBooleanTrue : kCFBooleanFalse;
CFDictionaryAddValue( dest, key, boolValue );
}
void addInteger(CFMutableDictionaryRef dest, CFStringRef key, UInt64 value) {
assert(dest);
CFNumberRef valueRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &value);
assert(valueRef);
CFDictionaryAddValue( dest, key, valueRef );
CFRelease(valueRef);
}
void addUUID(CFMutableDictionaryRef dest, CFStringRef key, UInt8 *uuid)
{
SInt64 i = 0;
CFMutableStringRef strValue = CFStringCreateMutable (kCFAllocatorDefault, 0);
for (i = 0; i < 4; i++) {
CFStringAppendFormat(strValue, NULL, CFSTR("%02x"), *uuid++);
}
for (i = 0; i < 3; i++) {
CFStringAppendFormat(strValue, NULL, CFSTR("-%02x"), *uuid++);
CFStringAppendFormat(strValue, NULL, CFSTR("%02x"), *uuid++);
}
CFStringAppendFormat(strValue, NULL, CFSTR("-"));
for (i = 0; i < 6; i++) {
CFStringAppendFormat(strValue, NULL, CFSTR("%02x"), *uuid++);
}
CFDictionaryAddValue( dest, key, strValue );
CFRelease(strValue);
}
void addIntArray(CFMutableDictionaryRef dest, CFStringRef key, UInt8 *Value, SInt64 num)
{
SInt64 i = 0;
CFMutableStringRef strValue = CFStringCreateMutable (kCFAllocatorDefault, 0);
for (i = 0; i < num; i++) {
CFStringAppendFormat(strValue, NULL, CFSTR("%02x"), Value[i]);
}
CFDictionaryAddValue( dest, key, strValue );
CFRelease(strValue);
}
void dump_plist(CFMutableDictionaryRef properties) {
CFWriteStreamRef stdoutStream = NULL;
CFURLRef devStdout = CFURLCreateWithFileSystemPath(
NULL,
CFSTR("/dev/stdout"),
kCFURLPOSIXPathStyle,
false
);
stdoutStream = CFWriteStreamCreateWithFile(NULL, devStdout);
CFRelease(devStdout);
if (stdoutStream == NULL)
errx(1,"cannot create CFWriteStream for /dev/stdout");
if (!CFWriteStreamOpen(stdoutStream))
errx(1,"cannot open CFWriteStream for /dev/stdout");
CFPropertyListWrite(
properties,
stdoutStream,
kCFPropertyListXMLFormat_v1_0,
0,
NULL
);
CFWriteStreamClose(stdoutStream);
CFRelease(stdoutStream);
}
// GetOFVariable(name, valueRef)
//
// Get the named firmware variable.
// Return the value in valueRef.
//
static kern_return_t GetOFVariable(io_registry_entry_t entry, const char *name, CFTypeRef *valueRef)
{
CFStringRef nameRef = CFStringCreateWithCString(kCFAllocatorDefault, name,
kCFStringEncodingUTF8);
if (!nameRef) {
errx(1, "Error creating CFString for key %s", name);
}
*valueRef = IORegistryEntryCreateCFProperty(entry, nameRef, 0, 0);
CFRelease(nameRef);
if (!*valueRef) {
printf("value not found\n");
return kIOReturnNotFound;
}
return KERN_SUCCESS;
}
void addGFXDictionary(CFMutableDictionaryRef dict, GFX_HEADER * gfx)
{
CFMutableDictionaryRef items;
CFDataRef data = NULL;
//CFNumberRef number = NULL;
CFStringRef string = NULL;
CFStringRef key = NULL;
GFX_BLOCKHEADER *gfx_blockheader_tmp;
GFX_ENTRY *gfx_entry_tmp;
// uint64_t bigint;
// char hexstr[32];
char *dpath;
// Create dictionary that will hold gfx data
// dict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0 ,&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
gfx_blockheader_tmp = gfx->blocks;
while(gfx_blockheader_tmp)
{
items = CFDictionaryCreateMutable(kCFAllocatorDefault, 0 ,&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
gfx_entry_tmp = gfx_blockheader_tmp->entries;
while(gfx_entry_tmp)
{
key = CFStringCreateWithCString(kCFAllocatorDefault, gfx_entry_tmp->key, kCFStringEncodingUTF8);
switch(gfx_entry_tmp->val_type)
{
case DATA_STRING:
string = CFStringCreateWithBytes(kCFAllocatorDefault,gfx_entry_tmp->val, gfx_entry_tmp->val_len-1, kCFStringEncodingASCII, false);
CFDictionarySetValue(items, key, string);
CFRelease(string);
CFRelease(key);
break;
/*
case DATA_INT8:
bigint = READ_UINT8(gfx_entry_tmp->val);
sprintf(hexstr,"0x%02llx",bigint);
string = CFStringCreateWithCString(kCFAllocatorDefault,hexstr, kCFStringEncodingASCII);
CFDictionarySetValue(items, key, string);
CFRelease(string);
CFRelease(key);
break;
case DATA_INT16:
bigint = READ_UINT16(gfx_entry_tmp->val);
sprintf(hexstr,"0x%04llx",bigint);
string = CFStringCreateWithCString(kCFAllocatorDefault,hexstr, kCFStringEncodingASCII);
CFDictionarySetValue(items, key, string);
CFRelease(string);
CFRelease(key);
break;
case DATA_INT32:
bigint = READ_UINT32(gfx_entry_tmp->val);
sprintf(hexstr,"0x%08llx",bigint);
string = CFStringCreateWithCString(kCFAllocatorDefault,hexstr, kCFStringEncodingASCII);
CFDictionarySetValue(items, key, string);
CFRelease(string);
CFRelease(key);
break;
*/
default:
case DATA_BINARY:
data = CFDataCreate(kCFAllocatorDefault,gfx_entry_tmp->val, gfx_entry_tmp->val_len);
CFDictionarySetValue(items, key, data);
CFRelease(data);
CFRelease(key);
break;
}
gfx_entry_tmp = gfx_entry_tmp->next;
}
dpath = ConvertDevicePathToAscii (gfx_blockheader_tmp->devpath, 1, 1);
if(dpath != NULL)
{
key = CFStringCreateWithCString(kCFAllocatorDefault, dpath, kCFStringEncodingUTF8);
}
else
{
printf("CreateGFXDictionary: error converting device path to text shorthand notation\n");
return;
}
CFDictionarySetValue(dict, key, items);
free(dpath);
CFRelease(key);
CFRelease(items);
gfx_blockheader_tmp = gfx_blockheader_tmp->next;
}
return;
}
void PrintConfig(CFTypeRef data, GFX_HEADER * gfx)
{
const Byte *dataPtr = NULL;
CFIndex length = 0;
CFTypeID typeID;
// int i;
// Get the OF variable's type.
typeID = CFGetTypeID(data);
if (typeID == CFDataGetTypeID()) {
length = CFDataGetLength(data);
if (length == 0)
return;
else
dataPtr = CFDataGetBytePtr(data);
} else {
printf("<INVALID> settings\n");
return;
}
if (length != sizeof(SETTINGS_DATA)) {
// errx(1, "Error the version of clover-genconfig didn't match current booted clover version");
printf("Error the version of clover-genconfig didn't match current booted clover version\n");
printf("len=%d sizeof=%d\n", (int)length, (int)sizeof(SETTINGS_DATA));
#if defined(MDE_CPU_IA32)
printf("32 bit generator\n");
#elif defined(MDE_CPU_X64)
printf("64 bit generator\n");
#else
printf("xxx bit generator\n");
#endif
return;
}
SETTINGS_DATA *s = (SETTINGS_DATA*)dataPtr;
CFMutableDictionaryRef dict = CFDictionaryCreateMutable (
kCFAllocatorDefault,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks
);
/*
if (s->ConfigName != NULL) {
//ConfigName allocated in boot memory, impossible to show
// addUString(dict, CFSTR("ConfigName"), (const UniChar *)&s->ConfigName);
addString(dict, CFSTR("ConfigName"), "config1");
} else {
addString(dict, CFSTR("ConfigName"), "config");
}
*/
//This is possible since Clover 4511
addUString(dict, CFSTR("ConfigName"), (const UniChar *)&s->ConfigName);
//Boot
CFMutableDictionaryRef bootDict = addDict(dict, CFSTR("Boot"));
addString(bootDict, CFSTR("Arguments"), s->BootArgs);
addUString(bootDict, CFSTR("Legacy"), (const UniChar *)&s->LegacyBoot);
// addUString(bootDict, CFSTR("LegacyEntry"), s->LegacyBiosCustomEntry);
addInteger(bootDict, CFSTR("XMPDetection"), s->XMPDetection);
//impossible
// addUString(bootDict, CFSTR("DefaultVolume"), (const UniChar *)&s->DefaultVolume);
// addUString(bootDict, CFSTR("DefaultLoader"), (const UniChar *)&s->DefaultLoader);
addBoolean(bootDict, CFSTR("Debug"), s->Debug);
addString(bootDict, CFSTR("#Timeout"), "_NOT_SHOWN_");
addBoolean(bootDict, CFSTR("Fast"), 0);
addString(bootDict, CFSTR("#CustomLogo"), "_NOT_SHOWN_");
addBoolean(bootDict, CFSTR("#NeverHibernate"), 0);
addBoolean(bootDict, CFSTR("#StrictHibernate"), 0);
addBoolean(bootDict, CFSTR("RtcHibernateAware"), 0);
addBoolean(bootDict, CFSTR("NeverDoRecovery"), s->NeverDoRecovery);
addBoolean(bootDict, CFSTR("SkipHibernateTimeout"), s->SkipHibernateTimeout);
addBoolean(bootDict, CFSTR("DisableCloverHotkeys"), s->DisableCloverHotkeys);
addInteger(bootDict, CFSTR("#LegacyBiosDefaultEntry"), s->LegacyBiosDefaultEntry);
// SystemParameters
CFMutableDictionaryRef systemParametersDict = addDict(dict, CFSTR("SystemParameters"));
addUString(systemParametersDict, CFSTR("CustomUUID"), (const UniChar *)&s->CustomUuid);
addBoolean(systemParametersDict, CFSTR("InjectSystemID"), s->InjectSystemID);
addHex(systemParametersDict, CFSTR("BacklightLevel"),s->BacklightLevel);
// addBoolean(systemParametersDict, CFSTR("InjectKexts"), 0);
addString(systemParametersDict, CFSTR("#InjectKexts"), "Detect");
addBoolean(systemParametersDict, CFSTR("NvidiaWeb"), s->NvidiaWeb);
// GUI
CFMutableDictionaryRef guiDict = addDict(dict, CFSTR("GUI"));
addString(guiDict, CFSTR("#Language"), s->Language);
addString(guiDict, CFSTR("#Theme"), "embedded");
addBoolean(guiDict, CFSTR("TextOnly"), 0);
addBoolean(guiDict, CFSTR("CustomIcons"), 0);
CFMutableDictionaryRef mouseDict = addDict(guiDict, CFSTR("Mouse"));
addBoolean(mouseDict, CFSTR("Enabled"), s->PointerEnabled);
addInteger(mouseDict, CFSTR("Speed"), s->PointerSpeed);
// addInteger(mouseDict, CFSTR("DoubleClick"), s->DoubleClickTime);
addBoolean(mouseDict, CFSTR("Mirror"), s->PointerMirror);
CFMutableArrayRef hideArray = addArray(guiDict, CFSTR("#Hide"));
addStringToArray(hideArray, "VolumeName_NOT_SHOWN");
addStringToArray(hideArray, "VolumeUUID_NOT_SHOWN");
addStringToArray(hideArray, "EntryPath_NOT_SHOWN");
CFMutableDictionaryRef scanDict = addDict(guiDict, CFSTR("Scan"));
addString(scanDict, CFSTR("Comment"), "These values wrong, they present for sample");
addBoolean(scanDict, CFSTR("#Entries"), 1);
addBoolean(scanDict, CFSTR("#Tool"), 1);
addBoolean(scanDict, CFSTR("#Legacy"), 1);
CFMutableDictionaryRef customDict = addDict(guiDict, CFSTR("Custom"));
addString(customDict, CFSTR("Comment"), "These values wrong, they present for sample");
CFMutableArrayRef entriesArray = addArray(customDict, CFSTR("Entries"));
CFMutableDictionaryRef entries1Dict = addDictToArray(entriesArray);
addString(entries1Dict, CFSTR("Comment"), "These values wrong, they present for sample");
addString(entries1Dict, CFSTR("#Volume"), "VolumeUUID_NOT_SHOWN");
addString(entries1Dict, CFSTR("#Path"), "_NOT_SHOWN_");
addString(entries1Dict, CFSTR("#Type"), "_NOT_SHOWN_");
addString(entries1Dict, CFSTR("#Arguments"), "_NOT_SHOWN_");
addString(entries1Dict, CFSTR("#AddArguments"), "-v");
addString(entries1Dict, CFSTR("#Title"), "_NOT_SHOWN_");
addString(entries1Dict, CFSTR("#FullTitle"), "_NOT_SHOWN_");
addString(entries1Dict, CFSTR("#Image"), "_NOT_SHOWN_");
addString(entries1Dict, CFSTR("#Hotkey"), "_NOT_SHOWN_");
addBoolean(entries1Dict, CFSTR("#Disabled"), 1);
addBoolean(entries1Dict, CFSTR("#InjectKexts"), 1);
addBoolean(entries1Dict, CFSTR("#NoCaches"), 0);
addBoolean(entries1Dict, CFSTR("#Hidden"), 1);
CFMutableArrayRef subEntriesArray = addArray(entries1Dict, CFSTR("SubEntries"));
CFMutableDictionaryRef subEntries1Dict = addDictToArray(subEntriesArray);
addString(subEntries1Dict, CFSTR("#Title"), "_NOT_SHOWN_");
addString(subEntries1Dict, CFSTR("#AddArguments"), "_NOT_SHOWN_");
CFMutableArrayRef legacyArray = addArray(customDict, CFSTR("Legacy"));
CFMutableDictionaryRef legacy1Dict = addDictToArray(legacyArray);
addString(legacy1Dict, CFSTR("#Volume"), "VolumeUUID_NOT_SHOWN");
addString(legacy1Dict, CFSTR("#Type"), "_NOT_SHOWN_");
addString(legacy1Dict, CFSTR("#Title"), "_NOT_SHOWN_");
addString(legacy1Dict, CFSTR("#Hotkey"), "_NOT_SHOWN_");
addBoolean(legacy1Dict, CFSTR("#Disabled"), 1);
addBoolean(legacy1Dict, CFSTR("#Hidden"), 1);
CFMutableArrayRef toolArray = addArray(customDict, CFSTR("Tool"));
CFMutableDictionaryRef tool1Dict = addDictToArray(toolArray);
addString(tool1Dict, CFSTR("#Volume"), "VolumeUUID_NOT_SHOWN");
addString(tool1Dict, CFSTR("#Path"), "_NOT_SHOWN_");
addString(tool1Dict, CFSTR("#Type"), "_NOT_SHOWN_");
addString(tool1Dict, CFSTR("#Title"), "_NOT_SHOWN_");
addString(tool1Dict, CFSTR("#Arguments"), "_NOT_SHOWN_");
addString(tool1Dict, CFSTR("#Hotkey"), "_NOT_SHOWN_");
addBoolean(tool1Dict, CFSTR("#Disabled"), 1);
addBoolean(tool1Dict, CFSTR("#Hidden"), 1);
// SMBIOS
CFMutableDictionaryRef smbiosDict = addDict(dict, CFSTR("SMBIOS"));
// SMBIOS TYPE0
addString(smbiosDict, CFSTR("BiosVendor"), s->VendorName);
addString(smbiosDict, CFSTR("BiosVersion"), s->RomVersion);
addString(smbiosDict, CFSTR("BiosReleaseDate"), s->ReleaseDate);
// SMBIOS TYPE1
addString(smbiosDict, CFSTR("Manufacturer"), s->ManufactureName);
addString(smbiosDict, CFSTR("ProductName"), s->ProductName);
addString(smbiosDict, CFSTR("Version"), s->VersionNr);
addString(smbiosDict, CFSTR("SerialNumber"), s->SerialNr);
addUUID(smbiosDict, CFSTR("SmUUID"), (UInt8 *)&s->SmUUID);
addString(smbiosDict, CFSTR("Family"), s->FamilyName);
// SMBIOS TYPE2
addString(smbiosDict, CFSTR("BoardManufacturer"), s->BoardManufactureName);
addString(smbiosDict, CFSTR("BoardSerialNumber"), s->BoardSerialNumber);
addString(smbiosDict, CFSTR("Board-ID"), s->BoardNumber);
addString(smbiosDict, CFSTR("BoardVersion"), s->BoardVersion);
addInteger(smbiosDict, CFSTR("BoardType"), s->BoardType);
addString(smbiosDict, CFSTR("LocationInChassis"), s->LocationInChassis);
addString(smbiosDict, CFSTR("ChassisManufacturer"), s->ChassisManufacturer);
addString(smbiosDict, CFSTR("ChassisAssetTag"), s->ChassisAssetTag);
addHex(smbiosDict, CFSTR("ChassisType"), s->ChassisType);
addBoolean(smbiosDict, CFSTR("Mobile"), s->Mobile);
// SMBIOS TYPE17
addBoolean(smbiosDict, CFSTR("Trust"), s->TrustSMBIOS);
addString(smbiosDict, CFSTR("OEMProduct"), s->OEMProduct);
addString(smbiosDict, CFSTR("OEMVendor"), s->OEMVendor);
addString(smbiosDict, CFSTR("OEMBoard"), s->OEMBoard);
if (s->PlatformFeature != 0xFFFF) {
addHex(smbiosDict, CFSTR("PlatformFeature"), s->PlatformFeature);
}
if (s->InjectMemoryTables) {
CFMutableDictionaryRef memoryDict = addDict(smbiosDict, CFSTR("Memory"));
addString(memoryDict, CFSTR("Comment"), "there are no real data here");
addInteger(memoryDict, CFSTR("#SlotCount"), 0);
addInteger(memoryDict, CFSTR("#Channels"), 0);
CFMutableArrayRef modulesArray = addArray(memoryDict, CFSTR("Modules"));
CFMutableDictionaryRef moduleDict = addDictToArray(modulesArray);
addInteger(moduleDict, CFSTR("#Slot"), 0);
addInteger(moduleDict, CFSTR("#Size"), 0);
addString(moduleDict, CFSTR("#Vendor"), s->MemoryManufacturer);
addString(moduleDict, CFSTR("#Serial"), s->MemorySerialNumber);
addString(moduleDict, CFSTR("#Part"), s->MemoryPartNumber);
addString(moduleDict, CFSTR("#Frequency"), s->MemorySpeed);
addString(moduleDict, CFSTR("#Type"), "DDRx");
}
CFMutableArrayRef slotsArray = addArray(smbiosDict, CFSTR("#Slots"));
CFMutableDictionaryRef slotsDict = addDictToArray(slotsArray);
addString(slotsDict, CFSTR("Comment"), "there is a sample");
addString(slotsDict, CFSTR("Device"), "WIFI");
addInteger(slotsDict, CFSTR("ID"), 5);
addInteger(slotsDict, CFSTR("Type"), 1);
addString(slotsDict, CFSTR("Name"), "Airport");
// CPU
CFMutableDictionaryRef cpuDict = addDict(dict, CFSTR("CPU"));
addHex(cpuDict, CFSTR("Type"), s->CpuType);
addInteger(cpuDict, CFSTR("FrequencyMHz"), s->CpuFreqMHz);
addInteger(cpuDict, CFSTR("#BusSpeedkHz"), s->BusSpeed);
addInteger(cpuDict, CFSTR("QPI"), s->QPI);
addInteger(cpuDict, CFSTR("SavingMode"), s->SavingMode);
addBoolean(cpuDict, CFSTR("#UseARTFrequency"), s->UseARTFreq);
addBoolean(cpuDict, CFSTR("#TurboDisable"), (s->Turbo == 0));
addBoolean(cpuDict, CFSTR("#HWPEnable"), s->HWP);
addInteger(cpuDict, CFSTR("#HWPValue"), s->HWPValue);
addInteger(cpuDict, CFSTR("EnabledCores"), s->EnabledCores);
addBoolean(cpuDict, CFSTR("#TDP"), s->TDP);
addBoolean(cpuDict, CFSTR("#QEMU"), s->QEMU);
// Devices
CFMutableDictionaryRef pciDict = addDict(dict, CFSTR("Devices"));
addBoolean(pciDict, CFSTR("#Inject"), s->StringInjector);
addString(pciDict, CFSTR("#Properties"), "_NOT_SHOWN_");
// addInteger(pciDict, CFSTR("PCIRootUID"), s->PCIRootUID);
addBoolean(pciDict, CFSTR("#NoDefaultProperties"), s->NoDefaultProperties);
CFMutableArrayRef appPropArray = addArray(pciDict, CFSTR("#AddProperties"));
CFMutableDictionaryRef appPropDict = addDictToArray(appPropArray);
addString(appPropDict, CFSTR("#Device"), "XXX");
addBoolean(appPropDict, CFSTR("#Disabled"), 1);
addString(appPropDict, CFSTR("#Key"), "AAPL,XXX");
addHex(appPropDict, CFSTR("#Value"), 0xFFFF);
CFMutableDictionaryRef propDict = addDict(pciDict, CFSTR("Properties"));
addGFXDictionary(propDict, gfx);
CFMutableDictionaryRef fakeIDDict = addDict(pciDict, CFSTR("FakeID"));
addHex(fakeIDDict, CFSTR("ATI"), s->FakeATI);
addHex(fakeIDDict, CFSTR("NVidia"), s->FakeNVidia);
addHex(fakeIDDict, CFSTR("IntelGFX"), s->FakeIntel);
addHex(fakeIDDict, CFSTR("LAN"), s->FakeLAN);
addHex(fakeIDDict, CFSTR("WIFI"), s->FakeWIFI);
addHex(fakeIDDict, CFSTR("SATA"), s->FakeSATA);
addHex(fakeIDDict, CFSTR("XHCI"), s->FakeXHCI);
addHex(fakeIDDict, CFSTR("IMEI"), s->FakeIMEI);
CFMutableDictionaryRef audioDict = addDict(pciDict, CFSTR("Audio"));
if (s->HDAInjection)
addInteger(audioDict, CFSTR("#Inject"), s->HDALayoutId);
else
addBoolean(audioDict, CFSTR("#Inject"), s->HDAInjection);
addBoolean(audioDict, CFSTR("#ResetHDA"), s->ResetHDA);
addBoolean(pciDict, CFSTR("UseIntelHDMI"), s->UseIntelHDMI);
addBoolean(pciDict, CFSTR("ForceHPET"), s->ForceHPET);
addBoolean(pciDict, CFSTR("#SetIntelBacklight"), s->IntelBacklight);
addBoolean(pciDict, CFSTR("#SetIntelMaxBacklight"), s->IntelMaxBacklight);
addInteger(pciDict, CFSTR("#IntelMaxValue"), s->IntelMaxValue);
CFMutableDictionaryRef usbDict = addDict(pciDict, CFSTR("USB"));
addBoolean(usbDict, CFSTR("Inject"), s->USBInjection);
addBoolean(usbDict, CFSTR("FixOwnership"), s->USBFixOwnership);
addBoolean(usbDict, CFSTR("AddClockID"), s->InjectClockID);
addBoolean(usbDict, CFSTR("HighCurrent"), s->HighCurrent);
// Graphics
CFMutableDictionaryRef graphicsDict = addDict(dict, CFSTR("Graphics"));
CFMutableDictionaryRef injectDict = addDict(graphicsDict, CFSTR("Inject"));
addBoolean(injectDict, CFSTR("ATI"), s->InjectATI);
addBoolean(injectDict, CFSTR("NVidia"), s->InjectNVidia);
addBoolean(injectDict, CFSTR("Intel"), s->InjectIntel);
addBoolean(graphicsDict, CFSTR("LoadVBios"), s->LoadVBios);
// addBoolean(graphicsDict, CFSTR("InjectEDID"), s->InjectEDID);
// addString(graphicsDict, CFSTR("#CustomEDID"), "_NOT_SHOWN_");
addBoolean(graphicsDict, CFSTR("PatchVBios"), s->PatchVBios);
addInteger(graphicsDict, CFSTR("VideoPorts"), s->VideoPorts);
addInteger(graphicsDict, CFSTR("VRAM"), s->VRAM);
addInteger(graphicsDict, CFSTR("DualLink"), s->DualLink);
// ATI specific"
addUString(graphicsDict, CFSTR("FBName"), (const UniChar *)&s->FBName);
addBoolean(graphicsDict, CFSTR("RadeonDeInit"), s->DeInit);
// NVIDIA specific
addIntArray(graphicsDict, CFSTR("display-cfg"), &s->Dcfg[0], 8);
addIntArray(graphicsDict, CFSTR("NVCAP"), &s->NVCAP[0], 20);
addBoolean(graphicsDict, CFSTR("NvidiaGeneric"), s->NvidiaGeneric);
addBoolean(graphicsDict, CFSTR("NvidiaNoEFI"), s->NvidiaNoEFI);
addBoolean(graphicsDict, CFSTR("NvidiaSingle"), s->NvidiaSingle);
// INTEL specific
addHex(graphicsDict, CFSTR("ig-platform-id"), s->IgPlatform);
addInteger(graphicsDict, CFSTR("#PatchVBiosBytes Count"), s->PatchVBiosBytesCount);
CFMutableArrayRef vbiosArray = addArray(graphicsDict, CFSTR("#PatchVBiosBytes"));
CFMutableDictionaryRef vbiosDict = addDictToArray(vbiosArray);
addString(vbiosDict, CFSTR("#Find"), "_NOT_SHOWN_");
addString(vbiosDict, CFSTR("#Replace"), "_NOT_SHOWN_");
//EDID
CFMutableDictionaryRef edidDict = addDict(graphicsDict, CFSTR("EDID"));
addBoolean(edidDict, CFSTR("Inject"), s->InjectEDID);
addString(edidDict, CFSTR("#Custom"), "_NOT_SHOWN_");
addHex(edidDict, CFSTR("#VendorID"), s->VendorEDID);
addHex(edidDict, CFSTR("#ProductID"), s->ProductEDID);
//ACPI
CFMutableDictionaryRef acpiDict = addDict(dict, CFSTR("ACPI"));
addHex(acpiDict, CFSTR("ResetAddress"), s->ResetAddr);
addHex(acpiDict, CFSTR("ResetValue"), s->ResetVal);
addBoolean(acpiDict, CFSTR("HaltEnabler"), s->SlpSmiEnable);
addBoolean(acpiDict, CFSTR("PatchAPIC"), s->PatchNMI);
addBoolean(acpiDict, CFSTR("smartUPS"), s->smartUPS);
addBoolean(acpiDict, CFSTR("AutoMerge"), s->AutoMerge);
addBoolean(acpiDict, CFSTR("DisableASPM"), s->NoASPM);
addBoolean(acpiDict, CFSTR("FixHeaders"), s->FixHeaders);
addBoolean(acpiDict, CFSTR("FixMCFG"), s->FixMCFG);
CFMutableDictionaryRef dsdtDict = addDict(acpiDict, CFSTR("DSDT"));
addUString(dsdtDict, CFSTR("Name"), (const UniChar *)&s->DsdtName);
addBoolean(dsdtDict, CFSTR("Debug"), s->DebugDSDT);
addBoolean(dsdtDict, CFSTR("ReuseFFFF"), s->ReuseFFFF);
addBoolean(dsdtDict, CFSTR("SuspendOverride"), s->SuspendOverride);
addBoolean(dsdtDict, CFSTR("Rtc8Allowed"), s->Rtc8Allowed);
// addBoolean(dsdtDict, CFSTR("SlpSmiAtWake"), s->SlpWak);
addInteger(dsdtDict, CFSTR("#Patches count"), s->PatchDsdtNum);
CFMutableDictionaryRef fixDict = addDict(dsdtDict, CFSTR("Fixes"));
addBoolean(fixDict, CFSTR("AddDTGP"), !!(s->FixDsdt & FIX_DTGP));
addBoolean(fixDict, CFSTR("FixDarwin"), !!(s->FixDsdt & FIX_WARNING));
addBoolean(fixDict, CFSTR("FixShutdown"), !!(s->FixDsdt & FIX_SHUTDOWN));
addBoolean(fixDict, CFSTR("AddMCHC"), !!(s->FixDsdt & FIX_MCHC));
addBoolean(fixDict, CFSTR("FixHPET"), !!(s->FixDsdt & FIX_HPET));
addBoolean(fixDict, CFSTR("FakeLPC"), !!(s->FixDsdt & FIX_LPC));
addBoolean(fixDict, CFSTR("FixIPIC"), !!(s->FixDsdt & FIX_IPIC));
addBoolean(fixDict, CFSTR("FixSBUS"), !!(s->FixDsdt & FIX_SBUS));
addBoolean(fixDict, CFSTR("FixDisplay"), !!(s->FixDsdt & FIX_DISPLAY));
addBoolean(fixDict, CFSTR("FixIDE"), !!(s->FixDsdt & FIX_IDE));
addBoolean(fixDict, CFSTR("FixSATA"), !!(s->FixDsdt & FIX_SATA));
addBoolean(fixDict, CFSTR("FixFirewire"), !!(s->FixDsdt & FIX_FIREWIRE));
addBoolean(fixDict, CFSTR("FixUSB"), !!(s->FixDsdt & FIX_USB));
addBoolean(fixDict, CFSTR("FixLAN"), !!(s->FixDsdt & FIX_LAN));
addBoolean(fixDict, CFSTR("FixAirport"), !!(s->FixDsdt & FIX_WIFI));
addBoolean(fixDict, CFSTR("FixHDA"), !!(s->FixDsdt & FIX_HDA));
addBoolean(fixDict, CFSTR("FixDarwin7"), !!(s->FixDsdt & FIX_DARWIN));
addBoolean(fixDict, CFSTR("FixRTC"), !!(s->FixDsdt & FIX_RTC));
addBoolean(fixDict, CFSTR("FixTMR"), !!(s->FixDsdt & FIX_TMR));
addBoolean(fixDict, CFSTR("AddIMEI"), !!(s->FixDsdt & FIX_IMEI));
addBoolean(fixDict, CFSTR("FixIntelGfx"), !!(s->FixDsdt & FIX_INTELGFX));
addBoolean(fixDict, CFSTR("FixWAK"), !!(s->FixDsdt & FIX_WAK));
addBoolean(fixDict, CFSTR("DeleteUnused"), !!(s->FixDsdt & FIX_UNUSED));
addBoolean(fixDict, CFSTR("FixADP1"), !!(s->FixDsdt & FIX_ADP1));
addBoolean(fixDict, CFSTR("AddPNLF"), !!(s->FixDsdt & FIX_PNLF));
addBoolean(fixDict, CFSTR("FixS3D"), !!(s->FixDsdt & FIX_S3D));
addBoolean(fixDict, CFSTR("FixACST"), !!(s->FixDsdt & FIX_ACST));
addBoolean(fixDict, CFSTR("AddHDMI"), !!(s->FixDsdt & FIX_HDMI));
addBoolean(fixDict, CFSTR("FixRegions"), !!(s->FixDsdt & FIX_REGIONS));
addBoolean(fixDict, CFSTR("FixHeaders"), !!(s->FixDsdt & FIX_HEADERS));
CFMutableArrayRef dsdtPatchArray = addArray(dsdtDict, CFSTR("Patches"));
CFMutableDictionaryRef dsdtPatchDict = addDictToArray(dsdtPatchArray);
addString(dsdtPatchDict, CFSTR("Comment"), "This is for sample");
addBoolean(dsdtPatchDict, CFSTR("Disabled"), TRUE);
addString(dsdtPatchDict, CFSTR("Find"), "_NOT_SHOWN_");
addString(dsdtPatchDict, CFSTR("Replace"), "_NOT_SHOWN_");
CFMutableDictionaryRef dsmDict = addDict(dsdtDict, CFSTR("DropOEM_DSM"));
addBoolean(dsmDict, CFSTR("ATI"), !!(s->DropOEM_DSM & DEV_ATI));
addBoolean(dsmDict, CFSTR("IntelGFX"), !!(s->DropOEM_DSM & DEV_INTEL));
addBoolean(dsmDict, CFSTR("NVidia"), !!(s->DropOEM_DSM & DEV_NVIDIA));
addBoolean(dsmDict, CFSTR("LAN"), !!(s->DropOEM_DSM & DEV_LAN));
addBoolean(dsmDict, CFSTR("WIFI"), !!(s->DropOEM_DSM & DEV_WIFI));
addBoolean(dsmDict, CFSTR("HDA"), !!(s->DropOEM_DSM & DEV_HDA));
addBoolean(dsmDict, CFSTR("HDMI"), !!(s->DropOEM_DSM & DEV_HDMI));
addBoolean(dsmDict, CFSTR("LPC"), !!(s->DropOEM_DSM & DEV_LPC));
addBoolean(dsmDict, CFSTR("SmBUS"), !!(s->DropOEM_DSM & DEV_SMBUS));
addBoolean(dsmDict, CFSTR("Firewire"), !!(s->DropOEM_DSM & DEV_FIREWIRE));
addBoolean(dsmDict, CFSTR("USB"), !!(s->DropOEM_DSM & DEV_USB));
addBoolean(dsmDict, CFSTR("IDE"), !!(s->DropOEM_DSM & DEV_IDE));
addBoolean(dsmDict, CFSTR("SATA"), !!(s->DropOEM_DSM & DEV_SATA));
CFMutableDictionaryRef ssdtDict = addDict(acpiDict, CFSTR("SSDT"));
CFMutableDictionaryRef genDict = addDict(ssdtDict, CFSTR("Generate"));
addBoolean(genDict, CFSTR("PStates"), s->GeneratePStates);
addBoolean(genDict, CFSTR("CStates"), s->GenerateCStates);
addBoolean(genDict, CFSTR("APSN"), s->GenerateAPSN);
addBoolean(genDict, CFSTR("APLF"), s->GenerateAPLF);
addBoolean(genDict, CFSTR("PluginType"), s->GeneratePluginType);
addBoolean(ssdtDict, CFSTR("DropOem"), s->DropSSDT);
addBoolean(ssdtDict, CFSTR("#DoubleFirstState"), s->DoubleFirstState);
addInteger(ssdtDict, CFSTR("#MinMultiplier"), s->MinMultiplier);
addInteger(ssdtDict, CFSTR("#MaxMultiplier"), s->MaxMultiplier);
addInteger(ssdtDict, CFSTR("#PLimitDict"), s->PLimitDict);
addInteger(ssdtDict, CFSTR("#UnderVoltStep"), s->UnderVoltStep);
addInteger(ssdtDict, CFSTR("#PluginType"), s->PluginType);
addBoolean(ssdtDict, CFSTR("#UseSystemIO"), s->EnableISS);
addBoolean(ssdtDict, CFSTR("#EnableC2"), s->EnableC2);
addBoolean(ssdtDict, CFSTR("#EnableC4"), s->EnableC4);
addBoolean(ssdtDict, CFSTR("#EnableC6"), s->EnableC6);
addBoolean(ssdtDict, CFSTR("#EnableC7"), s->EnableC7);
addInteger(ssdtDict, CFSTR("#C3Latency"), s->C3Latency);
addBoolean(ssdtDict, CFSTR("NoDynamicExtract"), s->NoDynamicExtract);
CFMutableArrayRef dropArray = addArray(acpiDict, CFSTR("DropTables"));
CFMutableDictionaryRef drop1Dict = addDictToArray(dropArray);
addString(drop1Dict, CFSTR("#Signature"), "_NOT_SHOWN_");
addString(drop1Dict, CFSTR("#TableId"), "_NOT_SHOWN_");
addInteger(drop1Dict, CFSTR("#Length"), 0);
CFMutableArrayRef sortedArray = addArray(acpiDict, CFSTR("#SortedOrder"));
addStringToArray(sortedArray, "SSDT-1.aml");
addInteger(acpiDict, CFSTR("#Sorted ACPI tables Count"), s->SortedACPICount);
CFMutableDictionaryRef renameDict = addDict(acpiDict, CFSTR("#RenameDevices"));
addString(renameDict, CFSTR("#_SB.PCI0.RP01.PXSX"), "ARPT");
addString(renameDict, CFSTR("_SB.PCI0.RP02.PXSX"), "XHC2");
// KernelAndKextPatches
CFMutableDictionaryRef KernelAndKextPatchesDict = addDict(dict, CFSTR("KernelAndKextPatches"));
addBoolean(KernelAndKextPatchesDict, CFSTR("#Debug"), s->KernelAndKextPatches.KPDebug);
addBoolean(KernelAndKextPatchesDict, CFSTR("KernelCpu"), s->KernelAndKextPatches.KPKernelCpu);
addBoolean(KernelAndKextPatchesDict, CFSTR("KernelLapic"), s->KernelAndKextPatches.KPKernelLapic);
addBoolean(KernelAndKextPatchesDict, CFSTR("KernelXCPM"), s->KernelAndKextPatches.KPKernelXCPM);
addBoolean(KernelAndKextPatchesDict, CFSTR("KernelPm"), s->KernelAndKextPatches.KPKernelPm);
addBoolean(KernelAndKextPatchesDict, CFSTR("AppleIntelCPUPM"), s->KernelAndKextPatches.KPAppleIntelCPUPM);
addBoolean(KernelAndKextPatchesDict, CFSTR("AppleRTC"), s->KernelAndKextPatches.KPAppleRTC);
addBoolean(KernelAndKextPatchesDict, CFSTR("DellSMBIOSPatch"), s->KernelAndKextPatches.KPDELLSMBIOS);
//addBoolean(KernelAndKextPatchesDict, CFSTR("KextPatchesAllowed"), s->KextPatchesAllowed);
addInteger(KernelAndKextPatchesDict, CFSTR("#Number of KextsToPatch"), s->KernelAndKextPatches.NrKexts);
addInteger(KernelAndKextPatchesDict, CFSTR("#Number of Patchs To Kernel"), s->KernelAndKextPatches.NrKernels);
addHex(KernelAndKextPatchesDict, CFSTR("#FakeCPUID"), s->KernelAndKextPatches.FakeCPUID);
CFMutableArrayRef KKPatchArray = addArray(KernelAndKextPatchesDict, CFSTR("#KextsToPatch"));
CFMutableDictionaryRef patchDict1 = addDictToArray(KKPatchArray);
addString(patchDict1, CFSTR("Comment"), "this is a sample");
addString(patchDict1, CFSTR("#Name"), "AppleUSBXHCIPCI");
addString(patchDict1, CFSTR("#Find"), "_NOT_SHOWN_");
addString(patchDict1, CFSTR("#Replace"), "_NOT_SHOWN_");
addBoolean(patchDict1, CFSTR("Disabled"), 1);
addString(patchDict1, CFSTR("#MatchOS"), "10.11.6,10.12.x");
addString(patchDict1, CFSTR("#MatchBuild"), "16D1111");
CFMutableDictionaryRef rtVariablesDict = addDict(dict, CFSTR("RtVariables"));
addString(rtVariablesDict, CFSTR("#ROM"), "UseMacAddr0");
addString(rtVariablesDict, CFSTR("#MLB"), s->BoardSerialNumber);
addHex(rtVariablesDict, CFSTR("CsrActiveConfig"), s->CsrActiveConfig);
addHex(rtVariablesDict, CFSTR("BooterConfig"), s->BooterConfig);
CFMutableArrayRef disArray = addArray(dict, CFSTR("#DisableDrivers"));
addStringToArray(disArray, "_NOT_SHOWN_");
CFMutableDictionaryRef bootGraphicsDict = addDict(dict, CFSTR("BootGraphics"));
addHex(bootGraphicsDict, CFSTR("DefaultBackgroundColor"), s->DefaultBackgroundColor);
addInteger(bootGraphicsDict, CFSTR("UIScale"), s->UIScale);
addInteger(bootGraphicsDict, CFSTR("EFILoginHiDPI"), s->EFILoginHiDPI);
addInteger(bootGraphicsDict, CFSTR("flagstate"), s->flagstate[0]);
dump_plist(dict);
printf("\nDsdtFix=%x\n", s->FixDsdt);
printf("DsdtFix offset=%d\n", (int)offsetof(SETTINGS_DATA, FixDsdt));
printf("HDALayoutId offset=%d\n", (int)offsetof(SETTINGS_DATA, HDALayoutId));
#if defined(MDE_CPU_IA32)
printf("32 bit generator\n");
#elif defined(MDE_CPU_X64)
printf("64 bit generator\n");
#else
printf("xxx bit generator\n");
#endif
}
int main(int argc, char **argv)
{
kern_return_t result;
#if GFX
CFTypeRef devProp = NULL;
// SETTINGS settings;
GFX_HEADER * gfx;
const unsigned char *dataPtr = NULL;
CFIndex length = 0;
CFTypeID typeID;
#endif
result = IOMasterPort(bootstrap_port, &masterPort);
if (result != KERN_SUCCESS) {
errx(1, "Error getting the IOMaster port: %s",
mach_error_string(result));
}
#if GFX
gEFI = IORegistryEntryFromPath(masterPort, "IODeviceTree:/efi");
if (gEFI == 0) {
errx(1, "EFI is not supported on this system");
}
(void) GetOFVariable(gEFI, "device-properties", &devProp);
// Get the OF variable's type.
typeID = CFGetTypeID(devProp);
if (typeID == CFDataGetTypeID()) {
length = CFDataGetLength(devProp);
if (length > 0) {
dataPtr = CFDataGetBytePtr(devProp);
gfx = parse_binary(dataPtr);
} else {
warnx("<INVALID> Length of device-properties");
}
} else {
warnx("<INVALID> Type of device-properties");
}
#endif
gPlatform = IORegistryEntryFromPath(masterPort, "IODeviceTree:/efi/platform");
if (gPlatform == 0) {
errx(1, "EFI is not supported on this system");
}
CFTypeRef data = NULL;
result = GetOFVariable(gPlatform, "Settings", &data);
if (result != KERN_SUCCESS) {
errx(1, "Can not get Clover settings: %s",
mach_error_string(result));
}
PrintConfig(data, gfx);
CFRelease(data);
IOObjectRelease(gPlatform);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink