timamsk/OpenCore-Legacy-Patcher
1
0
Fork 0
mirror of https://github.com/dortania/OpenCore-Legacy-Patcher.git synced 2026-06-21 06:30:52 +10:00
Code Issues Packages Projects Releases Wiki Activity

Use device_probe

Browse Source
This commit is contained in:
Dhinak G
2021-06-17 13:18:31 -04:00
parent 7b758fcf15
commit 94af2350f4
12 changed files with 973 additions and 914 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.flake8
+1 -1
View File
@@ -1,4 +1,4 @@
[flake8] [flake8]
ignore = E501 extend-ignore = E501, E203
per-file-ignores = per-file-ignores =
Resources/Constants.py:E704 Resources/Constants.py:E704
OpenCore-Patcher.command
+121 -106
View File
@@ -3,120 +3,129 @@
from __future__ import print_function from __future__ import print_function
import plistlib import platform
import subprocess import subprocess
import sys import sys
import platform
from Resources import Build, ModelArray, PCIIDArray, Constants, SysPatch, Utilities, CliMenu, DeviceProbe from Resources import (Build, CliMenu, Constants, ModelArray, SysPatch,
Utilities, device_probe)
class OpenCoreLegacyPatcher(): class OpenCoreLegacyPatcher:
def __init__(self): def __init__(self):
print("Loading...")
self.constants = Constants.Constants() self.constants = Constants.Constants()
self.current_model: str = None self.constants.computer = device_probe.Computer.probe()
self.current_model = DeviceProbe.smbios_probe().model_detect(False) self.computer = self.constants.computer
self.constants.detected_os = int(platform.uname().release.partition(".")[0]) self.constants.detected_os = int(platform.uname().release.partition(".")[0])
self.check_default_settings(self.current_model, False) self.set_defaults(self.computer.real_model, True)
custom_cpu_model_value: str = subprocess.run("nvram 4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:revcpuname".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode() custom_cpu_model_value = Utilities.get_nvram("revcpuname", "4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102", decode=True)
if not custom_cpu_model_value.startswith("nvram: Error getting variable"): if custom_cpu_model_value is not None:
custom_cpu_model_value = [line.strip().split(":revcpuname ", 1)[1] for line in custom_cpu_model_value.split("\n") if line.strip().startswith("4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:")][0] # TODO: Fix to not use two separate variables
if custom_cpu_model_value.split("%00")[0] != "": self.constants.custom_cpu_model = 1
self.constants.custom_cpu_model = 1 self.constants.custom_cpu_model_value = custom_cpu_model_value.split("%00")[0]
self.constants.custom_cpu_model_value = custom_cpu_model_value.split("%00")[0]
if "-v" in (Utilities.get_nvram("boot-args", decode=False) or ""): if "-v" in (Utilities.get_nvram("boot-args") or ""):
self.constants.verbose_debug = True self.constants.verbose_debug = True
# Check if running in RecoveryOS # Check if running in RecoveryOS
self.check_recovery() self.constants.recovery_status = Utilities.check_recovery()
def check_default_settings(self, model, custom): def set_defaults(self, model, host_is_target):
# Defaults
self.constants.sip_status = True self.constants.sip_status = True
self.constants.secure_status = False # Default false for Monterey
self.constants.disable_amfi = False self.constants.disable_amfi = False
if model in ModelArray.LegacyGPU:
if custom is False:
dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
if (dgpu_vendor == self.constants.pci_amd_ati and (dgpu_device in PCIIDArray.amd_ids().polaris_ids or dgpu_device in PCIIDArray.amd_ids().vega_ids or dgpu_device in PCIIDArray.amd_ids().navi_ids or dgpu_device in PCIIDArray.amd_ids().legacy_gcn_ids)) or (dgpu_vendor == self.constants.pci_nvidia and dgpu_device in PCIIDArray.nvidia_ids().kepler_ids):
self.constants.sip_status = True
self.constants.secure_status = False
self.constants.disable_amfi = False
else:
self.constants.sip_status = False
self.constants.secure_status = False
self.constants.disable_amfi = True
else:
self.constants.sip_status = False
self.constants.secure_status = False
self.constants.disable_amfi = True
if model in ModelArray.ModernGPU:
if model in ["iMac13,1", "iMac13,3"]:
if custom is False: if (
dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0") model in ModelArray.LegacyGPU
if not dgpu_vendor: and host_is_target
self.constants.sip_status = False and self.computer.dgpu.arch
self.constants.secure_status = False in [
else: device_probe.AMD.Archs.Legacy_GCN,
self.constants.sip_status = False device_probe.AMD.Archs.Polaris,
self.constants.secure_status = False device_probe.AMD.Archs.Vega,
device_probe.AMD.Archs.Navi,
def check_recovery(self): device_probe.NVIDIA.Archs.Kepler,
root_partition_info = plistlib.loads(subprocess.run("diskutil info -plist /".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()) ]
if root_partition_info["VolumeName"] == "macOS Base System" and \ ):
root_partition_info["FilesystemType"] == "apfs" and \ # Building on device and we have a native, supported GPU
root_partition_info["BusProtocol"] == "Disk Image": self.constants.sip_status = True
self.constants.recovery_status = True # self.constants.secure_status = True # Monterey
self.constants.disable_amfi = False
else: else:
self.constants.recovery_status = False self.constants.sip_status = False # Unsigned kexts
self.constants.secure_status = False # Root volume modified
self.constants.disable_amfi = True # Unsigned binaries
if model in ModelArray.ModernGPU and host_is_target and model in ["iMac13,1", "iMac13,3"] and self.computer.dgpu:
# Some models have a supported dGPU, others don't
self.constants.sip_status = True
# self.constants.secure_status = True # Monterey
self.constants.disable_amfi = False
else:
self.constants.sip_status = False # Unsigned kexts
self.constants.secure_status = False # Modified root volume
self.constants.disable_amfi = False # Signed bundles
def build_opencore(self): def build_opencore(self):
Build.BuildOpenCore(self.constants.custom_model or self.current_model, self.constants).build_opencore() Build.BuildOpenCore(self.constants.custom_model or self.constants.computer.real_model, self.constants).build_opencore()
def install_opencore(self): def install_opencore(self):
Build.BuildOpenCore(self.constants.custom_model or self.current_model, self.constants).copy_efi() Build.BuildOpenCore(self.constants.custom_model or self.constants.computer.real_model, self.constants).copy_efi()
def change_model(self): def change_model(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Select Different Model"]) Utilities.header(["Select Different Model"])
print(""" print(
"""
Tip: Run the following command on the target machine to find the model identifier: Tip: Run the following command on the target machine to find the model identifier:
system_profiler SPHardwareDataType | grep 'Model Identifier' system_profiler SPHardwareDataType | grep 'Model Identifier'
""") """
)
self.constants.custom_model = input("Please enter the model identifier of the target machine: ").strip() self.constants.custom_model = input("Please enter the model identifier of the target machine: ").strip()
if self.constants.custom_model not in ModelArray.SupportedSMBIOS: if self.constants.custom_model not in ModelArray.SupportedSMBIOS:
print(f""" print(
{self.constants.custom_model} is not a valid SMBIOS Identifier for macOS {self.constants.os_support}! f"""
""") {self.constants.custom_model} is not a valid SMBIOS Identifier for macOS {self.constants.os_support}!
"""
)
print_models = input(f"Print list of valid options for macOS {self.constants.os_support}? (y/n)") print_models = input(f"Print list of valid options for macOS {self.constants.os_support}? (y/n)")
if print_models in {"y", "Y", "yes", "Yes"}: if print_models.lower() in {"y", "yes"}:
print("\n".join(ModelArray.SupportedSMBIOS)) print("\n".join(ModelArray.SupportedSMBIOS))
input("\nPress [ENTER] to continue") input("\nPress [ENTER] to continue")
else: else:
self.check_default_settings(self.constants.custom_model, True) self.set_defaults(self.constants.custom_model, False)
def patcher_settings(self): def patcher_settings(self):
response = None response = None
while not (response and response == -1): while not (response and response == -1):
title = [ title = ["Adjust Patcher Settings"]
"Adjust Patcher Settings"
]
menu = Utilities.TUIMenu(title, "Please select an option: ", auto_number=True, top_level=True) menu = Utilities.TUIMenu(title, "Please select an option: ", auto_number=True, top_level=True)
options = [ options = [
[f"Enable Verbose Mode:\t\tCurrently {self.constants.verbose_debug}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_verbose], [f"Enable Verbose Mode:\t\tCurrently {self.constants.verbose_debug}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_verbose],
[f"Enable OpenCore DEBUG:\t\tCurrently {self.constants.opencore_debug}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_oc], [f"Enable OpenCore DEBUG:\t\tCurrently {self.constants.opencore_debug}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_oc],
[f"Enable Kext DEBUG:\t\t\tCurrently {self.constants.kext_debug}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_kext], [f"Enable Kext DEBUG:\t\t\tCurrently {self.constants.kext_debug}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_kext],
[f"Set ShowPicker Mode:\t\tCurrently {self.constants.showpicker}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_showpicker], [f"Set ShowPicker Mode:\t\tCurrently {self.constants.showpicker}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_showpicker],
[f"Set Vault Mode:\t\t\tCurrently {self.constants.vault}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_vault], [f"Set Vault Mode:\t\t\tCurrently {self.constants.vault}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_vault],
[f"Allow FireWire Boot:\t\tCurrently {self.constants.firewire_boot}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).allow_firewire], [f"Allow FireWire Boot:\t\tCurrently {self.constants.firewire_boot}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).allow_firewire],
[f"Allow NVMe Boot:\t\t\tCurrently {self.constants.nvme_boot}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).allow_nvme], [f"Allow NVMe Boot:\t\t\tCurrently {self.constants.nvme_boot}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).allow_nvme],
[f"Enable TeraScale 2 Acceleration:\tCurrently {self.constants.terscale_2_patch}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).enable_terascale], [
[f"Disable AMFI:\t\t\tCurrently {self.constants.disable_amfi}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).set_amfi], f"Enable TeraScale 2 Acceleration:\tCurrently {self.constants.terascale_2_patch}",
[f"Set SIP and SecureBootModel:\tSIP: {self.constants.sip_status} SBM: {self.constants.secure_status}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_sip], CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).enable_terascale,
[f"Allow OpenCore on native Models:\tCurrently {self.constants.allow_oc_everywhere}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).allow_native_models], ],
[f"Advanced Patch Settings, for developers only", self.advanced_patcher_settings], [f"Disable AMFI:\t\t\tCurrently {self.constants.disable_amfi}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).set_amfi],
[
f"Set SIP and SecureBootModel:\tSIP: {self.constants.sip_status} SBM: {self.constants.secure_status}",
CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_sip,
],
[
f"Allow OpenCore on native Models:\tCurrently {self.constants.allow_oc_everywhere}",
CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).allow_native_models,
],
["Advanced Patch Settings, for developers only", self.advanced_patcher_settings],
] ]
for option in options: for option in options:
@@ -127,21 +136,22 @@ system_profiler SPHardwareDataType | grep 'Model Identifier'
def advanced_patcher_settings(self): def advanced_patcher_settings(self):
response = None response = None
while not (response and response == -1): while not (response and response == -1):
title = [ title = ["Adjust Advanced Patcher Settings, for developers ONLY"]
"Adjust Advanced Patcher Settings, for developers ONLY"
]
menu = Utilities.TUIMenu(title, "Please select an option: ", auto_number=True, top_level=True) menu = Utilities.TUIMenu(title, "Please select an option: ", auto_number=True, top_level=True)
options = [ options = [
[f"Assume Metal GPU Always:\t\tCurrently {self.constants.imac_vendor}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_metal], [f"Assume Metal GPU Always:\t\tCurrently {self.constants.imac_vendor}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_metal],
#[f"Assume Upgraded Wifi Always:\tCurrently {self.constants.wifi_build}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_wifi], # [f"Assume Upgraded Wifi Always:\tCurrently {self.constants.wifi_build}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_wifi],
[f"Set SMBIOS Mode:\t\t\tCurrently {self.constants.serial_settings}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_serial], [f"Set SMBIOS Mode:\t\t\tCurrently {self.constants.serial_settings}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_serial],
[f"DRM Preferences:\t\t\tCurrently {self.constants.drm_support}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).drm_setting], [f"DRM Preferences:\t\t\tCurrently {self.constants.drm_support}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).drm_setting],
[f"Set Generic Bootstrap:\t\tCurrently {self.constants.boot_efi}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).bootstrap_setting], [f"Set Generic Bootstrap:\t\tCurrently {self.constants.boot_efi}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).bootstrap_setting],
#[f"Assume Legacy GPU:\t\t\tCurrently {self.constants.assume_legacy}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).force_accel_setting], # [f"Assume Legacy GPU:\t\t\tCurrently {self.constants.assume_legacy}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).force_accel_setting],
[f"Disable CPU Friend:\t\t\tCurrently {self.constants.disallow_cpufriend}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).disable_cpufriend], [
[f"Override SMBIOS Spoof:\t\tCurrently {self.constants.override_smbios}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).set_smbios], f"Disable CPU Friend:\t\t\tCurrently {self.constants.disallow_cpufriend}",
[f"Set Custom name {self.constants.custom_cpu_model_value}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).custom_cpu], CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).disable_cpufriend,
[f"Set SeedUtil Status", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).set_seedutil], ],
[f"Override SMBIOS Spoof:\t\tCurrently {self.constants.override_smbios}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).set_smbios],
[f"Set Custom name {self.constants.custom_cpu_model_value}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).custom_cpu],
["Set SeedUtil Status", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).set_seedutil],
] ]
for option in options: for option in options:
@@ -150,8 +160,11 @@ system_profiler SPHardwareDataType | grep 'Model Identifier'
response = menu.start() response = menu.start()
def credits(self): def credits(self):
Utilities.TUIOnlyPrint(["Credits"], "Press [Enter] to go back.\n", Utilities.TUIOnlyPrint(
["""Many thanks to the following: ["Credits"],
"Press [Enter] to go back.\n",
[
"""Many thanks to the following:
- Acidanthera:\tOpenCore, kexts and other tools - Acidanthera:\tOpenCore, kexts and other tools
- Khronokernel:\tWriting and maintaining this patcher - Khronokernel:\tWriting and maintaining this patcher
@@ -159,7 +172,9 @@ system_profiler SPHardwareDataType | grep 'Model Identifier'
- ASentientBot:\tLegacy Acceleration Patches - ASentientBot:\tLegacy Acceleration Patches
- Ausdauersportler:\tLinking fixes for SNBGraphicsFB and AMDX3000 - Ausdauersportler:\tLinking fixes for SNBGraphicsFB and AMDX3000
- Syncretic:\t\tAAAMouSSE and telemetrap - Syncretic:\t\tAAAMouSSE and telemetrap
- cdf:\t\tNightShiftEnabler and Innie"""]).start() - cdf:\t\tNightShiftEnabler and Innie"""
],
).start()
def PatchVolume(self): def PatchVolume(self):
Utilities.cls() Utilities.cls()
@@ -223,9 +238,9 @@ B. Exit
no_patch = True no_patch = True
change_menu = input("Patch System Volume?: ") change_menu = input("Patch System Volume?: ")
if no_patch is not True and change_menu == "1": if no_patch is not True and change_menu == "1":
SysPatch.PatchSysVolume(self.constants.custom_model or self.current_model, self.constants).start_patch() SysPatch.PatchSysVolume(self.constants.custom_model or self.computer.real_model, self.constants).start_patch()
elif no_patch is not True and change_menu == "2": elif no_patch is not True and change_menu == "2":
SysPatch.PatchSysVolume(self.constants.custom_model or self.current_model, self.constants).start_unpatch() SysPatch.PatchSysVolume(self.constants.custom_model or self.computer.real_model, self.constants).start_unpatch()
else: else:
print("Returning to main menu") print("Returning to main menu")
@@ -234,38 +249,38 @@ B. Exit
while not (response and response == -1): while not (response and response == -1):
title = [ title = [
f"OpenCore Legacy Patcher v{self.constants.patcher_version}", f"OpenCore Legacy Patcher v{self.constants.patcher_version}",
f"Selected Model: {self.constants.custom_model or self.current_model}", f"Selected Model: {self.constants.custom_model or self.computer.real_model}",
] ]
if (self.constants.custom_model or self.current_model) not in ModelArray.SupportedSMBIOS and self.constants.allow_oc_everywhere is False: if (self.constants.custom_model or self.computer.real_model) not in ModelArray.SupportedSMBIOS and self.constants.allow_oc_everywhere is False:
in_between = [ in_between = [
'Your model is not supported by this patcher for running unsupported OSes!', "Your model is not supported by this patcher for running unsupported OSes!",
'', "",
'If you plan to create the USB for another machine, please select the "Change Model" option in the menu.' 'If you plan to create the USB for another machine, please select the "Change Model" option in the menu.',
] ]
elif not self.constants.custom_model and self.current_model == "iMac7,1" and \ elif not self.constants.custom_model and self.computer.real_model == "iMac7,1" and "SSE4.1" not in self.computer.cpu.flags:
DeviceProbe.pci_probe().cpu_feature("SSE4.1") is False:
in_between = [ in_between = [
'Your model requires a CPU upgrade to a CPU supporting SSE4.1+ to be supported by this patcher!', "Your model requires a CPU upgrade to a CPU supporting SSE4.1+ to be supported by this patcher!",
'', "",
f'If you plan to create the USB for another {self.current_model} with SSE4.1+, please select the "Change Model" option in the menu.' f'If you plan to create the USB for another {self.computer.real_model} with SSE4.1+, please select the "Change Model" option in the menu.',
] ]
elif self.constants.custom_model == "iMac7,1": elif self.constants.custom_model == "iMac7,1":
in_between = ["This model is supported", in_between = ["This model is supported", "However please ensure the CPU has been upgraded to support SSE4.1+"]
"However please ensure the CPU has been upgraded to support SSE4.1+"
]
else: else:
in_between = ["This model is supported"] in_between = ["This model is supported"]
menu = Utilities.TUIMenu(title, "Please select an option: ", in_between=in_between, auto_number=True, top_level=True) menu = Utilities.TUIMenu(title, "Please select an option: ", in_between=in_between, auto_number=True, top_level=True)
options = ( options = (
[["Build OpenCore", self.build_opencore]] if ((self.constants.custom_model or self.current_model) in ModelArray.SupportedSMBIOS) or self.constants.allow_oc_everywhere is True else []) + [ [["Build OpenCore", self.build_opencore]]
if ((self.constants.custom_model or self.computer.real_model) in ModelArray.SupportedSMBIOS) or self.constants.allow_oc_everywhere is True
else []
) + [
["Install OpenCore to USB/internal drive", self.install_opencore], ["Install OpenCore to USB/internal drive", self.install_opencore],
["Post-Install Volume Patch", self.PatchVolume], ["Post-Install Volume Patch", self.PatchVolume],
["Change Model", self.change_model], ["Change Model", self.change_model],
["Patcher Settings", self.patcher_settings], ["Patcher Settings", self.patcher_settings],
["Credits", self.credits] ["Credits", self.credits],
] ]
for option in options: for option in options:
Resources/Build.py
+196 -195
View File
@@ -3,6 +3,8 @@
from __future__ import print_function from __future__ import print_function
import binascii import binascii
import copy
import pickle
import plistlib import plistlib
import shutil import shutil
import subprocess import subprocess
@@ -12,7 +14,7 @@ import ast
from pathlib import Path from pathlib import Path
from datetime import date from datetime import date
from Resources import Constants, ModelArray, PCIIDArray, Utilities, DeviceProbe from Resources import Constants, ModelArray, Utilities, device_probe
def human_fmt(num): def human_fmt(num):
@@ -34,6 +36,9 @@ class BuildOpenCore:
self.model = model self.model = model
self.config = None self.config = None
self.constants: Constants.Constants = versions self.constants: Constants.Constants = versions
self.computer = self.constants.computer
self.gfx0_path = None
def smbios_set(self): def smbios_set(self):
print("- Setting macOS Monterey Supported SMBIOS") print("- Setting macOS Monterey Supported SMBIOS")
@@ -83,14 +88,14 @@ class BuildOpenCore:
# Additionally, APFS bit(19) flipped # Additionally, APFS bit(19) flipped
# https://github.com/acidanthera/OpenCorePkg/blob/0.6.9/Include/Apple/IndustryStandard/AppleFeatures.h#L136 # https://github.com/acidanthera/OpenCorePkg/blob/0.6.9/Include/Apple/IndustryStandard/AppleFeatures.h#L136
if model == "iMac7,1": if model == "iMac7,1":
fw_feature = b'\x07\x14\x08\xc0\x00\x00\x00\x00' fw_feature = b"\x07\x14\x08\xc0\x00\x00\x00\x00"
fw_mask = b'\xff\x1f\x08\xc0\x00\x00\x00\x00' fw_mask = b"\xff\x1f\x08\xc0\x00\x00\x00\x00"
elif model in ["MacPro4,1", "Xserve3,1"]: elif model in ["MacPro4,1", "Xserve3,1"]:
fw_feature = b'7\xf5\t\xe0\x00\x00\x00\x00' fw_feature = b"7\xf5\t\xe0\x00\x00\x00\x00"
fw_mask = b'7\xff\x0b\xc0\x00\x00\x00\x00' fw_mask = b"7\xff\x0b\xc0\x00\x00\x00\x00"
else: else:
fw_feature = b'\x03\x14\x08\xc0\x00\x00\x00\x00' fw_feature = b"\x03\x14\x08\xc0\x00\x00\x00\x00"
fw_mask = b'\xff\x3f\x08\xc0\x00\x00\x00\x00' fw_mask = b"\xff\x3f\x08\xc0\x00\x00\x00\x00"
return fw_feature, fw_mask return fw_feature, fw_mask
def build_efi(self): def build_efi(self):
@@ -126,6 +131,9 @@ class BuildOpenCore:
self.config["#Revision"]["Build-Version"] = f"{self.constants.patcher_version} - {date.today()}" self.config["#Revision"]["Build-Version"] = f"{self.constants.patcher_version} - {date.today()}"
if not self.constants.custom_model: if not self.constants.custom_model:
self.config["#Revision"]["Build-Type"] = "OpenCore Built on Target Machine" self.config["#Revision"]["Build-Type"] = "OpenCore Built on Target Machine"
computer_copy = copy.copy(self.computer)
computer_copy.ioregistry = None
self.config["#Revision"]["Hardware-Probe"] = pickle.dumps(computer_copy)
else: else:
self.config["#Revision"]["Build-Type"] = "OpenCore Built for External Machine" self.config["#Revision"]["Build-Type"] = "OpenCore Built for External Machine"
self.config["#Revision"]["OpenCore-Version"] = f"{self.constants.opencore_version} - {self.constants.opencore_build} - {self.constants.opencore_commit}" self.config["#Revision"]["OpenCore-Version"] = f"{self.constants.opencore_version} - {self.constants.opencore_build} - {self.constants.opencore_commit}"
@@ -138,13 +146,23 @@ class BuildOpenCore:
("WhateverGreen.kext", self.constants.whatevergreen_version, self.constants.whatevergreen_path, lambda: self.constants.allow_oc_everywhere is False), ("WhateverGreen.kext", self.constants.whatevergreen_version, self.constants.whatevergreen_path, lambda: self.constants.allow_oc_everywhere is False),
("RestrictEvents.kext", self.constants.restrictevents_version, self.constants.restrictevents_path, lambda: self.model in ModelArray.MacPro71), ("RestrictEvents.kext", self.constants.restrictevents_version, self.constants.restrictevents_path, lambda: self.model in ModelArray.MacPro71),
("RestrictEvents.kext", self.constants.restrictevents_mbp_version, self.constants.restrictevents_mbp_path, lambda: self.model in ["MacBookPro6,1", "MacBookPro6,2", "MacBookPro9,1"]), ("RestrictEvents.kext", self.constants.restrictevents_mbp_version, self.constants.restrictevents_mbp_path, lambda: self.model in ["MacBookPro6,1", "MacBookPro6,2", "MacBookPro9,1"]),
("NightShiftEnabler.kext", self.constants.nightshift_version, self.constants.nightshift_path, lambda: self.model in ModelArray.NightShift and self.constants.allow_oc_everywhere is False and self.constants.serial_settings == "Minimal"), (
"NightShiftEnabler.kext",
self.constants.nightshift_version,
self.constants.nightshift_path,
lambda: self.model in ModelArray.NightShift and self.constants.allow_oc_everywhere is False and self.constants.serial_settings == "Minimal",
),
("SMC-Spoof.kext", self.constants.smcspoof_version, self.constants.smcspoof_path, lambda: self.constants.allow_oc_everywhere is False), ("SMC-Spoof.kext", self.constants.smcspoof_version, self.constants.smcspoof_path, lambda: self.constants.allow_oc_everywhere is False),
# CPU patches # CPU patches
("AppleMCEReporterDisabler.kext", self.constants.mce_version, self.constants.mce_path, lambda: self.model in ModelArray.DualSocket), ("AppleMCEReporterDisabler.kext", self.constants.mce_version, self.constants.mce_path, lambda: self.model in ModelArray.DualSocket),
("AAAMouSSE.kext", self.constants.mousse_version, self.constants.mousse_path, lambda: self.model in ModelArray.SSEEmulator), ("AAAMouSSE.kext", self.constants.mousse_version, self.constants.mousse_path, lambda: self.model in ModelArray.SSEEmulator),
("telemetrap.kext", self.constants.telemetrap_version, self.constants.telemetrap_path, lambda: self.model in ModelArray.MissingSSE42), ("telemetrap.kext", self.constants.telemetrap_version, self.constants.telemetrap_path, lambda: self.model in ModelArray.MissingSSE42),
("CPUFriend.kext", self.constants.cpufriend_version, self.constants.cpufriend_path, lambda: self.model not in ["iMac7,1", "Xserve2,1"] and self.constants.allow_oc_everywhere is False and self.constants.disallow_cpufriend is False), (
"CPUFriend.kext",
self.constants.cpufriend_version,
self.constants.cpufriend_path,
lambda: self.model not in ["iMac7,1", "Xserve2,1"] and self.constants.allow_oc_everywhere is False and self.constants.disallow_cpufriend is False,
),
# Ethernet patches # Ethernet patches
("nForceEthernet.kext", self.constants.nforce_version, self.constants.nforce_path, lambda: self.model in ModelArray.EthernetNvidia), ("nForceEthernet.kext", self.constants.nforce_version, self.constants.nforce_path, lambda: self.model in ModelArray.EthernetNvidia),
("MarvelYukonEthernet.kext", self.constants.marvel_version, self.constants.marvel_path, lambda: self.model in ModelArray.EthernetMarvell), ("MarvelYukonEthernet.kext", self.constants.marvel_version, self.constants.marvel_path, lambda: self.model in ModelArray.EthernetMarvell),
@@ -162,87 +180,51 @@ class BuildOpenCore:
if self.constants.allow_oc_everywhere is False: if self.constants.allow_oc_everywhere is False:
self.get_item_by_kv(self.config["Kernel"]["Patch"], "Identifier", "com.apple.driver.AppleSMC")["Enabled"] = True self.get_item_by_kv(self.config["Kernel"]["Patch"], "Identifier", "com.apple.driver.AppleSMC")["Enabled"] = True
if not self.constants.custom_model and (self.constants.allow_oc_everywhere is True or self.model in ModelArray.MacPro71): if not self.constants.custom_model and (self.constants.allow_oc_everywhere is True or self.model in ModelArray.MacPro71):
# Use Innie's same logic: # Use Innie's same logic:
# https://github.com/cdf/Innie/blob/v1.3.0/Innie/Innie.cpp#L90-L97 # https://github.com/cdf/Innie/blob/v1.3.0/Innie/Innie.cpp#L90-L97
storage_devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()) for i, controller in enumerate(self.computer.storage):
storage_devices = [i for i in storage_devices if i["class-code"] == binascii.unhexlify(self.constants.classcode_sata) or i["class-code"] == binascii.unhexlify(self.constants.classcode_nvme)] print(f"- Fixing PCIe Storage Controller ({i + 1}) reporting")
storage_path_gfx: str = subprocess.run([self.constants.gfxutil_path] + f"-v".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode() if controller.pci_path:
try: self.config["DeviceProperties"]["Add"][controller.pci_path] = {"built-in": 1}
x = 1 else:
for i in storage_devices: print(f"- Failed to find Device path for PCIe Storage Controller {i}, falling back to Innie")
storage_vendor = Utilities.hexswap(binascii.hexlify(i["vendor-id"]).decode()[:4]) if self.get_kext_by_bundle_path("Innie.kext")["Enabled"] is False:
storage_device = Utilities.hexswap(binascii.hexlify(i["device-id"]).decode()[:4]) self.enable_kext("Innie.kext", self.constants.innie_version, self.constants.innie_path)
print(f'- Fixing PCIe Storage Controller ({x}) reporting') if not self.computer.storage:
try: print("- No PCIe Storage Controllers found to fix")
storage_path = [line.strip().split("= ", 1)[1] for line in storage_path_gfx.split("\n") if f'{storage_vendor}:{storage_device}'.lower() in line.strip()][0]
self.config["DeviceProperties"]["Add"][storage_path] = { "built-in": 1}
except IndexError:
print(f"- Failed to find Device path for PCIe Storage Controller {x}, falling back to Innie")
if self.get_kext_by_bundle_path("Innie.kext")["Enabled"] is False:
self.enable_kext("Innie.kext", self.constants.innie_version, self.constants.innie_path)
x = x + 1
except ValueError:
print("- No PCIe Storage Controllers found to fix(V)")
except IndexError:
print("- No PCIe Storage Controllers found to fix(I)")
if not self.constants.custom_model: if not self.constants.custom_model:
nvme_devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()) nvme_devices = [i for i in self.computer.storage if isinstance(i, device_probe.NVMeController)]
nvme_devices = [i for i in nvme_devices if i.get("IORegistryEntryChildren", None) and i["vendor-id"] != binascii.unhexlify("6B100000") and i["IORegistryEntryChildren"][0]["IORegistryEntryName"] == "IONVMeController"] for i, controller in enumerate(nvme_devices):
try: print(f"- Found 3rd Party NVMe SSD ({i + 1}): {Utilities.friendly_hex(controller.vendor_id)}:{Utilities.friendly_hex(controller.device_id)}")
x = 1 self.config["#Revision"][f"Hardware-NVMe-{i}"] = f"{Utilities.friendly_hex(controller.vendor_id)}:{Utilities.friendly_hex(controller.device_id)}"
for i in nvme_devices:
nvme_vendor = Utilities.hexswap(binascii.hexlify(i["vendor-id"]).decode()[:4]) # Disable Bit 0 (L0s), enable Bit 1 (L1)
nvme_device = Utilities.hexswap(binascii.hexlify(i["device-id"]).decode()[:4]) nvme_aspm = (controller.aspm & (~3)) | 2
print(f'- Found 3rd Party NVMe SSD ({x}): {nvme_vendor}:{nvme_device}')
nvme_aspm = i["pci-aspm-default"] if controller.pci_path:
try: print(f"- Found NVMe ({i}) at {controller.pci_path}")
nvme_acpi = i["acpi-path"] self.config["DeviceProperties"]["Add"][controller.pci_path]["pci-aspm-default"] = nvme_aspm
nvme_acpi = DeviceProbe.pci_probe().acpi_strip(nvme_acpi) self.config["DeviceProperties"]["Add"][controller.pci_path.rpartition("/")[0]] = {"pci-aspm-default": nvme_aspm}
except KeyError: else:
print(f"- No ACPI entry found for NVMe SSD ({x})") if "-nvmefaspm" not in self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"]:
nvme_acpi = "" print("- Falling back to -nvmefaspm")
# Disable Bit 0 (L0s), enable Bit 1 (L1) self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " -nvmefaspm"
if not isinstance(nvme_aspm, int):
nvme_aspm = int.from_bytes(nvme_aspm, byteorder='little') if self.get_kext_by_bundle_path("NVMeFix.kext")["Enabled"] is False:
nvme_aspm = (nvme_aspm & (~3)) | 2 self.enable_kext("NVMeFix.kext", self.constants.nvmefix_version, self.constants.nvmefix_path)
#nvme_aspm &= ~1 # Turn off bit 1
#nvme_aspm |= 2 # Turn on bit 2 if not nvme_devices:
self.config["#Revision"][f"Hardware-NVMe-{x}"] = f'{nvme_vendor}:{nvme_device}' print("- No 3rd Party NVMe drives found")
try:
nvme_path = DeviceProbe.pci_probe().deviceproperty_probe(nvme_vendor, nvme_device, nvme_acpi)
if nvme_path == "":
raise IndexError
nvme_path_parent = DeviceProbe.pci_probe().device_property_parent(nvme_path)
print(f"- Found NVMe ({x}) at {nvme_path}")
self.config["DeviceProperties"]["Add"][nvme_path] = {"pci-aspm-default": nvme_aspm, "built-in": 1}
self.config["DeviceProperties"]["Add"][nvme_path_parent] = {"pci-aspm-default": nvme_aspm}
except IndexError:
if "-nvmefaspm" not in self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"]:
print("- Falling back to -nvmefaspm")
self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " -nvmefaspm"
if self.get_kext_by_bundle_path("NVMeFix.kext")["Enabled"] is False:
self.enable_kext("NVMeFix.kext", self.constants.nvmefix_version, self.constants.nvmefix_path)
x = x + 1
except ValueError:
print("- No 3rd Party NVMe drive found(V)")
except IndexError:
print("- No 3rd Party NVMe drive found(I)")
def wifi_fake_id(self): def wifi_fake_id(self):
default_path = True
self.enable_kext("AirportBrcmFixup.kext", self.constants.airportbcrmfixup_version, self.constants.airportbcrmfixup_path) self.enable_kext("AirportBrcmFixup.kext", self.constants.airportbcrmfixup_version, self.constants.airportbcrmfixup_path)
#self.get_kext_by_bundle_path("AirportBrcmFixup.kext/Contents/PlugIns/AirPortBrcmNIC_Injector.kext")["Enabled"] = True # self.get_kext_by_bundle_path("AirportBrcmFixup.kext/Contents/PlugIns/AirPortBrcmNIC_Injector.kext")["Enabled"] = True
if not self.constants.custom_model: if not self.constants.custom_model and self.computer.wifi and self.computer.wifi.pci_path:
arpt_path = DeviceProbe.pci_probe().deviceproperty_probe(wifi_vendor, wifi_device, wifi_acpi) arpt_path = self.computer.wifi.pci_path
if arpt_path: print(f"- Found ARPT device at {arpt_path}")
print(f"- Found ARPT device at {arpt_path}") else:
default_path = False
else:
default_path = True
if default_path is True:
if self.model in ModelArray.nvidiaHDEF: if self.model in ModelArray.nvidiaHDEF:
# Nvidia chipsets all have the same path to ARPT # Nvidia chipsets all have the same path to ARPT
arpt_path = "PciRoot(0x0)/Pci(0x15,0x0)/Pci(0x0,0x0)" arpt_path = "PciRoot(0x0)/Pci(0x15,0x0)/Pci(0x0,0x0)"
@@ -263,30 +245,29 @@ class BuildOpenCore:
# WiFi patches # WiFi patches
# TODO: -a is not supported in Lion and older, need to add proper fix # TODO: -a is not supported in Lion and older, need to add proper fix
if self.constants.detected_os > self.constants.lion and not self.constants.custom_model: if self.constants.detected_os > self.constants.lion and not self.constants.custom_model:
wifi_vendor,wifi_device,wifi_ioname,wifi_acpi = DeviceProbe.pci_probe().wifi_probe() if self.computer.wifi:
if wifi_vendor: print(f"- Found Wireless Device {Utilities.friendly_hex(self.computer.wifi.vendor_id)}:{Utilities.friendly_hex(self.computer.wifi.device_id)}")
print(f"- Found Wireless Device {wifi_vendor}:{wifi_device} ({wifi_ioname})") self.config["#Revision"]["Hardware-Wifi"] = f"{Utilities.friendly_hex(self.computer.wifi.vendor_id)}:{Utilities.friendly_hex(self.computer.wifi.device_id)}"
self.config["#Revision"]["Hardware-Wifi"] = f"{wifi_vendor}:{wifi_device} ({wifi_ioname})"
else: else:
wifi_vendor = ""
print("- Unable to run Wireless hardware detection") print("- Unable to run Wireless hardware detection")
if self.constants.wifi_build is True: if self.constants.wifi_build is True:
print("- Skipping Wifi patches on request") print("- Skipping Wifi patches on request")
elif not self.constants.custom_model and wifi_vendor: elif not self.constants.custom_model and self.computer.wifi:
if wifi_vendor == self.constants.pci_broadcom: if isinstance(self.computer.wifi, device_probe.Broadcom):
# This works around OCLP spoofing the Wifi card and therefore unable to actually detect the correct device # This works around OCLP spoofing the Wifi card and therefore unable to actually detect the correct device
if wifi_device in PCIIDArray.broadcom_ids().AirPortBrcmNIC and wifi_ioname not in ["pci14e4,4353", "pci14e4,4331"]: if self.computer.wifi.chipset == device_probe.Broadcom.Chipsets.AirportBrcmNIC:
self.enable_kext("AirportBrcmFixup.kext", self.constants.airportbcrmfixup_version, self.constants.airportbcrmfixup_path) self.enable_kext("AirportBrcmFixup.kext", self.constants.airportbcrmfixup_version, self.constants.airportbcrmfixup_path)
elif wifi_ioname in ["pci14e4,4353", "pci14e4,4331"] or wifi_device in PCIIDArray.broadcom_ids().AirPortBrcm4360: elif self.computer.wifi.chipset == device_probe.Broadcom.Chipsets.AirPortBrcm4360:
wifi_fake_id(self) wifi_fake_id(self)
elif wifi_device in PCIIDArray.broadcom_ids().AirPortBrcm4331: elif self.computer.wifi.chipset == device_probe.Broadcom.Chipsets.AirPortBrcm4331:
self.enable_kext("IO80211Mojave.kext", self.constants.io80211mojave_version, self.constants.io80211mojave_path) self.enable_kext("IO80211Mojave.kext", self.constants.io80211mojave_version, self.constants.io80211mojave_path)
self.get_kext_by_bundle_path("IO80211Mojave.kext/Contents/PlugIns/AirPortBrcm4331.kext")["Enabled"] = True self.get_kext_by_bundle_path("IO80211Mojave.kext/Contents/PlugIns/AirPortBrcm4331.kext")["Enabled"] = True
elif wifi_device in PCIIDArray.broadcom_ids().AppleAirPortBrcm43224: elif self.computer.wifi.chipset == device_probe.Broadcom.Chipsets.AirPortBrcm43224:
self.enable_kext("corecaptureElCap.kext", self.constants.corecaptureelcap_version, self.constants.corecaptureelcap_path) self.enable_kext("corecaptureElCap.kext", self.constants.corecaptureelcap_version, self.constants.corecaptureelcap_path)
self.enable_kext("IO80211ElCap.kext", self.constants.io80211elcap_version, self.constants.io80211elcap_path) self.enable_kext("IO80211ElCap.kext", self.constants.io80211elcap_version, self.constants.io80211elcap_path)
self.get_kext_by_bundle_path("IO80211ElCap.kext/Contents/PlugIns/AppleAirPortBrcm43224.kext")["Enabled"] = True self.get_kext_by_bundle_path("IO80211ElCap.kext/Contents/PlugIns/AppleAirPortBrcm43224.kext")["Enabled"] = True
elif wifi_vendor == self.constants.pci_atheros and wifi_device in PCIIDArray.atheros_ids().AtherosWifi: elif isinstance(self.computer.wifi, device_probe.Atheros) and self.computer.wifi.chipset == device_probe.Atheros.Chipsets.AirPortAtheros40:
self.enable_kext("IO80211HighSierra.kext", self.constants.io80211high_sierra_version, self.constants.io80211high_sierra_path) self.enable_kext("IO80211HighSierra.kext", self.constants.io80211high_sierra_version, self.constants.io80211high_sierra_path)
self.get_kext_by_bundle_path("IO80211HighSierra.kext/Contents/PlugIns/AirPortAtheros40.kext")["Enabled"] = True self.get_kext_by_bundle_path("IO80211HighSierra.kext/Contents/PlugIns/AirPortAtheros40.kext")["Enabled"] = True
else: else:
@@ -335,13 +316,12 @@ class BuildOpenCore:
usb_map_path = Path(self.constants.plist_folder_path) / Path("AppleUSBMaps/Info.plist") usb_map_path = Path(self.constants.plist_folder_path) / Path("AppleUSBMaps/Info.plist")
# iMac7,1 kernel panics with USB map installed, remove for time being until properly debugged # iMac7,1 kernel panics with USB map installed, remove for time being until properly debugged
if usb_map_path.exists() and self.constants.allow_oc_everywhere is False and self.model not in ["iMac7,1", "Xserve2,1"]: if usb_map_path.exists() and self.constants.allow_oc_everywhere is False and self.model not in ["iMac7,1", "Xserve2,1"]:
print(f"- Adding USB-Map.kext") print("- Adding USB-Map.kext")
Path(self.constants.map_kext_folder).mkdir() Path(self.constants.map_kext_folder).mkdir()
Path(self.constants.map_contents_folder).mkdir() Path(self.constants.map_contents_folder).mkdir()
shutil.copy(usb_map_path, self.constants.map_contents_folder) shutil.copy(usb_map_path, self.constants.map_contents_folder)
self.get_kext_by_bundle_path("USB-Map.kext")["Enabled"] = True self.get_kext_by_bundle_path("USB-Map.kext")["Enabled"] = True
if self.constants.allow_oc_everywhere is False: if self.constants.allow_oc_everywhere is False:
if self.model == "MacBookPro9,1": if self.model == "MacBookPro9,1":
print("- Adding AppleMuxControl Override") print("- Adding AppleMuxControl Override")
@@ -371,28 +351,33 @@ class BuildOpenCore:
# AGPM Patch # AGPM Patch
if self.model in ModelArray.DualGPUPatch: if self.model in ModelArray.DualGPUPatch:
print("- Adding dual GPU patch") print("- Adding dual GPU patch")
if not self.constants.custom_model: if not self.constants.custom_model and self.computer.dgpu and self.computer.dgpu.pci_path:
dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0") self.gfx0_path = self.computer.dgpi.pci_path
self.gfx0_path = DeviceProbe.pci_probe().deviceproperty_probe(dgpu_vendor,dgpu_device,dgpu_acpi) print(f"- Found GFX0 Device Path: {self.gfx0_path}")
if self.gfx0_path == "":
print("- Failed to find GFX0 Device path, falling back on known logic")
self.gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"
else:
print(f"- Found GFX0 Device Path: {self.gfx0_path}")
else: else:
if not self.constants.custom_model:
print("- Failed to find GFX0 Device path, falling back on known logic")
self.gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)" self.gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"
if self.model in ModelArray.IntelNvidiaDRM and self.constants.drm_support is True: if self.model in ModelArray.IntelNvidiaDRM and self.constants.drm_support is True:
print("- Prioritizing DRM support over Intel QuickSync") print("- Prioritizing DRM support over Intel QuickSync")
self.config["DeviceProperties"]["Add"][self.gfx0_path] = {"agdpmod": "vit9696", "shikigva": 256} self.config["DeviceProperties"]["Add"][self.gfx0_path] = {"agdpmod": "vit9696", "shikigva": 256}
self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {"name": binascii.unhexlify("23646973706C6179"), "IOName": "#display", "class-code": binascii.unhexlify("FFFFFFFF")} self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {
"name": binascii.unhexlify("23646973706C6179"),
"IOName": "#display",
"class-code": binascii.unhexlify("FFFFFFFF"),
}
else: else:
self.config["DeviceProperties"]["Add"][self.gfx0_path] = {"agdpmod": "vit9696"} self.config["DeviceProperties"]["Add"][self.gfx0_path] = {"agdpmod": "vit9696"}
if self.model in ["iMac13,1", "iMac13,2", "iMac13,3"]: if self.model in ["iMac13,1", "iMac13,2", "iMac13,3"]:
dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0") if self.computer.dgpu:
if dgpu_vendor:
print("- Fixing sleep support in macOS 12") print("- Fixing sleep support in macOS 12")
self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {"name": binascii.unhexlify("23646973706C6179"), "IOName": "#display", "class-code": binascii.unhexlify("FFFFFFFF")} self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {
"name": binascii.unhexlify("23646973706C6179"),
"IOName": "#display",
"class-code": binascii.unhexlify("FFFFFFFF"),
}
# Audio Patch # Audio Patch
if self.model in ModelArray.LegacyAudio: if self.model in ModelArray.LegacyAudio:
@@ -400,9 +385,17 @@ class BuildOpenCore:
hdef_path = "PciRoot(0x0)/Pci(0x8,0x0)" if self.model in ModelArray.nvidiaHDEF else "PciRoot(0x0)/Pci(0x1b,0x0)" hdef_path = "PciRoot(0x0)/Pci(0x8,0x0)" if self.model in ModelArray.nvidiaHDEF else "PciRoot(0x0)/Pci(0x1b,0x0)"
# In AppleALC, MacPro3,1's original layout is already in use, forcing layout 13 instead # In AppleALC, MacPro3,1's original layout is already in use, forcing layout 13 instead
if self.model == "MacPro3,1": if self.model == "MacPro3,1":
self.config["DeviceProperties"]["Add"][hdef_path] = {"apple-layout-id": 90, "use-apple-layout-id": 1, "alc-layout-id": 13, } self.config["DeviceProperties"]["Add"][hdef_path] = {
"apple-layout-id": 90,
"use-apple-layout-id": 1,
"alc-layout-id": 13,
}
else: else:
self.config["DeviceProperties"]["Add"][hdef_path] = {"apple-layout-id": 90, "use-apple-layout-id": 1, "use-layout-id": 1, } self.config["DeviceProperties"]["Add"][hdef_path] = {
"apple-layout-id": 90,
"use-apple-layout-id": 1,
"use-layout-id": 1,
}
# Enable FireWire Boot Support # Enable FireWire Boot Support
if self.constants.firewire_boot is True and self.model not in ModelArray.NoFireWireSupport: if self.constants.firewire_boot is True and self.model not in ModelArray.NoFireWireSupport:
@@ -413,44 +406,55 @@ class BuildOpenCore:
self.get_kext_by_bundle_path("IOFireWireFamily.kext/Contents/PlugIns/AppleFWOHCI.kext")["Enabled"] = True self.get_kext_by_bundle_path("IOFireWireFamily.kext/Contents/PlugIns/AppleFWOHCI.kext")["Enabled"] = True
def backlight_path_detection(self): def backlight_path_detection(self):
if not self.constants.custom_model: if not self.constants.custom_model and self.computer.dgpu and self.computer.dgpu.pci_path:
dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0") self.gfx0_path = self.computer.dgpi.pci_path
self.gfx0_path = DeviceProbe.pci_probe().deviceproperty_probe(dgpu_vendor,dgpu_device,dgpu_acpi) print(f"- Found GFX0 Device Path: {self.gfx0_path}")
if self.gfx0_path == "":
print("- Failed to find GFX0 Device path, falling back on known logic")
if self.model in ["iMac11,1", "iMac11,3"]:
self.gfx0_path = "PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"
elif self.model == "iMac10,1":
self.gfx0_path = "PciRoot(0x0)/Pci(0xc,0x0)/Pci(0x0,0x0)"
else:
self.gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"
else:
print(f"- Found GFX0 Device Path: {self.gfx0_path}")
else: else:
if not self.constants.custom_model:
print("- Failed to find GFX0 Device path, falling back on known logic")
if self.model in ["iMac11,1", "iMac11,3"]: if self.model in ["iMac11,1", "iMac11,3"]:
self.gfx0_path = "PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)" self.gfx0_path = "PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"
elif self.model == "iMac10,1": elif self.model == "iMac10,1":
self.gfx0_path = "PciRoot(0x0)/Pci(0xc,0x0)/Pci(0x0,0x0)" self.gfx0_path = "PciRoot(0x0)/Pci(0xc,0x0)/Pci(0x0,0x0)"
else: else:
self.gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)" self.gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"
print(f"- Using known GFX0 path: {self.gfx0_path}")
def nvidia_patch(self, backlight_path): def nvidia_patch(self, backlight_path):
self.constants.custom_mxm_gpu = True self.constants.custom_mxm_gpu = True
if self.model in ["iMac11,1", "iMac11,2", "iMac11,3", "iMac10,1"]: if self.model in ["iMac11,1", "iMac11,2", "iMac11,3", "iMac10,1"]:
print("- Adding Nvidia Brightness Control and DRM patches") print("- Adding Nvidia Brightness Control and DRM patches")
self.config["DeviceProperties"]["Add"][backlight_path] = {"applbkl": binascii.unhexlify("01000000"), "@0,backlight-control": binascii.unhexlify("01000000"), "@0,built-in": binascii.unhexlify("01000000"), "shikigva": 256, "agdpmod": "vit9696"} self.config["DeviceProperties"]["Add"][backlight_path] = {
"applbkl": binascii.unhexlify("01000000"),
"@0,backlight-control": binascii.unhexlify("01000000"),
"@0,built-in": binascii.unhexlify("01000000"),
"shikigva": 256,
"agdpmod": "vit9696",
}
if self.constants.custom_model and self.model == "iMac11,2": if self.constants.custom_model and self.model == "iMac11,2":
# iMac11,2 can have either PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0) or PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0) # iMac11,2 can have either PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0) or PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)
# Set both properties when we cannot run hardware detection # Set both properties when we cannot run hardware detection
self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"] = {"applbkl": binascii.unhexlify("01000000"), "@0,backlight-control": binascii.unhexlify("01000000"), "@0,built-in": binascii.unhexlify("01000000"), "shikigva": 256, "agdpmod": "vit9696"} self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"] = {
"applbkl": binascii.unhexlify("01000000"),
"@0,backlight-control": binascii.unhexlify("01000000"),
"@0,built-in": binascii.unhexlify("01000000"),
"shikigva": 256,
"agdpmod": "vit9696",
}
elif self.model in ["iMac12,1", "iMac12,2"]: elif self.model in ["iMac12,1", "iMac12,2"]:
print("- Adding Nvidia Brightness Control and DRM patches") print("- Adding Nvidia Brightness Control and DRM patches")
self.config["DeviceProperties"]["Add"][backlight_path] = {"applbkl": binascii.unhexlify("01000000"), "@0,backlight-control": binascii.unhexlify("01000000"), "@0,built-in": binascii.unhexlify("01000000"), "shikigva": 256, "agdpmod": "vit9696"} self.config["DeviceProperties"]["Add"][backlight_path] = {
"applbkl": binascii.unhexlify("01000000"),
"@0,backlight-control": binascii.unhexlify("01000000"),
"@0,built-in": binascii.unhexlify("01000000"),
"shikigva": 256,
"agdpmod": "vit9696",
}
print("- Disabling unsupported iGPU") print("- Disabling unsupported iGPU")
self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {"name": binascii.unhexlify("23646973706C6179"), "IOName": "#display", "class-code": binascii.unhexlify("FFFFFFFF")} self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {
"name": binascii.unhexlify("23646973706C6179"),
"IOName": "#display",
"class-code": binascii.unhexlify("FFFFFFFF"),
}
shutil.copy(self.constants.backlight_injector_path, self.constants.kexts_path) shutil.copy(self.constants.backlight_injector_path, self.constants.kexts_path)
self.get_kext_by_bundle_path("BacklightInjector.kext")["Enabled"] = True self.get_kext_by_bundle_path("BacklightInjector.kext")["Enabled"] = True
self.config["UEFI"]["Quirks"]["ForgeUefiSupport"] = True self.config["UEFI"]["Quirks"]["ForgeUefiSupport"] = True
@@ -461,12 +465,16 @@ class BuildOpenCore:
print("- Adding AMD DRM patches") print("- Adding AMD DRM patches")
self.config["DeviceProperties"]["Add"][backlight_path] = {"shikigva": 80, "unfairgva": 1} self.config["DeviceProperties"]["Add"][backlight_path] = {"shikigva": 80, "unfairgva": 1}
if self.constants.custom_model and self.model == "iMac11,2": if self.constants.custom_model and self.model == "iMac11,2":
# iMac11,2 can have either PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0) or PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0) # iMac11,2 can have either PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0) or PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)
# Set both properties when we cannot run hardware detection # Set both properties when we cannot run hardware detection
self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"] = {"shikigva": 80, "unfairgva": 1} self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"] = {"shikigva": 80, "unfairgva": 1}
if self.model in ["iMac12,1", "iMac12,2"]: if self.model in ["iMac12,1", "iMac12,2"]:
print("- Disabling unsupported iGPU") print("- Disabling unsupported iGPU")
self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {"name": binascii.unhexlify("23646973706C6179"), "IOName": "#display", "class-code": binascii.unhexlify("FFFFFFFF")} self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {
"name": binascii.unhexlify("23646973706C6179"),
"IOName": "#display",
"class-code": binascii.unhexlify("FFFFFFFF"),
}
elif self.model == "iMac10,1": elif self.model == "iMac10,1":
self.enable_kext("AAAMouSSE.kext", self.constants.mousse_version, self.constants.mousse_path) self.enable_kext("AAAMouSSE.kext", self.constants.mousse_version, self.constants.mousse_path)
@@ -480,67 +488,60 @@ class BuildOpenCore:
nvidia_patch(self, self.gfx0_path) nvidia_patch(self, self.gfx0_path)
else: else:
print("- Failed to find vendor") print("- Failed to find vendor")
elif not self.constants.custom_model and self.model in ModelArray.LegacyGPU: elif not self.constants.custom_model and self.model in ModelArray.LegacyGPU and self.computer.dgpu:
dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0") print(f"- Detected dGPU: {Utilities.friendly_hex(self.computer.dgpu.vendor_id)}:{Utilities.friendly_hex(self.computer.dgpu.device_id)}")
if dgpu_vendor: if self.computer.dgpu.arch in [
print(f"- Detected dGPU: {dgpu_vendor}:{dgpu_device}") device_probe.AMD.Archs.Legacy_GCN,
if dgpu_vendor == self.constants.pci_amd_ati and (dgpu_device in PCIIDArray.amd_ids().polaris_ids or dgpu_device in PCIIDArray.amd_ids().vega_ids or dgpu_device in PCIIDArray.amd_ids().navi_ids or dgpu_device in PCIIDArray.amd_ids().legacy_gcn_ids): device_probe.AMD.Archs.Polaris,
backlight_path_detection(self) device_probe.AMD.Archs.Vega,
amd_patch(self, self.gfx0_path) device_probe.AMD.Archs.Navi,
elif dgpu_vendor == self.constants.pci_nvidia and dgpu_device in PCIIDArray.nvidia_ids().kepler_ids: ]:
backlight_path_detection(self) backlight_path_detection(self)
nvidia_patch(self, self.gfx0_path) amd_patch(self, self.gfx0_path)
elif self.computer.dgpu.arch == device_probe.NVIDIA.Archs.Kepler:
backlight_path_detection(self)
nvidia_patch(self, self.gfx0_path)
if self.model in ModelArray.MacPro71: if self.model in ModelArray.MacPro71:
if not self.constants.custom_model: if not self.constants.custom_model:
mp_dgpu_devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()) for i, device in enumerate(self.computer.gpus):
mp_dgpu_devices = [i for i in mp_dgpu_devices if i["class-code"] == binascii.unhexlify("00000300") or i["class-code"] == binascii.unhexlify("00800300")] print(f"- Found dGPU ({i + 1}): {Utilities.friendly_hex(device.vendor_id)}:{Utilities.friendly_hex(device.device_id)}")
mp_dgpu_devices_gfx: str = subprocess.run([self.constants.gfxutil_path] + f"-v".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode() self.config["#Revision"][f"Hardware-MacPro-dGPU-{i + 1}"] = f"{Utilities.friendly_hex(device.vendor_id)}:{Utilities.friendly_hex(device.device_id)}"
try:
x = 1
for i in mp_dgpu_devices:
mp_dgpu_vendor = Utilities.hexswap(binascii.hexlify(i["vendor-id"]).decode()[:4])
mp_dgpu_device = Utilities.hexswap(binascii.hexlify(i["device-id"]).decode()[:4])
print(f'- Found dGPU ({x}): {mp_dgpu_vendor}:{mp_dgpu_device}') if device.pci_path:
self.config["#Revision"][f"Hardware-MacPro-dGPU-{x}"] = f'{mp_dgpu_vendor}:{mp_dgpu_device}' print(f"- Found dGPU ({i + 1}) at {device.pci_path}")
if isinstance(device, device_probe.AMD):
print("- Adding Mac Pro, Xserve DRM patches")
self.config["DeviceProperties"]["Add"][device.pci_path] = {"shikigva": 128, "unfairgva": 1, "rebuild-device-tree": 1}
elif isinstance(device, device_probe.NVIDIA):
print("- Enabling Nvidia Output Patch")
self.config["DeviceProperties"]["Add"][device.pci_path] = {"rebuild-device-tree": 1}
self.config["UEFI"]["Quirks"]["ForgeUefiSupport"] = True
self.config["UEFI"]["Quirks"]["ReloadOptionRoms"] = True
try: else:
mp_dgpu_path = [line.strip().split("= ", 1)[1] for line in mp_dgpu_devices_gfx.split("\n") if f'{mp_dgpu_vendor}:{mp_dgpu_device}'.lower() in line.strip()][0] print(f"- Failed to find Device path for dGPU {i + 1}")
print(f"- Found dGPU ({x}) at {mp_dgpu_path}") if isinstance(device, device_probe.AMD):
if mp_dgpu_vendor == self.constants.pci_amd_ati: print("- Adding Mac Pro, Xserve DRM patches")
print("- Adding Mac Pro, Xserve DRM patches") if "shikigva=128 unfairgva=1" not in self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"]:
self.config["DeviceProperties"]["Add"][mp_dgpu_path] = {"shikigva": 128, "unfairgva": 1, "rebuild-device-tree": 1} print("- Falling back to boot-args")
elif mp_dgpu_vendor == self.constants.pci_nvidia: self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " shikigva=128 unfairgva=1" + (" -wegtree" if "-wegtree" not in self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] else "")
print("- Enabling Nvidia Output Patch") elif isinstance(device, device_probe.NVIDIA):
self.config["DeviceProperties"]["Add"][mp_dgpu_path] = {"rebuild-device-tree": 1} print("- Enabling Nvidia Output Patch")
self.config["UEFI"]["Quirks"]["ForgeUefiSupport"] = True if "-wegtree" not in self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"]:
self.config["UEFI"]["Quirks"]["ReloadOptionRoms"] = True print("- Falling back to boot-args")
self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " -wegtree"
self.config["UEFI"]["Quirks"]["ForgeUefiSupport"] = True
self.config["UEFI"]["Quirks"]["ReloadOptionRoms"] = True
except IndexError: if not self.computer.gpus:
print(f"- Failed to find Device path for NVMe {x}")
if mp_dgpu_vendor == self.constants.pci_amd_ati:
print("- Adding Mac Pro, Xserve DRM patches")
if "shikigva=128 unfairgva=1 -wegtree" not in self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"]:
print("- Falling back to boot-args")
self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " shikigva=128 unfairgva=1 -wegtree"
elif mp_dgpu_vendor == self.constants.pci_nvidia:
print("- Enabling Nvidia Output Patch")
if "-wegtree" not in self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"]:
print("- Falling back to boot-args")
self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " -wegtree"
self.config["UEFI"]["Quirks"]["ForgeUefiSupport"] = True
self.config["UEFI"]["Quirks"]["ReloadOptionRoms"] = True
x = x + 1
except ValueError:
print("- No socketed dGPU found")
except IndexError:
print("- No socketed dGPU found") print("- No socketed dGPU found")
else: else:
print("- Adding Mac Pro, Xserve DRM patches") print("- Adding Mac Pro, Xserve DRM patches")
self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " shikigva=128 unfairgva=1 -wegtree" self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " shikigva=128 unfairgva=1 -wegtree"
# Add XhciDxe if firmware doesn't have XHCI controller support and XCHI controller detected # Add XhciDxe if firmware doesn't have XHCI controller support and XCHI controller detected
#if self.model not in ModelArray.XhciSupport and not self.constants.custom_model: # if self.model not in ModelArray.XhciSupport and not self.constants.custom_model:
# devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()) # devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
# try: # try:
# devices = [i for i in devices if i["class-code"] == binascii.unhexlify(self.constants.classcode_xhci)] # devices = [i for i in devices if i["class-code"] == binascii.unhexlify(self.constants.classcode_xhci)]
@@ -587,7 +588,7 @@ class BuildOpenCore:
if self.constants.kext_debug is True: if self.constants.kext_debug is True:
print("- Enabling DEBUG Kexts") print("- Enabling DEBUG Kexts")
self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " -liludbgall" self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " -liludbgall"
#self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " msgbuf=1048576" # self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " msgbuf=1048576"
if self.constants.opencore_debug is True: if self.constants.opencore_debug is True:
print("- Enabling DEBUG OpenCore") print("- Enabling DEBUG OpenCore")
self.config["Misc"]["Debug"]["Target"] = 0x43 self.config["Misc"]["Debug"]["Target"] = 0x43
@@ -651,7 +652,7 @@ class BuildOpenCore:
if self.constants.custom_cpu_model == 0 or self.constants.custom_cpu_model == 1: if self.constants.custom_cpu_model == 0 or self.constants.custom_cpu_model == 1:
self.config["PlatformInfo"]["SMBIOS"]["ProcessorType"] = 1537 self.config["PlatformInfo"]["SMBIOS"]["ProcessorType"] = 1537
if self.model in ModelArray.NoAPFSsupport: if self.model in ModelArray.NoAPFSsupport:
fw_feature,fw_mask = self.fw_feature_detect(self.model) fw_feature, fw_mask = self.fw_feature_detect(self.model)
self.config["PlatformInfo"]["PlatformNVRAM"]["FirmwareFeatures"] = fw_feature self.config["PlatformInfo"]["PlatformNVRAM"]["FirmwareFeatures"] = fw_feature
self.config["PlatformInfo"]["SMBIOS"]["FirmwareFeatures"] = fw_feature self.config["PlatformInfo"]["SMBIOS"]["FirmwareFeatures"] = fw_feature
self.config["PlatformInfo"]["PlatformNVRAM"]["FirmwareFeaturesMask"] = fw_mask self.config["PlatformInfo"]["PlatformNVRAM"]["FirmwareFeaturesMask"] = fw_mask
@@ -739,7 +740,6 @@ class BuildOpenCore:
cpu_config["IOKitPersonalities"]["CPUFriendDataProvider"]["cf-frequency-data"] = string_stuff cpu_config["IOKitPersonalities"]["CPUFriendDataProvider"]["cf-frequency-data"] = string_stuff
plistlib.dump(cpu_config, Path(new_cpu_ls).open("wb"), sort_keys=True) plistlib.dump(cpu_config, Path(new_cpu_ls).open("wb"), sort_keys=True)
if self.constants.allow_oc_everywhere is False: if self.constants.allow_oc_everywhere is False:
if self.model == "MacBookPro9,1": if self.model == "MacBookPro9,1":
new_amc_ls = Path(self.constants.amc_contents_folder) / Path("Info.plist") new_amc_ls = Path(self.constants.amc_contents_folder) / Path("Info.plist")
@@ -754,10 +754,11 @@ class BuildOpenCore:
if self.model in ModelArray.AGDPSupport: if self.model in ModelArray.AGDPSupport:
new_agdp_ls = Path(self.constants.agdp_contents_folder) / Path("Info.plist") new_agdp_ls = Path(self.constants.agdp_contents_folder) / Path("Info.plist")
agdp_config = plistlib.load(Path(new_agdp_ls).open("rb")) agdp_config = plistlib.load(Path(new_agdp_ls).open("rb"))
agdp_config["IOKitPersonalities"]["AppleGraphicsDevicePolicy"]["ConfigMap"][self.spoofed_board] = agdp_config["IOKitPersonalities"]["AppleGraphicsDevicePolicy"]["ConfigMap"].pop(self.model) agdp_config["IOKitPersonalities"]["AppleGraphicsDevicePolicy"]["ConfigMap"][self.spoofed_board] = agdp_config["IOKitPersonalities"]["AppleGraphicsDevicePolicy"]["ConfigMap"].pop(
self.model
)
plistlib.dump(agdp_config, Path(new_agdp_ls).open("wb"), sort_keys=True) plistlib.dump(agdp_config, Path(new_agdp_ls).open("wb"), sort_keys=True)
@staticmethod @staticmethod
def get_item_by_kv(iterable, key, value): def get_item_by_kv(iterable, key, value):
item = None item = None
@@ -819,7 +820,7 @@ class BuildOpenCore:
zip_file.extractall(self.constants.oc_folder) zip_file.extractall(self.constants.oc_folder)
item.unlink() item.unlink()
if self.constants.recovery_status == False: if not self.constants.recovery_status:
# Crashes in RecoveryOS for unknown reason # Crashes in RecoveryOS for unknown reason
for i in self.constants.build_path.rglob("__MACOSX"): for i in self.constants.build_path.rglob("__MACOSX"):
shutil.rmtree(i) shutil.rmtree(i)
@@ -829,7 +830,7 @@ class BuildOpenCore:
def sign_files(self): def sign_files(self):
if self.constants.vault is True: if self.constants.vault is True:
print("- Vaulting EFI") print("- Vaulting EFI")
subprocess.run([self.constants.vault_path] + f"{self.constants.oc_folder}/".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT) subprocess.run([str(self.constants.vault_path), f"{self.constants.oc_folder}/"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
def build_opencore(self): def build_opencore(self):
self.build_efi() self.build_efi()
@@ -919,7 +920,7 @@ Please build OpenCore first!"""
selected_disk["partitions"][partition]["type"] == "Microsoft Basic Data" and selected_disk["partitions"][partition]["size"] < 1024 * 1024 * 512 selected_disk["partitions"][partition]["type"] == "Microsoft Basic Data" and selected_disk["partitions"][partition]["size"] < 1024 * 1024 * 512
): # 512 megabytes: ): # 512 megabytes:
text += " *" text += " *"
menu.add_menu_option(text, key=partition[len(disk_identifier) + 1:]) menu.add_menu_option(text, key=partition[len(disk_identifier) + 1 :])
response = menu.start() response = menu.start()
@@ -936,7 +937,7 @@ Please build OpenCore first!"""
" without altering line endings", " without altering line endings",
] ]
if self.constants.detected_os > self.constants.yosemite and self.constants.recovery_status == False: if self.constants.detected_os >= self.constants.el_capitan and not self.constants.recovery_status:
result = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE) result = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
else: else:
result = subprocess.run(f"diskutil mount {disk_identifier}s{response}".split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE) result = subprocess.run(f"diskutil mount {disk_identifier}s{response}".split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
@@ -996,10 +997,10 @@ Please build OpenCore first!"""
print("- Adding Internal Drive icon") print("- Adding Internal Drive icon")
shutil.copy(self.constants.icon_path_internal, mount_path) shutil.copy(self.constants.icon_path_internal, mount_path)
print("- Cleaning install location") print("- Cleaning install location")
if self.constants.recovery_status == False: if not self.constants.recovery_status:
# RecoveryOS doesn't support dot_clean # RecoveryOS doesn't support dot_clean
# Remove dot_clean, requires full disk access # Remove dot_clean, requires full disk access
#subprocess.run(["dot_clean", mount_path], stdout=subprocess.PIPE).stdout.decode().strip().encode() # subprocess.run(["dot_clean", mount_path], stdout=subprocess.PIPE).stdout.decode().strip().encode()
print("- Unmounting EFI partition") print("- Unmounting EFI partition")
subprocess.run(["diskutil", "umount", mount_path], stdout=subprocess.PIPE).stdout.decode().strip().encode() subprocess.run(["diskutil", "umount", mount_path], stdout=subprocess.PIPE).stdout.decode().strip().encode()
print("- OpenCore transfer complete") print("- OpenCore transfer complete")
Resources/CliMenu.py
+94 -67
View File
@@ -3,7 +3,7 @@
from __future__ import print_function from __future__ import print_function
import subprocess import subprocess
from Resources import ModelArray, Constants, Utilities from Resources import Constants, Utilities
class MenuOptions: class MenuOptions:
@@ -49,7 +49,8 @@ class MenuOptions:
def change_metal(self): def change_metal(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Assume Metal GPU Always in iMac"]) Utilities.header(["Assume Metal GPU Always in iMac"])
print("""This is for iMacs that have upgraded Metal GPUs, otherwise print(
"""This is for iMacs that have upgraded Metal GPUs, otherwise
Patcher assumes based on stock configuration (ie. iMac10,x-12,x) Patcher assumes based on stock configuration (ie. iMac10,x-12,x)
Valid Options: Valid Options:
@@ -60,7 +61,8 @@ Valid Options:
Note: Patcher will detect whether hardware has been upgraded regardless, this Note: Patcher will detect whether hardware has been upgraded regardless, this
option is for those patching on a different machine or OCLP cannot detect. option is for those patching on a different machine or OCLP cannot detect.
""") """
)
change_menu = input("Set GPU Patch type(ie. 1): ") change_menu = input("Set GPU Patch type(ie. 1): ")
if change_menu == "1": if change_menu == "1":
self.constants.metal_build = False self.constants.metal_build = False
@@ -77,11 +79,13 @@ option is for those patching on a different machine or OCLP cannot detect.
def change_wifi(self): def change_wifi(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Assume Upgraded Wifi Always"]) Utilities.header(["Assume Upgraded Wifi Always"])
print("""This is for Macs with upgraded wifi cards(ie. BCM94360/2) print(
"""This is for Macs with upgraded wifi cards(ie. BCM94360/2)
Note: Patcher will detect whether hardware has been upgraded regardless, this Note: Patcher will detect whether hardware has been upgraded regardless, this
option is for those patching on a different machine or cannot detect. option is for those patching on a different machine or cannot detect.
""") """
)
change_menu = input("Enable Upgraded Wifi build algorithm?(y/n): ") change_menu = input("Enable Upgraded Wifi build algorithm?(y/n): ")
if change_menu in {"y", "Y", "yes", "Yes"}: if change_menu in {"y", "Y", "yes", "Yes"}:
self.constants.wifi_build = True self.constants.wifi_build = True
@@ -93,7 +97,8 @@ option is for those patching on a different machine or cannot detect.
def change_serial(self): def change_serial(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Set SMBIOS Mode"]) Utilities.header(["Set SMBIOS Mode"])
print("""This section is for setting how OpenCore generates the SMBIOS print(
"""This section is for setting how OpenCore generates the SMBIOS
Recommended for adanced users who want control how serials are handled Recommended for adanced users who want control how serials are handled
Valid options: Valid options:
@@ -103,7 +108,8 @@ Valid options:
3. Advanced:\tReplace entire SMBIOS and generate new serials 3. Advanced:\tReplace entire SMBIOS and generate new serials
Note: For new users we recommend leaving as default(1. Minimal) Note: For new users we recommend leaving as default(1. Minimal)
""") """
)
change_menu = input("Set SMBIOS Mode(ie. 1): ") change_menu = input("Set SMBIOS Mode(ie. 1): ")
if change_menu == "1": if change_menu == "1":
self.constants.serial_settings = "Minimal" self.constants.serial_settings = "Minimal"
@@ -117,10 +123,12 @@ Note: For new users we recommend leaving as default(1. Minimal)
def change_showpicker(self): def change_showpicker(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Set OpenCore Picker mode"]) Utilities.header(["Set OpenCore Picker mode"])
print("""By default, OpenCore will show its boot picker each time on boot up, print(
"""By default, OpenCore will show its boot picker each time on boot up,
however this can be disabled by default and be shown on command by repeatedly however this can be disabled by default and be shown on command by repeatedly
pressing the "Esc" key pressing the "Esc" key
""") """
)
change_menu = input("Show OpenCore Picker by default(y/n): ") change_menu = input("Show OpenCore Picker by default(y/n): ")
if change_menu in {"y", "Y", "yes", "Yes"}: if change_menu in {"y", "Y", "yes", "Yes"}:
self.constants.showpicker = True self.constants.showpicker = True
@@ -132,13 +140,15 @@ pressing the "Esc" key
def change_vault(self): def change_vault(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Set OpenCore Vaulting"]) Utilities.header(["Set OpenCore Vaulting"])
print("""By default, this patcher will sign all your files and ensure none of the print(
"""By default, this patcher will sign all your files and ensure none of the
contents can be tampered with. However for more advanced users, you may contents can be tampered with. However for more advanced users, you may
want to be able to freely edit the config.plist and files. want to be able to freely edit the config.plist and files.
Note: For security reasons, OpenShell will be disabled when Vault is set. Note: For security reasons, OpenShell will be disabled when Vault is set.
""") """
)
change_menu = input("Enable Vault(y/n): ") change_menu = input("Enable Vault(y/n): ")
if change_menu in {"y", "Y", "yes", "Yes"}: if change_menu in {"y", "Y", "yes", "Yes"}:
self.constants.vault = True self.constants.vault = True
@@ -150,7 +160,8 @@ Note: For security reasons, OpenShell will be disabled when Vault is set.
def change_sip(self): def change_sip(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Set SIP and SecureBootModel"]) Utilities.header(["Set SIP and SecureBootModel"])
print("""SIP and SecureBootModel are used to ensure proper OTA functionality, print(
"""SIP and SecureBootModel are used to ensure proper OTA functionality,
however to patch the root volume both of these must be disabled. however to patch the root volume both of these must be disabled.
Only disable is absolutely necessary. SIP value = 0xFEF Only disable is absolutely necessary. SIP value = 0xFEF
@@ -161,7 +172,8 @@ Valid options:
3. Disable SecureBootModel Only 3. Disable SecureBootModel Only
4. Disable Both 4. Disable Both
""") """
)
change_menu = input("Set SIP and SecureBootModel(ie. 1): ") change_menu = input("Set SIP and SecureBootModel(ie. 1): ")
if change_menu == "1": if change_menu == "1":
self.constants.sip_status = True self.constants.sip_status = True
@@ -181,10 +193,12 @@ Valid options:
def set_amfi(self): def set_amfi(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Disable AMFI"]) Utilities.header(["Disable AMFI"])
print("""Required for Root Patching non-Metal GPUs print(
"""Required for Root Patching non-Metal GPUs
in macOS Big Sur. Without this, will receive kernel panic once in macOS Big Sur. Without this, will receive kernel panic once
Patcher finishes installing legacy acceleration patches. Patcher finishes installing legacy acceleration patches.
""") """
)
change_menu = input("Disable AMFI(y/n): ") change_menu = input("Disable AMFI(y/n): ")
if change_menu in {"y", "Y", "yes", "Yes"}: if change_menu in {"y", "Y", "yes", "Yes"}:
self.constants.disable_amfi = True self.constants.disable_amfi = True
@@ -193,25 +207,11 @@ Patcher finishes installing legacy acceleration patches.
else: else:
print("Invalid option") print("Invalid option")
def change_imac_nvidia(self):
Utilities.cls()
Utilities.header(["Assume Metal GPU Always"])
print("""Specifically for iMac10,x-12,x with Metal Nvidia GPU upgrades
By default the patcher will try to detect what hardware is
running, however this will enforce iMac Nvidia Build Patches.
""")
change_menu = input("Assume iMac Nvidia patches(y/n): ")
if change_menu in {"y", "Y", "yes", "Yes"}:
self.constants.imac_nvidia_build = True
elif change_menu in {"n", "N", "no", "No"}:
self.constants.imac_nvidia_build = False
else:
print("Invalid option")
def bootstrap_setting(self): def bootstrap_setting(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Set Bootstrap method"]) Utilities.header(["Set Bootstrap method"])
print("""Sets OpenCore's bootstrap method, currently the patcher supports the print(
"""Sets OpenCore's bootstrap method, currently the patcher supports the
following options. following options.
Valid options: Valid options:
@@ -226,7 +226,8 @@ and not to macOS itself.
Recommended to set to BOOTx64.efi in situations where your Mac cannot Recommended to set to BOOTx64.efi in situations where your Mac cannot
see the EFI Boot entry in the boot picker. see the EFI Boot entry in the boot picker.
""") """
)
change_menu = input("Set Bootstrap method: ") change_menu = input("Set Bootstrap method: ")
if change_menu == "1": if change_menu == "1":
self.constants.boot_efi = False self.constants.boot_efi = False
@@ -235,11 +236,11 @@ see the EFI Boot entry in the boot picker.
else: else:
print("Invalid option") print("Invalid option")
def drm_setting(self): def drm_setting(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Set DRM preferences"]) Utilities.header(["Set DRM preferences"])
print("""Sets OpenCore's DRM preferences for iMac13,x and iMac14,x. print(
"""Sets OpenCore's DRM preferences for iMac13,x and iMac14,x.
In Big Sur, some DRM based content may be broken by In Big Sur, some DRM based content may be broken by
default in AppleTV, Photobooth, etc. default in AppleTV, Photobooth, etc.
@@ -249,7 +250,8 @@ greatly hampers Video rendering performance in Final Cut Pro and
other programs relying on such features. other programs relying on such features.
Recommend only disabling if absolutely required. Recommend only disabling if absolutely required.
""") """
)
change_menu = input("Enable Nvidia's Software DRM rendering(y/n): ") change_menu = input("Enable Nvidia's Software DRM rendering(y/n): ")
if change_menu in {"y", "Y", "yes", "Yes"}: if change_menu in {"y", "Y", "yes", "Yes"}:
self.constants.drm_support = True self.constants.drm_support = True
@@ -261,11 +263,13 @@ Recommend only disabling if absolutely required.
def force_accel_setting(self): def force_accel_setting(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Assume Legacy GPU"]) Utilities.header(["Assume Legacy GPU"])
print("""Allows any model to force install Legacy Acceleration print(
"""Allows any model to force install Legacy Acceleration
patches. Only required for Mac Pro and Xserve users. patches. Only required for Mac Pro and Xserve users.
DO NOT RUN IF METAL GPU IS INSTALLED DO NOT RUN IF METAL GPU IS INSTALLED
""") """
)
change_menu = input("Enable Beta Acceleration Patches(y/n): ") change_menu = input("Enable Beta Acceleration Patches(y/n): ")
if change_menu in {"y", "Y", "yes", "Yes"}: if change_menu in {"y", "Y", "yes", "Yes"}:
self.constants.assume_legacy = True self.constants.assume_legacy = True
@@ -277,11 +281,13 @@ DO NOT RUN IF METAL GPU IS INSTALLED
def allow_native_models(self): def allow_native_models(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Allow OpenCore on native Models"]) Utilities.header(["Allow OpenCore on native Models"])
print("""Allows natively supported Macs to use OpenCore. Recommended print(
"""Allows natively supported Macs to use OpenCore. Recommended
for users with 3rd Party NVMe SSDs to achieve improved overall for users with 3rd Party NVMe SSDs to achieve improved overall
power usage. power usage.
""") """
)
change_menu = input("Allow OpenCore on all Models(y/n): ") change_menu = input("Allow OpenCore on all Models(y/n): ")
if change_menu in {"y", "Y", "yes", "Yes"}: if change_menu in {"y", "Y", "yes", "Yes"}:
self.constants.allow_oc_everywhere = True self.constants.allow_oc_everywhere = True
@@ -295,13 +301,15 @@ power usage.
def custom_cpu(self): def custom_cpu(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Set custom CPU Model Name"]) Utilities.header(["Set custom CPU Model Name"])
print("""Change reported CPU Model name in About This Mac print(
"""Change reported CPU Model name in About This Mac
Custom names will report as follows: Custom names will report as follows:
1: Original Name: 2.5 Ghz Dual-Core Intel Core i5 1: Original Name: 2.5 Ghz Dual-Core Intel Core i5
2. CPU name: Intel(R) Core(TM) i5-3210M CPU @ 2.50Ghz 2. CPU name: Intel(R) Core(TM) i5-3210M CPU @ 2.50Ghz
3. Custom Name: 2.5Ghz Cotton Candy (example) 3. Custom Name: 2.5Ghz Cotton Candy (example)
""") """
)
if self.constants.custom_cpu_model_value == "": if self.constants.custom_cpu_model_value == "":
if self.constants.custom_cpu_model == 0: if self.constants.custom_cpu_model == 0:
print("Currently using original name") print("Currently using original name")
@@ -325,19 +333,21 @@ Custom names will report as follows:
def custom_color_thing(self): def custom_color_thing(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Set custom CPU Model Name"]) Utilities.header(["Set custom CPU Model Name"])
print("""Change reported CPU Model name in About This Mac print(
"""Change reported CPU Model name in About This Mac
Custom names will report as follows: Custom names will report as follows:
1: Custom Color 1: Custom Color
2. Reset 2. Reset
""") """
)
change_menu = input("Set custom CPU Name(1,2,3): ") change_menu = input("Set custom CPU Name(1,2,3): ")
if change_menu == "1": if change_menu == "1":
print("") print("")
#temp_tk_root = tk.Tk() # temp_tk_root = tk.Tk()
#temp_tk_root.wm_withdraw() # temp_tk_root.wm_withdraw()
#self.constants.custom_color = colorchooser.askcolor(title="Choose color") # self.constants.custom_color = colorchooser.askcolor(title="Choose color")
#temp_tk_root.destroy() # temp_tk_root.destroy()
elif change_menu == "2": elif change_menu == "2":
self.constants.custom_color = "" self.constants.custom_color = ""
else: else:
@@ -346,9 +356,11 @@ Custom names will report as follows:
def download_more_ram_dot_com(self): def download_more_ram_dot_com(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Download more RAM"]) Utilities.header(["Download more RAM"])
print("""Downloads more RAM to your Mac! print(
"""Downloads more RAM to your Mac!
Currently only offers 1.5TB bundles Currently only offers 1.5TB bundles
""") """
)
change_menu = input("Download more RAM?(y/n): ") change_menu = input("Download more RAM?(y/n): ")
if change_menu == "y": if change_menu == "y":
self.constants.download_ram = True self.constants.download_ram = True
@@ -360,11 +372,13 @@ Currently only offers 1.5TB bundles
def disable_cpufriend(self): def disable_cpufriend(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Disable CPU Friend?"]) Utilities.header(["Disable CPU Friend?"])
print("""Only recommended for advanced users print(
"""Only recommended for advanced users
Disabling CPUFriend forces macOS into using a different Disabling CPUFriend forces macOS into using a different
Mac's power profile for CPUs and GPUs, which can harm the Mac's power profile for CPUs and GPUs, which can harm the
hardware hardware
""") """
)
change_menu = input("Disable CPU Friend?(y/n): ") change_menu = input("Disable CPU Friend?(y/n): ")
if change_menu == "y": if change_menu == "y":
self.constants.disallow_cpufriend = True self.constants.disallow_cpufriend = True
@@ -376,24 +390,30 @@ hardware
def set_seedutil(self): def set_seedutil(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Set SeedUtil Status"]) Utilities.header(["Set SeedUtil Status"])
print("""Used for setting OS Update Preferences print(
"""Used for setting OS Update Preferences
Valid options: Valid options:
1. Public Release Seed (Default) 1. Public Release Seed (Default)
2. Public Beta Seed 2. Public Beta Seed
3. Developer Beta Seed 3. Developer Beta Seed
4. Check SeedUtil's current status 4. Check SeedUtil's current status
""") """
)
change_menu = input("Set update status(Press [ENTER] to exit): ") change_menu = input("Set update status(Press [ENTER] to exit): ")
if change_menu == "1": if change_menu == "1":
subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "unenroll"], stdout=subprocess.PIPE).stdout.decode().strip().encode() subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "unenroll"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
elif change_menu == "2": elif change_menu == "2":
subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "unenroll"], stdout=subprocess.PIPE).stdout.decode().strip().encode() subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "unenroll"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "enroll", "PublicSeed"], stdout=subprocess.PIPE).stdout.decode().strip().encode() subprocess.run(
["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "enroll", "PublicSeed"], stdout=subprocess.PIPE
).stdout.decode().strip().encode()
elif change_menu == "3": elif change_menu == "3":
subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "unenroll"], stdout=subprocess.PIPE).stdout.decode().strip().encode() subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "unenroll"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "enroll", "DeveloperSeed"], stdout=subprocess.PIPE).stdout.decode().strip().encode() subprocess.run(
["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "enroll", "DeveloperSeed"], stdout=subprocess.PIPE
).stdout.decode().strip().encode()
elif change_menu == "4": elif change_menu == "4":
result = subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "current"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) result = subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "current"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
result = [i.partition(":")[2] for i in result.stdout.decode().split("\n") if "Currently enrolled in" in i][0] result = [i.partition(":")[2] for i in result.stdout.decode().split("\n") if "Currently enrolled in" in i][0]
@@ -406,13 +426,15 @@ Valid options:
def set_smbios(self): def set_smbios(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Override SMBIOS Spoof"]) Utilities.header(["Override SMBIOS Spoof"])
print("""Change model OpenCore spoofs Mac too print(
"""Change model OpenCore spoofs Mac too
Valid options: Valid options:
1. Default set by OpenCore (Default) 1. Default set by OpenCore (Default)
2. User Override 2. User Override
3. Disable all spoofing (unsupported configuration) 3. Disable all spoofing (unsupported configuration)
""") """
)
change_menu = input("Set SMBIOS status: ") change_menu = input("Set SMBIOS status: ")
if change_menu == "1": if change_menu == "1":
@@ -435,7 +457,8 @@ Valid options:
def allow_firewire(self): def allow_firewire(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Allow FireWire Boot Support"]) Utilities.header(["Allow FireWire Boot Support"])
print(""" print(
"""
In macOS Catalina and newer, Apple restricted In macOS Catalina and newer, Apple restricted
usage of FireWire devices to boot macOS for usage of FireWire devices to boot macOS for
security concerns relating to DMA access. security concerns relating to DMA access.
@@ -445,7 +468,8 @@ you can re-enable FireWire support for Catalina
and newer. and newer.
Note: MacBook5,x-7,1 don't support FireWire boot Note: MacBook5,x-7,1 don't support FireWire boot
""") """
)
change_menu = input("Enable FireWire Boot support?(y/n): ") change_menu = input("Enable FireWire Boot support?(y/n): ")
if change_menu == "y": if change_menu == "y":
@@ -458,7 +482,8 @@ Note: MacBook5,x-7,1 don't support FireWire boot
def allow_nvme(self): def allow_nvme(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Allow NVMe UEFI Support"]) Utilities.header(["Allow NVMe UEFI Support"])
print(""" print(
"""
For machines not natively supporting NVMe, For machines not natively supporting NVMe,
this option allows you to see and boot NVMe this option allows you to see and boot NVMe
drive in OpenCore's picker drive in OpenCore's picker
@@ -468,7 +493,8 @@ Not required if your machine natively supports NVMe
Note: You must have OpenCore on a bootable volume Note: You must have OpenCore on a bootable volume
first, ie. USB or SATA drive. Once loaded, first, ie. USB or SATA drive. Once loaded,
OpenCore will enable NVMe support in it's picker OpenCore will enable NVMe support in it's picker
""") """
)
change_menu = input("Enable NVMe Boot support?(y/n): ") change_menu = input("Enable NVMe Boot support?(y/n): ")
if change_menu == "y": if change_menu == "y":
@@ -478,11 +504,11 @@ OpenCore will enable NVMe support in it's picker
else: else:
print("Invalid option") print("Invalid option")
def enable_terascale(self): def enable_terascale(self):
Utilities.cls() Utilities.cls()
Utilities.header(["Enable TeraScale 2 Acceleration"]) Utilities.header(["Enable TeraScale 2 Acceleration"])
print(""" print(
"""
Currently TeraScale 2 graphics acceleration is in beta with Currently TeraScale 2 graphics acceleration is in beta with
some unfortunate bugs on login including strobing colours some unfortunate bugs on login including strobing colours
until the user forces Million Colours on the Display with until the user forces Million Colours on the Display with
@@ -493,12 +519,13 @@ patches or ask someone to handle inital setup to ensure
no issues no issues
Note: Acceleration only applies to macOS Big Sur Note: Acceleration only applies to macOS Big Sur
""") """
)
change_menu = input("Enable TS2 Acceleration?(y/n): ") change_menu = input("Enable TS2 Acceleration?(y/n): ")
if change_menu == "y": if change_menu == "y":
self.constants.terscale_2_patch = True self.constants.terascale_2_patch = True
elif change_menu == "n": elif change_menu == "n":
self.constants.terscale_2_patch = False self.constants.terascale_2_patch = False
else: else:
print("Invalid option") print("Invalid option")
Resources/Constants.py
+324 -133
View File
@@ -5,6 +5,9 @@
from __future__ import print_function from __future__ import print_function
from pathlib import Path from pathlib import Path
from typing import Optional
from Resources import device_probe
class Constants: class Constants:
@@ -41,16 +44,17 @@ class Constants:
self.debugenhancer_version = "1.0.3" self.debugenhancer_version = "1.0.3"
self.innie_version = "1.3.0" self.innie_version = "1.3.0"
self.fw_kext = "1.0.0" self.fw_kext = "1.0.0"
self.payload_version = "0.0.18" # Apple-Binaries-OCLP self.payload_version = "0.0.18" # Apple-Binaries-OCLP
# Get resource path # Get resource path
self.current_path = Path(__file__).parent.parent.resolve() self.current_path = Path(__file__).parent.parent.resolve()
self.payload_path = self.current_path / Path("payloads") self.payload_path = self.current_path / Path("payloads")
self.custom_model: str = None # Hardware
self.custom_mxm_gpu: str = None self.computer: device_probe.Computer = None # type: ignore
self.current_gpuv: str = None
self.current_gpud: str = None self.custom_model: Optional[str] = None
self.custom_mxm_gpu: bool = False
# Patcher Settings # Patcher Settings
self.opencore_debug = False self.opencore_debug = False
@@ -86,7 +90,7 @@ class Constants:
self.firewire_boot = False self.firewire_boot = False
self.nvme_boot = False self.nvme_boot = False
self.disable_amfi = False self.disable_amfi = False
self.terscale_2_patch = False self.terascale_2_patch = False
# OS Versions # OS Versions
self.tiger = 8 self.tiger = 8
@@ -133,252 +137,440 @@ class Constants:
# Payload Location # Payload Location
# OpenCore # OpenCore
@property @property
def opencore_zip_source(self): return self.payload_path / Path(f"OpenCore/OpenCore-{self.opencore_build}.zip") def opencore_zip_source(self):
return self.payload_path / Path(f"OpenCore/OpenCore-{self.opencore_build}.zip")
@property @property
def plist_template(self): return self.payload_path / Path(f"Config/config.plist") def plist_template(self):
return self.payload_path / Path("Config/config.plist")
# Mount Location # Mount Location
@property @property
def payload_mnt1_path(self): return self.payload_path / Path("mnt1") def payload_mnt1_path(self):
return self.payload_path / Path("mnt1")
# ACPI # ACPI
@property @property
def pci_ssdt_path(self): return self.payload_path / Path("ACPI/SSDT-CPBG.aml") def pci_ssdt_path(self):
return self.payload_path / Path("ACPI/SSDT-CPBG.aml")
@property @property
def windows_ssdt_path(self): return self.payload_path / Path("ACPI/SSDT-PCI.aml") def windows_ssdt_path(self):
return self.payload_path / Path("ACPI/SSDT-PCI.aml")
# Drivers # Drivers
@property @property
def nvme_driver_path(self): return self.payload_path / Path("Drivers/NvmExpressDxe.efi") def nvme_driver_path(self):
return self.payload_path / Path("Drivers/NvmExpressDxe.efi")
@property @property
def exfat_legacy_driver_path(self): return self.payload_path / Path("Drivers/ExFatDxeLegacy.efi") def exfat_legacy_driver_path(self):
return self.payload_path / Path("Drivers/ExFatDxeLegacy.efi")
@property @property
def xhci_driver_path(self): return self.payload_path / Path("Drivers/XhciDxe.efi") def xhci_driver_path(self):
return self.payload_path / Path("Drivers/XhciDxe.efi")
# Kexts # Kexts
@property @property
def payload_kexts_path(self): return self.payload_path / Path("Kexts") def payload_kexts_path(self):
return self.payload_path / Path("Kexts")
@property @property
def lilu_path(self): return self.payload_kexts_path / Path(f"Acidanthera/Lilu-v{self.lilu_version}.zip") def lilu_path(self):
return self.payload_kexts_path / Path(f"Acidanthera/Lilu-v{self.lilu_version}.zip")
@property @property
def whatevergreen_path(self): return self.payload_kexts_path / Path(f"Acidanthera/WhateverGreen-v{self.whatevergreen_version}.zip") def whatevergreen_path(self):
return self.payload_kexts_path / Path(f"Acidanthera/WhateverGreen-v{self.whatevergreen_version}.zip")
@property @property
def airportbcrmfixup_path(self): return self.payload_kexts_path / Path(f"Acidanthera/AirportBrcmFixup-v{self.airportbcrmfixup_version}.zip") def airportbcrmfixup_path(self):
return self.payload_kexts_path / Path(f"Acidanthera/AirportBrcmFixup-v{self.airportbcrmfixup_version}.zip")
@property @property
def restrictevents_path(self): return self.payload_kexts_path / Path(f"Acidanthera/RestrictEvents-v{self.restrictevents_version}.zip") def restrictevents_path(self):
return self.payload_kexts_path / Path(f"Acidanthera/RestrictEvents-v{self.restrictevents_version}.zip")
@property @property
def restrictevents_mbp_path(self): return self.payload_kexts_path / Path(f"Acidanthera/RestrictEvents-MBP91-v{self.restrictevents_mbp_version}.zip") def restrictevents_mbp_path(self):
return self.payload_kexts_path / Path(f"Acidanthera/RestrictEvents-MBP91-v{self.restrictevents_mbp_version}.zip")
@property @property
def bcm570_path(self): return self.payload_kexts_path / Path(f"Ethernet/CatalinaBCM5701Ethernet-v{self.bcm570_version}.zip") def bcm570_path(self):
return self.payload_kexts_path / Path(f"Ethernet/CatalinaBCM5701Ethernet-v{self.bcm570_version}.zip")
@property @property
def marvel_path(self): return self.payload_kexts_path / Path(f"Ethernet/MarvelYukonEthernet-v{self.marvel_version}.zip") def marvel_path(self):
return self.payload_kexts_path / Path(f"Ethernet/MarvelYukonEthernet-v{self.marvel_version}.zip")
@property @property
def nforce_path(self): return self.payload_kexts_path / Path(f"Ethernet/nForceEthernet-v{self.nforce_version}.zip") def nforce_path(self):
return self.payload_kexts_path / Path(f"Ethernet/nForceEthernet-v{self.nforce_version}.zip")
@property @property
def mce_path(self): return self.payload_kexts_path / Path(f"Misc/AppleMCEReporterDisabler-v{self.mce_version}.zip") def mce_path(self):
return self.payload_kexts_path / Path(f"Misc/AppleMCEReporterDisabler-v{self.mce_version}.zip")
@property @property
def mousse_path(self): return self.payload_kexts_path / Path(f"SSE/AAAMouSSE-v{self.mousse_version}.zip") def mousse_path(self):
return self.payload_kexts_path / Path(f"SSE/AAAMouSSE-v{self.mousse_version}.zip")
@property @property
def telemetrap_path(self): return self.payload_kexts_path / Path(f"SSE/telemetrap-v{self.telemetrap_version}.zip") def telemetrap_path(self):
return self.payload_kexts_path / Path(f"SSE/telemetrap-v{self.telemetrap_version}.zip")
@property @property
def corecaptureelcap_path(self): return self.payload_kexts_path / Path(f"Wifi/corecaptureElCap-v{self.corecaptureelcap_version}.zip") def corecaptureelcap_path(self):
return self.payload_kexts_path / Path(f"Wifi/corecaptureElCap-v{self.corecaptureelcap_version}.zip")
@property @property
def io80211elcap_path(self): return self.payload_kexts_path / Path(f"Wifi/IO80211ElCap-v{self.io80211elcap_version}.zip") def io80211elcap_path(self):
return self.payload_kexts_path / Path(f"Wifi/IO80211ElCap-v{self.io80211elcap_version}.zip")
@property @property
def io80211high_sierra_path(self): return self.payload_kexts_path / Path(f"Wifi/IO80211HighSierra-v{self.io80211high_sierra_version}.zip") def io80211high_sierra_path(self):
return self.payload_kexts_path / Path(f"Wifi/IO80211HighSierra-v{self.io80211high_sierra_version}.zip")
@property @property
def io80211mojave_path(self): return self.payload_kexts_path / Path(f"Wifi/IO80211Mojave-v{self.io80211mojave_version}.zip") def io80211mojave_path(self):
return self.payload_kexts_path / Path(f"Wifi/IO80211Mojave-v{self.io80211mojave_version}.zip")
@property @property
def applealc_path(self): return self.payload_kexts_path / Path(f"Acidanthera/AppleALC-v{self.applealc_version}.zip") def applealc_path(self):
return self.payload_kexts_path / Path(f"Acidanthera/AppleALC-v{self.applealc_version}.zip")
@property @property
def piixata_path(self): return self.payload_kexts_path / Path(f"Misc/AppleIntelPIIXATA-v{self.piixata_version}.zip") def piixata_path(self):
return self.payload_kexts_path / Path(f"Misc/AppleIntelPIIXATA-v{self.piixata_version}.zip")
@property @property
def backlight_path(self): return self.payload_kexts_path / Path(f"Misc/AppleBacklightFixup-v{self.backlight_version}.zip") def backlight_path(self):
return self.payload_kexts_path / Path(f"Misc/AppleBacklightFixup-v{self.backlight_version}.zip")
@property @property
def backlight_injector_path(self): return self.payload_kexts_path / Path(f"Misc/BacklightInjector-v{self.backlight_injector_version}.zip") def backlight_injector_path(self):
return self.payload_kexts_path / Path(f"Misc/BacklightInjector-v{self.backlight_injector_version}.zip")
@property @property
def cpufriend_path(self): return self.payload_kexts_path / Path(f"Acidanthera/CPUFriend-v{self.cpufriend_version}.zip") def cpufriend_path(self):
return self.payload_kexts_path / Path(f"Acidanthera/CPUFriend-v{self.cpufriend_version}.zip")
@property @property
def nightshift_path(self): return self.payload_kexts_path / Path(f"Misc/NightShiftEnabler-v{self.nightshift_version}.zip") def nightshift_path(self):
return self.payload_kexts_path / Path(f"Misc/NightShiftEnabler-v{self.nightshift_version}.zip")
@property @property
def smcspoof_path(self): return self.payload_kexts_path / Path(f"Misc/SMC-Spoof-v{self.smcspoof_version}.zip") def smcspoof_path(self):
return self.payload_kexts_path / Path(f"Misc/SMC-Spoof-v{self.smcspoof_version}.zip")
@property @property
def cputscsync_path(self): return self.payload_kexts_path / Path(f"Acidanthera/CpuTscSync-v{self.cputscsync}.zip") def cputscsync_path(self):
return self.payload_kexts_path / Path(f"Acidanthera/CpuTscSync-v{self.cputscsync}.zip")
@property @property
def hibernationfixup_path(self): return self.payload_kexts_path / Path(f"Acidanthera/HibernationFixup-v{self.hibernationfixup}.zip") def hibernationfixup_path(self):
return self.payload_kexts_path / Path(f"Acidanthera/HibernationFixup-v{self.hibernationfixup}.zip")
@property @property
def nvmefix_path(self): return self.payload_kexts_path / Path(f"Acidanthera/NVMeFix-v{self.nvmefix_version}.zip") def nvmefix_path(self):
return self.payload_kexts_path / Path(f"Acidanthera/NVMeFix-v{self.nvmefix_version}.zip")
@property @property
def sidecarfixup_path(self): return self.payload_kexts_path / Path(f"Acidanthera/SidecarFixup-v{self.sidecarfixup_version}.zip") def sidecarfixup_path(self):
return self.payload_kexts_path / Path(f"Acidanthera/SidecarFixup-v{self.sidecarfixup_version}.zip")
@property @property
def debugenhancer_path(self): return self.payload_kexts_path / Path(f"Acidanthera/DebugEnhancer-v{self.debugenhancer_version}.zip") def debugenhancer_path(self):
return self.payload_kexts_path / Path(f"Acidanthera/DebugEnhancer-v{self.debugenhancer_version}.zip")
@property @property
def innie_path(self): return self.payload_kexts_path / Path(f"Misc/Innie-v{self.innie_version}.zip") def innie_path(self):
return self.payload_kexts_path / Path(f"Misc/Innie-v{self.innie_version}.zip")
@property @property
def plist_folder_path(self): return self.payload_kexts_path / Path(f"Plists") def plist_folder_path(self):
return self.payload_kexts_path / Path("Plists")
@property @property
def platform_plugin_plist_path(self): return self.plist_folder_path / Path(f"PlatformPlugin") def platform_plugin_plist_path(self):
return self.plist_folder_path / Path("PlatformPlugin")
@property @property
def fw_family_path(self): return self.payload_kexts_path / Path(f"FireWire/IOFireWireFamily-v{self.fw_kext}.zip") def fw_family_path(self):
return self.payload_kexts_path / Path(f"FireWire/IOFireWireFamily-v{self.fw_kext}.zip")
@property @property
def fw_sbp2_path(self): return self.payload_kexts_path / Path(f"FireWire/IOFireWireSBP2-v{self.fw_kext}.zip") def fw_sbp2_path(self):
return self.payload_kexts_path / Path(f"FireWire/IOFireWireSBP2-v{self.fw_kext}.zip")
@property @property
def fw_bus_path(self): return self.payload_kexts_path / Path(f"FireWire/IOFireWireSerialBusProtocolTransport-v{self.fw_kext}.zip") def fw_bus_path(self):
return self.payload_kexts_path / Path(f"FireWire/IOFireWireSerialBusProtocolTransport-v{self.fw_kext}.zip")
# Build Location # Build Location
@property @property
def build_path(self): return self.current_path / Path("Build-Folder/") def build_path(self):
@property return self.current_path / Path("Build-Folder/")
def opencore_release_folder(self): return self.build_path / Path(f"OpenCore-{self.opencore_build}")
@property
def opencore_zip_copied(self): return self.build_path / Path(f"OpenCore-{self.opencore_build}.zip")
@property @property
def oc_folder(self): return self.opencore_release_folder / Path("EFI/OC/") def opencore_release_folder(self):
return self.build_path / Path(f"OpenCore-{self.opencore_build}")
@property @property
def plist_path(self): return self.oc_folder / Path("config.plist") def opencore_zip_copied(self):
return self.build_path / Path(f"OpenCore-{self.opencore_build}.zip")
@property @property
def acpi_path(self): return self.oc_folder / Path("ACPI") def oc_folder(self):
return self.opencore_release_folder / Path("EFI/OC/")
@property @property
def drivers_path(self): return self.oc_folder / Path("Drivers") def plist_path(self):
return self.oc_folder / Path("config.plist")
@property @property
def kexts_path(self): return self.oc_folder / Path("Kexts") def acpi_path(self):
return self.oc_folder / Path("ACPI")
@property @property
def resources_path(self): return self.oc_folder / Path("Resources") def drivers_path(self):
return self.oc_folder / Path("Drivers")
@property @property
def map_kext_folder(self): return self.kexts_path / Path("USB-Map.kext") def kexts_path(self):
return self.oc_folder / Path("Kexts")
@property @property
def map_contents_folder(self): return self.map_kext_folder / Path("Contents") def resources_path(self):
return self.oc_folder / Path("Resources")
@property @property
def pp_kext_folder(self): return self.kexts_path / Path("CPUFriendDataProvider.kext") def map_kext_folder(self):
return self.kexts_path / Path("USB-Map.kext")
@property @property
def pp_contents_folder(self): return self.pp_kext_folder / Path("Contents") def map_contents_folder(self):
return self.map_kext_folder / Path("Contents")
@property @property
def agdp_kext_folder(self): return self.kexts_path / Path("AGDP-Override.kext") def pp_kext_folder(self):
return self.kexts_path / Path("CPUFriendDataProvider.kext")
@property @property
def agdp_contents_folder(self): return self.agdp_kext_folder / Path("Contents") def pp_contents_folder(self):
return self.pp_kext_folder / Path("Contents")
@property @property
def agpm_kext_folder(self): return self.kexts_path / Path("AGPM-Override.kext") def agdp_kext_folder(self):
return self.kexts_path / Path("AGDP-Override.kext")
@property @property
def agpm_contents_folder(self): return self.agpm_kext_folder / Path("Contents") def agdp_contents_folder(self):
return self.agdp_kext_folder / Path("Contents")
@property @property
def amc_kext_folder(self): return self.kexts_path / Path("AMC-Override.kext") def agpm_kext_folder(self):
return self.kexts_path / Path("AGPM-Override.kext")
@property @property
def amc_contents_folder(self): return self.amc_kext_folder / Path("Contents") def agpm_contents_folder(self):
return self.agpm_kext_folder / Path("Contents")
@property
def amc_kext_folder(self):
return self.kexts_path / Path("AMC-Override.kext")
@property
def amc_contents_folder(self):
return self.amc_kext_folder / Path("Contents")
# Tools # Tools
@property @property
def macserial_path(self): return self.payload_path / Path("Tools/macserial") def macserial_path(self):
return self.payload_path / Path("Tools/macserial")
@property @property
def gfxutil_path(self): return self.payload_path / Path("Tools/gfxutil") def gfxutil_path(self):
return self.payload_path / Path("Tools/gfxutil")
@property @property
def vault_path(self): return self.payload_path / Path("Tools/CreateVault/sign.command") def vault_path(self):
return self.payload_path / Path("Tools/CreateVault/sign.command")
# Icons # Icons
@property @property
def app_icon_path(self): return self.current_path / Path("OC-Patcher.icns") def app_icon_path(self):
return self.current_path / Path("OC-Patcher.icns")
@property @property
def icon_path_external(self): return self.payload_path / Path("Icon/External/.VolumeIcon.icns") def icon_path_external(self):
return self.payload_path / Path("Icon/External/.VolumeIcon.icns")
@property @property
def icon_path_internal(self): return self.payload_path / Path("Icon/Internal/.VolumeIcon.icns") def icon_path_internal(self):
return self.payload_path / Path("Icon/Internal/.VolumeIcon.icns")
@property @property
def icon_path_sd(self): return self.payload_path / Path("Icon/SD-Card/.VolumeIcon.icns") def icon_path_sd(self):
return self.payload_path / Path("Icon/SD-Card/.VolumeIcon.icns")
@property @property
def icon_path_ssd(self): return self.payload_path / Path("Icon/SSD/.VolumeIcon.icns") def icon_path_ssd(self):
return self.payload_path / Path("Icon/SSD/.VolumeIcon.icns")
@property @property
def gui_path(self): return self.payload_path / Path("Icon/Resources.zip") def gui_path(self):
return self.payload_path / Path("Icon/Resources.zip")
# Apple Payloads Paths # Apple Payloads Paths
@property @property
def payload_apple_root_path_unzip(self): return self.payload_path / Path(f"Apple-Binaries-OCLP-{self.payload_version}") def payload_apple_root_path_unzip(self):
return self.payload_path / Path(f"Apple-Binaries-OCLP-{self.payload_version}")
@property @property
def payload_apple_root_path_zip(self): return self.payload_path / Path("Apple.zip") def payload_apple_root_path_zip(self):
return self.payload_path / Path("Apple.zip")
@property @property
def payload_apple_root_path(self): return self.payload_path / Path("Apple") def payload_apple_root_path(self):
return self.payload_path / Path("Apple")
@property @property
def payload_apple_kexts_path(self): return self.payload_apple_root_path / Path("Extensions") def payload_apple_kexts_path(self):
return self.payload_apple_root_path / Path("Extensions")
@property @property
def payload_apple_frameworks_path(self): return self.payload_apple_root_path / Path("Frameworks") def payload_apple_frameworks_path(self):
return self.payload_apple_root_path / Path("Frameworks")
@property @property
def payload_apple_frameworks_path_accel(self): return self.payload_apple_frameworks_path / Path("Graphics-Acceleration") def payload_apple_frameworks_path_accel(self):
return self.payload_apple_frameworks_path / Path("Graphics-Acceleration")
@property @property
def payload_apple_frameworks_path_accel_ts2(self): return self.payload_apple_frameworks_path / Path("Graphics-Acceleration-TS2") def payload_apple_frameworks_path_accel_ts2(self):
return self.payload_apple_frameworks_path / Path("Graphics-Acceleration-TS2")
@property @property
def payload_apple_lauchd_path(self): return self.payload_apple_root_path / Path("LaunchDaemons") def payload_apple_lauchd_path(self):
return self.payload_apple_root_path / Path("LaunchDaemons")
@property @property
def payload_apple_lauchd_path_accel(self): return self.payload_apple_lauchd_path / Path("Graphics-Acceleration") def payload_apple_lauchd_path_accel(self):
return self.payload_apple_lauchd_path / Path("Graphics-Acceleration")
@property @property
def payload_apple_private_frameworks_path(self): return self.payload_apple_root_path / Path("PrivateFrameworks") def payload_apple_private_frameworks_path(self):
return self.payload_apple_root_path / Path("PrivateFrameworks")
@property @property
def payload_apple_private_frameworks_path_accel(self): return self.payload_apple_private_frameworks_path / Path("Graphics-Acceleration") def payload_apple_private_frameworks_path_accel(self):
return self.payload_apple_private_frameworks_path / Path("Graphics-Acceleration")
@property @property
def payload_apple_private_frameworks_path_accel_ts2(self): return self.payload_apple_private_frameworks_path / Path("Graphics-Acceleration-TS2") def payload_apple_private_frameworks_path_accel_ts2(self):
return self.payload_apple_private_frameworks_path / Path("Graphics-Acceleration-TS2")
@property @property
def payload_apple_private_frameworks_path_brightness(self): return self.payload_apple_private_frameworks_path / Path("Brightness-Control") def payload_apple_private_frameworks_path_brightness(self):
return self.payload_apple_private_frameworks_path / Path("Brightness-Control")
# Apple Extensions # Apple Extensions
@property @property
def audio_path(self): return self.payload_apple_kexts_path / Path("Audio") def audio_path(self):
return self.payload_apple_kexts_path / Path("Audio")
# GPU Kexts and Bundles # GPU Kexts and Bundles
@property @property
def legacy_graphics(self): return self.payload_apple_kexts_path / Path("Graphics-Acceleration") def legacy_graphics(self):
@property return self.payload_apple_kexts_path / Path("Graphics-Acceleration")
def legacy_graphics_ts2(self): return self.payload_apple_kexts_path / Path("Graphics-Acceleration-TS2")
@property
def legacy_nvidia_path(self): return self.legacy_graphics / Path("Nvidia-Tesla-Fermi")
@property
def legacy_nvidia_kepler_path(self): return self.legacy_graphics / Path("Nvidia-Kepler")
@property
def legacy_amd_path(self): return self.legacy_graphics / Path("AMD-ATI")
@property
def legacy_amd_path_ts2(self): return self.legacy_graphics / Path("ATI-TS2")
@property
def legacy_intel_gen1_path(self): return self.legacy_graphics / Path("Intel-Gen5-Ironlake")
@property
def legacy_intel_gen2_path(self): return self.legacy_graphics / Path("Intel-Gen6-SandyBridge")
@property
def legacy_intel_gen3_path(self): return self.legacy_graphics / Path("Intel-Gen7-IvyBridge")
@property
def legacy_general_path(self): return self.legacy_graphics / Path("General-Patches")
@property @property
def legacy_brightness(self): return self.payload_apple_kexts_path / Path("Brightness-Control") def legacy_graphics_ts2(self):
return self.payload_apple_kexts_path / Path("Graphics-Acceleration-TS2")
@property
def legacy_nvidia_path(self):
return self.legacy_graphics / Path("Nvidia-Tesla-Fermi")
@property
def legacy_nvidia_kepler_path(self):
return self.legacy_graphics / Path("Nvidia-Kepler")
@property
def legacy_amd_path(self):
return self.legacy_graphics / Path("AMD-ATI")
@property
def legacy_amd_path_ts2(self):
return self.legacy_graphics / Path("ATI-TS2")
@property
def legacy_intel_gen1_path(self):
return self.legacy_graphics / Path("Intel-Gen5-Ironlake")
@property
def legacy_intel_gen2_path(self):
return self.legacy_graphics / Path("Intel-Gen6-SandyBridge")
@property
def legacy_intel_gen3_path(self):
return self.legacy_graphics / Path("Intel-Gen7-IvyBridge")
@property
def legacy_general_path(self):
return self.legacy_graphics / Path("General-Patches")
@property
def legacy_brightness(self):
return self.payload_apple_kexts_path / Path("Brightness-Control")
# Apple Frameworks # Apple Frameworks
@property @property
def coredisplay_path(self): return self.payload_apple_frameworks_path_accel / Path("CoreDisplay.framework") def coredisplay_path(self):
return self.payload_apple_frameworks_path_accel / Path("CoreDisplay.framework")
@property @property
def iosurface_f_path(self): return self.payload_apple_frameworks_path_accel / Path("IOSurface.framework") def iosurface_f_path(self):
return self.payload_apple_frameworks_path_accel / Path("IOSurface.framework")
@property @property
def opengl_path(self): return self.payload_apple_frameworks_path_accel / Path("OpenGL.framework") def opengl_path(self):
return self.payload_apple_frameworks_path_accel / Path("OpenGL.framework")
# Apple LaunchDaemons # Apple LaunchDaemons
@property @property
def hiddhack_path(self): return self.payload_apple_lauchd_path_accel / Path("IOHID-Fixup.plist") def hiddhack_path(self):
return self.payload_apple_lauchd_path_accel / Path("IOHID-Fixup.plist")
@property @property
def legacy_hiddhack_path(self): return self.payload_apple_lauchd_path_accel / Path("HiddHack.plist") def legacy_hiddhack_path(self):
return self.payload_apple_lauchd_path_accel / Path("HiddHack.plist")
# Apple PrivateFrameworks # Apple PrivateFrameworks
@property @property
def gpusupport_path(self): return self.payload_apple_private_frameworks_path_accel / Path("GPUSupport.framework") def gpusupport_path(self):
return self.payload_apple_private_frameworks_path_accel / Path("GPUSupport.framework")
@property @property
def skylight_path(self): return self.payload_apple_private_frameworks_path_accel / Path("SkyLight.framework") def skylight_path(self):
return self.payload_apple_private_frameworks_path_accel / Path("SkyLight.framework")
csr_values = { csr_values = {
"CSR_ALLOW_UNTRUSTED_KEXTS": False, # 0x1 - Allows Unsigned Kexts - Introduced in El Capitan # noqa: E241 "CSR_ALLOW_UNTRUSTED_KEXTS": False, # 0x1 - Allows Unsigned Kexts - Introduced in El Capitan # noqa: E241
"CSR_ALLOW_UNRESTRICTED_FS": False, # 0x2 - File System Access - Introduced in El Capitan # noqa: E241 "CSR_ALLOW_UNRESTRICTED_FS": False, # 0x2 - File System Access - Introduced in El Capitan # noqa: E241
"CSR_ALLOW_TASK_FOR_PID": False, # 0x4 - Unrestricted Debugging - Introduced in El Capitan # noqa: E241 "CSR_ALLOW_TASK_FOR_PID": False, # 0x4 - Unrestricted Debugging - Introduced in El Capitan # noqa: E241
"CSR_ALLOW_KERNEL_DEBUGGER": False, # 0x8 - Allow Kernel Debugger - Introduced in El Capitan # noqa: E241 "CSR_ALLOW_KERNEL_DEBUGGER": False, # 0x8 - Allow Kernel Debugger - Introduced in El Capitan # noqa: E241
"CSR_ALLOW_APPLE_INTERNAL": False, # 0x10 - Set AppleInternal Features - Introduced in El Capitan # noqa: E241 "CSR_ALLOW_APPLE_INTERNAL": False, # 0x10 - Set AppleInternal Features - Introduced in El Capitan # noqa: E241
"CSR_ALLOW_UNRESTRICTED_DTRACE": False, # 0x20 - Unrestricted DTrace usage - Introduced in El Capitan # noqa: E241 "CSR_ALLOW_UNRESTRICTED_DTRACE": False, # 0x20 - Unrestricted DTrace usage - Introduced in El Capitan # noqa: E241
"CSR_ALLOW_UNRESTRICTED_NVRAM": False, # 0x40 - Unrestricted NVRAM write - Introduced in El Capitan # noqa: E241 "CSR_ALLOW_UNRESTRICTED_NVRAM": False, # 0x40 - Unrestricted NVRAM write - Introduced in El Capitan # noqa: E241
"CSR_ALLOW_DEVICE_CONFIGURATION": False, # 0x80 - Allow Device Configuration(?) - Introduced in El Capitan # noqa: E241 "CSR_ALLOW_DEVICE_CONFIGURATION": False, # 0x80 - Allow Device Configuration(?) - Introduced in El Capitan # noqa: E241
"CSR_ALLOW_ANY_RECOVERY_OS": False, # 0x100 - Disable BaseSystem Verification - Introduced in Sierra # noqa: E241 "CSR_ALLOW_ANY_RECOVERY_OS": False, # 0x100 - Disable BaseSystem Verification - Introduced in Sierra # noqa: E241
"CSR_ALLOW_UNAPPROVED_KEXTS": False, # 0x200 - Allow Unapproved Kexts - Introduced in High Sierra # noqa: E241 "CSR_ALLOW_UNAPPROVED_KEXTS": False, # 0x200 - Allow Unapproved Kexts - Introduced in High Sierra # noqa: E241
"CSR_ALLOW_EXECUTABLE_POLICY_OVERRIDE": False, # 0x400 - Override Executable Policy - Introduced in Mojave # noqa: E241 "CSR_ALLOW_EXECUTABLE_POLICY_OVERRIDE": False, # 0x400 - Override Executable Policy - Introduced in Mojave # noqa: E241
"CSR_ALLOW_UNAUTHENTICATED_ROOT": False, # 0x800 - Allow Root Volume Mounting - Introduced in Big Sur # noqa: E241 "CSR_ALLOW_UNAUTHENTICATED_ROOT": False, # 0x800 - Allow Root Volume Mounting - Introduced in Big Sur # noqa: E241
} }
root_patch_sip_mojave = [ root_patch_sip_mojave = [
@@ -442,7 +634,7 @@ class Constants:
"MacBookAir7,1": "Mac-9F18E312C5C2BF0B", "MacBookAir7,1": "Mac-9F18E312C5C2BF0B",
"MacBookAir7,2": "Mac-937CB26E2E02BB01", "MacBookAir7,2": "Mac-937CB26E2E02BB01",
"MacBookAir8,1": "Mac-827FAC58A8FDFA22", "MacBookAir8,1": "Mac-827FAC58A8FDFA22",
"MacBookAir8,1": "Mac-226CB3C6A851A671", "MacBookAir8,2": "Mac-226CB3C6A851A671",
"MacBookAir9,1": "Mac-0CFF9C7C2B63DF8D", "MacBookAir9,1": "Mac-0CFF9C7C2B63DF8D",
"MacBookPro1,1": "Mac-F425BEC8", "MacBookPro1,1": "Mac-F425BEC8",
"MacBookPro1,2": "Mac-F42DBEC8", "MacBookPro1,2": "Mac-F42DBEC8",
@@ -505,14 +697,13 @@ class Constants:
"iMac8,1": "Mac-F227BEC8", "iMac8,1": "Mac-F227BEC8",
"iMac9,1": "Mac-F2218FA9", "iMac9,1": "Mac-F2218FA9",
"iMac10,1": "Mac-F221DCC8", "iMac10,1": "Mac-F221DCC8",
"iMac10,1": "Mac-F2268CC8", # "iMac10,1": "Mac-F2268CC8",
"iMac11,1": "Mac-F2268DAE", "iMac11,1": "Mac-F2268DAE",
"iMac11,2": "Mac-F2238AC8", "iMac11,2": "Mac-F2238AC8",
"iMac11,3": "Mac-F2238BAE", "iMac11,3": "Mac-F2238BAE",
"iMac12,1": "Mac-942B5BF58194151B", "iMac12,1": "Mac-942B5BF58194151B",
"iMac12,2": "Mac-942B59F58194171B", "iMac12,2": "Mac-942B59F58194171B",
"iMac13,1": "Mac-00BE6ED71E35EB86", "iMac13,1": "Mac-00BE6ED71E35EB86",
"iMac13,1": "Mac-00BE6ED71E35EB86",
"iMac13,2": "Mac-FC02E91DDD3FA6A4", "iMac13,2": "Mac-FC02E91DDD3FA6A4",
"iMac13,3": "Mac-7DF2A3B5E5D671ED", "iMac13,3": "Mac-7DF2A3B5E5D671ED",
"iMac14,1": "Mac-031B6874CF7F642A", "iMac14,1": "Mac-031B6874CF7F642A",
Resources/DeviceProbe.py
-116
View File
@@ -1,116 +0,0 @@
# Probe devices, return device entries
# Copyright (C) 2021 Mykola Grymalyuk
from __future__ import print_function
import binascii
import plistlib
import subprocess
from Resources import Constants, Utilities
class pci_probe:
def __init__(self):
self.constants = Constants.Constants()
# Converts given device IDs to DeviceProperty pathing, requires ACPI pathing as DeviceProperties shouldn't be used otherwise
def deviceproperty_probe(self, vendor_id, device_id, acpi_path):
gfxutil_output: str = subprocess.run([self.constants.gfxutil_path] + f"-v".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
try:
if acpi_path == "":
acpi_path = "No ACPI Path Given"
raise IndexError
device_path = [line.strip().split("= ", 1)[1] for line in gfxutil_output.split("\n") if f'{vendor_id}:{device_id}'.lower() in line.strip() and acpi_path in line.strip()][0]
return device_path
except IndexError:
print(f"- No DevicePath found for {vendor_id}:{device_id} ({acpi_path})")
return ""
# Returns the device path of parent controller
def device_property_parent(self, device_path):
device_path_parent = "/".join(device_path.split("/")[:-1])
return device_path_parent
def acpi_strip(self, acpi_path_full):
# Strip IOACPIPlane:/_SB, remove 000's, convert ffff into 0 and finally make everything upper case
# IOReg | gfxutil
# IOACPIPlane:/_SB/PC00@0/DMI0@0 -> /PC00@0/DMI0@0
# IOACPIPlane:/_SB/PC03@0/BR3A@0/SL09@ffff -> /PC03@0/BR3A@0/SL09@0
# IOACPIPlane:/_SB/PC03@0/M2U0@150000 -> /PC03@0/M2U0@15
# IOACPIPlane:/_SB/PC01@0/CHA6@100000 -> /PC01@0/CHA6@10
# IOACPIPlane:/_SB/PC00@0/RP09@1d0000/PXSX@0 -> /PC00@0/RP09@1D/PXSX@0
# IOACPIPlane:/_SB/PCI0@0/P0P2@10000 -> /PCI0@0/P0P2@1
acpi_path = acpi_path_full.replace("IOACPIPlane:/_SB", "")
acpi_path = acpi_path.replace("0000", "")
for entry in ["1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"]:
acpi_path = acpi_path.replace(f"000{entry}", f",{entry}")
acpi_path = acpi_path.replace("ffff", "0")
acpi_path = acpi_path.upper()
return acpi_path
# Note gpu_probe should only be used on IGPU and GFX0 entries
def gpu_probe(self, gpu_type):
try:
devices = plistlib.loads(subprocess.run(f"ioreg -r -n {gpu_type} -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
vendor_id = Utilities.hexswap(binascii.hexlify(devices[0]["vendor-id"]).decode()[:4])
device_id = Utilities.hexswap(binascii.hexlify(devices[0]["device-id"]).decode()[:4])
try:
acpi_path = devices[0]["acpi-path"]
acpi_path = self.acpi_strip(acpi_path)
return vendor_id, device_id, acpi_path
except KeyError:
print(f"- No ACPI entry found for {gpu_type}")
return vendor_id, device_id, ""
except ValueError:
print(f"- No IOService entry found for {gpu_type} (V)")
return "", "", ""
except IndexError:
print(f"- No IOService entry found for {gpu_type} (I)")
return "", "", ""
def wifi_probe(self):
devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
try:
devices = [i for i in devices if i["class-code"] == binascii.unhexlify(self.constants.classcode_wifi)]
vendor_id = Utilities.hexswap(binascii.hexlify(devices[0]["vendor-id"]).decode()[:4])
device_id = Utilities.hexswap(binascii.hexlify(devices[0]["device-id"]).decode()[:4])
ioname = devices[0]["IOName"]
try:
acpi_path = devices[0]["acpi-path"]
acpi_path = self.acpi_strip(acpi_path)
return vendor_id, device_id, ioname, acpi_path
except KeyError:
print(f"- No ACPI entry found for {vendor_id}:{device_id}")
return vendor_id, device_id, ioname, ""
except ValueError:
print(f"- No IOService entry found for Wireless Card (V)")
return "", "", "", ""
except IndexError:
print(f"- No IOService entry found for Wireless Card (I)")
return "", "", "", ""
def cpu_feature(self, instruction):
cpu_features = subprocess.run("sysctl machdep.cpu.features".split(), stdout=subprocess.PIPE).stdout.decode().partition(": ")[2].strip().split(" ")
if instruction in cpu_features:
print(f"- Found {instruction} support")
return True
else:
print(f"- Failed to find {instruction} support")
return False
class smbios_probe:
def model_detect(self, custom):
opencore_model: str = subprocess.run("nvram 4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:oem-product".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
if not opencore_model.startswith("nvram: Error getting variable") and custom is False:
current_model = [line.strip().split(":oem-product ", 1)[1] for line in opencore_model.split("\n") if line.strip().startswith("4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:")][0]
else:
current_model = plistlib.loads(subprocess.run("system_profiler -detailLevel mini -xml SPHardwareDataType".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.strip())[0]["_items"][0]["machine_model"]
return current_model
def board_detect(self, custom):
opencore_model: str = subprocess.run("nvram 4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:oem-board".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
if not opencore_model.startswith("nvram: Error getting variable") and custom is False:
current_model = [line.strip().split(":oem-board ", 1)[1] for line in opencore_model.split("\n") if line.strip().startswith("4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:")][0]
else:
current_model = plistlib.loads(subprocess.run(f"ioreg -p IODeviceTree -r -n / -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
current_model = current_model[0]["board-id"]
return current_model
Resources/ModelArray.py
+63 -168
View File
@@ -100,32 +100,14 @@ MissingSSE42 = [
"iMac10,1", "iMac10,1",
"MacPro3,1", "MacPro3,1",
"Xserve2,1", "Xserve2,1",
"Dortania1,1" "Dortania1,1",
] ]
SSEEmulator = [ SSEEmulator = ["MacPro3,1", "Xserve2,1", "Dortania1,1"]
"MacPro3,1",
"Xserve2,1",
"Dortania1,1"
]
DualSocket = [ DualSocket = ["MacPro3,1", "MacPro4,1", "MacPro5,1", "Xserve2,1", "Xserve3,1", "Dortania1,1"]
"MacPro3,1",
"MacPro4,1",
"MacPro5,1",
"Xserve2,1",
"Xserve3,1",
"Dortania1,1"
]
pciSSDT = [ pciSSDT = ["MacBookPro6,1", "MacBookPro6,2", "iMac11,1", "iMac11,2", "iMac11,3", "Dortania1,1"]
"MacBookPro6,1",
"MacBookPro6,2",
"iMac11,1",
"iMac11,2",
"iMac11,3",
"Dortania1,1"
]
# Ethernet patches # Ethernet patches
@@ -142,15 +124,9 @@ EthernetNvidia = [
"Macmini3,1", "Macmini3,1",
"iMac9,1", "iMac9,1",
"iMac10,1", "iMac10,1",
"Dortania1,1" "Dortania1,1",
]
EthernetMarvell = [
"MacBook4,1",
"MacBookPro4,1",
"iMac7,1",
"iMac8,1",
"Dortania1,1"
] ]
EthernetMarvell = ["MacBook4,1", "MacBookPro4,1", "iMac7,1", "iMac8,1", "Dortania1,1"]
EthernetBroadcom = [ EthernetBroadcom = [
"MacBookAir4,1", "MacBookAir4,1",
"MacBookAir4,2", "MacBookAir4,2",
@@ -169,31 +145,14 @@ EthernetBroadcom = [
"iMac11,3", "iMac11,3",
"iMac12,1", "iMac12,1",
"iMac12,2", "iMac12,2",
"Dortania1,1" "Dortania1,1",
] ]
# Wifi patches # Wifi patches
WifiAtheros = [ WifiAtheros = ["iMac10,1", "iMac11,1", "iMac11,2", "iMac11,3", "iMac12,1", "iMac12,2", "MacPro3,1", "MacPro4,1", "Dortania1,1"]
"iMac10,1",
"iMac11,1",
"iMac11,2",
"iMac11,3",
"iMac12,1",
"iMac12,2",
"MacPro3,1",
"MacPro4,1",
"Dortania1,1"
]
WifiBCM94328 = [ WifiBCM94328 = ["MacBook4,1", "MacBookAir2,1", "MacBookPro4,1", "iMac7,1", "iMac8,1", "Dortania1,1"]
"MacBook4,1",
"MacBookAir2,1",
"MacBookPro4,1",
"iMac7,1",
"iMac8,1",
"Dortania1,1"
]
WifiBCM94322 = [ WifiBCM94322 = [
"MacBook5,1", "MacBook5,1",
@@ -209,12 +168,12 @@ WifiBCM94322 = [
"Macmini3,1", "Macmini3,1",
"iMac9,1", "iMac9,1",
"MacPro5,1", "MacPro5,1",
"Dortania1,1" "Dortania1,1",
] ]
WifiBCM94331 = [ WifiBCM94331 = [
"MacBook6,1", # PciRoot(0x0)/Pci(0x15,0x0)/Pci(0x0,0x0) "MacBook6,1", # PciRoot(0x0)/Pci(0x15,0x0)/Pci(0x0,0x0)
"MacBook7,1", # PciRoot(0x0)/Pci(0x15,0x0)/Pci(0x0,0x0) "MacBook7,1", # PciRoot(0x0)/Pci(0x15,0x0)/Pci(0x0,0x0)
"MacBookAir4,1", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0) "MacBookAir4,1", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0)
"MacBookAir4,2", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0) "MacBookAir4,2", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0)
"MacBookAir5,1", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0) "MacBookAir5,1", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0)
@@ -228,16 +187,16 @@ WifiBCM94331 = [
"MacBookPro9,2", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0) "MacBookPro9,2", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0)
"MacBookPro10,1", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0) "MacBookPro10,1", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0)
"MacBookPro10,2", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0) "MacBookPro10,2", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0)
"Macmini4,1", # PciRoot(0x0)/Pci(0x15,0x0)/Pci(0x0,0x0) "Macmini4,1", # PciRoot(0x0)/Pci(0x15,0x0)/Pci(0x0,0x0)
"Macmini5,1", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0) "Macmini5,1", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0)
"Macmini5,2", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0) "Macmini5,2", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0)
"Macmini5,3", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0) "Macmini5,3", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0)
"Macmini6,1", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0) "Macmini6,1", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0)
"Macmini6,2", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0) "Macmini6,2", # PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0)
"iMac13,1", # PciRoot(0x0)/Pci(0x1C,0x3)/Pci(0x0,0x0) "iMac13,1", # PciRoot(0x0)/Pci(0x1C,0x3)/Pci(0x0,0x0)
"iMac13,2", # PciRoot(0x0)/Pci(0x1C,0x3)/Pci(0x0,0x0) "iMac13,2", # PciRoot(0x0)/Pci(0x1C,0x3)/Pci(0x0,0x0)
"iMac13,3", # PciRoot(0x0)/Pci(0x1C,0x3)/Pci(0x0,0x0) "iMac13,3", # PciRoot(0x0)/Pci(0x1C,0x3)/Pci(0x0,0x0)
"Dortania1,1" "Dortania1,1",
] ]
# Audio # Audio
@@ -270,8 +229,8 @@ LegacyAudio = [
"Macmini5,1", "Macmini5,1",
"Macmini5,2", "Macmini5,2",
"Macmini5,3", "Macmini5,3",
#"iMac7,1", # "iMac7,1",
#"iMac8,1", # "iMac8,1",
"iMac9,1", "iMac9,1",
"iMac10,1", "iMac10,1",
"iMac11,1", "iMac11,1",
@@ -280,7 +239,7 @@ LegacyAudio = [
"iMac12,1", "iMac12,1",
"iMac12,2", "iMac12,2",
"MacPro3,1", "MacPro3,1",
"Dortania1,1" "Dortania1,1",
] ]
nvidiaHDEF = [ nvidiaHDEF = [
@@ -300,7 +259,7 @@ nvidiaHDEF = [
"Macmini3,1", "Macmini3,1",
"Macmini4,1", "Macmini4,1",
"iMac9,1", "iMac9,1",
"iMac10,1" "iMac10,1",
] ]
# GPU # GPU
@@ -355,7 +314,7 @@ LegacyGPU = [
"iMac11,3", # AMD 5000 "iMac11,3", # AMD 5000
"iMac12,1", # AMD 6000 "iMac12,1", # AMD 6000
"iMac12,2", # AMD 6000 "iMac12,2", # AMD 6000
"Dortania1,1" # RTX 3080 "Dortania1,1", # RTX 3080
] ]
LegacyGPUNvidia = [ LegacyGPUNvidia = [
@@ -447,15 +406,10 @@ LegacyHID = [
"iMac9,1", "iMac9,1",
"iMac10,1", "iMac10,1",
"MacPro3,1", "MacPro3,1",
"Dortania1,1" "Dortania1,1",
] ]
NVMePatch = [ NVMePatch = ["MacPro3,1", "MacPro4,1", "Xserve3,1", "Dortania1,1"]
"MacPro3,1",
"MacPro4,1",
"Xserve3,1",
"Dortania1,1"
]
XhciSupport = [ XhciSupport = [
"MacBookAir5,1", "MacBookAir5,1",
@@ -487,7 +441,7 @@ XhciSupport = [
"iMac16,1", "iMac16,1",
"iMac16,2", "iMac16,2",
"MacPro6,1", "MacPro6,1",
"Dortania1,1" "Dortania1,1",
] ]
SidecarPatch = [ SidecarPatch = [
@@ -522,7 +476,7 @@ SidecarPatch = [
"iMac16,2", "iMac16,2",
"MacPro5,1", "MacPro5,1",
"MacPro6,1", "MacPro6,1",
"Dortania1,1" "Dortania1,1",
] ]
DualGPUPatch = [ DualGPUPatch = [
@@ -540,7 +494,7 @@ DualGPUPatch = [
"iMac13,2", "iMac13,2",
"iMac14,2", "iMac14,2",
"iMac14,3", "iMac14,3",
"Dortania1,1" "Dortania1,1",
] ]
DualGPUPatchRetina = [ DualGPUPatchRetina = [
@@ -555,26 +509,9 @@ IntelNvidiaDRM = [
"iMac14,3", "iMac14,3",
] ]
HiDPIpicker = [ HiDPIpicker = ["MacBook8,1", "MacBookPro10,1", "MacBookPro10,2", "MacBookPro11,1", "MacBookPro11,2", "MacBookPro11,3", "iMac15,1", "Dortania1,1"]
"MacBook8,1",
"MacBookPro10,1",
"MacBookPro10,2",
"MacBookPro11,1",
"MacBookPro11,2",
"MacBookPro11,3",
"iMac15,1",
"Dortania1,1"
]
IDEPatch = [ IDEPatch = ["MacBook4,1", "MacBookPro4,1", "iMac7,1", "iMac8,1", "MacPro3,1", "Xserve2,1", "Dortania1,1"]
"MacBook4,1",
"MacBookPro4,1",
"iMac7,1",
"iMac8,1",
"MacPro3,1",
"Xserve2,1",
"Dortania1,1"
]
# 11" Air # 11" Air
MacBookAir61 = [ MacBookAir61 = [
@@ -616,9 +553,7 @@ MacBookPro111 = [
# MacBook Pro 15" (iGPU) # MacBook Pro 15" (iGPU)
MacBookPro112 = [ MacBookPro112 = ["MacBookPro11,2"]
"MacBookPro11,2"
]
# MacBook Pro 15" and 17" (dGPU) # MacBook Pro 15" and 17" (dGPU)
@@ -639,15 +574,7 @@ MacBookPro113 = [
# Mac Mini # Mac Mini
Macmini71 = [ Macmini71 = ["Macmini3,1", "Macmini4,1", "Macmini5,1", "Macmini5,2", "Macmini5,3", "Macmini6,1", "Macmini6,2"]
"Macmini3,1",
"Macmini4,1",
"Macmini5,1",
"Macmini5,2",
"Macmini5,3",
"Macmini6,1",
"Macmini6,2"
]
# iMacPro = dGPU only iMacs # iMacPro = dGPU only iMacs
iMacPro11 = [ iMacPro11 = [
"iMac7,1", "iMac7,1",
@@ -669,21 +596,10 @@ iMac151 = [
"iMac15,1", "iMac15,1",
] ]
# iMac = Intel iGPU # iMac = Intel iGPU
iMac144 = [ iMac144 = ["iMac13,1", "iMac14,1", "iMac14,4"]
"iMac13,1",
"iMac14,1",
"iMac14,4"
]
# Mac Pro and Xserve # Mac Pro and Xserve
MacPro71 = [ MacPro71 = ["MacPro3,1", "MacPro4,1", "MacPro5,1", "Xserve2,1", "Xserve3,1", "Dortania1,1"]
"MacPro3,1",
"MacPro4,1",
"MacPro5,1",
"Xserve2,1",
"Xserve3,1",
"Dortania1,1"
]
XXerve = [ XXerve = [
"Xserve3,1", "Xserve3,1",
@@ -778,16 +694,7 @@ ControllerTypes = [
"-InternalHub", "-InternalHub",
] ]
upgradableMXMGPUs = [ upgradableMXMGPUs = ["iMac10,1", "iMac11,1", "iMac11,2", "iMac11,3", "iMac12,1", "iMac12,2", "Xserve3,1", "Dortania1,1"]
"iMac10,1"
"iMac11,1",
"iMac11,2",
"iMac11,3",
"iMac12,1",
"iMac12,2",
"Xserve3,1",
"Dortania1,1"
]
NightShift = [ NightShift = [
"MacBook4,1", "MacBook4,1",
@@ -831,7 +738,7 @@ NightShift = [
"MacPro5,1", "MacPro5,1",
"Xserve2,1", "Xserve2,1",
"Xserve3,1", "Xserve3,1",
"Dortania1,1" "Dortania1,1",
] ]
UGAtoGOP = [ UGAtoGOP = [
@@ -887,7 +794,7 @@ SATAPatch = [
"MacPro5,1", "MacPro5,1",
"Xserve2,1", "Xserve2,1",
"Xserve3,1", "Xserve3,1",
"Dortania1,1" "Dortania1,1",
] ]
NoAPFSsupport = [ NoAPFSsupport = [
@@ -909,7 +816,7 @@ NoAPFSsupport = [
"MacPro4,1", "MacPro4,1",
"Xserve2,1", "Xserve2,1",
"Xserve3,1", "Xserve3,1",
"Dortania1,1" "Dortania1,1",
] ]
NoRootPatch11 = [ NoRootPatch11 = [
@@ -959,7 +866,7 @@ NoExFat = [
"MacPro5,1", "MacPro5,1",
"Xserve2,1", "Xserve2,1",
"Xserve3,1", "Xserve3,1",
"Dortania1,1" "Dortania1,1",
] ]
SandyIGPU = [ SandyIGPU = [
@@ -997,14 +904,7 @@ windows_audio = [
"iMac13,3", "iMac13,3",
] ]
NoAGPMSupport = [ NoAGPMSupport = ["MacBook4,1", "MacBookPro4,1", "iMac7,1", "iMac8,1", "MacPro3,1", "Xserve2,1"]
"MacBook4,1",
"MacBookPro4,1",
"iMac7,1",
"iMac8,1",
"MacPro3,1",
"Xserve2,1"
]
AGDPSupport = [ AGDPSupport = [
"MacBookPro9,1", "MacBookPro9,1",
@@ -1017,37 +917,32 @@ AGDPSupport = [
"iMac14,4", "iMac14,4",
"iMac15,1", "iMac15,1",
# TODO: Uncomment when dropped from macOS # TODO: Uncomment when dropped from macOS
#"iMac17,1", # "iMac17,1",
#"iMac18,2", # "iMac18,2",
#"iMac18,3", # "iMac18,3",
#"iMac19,1", # "iMac19,1",
#"iMac19,2", # "iMac19,2",
#"iMac20,1", # "iMac20,1",
#"iMac20,2", # "iMac20,2",
#"iMacPro1,1", # "iMacPro1,1",
#"MacPro6,1", # "MacPro6,1",
] ]
AMCSupport = [ AMCSupport = [
"MacBookPro8,2", "MacBookPro8,2",
"MacBookPro8,3", "MacBookPro8,3",
#"MacBookPro9,1", # "MacBookPro9,1",
#"MacBookPro10,1" # "MacBookPro10,1"
] ]
NoFireWireSupport = [ NoFireWireSupport = [
"MacBook5,1", "MacBook5,1",
"MacBook6,1", "MacBook6,1",
"MacBook7,1", "MacBook7,1",
"MacBookAir1,1", "MacBookAir1,1",
"MacBookAir2,1", "MacBookAir2,1",
"MacBookAir3,1", "MacBookAir3,1",
"MacBookAir3,2", "MacBookAir3,2",
] ]
RecoveryIgnore = [ RecoveryIgnore = ["Update", "VM", "Recovery", "Preboot"]
"Update",
"VM",
"Recovery",
"Preboot"
]
Resources/SysPatch.py
+60 -80
View File
@@ -6,14 +6,12 @@
# - Work-around battery throttling on laptops with no battery (IOPlatformPluginFamily.kext/Contents/PlugIns/ACPI_SMC_PlatformPlugin.kext/Contents/Resources/) # - Work-around battery throttling on laptops with no battery (IOPlatformPluginFamily.kext/Contents/PlugIns/ACPI_SMC_PlatformPlugin.kext/Contents/Resources/)
import os import os
import plistlib
import shutil import shutil
import subprocess import subprocess
import zipfile import zipfile
from pathlib import Path from pathlib import Path
from typing import Any
from Resources import Constants, DeviceProbe, ModelArray, SysPatchArray, PCIIDArray, Utilities from Resources import Constants, device_probe, ModelArray, SysPatchArray, Utilities
class PatchSysVolume: class PatchSysVolume:
@@ -48,14 +46,14 @@ class PatchSysVolume:
self.mount_lauchd = f"{self.mount_location}/System/Library/LaunchDaemons" self.mount_lauchd = f"{self.mount_location}/System/Library/LaunchDaemons"
self.mount_private_frameworks = f"{self.mount_location}/System/Library/PrivateFrameworks" self.mount_private_frameworks = f"{self.mount_location}/System/Library/PrivateFrameworks"
def elevated(self, *args, **kwargs) -> subprocess.CompletedProcess([Any], returncode=0): def elevated(self, *args, **kwargs) -> subprocess.CompletedProcess:
if os.getuid() == 0: if os.getuid() == 0:
return subprocess.run(*args, **kwargs) return subprocess.run(*args, **kwargs)
else: else:
return subprocess.run(["sudo"] + [args[0][0]] + args[0][1:], **kwargs) return subprocess.run(["sudo"] + [args[0][0]] + args[0][1:], **kwargs)
def find_mount_root_vol(self, patch): def find_mount_root_vol(self, patch):
self.root_mount_path = Utilities.get_disk_path() self.root_mount_path = Utilities.get_disk_path()
if self.root_mount_path.startswith("disk"): if self.root_mount_path.startswith("disk"):
print(f"- Found Root Volume at: {self.root_mount_path}") print(f"- Found Root Volume at: {self.root_mount_path}")
if Path(self.mount_extensions).exists(): if Path(self.mount_extensions).exists():
@@ -124,7 +122,6 @@ class PatchSysVolume:
print("\nPlease reboot the machine for patches to take effect") print("\nPlease reboot the machine for patches to take effect")
input("Press [ENTER] to continue") input("Press [ENTER] to continue")
def unmount_drive(self): def unmount_drive(self):
print("- Unmounting Root Volume (Don't worry if this fails)") print("- Unmounting Root Volume (Don't worry if this fails)")
self.elevated(["diskutil", "unmount", self.root_mount_path], stdout=subprocess.PIPE).stdout.decode().strip().encode() self.elevated(["diskutil", "unmount", self.root_mount_path], stdout=subprocess.PIPE).stdout.decode().strip().encode()
@@ -342,43 +339,39 @@ class PatchSysVolume:
print("- Download failed, please verify the below link works:") print("- Download failed, please verify the below link works:")
print(f"{self.constants.url_apple_binaries}{self.constants.payload_version}") print(f"{self.constants.url_apple_binaries}{self.constants.payload_version}")
def detect_gpus(self): def detect_gpus(self):
igpu_vendor, igpu_device, igpu_acpi = DeviceProbe.pci_probe().gpu_probe("IGPU") dgpu = self.constants.computer.dgpu
dgpu_vendor, dgpu_device, dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0") igpu = self.constants.computer.igpu
if dgpu_vendor: if dgpu:
print(f"- Found GFX0: {dgpu_vendor}:{dgpu_device}") print(f"- Found GFX0: {Utilities.friendly_hex(dgpu.vendor_id)}:{Utilities.friendly_hex(dgpu.device_id)}")
if dgpu_vendor == self.constants.pci_nvidia: if dgpu.arch in [device_probe.NVIDIA.Archs.Tesla, device_probe.NVIDIA.Archs.Fermi]:
if dgpu_device in PCIIDArray.nvidia_ids().tesla_ids or dgpu_device in PCIIDArray.nvidia_ids().fermi_ids: if self.constants.detected_os > self.constants.catalina:
if self.constants.detected_os > self.constants.catalina: self.nvidia_legacy = True
self.nvidia_legacy = True self.amfi_must_disable = True
self.amfi_must_disable = True elif dgpu.arch == device_probe.AMD.Archs.TeraScale_1:
elif dgpu_vendor == self.constants.pci_amd_ati: if self.constants.detected_os > self.constants.catalina:
if dgpu_device in PCIIDArray.amd_ids().terascale_1_ids: self.amd_ts1 = True
if self.constants.detected_os > self.constants.catalina: self.amfi_must_disable = True
self.amd_ts1 = True # TODO: Enable TS2 support
self.amfi_must_disable = True elif dgpu.arch == device_probe.AMD.Archs.TeraScale_2:
# TODO: Enable TS2 support # Requires manual permission from user to avoid medical issues
elif dgpu_device in PCIIDArray.amd_ids().terascale_2_ids: if self.constants.detected_os > self.constants.catalina and self.constants.terascale_2_patch is True:
# Requires manual permission from user to avoid medical issues self.amd_ts2 = True
if self.constants.detected_os > self.constants.catalina and self.constants.terscale_2_patch is True: self.amfi_must_disable = True
self.amd_ts2 = True if igpu and igpu.class_code != 0xFFFFFF:
self.amfi_must_disable = True print(f"- Found IGPU: {Utilities.friendly_hex(igpu.vendor_id)}:{Utilities.friendly_hex(igpu.device_id)}")
if igpu_vendor: if igpu.arch == device_probe.Intel.Archs.Iron_Lake:
print(f"- Found IGPU: {igpu_vendor}:{igpu_device}") if self.constants.detected_os > self.constants.catalina:
if igpu_vendor == self.constants.pci_intel: self.iron_gpu = True
if igpu_device in PCIIDArray.intel_ids().iron_ids: self.amfi_must_disable = True
if self.constants.detected_os > self.constants.catalina: elif igpu.arch == device_probe.Intel.Archs.Sandy_Bridge:
self.iron_gpu = True if self.constants.detected_os > self.constants.catalina:
self.amfi_must_disable = True self.sandy_gpu = True
elif igpu_device in PCIIDArray.intel_ids().sandy_ids: self.amfi_must_disable = True
if self.constants.detected_os > self.constants.catalina: elif igpu.arch == device_probe.Intel.Archs.Ivy_Bridge:
self.sandy_gpu = True if self.constants.detected_os > self.constants.big_sur:
self.amfi_must_disable = True self.ivy_gpu = True
elif igpu_device in PCIIDArray.intel_ids().ivy_ids: elif isinstance(igpu, device_probe.NVIDIA):
if self.constants.detected_os > self.constants.big_sur:
self.ivy_gpu = True
elif igpu_vendor == self.constants.pci_nvidia:
if self.constants.detected_os > self.constants.catalina: if self.constants.detected_os > self.constants.catalina:
self.nvidia_legacy = True self.nvidia_legacy = True
self.amfi_must_disable = True self.amfi_must_disable = True
@@ -412,58 +405,46 @@ class PatchSysVolume:
if self.legacy_audio is True: if self.legacy_audio is True:
print("- Add legacy Audio Control") print("- Add legacy Audio Control")
if self.nvidia_legacy is False and \ self.no_patch = any(
self.amd_ts1 is False and \ [
self.amd_ts2 is False and \ self.nvidia_legacy,
self.iron_gpu is False and \ self.amd_ts1,
self.sandy_gpu is False and \ self.amd_ts2,
self.ivy_gpu is False and \ self.iron_gpu,
self.brightness_legacy is False and \ self.sandy_gpu,
self.legacy_audio is False: self.ivy_gpu,
self.no_patch = True self.brightness_legacy,
else: self.legacy_audio,
self.no_patch = False ]
)
def verify_patch_allowed(self): def verify_patch_allowed(self):
self.sip_enabled, self.sbm_enabled, self.amfi_enabled, self.fv_enabled = Utilities.patching_status() self.sip_enabled, self.sbm_enabled, self.amfi_enabled, self.fv_enabled = Utilities.patching_status()
if self.sip_enabled is True: if self.sip_enabled is True:
print("\nCannot patch!!! Please disable SIP!!!") print("\nCannot patch! Please disable System Integrity Protection (SIP).")
print("Disable SIP in Patcher Settings and Rebuild OpenCore") print("Disable SIP in Patcher Settings and Rebuild OpenCore\n")
print("Ensure the following bits are set for csr-active-config:\n") print("Ensure the following bits are set for csr-active-config:")
if self.constants.detected_os > self.constants.catalina: print("\n".join(self.constants.root_patch_sip_big_sur if self.constants.detected_os > self.constants.catalina else self.constants.root_patch_sip_mojave))
sip = self.constants.root_patch_sip_big_sur print("For Hackintoshes, please set csr-active-config to '030A0000' (0xA03)")
else:
sip = self.constants.root_patch_sip_mojave
print("\n".join(sip))
print("For Hackintoshes, please set csr-active-config to 030A0000 (0xA03)")
print("For non-OpenCore Macs, please run 'csrutil disable' and \n'csrutil authenticated-root disable' in RecoveryOS") print("For non-OpenCore Macs, please run 'csrutil disable' and \n'csrutil authenticated-root disable' in RecoveryOS")
if self.sbm_enabled is True: if self.sbm_enabled is True:
print("\nCannot patch!!! Please disable SecureBootModel!!!") print("\nCannot patch! Please disable Apple Secure Boot.")
print("Disable SecureBootModel in Patcher Settings and Rebuild OpenCore") print("Disable SecureBootModel in Patcher Settings and Rebuild OpenCore")
print("For Hackintoshes, set SecureBootModel to Disabled") print("For Hackintoshes, set SecureBootModel to Disabled")
if self.fv_enabled is True: if self.fv_enabled is True:
print("\nCannot patch!!! Please disable FileVault!!!") print("\nCannot patch! Please disable FileVault.")
print("Go to System Preferences -> Security and disable FileVault") print("Go to System Preferences -> Security and disable FileVault")
if self.amfi_enabled is True and self.amfi_must_disable is True: if self.amfi_enabled is True and self.amfi_must_disable is True:
print("\nCannot patch!!! Please disable AMFI!!!") print("\nCannot patch! Please disable AMFI.")
print("For Hackintoshes, please add amfi_get_out_of_my_way=1 to boot-args") print("For Hackintoshes, please add amfi_get_out_of_my_way=1 to boot-args")
if self.amfi_must_disable is True: if any([self.sip_enabled, self.sbm_enabled, self.fv_enabled, self.amfi_enabled if self.amfi_must_disable else False]):
if self.sip_enabled is True or \ return False
self.sbm_enabled is True or \
self.amfi_enabled is True or \
self.fv_enabled is True:
return False
else:
return True
else: else:
if self.sip_enabled is True or \ return True
self.sbm_enabled is True or \
self.fv_enabled is True:
return False
else:
return True
# Entry Function # Entry Function
def start_patch(self): def start_patch(self):
@@ -494,4 +475,3 @@ class PatchSysVolume:
if self.verify_patch_allowed() is True: if self.verify_patch_allowed() is True:
self.find_mount_root_vol(False) self.find_mount_root_vol(False)
input("\nPress [ENTER] to return to the main menu") input("\nPress [ENTER] to return to the main menu")
Resources/SysPatchArray.py
+4 -9
View File
@@ -129,8 +129,8 @@ AddAMDBrightness = [
"AMDLegacySupport.kext", "AMDLegacySupport.kext",
"AMDRadeonVADriver.bundle", "AMDRadeonVADriver.bundle",
"AMDRadeonVADriver2.bundle", "AMDRadeonVADriver2.bundle",
#"AMDRadeonX3000.kext", # "AMDRadeonX3000.kext",
#"AMDRadeonX3000GLDriver.bundle", # "AMDRadeonX3000GLDriver.bundle",
"AMDShared.bundle", "AMDShared.bundle",
"ATIRadeonX2000.kext", "ATIRadeonX2000.kext",
"ATIRadeonX2000GA.plugin", "ATIRadeonX2000GA.plugin",
@@ -169,14 +169,9 @@ AddIntelGen3Accel = [
"AppleIntelGraphicsShared.bundle", "AppleIntelGraphicsShared.bundle",
] ]
AddGeneralAccel = [ AddGeneralAccel = ["IOAcceleratorFamily2.kext", "IOSurface.kext"]
"IOAcceleratorFamily2.kext",
"IOSurface.kext"
]
DeleteBrightness = [ DeleteBrightness = ["AppleGraphicsControl.kext/Contents/PlugIns/AGDCBacklightControl.kext"]
"AppleGraphicsControl.kext/Contents/PlugIns/AGDCBacklightControl.kext"
]
AddBrightness = [ AddBrightness = [
"AppleBacklight.kext", "AppleBacklight.kext",
Resources/Utilities.py
+29 -16
View File
@@ -3,11 +3,13 @@ from __future__ import print_function
import os import os
import math import math
from pathlib import Path
import plistlib import plistlib
import subprocess import subprocess
from Resources import Constants from Resources import Constants
def hexswap(input_hex: str): def hexswap(input_hex: str):
hex_pairs = [input_hex[i : i + 2] for i in range(0, len(input_hex), 2)] hex_pairs = [input_hex[i : i + 2] for i in range(0, len(input_hex), 2)]
hex_rev = hex_pairs[::-1] hex_rev = hex_pairs[::-1]
@@ -25,12 +27,17 @@ def header(lines):
print("#" * total_length) print("#" * total_length)
RECOVERY_STATUS = None
def check_recovery(): def check_recovery():
root_partition_info = plistlib.loads(subprocess.run("diskutil info -plist /".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()) global RECOVERY_STATUS # pylint: disable=global-statement # We need to cache the result
if root_partition_info["VolumeName"] == "macOS Base System" and root_partition_info["FilesystemType"] == "apfs" and root_partition_info["BusProtocol"] == "Disk Image":
return True if RECOVERY_STATUS is None:
else: RECOVERY_STATUS = Path("/System/Library/BaseSystem").exists()
return False
return RECOVERY_STATUS
def get_disk_path(): def get_disk_path():
root_partition_info = plistlib.loads(subprocess.run("diskutil info -plist /".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()) root_partition_info = plistlib.loads(subprocess.run("diskutil info -plist /".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
@@ -38,39 +45,40 @@ def get_disk_path():
root_mount_path = root_mount_path[:-2] if root_mount_path.count("s") > 1 else root_mount_path root_mount_path = root_mount_path[:-2] if root_mount_path.count("s") > 1 else root_mount_path
return root_mount_path return root_mount_path
def csr_decode(csr_active_config): def csr_decode(csr_active_config):
if csr_active_config is None: if csr_active_config is None:
csr_active_config = b"\x00\x00\x00\x00" csr_active_config = b"\x00\x00\x00\x00"
sip_int = int.from_bytes(csr_active_config, byteorder="little") sip_int = int.from_bytes(csr_active_config, byteorder="little")
i = 0 i = 0
for current_sip_bit in Constants.Constants().csr_values: for current_sip_bit in Constants.Constants.csr_values:
if sip_int & (1 << i): if sip_int & (1 << i):
Constants.Constants().csr_values[current_sip_bit] = True Constants.Constants.csr_values[current_sip_bit] = True
i = i + 1 i = i + 1
# Can be adjusted to whatever OS needs patching # Can be adjusted to whatever OS needs patching
sip_needs_change = all( sip_needs_change = all(Constants.Constants.csr_values[i] for i in Constants.Constants.root_patch_sip_big_sur)
Constants.Constants().csr_values[i]
for i in Constants.Constants().root_patch_sip_big_sur
)
if sip_needs_change is True: if sip_needs_change is True:
return False return False
else: else:
return True return True
def friendly_hex(integer: int):
return "{:02X}".format(integer)
def patching_status(): def patching_status():
# Detection for Root Patching # Detection for Root Patching
sip_enabled = True # System Integrity Protection sip_enabled = True # System Integrity Protection
sbm_enabled = True # Secure Boot Status (SecureBootModel) sbm_enabled = True # Secure Boot Status (SecureBootModel)
amfi_enabled = True # Apple Mobile File Integrity amfi_enabled = True # Apple Mobile File Integrity
fv_enabled = True # FileVault fv_enabled = True # FileVault
amfi_1 = "amfi_get_out_of_my_way=0x1" amfi_1 = "amfi_get_out_of_my_way=0x1"
amfi_2 = "amfi_get_out_of_my_way=1" amfi_2 = "amfi_get_out_of_my_way=1"
if get_nvram("boot-args", decode=False) and (amfi_1 in get_nvram("boot-args", decode=False) or amfi_2 in get_nvram("boot-args", decode=False)): if get_nvram("boot-args", decode=False) and amfi_1 in get_nvram("boot-args", decode=False) or amfi_2 in get_nvram("boot-args", decode=False):
amfi_enabled = False amfi_enabled = False
if get_nvram("HardwareModel", "94B73556-2197-4702-82A8-3E1337DAFBFB", decode=False) not in Constants.Constants().sbm_values: if get_nvram("HardwareModel", "94B73556-2197-4702-82A8-3E1337DAFBFB", decode=False) not in Constants.Constants.sbm_values:
sbm_enabled = False sbm_enabled = False
if get_nvram("csr-active-config", decode=False) and csr_decode(get_nvram("csr-active-config", decode=False)) is False: if get_nvram("csr-active-config", decode=False) and csr_decode(get_nvram("csr-active-config", decode=False)) is False:
@@ -82,14 +90,18 @@ def patching_status():
return sip_enabled, sbm_enabled, amfi_enabled, fv_enabled return sip_enabled, sbm_enabled, amfi_enabled, fv_enabled
def cls(): def cls():
if not check_recovery(): if not check_recovery():
os.system("cls" if os.name == "nt" else "clear") os.system("cls" if os.name == "nt" else "clear")
else: else:
print("\u001Bc") print("\u001Bc")
def get_nvram(variable: str, uuid: str = None, *, decode: bool = False): def get_nvram(variable: str, uuid: str = None, *, decode: bool = False):
if uuid != None: # TODO: Properly fix for El Capitan, which does not print the XML representation even though we say to
if uuid is not None:
uuid += ":" uuid += ":"
else: else:
uuid = "" uuid = ""
@@ -102,6 +114,7 @@ def get_nvram(variable: str, uuid: str = None, *, decode: bool = False):
value = value.strip(b"\0").decode() value = value.strip(b"\0").decode()
return value return value
# def menu(title, prompt, menu_options, add_quit=True, auto_number=False, in_between=[], top_level=False): # def menu(title, prompt, menu_options, add_quit=True, auto_number=False, in_between=[], top_level=False):
# return_option = ["Q", "Quit", None] if top_level else ["B", "Back", None] # return_option = ["Q", "Quit", None] if top_level else ["B", "Back", None]
# if add_quit: menu_options.append(return_option) # if add_quit: menu_options.append(return_option)
Resources/device_probe.py
+57 -7
View File
@@ -8,6 +8,12 @@ from typing import Any, ClassVar, Optional, Type
from Resources import PCIIDArray, Utilities, ioreg from Resources import PCIIDArray, Utilities, ioreg
@dataclass
class CPU:
name: str
flags: list[str]
@dataclass @dataclass
class PCIDevice: class PCIDevice:
VENDOR_ID: ClassVar[int] # Default vendor id, for subclasses. VENDOR_ID: ClassVar[int] # Default vendor id, for subclasses.
@@ -70,6 +76,12 @@ class PCIDevice:
elif entry.entry_class == "IOACPIPlatformDevice": elif entry.entry_class == "IOACPIPlatformDevice":
paths.append(f"PciRoot({hex(int(entry.properties.get('_UID', 0)))})") paths.append(f"PciRoot({hex(int(entry.properties.get('_UID', 0)))})")
break break
elif entry.entry_class in ["IOPCI2PCIBridge", "IOPCIBridge", "AppleACPIPCI"]:
pass
else:
# There's something in between that's not PCI! Abort
paths = []
break
entry = entry.parent entry = entry.parent
self.pci_path = "/".join(reversed(paths)) self.pci_path = "/".join(reversed(paths))
@@ -97,6 +109,19 @@ class WirelessCard(PCIDevice):
raise NotImplementedError raise NotImplementedError
@dataclass
class NVMeController(PCIDevice):
CLASS_CODE: ClassVar[int] = 0x010802
aspm: Optional[int] = None
parent_aspm: Optional[int] = None
@dataclass
class SATAController(PCIDevice):
CLASS_CODE: ClassVar[int] = 0x010601
@dataclass @dataclass
class NVIDIA(GPU): class NVIDIA(GPU):
VENDOR_ID: ClassVar[int] = 0x10DE VENDOR_ID: ClassVar[int] = 0x10DE
@@ -225,12 +250,6 @@ class Atheros(WirelessCard):
self.chipset = Atheros.Chipsets.Unknown self.chipset = Atheros.Chipsets.Unknown
@dataclass
class CPU:
name: str
flags: list[str]
@dataclass @dataclass
class Computer: class Computer:
real_model: Optional[str] = None real_model: Optional[str] = None
@@ -240,6 +259,7 @@ class Computer:
gpus: list[GPU] = field(default_factory=list) gpus: list[GPU] = field(default_factory=list)
igpu: Optional[GPU] = None # Shortcut for IGPU igpu: Optional[GPU] = None # Shortcut for IGPU
dgpu: Optional[GPU] = None # Shortcut for GFX0 dgpu: Optional[GPU] = None # Shortcut for GFX0
storage: list[PCIDevice] = field(default_factory=list)
wifi: Optional[WirelessCard] = None wifi: Optional[WirelessCard] = None
cpu: Optional[CPU] = None cpu: Optional[CPU] = None
oclp_version: Optional[str] = None oclp_version: Optional[str] = None
@@ -253,6 +273,7 @@ class Computer:
computer.dgpu_probe() computer.dgpu_probe()
computer.igpu_probe() computer.igpu_probe()
computer.wifi_probe() computer.wifi_probe()
computer.storage_probe()
computer.smbios_probe() computer.smbios_probe()
computer.cpu_probe() computer.cpu_probe()
return computer return computer
@@ -303,11 +324,40 @@ class Computer:
# return # return
for device in devices: for device in devices:
vendor: Type[WirelessCard] = PCIDevice.from_ioregistry(device).vendor_detect(inherits=WirelessCard) # type: ignore vendor: Type[WirelessCard] = PCIDevice.from_ioregistry(device, anti_spoof=True).vendor_detect(inherits=WirelessCard) # type: ignore
if vendor: if vendor:
self.wifi = vendor.from_ioregistry(device, anti_spoof=True) # type: ignore self.wifi = vendor.from_ioregistry(device, anti_spoof=True) # type: ignore
break break
def storage_probe(self):
sata_controllers = self.ioregistry.find(entry_class="IOPCIDevice", property=("class-code", binascii.a2b_hex(Utilities.hexswap(hex(SATAController.CLASS_CODE)[2:].zfill(8)))))
nvme_controllers = itertools.chain.from_iterable(
[
# self.ioregistry.find(entry_class="IOPCIDevice", property=("class-code", binascii.a2b_hex(Utilities.hexswap(hex(NVMeController.CLASS_CODE)[2:].zfill(8))))),
self.ioregistry.find(entry_class="IOPCIDevice", children={"entry_class": "IONVMeController"}),
]
)
for device in sata_controllers:
self.storage.append(SATAController.from_ioregistry(device))
for device in nvme_controllers:
aspm = device.properties.get("pci-aspm-default", 0)
if isinstance(aspm, bytes):
aspm = int.from_bytes(aspm, byteorder="little")
if device.parent.parent.entry_class == "IOPCIDevice":
parent_aspm = device.parent.parent.properties.get("pci-aspm-default", 0)
if isinstance(parent_aspm, bytes):
parent_aspm = int.from_bytes(parent_aspm, byteorder="little")
else:
parent_aspm = None
controller = NVMeController.from_ioregistry(device)
controller.aspm = aspm
controller.parent_aspm = parent_aspm
if controller.vendor_id != 0x106B:
self.storage.append(controller)
def smbios_probe(self): def smbios_probe(self):
# Reported model # Reported model
entry = next(self.ioregistry.find(name="Root")).children[0] entry = next(self.ioregistry.find(name="Root")).children[0]
Resources/ioreg.py
+24 -16
View File
@@ -1,7 +1,9 @@
from __future__ import annotations
from dataclasses import dataclass from dataclasses import dataclass
import plistlib import plistlib
import subprocess import subprocess
from typing import Any from typing import Generator
@dataclass @dataclass
@@ -10,8 +12,8 @@ class IORegistryEntry:
entry_class: str entry_class: str
properties: dict properties: dict
location: str location: str
children: list children: list[IORegistryEntry]
parent: Any parent: IORegistryEntry
class IOReg: class IOReg:
@@ -49,25 +51,31 @@ class IOReg:
return converted return converted
def find(self, root=None, **kwargs): def parse_conditions(self, entry: IORegistryEntry, **kwargs):
conditions = []
if "parent" in kwargs:
conditions.append(self.parse_conditions(entry.parent, **kwargs["parent"]))
if "children" in kwargs:
conditions.append(any(self.parse_conditions(i, **kwargs["children"]) for i in entry.children))
if "name" in kwargs:
conditions.append(kwargs["name"] == entry.name)
if "entry_class" in kwargs:
conditions.append(kwargs["entry_class"] == entry.entry_class)
if "key" in kwargs:
conditions.append(kwargs["key"] in entry.properties)
if "property" in kwargs:
conditions.append(kwargs["property"][0] in entry.properties and entry.properties[kwargs["property"][0]] == kwargs["property"][1])
return all(conditions)
def find(self, root: IORegistryEntry = None, **kwargs) -> Generator[IORegistryEntry, None, None]:
if not root: if not root:
root = self.tree root = self.tree
if not kwargs: if not kwargs:
return return
conditions = [] if self.parse_conditions(root, **kwargs):
if "name" in kwargs:
conditions.append(kwargs["name"] == root.name)
if "entry_class" in kwargs:
conditions.append(kwargs["entry_class"] == root.entry_class)
if "key" in kwargs:
conditions.append(kwargs["key"] in root.properties)
if "property" in kwargs:
conditions.append(kwargs["property"][0] in root.properties and root.properties[kwargs["property"][0]] == kwargs["property"][1])
if all(conditions):
yield root yield root
for i in root.children: for i in root.children: